/ Detailed source-code truncated for AI context efficiency. /

配置环境变量

cp backend/env.example backend/.env
编辑 .env，设置 AGENT_ENABLED=true
启动完整服务

docker compose up -d

cd docker/sandbox
./build.sh

嵌入模型配置

EMBEDDING_PROVIDER=openai
EMBEDDING_MODEL=text-embedding-3-small
向量数据库配置

VECTOR_DB_TYPE=chroma

SANDBOX_ENABLED=true
SANDBOX_IMAGE=deepaudit-sandbox:latest
SANDBOX_MEMORY_LIMIT=512m
SANDBOX_CPU_LIMIT=1.0
SANDBOX_NETWORK_DISABLED=true

POST /api/v1/agent-tasks/
Content-Type: application/json
{
  "project_id": "xxx",
  "name": "安全审计",
  "target_vulnerabilities": ["sql_injection", "xss"],
  "verification_level": "sandbox",
  "max_iterations": 3
}

GET /api/v1/agent-tasks/{task_id}/events
Accept: text/event-stream

GET /api/v1/agent-tasks/{task_id}/findings?verified_only=true

GET /api/v1/agent-tasks/{task_id}/summary

GET /api/v1/agent-tasks/{task_id}/report?format=markdown

backend/app/services/agent/
├── __init__.py              # 模块导出
├── event_manager.py         # 事件管理
├── agents/                  # Agent 实现
│   ├── __init__.py
│   ├── base.py             # Agent 基类
│   ├── recon.py            # 信息收集 Agent
│   ├── analysis.py         # 漏洞分析 Agent
│   ├── verification.py     # 漏洞验证 Agent
│   └── orchestrator.py     # 编排 Agent
├── tools/                   # Agent 工具
│   ├── __init__.py
│   ├── base.py             # 工具基类
│   ├── rag_tool.py         # RAG 工具
│   ├── pattern_tool.py     # 模式匹配工具
│   ├── code_analysis_tool.py
│   ├── file_tool.py        # 文件操作
│   ├── sandbox_tool.py     # 沙箱工具
│   └── external_tools.py   # 外部安全工具
└── prompts/                 # 系统提示词
    ├── __init__.py
    └── system_prompts.py

检查服务状态

docker compose ps
查看后端日志

docker compose logs backend | grep -i agent

检查嵌入模型配置

确保 EMBEDDING_API_KEY 正确设置

检查沙箱镜像

docker images | grep deepaudit-sandbox
重新构建沙箱

cd docker/sandbox && ./build.sh

检查工具安装（本地开发时）

which semgrep bandit gitleaks
或使用 Docker 沙箱执行

查看 Agent 日志

docker compose logs -f backend | grep -E "(agent|Agent)"
查看详细日志

tail -f logs/agent.log

传统方式: 规则 → 固定流程 → 结果
DeepAudit: LLM分析 → 自主决策 → 动态调整 → 结果

┌─────────────────────────────────────────────────┐
│                  LLM 输出                        │
├─────────────────────────────────────────────────┤
│ Thought: 我应该先了解项目结构...                  │
│ Action: list_files                              │
│ Action Input: {"directory": ".", "pattern": "*"}│
└─────────────────────────────────────────────────┘
                      ↓
┌─────────────────────────────────────────────────┐
│                系统执行工具                       │
├─────────────────────────────────────────────────┤
│ Observation: [找到 app/, config/, tests/...]     │
└─────────────────────────────────────────────────┘
                      ↓
         反馈给LLM，继续下一轮循环

┌───────────────────┐
                    │  OrchestratorAgent │
                    │    (策略编排者)     │
                    └─────────┬─────────┘
                              │
            ┌─────────────────┼─────────────────┐
            ↓                 ↓                 ↓
    ┌───────────────┐ ┌───────────────┐ ┌───────────────┐
    │  ReconAgent   │ │ AnalysisAgent │ │VerificationAgent│
    │  (情报收集)    │ │  (漏洞猎手)    │ │   (验证确认)   │
    └───────────────┘ └───────────────┘ └───────────────┘

class BaseAgent:
    """Agent基类 - 提供通用功能"""
    # 核心配置
    config: AgentConfig  # 名称、类型、模式、最大token数、最大迭代次数
    state: AgentState    # 状态管理(status, messages, findings)
    # 关键方法
    async def run(self, input_data: dict) -> AgentResult  # 抽象方法
    async def stream_llm_call()    # 统一的LLM调用(支持流式+自动压缩)
    async def execute_tool()       # 工具执行(带错误处理)
    # 事件发射
    def emit_thinking_token()      # 流式输出LLM思考过程
    def emit_thinking_start/end()  # 思考生命周期
    def emit_tool_call/result()    # 工具执行生命周期
    def emit_finding()             # 漏洞发现事件

class OrchestratorAgent(BaseAgent):
    """编排器Agent - 协调整体审计流程"""
    async def run(self, input_data: dict) -> AgentResult:
        """主ReAct循环 - LLM决定下一步行动"""
        # dispatch_agent: 派发子Agent
        # summarize: 汇总当前进度
        # finish: 完成审计
    async def _dispatch_agent(self, agent_name: str, task: str):
        """派发ReconAgent、AnalysisAgent或VerificationAgent"""
    def _parse_llm_response(self, response: str):
        """从LLM输出中提取Thought/Action/Action Input"""

{
  "project_structure": {...},
  "tech_stack": {"languages": ["Python"], "frameworks": ["Django"]},
  "entry_points": ["app/views.py", "api/routes.py"],
  "high_risk_areas": ["auth/", "payment/"],
  "initial_findings": [...]
}

{
  "is_verified": true,
  "poc": {
    "description": "...",
    "steps": [...],
    "payload": "..."
  },
  "exploitability": "high",
  "confidence": 0.95
}

@dataclass
class TaskHandoff:
    """Agent间的结构化通信协议"""
    work_completed: str          # 已完成的工作
    key_findings: List[dict]     # 关键发现
    insights: List[str]          # 洞察
    suggested_actions: List[str] # 建议行动
    attention_points: List[str]  # 需要关注的点
    priority_areas: List[str]    # 优先区域
    context_data: dict           # 上下文数据
    def to_prompt_context(self) -> str:
        """转换为LLM可读格式"""

class AgentState:
    """Agent状态跟踪"""
    status: Literal["created", "running", "waiting", "completed", "failed"]
    messages: List[Message]  # 对话历史
    findings: List[Finding]  # 发现列表
    iterations: int          # 当前迭代次数
    tool_calls: int          # 工具调用次数

class ExecutionContext:
    """分布式追踪的执行上下文"""
    task_id: str           # 任务ID
    agent_id: str          # Agent ID
    trace_path: str        # 追踪路径 (如: Orchestrator > Analysis)
    depth: int             # 嵌套深度
    iteration: int         # 当前迭代
    metadata: dict         # 附加元数据
    def child_context(self, agent_id: str) -> ExecutionContext:
        """创建子上下文"""
    def with_iteration(self, iteration: int) -> ExecutionContext:
        """带迭代信息的上下文"""

class CircuitBreaker:
    """熔断器 - 防止级联故障"""
    # 状态转换: CLOSED -> OPEN -> HALF_OPEN -> CLOSED
    failure_threshold: int = 5     # 失败阈值
    recovery_timeout: float = 30.0 # 恢复超时(秒)
    async def call(self, func: Callable) -> Any:
        """受保护的调用"""
        if self.state == CircuitState.OPEN:
            raise CircuitOpenError()
        try:
            result = await func()
            self._record_success()
            return result
        except Exception as e:
            self._record_failure()
            raise

class RetryStrategy:
    """指数退避重试"""
    base_delay: float = 1.0   # 基础延迟(秒)
    max_delay: float = 60.0   # 最大延迟(秒)
    max_retries: int = 3      # 最大重试次数
    def get_delay(self, attempt: int) -> float:
        """计算延迟: min(base  (2 * attempt) + jitter, max)"""

class RateLimiter:
    """令牌桶算法速率限制"""
    # 预设限制:
    # - 外部工具: 0.2 calls/second (每5秒1次)
    # - LLM调用: 60 calls/minute
    # - 突发支持: 最多3个并发调用
    async def acquire(self, tool_name: str):
        """获取执行许可"""

class InputValidator:
    """输入安全验证"""
    def validate_file_path(self, path: str) -> bool:
        """文件路径安全检查"""
        # - 检查路径遍历攻击
        # - 验证文件扩展名
        # - 检查符号链接
    def validate_file_size(self, path: str, max_size: int = 10_000_000):
        """文件大小限制(默认10MB)"""

自定义异常层级

class AgentError(Exception): pass
class CircuitOpenError(AgentError): pass      # 熔断器打开
class AgentExecutionError(AgentError): pass   # Agent执行失败
class ToolExecutionError(AgentError): pass    # 工具执行失败
class ValidationError(AgentError): pass       # 输入验证失败
class TokenLimitError(AgentError): pass       # Token超限

class SmartScanTool:
    """智能批量安全扫描 - 推荐首选工具"""
    # 功能:
    # - 自动检测漏洞模式
    # - 聚焦高风险文件
    # - 批量处理提高效率
    async def execute(self, target: str) -> dict:
        return {
            "vulnerabilities": [...],
            "risk_areas": [...],
            "recommendations": [...]
        }

class PatternMatchTool:
    """基于正则的模式检测"""
    # 内置模式:
    # - SQL注入模式
    # - XSS模式
    # - 命令注入模式
    # - 可作为Semgrep的后备

class DataFlowAnalysisTool:
    """数据流分析工具"""
    # 功能:
    # - 源点到汇点追踪
    # - 变量污点分析
    # - LLM辅助的数据流理解

class FinishTool:
    """任务完成工具"""
    async def execute(self, conclusion: str, findings: List[dict]):
        """标记任务完成并返回最终结果"""

核心安全原则

CORE_SECURITY_PRINCIPLES = """
- 深度分析优于广度覆盖
- 重视数据流追踪
- 上下文感知分析
- 假阳性需验证确认
"""
漏洞优先级

VULNERABILITY_PRIORITIES = {
    "critical": ["sql_injection", "command_injection", "code_injection"],
    "high": ["path_traversal", "ssrf", "auth_bypass"],
    "medium": ["xss", "information_disclosure", "xxe"],
    "low": ["csrf", "weak_crypto", "unsafe_transport"]
}
多Agent协作规则

MULTI_AGENT_RULES = """
- 避免重复工作
- 共享上下文信息
- 聚焦自身职责
- 及时交接发现
"""

AgentAudit/
├── index.tsx              # 主页面组件
├── types.ts               # TypeScript类型定义
├── utils.ts               # 工具函数
├── constants.tsx          # 常量配置
├── hooks/
│   ├── useAgentAuditState.ts  # 状态管理(useReducer)
│   ├── useResilientStream.ts  # SSE流式连接
│   └── index.ts
└── components/
    ├── Header.tsx             # 标题、状态、控制按钮
    ├── StatsPanel.tsx         # 统计面板
    ├── AgentTreeNode.tsx      # Agent树节点渲染
    ├── AgentDetailPanel.tsx   # Agent详情侧边栏
    ├── LogEntry.tsx           # 单条日志条目
    ├── ConnectionStatus.tsx   # 连接状态指示器
    ├── StatusBadge.tsx        # 状态徽章
    ├── SplashScreen.tsx       # 初始屏幕
    ├── AgentErrorBoundary.tsx # 错误边界
    ├── ReportExportDialog.tsx # 导出对话框
    └── index.ts

interface AgentAuditState {
  task: AgentTask | null;              // 当前任务
  findings: AgentFinding[];            // 发现列表
  agentTree: AgentTreeResponse | null; // Agent树
  logs: LogItem[];                     // 日志列表
  selectedAgentId: string | null;      // 选中的Agent
  connectionStatus: ConnectionStatus;   // 连接状态
  isAutoScroll: boolean;               // 自动滚动
  expandedLogIds: Set<string>;         // 展开的日志ID
}
type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error';
// Reducer Actions
type Action =
  | { type: 'SET_TASK'; payload: AgentTask }
  | { type: 'SET_FINDINGS'; payload: AgentFinding[] }
  | { type: 'ADD_LOG'; payload: LogItem }
  | { type: 'UPDATE_LOG'; payload: { id: string; updates: Partial<LogItem> } }
  | { type: 'SET_CONNECTION_STATUS'; payload: ConnectionStatus }
  | { type: 'SELECT_AGENT'; payload: string | null }
  | { type: 'TOGGLE_LOG_EXPANDED'; payload: string }
  | { type: 'RESET' };

function useResilientStream(taskId: string, options: StreamOptions) {
  // 功能:
  // - 弹性SSE连接(自动重连)
  // - Thinking token逐字符流式更新
  // - 按类型过滤事件
  // - 组件卸载时自动清理
  // 事件处理器
  onThinkingToken: (token: string) => void;  // 累积thinking内容
  onToolStart: (tool: ToolEvent) => void;    // 工具开始
  onToolEnd: (tool: ToolEvent) => void;      // 工具结束
  onFinding: (finding: Finding) => void;     // 新发现
  onComplete: () => void;                     // 任务完成
  onError: (error: Error) => void;           // 错误处理
}

type LogType =
  | 'thinking'  // LLM思考过程(支持流式)
  | 'tool'      // 工具执行(含耗时和状态)
  | 'phase'     // 工作流阶段
  | 'finding'   // 漏洞发现
  | 'info'      // 信息消息
  | 'error'     // 错误消息
  | 'dispatch'  // 子Agent派发
  | 'user';     // 用户操作
interface LogItem {
  id: string;
  type: LogType;
  timestamp: Date;
  content: string;
  metadata?: Record<string, any>;
  isExpanded?: boolean;
  isStreaming?: boolean;  // thinking类型专用
}

SSE Stream → useResilientStream → dispatch() → reducer → UI更新
     ↓
thinking_token事件
     ↓
onThinkingToken回调
     ↓
dispatch({type: 'ADD_LOG', payload: {type: 'thinking', content: accumulated}})
     ↓
UI渲染LogEntry(流式效果)

class AgentTaskCreate(BaseModel):
    project_id: str                    # 项目ID
    name: Optional[str]                # 任务名称
    target_vulnerabilities: List[str] = [
        "sql_injection", "xss", "command_injection",
        "path_traversal", "ssrf"
    ]
    verification_level: str = "sandbox"  # 验证级别
    exclude_patterns: List[str] = [      # 排除模式
        "node_modules", "venv", "__pycache__", ".git"
    ]
    target_files: Optional[List[str]]    # 限定扫描文件
    max_iterations: int = 50             # 最大迭代(1-200)
    timeout_seconds: int = 1800          # 超时(60-7200秒)

/ Detailed source-code truncated for AI context efficiency. /

1. 用户请求: POST /agent-tasks/
   {
     "project_id": "123",
     "target_files": ["app/views.py"]
   }
2. Orchestrator迭代1 - LLM输出:
   Thought: 我应该先用recon了解项目结构
   Action: dispatch_agent
   Action Input: {"agent": "recon", "task": "分析项目结构"}
3. ReconAgent执行:
   迭代1: list_files → 找到 app/views.py, models.py...
   迭代2: read_file → 读取app/views.py内容
   迭代N: Final Answer → 返回项目结构信息
4. Orchestrator迭代2 - LLM输出:
   Thought: 这是一个Django项目，让我派发Analysis进行漏洞分析
   Action: dispatch_agent
   Action Input: {"agent": "analysis", "task": "深度漏洞分析"}
5. AnalysisAgent执行:
   迭代1: smart_scan → 发现第42行可能存在SQL注入
   迭代2: read_file → 确认问题代码
   迭代M: Final Answer → 返回结构化的漏洞发现
6. Orchestrator迭代3 - LLM输出:
   Thought: 发现高危SQL注入，需要验证
   Action: dispatch_agent
   Action Input: {"agent": "verification", "task": "验证SQL注入"}
7. VerificationAgent确认:
   返回: {"is_verified": true, "poc": {...}}
8. Orchestrator完成:
   Thought: 审计完成，共发现1个已验证漏洞
   Action: finish
   Action Input: {"conclusion": "...", "findings": [...]}
9. 后端持久化:
   - AgentTask.status = COMPLETED
   - 写入AgentFinding表
10. 前端实时展示:
    - 日志流式更新
    - Agent树动态生长
    - 统计数据刷新
    - 最终展示发现列表

class EventManager:
    """事件管理器 - 内存队列 + 流式迭代"""
    max_events: int = 1000  # 最大事件数
    async def emit(self, event_type: str, message: str, metadata):
        """发射事件"""
    async def stream_events(self):
        """异步迭代器: async for event in manager.stream_events()"""

class Tracer:
    """分布式追踪"""
    def create_span(self, name: str, parent_span: Span = None) -> Span:
        """创建追踪Span"""
    # 追踪路径示例: Orchestrator > Analysis > (Verification)
    # 记录的指标:
    # - 执行时间
    # - Token使用量
    # - 工具调用次数
    # - 关联ID

class AgentConfig:
    """Agent配置 (环境变量前缀: AGENT_)"""
    # LLM设置
    llm_max_retries: int = 3
    llm_retry_base_delay: float = 1.0
    llm_timeout_seconds: int = 120
    llm_max_tokens_per_call: int = 4096
    llm_temperature: float = 0.1
    llm_stream_enabled: bool = True
    # Agent迭代限制
    orchestrator_max_iterations: int = 20
    recon_max_iterations: int = 15
    analysis_max_iterations: int = 30
    verification_max_iterations: int = 15
    # 工具设置
    tool_timeout_seconds: int = 60
    tool_max_retries: int = 2
    semgrep_enabled: bool = True
    bandit_enabled: bool = True
    gitleaks_enabled: bool = True
    # 资源限制
    max_file_size_bytes: int = 10_000_000  # 10MB
    max_files_per_scan: int = 1000
    max_total_findings: int = 500
    max_context_messages: int = 50
    # 熔断器
    circuit_breaker_enabled: bool = True
    circuit_failure_threshold: int = 5
    circuit_recovery_timeout_seconds: float = 30.0
    # 检查点
    checkpoint_enabled: bool = True
    checkpoint_interval_iterations: int = 5
    max_checkpoints_per_task: int = 50

def apply_development_preset():
    """开发环境预设"""
    # 更宽松的限制，更多日志
def apply_production_preset():
    """生产环境预设"""
    # 更严格的限制，优化性能
def apply_testing_preset():
    """测试环境预设"""
    # 快速迭代，最小资源

┌─────────────────────────────────────────────┐
│              传统自动化                      │
│  规则引擎 → 固定流程 → 预定义行为           │
└─────────────────────────────────────────────┘
┌─────────────────────────────────────────────┐
│              DeepAudit                       │
│  LLM分析 → 自主决策 → 动态适应 → 智能输出   │
└─────────────────────────────────────────────┘

Loop:
  1. Thought: LLM思考当前状态和下一步
  2. Action: 选择要执行的动作/工具
  3. Action Input: 提供参数
  4. Observation: 获取执行结果
  5. 重复直到达成目标或Final Answer

Agent A完成工作后

handoff = TaskHandoff(
    work_completed="扫描了10个文件，发现3个可疑点",
    key_findings=[finding1, finding2, finding3],
    suggested_actions=["验证SQL注入", "检查认证逻辑"],
    priority_areas=["auth/", "api/"]
)
转换为下一个Agent的输入

context = handoff.to_prompt_context()
Agent B使用此上下文继续工作

┌───────────────────────────────────────────────────┐
│                 优雅降级策略                       │
├───────────────────────────────────────────────────┤
│ • 工具失败不中断执行 (continue_on_tool_failure)   │
│ • 后备工具链 (Semgrep → PatternMatch)             │
│ • 超时时返回部分结果                              │
│ • 熔断器防止级联故障                              │
│ • 消息压缩避免token超限                           │
└───────────────────────────────────────────────────┘

支持的范围限定:

AgentTaskCreate(
    exclude_patterns=["node_modules", "*.min.js"],  # 排除模式
    target_files=["src/auth/", "api/views.py"]      # 限定文件
)
减少噪音，聚焦LLM注意力

1. 创建新Agent类

class CustomAgent(BaseAgent):
    def __init__(self, config: AgentConfig):
        super().__init__(config)
        self.config.name = "custom"
        self.config.max_iterations = 20
    async def run(self, input_data: dict) -> AgentResult:
        # 实现ReAct循环
        for iteration in range(self.config.max_iterations):
            response = await self.stream_llm_call(messages)
            parsed = self._parse_response(response)
            if parsed.action == "finish":
                return AgentResult(data=parsed.data)
            observation = await self.execute_tool(
                parsed.action,
                parsed.action_input
            )
            messages.append({"role": "user", "content": f"Observation: {observation}"})
2. 在Orchestrator中注册

orchestrator.register_agent("custom", CustomAgent(config))

1. 实现工具接口

class CustomTool:
    name: str = "custom_tool"
    description: str = "自定义工具描述"
    async def execute(self, kwargs) -> dict:
        # 实现工具逻辑
        return {"result": "..."}
2. 在工具注册表中添加

TOOL_REGISTRY["custom_tool"] = CustomTool()

创建新的知识模块: knowledge/vulnerabilities/custom_vuln.py
CUSTOM_VULN_KNOWLEDGE = {
    "name": "Custom Vulnerability",
    "description": "...",
    "patterns": [
        r"pattern1",
        r"pattern2"
    ],
    "examples": [...],
    "remediation": "..."
}

在system_prompts.py中添加

CUSTOM_AGENT_PROMPT = """
你是一个专门的安全分析Agent。
职责:
- ...
可用工具:
- ...
输出格式:
- ...
"""

在Agent中发射自定义事件

self.emit_event(
    event_type="custom_event",
    message="自定义消息",
    custom_field="value"
)
在前端处理

switch (event.type) {
    case 'custom_event':
        handleCustomEvent(event);
        break;
}

/ Detailed source-code truncated for AI context efficiency. /

后端依赖

cd backend
uv pip install chromadb litellm langchain langgraph
外部安全工具（可选但推荐）

pip install semgrep bandit safety
或者使用系统包管理器

brew install semgrep  # macOS
apt install semgrep   # Ubuntu

LLM 配置（必须）

LLM_PROVIDER=openai      # 或 azure, anthropic, ollama 等
LLM_MODEL=gpt-4o-mini    # 推荐使用 gpt-4 系列
LLM_API_KEY=sk-xxx       # 你的 API Key
LLM_BASE_URL=            # 可选，自定义端点
嵌入模型配置（RAG 需要）

EMBEDDING_PROVIDER=openai
EMBEDDING_MODEL=text-embedding-3-small

cd backend
alembic upgrade head

创建向量数据库目录

mkdir -p /var/data/deepaudit/vector_db
在 .env 中配置

VECTOR_DB_PATH=/var/data/deepaudit/vector_db

拉取沙箱镜像

docker pull python:3.11-slim
配置沙箱参数

SANDBOX_IMAGE=python:3.11-slim
SANDBOX_MEMORY_LIMIT=256m
SANDBOX_CPU_LIMIT=0.5

cd backend
PYTHONPATH=. uv run pytest tests/agent/ -v

cd backend
PYTHONPATH=. uv run python -c "
import asyncio
from app.services.agent.graph.runner import LLMService
async def test():
    llm = LLMService()
    result = await llm.analyze_code('print(\"hello\")', 'python')
    print('LLM 连接成功:', 'issues' in result)
asyncio.run(test())
"

测试 Semgrep

semgrep --version
测试 Bandit

bandit --version

Kubernetes 部署示例

resources:
  limits:
    memory: "2Gi"
    cpu: "2"
  requests:
    memory: "1Gi"
    cpu: "1"

限制同时运行的任务数

MAX_CONCURRENT_AGENT_TASKS=3
AGENT_TASK_TIMEOUT=1800  # 30 分钟

配置日志级别

LOG_LEVEL=INFO
启用 SQLAlchemy 日志（调试用）

SQLALCHEMY_ECHO=false

cd backend
PYTHONPATH=. uv run python -c "
print('检查部署状态...')
1. 检查数据库连接

try:
    from app.db.session import async_session_factory
    print('✅ 数据库配置正确')
except Exception as e:
    print(f'❌ 数据库错误: {e}')
2. 检查 LLM 配置

from app.core.config import settings
if settings.LLM_API_KEY:
    print('✅ LLM API Key 已配置')
else:
    print('⚠️ LLM API Key 未配置')
3. 检查向量数据库

import os
if os.path.exists(settings.VECTOR_DB_PATH or '/tmp'):
    print('✅ 向量数据库路径存在')
else:
    print('⚠️ 向量数据库路径不存在')
4. 检查外部工具

import shutil
tools = ['semgrep', 'bandit']
for tool in tools:
    if shutil.which(tool):
        print(f'✅ {tool} 已安装')
    else:
        print(f'⚠️ {tool} 未安装（可选）')
print()
print('部署检查完成！')
"

cp backend/env.example backend/.env

/ Detailed source-code truncated for AI context efficiency. /

LLM_PROVIDER=openai
LLM_API_KEY=sk-your-api-key
LLM_MODEL=gpt-4o-mini

LLM_PROVIDER=qwen
LLM_API_KEY=sk-your-dashscope-key
LLM_MODEL=qwen-turbo

LLM_PROVIDER=ollama
LLM_MODEL=llama3
LLM_BASE_URL=http://localhost:11434/v1

LLM_PROVIDER=baidu
LLM_API_KEY=your_api_key:your_secret_key
LLM_MODEL=ernie-bot-4

cp frontend/.env.example frontend/.env

========== 后端 API 配置 ==========

VITE_API_BASE_URL=/api             # 后端 API 地址
========== 应用配置 ==========

VITE_APP_ID=deepaudit
========== 代码分析配置 ==========

VITE_MAX_ANALYZE_FILES=0           # 最大分析文件数，0表示无限制
VITE_LLM_CONCURRENCY=2             # LLM 并发数
VITE_LLM_GAP_MS=500                # 请求间隔（毫秒）
VITE_OUTPUT_LANGUAGE=zh-CN         # 输出语言

┌─────────────┐     ┌─────────────┐     ┌─────────────┐
│   前端      │────▶│   后端 API  │────▶│ PostgreSQL  │
│  (React)    │     │  (FastAPI)  │     │   数据库    │
└─────────────┘     └─────────────┘     └─────────────┘

LLM_PROVIDER=openai
LLM_API_KEY=中转站提供的Key
LLM_BASE_URL=https://your-proxy.com/v1
LLM_MODEL=gpt-4o-mini

{
  "name": "自定义安全规则",
  "description": "团队自定义的安全检测规则",
  "language": "all",
  "rule_type": "security",
  "rules": [
    {
      "rule_code": "CUSTOM001",
      "name": "敏感信息硬编码",
      "description": "检测代码中硬编码的敏感信息",
      "category": "security",
      "severity": "critical",
      "custom_prompt": "检查是否存在硬编码的密码、API Key、Token、私钥等敏感信息",
      "fix_suggestion": "使用环境变量或配置文件存储敏感信息"
    }
  ]
}

你是一个专业的代码审计助手。请从以下维度全面分析代码：
- 安全漏洞（SQL注入、XSS、命令注入、路径遍历、SSRF、XXE、反序列化、硬编码密钥等）
- 潜在的 Bug 和逻辑错误
- 性能问题和优化建议
- 编码规范和代码风格
- 可维护性和可读性
- 最佳实践和设计模式
请尽可能多地找出代码中的所有问题，不要遗漏任何安全漏洞或潜在风险！

你是一个专业的安全审计专家。请专注于检测以下安全问题：
【注入类漏洞】
- SQL注入（包括盲注、时间盲注、联合查询注入）
- 命令注入（OS命令执行）
- LDAP注入、XPath注入、NoSQL注入
【跨站脚本（XSS）】
- 反射型XSS、存储型XSS、DOM型XSS
【认证与授权】
- 硬编码凭证、弱密码策略、会话管理问题、权限绕过
【敏感数据】
- 敏感信息泄露、不安全的加密、明文传输敏感数据
【其他安全问题】
- SSRF、XXE、反序列化漏洞、路径遍历、文件上传漏洞、CSRF
请详细说明每个漏洞的风险等级、利用方式和修复建议。

你是一个专业的性能优化专家。请专注于检测以下性能问题：
【数据库性能】
- N+1查询问题、缺少索引、不必要的全表扫描、大量数据一次性加载、未使用连接池
【内存问题】
- 内存泄漏、大对象未及时释放、缓存使用不当、循环中创建大量对象
【算法效率】
- 时间复杂度过高、不必要的重复计算、可优化的循环、递归深度过大
【并发问题】
- 线程安全问题、死锁风险、资源竞争、不必要的同步
【I/O性能】
- 同步阻塞I/O、未使用缓冲、频繁的小文件操作、网络请求未优化
请提供具体的优化建议和预期的性能提升。

你是一个专业的代码质量审计专家。请专注于检测以下代码质量问题：
【代码规范】
- 命名不规范（变量、函数、类）、代码格式不一致、注释缺失或过时、魔法数字/字符串
【代码结构】
- 函数过长（超过50行）、类职责不单一、嵌套层级过深、重复代码
【可维护性】
- 高耦合低内聚、缺少错误处理、硬编码配置、缺少日志记录
【设计模式】
- 违反SOLID原则、可使用设计模式优化的场景、过度设计
【测试相关】
- 难以测试的代码、缺少边界条件处理、依赖注入问题
请提供具体的重构建议和代码示例。

┌─────────────────────────────────────────────────────────────┐
│                    System Prompt (系统提示词)                 │
├─────────────────────────────────────────────────────────────┤
│  ① 提示词模板内容 (来自数据库或默认模板)                        │
│     - 定义 AI 的角色和任务                                    │
│     - 指定分析维度和重点                                      │
├─────────────────────────────────────────────────────────────┤
│  ② 输出格式要求                                              │
│     - JSON Schema 定义                                       │
│     - 字段说明和约束                                          │
├─────────────────────────────────────────────────────────────┤
│  ③ 审计规则 (如果选择了规则集)                                 │
│     - 规则代码、名称、描述                                    │
│     - 每条规则的检测提示词                                    │
└─────────────────────────────────────────────────────────────┘
┌─────────────────────────────────────────────────────────────┐
│                    User Prompt (用户提示词)                   │
├─────────────────────────────────────────────────────────────┤
│  ④ 编程语言                                                  │
│  ⑤ 带行号的代码内容                                          │
└─────────────────────────────────────────────────────────────┘

你是一个专业的代码审计助手。请从以下维度全面分析代码：
- 安全漏洞（SQL注入、XSS、命令注入、路径遍历、SSRF、XXE、反序列化、硬编码密钥等）
- 潜在的 Bug 和逻辑错误
- 性能问题和优化建议
- 编码规范和代码风格
- 可维护性和可读性
- 最佳实践和设计模式
请尽可能多地找出代码中的所有问题，不要遗漏任何安全漏洞或潜在风险！
【输出格式要求】
1. 必须只输出纯JSON对象
2. 禁止在JSON前后添加任何文字、说明、markdown标记
3. 所有文本字段（title, description, suggestion等）必须使用中文输出
4. 输出格式必须符合以下 JSON Schema：
{
    "issues": [
        {
            "type": "security|bug|performance|style|maintainability",
            "severity": "critical|high|medium|low",
            "title": "string",
            "description": "string",
            "suggestion": "string",
            "line": 1,
            "column": 1,
            "code_snippet": "string",
            "rule_code": "string (optional, if matched a specific rule)"
        }
    ],
    "quality_score": 0-100,
    "summary": {
        "total_issues": number,
        "critical_issues": number,
        "high_issues": number,
        "medium_issues": number,
        "low_issues": number
    }
}
【审计规则】请特别关注以下规则：
- [A01] 访问控制失效: 检测权限绕过、越权访问、IDOR等访问控制问题
  检测要点: 检查是否存在访问控制失效问题：权限检查缺失、越权访问、IDOR（不安全的直接对象引用）、CORS配置错误
- [A02] 加密机制失效: 检测弱加密、明文传输、密钥管理不当等问题
  检测要点: 检查是否存在加密问题：使用弱加密算法(MD5/SHA1/DES)、明文存储密码、硬编码密钥、不安全的随机数生成
- [A03] 注入攻击: 检测SQL注入、命令注入、LDAP注入等注入漏洞
  检测要点: 检查是否存在注入漏洞：SQL注入、命令注入、LDAP注入、XPath注入、NoSQL注入、表达式语言注入
... (其他规则)

编程语言: Python
代码已标注行号（格式：行号| 代码内容），请根据行号准确填写 line 字段。
请分析以下代码:
1| import sqlite3
2| 
3| def get_user(user_id):
4|     conn = sqlite3.connect('users.db')
5|     cursor = conn.cursor()
6|     query = f"SELECT * FROM users WHERE id = {user_id}"
7|     cursor.execute(query)
8|     return cursor.fetchone()

⚠️⚠️⚠️ 只输出JSON，禁止输出其他任何格式！禁止markdown！禁止文本分析！⚠️⚠️⚠️
你是一个专业的代码审计助手。你的任务是分析代码并返回严格符合JSON Schema的结果。
【最重要】输出格式要求：
1. 必须只输出纯JSON对象，从{开始，到}结束
2. 禁止在JSON前后添加任何文字、说明、markdown标记
3. 禁止输出

提示词优先级  Copy Section
1. 用户选择的提示词模板 > 数据库默认模板 > 硬编码默认提示词
2. 规则集是可选的，如果选择了规则集，规则会追加到系统提示词末尾
---
更多资源  Copy Chapter
- 部署指南 - 详细的部署说明
- LLM 平台支持 - 各 LLM 平台的配置方法
- 常见问题 - 配置相关问题解答
---
DEPLOYMENT  Copy Section
部署指南
本文档详细介绍 DeepAudit v3.0.0 的各种部署方式，包括 Docker Compose 一键部署、Agent 审计模式部署和本地开发环境搭建。
目录  Copy Chapter
- 快速开始
- Docker Compose 部署（推荐）
- Agent 审计模式部署
- 生产环境部署
- 本地开发部署
- 常见部署问题
---
快速开始  Copy Chapter
最快的方式是使用 Docker Compose 一键部署：