核心概念
要理解 Python 如何与 ModSecurity 交互：
（图片来源网络，侵删）
- ModSecurity 是一个 Web 应用防火墙：它通常作为反向代理（如 Nginx、Apache）的一个模块运行，在请求到达你的应用程序之前对其进行检查。
- Python 绑定：这意味着我们不是直接在 Python 代码中运行 ModSecurity 的所有规则，而是通过一个 Python 库来与 ModSecurity 的核心引擎（
libmodsecurity）进行通信。 - 两种主要模式：
- 嵌入式模式：在你的 Python 应用程序（如 Flask/Django）中直接集成 ModSecurity，这种模式灵活性高，但需要你的应用能够处理 ModSecurity 的处理流程（如获取请求、处理、再放行）。
- 独立模式：将 ModSecurity 作为一个独立的守护进程运行，你的 Python 应用通过进程间通信（如 Unix Socket）与它交互，这种模式解耦了应用和 WAF，更稳定，但配置稍复杂。
使用 ModSecurity 库（推荐，最简单）
这是最直接、最易于使用的方法，它是一个 Python 封装器，直接调用 libmodsecurity 的 C 库，非常适合在 Python 脚本中进行快速测试、规则开发和集成。
安装依赖
你需要先安装 libmodsecurity 库。
在 Ubuntu/Debian 上：
sudo apt-get update sudo apt-get install libmodsecurity2
在 CentOS/RHEL/Fedora 上：
（图片来源网络，侵删）
sudo yum install mod_security # 或者使用 dnf sudo dnf install mod_security
在 macOS 上 (使用 Homebrew)：
brew install modsecurity
安装 Python 库
使用 pip 安装 ModSecurity 包。
pip install ModSecurity
编写 Python 代码
下面是一个完整的示例,展示如何创建 ModSecurity 上下文、加载规则、并处理一个模拟的 HTTP 请求。
# modsecurity_example.py
import ModSecurity
import time
# --- 1. 创建 ModSecurity 上下文 ---
# 这是 ModSecurity 的主控制器，用于管理所有操作
modsec = Mod.ModSecurity()
# --- 2. 创建事务 ---
# 每次请求/响应的检查都是一个“事务”
transaction = modsec.new_transaction()
# --- 3. 加载规则集 ---
# ModSecurity 的核心是规则集（如 CRS - Core Rule Set）
# 这里我们创建一个简单的自定义规则来演示
# 这个规则会拦截包含 "malicious" 字符串的请求体
rules = """
SecRule REQUEST_BODY "@contains malicious" "id:1001,phase:2,block,log,msg:'Detected malicious payload in request body.'"
"""
# 将规则加载到事务中
transaction.add_rules(rules)
print("已加载规则集.")
# --- 4. 模拟一个 HTTP 请求 ---
# 我们需要手动构建一个请求对象，并填充其各个部分
# 这是一个 POST 请求，请求体包含恶意内容
# 注意：请求行、头信息和请求体都需要用字节串(bytes)表示
request_headers = (
b"Host: example.com\r\n"
b"User-Agent: Python-ModSecurity-Test\r\n"
b"Content-Type: application/x-www-form-urlencoded\r\n"
)
request_body = b"username=test&password=123&data=This is a malicious script"
# 将请求信息填充到事务中
# 注意：ModSecurity v3 中，请求行、头、体是分开设置的
# 请求行: METHOD URI PROTOCOL
# POST /api/login HTTP/1.1
# transaction.process_connection("127.0.0.1", 12345) # 可选，用于连接信息
# transaction.process_uri("/api/login", "http://example.com/api/login", "HTTP/1.1")
# transaction.process_request_headers(request_headers)
# transaction.process_request_body(request_body)
# 更简单的方式是使用 process_uri 和 process_request_body
# (注意：不同版本的库API可能略有不同，以下是基于常见实践的写法)
# 对于这个简单例子，我们直接处理请求体
# 在 v3 中，通常需要更完整地构建请求
# 我们这里简化，直接处理请求体和URI
transaction.process_uri("/api/login", "http://example.com/api/login", "HTTP/1.1")
transaction.process_request_headers(request_headers)
transaction.process_request_body(request_body)
# --- 5. 执行检查并获取结果 ---
# 这是触发规则引擎执行的关键步骤
status = transaction.process_connection("127.0.0.1", 8080)
# status = transaction.process_uri(...) # 可能需要更完整的构建
# status = transaction.process_request_headers(...)
# status = transaction.process_request_body(...)
# --- 6. 分析结果 ---
# 检查事务的状态
# ModStatus 决定了请求的最终结果
# ModStatus.DISALLOW (2) 表示请求被阻止
# ModStatus.ALLOW (1) 表示请求被允许
if status == Mod.ModStatus.DISALLOW:
print("\n[!] 请求被 ModSecurity 阻止！")
print(f" 状态码: {transaction.status_code}")
print(f" 阻止原因: {transaction.interception_message}")
print(f" 规则ID: {transaction.rule_ids}") # 可能被多个规则拦截
else:
print("\n[+] 请求通过 ModSecurity 检查。")
# 打印日志（如果需要）
# print("\n--- 事务日志 ---")
# print(transaction.get_log())
# --- 7. 清理 ---
# 释放事务资源
transaction.processing_complete()
如何运行：
（图片来源网络，侵删）
- 将上述代码保存为
modsecurity_example.py。 - 确保你已经安装了
libmodsecurity和ModSecurityPython 包。 - 运行脚本：
python modsecurity_example.py
预期输出：
已加载规则集.
[!] 请求被 ModSecurity 阻止！
状态码: 403
阻止原因: Detected malicious payload in request body.
规则ID: [1001]使用 modsecurity-standalone 和 Unix Socket（生产环境推荐）
这种方法更接近生产环境的部署方式,ModSecurity 作为一个独立的守护进程运行，你的 Python 应用通过一个 Unix Socket 与它通信，这提供了更好的性能和隔离性。
安装 modsecurity-standalone
这个工具通常包含在 libmodsecurity 的源码包中，或者由发行版提供。
- 在 Ubuntu/Debian 上：
sudo apt-get install modsecurity-standalone - 从源码编译： 你可以从 ModSecurity 的 GitHub 仓库获取源码并编译安装。
配置 modsecurity-standalone
创建一个配置文件,/etc/modsecurity/modsecurity_standalone.conf：
# modsecurity_standalone.conf # 监听 Unix Socket Listen unix:/tmp/modsec.sock # 启用 ModSecurity SecRuleEngine On # 加载你的规则集，这里用一个简单的规则作为示例 # 在生产环境中，你应该加载完整的 CRS (Core Rule Set) Include /path/to/your/rules/custom_rules.conf # 日志配置 SecAuditEngine RelevantOnly SecAuditLog /var/log/modsecurity/audit.log SecAuditLogFormat JSON
创建你的规则文件 /path/to/your/rules/custom_rules.conf：
# custom_rules.conf
SecRule REQUEST_BODY "@contains malicious" \
"id:1001,phase:2,block,log,msg:'Detected malicious payload in request body.'"
启动 modsecurity-standalone 守护进程
# 确保目录和socket文件存在 sudo mkdir -p /var/log/modsecurity sudo touch /var/log/modsecurity/audit.log sudo chown -R www-data:www-data /var/log/modsecurity # 根据你的用户调整 # 启动守护进程 # 使用 -c 指定配置文件 # 使用 -f 让它在前台运行，方便调试（生产环境建议用 systemd 管理） sudo modsecurity-standalone -f -c /etc/modsecurity/modsecurity_standalone.conf
守护进程应该在监听 /tmp/modsec.sock。
编写 Python 客户端代码
Python 端通过标准的 Unix Socket 通信，ModSecurity 使用一个简单的文本协议。
# modsec_standalone_client.py
import socket
import json
def check_request_with_modsec(sock_path, request_data):
"""
通过 Unix Socket 与 modsecurity-standalone 通信
:param sock_path: Unix Socket 文件路径
:param request_data: 要检查的请求数据（字符串格式）
:return: (status, response_message)
"""
try:
# 1. 创建 Unix Socket 客户端
client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
client.connect(sock_path)
# 2. 发送请求数据
# 协议要求以 "POST / HTTP/1.1\r\n" 开头，后面跟着完整的请求
# 然后以一个空行结束请求头
# 最后跟着请求体
# 注意：这里为了简单，直接发送了完整的字符串
# 在实际应用中，你可能需要分块发送或构建更规范的请求
full_request = f"POST / HTTP/1.1\r\nHost: localhost\r\nContent-Length: {len(request_data)}\r\n\r\n{request_data}"
client.sendall(full_request.encode('utf-8'))
# 3. 接收响应
# 响应通常是 JSON 格式的日志
response = b""
while True:
chunk = client.recv(4096)
if not chunk:
break
response += chunk
client.close()
# 4. 解析响应
# 响应体是 JSON，我们需要解析它
response_str = response.decode('utf-8').strip()
# 响应可能包含 HTTP 头和 JSON 体，我们只关心 JSON 体
# 一个简单的分割方式（不完美，但适用于此场景）
try:
json_start = response_str.find('{')
if json_start != -1:
json_data = json.loads(response_str[json_start:])
# 检查是否有匹配的规则
if 'matches' in json_data and json_data['matches']:
return (2, f"Blocked by rule: {json_data['matches'][0]['message']}")
else:
return (1, "Request allowed")
else:
return (1, "Request allowed (no JSON response)")
except json.JSONDecodeError:
print("Failed to decode JSON response:", response_str)
return (1, "Request allowed (error in parsing)")
except FileNotFoundError:
return (-1, "ModSecurity socket not found. Is the daemon running?")
except Exception as e:
return (-1, f"An error occurred: {e}")
# --- 测试 ---
if __name__ == "__main__":
socket_path = "/tmp/modsec.sock"
# 测试一个干净的请求
print("--- 测试干净请求 ---")
clean_request = "username=admin&password=secret"
status, msg = check_request_with_modsec(socket_path, clean_request)
if status == 1:
print("[+] 请求通过:", msg)
else:
print("[!] 请求被阻止:", msg)
# 测试一个包含恶意内容的请求
print("\n--- 测试恶意请求 ---")
malicious_request = "username=admin&password=secret&script=<script>alert('xss')</script>&data=malicious"
status, msg = check_request_with_modsec(socket_path, malicious_request)
if status == 1:
print("[+] 请求通过:", msg)
else:
print("[!] 请求被阻止:", msg)
如何运行：
- 确保
modsecurity-standalone守护进程正在运行。 - 将客户端代码保存为
modsec_standalone_client.py。 - 运行客户端脚本：
python modsec_standalone_client.py
预期输出：
--- 测试干净请求 ---
[+] 请求通过: Request allowed
--- 测试恶意请求 ---
[!] 请求被阻止: Blocked by rule: Detected malicious payload in request body.总结与选择
| 特性 | ModSecurity Python 库 |
modsecurity-standalone + Socket |
|---|---|---|
| 易用性 | 非常高，API 直观，适合快速开发和测试。 | 中等，需要额外配置守护进程和通信。 |
| 性能 | 较低，因为每次请求都涉及 Python 和 C 库的交互。 | 较高，守护进程独立运行，通信高效，适合高并发。 |
| 耦合度 | 高，ModSecurity 逻辑与应用代码紧密耦合。 | 低，应用和 WAF 完全解耦，易于维护和扩展。 |
| 适用场景 | - 学习 ModSecurity - 开发和测试自定义规则 - 小型项目快速集成 |
- 生产环境 - 微服务架构 - 需要高性能和高可用性的应用 |
建议：
- 如果你是初学者，或者只是想快速验证一个 ModSecurity 规则，请使用方法一 (
ModSecurity库)，它最简单直接。 - 如果你正在构建一个生产系统，或者你的 Python 应用需要处理大量流量，强烈推荐方法二，它更健壮、性能更好，是业界标准的实践方式。
