PY-RASP 项目深度拆解
AI 原生应用运行时防护
PY-RASP 项目深度拆解
项目地址:https://github.com/ez-lbz/PY-RASP
随着 AI 应用的兴起,Python 作为 AI 应用常用语言,正在逐渐取代 Java 的地位,然而目前没有什么开源的 Python rasp 项目,总感觉缺了点什么。于是我出于学习的目的,做了 PY-RASP 这个 demo 级别的项目。
Python 生态里做 RASP 一直有个现实问题。想拦住危险动作,最直接的办法是把 open、subprocess、socket、eval 这一类系统级入口全部接管。可一旦接管范围太大,业务代码和框架代码会一起被影响,正常逻辑也可能被拖下水。这个项目最有意思的地方,不在于它 hook 了多少 API,而在于它试图回答另一个更具体的问题:怎样在 Python 进程里只对“当前请求”启用防护,同时尽量不破坏请求之外的执行路径。
PY-RASP 不是一个成熟的生产级安全产品,更像一个相当完整的原型。代码规模不大,但结构完整,入口层、策略层、请求上下文、Hook 注册、拦截判定、日志记录、框架适配、示例应用和测试都已经串起来了。
本文就按这条链路展开,不做泛泛介绍,直接从入口开始拆解。
RASP 入口
先看 py_rasp/__init__.py。
from .core import RASP, install
from .policy import RASPPolicy
__all__ = ['RASP', 'RASPPolicy', 'install']对外暴露只有三个符号,RASP、RASPPolicy 和 install,真正的总入口在 py_rasp/core.py。
from __future__ import annotations
from typing import Any
from .frameworks import django_middleware_factory, patch_fastapi_app, patch_flask_app
from .hooks import HookManager
from .policy import RASPPolicy
from .state import set_active_tracer
from .tracer import RequestTracer
class RASP:
def __init__(self, policy: RASPPolicy | None=None) -> None:
self.policy = policy or RASPPolicy()
self.tracer = RequestTracer()
self.hooks = HookManager(policy=self.policy, tracer=self.tracer)
def install(self) -> 'RASP':
self.hooks.install()
set_active_tracer(self.tracer)
return self
def patch_flask(self, app: Any) -> 'RASP':
self.install()
patch_flask_app(app, self.tracer)
return self
def patch_fastapi(self, app: Any) -> 'RASP':
self.install()
patch_fastapi_app(app, self.tracer)
return self
def django_middleware(self):
self.install()
return django_middleware_factory(self.tracer)
def install(policy: RASPPolicy | None=None) -> RASP:
return RASP(policy=policy).install()这一层做的事情非常单纯。第一步构造 RequestTracer 和 HookManager。第二步在 install() 里执行全局 Hook。第三步针对 Flask、FastAPI、Django 做框架接入。也就是说,这个项目的核心思路并不是“每个框架单独实现一套安全能力”,而是“先把系统级拦截能力装进进程,再让不同框架负责提供请求上下文”。
这是一种很典型的分层方式。框架层负责回答“现在是不是一次 Web 请求”。Hook 层负责回答“当前代码触发了什么敏感动作”。策略层负责回答“这个动作该不该拦”。日志层负责回答“拦截以后怎样留痕”。
RASPPolicy 规则底座
py_rasp/policy.py 里这段代码是整个项目的规则底座。
from __future__ import annotations
from dataclasses import dataclass, field
import os
@dataclass(slots=True)
class RASPPolicy:
block_command: bool = True
block_network: bool = True
block_file_read: bool = True
block_file_write: bool = True
block_code_execution: bool = True
block_archive_extract: bool = True
block_native_load: bool = True
block_sql_injection: bool = True
project_root: str = field(default_factory=lambda: os.path.abspath(os.getcwd()))
allowed_file_roots: tuple[str, ...] = field(default_factory=tuple)
protected_sql_apis: tuple[str, ...] = field(default_factory=lambda: ('sqlite3.Connection.execute', 'sqlite3.Cursor.execute', 'pymysql.Cursor.execute', 'MySQLdb.Cursor.execute', 'psycopg2.Cursor.execute', 'psycopg.Cursor.execute'))
command_allowlist: tuple[str, ...] = field(default_factory=tuple)
network_allowlist: tuple[str, ...] = field(default_factory=tuple)
file_allow_prefixes: tuple[str, ...] = field(default_factory=tuple)
file_write_allow_prefixes: tuple[str, ...] = field(default_factory=tuple)
log_trace_events: bool = True
log_file_path: str = field(default_factory=lambda: os.path.abspath('py_rasp_mock.log'))
def is_command_allowed(self, command: str) -> bool:
return any((command.startswith(prefix) for prefix in self.command_allowlist))
def is_network_allowed(self, target: str) -> bool:
return any((target.startswith(prefix) for prefix in self.network_allowlist))
@staticmethod
def _normalized_path(path: str) -> str:
return os.path.normcase(os.path.abspath(path))
def _is_within_project_root(self, path: str) -> bool:
normalized_root = self._normalized_path(self.project_root)
normalized_path = self._normalized_path(path)
try:
return os.path.commonpath([normalized_root, normalized_path]) == normalized_root
except ValueError:
return False
def _is_within_allowed_roots(self, path: str) -> bool:
if not self.allowed_file_roots:
return self._is_within_project_root(path)
normalized_path = self._normalized_path(path)
for root in self.allowed_file_roots:
normalized_root = self._normalized_path(root)
try:
if os.path.commonpath([normalized_root, normalized_path]) == normalized_root:
return True
except ValueError:
continue
return False
def is_file_allowed(self, path: str) -> bool:
if self._is_within_allowed_roots(path):
return True
normalized_path = self._normalized_path(path)
return any((normalized_path.startswith(self._normalized_path(prefix)) for prefix in self.file_allow_prefixes))
def is_file_write_allowed(self, path: str) -> bool:
if self._is_within_allowed_roots(path):
return True
normalized_path = self._normalized_path(path)
return any((normalized_path.startswith(self._normalized_path(prefix)) for prefix in self.file_write_allow_prefixes))这里的防御规则比较粗糙,因为项目设计的初衷是用于断网比赛,宁可杀错不可放过了。
文件访问策略默认以 project_root 为边界,或者显式指定 allowed_file_roots。这意味着它不是在做细粒度文件权限模型,而是在做一个很直接的目录边界模型。这个模型的优点是实现简单,效果可预期。缺点也很明显,只要业务本来就需要跨目录读写,策略就会变得比较粗。
SQL 部分同样有一个非常实用但并不复杂的设计。protected_sql_apis 明确指定了哪些数据库 API 会进入拦截判定。这里主要防护的是 SQLITE,MYSQL,POSTGRESQL 的直接查询 API。
请求上下文的追踪
RASP 最容易出问题的地方,往往不是 hook 本身,而是作用范围。如果把 open、socket.connect、subprocess.run 一类函数全局替换后没有任何上下文判断,整个 Python 进程都会被一锅端。定时任务、后台线程、日志组件、框架内部行为都有可能出问题。
这个项目给出的解法,是在框架层建立请求作用域,然后让所有 hook 只在请求线程内生效。
py_rasp/frameworks.py 的核心代码如下。
from __future__ import annotations
import sys
import threading
from collections.abc import Mapping
from typing import Any, Awaitable, Callable
from .context import enter_request_scope, exit_request_scope
from .state import get_active_tracer
from .tracer import RequestTracer
def _request_metadata(request: Any) -> dict[str, Any]:
client = getattr(request, 'client', None)
remote = getattr(request, 'remote_addr', None)
if client:
remote = getattr(client, 'host', remote)
return {'remote_addr': remote}
def _flatten_user_values(value: Any) -> list[str]:
values: list[str] = []
if value is None:
return values
if isinstance(value, (str, int, float, bool)):
text = str(value).strip()
if text:
values.append(text)
return values
if isinstance(value, Mapping):
for item in value.values():
values.extend(_flatten_user_values(item))
return values
if isinstance(value, (list, tuple, set)):
for item in value:
values.extend(_flatten_user_values(item))
return values
return values
def _extract_request_inputs(framework: str, request: Any) -> tuple[str, ...]:
values: list[str] = []
try:
if framework == 'flask':
values.extend(_flatten_user_values(request.args.to_dict(flat=False)))
values.extend(_flatten_user_values(request.form.to_dict(flat=False)))
values.extend(_flatten_user_values(getattr(request, 'view_args', {}) or {}))
values.extend(_flatten_user_values(request.get_json(silent=True)))
elif framework == 'fastapi':
values.extend(_flatten_user_values(dict(request.query_params)))
elif framework == 'django':
values.extend(_flatten_user_values(request.GET.dict()))
try:
values.extend(_flatten_user_values(request.POST.dict()))
except Exception:
pass
except Exception:
pass
deduped: list[str] = []
seen: set[str] = set()
for item in values:
if item not in seen:
seen.add(item)
deduped.append(item)
return tuple(deduped)
def _start_request(tracer: RequestTracer, framework: str, method: str, path: str, metadata: dict[str, Any], request_inputs: tuple[str, ...]):
token = enter_request_scope(framework, method, path, metadata, request_inputs=request_inputs)
tracer.enable_for_current_thread()
sys.settrace(tracer.trace)
threading.settrace(tracer.trace)
return token
def _finish_request(tracer: RequestTracer, token: Any) -> None:
sys.settrace(None)
tracer.disable_for_current_thread()
exit_request_scope(token)
def patch_flask_app(app: Any, tracer: RequestTracer) -> None:
try:
from flask import request
except ImportError:
return
@app.before_request
def _py_rasp_before_request():
token = _start_request(tracer=tracer, framework='flask', method=request.method, path=request.path, metadata=_request_metadata(request), request_inputs=_extract_request_inputs('flask', request))
request.environ['py_rasp_request_token'] = token
@app.after_request
def _py_rasp_after_request(response: Any):
token = request.environ.pop('py_rasp_request_token', None)
if token is not None:
_finish_request(tracer, token)
return response
@app.teardown_request
def _py_rasp_teardown_request(exc: BaseException | None):
token = request.environ.pop('py_rasp_request_token', None)
if token is not None:
_finish_request(tracer, token)
def patch_fastapi_app(app: Any, tracer: RequestTracer) -> None:
try:
from fastapi import Request
except ImportError:
return
@app.middleware('http')
async def _py_rasp_middleware(request: Request, call_next: Callable[[Request], Awaitable[Any]]):
token = _start_request(tracer=tracer, framework='fastapi', method=request.method, path=request.url.path, metadata=_request_metadata(request), request_inputs=_extract_request_inputs('fastapi', request))
try:
return await call_next(request)
finally:
_finish_request(tracer, token)
class DjangoRASPTracerMiddleware:
def __init__(self, get_response: Callable[[Any], Any], tracer: RequestTracer | None=None):
self.get_response = get_response
self.tracer = tracer or get_active_tracer()
def __call__(self, request: Any):
token = _start_request(tracer=self.tracer, framework='django', method=request.method, path=request.path, metadata=_request_metadata(request), request_inputs=_extract_request_inputs('django', request))
try:
return self.get_response(request)
finally:
_finish_request(self.tracer, token)
def django_middleware_factory(tracer: RequestTracer):
def _factory(get_response: Callable[[Any], Any]):
return DjangoRASPTracerMiddleware(get_response, tracer)
return _factory这段代码看起来像普通的框架 glue code,实际上它把整个项目最重要的上下文边界建立起来了。第一件事是抽取请求输入。SQL 注入拦截并不是凭空判断某条 SQL 像不像注入,而是先把请求里的参数收集出来,再去看这些值有没有直接出现在 SQL 文本里。这里用 _extract_request_inputs() 做了一个扁平化处理,把 query、form、json、path 参数统一压成字符串元组。这个实现不复杂,但足够支撑一个“来源在请求里”的判断基础。
第二件事是通过 enter_request_scope() 建立上下文,再用 tracer.enable_for_current_thread() 和 sys.settrace() 打开调用跟踪。也就是说,这个项目不只知道“现在在请求里”,还会记录请求线程的调用事件。
第三件事是请求结束时必须清理。Flask 同时用了 after_request 和 teardown_request,本质上是在防双保险,避免异常路径把上下文留在当前线程。这个细节虽然小,但非常必要。做运行时安全时,最怕的不是拦不住,而是状态泄漏。一次请求结束后若上下文残留,下一段无关代码可能被误判成请求内执行,那就不是保护,而是污染。
框架层把 token 建起来以后,真正存储上下文的地方在 py_rasp/context.py。
from __future__ import annotations
import contextvars
import threading
import time
from dataclasses import dataclass, field
from typing import Any
_request_scope: contextvars.ContextVar[RequestScope | None] = contextvars.ContextVar('py_rasp_request_scope', default=None)
@dataclass(slots=True)
class RequestScope:
framework: str
method: str
path: str
thread_id: int
started_at: float = field(default_factory=time.time)
metadata: dict[str, Any] = field(default_factory=dict)
request_inputs: tuple[str, ...] = field(default_factory=tuple)
trace_events: list[dict[str, Any]] = field(default_factory=list)
def add_event(self, action: str, payload: dict[str, Any]) -> None:
self.trace_events.append({'ts': time.time(), 'action': action, 'payload': payload})
def enter_request_scope(framework: str, method: str, path: str, metadata: dict[str, Any] | None=None, request_inputs: tuple[str, ...] | None=None) -> contextvars.Token:
scope = RequestScope(framework=framework, method=method, path=path, thread_id=threading.get_ident(), metadata=metadata or {}, request_inputs=request_inputs or ())
return _request_scope.set(scope)
def exit_request_scope(token: contextvars.Token) -> None:
_request_scope.reset(token)
def get_request_scope() -> RequestScope | None:
return _request_scope.get()
def is_request_thread() -> bool:
return get_request_scope() is not NoneRequestScope 里保存的信息不多,但都很有用。框架名、请求方法、路径、线程 ID、远端地址、请求输入、trace 事件。这些信息足够把一次拦截还原到某个请求上。
这里用了 contextvars.ContextVar。这在同步和异步混合环境里都比简单的线程局部变量更稳妥一些。尤其是 FastAPI 这种异步框架,如果只靠 threading.local(),很多场景下会很别扭。这里额外维护了 thread_id 和 tracer 的 enabled thread 集合,等于是把“上下文存在”与“当前线程启用 trace”两件事都保留下来。
py_rasp/tracer.py 则负责采集调用事件。
from __future__ import annotations
import inspect
import threading
from types import FrameType
from typing import Any
from .context import get_request_scope
class RequestTracer:
def __init__(self) -> None:
self._enabled_threads: set[int] = set()
self._lock = threading.Lock()
def enable_for_current_thread(self) -> None:
ident = threading.get_ident()
with self._lock:
self._enabled_threads.add(ident)
def disable_for_current_thread(self) -> None:
ident = threading.get_ident()
with self._lock:
self._enabled_threads.discard(ident)
def is_enabled(self) -> bool:
ident = threading.get_ident()
with self._lock:
return ident in self._enabled_threads
def trace(self, frame: FrameType, event: str, arg: Any):
if event != 'call' or not self.is_enabled():
return self.trace
scope = get_request_scope()
if scope is None:
return self.trace
code = frame.f_code
scope.add_event('trace.call', {'module': frame.f_globals.get('__name__', ''), 'function': code.co_name, 'filename': code.co_filename, 'line': frame.f_lineno})
return self.trace
@staticmethod
def caller_summary(skip: int=2, limit: int=4) -> list[str]:
stack = inspect.stack()[skip:skip + limit]
return [f'{info.function}@{info.filename}:{info.lineno}' for info in stack]这个 tracer 很朴素。它没有实现复杂的污点传播,也没有构建调用图,只是在请求线程开启时记录函数调用事件,并在拦截发生时通过 caller_summary() 给出一段简短栈摘要。
HookManager 实现
上下文建立好以后,接下来要看的就是系统级 hook 是怎么组织的。
py_rasp/hook_manager.py 的结构很关键。
from __future__ import annotations
import builtins
import ctypes
import importlib
import io
import os
import pathlib
import shutil
import socket
import sqlite3
import subprocess
import tarfile
import threading
import zipfile
from typing import Any
from .hook_mixins.archive import ArchiveHookMixin
from .hook_mixins.filesystem import FileSystemHookMixin
from .hook_mixins.processes import ProcessHookMixin
from .hook_mixins.runtime import RuntimeHookMixin
from .hook_mixins.sql import SQLHookMixin
from .hook_runtime import HookRuntime
from .logger import BlockEventLogger
from .policy import RASPPolicy
from .tracer import RequestTracer
_ORIGINAL_BUILTINS_OPEN = builtins.open
class HookManager(FileSystemHookMixin, ProcessHookMixin, ArchiveHookMixin, RuntimeHookMixin, SQLHookMixin):
def __init__(self, policy: RASPPolicy, tracer: RequestTracer) -> None:
self.policy = policy
self.tracer = tracer
self._installed = False
self._lock = threading.Lock()
self._originals: dict[tuple[Any, str], Any] = {}
logger = BlockEventLogger(policy.log_file_path, _ORIGINAL_BUILTINS_OPEN)
self.runtime = HookRuntime(policy=policy, tracer=tracer, logger=logger)
def install(self) -> None:
with self._lock:
if self._installed:
return
self._install_filesystem_hooks()
self._install_process_hooks()
self._install_archive_hooks()
self._install_runtime_hooks()
self._install_sql_hooks()
self._installed = True
def _patch(self, module: Any, name: str, value: Any) -> None:
self._originals[module, name] = getattr(module, name)
setattr(module, name, value)
def _install_filesystem_hooks(self) -> None:
self._patch(builtins, 'open', self._wrap_open(builtins.open))
self._patch(io, 'open', self._wrap_io_open(io.open))
self._patch(os, 'open', self._wrap_os_open(os.open))
self._patch(pathlib.Path, 'read_text', self._wrap_path_read_text(pathlib.Path.read_text))
self._patch(pathlib.Path, 'read_bytes', self._wrap_path_read_bytes(pathlib.Path.read_bytes))
self._patch(pathlib.Path, 'write_text', self._wrap_path_write_text(pathlib.Path.write_text))
self._patch(pathlib.Path, 'write_bytes', self._wrap_path_write_bytes(pathlib.Path.write_bytes))
self._patch(shutil, 'copyfile', self._wrap_shutil_copyfile(shutil.copyfile))
self._patch(shutil, 'copy', self._wrap_shutil_copy(shutil.copy))
self._patch(shutil, 'copy2', self._wrap_shutil_copy2(shutil.copy2))
self._patch(shutil, 'move', self._wrap_shutil_move(shutil.move))
def _install_process_hooks(self) -> None:
self._patch(os, 'system', self._wrap_os_system(os.system))
self._patch(os, 'popen', self._wrap_os_popen(os.popen))
self._patch_spawn_functions()
self._patch_exec_functions()
self._patch(subprocess, 'Popen', self._make_popen_class(subprocess.Popen))
self._patch(subprocess, 'run', self._wrap_run(subprocess.run))
self._patch(subprocess, 'call', self._wrap_call(subprocess.call))
self._patch(subprocess, 'check_call', self._wrap_check_call(subprocess.check_call))
self._patch(subprocess, 'check_output', self._wrap_check_output(subprocess.check_output))
self._patch(subprocess, 'getoutput', self._wrap_getoutput(subprocess.getoutput))
self._patch(subprocess, 'getstatusoutput', self._wrap_getstatusoutput(subprocess.getstatusoutput))
self._patch_low_level_process_sinks()
def _install_archive_hooks(self) -> None:
self._patch(shutil, 'unpack_archive', self._wrap_unpack_archive(shutil.unpack_archive))
self._patch(zipfile.ZipFile, 'extract', self._wrap_zip_extract(zipfile.ZipFile.extract))
self._patch(zipfile.ZipFile, 'extractall', self._wrap_zip_extractall(zipfile.ZipFile.extractall))
self._patch(tarfile.TarFile, 'extract', self._wrap_tar_extract(tarfile.TarFile.extract))
self._patch(tarfile.TarFile, 'extractall', self._wrap_tar_extractall(tarfile.TarFile.extractall))
def _install_runtime_hooks(self) -> None:
self._patch(builtins, 'eval', self._wrap_eval(builtins.eval))
self._patch(builtins, 'exec', self._wrap_exec(builtins.exec))
self._patch(builtins, '__import__', self._wrap_import(builtins.__import__))
self._patch(importlib, 'import_module', self._wrap_import_module(importlib.import_module))
self._patch(ctypes, 'CDLL', self._wrap_native_loader('ctypes.CDLL', ctypes.CDLL))
self._patch(ctypes, 'PyDLL', self._wrap_native_loader('ctypes.PyDLL', ctypes.PyDLL))
if hasattr(ctypes, 'WinDLL'):
self._patch(ctypes, 'WinDLL', self._wrap_native_loader('ctypes.WinDLL', ctypes.WinDLL))
if hasattr(ctypes, 'OleDLL'):
self._patch(ctypes, 'OleDLL', self._wrap_native_loader('ctypes.OleDLL', ctypes.OleDLL))
self._patch(socket.socket, 'connect', self._wrap_socket_connect(socket.socket.connect))
self._patch(socket.socket, 'connect_ex', self._wrap_socket_connect_ex(socket.socket.connect_ex))
self._patch(socket, 'create_connection', self._wrap_create_connection(socket.create_connection))
def _install_sql_hooks(self) -> None:
self._patch(sqlite3, 'connect', self._wrap_dbapi_connect('sqlite3', sqlite3.connect))
optional_connectors: tuple[tuple[str, str, str], ...] = (('pymysql', 'connect', 'pymysql'), ('MySQLdb', 'connect', 'MySQLdb'), ('psycopg2', 'connect', 'psycopg2'), ('psycopg', 'connect', 'psycopg'))
for module_name, connect_name, db_label in optional_connectors:
try:
module = importlib.import_module(module_name)
except ImportError:
continue
if hasattr(module, connect_name):
self._patch(module, connect_name, self._wrap_dbapi_connect(db_label, getattr(module, connect_name)))这个类用 mixin 把不同类别的 Hook 分开,结构上非常利于阅读。所有具体 wrapper 都分散在 hook_mixins 目录,HookManager 自己只负责安装顺序、一次性初始化和原始对象保存。
这里让 AI 给我寻找了一些非常底层的 API 去 Hook,从而防止 Pyjail 等绕过。
HookRuntime 统一裁决
如果说 HookManager 是武器库,那 HookRuntime 就是裁判层。所有 wrapper 真正决定“放行还是拦截”,都绕不过它。
py_rasp/hook_runtime.py 的核心如下。
from __future__ import annotations
import os
from typing import Any
from .context import get_request_scope, is_request_thread
from .logger import BlockEventLogger
from .policy import RASPPolicy
from .tracer import RequestTracer
SPAWN_FUNCTIONS: tuple[str, ...] = ('spawnl', 'spawnle', 'spawnlp', 'spawnlpe', 'spawnv', 'spawnve', 'spawnvp', 'spawnvpe', 'posix_spawn', 'posix_spawnp')
EXEC_FUNCTIONS: tuple[str, ...] = ('execl', 'execle', 'execlp', 'execlpe', 'execv', 'execve', 'execvp', 'execvpe')
def stringify_command(command: Any) -> str:
if isinstance(command, (list, tuple)):
return ' '.join((str(part) for part in command))
return str(command)
class HookRuntime:
def __init__(self, policy: RASPPolicy, tracer: RequestTracer, logger: BlockEventLogger) -> None:
self.policy = policy
self.tracer = tracer
self.logger = logger
def record_block(self, action: str, payload: dict[str, Any]) -> None:
scope = get_request_scope()
if scope and self.policy.log_trace_events:
payload = dict(payload)
payload['caller'] = self.tracer.caller_summary()
scope.add_event(action, payload)
self.logger.log(scope, action, payload)
def should_block_command(self, command: str) -> bool:
return self.policy.block_command and is_request_thread() and (not self.policy.is_command_allowed(command))
def should_block_network(self, target: str) -> bool:
return self.policy.block_network and is_request_thread() and (not self.policy.is_network_allowed(target))
def should_block_file_read(self, path: str, mode: str) -> bool:
is_read_mode = any((flag in mode for flag in ('r', '+'))) and 'w' not in mode and ('a' not in mode)
return self.policy.block_file_read and is_request_thread() and is_read_mode and (not self.policy.is_file_allowed(path))
def should_block_file_write(self, path: str, mode: str) -> bool:
is_write_mode = any((flag in mode for flag in ('w', 'a', '+', 'x')))
return self.policy.block_file_write and is_request_thread() and is_write_mode and (not self.policy.is_file_write_allowed(path))
def should_block_code_execution(self) -> bool:
return self.policy.block_code_execution and is_request_thread()
def should_block_native_load(self) -> bool:
return self.policy.block_native_load and is_request_thread()
def should_block_archive_extract(self) -> bool:
return self.policy.block_archive_extract and is_request_thread()
def should_block_sql(self, api: str, query: str, params: Any=None) -> bool:
if not (self.policy.block_sql_injection and is_request_thread()):
return False
if api not in self.policy.protected_sql_apis:
return False
query_text = (query or '').strip()
if not query_text:
return False
has_placeholders = '?' in query_text or '%s' in query_text or ':' in query_text
has_params = params is not None and params != () and (params != {})
if has_placeholders and has_params:
return False
scope = get_request_scope()
if scope is None or not scope.request_inputs:
return False
lowered_query = query_text.lower()
for value in scope.request_inputs:
normalized = str(value).strip()
if len(normalized) < 3:
continue
if normalized.lower() in lowered_query:
return True
return False
@staticmethod
def is_read_only_os_open(flags: int) -> bool:
write_flags = 0
for name in ('O_WRONLY', 'O_RDWR', 'O_APPEND', 'O_CREAT', 'O_TRUNC'):
write_flags |= getattr(os, name, 0)
return flags & write_flags == 0
@staticmethod
def is_write_os_open(flags: int) -> bool:
return not HookRuntime.is_read_only_os_open(flags)这段代码把项目的裁决逻辑完全统一了。所有 wrapper 在该不该拦这件事上都不会自己发挥,而是交给 HookRuntime。这样的好处很明显。拦截条件集中,日志统一,行为更容易测。
文件读写判定很直接。命令执行、网络访问、动态代码执行、本地库加载、归档解压这些 sink,只要发生在请求线程里,就按策略直接拦。SQL 是唯一稍微像“检测规则”的地方。作者没有用关键字黑名单,也没有做语法树分析,而是用了一个非常实用的启发式判断。
第一步,这个 API 必须在受保护列表里。第二步,如果 SQL 使用了占位符并且参数单独绑定,那就不拦。第三步,把请求里收集到的输入值逐个拿出来,看它们是否原样出现在 SQL 文本中。只要同时满足这些条件,就认为用户输入直接拼进了查询字符串,触发阻断。
通过 mock 来“假成功”
很多运行时防护在拦截时会直接抛异常。这么做简单,但副作用很重。上层业务如果没处理好异常,整个请求可能直接 500。这个项目选了另一条路,大量使用 mock 对象,让敏感调用看起来像成功执行,但实际没有触发真实副作用。
先看 py_rasp/hook_mixins/filesystem.py。
from __future__ import annotations
import os
import pathlib
from functools import wraps
from typing import Any, Callable
from ..context import is_request_thread
from ..mock import mock_open
class FileSystemHookMixin:
def _wrap_open(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(file: Any, mode: str='r', *args: Any, **kwargs: Any):
path = str(file)
if self.runtime.should_block_file_read(path, mode):
self.runtime.record_block('block.file_read', {'path': path, 'mode': mode})
return mock_open(mode)
if self.runtime.should_block_file_write(path, mode):
self.runtime.record_block('block.file_write', {'path': path, 'mode': mode})
return mock_open(mode)
return original(file, mode, *args, **kwargs)
return wrapper
def _wrap_io_open(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(file: Any, mode: str='r', *args: Any, **kwargs: Any):
path = str(file)
if self.runtime.should_block_file_read(path, mode):
self.runtime.record_block('block.file_read', {'api': 'io.open', 'path': path, 'mode': mode})
return mock_open(mode)
if self.runtime.should_block_file_write(path, mode):
self.runtime.record_block('block.file_write', {'api': 'io.open', 'path': path, 'mode': mode})
return mock_open(mode)
return original(file, mode, *args, **kwargs)
return wrapper
def _wrap_os_open(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(path: Any, flags: int, *args: Any, **kwargs: Any):
path_text = str(path)
if self.policy.block_file_read and is_request_thread() and self.runtime.is_read_only_os_open(flags) and (not self.policy.is_file_allowed(path_text)):
self.runtime.record_block('block.file_read', {'api': 'os.open', 'path': path_text, 'flags': flags})
return original(os.devnull, getattr(os, 'O_RDONLY', 0))
if self.policy.block_file_write and is_request_thread() and self.runtime.is_write_os_open(flags) and (not self.policy.is_file_write_allowed(path_text)):
self.runtime.record_block('block.file_write', {'api': 'os.open', 'path': path_text, 'flags': flags})
devnull_write = getattr(os, 'O_WRONLY', 1)
return original(os.devnull, devnull_write)
return original(path, flags, *args, **kwargs)
return wrapper
def _wrap_path_read_text(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(path_obj: pathlib.Path, *pargs: Any, **kwargs: Any):
path = str(path_obj)
if self.policy.block_file_read and is_request_thread() and (not self.policy.is_file_allowed(path)):
self.runtime.record_block('block.file_read', {'api': 'pathlib.Path.read_text', 'path': path})
return ''
return original(path_obj, *pargs, **kwargs)
return wrapper
def _wrap_path_read_bytes(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(path_obj: pathlib.Path, *pargs: Any, **kwargs: Any):
path = str(path_obj)
if self.policy.block_file_read and is_request_thread() and (not self.policy.is_file_allowed(path)):
self.runtime.record_block('block.file_read', {'api': 'pathlib.Path.read_bytes', 'path': path})
return b''
return original(path_obj, *pargs, **kwargs)
return wrapper
def _wrap_path_write_text(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(path_obj: pathlib.Path, data: str, *pargs: Any, **kwargs: Any):
path = str(path_obj)
if self.policy.block_file_write and is_request_thread() and (not self.policy.is_file_write_allowed(path)):
self.runtime.record_block('block.file_write', {'api': 'pathlib.Path.write_text', 'path': path})
return len(data)
return original(path_obj, data, *pargs, **kwargs)
return wrapper
def _wrap_path_write_bytes(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(path_obj: pathlib.Path, data: bytes, *pargs: Any, **kwargs: Any):
path = str(path_obj)
if self.policy.block_file_write and is_request_thread() and (not self.policy.is_file_write_allowed(path)):
self.runtime.record_block('block.file_write', {'api': 'pathlib.Path.write_bytes', 'path': path})
return len(data)
return original(path_obj, data, *pargs, **kwargs)
return wrapper这里的设计思路很一致。读文件时返回空内容,写文件时返回“好像写成功了”的长度或句柄。os.open 更进一步,直接把目标重定向到 os.devnull。这种办法能够在防护漏洞的同时防止服务 down 掉。
对命令执行的 Hook
命令执行显然是最常见的利用手段。项目在这部分投入明显最多。
py_rasp/hook_mixins/processes.py 里有一段很能说明问题。
from __future__ import annotations
import os
import subprocess
from functools import wraps
from typing import Any, Callable
from ..hook_runtime import EXEC_FUNCTIONS, SPAWN_FUNCTIONS, stringify_command
from ..mock import MockPopen, mock_completed_process, mock_open
class ProcessHookMixin:
def _patch_spawn_functions(self) -> None:
for name in SPAWN_FUNCTIONS:
if hasattr(os, name):
self._patch(os, name, self._wrap_os_spawn(name, getattr(os, name)))
def _patch_exec_functions(self) -> None:
for name in EXEC_FUNCTIONS:
if hasattr(os, name):
self._patch(os, name, self._wrap_os_exec(name, getattr(os, name)))
def _patch_low_level_process_sinks(self) -> None:
try:
import _winapi
self._patch(_winapi, 'CreateProcess', self._wrap_winapi_create_process(_winapi.CreateProcess))
except ImportError:
pass
try:
import _posixsubprocess
self._patch(_posixsubprocess, 'fork_exec', self._wrap_fork_exec(_posixsubprocess.fork_exec))
except ImportError:
pass
def _wrap_os_system(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(command: Any):
command_text = stringify_command(command)
if self.runtime.should_block_command(command_text):
self.runtime.record_block('block.command', {'api': 'os.system', 'command': command_text})
return 0
return original(command)
return wrapper
def _wrap_os_popen(self, original: Callable[..., Any]) -> Callable[..., Any]:
@wraps(original)
def wrapper(command: Any, mode: str='r', buffering: int=-1):
command_text = stringify_command(command)
if self.runtime.should_block_command(command_text):
self.runtime.record_block('block.command', {'api': 'os.popen', 'command': command_text, 'mode': mode})
return mock_open(mode)
return original(command, mode=mode, buffering=buffering)
return wrapper
def _make_popen_class(self, original: type[subprocess.Popen]) -> type[subprocess.Popen]:
manager = self
class PatchedPopen(original):
def __init__(self, args: Any, *pargs: Any, **kwargs: Any) -> None:
command_text = stringify_command(args)
if manager.runtime.should_block_command(command_text):
manager.runtime.record_block('block.command', {'api': 'subprocess.Popen', 'command': command_text})
self._py_rasp_mock = MockPopen(args, *pargs, **kwargs)
self.args = args
self.kwargs = kwargs
self.returncode = 0
self.pid = 0
self.stdin = None
self.stdout = None
self.stderr = None
self.universal_newlines = bool(kwargs.get('universal_newlines'))
if 'text' in kwargs:
self.text_mode = bool(kwargs.get('text'))
return
self._py_rasp_mock = None
super().__init__(args, *pargs, **kwargs)
def communicate(self, input: bytes | str | None=None, timeout: float | None=None):
if self._py_rasp_mock is not None:
return self._py_rasp_mock.communicate(input=input, timeout=timeout)
return super().communicate(input=input, timeout=timeout)
def wait(self, timeout: float | None=None) -> int:
if self._py_rasp_mock is not None:
return self._py_rasp_mock.wait(timeout=timeout)
return super().wait(timeout=timeout)
def poll(self) -> int | None:
if self._py_rasp_mock is not None:
return self._py_rasp_mock.poll()
return super().poll()
def kill(self) -> None:
if self._py_rasp_mock is not None:
self._py_rasp_mock.kill()
self.returncode = self._py_rasp_mock.returncode
return
super().kill()
def terminate(self) -> None:
if self._py_rasp_mock is not None:
self._py_rasp_mock.terminate()
self.returncode = self._py_rasp_mock.returncode
return
super().terminate()
def __enter__(self):
return self
def __exit__(self, exc_type, exc, tb) -> None:
if self._py_rasp_mock is not None:
return None
return super().__exit__(exc_type, exc, tb)
PatchedPopen.__name__ = original.__name__
PatchedPopen.__qualname__ = original.__qualname__
PatchedPopen.__module__ = original.__module__
return PatchedPopen一方面,只补 subprocess.run 不够,因为很多库直接调 Popen,甚至进一步落到平台相关底层实现。所以它对高层和底层都做了覆盖。另一方面, Popen 不是一个简单函数,很多代码会依赖它的对象行为。因此没有简单返回一个字典或空值,而是构造了一个继承自原始 Popen 的替身类,尽量维持 communicate、wait、poll、kill、terminate、上下文管理这些接口语义。这种处理虽然还谈不上完全兼容,但是我能想到的最好办法了。
测试里专门有一条用来确认 subprocess.Popen 仍然可继承,这就是在防止 wrapper 破坏面向对象接口契约。
def test_subprocess_popen_remains_inheritable(self) -> None:
class DerivedPopen(subprocess.Popen):
pass
self.assertTrue(issubclass(DerivedPopen, subprocess.Popen))这种测试很有价值,因为 monkey patch 最容易破坏的,恰恰是那些不在表面调用路径上的隐式约束。
对 SQL 注入的 Hook
SQL 部分是这个项目里最像“检测逻辑”的地方,它不是要识别所有注入,而是锁定“请求输入直接进入非参数化 SQL 文本”这个场景。
py_rasp/hook_mixins/sql.py 的核心代理如下。
from __future__ import annotations
from functools import wraps
from typing import Any, Callable
from ..mock import MockDBCursor
class SQLHookMixin:
def _wrap_dbapi_connect(self, db_label: str, original: Callable[..., Any]) -> Callable[..., Any]:
manager = self
class CursorProxy:
def __init__(self, cursor: Any) -> None:
self._cursor = cursor
def execute(self, query: str, parameters: Any=None):
api = f'{db_label}.Cursor.execute'
if manager.runtime.should_block_sql(api, query, parameters):
manager.runtime.record_block('block.sql_injection', {'api': api, 'query': str(query)[:300]})
return MockDBCursor()
if parameters is None:
self._cursor.execute(query)
else:
self._cursor.execute(query, parameters)
return self
def executemany(self, query: str, seq_of_parameters: Any):
api = f'{db_label}.Cursor.executemany'
if manager.runtime.should_block_sql(api, query, seq_of_parameters):
manager.runtime.record_block('block.sql_injection', {'api': api, 'query': str(query)[:300]})
return self
self._cursor.executemany(query, seq_of_parameters)
return self
def executescript(self, sql_script: str):
if not hasattr(self._cursor, 'executescript'):
raise AttributeError('executescript is not supported by this cursor')
api = f'{db_label}.Cursor.executescript'
if manager.runtime.should_block_sql(api, sql_script):
manager.runtime.record_block('block.sql_injection', {'api': api, 'query': str(sql_script)[:300]})
return self
self._cursor.executescript(sql_script)
return self
def __iter__(self):
return iter(self._cursor)
def __getattr__(self, name: str) -> Any:
return getattr(self._cursor, name)
class ConnectionProxy:
def __init__(self, connection: Any) -> None:
self._connection = connection
def cursor(self, *args: Any, **kwargs: Any):
return CursorProxy(self._connection.cursor(*args, **kwargs))
def execute(self, query: str, parameters: Any=None):
if not hasattr(self._connection, 'execute'):
raise AttributeError('execute is not supported by this connection')
api = f'{db_label}.Connection.execute'
if manager.runtime.should_block_sql(api, query, parameters):
manager.runtime.record_block('block.sql_injection', {'api': api, 'query': str(query)[:300]})
return MockDBCursor()
if parameters is None:
return CursorProxy(self._connection.execute(query))
return CursorProxy(self._connection.execute(query, parameters))
def executemany(self, query: str, seq_of_parameters: Any):
if not hasattr(self._connection, 'executemany'):
raise AttributeError('executemany is not supported by this connection')
api = f'{db_label}.Connection.executemany'
if manager.runtime.should_block_sql(api, query, seq_of_parameters):
manager.runtime.record_block('block.sql_injection', {'api': api, 'query': str(query)[:300]})
return MockDBCursor()
return CursorProxy(self._connection.executemany(query, seq_of_parameters))
def executescript(self, sql_script: str):
if not hasattr(self._connection, 'executescript'):
raise AttributeError('executescript is not supported by this connection')
api = f'{db_label}.Connection.executescript'
if manager.runtime.should_block_sql(api, sql_script):
manager.runtime.record_block('block.sql_injection', {'api': api, 'query': str(sql_script)[:300]})
return MockDBCursor()
return CursorProxy(self._connection.executescript(sql_script))
def __enter__(self):
self._connection.__enter__()
return self
def __exit__(self, exc_type, exc, tb):
return self._connection.__exit__(exc_type, exc, tb)
def __getattr__(self, name: str) -> Any:
return getattr(self._connection, name)
@wraps(original)
def wrapper(*pargs: Any, **kwargs: Any):
return ConnectionProxy(original(*pargs, **kwargs))
return wrapper做法很清晰。它不是去 patch 每个 execute 方法,而是直接从 connect() 开始,返回一个代理连接对象,再由代理连接对象派生代理游标。这样后面无论是 conn.execute() 还是 conn.cursor().execute(),都会落进统一判定逻辑。
这种实现的优点是入口少,扩展数据库驱动也方便。只要某个驱动有一个类似 connect 的工厂方法,就能把后续连接对象包起来。
它的局限也很明显。第一,它只能覆盖通过被 patch 的 connect() 新建出来的连接。已经存在的连接对象不受影响。第二,它没有做 ORM 级支持。SQLAlchemy、Django ORM、peewee 这类框架如果最后不是直接调用这些受保护 API,覆盖面就会打折扣。第三,它不理解 SQL 结构。只会做字符串级判断,所以复杂拼接、编码变形、二次包装、存储过程等场景很容易绕过去。
但对于这些局限,暂时选择妥协。
日志记录
在 AWD 竞赛中,“偷” payload 肯定是最重要的一个环节,因此日志记录必不可少。
from __future__ import annotations
import json
import os
import threading
import time
from typing import Any, Callable
from .context import RequestScope
_ORIGINAL_OS_OPEN = os.open
_ORIGINAL_OS_WRITE = os.write
_ORIGINAL_OS_CLOSE = os.close
class BlockEventLogger:
def __init__(self, log_file_path: str, open_fn: Callable[..., Any]) -> None:
self.log_file_path = os.path.abspath(log_file_path)
self._lock = threading.Lock()
def log(self, scope: RequestScope | None, action: str, payload: dict[str, Any]) -> None:
if scope is None:
return
event = {'ts': time.time(), 'action': action, 'framework': scope.framework, 'method': scope.method, 'path': scope.path, 'thread_id': scope.thread_id, 'metadata': scope.metadata, 'payload': payload}
directory = os.path.dirname(self.log_file_path)
if directory:
os.makedirs(directory, exist_ok=True)
line = (json.dumps(event, ensure_ascii=False) + '\n').encode('utf-8')
with self._lock:
flags = os.O_WRONLY | os.O_CREAT | os.O_APPEND
fd = _ORIGINAL_OS_OPEN(self.log_file_path, flags, 420)
try:
_ORIGINAL_OS_WRITE(fd, line)
finally:
_ORIGINAL_OS_CLOSE(fd)这里一个很细的处理值得单独说。日志写入没有走已经被 patch 的 open,而是直接使用原始 os.open、os.write、os.close。这个选择非常对。因为日志本身就是文件写操作。如果记录日志还去走已经被自己 hook 的文件系统接口,很容易递归触发拦截,最后把自己套进去。现在直接保留原始系统调用,就能避免这类自咬尾巴的问题。
mock 层实现
前面多次提到假成功,这一层都集中在 py_rasp/mock.py。
from __future__ import annotations
import io
import subprocess
from typing import Any
class MockPopen:
def __init__(self, *args: Any, **kwargs: Any) -> None:
self.args = args
self.kwargs = kwargs
self.returncode = 0
def communicate(self, input: bytes | str | None=None, timeout: float | None=None):
if self.kwargs.get('text') or self.kwargs.get('universal_newlines'):
return ('', '')
return (b'', b'')
def wait(self, timeout: float | None=None) -> int:
return self.returncode
def poll(self) -> int:
return self.returncode
def kill(self) -> None:
self.returncode = -9
def terminate(self) -> None:
self.returncode = -15
def mock_open(mode: str):
if 'b' in mode:
return io.BytesIO(b'')
return io.StringIO('')
class MockLibrary:
def __getattr__(self, name: str):
def _stub(*args: Any, **kwargs: Any) -> int:
return 0
return _stub
class MockSocket:
def __init__(self) -> None:
self.closed = False
def connect(self, address: Any) -> None:
return None
def connect_ex(self, address: Any) -> int:
return 0
def send(self, data: bytes | bytearray | memoryview, *args: Any, **kwargs: Any) -> int:
return len(data)
def sendall(self, data: bytes | bytearray | memoryview, *args: Any, **kwargs: Any) -> None:
return None
def recv(self, bufsize: int, *args: Any, **kwargs: Any) -> bytes:
return b''
def close(self) -> None:
self.closed = True
def fileno(self) -> int:
return -1
def shutdown(self, how: int) -> None:
return None
class MockDBCursor:
rowcount = 0
lastrowid = None
description = None
def execute(self, *args: Any, **kwargs: Any):
return self
def executemany(self, *args: Any, **kwargs: Any):
return self
def executescript(self, *args: Any, **kwargs: Any):
return self
def fetchone(self):
return None
def fetchall(self):
return []
def fetchmany(self, size: int | None=None):
return []
def close(self) -> None:
return None
def mock_completed_process(args: Any, text_mode: bool=False) -> subprocess.CompletedProcess[Any]:
if text_mode:
return subprocess.CompletedProcess(args=args, returncode=0, stdout='', stderr='')
return subprocess.CompletedProcess(args=args, returncode=0, stdout=b'', stderr=b'')这里没有复杂技巧,就是一堆最小行为兼容对象,把“阻断行为”和“接口不崩”这两个目标粘在了一起。
从安全视角看,这种 mock 并不保证所有上层逻辑都能正常跑,因为任何依赖真实系统状态的代码最终都会暴露差异。但是属于在 Python 场景下作者能想到的最好办法。
总结完整请求链路
到这里可以把整条链收束起来了。
应用启动时,RASP(policy).patch_flask(app)、patch_fastapi(app) 或 Django 的 install() 会先调用 HookManager.install(),把文件系统、进程、归档、运行时、SQL 相关 API 全部做全局替换。
请求进入框架后,中间件或钩子函数会调用 _start_request()。这一步把框架名、请求方法、路径、远端地址和请求参数写进 RequestScope,同时为当前线程打开 tracer。
请求处理函数执行过程中,只要代码走到 open、subprocess.run、socket.connect、ctypes.CDLL、sqlite3.connect(...).execute(...) 这一类入口,就会先进入对应 wrapper。
wrapper 不自己做复杂判断,而是把动作类型和参数交给 HookRuntime。HookRuntime 再结合当前策略和请求作用域,判断这次调用是不是该拦。
如果不该拦,调用落回原始实现。如果该拦,HookRuntime.record_block() 会把事件写进请求作用域和日志文件,然后 wrapper 返回空内容、空结果、mock 句柄、mock 连接或者假成功状态码。
请求结束时,框架适配层调用 _finish_request(),关闭 trace,清理线程启用状态,重置上下文变量,整个请求生命周期结束。
本文深度拆解 PY-RASP 项目,聚焦其基于请求作用域的精准防护机制、分层 Hook 架构与“假成功”拦截策略。
由 AI 根据全文自动生成,仅供参考,以原文为准