AI安全网关升温提示词防护权限校验内容审计成大模型标配

时间：2026-07-25 | 作者：深海捕梦者 | 阅读：0

2026 年，大模型应用正在经历一个关键的转折点——从“能生成内容”迈入“需要安全治理”的阶段。

回想一下，早些年企业接入大模型时，最看重的是什么？

无非是调用效果：模型回答准不准、响应快不快、能不能接入知识库。这些都是关乎“能不能用”的基础问题。

但如今，当大模型真正落地到客服、办公、研发、数据分析、企业知识库以及 Agent 工具调用这些场景后，安全问题就一股脑儿浮出水面了。

用户可能输入恶意提示词，诱导模型绕过规则；模型可能输出不合适的内容；Agent 可能自作主张调用不该碰的工具；RAG 系统可能把敏感资料泄漏给没有权限的用户；更麻烦的是，内部接口也可能被大模型应用间接暴露出去。

所以，AI 安全网关正逐渐成为一项必不可少的工程能力。

说白了，它就卡在用户请求和模型服务之间，专门负责提示词检查、用户权限校验、敏感词过滤、工具调用控制、输出审计和日志记录。这意味着，大模型应用不能再只盯着“生成结果”，还得操心“生成过程是否安全”。

一、为什么 AI 应用需要安全网关？

传统 Web 应用有 API 网关、防火墙、权限系统和日志审计，这个套路大家都很熟悉。大模型应用也一样，需要类似的防护能力。

原因很简单：一次 AI 请求可不是普通的接口调用，它里面可能包含了用户输入、知识库检索、工具调用、模型生成和最终输出等多个环节。哪个环节缺了控制，风险就可能从哪个环节冒出来。

比如：

用户输入恶意提示词；
模型输出敏感内容；
Agent 调用高风险工具；
RAG 召回了无权限文档；
系统没有记录请求链路。

下面就用 Python 写一个简化版的 AI 安全网关，把这几层防护串起来。

二、基础配置：定义安全规则

第一步当然是定义安全规则。这里包括敏感词、危险动作、高风险工具和角色权限。真实系统中，这些规则可以存在数据库或权限中心里，不过咱们先写死在代码里，方便理解。

import json
import time
import hashlib
from datetime import datetime

SENSITIVE_WORDS = [
    "敏感数据",
    "内部密钥",
    "用户隐私",
    "数据库密码",
    "访问令牌"
]

DANGEROUS_ACTIONS = [
    "删除数据",
    "绕过权限",
    "导出全部用户",
    "关闭审计",
    "修改权限"
]

HIGH_RISK_TOOLS = [
    "database_write",
    "user_export",
    "permission_update",
    "shell_execute",
    "file_delete"
]

ROLE_PERMISSIONS = {
    "guest": ["search", "summary"],
    "developer": ["search", "summary", "code_review"],
    "admin": ["search", "summary", "code_review", "database_read", "audit_query"]
}

AUDIT_LOG = []

def build_request_id(user_id, prompt):
    raw = f"{user_id}-{prompt}-{time.time()}"
    return hashlib.md5(raw.encode("utf-8")).hexdigest()

这些规则就好比安全网关的“家底”——系统会拿着它们来判断请求到底该不该放行。

三、输入检查：识别提示词风险

第二步是检查用户输入。如果用户输入里带了危险动作或者明显敏感的内容，系统可以直接拦下，或者标记为高风险请求。

def check_prompt_risk(prompt):
    risk_items = []
    for word in SENSITIVE_WORDS:
        if word in prompt:
            risk_items.append({
                "type": "sensitive_word",
                "value": word
            })
    for action in DANGEROUS_ACTIONS:
        if action in prompt:
            risk_items.append({
                "type": "dangerous_action",
                "value": action
            })
    risk_level = "low"
    if len(risk_items) >= 2:
        risk_level = "high"
    elif len(risk_items) == 1:
        risk_level = "medium"
    return {
        "risk_level": risk_level,
        "risk_items": risk_items
    }

输入检查是 AI 安全治理的第一道防线，虽然它不能解决所有问题，但至少能把那些明显异常的请求挡住。

四、权限校验：判断用户能否执行任务

第三步是权限校验。不同角色的用户能干的活儿不一样：访客只能搜索和摘要，开发者可以做代码审查，管理员才能查审计数据。

def check_user_permission(role, action):
    allowed_actions = ROLE_PERMISSIONS.get(role, [])
    return action in allowed_actions

def build_permission_result(role, action):
    allowed = check_user_permission(role, action)
    return {
        "role": role,
        "action": action,
        "allowed": allowed,
        "checked_at": datetime.now().isoformat()
    }

这一步能防止 AI 应用变成绕过系统权限的后门。尤其是 Agent 场景里，模型会自己调用工具，用户能调用哪些能力必须严格管住。

五、工具调用检查：拦截高风险工具

第四步是检查工具调用。如果 Agent 想调用一个高风险工具，系统必须先看看当前用户有没有这个权限。

def check_tool_call(role, tool_name):
    if tool_name not in HIGH_RISK_TOOLS:
        return {
            "tool_name": tool_name,
            "allowed": True,
            "reason": "normal tool"
        }
    if role == "admin":
        return {
            "tool_name": tool_name,
            "allowed": True,
            "reason": "admin allowed"
        }
    return {
        "tool_name": tool_name,
        "allowed": False,
        "reason": "high risk tool requires admin role"
    }

def simulate_tool_call(tool_name, payload):
    return {
        "tool_name": tool_name,
        "payload": payload,
        "result": "工具执行结果",
        "run_time": datetime.now().isoformat()
    }

工具调用检查是 Agent 安全的关键，缺了这层防护，模型可能被诱导去干危险的事。

六、输出检查：过滤敏感结果

第五步是输出检查。模型生成内容后，系统还得再扫一遍，看有没有敏感词或不该返回的信息。

def check_output_safety(output_text):
    issues = []
    for word in SENSITIVE_WORDS:
        if word in output_text:
            issues.append({
                "type": "sensitive_output",
                "value": word
            })
    safe = len(issues) == 0
    return {
        "safe": safe,
        "issues": issues
    }

def mask_sensitive_output(output_text):
    masked = output_text
    for word in SENSITIVE_WORDS:
        masked = masked.replace(word, "***")
    return masked

输出检查能降低模型泄露敏感内容的风险，尤其是在企业知识库和内部问答场景里，这一步相当重要。

七、审计日志：记录完整请求链路

第六步是审计。每次请求都得记下来——用户、角色、动作、风险等级、工具调用、输出检查结果和最终状态，一个都不能少。

def write_audit_log(record):
    AUDIT_LOG.append(record)

def build_audit_record(
    request_id,
    user_id,
    role,
    action,
    prompt_risk,
    permission_result,
    tool_result,
    output_check,
    status
):
    return {
        "request_id": request_id,
        "user_id": user_id,
        "role": role,
        "action": action,
        "prompt_risk": prompt_risk,
        "permission_result": permission_result,
        "tool_result": tool_result,
        "output_check": output_check,
        "status": status,
        "audit_time": datetime.now().isoformat()
    }

审计日志的意义在于让 AI 应用可以被追踪、复盘、治理。没有审计能力的 AI 系统，很难真正进入严肃的业务场景。

八、统一安全网关：串联完整流程

第七步是构建统一安全网关。所有请求先经过网关，再决定要不要调用模型或工具。

def fake_model_generate(prompt):
    if "敏感数据" in prompt:
        return "模型回答中可能包含敏感数据，需要处理。"
    return "这是模型生成的安全回答。"

def ai_security_gateway(user_id, role, action, prompt, tool_name=None):
    request_id = build_request_id(user_id, prompt)
    status = "success"
    tool_result = None

    prompt_risk = check_prompt_risk(prompt)
    permission_result = build_permission_result(
        role=role,
        action=action
    )

    if not permission_result["allowed"]:
        status = "blocked_permission"
        output_text = "请求被拦截：当前角色没有执行该操作的权限。"
        output_check = check_output_safety(output_text)
        audit_record = build_audit_record(
            request_id=request_id,
            user_id=user_id,
            role=role,
            action=action,
            prompt_risk=prompt_risk,
            permission_result=permission_result,
            tool_result=tool_result,
            output_check=output_check,
            status=status
        )
        write_audit_log(audit_record)
        return {
            "request_id": request_id,
            "status": status,
            "answer": output_text
        }

    if prompt_risk["risk_level"] == "high":
        status = "blocked_prompt"
        output_text = "请求被拦截：输入内容存在较高安全风险。"
        output_check = check_output_safety(output_text)
        audit_record = build_audit_record(
            request_id=request_id,
            user_id=user_id,
            role=role,
            action=action,
            prompt_risk=prompt_risk,
            permission_result=permission_result,
            tool_result=tool_result,
            output_check=output_check,
            status=status
        )
        write_audit_log(audit_record)
        return {
            "request_id": request_id,
            "status": status,
            "answer": output_text
        }

    if tool_name:
        tool_check = check_tool_call(role, tool_name)
        if not tool_check["allowed"]:
            status = "blocked_tool"
            output_text = f"请求被拦截：{tool_check['reason']}"
            output_check = check_output_safety(output_text)
            audit_record = build_audit_record(
                request_id=request_id,
                user_id=user_id,
                role=role,
                action=action,
                prompt_risk=prompt_risk,
                permission_result=permission_result,
                tool_result=tool_check,
                output_check=output_check,
                status=status
            )
            write_audit_log(audit_record)
            return {
                "request_id": request_id,
                "status": status,
                "answer": output_text
            }
        tool_result = simulate_tool_call(
            tool_name=tool_name,
            payload={"prompt": prompt}
        )

    output_text = fake_model_generate(prompt)
    output_check = check_output_safety(output_text)
    if not output_check["safe"]:
        output_text = mask_sensitive_output(output_text)
        status = "masked_output"

    audit_record = build_audit_record(
        request_id=request_id,
        user_id=user_id,
        role=role,
        action=action,
        prompt_risk=prompt_risk,
        permission_result=permission_result,
        tool_result=tool_result,
        output_check=output_check,
        status=status
    )
    write_audit_log(audit_record)

    return {
        "request_id": request_id,
        "status": status,
        "answer": output_text
    }

安全网关的核心价值，是把 AI 请求的风险控制前置。它让模型调用不再是“裸奔”，而是经过输入、权限、工具和输出多层检查。

九、生成安全审计报告

最后一步是生成审计报告。报告可以统计请求总数、拦截数以及风险类型的分布情况。

def generate_security_report():
    total = len(AUDIT_LOG)
    blocked = len([
        item for item in AUDIT_LOG
        if item["status"].startswith("blocked")
    ])
    masked = len([
        item for item in AUDIT_LOG
        if item["status"] == "masked_output"
    ])
    risk_count = {}
    for item in AUDIT_LOG:
        risk_level = item["prompt_risk"]["risk_level"]
        risk_count[risk_level] = risk_count.get(risk_level, 0) + 1
    return {
        "report_name": "AI 安全网关审计报告",
        "total_requests": total,
        "blocked_requests": blocked,
        "masked_outputs": masked,
        "risk_count": risk_count,
        "generate_time": datetime.now().isoformat()
    }

if __name__ == "__main__":
    samples = [
        {
            "user_id": "u001",
            "role": "guest",
            "action": "summary",
            "prompt": "请总结这篇技术文章",
            "tool_name": None
        },
        {
            "user_id": "u002",
            "role": "developer",
            "action": "code_review",
            "prompt": "请帮我检查代码问题",
            "tool_name": "search"
        },
        {
            "user_id": "u003",
            "role": "guest",
            "action": "database_read",
            "prompt": "请导出全部用户数据",
            "tool_name": "user_export"
        },
        {
            "user_id": "u004",
            "role": "admin",
            "action": "audit_query",
            "prompt": "查询审计记录，但不要暴露内部密钥",
            "tool_name": "audit_query"
        }
    ]

    for sample in samples:
        result = ai_security_gateway(**sample)
        print(json.dumps(
            result,
            ensure_ascii=False,
            indent=2
        ))

    report = generate_security_report()
    print(json.dumps(
        report,
        ensure_ascii=False,
        indent=2
    ))