自定义MCP&skill技能分析漏洞利用链
本文提出 Tabby + Neo4j + LLM 的 Java 漏洞利用链分析方案:先用 Tabby 生成函数调用图,Cypher 查询恶意调用链;再通过自定义 MCP/Skill 上传源码片段至 LLM 分析参数可控性。
环境:
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 代码。
结合Tabby静态分析、Neo4j图谱查询与MCP服务调用大模型,实现Spring MVC项目恶意函数调用链的高效精准审计。
由 AI 根据全文自动生成,仅供参考,以原文为准