环境:

trae pro、tabby、neo4j

自定义MCP分析漏洞利用链

tabby生成函数关系节点文件

Java项目分析例子:https://gitee.com/zwens/springboot-manager/

我们需要分析web的入口点,可以发现这是个纯的Springmvc项目,

入口的就是@RequestMapping、@PostMapping、@DeleteMapping、@PutMapping、@GetMapping,

先利用tabby分析函数关系,将关系节点导入neo4j数据中,

java -Xmx8g -jar tabby.jar

然后我们需要利用Cypher自定义查询函数,查询条件尽量仔细或者准确一点,恶意函数调用链就更准确,

如

#这里只提供查询语句,完整的查询脚本在我的上一篇文章,

queue_2 = f'''
    MATCH (source:Method)
    MATCH (source_c:Class)
    WHERE source.CLASSNAME = source_c.NAME

    and source_c.ANNOTATIONS in ["RequestMapping","PostMapping","DeleteMapping","PutMapping","GetMapping"]

    MATCH (sink:Method)<-[:CALL]-(m1:Method)
    WHERE sink.NAME in {vul_list}
    CALL apoc.algo.allSimplePaths(source, m1, "ALIAS>|CALL>", 5) YIELD path

    RETURN *
    LIMIT 100
    '''

最后得到函数调用关系,导出到output.xlxs中,

编写mcpserver端

编写mcpserver端,主要的作用是读取output.xlsx中的内容,根据内容中的恶意函数调用链中的函数关系上次源码文件,然后让模型分析函数调用链是否真实存在,函数调用链的参数是否可控,

import sys
import os
import re
from pathlib import Path
from typing import Any, Dict, List, Optional
from fastmcp import FastMCP

# 路径配置
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))

try:
    from read_output import load_output
except ImportError:
    print("错误: 无法导入 read_output.py")
    sys.exit(1)

mcp = FastMCP("MaliciousChainAnalyzer")

# --- 核心工具:定位类文件 ---

def find_class_file(fqn: str) -> Optional[Path]:
    """根据全类名定位 Java 文件"""
    source_root = ROOT / "springboot-manager-master" / "src" / "main" / "java"
    parts = fqn.split(".")
    candidate = source_root.joinpath(*parts).with_suffix(".java")
    if candidate.exists():
        return candidate
    
    # 模糊搜索处理内部类或特殊命名
    simple_name = parts[-1].split("$")[0] + ".java"
    for path in source_root.rglob(simple_name):
        try:
            with open(path, "r", encoding="utf-8", errors="ignore") as f:
                if f"package {'.'.join(parts[:-1])}" in f.read(1024):
                    return path
        except Exception:
            continue
    return None

# --- MCP 工具定义 ---

@mcp.tool()
def get_chain_analysis_context(row_index: int) -> Dict[str, Any]:
    """
    获取指定恶意调用链的完整审计上下文。
    返回:
    1. chain_sequence: 恶意函数的顺序调用关系。
    2. involved_classes: 链中涉及的所有类的完整源码(已去重)。
    
    模型应根据调用顺序,在源码中追踪参数从 Source 到 Sink 的传递过程。
    """
    summary = load_output()
    sheet_data = summary.get("Sheet", {}).get("data", [])
    
    if row_index >= len(sheet_data):
        return {"error": f"行索引 {row_index} 超出范围"}
    
    # 提取当前行的所有非空单元格
    raw_chain = [str(c) for c in sheet_data[row_index] if c]
    
    involved_classes = {}
    for cell in raw_chain:
        # 匹配 "method(class.fqn)"
        match = re.match(r"(\w+)\(([\w\.]+)\)", cell)
        if match:
            _, fqn = match.groups()
            if fqn not in involved_classes:
                file_path = find_class_file(fqn)
                if file_path:
                    try:
                        involved_classes[fqn] = file_path.read_text(encoding="utf-8")
                    except Exception as e:
                        involved_classes[fqn] = f"读取失败: {str(e)}"
                else:
                    involved_classes[fqn] = "未找到源码文件"
                    
    return {
        "row_index": row_index,
        "chain_sequence": " -> ".join(raw_chain),
        "involved_classes": involved_classes,
        "prompt_hint": (
            "请扮演高级安全审计专家。根据 chain_sequence 提供的恶意调用顺序,"
            "在 involved_classes 提供的完整类源码中进行静态分析。"
            "重点分析:参数是否能从链条的起点(Source)传递到终点(Sink)。"
            "如果发现参数可控且能触发敏感操作导入漏洞产生,请详细说明漏洞路径。"
        )
    }

@mcp.tool()
def list_all_chains() -> List[str]:
    """列出 output.xlsx 中所有的调用链摘要,方便选择行号"""
    summary = load_output()
    sheet_data = summary.get("Sheet", {}).get("data", [])
    return [f"Row {i}: {' -> '.join([str(c) for c in row if c])}" for i, row in enumerate(sheet_data)]

if __name__ == "__main__":
    mcp.run()

定义read_output.py,mcpserver会去调用读取xlsx内容的函数,

import json
from pathlib import Path

try:
    import openpyxl
except ImportError:
    print("NO_OPENPYXL")
    raise SystemExit(0)


def load_output() -> dict:
    # 使用绝对路径定位 output.xlsx,确保在不同目录下运行都能找到文件
    path = Path(__file__).parent / "output.xlsx"
    if not path.exists():
        return {"error": f"FILE_NOT_FOUND at {path}"}
    wb = openpyxl.load_workbook(path, data_only=True, read_only=True)
    summary = {}
    for ws in wb.worksheets:
        rows = [list(r) for r in ws.iter_rows(values_only=True)]
        row_count = len(rows)
        col_count = max((len(r) for r in rows), default=0)
        header = rows[0] if rows else []
        summary[ws.title] = {
            "rows": row_count,
            "cols": col_count,
            "header": header,
            "data": rows,
        }
    return summary


def main() -> None:
    summary = load_output()
    print(json.dumps(summary, ensure_ascii=False))


if __name__ == "__main__":
    main()

这里使用trae加载mcpserver,模型是gemini-3-flash-preview,

{
  "mcpServers": {
    "sink_mcp": {
      "command": "python",
      "args": [
        "d:\\xxx\\server.py"
      ],
      "env": {
        "PYTHONPATH": "d:\\xxx"
      }
    }
  }
}

然后创建智能体加载mcp,

测试

开始提问,trae会先利用mcp读取函数调用链,

之后会多批次上传函数内容分析是否存在相关漏洞,

输出结果,第一个为任意文件上传漏洞,

验证此恶意函数调用链确实存在任意文件上传,

第二个为代码生成下载,

此函数确实没有危害,我们询问大模型时可以让它忽略低危漏洞输出,

第三个相对安全,文件删除功能,

大模型说明得很清楚,这里只能控制id从数据库中获取路径再删除文件,并没有危害,

总结

此审计过程前半段利用tabby生成函数节点关系,利用Cypher编写恶意函数调用链查询语句,

后半段自定义mcp上传函数调用链每个节点的的代码片段然后分析是否真实存在漏洞,

优点是比全量ai代码审计效率高、token消耗少,缺点是准确率大部分依靠自定义的查询语句(查询出的恶意函数调用链)。

skill技能-分析漏洞利用链

在文章前半部分实现了一个类似功能的mcp,

此skill则是在mcp的基础上,完善一些功能。

主要功能:

读取output的恶意函数调用链,上传函数节点的代码片段,让模型分析是否真实存在漏洞。

完善功能:

1.函数调用链的最后一个节点sink不需要查找项目源码,因为此函数大概率是java原生代码,项目代码中没有。

2.源码项目在此工作组环境的根目录,需要提取用户的提示指定。

3.修复函数调用链分析不完全的情况。

4.优化上传代码内容,你首先需要保存output中的所有函数代码,并不是整个项目文件,只上传代码片段,并实现去重。

编写审计技能(skill)

在规则和技能处创建skill,导入skill.md,将server.py放在同一目录中,

技能描述,相当于提示词,

---
name: sink_skill
description: Java 应用恶意调用链分析工具。允许列出分析结果中的可用调用链,并检索特定链的详细上下文(源代码)以进行安全审计。同时记录分析日志和JSON数据。
---

# Sink 分析技能 (Sink Analysis Skill)

## 概述

本技能提供工具用于分析 `output.xlsx` 中识别出的恶意调用链。它通过提供调用顺序和相关类的源代码,帮助安全审计人员理解数据从源头 (Source) 到汇点 (Sink) 的流向。

**功能增强:**
- 自动记录所有分析请求到日志文件 (`sink_analysis.log`).
- 自动将每次分析的完整数据(包括源码)保存到 JSON 文件 (`chains_data.json`).
- 自动处理 `output.xlsx` 中的所有链,无需额外筛选。

## 工具

### 1. 列出所有调用链 (List All Chains)

列出 `output.xlsx` 中发现的所有调用链。每个链由行索引标识。

**用法:**

```python
# 调用 list_all_chains 工具
```

**输出:**
调用链列表,每一行代表一条链及其行索引。

### 2. 分析调用链 (Analyze Chain)

检索特定调用链的完整上下文,包括调用顺序和所有涉及类的源代码。
此操作会自动记录日志并更新 `chains_data.json`。

**用法:**

```python
# 调用 analyze_chain 工具,传入 row_index 和可选的 project_path
```

**参数:**
- `row_index`: 想要分析的链对应的行索引(通过 `list_all_chains` 获取)。
- `project_path`: (可选) 项目根目录名称,默认为 "springboot-manager-master"。

**输出:**
一个 JSON 对象,包含:
- `row_index`: 链的索引。
- `chain_sequence`: 方法调用的顺序序列。
- `involved_classes`: 一个字典,键为类名,值为源代码。
- `timestamp`: 分析时间戳。

### 3. 批量分析脚本 (Batch Analysis Script)

技能目录下提供了一个辅助脚本 `analyze_chains_script.py`,它直接调用技能的核心逻辑来批量分析所有发现的调用链。

**位置:** `.trae/skills/sink_skill/analyze_chains_script.py`

**功能:**
- 自动获取所有调用链列表。
- 遍历每一条链并执行详细分析。
- 将结果汇总并以 JSON 格式输出。
- 适用于无需 MCP 客户端即可直接运行分析的场景。

## 文件位置
- 技能代码: `.trae/skills/sink_skill/server.py`
- 日志文件: `.trae/skills/sink_skill/sink_analysis.log`
- 数据文件: `.trae/skills/sink_skill/chains_data.json`
- 辅助脚本: `.trae/skills/sink_skill/analyze_chains_script.py`

调用技能函数,

```python
import sys
import os
import json
import re
from pathlib import Path

# 获取当前脚本所在目录
current_dir = Path(__file__).resolve().parent
# 确保当前目录在 sys.path 中,以便导入同目录下的 server.py
if str(current_dir) not in sys.path:
    sys.path.append(str(current_dir))

try:
    # 直接导入实现函数,绕过 MCP 传输协议进行本地测试
    from server import _list_all_chains_impl, _analyze_chain_impl
except ImportError as e:
    print(f"从 server 导入函数失败: {e}")
    sys.exit(1)

def main():
    print("正在获取调用链列表...")
    chains = _list_all_chains_impl()
    
    if not chains:
        print("未找到任何调用链。")
        return

    print(f"找到 {len(chains)} 条调用链。")
    
    analysis_results = []
    
    # 遍历所有获取到的调用链摘要
    for chain_str in chains:
        print(f"正在处理: {chain_str}")
        
        # 解析行索引
        # 预期的格式为: "Row {i}: {chain}" 或 "行 {i}: {chain}"
        try:
            # 提取 ":" 之前的部分
            prefix = chain_str.split(":")[0]
            # 提取数字
            match = re.search(r'\d+', prefix)
            if match:
                row_idx = int(match.group())
            else:
                print(f"无法从 '{chain_str}' 解析行号")
                continue
            
            # 执行核心分析逻辑
            # 这里指定了项目路径为 'springboot-manager-master'
            result = _analyze_chain_impl(row_index=row_idx, project_path="springboot-manager-master")
            
            if "error" in result:
                print(f"分析行 {row_idx} 时出错: {result['error']}")
            else:
                analysis_results.append(result)
                print(f"成功分析行 {row_idx}")
                
        except Exception as e:
            print(f"处理调用链字符串 '{chain_str}' 时发生异常: {e}")

    # 以 JSON 格式打印完整结果,方便模型或用户查看
    print("\n--- 分析结果汇总 ---")
    # ensure_ascii=False 保证中文正常显示
    print(json.dumps(analysis_results, indent=2, ensure_ascii=False))

if __name__ == "__main__":
    main()

技能函数(读取output、上传内容等操作),

import sys
import os
import re
import json
import logging
import datetime
from pathlib import Path
from typing import Any, Dict, List, Optional
from fastmcp import FastMCP
import openpyxl

# 配置部分
CURRENT_DIR = Path(__file__).resolve().parent
# 路径逻辑:.trae/skills/sink_skill -> .trae/skills -> .trae -> 项目根目录
ROOT_DIR = CURRENT_DIR.parents[2]  
OUTPUT_FILE = ROOT_DIR / "output.xlsx"
# 默认源码根目录回退方案
DEFAULT_PROJECT_NAME = "springboot-manager-master"
LOG_FILE = CURRENT_DIR / "sink_analysis.log"
JSON_DATA_FILE = CURRENT_DIR / "chains_data.json"

# 初始化 FastMCP
mcp = FastMCP("SinkSkill")

# 设置日志系统
logging.basicConfig(
    filename=str(LOG_FILE),
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    encoding='utf-8'
)

def load_output_data() -> dict:
    """从 output.xlsx 加载数据"""
    if not OUTPUT_FILE.exists():
        return {"error": f"未找到文件: {OUTPUT_FILE}"}
    
    try:
        # data_only=True 获取公式计算后的值,read_only=True 提高读取效率
        wb = openpyxl.load_workbook(OUTPUT_FILE, data_only=True, read_only=True)
        summary = {}
        for ws in wb.worksheets:
            rows = [list(r) for r in ws.iter_rows(values_only=True)]
            summary[ws.title] = {
                "rows": len(rows),
                "data": rows
            }
        wb.close()
        return summary
    except Exception as e:
        return {"error": f"加载 Excel 失败: {str(e)}"}

def find_class_file(fqn: str, source_root: Path) -> Optional[Path]:
    """根据全限定名(FQN)定位 Java 文件"""
    parts = fqn.split(".")
    # 尝试直接匹配路径
    candidate = source_root.joinpath(*parts).with_suffix(".java")
    if candidate.exists():
        return candidate
    
    # 模糊匹配:处理内部类或非标准目录结构
    # 尝试查找与最后一部分名称匹配的文件(处理内部类 $ 符号)
    simple_name = parts[-1].split("$")[0] + ".java"
    for path in source_root.rglob(simple_name):
        try:
            # 读取前 1024 字节来查找 package 声明以进行校验
            with open(path, "r", encoding="utf-8", errors="ignore") as f:
                content_head = f.read(1024)
                # 检查包名是否匹配(排除类名后的部分)
                expected_pkg = ".".join(parts[:-1])
                if f"package {expected_pkg}" in content_head:
                    return path
        except Exception:
            continue
    return None

def extract_method_code(file_content: str, method_name: str) -> str:
    """
    从文件内容中提取方法代码片段。
    返回包含方法签名的代码体,若未找到则返回警告。
    """
    lines = file_content.splitlines()
    method_start_regex = re.compile(
        # 匹配模式: [修饰符] [类型] 方法名(
        # 例如: public void generatorCode(
        # 例如: protected List<Map<String, String>> queryColumns(
        fr"^\s*(?:public|protected|private|static|\s)*[\w<>\[\]\s]+\s+{re.escape(method_name)}\s*\(",
        re.MULTILINE
    )

    start_idx = -1
    is_abstract = False
    
    for i, line in enumerate(lines):
        if method_start_regex.search(line):
            # 检查是否为方法定义(后续行应包含 {)
            # 或者包含 ;(抽象方法或接口定义)
            has_brace = False
            has_semi = False
            for j in range(i, min(i + 10, len(lines))): # 向后查看 10 行
                if "{" in lines[j]:
                    has_brace = True
                    break
                if ";" in lines[j] and not has_brace: # 在找到大括号前先找到了分号
                    has_semi = True
                    break 
            
            if has_brace:
                start_idx = i
                break
            elif has_semi:
                # 抽象方法或接口方法
                start_idx = i
                is_abstract = True
                break
    
    if start_idx == -1:
        # 备选方案:尝试更宽松的正则搜索
        loose_regex = re.compile(fr"\s+{re.escape(method_name)}\s*\(")
        for i, line in enumerate(lines):
             if loose_regex.search(line) and "{" in line:
                 start_idx = i
                 break
        
        if start_idx == -1:
             return f"// 警告: 在源文件中未找到方法 '{method_name}'。\n// 显示文件前 20 行内容:\n" + "\n".join(lines[:20]) + "\n..."

    snippet_lines = []
    
    if is_abstract:
        # 提取直到分号为止
        for i in range(start_idx, len(lines)):
            line = lines[i]
            snippet_lines.append(line)
            if ";" in line:
                break
    else:
        # 通过计算大括号成对匹配来提取方法体
        brace_count = 0
        in_method = False
        
        for i in range(start_idx, len(lines)):
            line = lines[i]
            snippet_lines.append(line)
            brace_count += line.count("{")
            brace_count -= line.count("}")
            
            if brace_count > 0:
                in_method = True
            
            # 当进入方法后大括号计数归零,表示方法结束
            if in_method and brace_count == 0:
                break
            
    return "\n".join(snippet_lines)

def update_json_record(record: Dict[str, Any]):
    """使用新的调用链分析数据更新 JSON 记录文件"""
    data = []
    if JSON_DATA_FILE.exists():
        try:
            with open(JSON_DATA_FILE, "r", encoding="utf-8") as f:
                data = json.load(f)
        except Exception:
            data = []
    
    # 检查该行索引的记录是否已存在,存在则更新,不存在则添加
    row_index = record.get("row_index")
    existing_idx = -1
    for i, item in enumerate(data):
        if item.get("row_index") == row_index:
            existing_idx = i
            break
    
    if existing_idx >= 0:
        data[existing_idx] = record
    else:
        data.append(record)
        
    with open(JSON_DATA_FILE, "w", encoding="utf-8") as f:
        json.dump(data, f, ensure_ascii=False, indent=2)

def _list_all_chains_impl() -> List[str]:
    """list_all_chains 的具体实现逻辑"""
    summary = load_output_data()
    if "error" in summary:
        return [summary["error"]]
    
    first_sheet_name = list(summary.keys())[0]
    sheet_data = summary.get(first_sheet_name, {}).get("data", [])
    
    chains = []
    for i, row in enumerate(sheet_data):
        # 过滤空单元格并拼接调用链
        chain_str = " -> ".join([str(c) for c in row if c])
        if chain_str:
            chains.append(f"行 {i}: {chain_str}")
    return chains

def _analyze_chain_impl(row_index: int, project_path: str = None) -> Dict[str, Any]:
    """analyze_chain 的具体实现逻辑"""
    # 1. 记录请求日志
    logging.info(f"请求分析调用链 - 行索引: {row_index}, 项目路径: {project_path}")
    
    # 确定源码根目录
    # 如果提供了 project_path,则使用相对于 ROOT_DIR 的路径
    # 否则使用默认的 DEFAULT_PROJECT_NAME
    # 按照标准约定追加 "src/main/java"
    
    proj_name = project_path if project_path else DEFAULT_PROJECT_NAME
    source_root = ROOT_DIR / proj_name / "src" / "main" / "java"
    
    if not source_root.exists():
        # 备选方案:检查用户提供的是否是全路径或仅项目根目录
        alt_root = ROOT_DIR / proj_name
        if alt_root.exists():
             if (alt_root / "src" / "main" / "java").exists():
                 source_root = alt_root / "src" / "main" / "java"
             else:
                 # 如果找不到标准的 src/main/java,则尝试将项目根目录视为源码目录
                 logging.warning(f"在 {source_root} 未找到标准源码布局,尝试使用 {alt_root}")
                 source_root = alt_root
        else:
            return {"error": f"未找到源码目录: {source_root}"}

    # 2. 加载数据
    summary = load_output_data()
    if "error" in summary:
        msg = summary["error"]
        logging.error(msg)
        return {"error": msg}
        
    first_sheet_name = list(summary.keys())[0]
    sheet_data = summary.get(first_sheet_name, {}).get("data", [])
    
    if row_index < 0 or row_index >= len(sheet_data):
        msg = f"行索引 {row_index} 超出范围"
        logging.error(msg)
        return {"error": msg}
        
    row_data = sheet_data[row_index]
    raw_chain = [str(c) for c in row_data if c]
    chain_str = " -> ".join(raw_chain)
    
    # 3. 检索源代码
    # 根据需求跳过最后一个节点 (Sink)
    nodes_to_analyze = raw_chain[:-1]
    
    involved_classes = {}
    
    for cell in nodes_to_analyze:
        method_name = None
        fqn = None
        
        # 格式 1: method(class.fqn)
        match1 = re.match(r"([\w<>]+)\(([\w\.]+)\)", cell)
        if match1:
            method_name, fqn = match1.groups()
        
        # 格式 2: class.fqn#method
        if not method_name:
             match2 = re.match(r"([\w\.]+)[#\.]([\w<>]+)", cell)
             if match2:
                 fqn, method_name = match2.groups()
        
        if fqn and method_name:
            if fqn not in involved_classes:
                file_path = find_class_file(fqn, source_root)
                if file_path:
                    try:
                        full_code = file_path.read_text(encoding="utf-8")
                        snippet = extract_method_code(full_code, method_name)
                        involved_classes[fqn] = snippet
                    except Exception as e:
                        involved_classes[fqn] = f"// 读取文件失败: {str(e)}"
                else:
                    involved_classes[fqn] = "// 项目中未找到源文件"
            else:
                # 类已存在。检查是否需要添加另一个方法的片段。
                current_snippets = involved_classes[fqn]
                if f" {method_name}(" not in current_snippets: # 简单检查方法是否已存在
                     file_path = find_class_file(fqn, source_root)
                     if file_path:
                        try:
                            full_code = file_path.read_text(encoding="utf-8")
                            new_snippet = extract_method_code(full_code, method_name)
                            # 避免重复添加相同的代码片段
                            if new_snippet not in current_snippets:
                                involved_classes[fqn] = current_snippets + "\n\n" + new_snippet
                        except Exception:
                            pass

    # 4. 构建结果对象
    result = {
        "row_index": row_index,
        "chain_sequence": chain_str,
        "involved_classes": involved_classes,
        "timestamp": datetime.datetime.now().isoformat()
    }
    
    # 5. 保存到 JSON 文件
    try:
        update_json_record(result)
        logging.info(f"成功将行 {row_index} 的分析数据保存至 {JSON_DATA_FILE}")
    except Exception as e:
        logging.error(f"保存 JSON 数据失败: {str(e)}")
    
    return result

@mcp.tool()
def list_all_chains() -> List[str]:
    """列出 output.xlsx 中所有的调用链摘要"""
    return _list_all_chains_impl()

@mcp.tool()
def analyze_chain(row_index: int, project_path: str = "springboot-manager-master") -> Dict[str, Any]:
    """
    分析特定的调用链。
    - 检索链的详细信息和源代码(仅提取方法片段)。
    - 记录分析日志。
    - 将分析结果持久化到 JSON 文件。
    
    参数:
        row_index: output.xlsx 中的调用链索引行号。
        project_path: 项目根目录的相对路径(需包含 src/main/java 结构)。
                      默认为 'springboot-manager-master'。
    """
    return _analyze_chain_impl(row_index, project_path)

if __name__ == "__main__":
    mcp.run()

使用效果

首先会调用技能,然后读取outline的函数调用链,

然后将函数调用链的函数代码片段上传给模型分析是否存在漏洞,

与之前的mcp对比,这里新发现了一个可能造成模板注入的链子,

这是因此此skill修复了函数调用链分析不完全的bug,

函数调用链的函数内容记录正常,

日志记录功能正常,

总结:

功能与mcp大致一样,但还是存在不一样的点,

skill 是直接在 IDE 里通过 Python 脚本执行相关操作。

mcp是启动了一个 FastMCP 服务,AI 通过协议发指令,后台还是跑同样的 Python 代码。