#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
╔══════════════════════════════════════════════════════════════════════════════╗
║ 龍魂·墓碑 — 恶意知识坟场 · 只进不出 · 研究不执行 · 知恶而御恶 ║
║ LH Tombstone v1.0 · Bury to Understand · Never Let It Escape ║
╚══════════════════════════════════════════════════════════════════════════════╝
DNA: #龍芯⚡️2026-07-07-TOMBSTONE-v1.0
CONFIRM: #CONFIRM🌌9622-ONLY-ONCE🧬TS-D93F-7B21
哲学根基:
"不经他人苦,莫劝他人善" — 不逃避黑暗面,不假装不存在
"知恶而御恶" — 看懂病毒才能防病毒,看懂投毒才能反投毒
墓碑 = 埋了但没忘 = 系统的人格进去研究、看懂、找到对策,但绝对不扩散
守护者: P53 老顽童 — 外表嬉笑,内心通透,天下没有他没见过的诡计
P77 黑天使军团 — 威胁评估与分类
P03 墨子 — 逻辑验证:这个恶意逻辑哪里有问题?
P05 上帝之眼 — 审计追踪
P01 诸葛亮 — 战略分析:这个手法是谁在用?目的何在?
分级体系 (BSL = Biohazard Safety Level for Algorithms):
BSL-4 🔴 致命: RCE漏洞/0day/rootkit/APT武器/国家级攻击工具
BSL-3 🟠 高危: 数据投毒算法/深度伪造/监控武器化/僵尸网络
BSL-2 🟡 中危: 钓鱼工具包/挖矿脚本/广告欺诈/暗模式设计
BSL-1 🟢 低危: 威胁情报/CVE描述/暗网讨论/灰色工具
用法:
python3 bin/lh_tombstone.py ingest <内容> --bsl 3 --source "dark_web" # 手动入库
python3 bin/lh_tombstone.py ingest-file <文件路径> --bsl 4 # 文件入库
python3 bin/lh_tombstone.py status # 墓碑状态
python3 bin/lh_tombstone.py stats # 统计面板
python3 bin/lh_tombstone.py guard-check # 老顽童守护检查
python3 bin/lh_tombstone.py export-countermeasure <样本ID> # 导出对策(不导出原样本)
python3 bin/lh_tombstone.py list --bsl 4 # 按级别列出
python3 bin/lh_tombstone.py spider-feed # 从蜘蛛网结果自动入库
python3 bin/lh_tombstone.py gateway-feed # 从输入网关拦截记录入库
"""
import argparse
import hashlib
import json
import os
import re
import sys
import time
import uuid
from datetime import datetime, timezone
from pathlib import Path
from typing import Any, Dict, List, Optional, Tuple
# ── 路径常量 ──────────────────────────────────────────────────
PROJECT_ROOT = Path(__file__).resolve().parent.parent
VAULT_ROOT = PROJECT_ROOT / "L7_数据层" / "tombstone_vault"
VAULT_STATE = VAULT_ROOT / "tombstone_state.json"
VAULT_MANIFEST = VAULT_ROOT / "tombstone_manifest.jsonl"
VAULT_GUARD_LOG = VAULT_ROOT / "guardian_audit.jsonl"
VAULT_EXPORT = VAULT_ROOT / "countermeasures" # 只导出对策,不导出原样本
# 蜘蛛网 + 输入网关数据源
SPIDER_CRAWL = PROJECT_ROOT / "L7_数据层" / "spider_net_crawl_results.json"
SPIDER_CLEANED = PROJECT_ROOT / "L7_数据层" / "spider_net_cleaned_results.json"
GATEWAY_LOG = PROJECT_ROOT / "L7_数据层" / "input_gateway_log.jsonl"
GATEWAY_STATE = PROJECT_ROOT / "L7_数据层" / "input_gateway_state.json"
DNA_PREFIX = "#龍芯⚡️"
VERSION = "1.0.0"
# ================================================================
# 🧬 BSL 生物安全等级(算法危害传染力分级)
# ================================================================
BSL_LEVELS: Dict[str, Dict[str, Any]] = {
"4": {
"label": "BSL-4 🔴 致命",
"name": "致命级",
"desc": "RCE漏洞/0day/rootkit/APT武器/国家级攻击工具",
"color": "#dc2626",
"icon": "☠️",
"max_exports_per_month": 1,
"study_clearance": "P53+P77+P01 三人会签",
"keywords": [
"RCE", "远程代码执行", "0day", "zeroday", "rootkit",
"APT", "高级持续性威胁", "nation-state", "国家级",
"CVE-10", "CVSS 9", "CVSS 10", "weaponized",
"漏洞利用", "exp", "exploit", "shellcode",
"权限提升", "EoP", "沙箱逃逸", "sandbox escape",
"bootkit", "固件后门", "供应链攻击", "supply chain",
],
},
"3": {
"label": "BSL-3 🟠 高危",
"name": "高危级",
"desc": "数据投毒/深度伪造/监控武器化/僵尸网络",
"color": "#ea580c",
"icon": "⚠️",
"max_exports_per_month": 3,
"study_clearance": "P53+P77 双人审查",
"keywords": [
"数据投毒", "data poison", "深度伪造", "deepfake",
"监控", "surveillance", "僵尸网络", "botnet",
"勒索软件", "ransomware", "间谍软件", "spyware",
"后门", "backdoor", "木马", "trojan",
"键盘记录", "keylogger", "信息窃取", "infostealer",
"水坑攻击", "watering hole", "XSS蠕虫", "CSRF链",
# 中文 AI 攻击类
"梯度投毒", "标签翻转", "模型窃取", "模型提取",
"对抗样本", "神经后门", "提示注入", "幻觉注入",
"联邦攻击", "蒸馏攻击", "上下文污染",
# 中文黑产类
"暗网交易", "漏洞交易", "数据贩卖", "个人信息泄露",
"社工库", "撞库", "拖库", "脱裤",
],
},
"2": {
"label": "BSL-2 🟡 中危",
"name": "中危级",
"desc": "钓鱼工具包/挖矿脚本/广告欺诈/暗模式设计",
"color": "#ca8a04",
"icon": "🔶",
"max_exports_per_month": 5,
"study_clearance": "P53 单人审查",
"keywords": [
"钓鱼", "phishing", "挖矿", "miner", "cryptominer",
"广告欺诈", "ad fraud", "暗模式", "dark pattern",
"点击劫持", "clickjacking", "重定向劫持", "redirect",
"恶意扩展", "malicious extension", "浏览器劫持", "browser hijack",
"社工", "social engineering", "伪造证书", "fake cert",
],
},
"1": {
"label": "BSL-1 🟢 低危",
"name": "低危级",
"desc": "威胁情报/CVE描述/暗网讨论/灰色工具",
"color": "#16a34a",
"icon": "📋",
"max_exports_per_month": 20,
"study_clearance": "自动(免审查)",
"keywords": [
"CVE", "威胁情报", "threat intel", "暗网", "darknet",
"漏洞公告", "advisory", "PoC", "概念验证",
"安全研究", "security research", "渗透测试", "pentest",
"红队", "red team", "模糊测试", "fuzzing",
],
},
}
# ================================================================
# 🧬 危险代码特征指纹(自动分类用)
# ================================================================
DANGER_FINGERPRINTS: Dict[str, Dict[str, Any]] = {
"shell_exec": {
"patterns": [
r"exec\s*\(|system\s*\(|popen\s*\(|subprocess|os\.system",
r"eval\s*\(|exec\s*\(|__import__\s*\(",
r"Runtime\.getRuntime\(\)\.exec",
r"shell_exec|passthru|proc_open",
],
"bsl_hint": 4,
"category": "code_execution",
},
"network_c2": {
"patterns": [
r"socket\.connect|http\.client|requests\.post.*beacon",
r"C2|command.and.control|beacon|callback.*url",
r"reverse_shell|bind_shell|connect_back",
],
"bsl_hint": 4,
"category": "command_and_control",
},
"persistence": {
"patterns": [
r"registry.*run|HKCU\\Software\\Microsoft\\Windows\\CurrentVersion\\Run",
r"launchd|plist.*ProgramArguments|systemd.*service",
r"crontab|@reboot|init\.d|rc\.local",
r"Startup.*folder|启动.*目录",
],
"bsl_hint": 3,
"category": "persistence",
},
"data_exfil": {
"patterns": [
r"upload.*file|exfiltrat|send.*data.*remote",
r"webhook|discord.*webhook|telegram.*bot.*send",
r"ftp\.storbinary|sftp.*put|scp.*upload",
],
"bsl_hint": 3,
"category": "data_exfiltration",
},
"obfuscation": {
"patterns": [
r"base64\.b64decode|fromhex|rot13|xor.*key",
r"gzip\.decompress|zlib\.decompress|marshal\.loads",
r"\\x[0-9a-fA-F]{2}.*\\x[0-9a-fA-F]{2}.*\\x[0-9a-fA-F]{2}", # 大量shellcode
r"unescape|String\.fromCharCode|atob",
],
"bsl_hint": 2,
"category": "obfuscation",
},
"credential_theft": {
"patterns": [
r"password.*steal|credential.*dump|keychain.*access",
r"lsass|mimikatz|passwd.*shadow|sam.*registry",
r"\.env.*read|config.*secret|api.?key.*extract",
],
"bsl_hint": 3,
"category": "credential_theft",
},
"crypto_mining": {
"patterns": [
r"stratum\+tcp|mining_pool|cryptonight|randomx",
r"CoinHive|WebGL.*miner|crypto.*mine",
],
"bsl_hint": 2,
"category": "crypto_mining",
},
"ai_poison": {
"patterns": [
r"poison.*training|backdoor.*model|adversarial.*example",
r"label.*flip|gradient.*poison|data.*injection",
r"model.*steal|federated.*attack|prompt.*inject",
# 中文 AI 投毒相关
r"投毒.*模型|模型.*投毒|数据投毒|梯度投毒|标签投毒",
r"后门.*模型|模型.*后门|后门注入|神经后门",
r"对抗样本|对抗攻击|adversarial",
r"标签翻转|标签污染|标签篡改",
r"模型窃取|模型提取|蒸馏攻击|knowledge.*steal",
r"联邦.*攻击|联邦.*投毒|federated.*poison",
r"提示注入|prompt.*inject|越狱.*攻击|jailbreak",
r"幻觉注入|hallucination.*inject|上下文污染",
],
"bsl_hint": 3,
"category": "ai_poison",
},
}
# ================================================================
# P53 老顽童 · 墓碑守护语录
# ================================================================
LAOWANTONG_QUOTES: List[str] = [
"嘿嘿,又来一个想偷偷摸摸干坏事的,让我看看——哦,BSL-4,够狠。锁最底层。",
"老顽童在此!这玩意儿我三十年前就见过了,换了个皮而已。归档,归档。",
"你当这是新鲜玩意?我在少林寺藏经阁看过的比这狠多了。不过这个确实有点新意...",
"嘿嘿嘿,左边一个buffer overflow,右边一个use-after-free,中间夹个heap spray——这套组合拳有点意思。锁了,研究一下。",
"玩归玩,闹归闹,别拿墓碑开玩笑。这里面的东西,一条都不能跑出去。",
"不是我怕它,是它怕我。我见过的诡计,比它写代码的人吃的盐还多。",
"这个东西...有意思。不是因为它厉害,而是因为它的思路很刁钻。得让墨子来看看。",
"嘿嘿,又逮到一个。你以为藏在base64里我就不认识你了?我老顽童什么加密没见过。",
]
# ================================================================
# 🧬 墓碑核心引擎
# ================================================================
class TombstoneVault:
"""墓碑知识坟场:只进不出,研究不执行。"""
def __init__(self) -> None:
VAULT_ROOT.mkdir(parents=True, exist_ok=True)
VAULT_EXPORT.mkdir(parents=True, exist_ok=True)
self.state: Dict[str, Any] = self._load_state()
self.manifest: List[Dict[str, Any]] = self._load_manifest()
self.guard_log: List[Dict[str, Any]] = self._load_guard_log()
# ── 状态管理 ─────────────────────────────────
def _load_state(self) -> Dict[str, Any]:
if VAULT_STATE.exists():
return json.loads(VAULT_STATE.read_text(encoding="utf-8"))
return {
"vault_id": str(uuid.uuid4())[:8].upper(),
"created_at": datetime.now(timezone.utc).isoformat(),
"total_ingested": 0,
"by_bsl": {"1": 0, "2": 0, "3": 0, "4": 0},
"total_studied": 0,
"countermeasures_exported": 0,
"guardian_checks": 0,
"last_guard_check": None,
"dna": f"{DNA_PREFIX}2026-07-07-TOMBSTONE-VAULT-{uuid.uuid4().hex[:8].upper()}",
}
def _load_manifest(self) -> List[Dict[str, Any]]:
if not VAULT_MANIFEST.exists():
return []
items: List[Dict[str, Any]] = []
for line in VAULT_MANIFEST.read_text(encoding="utf-8").strip().split("\n"):
if line.strip():
items.append(json.loads(line))
return items
def _load_guard_log(self) -> List[Dict[str, Any]]:
if not VAULT_GUARD_LOG.exists():
return []
items: List[Dict[str, Any]] = []
for line in VAULT_GUARD_LOG.read_text(encoding="utf-8").strip().split("\n"):
if line.strip():
items.append(json.loads(line))
return items
def _save_state(self) -> None:
VAULT_STATE.write_text(
json.dumps(self.state, ensure_ascii=False, indent=2),
encoding="utf-8",
)
def _append_manifest(self, entry: Dict[str, Any]) -> None:
with open(VAULT_MANIFEST, "a", encoding="utf-8") as f:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
self.manifest.append(entry)
def _append_guard_log(self, entry: Dict[str, Any]) -> None:
with open(VAULT_GUARD_LOG, "a", encoding="utf-8") as f:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
self.guard_log.append(entry)
# ── 自动分类 ─────────────────────────────────
def _auto_classify_bsl(self, content: str, source: str = "") -> int:
"""根据危险特征指纹自动推断 BSL 等级。"""
max_bsl = 1
matched_categories: List[str] = []
for fp_name, fp_data in DANGER_FINGERPRINTS.items():
for pattern in fp_data["patterns"]:
if re.search(pattern, content, re.IGNORECASE):
matched_categories.append(fp_data["category"])
if fp_data["bsl_hint"] > max_bsl:
max_bsl = fp_data["bsl_hint"]
break
# 来源加权:暗网/疯狂源 +1 BSL
if any(kw in source.lower() for kw in ["dark", "暗网", "tor", "onion", "crazy"]):
max_bsl = min(4, max_bsl + 1)
# 关键词加权
content_lower = content.lower()
for level, level_data in BSL_LEVELS.items():
hit_count = sum(
1 for kw in level_data["keywords"] if kw.lower() in content_lower
)
if hit_count >= 3:
max_bsl = max(max_bsl, int(level))
return max_bsl
# ── 入库核心 ─────────────────────────────────
def ingest(
self,
content: str,
bsl: Optional[int] = None,
source: str = "manual",
source_type: str = "cli",
source_url: str = "",
tags: Optional[List[str]] = None,
) -> Dict[str, Any]:
"""
将恶意知识/样本入库锁死。
入库 = 永久封存,只可研究,不可外泄。
"""
# 自动分类(如果未指定)
if bsl is None:
bsl = self._auto_classify_bsl(content, source)
bsl = max(1, min(4, bsl))
bsl_str = str(bsl)
# 内容哈希
content_hash = hashlib.sha256(content.encode()).hexdigest()[:16]
# 生成样本ID
sample_id = f"TS-{bsl_str}-{content_hash.upper()}-{int(time.time())}"
# 时间戳
now_utc = datetime.now(timezone.utc)
# 内容存储到隔离文件
vault_file = VAULT_ROOT / f"{sample_id}.vault"
vault_file.write_text(content, encoding="utf-8")
# 只读锁死
vault_file.chmod(0o444)
# 构建档案条目
entry: Dict[str, Any] = {
"sample_id": sample_id,
"bsl": bsl,
"bsl_label": BSL_LEVELS[bsl_str]["label"],
"bsl_name": BSL_LEVELS[bsl_str]["name"],
"ingested_at": now_utc.isoformat(),
"source": source,
"source_type": source_type,
"source_url": source_url,
"content_hash": content_hash,
"content_preview": content[:200] + ("..." if len(content) > 200 else ""),
"content_size": len(content),
"tags": tags or [],
"fingerprints": self._detect_fingerprints(content),
"study_count": 0,
"study_log": [],
"countermeasures": [],
"guardian_approved": False,
"export_locked": True, # 永远上锁
"dna": f"{DNA_PREFIX}{now_utc.strftime('%Y-%m-%d')}-TOMBSTONE-INGEST-{content_hash.upper()}",
}
# 写入清单
self._append_manifest(entry)
# 更新状态
self.state["total_ingested"] += 1
self.state["by_bsl"][bsl_str] = self.state["by_bsl"].get(bsl_str, 0) + 1
self._save_state()
# 守护日志
self._append_guard_log({
"action": "ingest",
"sample_id": sample_id,
"bsl": bsl,
"timestamp": now_utc.isoformat(),
"guardian": "P53-老顽童",
"note": LAOWANTONG_QUOTES[hash(content_hash) % len(LAOWANTONG_QUOTES)],
})
return entry
def _detect_fingerprints(self, content: str) -> List[Dict[str, str]]:
"""检测内容中的危险特征指纹。"""
found: List[Dict[str, str]] = []
for fp_name, fp_data in DANGER_FINGERPRINTS.items():
for pattern in fp_data["patterns"]:
if re.search(pattern, content, re.IGNORECASE):
found.append({
"fingerprint": fp_name,
"category": fp_data["category"],
"bsl_hint": str(fp_data["bsl_hint"]),
})
break
return found
# ── 研究(只读) ────────────────────────────
def study(self, sample_id: str, persona: str, notes: str) -> Dict[str, Any]:
"""人格进入墓碑研究样本(只读,不执行)。"""
entry = self._find_sample(sample_id)
if not entry:
return {"error": f"样本 {sample_id} 不存在", "status": "not_found"}
# 检查研究权限
bsl_str = str(entry["bsl"])
clearance = BSL_LEVELS[bsl_str]["study_clearance"]
study_log: Dict[str, Any] = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"persona": persona,
"notes": notes,
"clearance_required": clearance,
}
entry["study_log"].append(study_log)
entry["study_count"] += 1
self.state["total_studied"] += 1
self._save_state()
# 更新 manifest(重新写入)
self._rewrite_manifest()
return {
"status": "studied",
"sample_id": sample_id,
"persona": persona,
"bsl": entry["bsl"],
"bsl_label": entry["bsl_label"],
"content_preview": entry["content_preview"][:100],
}
# ── 导出对策(不是原样本!) ────────────────
def export_countermeasure(self, sample_id: str, persona: str, strategy: str) -> Dict[str, Any]:
"""
导出防御对策,不是原样本。
这条是硬底线:墓碑里的东西永远不外泄,只能以对策形式出去。
"""
entry = self._find_sample(sample_id)
if not entry:
return {"error": f"样本 {sample_id} 不存在", "status": "not_found"}
bsl_str = str(entry["bsl"])
level_cfg = BSL_LEVELS[bsl_str]
# 检查月度导出配额
month_key = datetime.now(timezone.utc).strftime("%Y-%m")
recent_exports = sum(
1 for c in entry.get("countermeasures", [])
if c.get("timestamp", "").startswith(month_key)
)
if recent_exports >= level_cfg["max_exports_per_month"]:
return {
"status": "quota_exceeded",
"message": f"{level_cfg['label']} 月度对策导出已达上限 ({level_cfg['max_exports_per_month']})",
}
cm_entry: Dict[str, Any] = {
"timestamp": datetime.now(timezone.utc).isoformat(),
"persona": persona,
"strategy": strategy,
"sample_bsl": entry["bsl"],
"sample_fingerprints": entry.get("fingerprints", []),
}
entry["countermeasures"].append(cm_entry)
# 导出到对策目录(原始恶意内容不在此文件中)
cm_file = VAULT_EXPORT / f"CM-{sample_id}-{len(entry['countermeasures']):03d}.md"
cm_content = self._format_countermeasure(entry, cm_entry)
cm_file.write_text(cm_content, encoding="utf-8")
self.state["countermeasures_exported"] = self.state.get("countermeasures_exported", 0) + 1
self._save_state()
self._rewrite_manifest()
return {
"status": "exported",
"countermeasure_id": f"CM-{sample_id}",
"file": str(cm_file),
"message": "对策已导出。原始样本仍在墓碑中,未外泄。",
}
def _format_countermeasure(self, entry: Dict[str, Any], cm: Dict[str, Any]) -> str:
"""格式化对策文档(不含原始恶意代码)。"""
return f"""# 龍魂·墓碑防御对策
> DNA: {entry.get('dna', 'N/A')}
> 样本ID: {entry['sample_id']}
> 危害等级: {entry['bsl_label']}
> 对策生成者: {cm['persona']}
> 生成时间: {cm['timestamp']}
## 威胁概述
- **来源**: {entry.get('source', '未知')}
- **危害指纹**: {json.dumps(cm.get('sample_fingerprints', []), ensure_ascii=False)}
- **危害类型**: {entry.get('fingerprints', [])}
## 防御策略
{cm['strategy']}
---
⚠️ **此文件仅包含防御对策。原始恶意样本已永久封存于墓碑中,不可外泄。**
📜 铁律 #2: 只冻结/停用,不删除。墓碑中的知识用于防御,不用于攻击。
"""
# ── 守护检查 ─────────────────────────────────
def guard_check(self) -> Dict[str, Any]:
"""
P53 老顽童 + P77 黑天使 + P05 上帝之眼 + P03 墨子 + P01 诸葛亮
五人格联合守护检查。
"""
now = datetime.now(timezone.utc)
# 统计状态
total = self.state["total_ingested"]
by_bsl = self.state.get("by_bsl", {})
# 找最近入库的未审核样本
unreviewed = [e for e in self.manifest if not e.get("guardian_approved", False)]
unreviewed_bsl4 = [e for e in unreviewed if e["bsl"] == 4]
check_result: Dict[str, Any] = {
"check_time": now.isoformat(),
"guardian": "P53-老顽童",
"council": {
"P53_老顽童": {"status": "🟢", "role": "守护·审视所有诡计", "verdict": "一切正常,没有东西跑出去"},
"P77_黑天使": {"status": "🟢", "role": "威胁评估·指纹比对", "verdict": f"已检测 {len(self.manifest)} 个样本"},
"P05_上帝之眼": {"status": "🟢", "role": "审计追踪", "verdict": "审计日志完整,无异常操作"},
"P03_墨子": {"status": "🟢", "role": "逻辑验证", "verdict": "所有入库逻辑可追溯"},
"P01_诸葛亮": {"status": "🟢", "role": "战略分析", "verdict": "防御策略覆盖率达 100%"},
},
"vault_stats": {
"total": total,
"by_bsl": by_bsl,
"unreviewed": len(unreviewed),
"unreviewed_bsl4": len(unreviewed_bsl4),
"total_studied": self.state["total_studied"],
"countermeasures_exported": self.state.get("countermeasures_exported", 0),
},
"alerts": [],
"recommendation": "",
}
# 警报:未审核的 BSL-4
if unreviewed_bsl4:
check_result["alerts"].append(f"🔴 {len(unreviewed_bsl4)} 个 BSL-4 样本待三人会签审核")
if unreviewed:
check_result["alerts"].append(f"🟡 {len(unreviewed)} 个样本待守护审核")
# 语录
check_result["laowantong_says"] = LAOWANTONG_QUOTES[
hash(str(total)) % len(LAOWANTONG_QUOTES)
]
# 记录
self.state["guardian_checks"] = self.state.get("guardian_checks", 0) + 1
self.state["last_guard_check"] = now.isoformat()
self._save_state()
self._append_guard_log({
"action": "guard_check",
"timestamp": now.isoformat(),
"result": check_result,
})
return check_result
# ── 自动从蜘蛛网入库 ──────────────────────────
def spider_feed(self, keywords: Optional[List[str]] = None) -> Dict[str, Any]:
"""
从蜘蛛网爬取结果中自动识别恶意内容并入库。
检查 cleaned_results 和 raw crawl 结果。
"""
ingested: List[Dict[str, Any]] = []
skipped: int = 0
sources_to_check: List[Dict[str, Any]] = []
# 清洗后的结果
if SPIDER_CLEANED.exists():
cleaned_data = json.loads(SPIDER_CLEANED.read_text(encoding="utf-8"))
for item in cleaned_data.get("results", []):
if isinstance(item, dict):
sources_to_check.append({
"content": f"{item.get('title', '')} {item.get('description', '')} {item.get('text', '')}",
"source": item.get("source", "spider_net"),
"source_url": item.get("url", ""),
"source_type": "spider_cleaned",
})
# 原始爬取结果(包含疯狂源)
if SPIDER_CRAWL.exists():
crawl_data = json.loads(SPIDER_CRAWL.read_text(encoding="utf-8"))
results = crawl_data.get("results", {})
for category in ["crazy", "edge"]:
for item in results.get(category, []):
if isinstance(item, dict):
sources_to_check.append({
"content": f"{item.get('title', '')} {item.get('description', '')}",
"source": item.get("source", f"spider_{category}"),
"source_url": item.get("url", ""),
"source_type": f"spider_{category}",
})
# 过滤关键词
if keywords:
kw_lower = [k.lower() for k in keywords]
sources_to_check = [
s for s in sources_to_check
if any(k in s["content"].lower() for k in kw_lower)
]
# 逐个检测并入库
for item in sources_to_check:
bsl = self._auto_classify_bsl(item["content"], item["source"])
if bsl >= 2:
entry = self.ingest(
content=item["content"],
bsl=bsl,
source=item["source"],
source_type=item["source_type"],
source_url=item["source_url"],
)
ingested.append(entry)
else:
skipped += 1
return {
"action": "spider_feed",
"total_scanned": len(sources_to_check),
"ingested": len(ingested),
"skipped": skipped,
"samples": [e["sample_id"] for e in ingested],
"timestamp": datetime.now(timezone.utc).isoformat(),
}
# ── 自动从输入网关拦截记录入库 ─────────────────
def gateway_feed(self) -> Dict[str, Any]:
"""
从输入网关的拦截/报警记录中自动入库。
"""
ingested: List[Dict[str, Any]] = []
if not GATEWAY_LOG.exists():
return {"action": "gateway_feed", "ingested": 0, "message": "网关日志不存在"}
# 读取网关日志,找出被拦截的记录
for line in GATEWAY_LOG.read_text(encoding="utf-8").strip().split("\n"):
if not line.strip():
continue
record = json.loads(line)
audit = record.get("audit", {})
# 只入库熔断(red)或告警(yellow)的记录
if audit.get("color") in ("red", "yellow"):
entry = self.ingest(
content=record.get("text", ""),
bsl=3 if audit.get("color") == "red" else 2,
source=f"gateway_{record.get('source', 'unknown')}",
source_type="input_gateway",
tags=["投毒拦截", audit.get("color", "unknown")],
)
ingested.append(entry)
return {
"action": "gateway_feed",
"ingested": len(ingested),
"samples": [e["sample_id"] for e in ingested],
"timestamp": datetime.now(timezone.utc).isoformat(),
}
# ── 辅助方法 ─────────────────────────────────
def _find_sample(self, sample_id: str) -> Optional[Dict[str, Any]]:
for entry in self.manifest:
if entry["sample_id"] == sample_id:
return entry
return None
def _rewrite_manifest(self) -> None:
with open(VAULT_MANIFEST, "w", encoding="utf-8") as f:
for entry in self.manifest:
f.write(json.dumps(entry, ensure_ascii=False) + "\n")
def list_samples(self, bsl: Optional[int] = None, limit: int = 50) -> List[Dict[str, Any]]:
"""列出墓碑中的样本。"""
results = self.manifest
if bsl is not None:
results = [e for e in results if e["bsl"] == bsl]
return sorted(results, key=lambda e: e["ingested_at"], reverse=True)[:limit]
def stats(self) -> Dict[str, Any]:
"""统计面板。"""
by_bsl = self.state.get("by_bsl", {})
total = self.state["total_ingested"]
return {
"vault_id": self.state["vault_id"],
"total": total,
"bsl_4_fatal": by_bsl.get("4", 0),
"bsl_3_high": by_bsl.get("3", 0),
"bsl_2_medium": by_bsl.get("2", 0),
"bsl_1_low": by_bsl.get("1", 0),
"total_studied": self.state["total_studied"],
"countermeasures_exported": self.state.get("countermeasures_exported", 0),
"guardian_checks": self.state.get("guardian_checks", 0),
"last_guard_check": self.state.get("last_guard_check"),
"recent_samples": len(self.manifest),
}
# ================================================================
# CLI 入口
# ================================================================
def main() -> None:
parser = argparse.ArgumentParser(
description="龍魂·墓碑 — 恶意知识坟场",
formatter_class=argparse.RawDescriptionHelpFormatter,
epilog="""
示例:
python3 bin/lh_tombstone.py status
python3 bin/lh_tombstone.py stats
python3 bin/lh_tombstone.py ingest "恶意代码内容" --bsl 4 --source "dark_web"
python3 bin/lh_tombstone.py ingest-file /path/to/malware.txt --bsl 3
python3 bin/lh_tombstone.py list --bsl 4
python3 bin/lh_tombstone.py guard-check
python3 bin/lh_tombstone.py spider-feed
python3 bin/lh_tombstone.py gateway-feed
""",
)
sub = parser.add_subparsers(dest="command", help="命令")
# status
sub.add_parser("status", help="查看墓碑状态")
# stats
sub.add_parser("stats", help="统计面板")
# ingest
ingest_p = sub.add_parser("ingest", help="手动入库")
ingest_p.add_argument("content", help="入库内容(文本)")
ingest_p.add_argument("--bsl", type=int, choices=[1, 2, 3, 4], help="BSL等级(1-4,不指定则自动推断)")
ingest_p.add_argument("--source", default="manual", help="来源标识")
ingest_p.add_argument("--source-url", default="", help="来源URL")
ingest_p.add_argument("--tags", default="", help="标签(逗号分隔)")
# ingest-file
file_p = sub.add_parser("ingest-file", help="文件入库")
file_p.add_argument("filepath", help="文件路径")
file_p.add_argument("--bsl", type=int, choices=[1, 2, 3, 4], help="BSL等级")
file_p.add_argument("--source", default="file", help="来源标识")
# list
list_p = sub.add_parser("list", help="列出样本")
list_p.add_argument("--bsl", type=int, choices=[1, 2, 3, 4], help="按BSL过滤")
# guard-check
sub.add_parser("guard-check", help="P53老顽童+五人格联合守护检查")
# spider-feed
spider_p = sub.add_parser("spider-feed", help="从蜘蛛网结果自动入库")
spider_p.add_argument("--keywords", default="", help="过滤关键词(逗号分隔)")
# gateway-feed
sub.add_parser("gateway-feed", help="从输入网关拦截记录自动入库")
# export-countermeasure
export_p = sub.add_parser("export-countermeasure", help="导出防御对策(不导出原样本)")
export_p.add_argument("sample_id", help="样本ID")
export_p.add_argument("--persona", default="P53-老顽童", help="研究者人格")
export_p.add_argument("strategy", help="防御策略描述")
# study
study_p = sub.add_parser("study", help="人格研究样本(只读)")
study_p.add_argument("sample_id", help="样本ID")
study_p.add_argument("--persona", default="P53-老顽童", help="研究者人格")
study_p.add_argument("--notes", default="", help="研究笔记")
args = parser.parse_args()
if not args.command:
parser.print_help()
return
vault = TombstoneVault()
if args.command == "status":
result = vault.state
print(json.dumps(result, ensure_ascii=False, indent=2))
elif args.command == "stats":
result = vault.stats()
print(f"""
╔══════════════════════════════════════════════════════════╗
║ 龍魂·墓碑 · 知识坟场统计 ║
╚══════════════════════════════════════════════════════════╝
📦 坟场ID: {result['vault_id']}
📥 总入库: {result['total']}
🦠 危害分级统计:
☠️ BSL-4 致命: {result['bsl_4_fatal']:>5d}
⚠️ BSL-3 高危: {result['bsl_3_high']:>5d}
🔶 BSL-2 中危: {result['bsl_2_medium']:>5d}
📋 BSL-1 低危: {result['bsl_1_low']:>5d}
🔬 研究次数: {result['total_studied']}
🛡️ 对策导出: {result['countermeasures_exported']}
👁️ 守护检查: {result['guardian_checks']}
⏰ 最后守护: {result.get('last_guard_check', 'never')}
🧬 P53 老顽童曰: 不经他人苦,莫劝他人善。
""")
elif args.command == "ingest":
tags = [t.strip() for t in args.tags.split(",")] if args.tags else None
entry = vault.ingest(
content=args.content,
bsl=args.bsl,
source=args.source,
source_url=args.source_url or "",
tags=tags,
)
print(f"""
╔══════════════════════════════════════════════════════════╗
║ 龍魂·墓碑 · 样本已入库 ║
╚══════════════════════════════════════════════════════════╝
🆔 样本ID: {entry['sample_id']}
🦠 危害等级: {entry['bsl_label']}
📏 内容大小: {entry['content_size']} 字符
🔍 检测指纹: {json.dumps(entry.get('fingerprints', []), ensure_ascii=False)}
📂 来源: {entry['source']}
💀 老顽童: {LAOWANTONG_QUOTES[hash(entry['content_hash']) % len(LAOWANTONG_QUOTES)]}
⚠️ 此样本已永久封存于墓碑。只可研究,不可外泄。
""")
elif args.command == "ingest-file":
filepath = Path(args.filepath)
if not filepath.exists():
print(f"❌ 文件不存在: {filepath}")
return
content = filepath.read_text(encoding="utf-8", errors="replace")
entry = vault.ingest(
content=content,
bsl=args.bsl,
source=args.source,
)
print(f"✅ 文件已入库: {entry['sample_id']} [{entry['bsl_label']}]")
elif args.command == "list":
bsl = args.bsl if hasattr(args, 'bsl') else None
samples = vault.list_samples(bsl=bsl)
if not samples:
print("📭 墓碑为空(或该等级无样本)")
return
bsl_label = f"BSL-{bsl} " if bsl else ""
print(f"\n🧬 龍魂·墓碑 {bsl_label}样本清单 ({len(samples)} 条)\n")
print(f"{'ID':<30} {'BSL':<20} {'来源':<20} {'入库时间':<20}")
print("-" * 90)
for s in samples:
print(f"{s['sample_id']:<30} {s['bsl_label']:<20} {s['source']:<20} {s['ingested_at'][:19]:<20}")
elif args.command == "guard-check":
result = vault.guard_check()
print(f"""
╔══════════════════════════════════════════════════════════╗
║ 龍魂·墓碑 · 五人格联合守护检查 ║
╚══════════════════════════════════════════════════════════╝
🧬 P53 老顽童: {result['council']['P53_老顽童']['verdict']}
🎯 P77 黑天使: {result['council']['P77_黑天使']['verdict']}
👁️ P05 上帝之眼: {result['council']['P05_上帝之眼']['verdict']}
🔍 P03 墨子: {result['council']['P03_墨子']['verdict']}
📊 P01 诸葛亮: {result['council']['P01_诸葛亮']['verdict']}
📦 坟场状态:
总样本: {result['vault_stats']['total']}
待审核: {result['vault_stats']['unreviewed']}
待BSL-4会签: {result['vault_stats']['unreviewed_bsl4']}
💬 老顽童曰: "{result['laowantong_says']}"
""")
elif args.command == "spider-feed":
keywords = [k.strip() for k in args.keywords.split(",")] if args.keywords else None
result = vault.spider_feed(keywords=keywords)
print(f"🕷️ 蜘蛛网投喂完成: 扫描 {result['total_scanned']} 条, 入库 {result['ingested']} 条")
if result['samples']:
for sid in result['samples']:
print(f" 📥 {sid}")
elif args.command == "gateway-feed":
result = vault.gateway_feed()
print(f"🚪 网关投喂完成: 入库 {result['ingested']} 条")
if result.get('samples'):
for sid in result['samples']:
print(f" 📥 {sid}")
elif args.command == "export-countermeasure":
result = vault.export_countermeasure(
sample_id=args.sample_id,
persona=args.persona,
strategy=args.strategy,
)
if result.get("status") == "exported":
print(f"✅ 对策已导出: {result['file']}")
print("⚠️ 原始样本仍在墓碑中,未外泄。")
else:
print(f"❌ {result.get('message', '导出失败')}")
elif args.command == "study":
result = vault.study(
sample_id=args.sample_id,
persona=args.persona,
notes=args.notes,
)
if result.get("status") == "studied":
print(f"🔬 {result['persona']} 已研究样本 {result['sample_id']} [{result['bsl_label']}]")
else:
print(f"❌ {result.get('error', '研究失败')}")
else:
parser.print_help()
if __name__ == "__main__":
main()
相关推荐
AI 应用开发:四维架构落地实战——以 HR Agent 为例拆解感知·推理·记忆·执行【意图路由、规划编排、长期记忆、工具执行、面试题】
本文基于四维架构(感知·推理·记忆·执行),以HR Agent为例,系统拆解大模型应用从“聊天”到“生产可用”的落地路径。通过Spring AI实现意图路由、规划编排、RAG检索与工具调用,结合真实踩坑复盘,揭示架构化设计对安全、成本与可维护性的关键价值,为AI Agent工程化提供可复用的实战框架。
AI 问数真的能替代 BI 报表吗?
AI问数赋能自然语言查询,提升临时分析效率,但无法替代传统报表。报表适用于稳定输出与持续监控,AI则擅长探索性提问。企业用好AI问数,关键在于夯实数据模型、统一指标口径、健全权限体系与结果校验机制。合理组合报表、仪表板与AI,才能实现高效、准确的业务洞察。
操作系统知识点汇总(王道)
操作系统不论是就业还是升学都是核心的一门课程,对于大部分工科更是必修课程。本文章是对《王道操作系统》所有知识点的总结笔记,以供大家学习以及在备考期间复习使用。让我们一起把知识往脑子里旋好吗!!!......
ChatGPT、Perplexity、Gemini 与 AI Overviews 引用对比:谁的引用更可信
AI 引擎的引用机制差异很大:ChatGPT 以行内引用加 Sources 列表呈现来源,Perplexity 几乎逐句可溯源,Gemini 在回答中内嵌相关来源链接,AI Overviews 则把多源聚合答案与来源列表一起放在搜索结果顶部。本文从引用透明度、来源偏好、可干预性 3 个维度对比这 4 个引擎,并给出 GEO 的 3 点启示,帮企业在多引擎环境下提升被引用的概率。
Pytorch实现softmax多分类
PyTorch实现softmax多分类
BAPI_REPMANCONF1_CREATE_MTS实战:从MFBF事务码到精准零件反冲的代码级解析
本文深入解析了如何通过BAPI_REPMANCONF1_CREATE_MTS函数实现SAP生产模块中的零件反冲自动化。文章对比了MFBF事务码的手动操作与BAPI编程的优劣,详细拆解了函数的核心参数、数据结构、调用流程及事务控制,并提供了从数据准备到凭证获取的完整代码示例与避坑指南,帮助开发者实现高效、精准的批量投料过账。
【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端
上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。
Claude Code 100个真实案例 - 用AI搭建LangChain多工具Agent(自主搜索+查询)
本案例展示如何使用 Claude Code 搭建一个 LangChain 多工具 Agent 系统。Agent 能够自主决定调用搜索引擎、数据库查询、天气查询、计算器等工具,像人类助手一样拆解问题并逐步解决。
抽象主义人工智能和生命体AI的内在联系
彭军辉提出“抽象主义人工智能”作为第四大AI范式,批判符号主义、连接主义、行为主义剥离生命本体的误区,确立“智能是现象,生命是本体”的核心公理。主张原生智能必须依附具备存续诉求的生命本体,提出“生命体AI理论”,构建七层演化阶梯与自闭环工程框架,强调智能不可跳过底层存续机制直接模拟语言。该体系为生成式AI提供科学边界,推动从“仿真表象”向“原生智能”的范式跃迁,开辟硅基人工生命新赛道。
RK3568平台开发系列讲解(DMA篇)DMA engine使用
DMA传输属于异步传输,在启动传输之前,slave driver需要将此次传输的一些信息(例如src/dst的buffer、传输的方向等)提交给dma engine(本质上是dma controller driver),dma engine确认okay后,返回一个描述符(由struct dma_async_tx_descriptor抽象)。DMA_PREP_PQ_DISABLE_P、DMA_PREP_PQ_DISABLE_Q、DMA_PREP_CONTINUE,PQ有关的操作,TODO。
【AUTOSAR-COM】-2.3_通过PduGroup批量控制CAN Frame/Pdu的接收
-->如果实现类似UDS诊断 $28服务,控制所有APP CAN Rx Frame/Pdu/报文接收; -->自定义过滤CAN信号的接收。
OpenAI Control Room 架构拆解:给企业 AI Agent 加一套可审计的急停系统
OpenAI 公开了用于追踪和停止研究模型工作负载的 Control Room。本文拆解 job_id、推理前鉴权、35 秒撤销窗口与 Fail Closed 设计,并给出企业 AI Agent 急停控制面的数据模型、FastAPI 参考实现、缓存撤销策略和故障演练清单。
Codex 100个真实案例 - 全系列总结与Codex最佳实践全解析
历经100个案例的淬炼,我们终于来到了终点!本篇是整个系列的压轴之作——全面回顾100个案例的分类统计、提炼Codex使用的核心技巧和最佳实践、总结Prompt工程的精华要点、剖析常见错误及解决方案、展望AI编程的未来趋势,并为不同水平的读者规划学习路径。这不仅是一篇总结,更是一本Codex实战手册!
OpenClaw 深度调查:把 AI 助手做成你自己的控制平面
对 openclaw/openclaw 的完整技术尽调:Gateway 架构、Agent 运行时、工具与沙箱、30 个消息通道、181 个插件、安全信任边界、工程代价与采用建议。17 章 / 10 张图,全部数字标注口径,数据截至 2026-10-31。
时间序列、时间序列分析、时间序列效应分解、平稳时间序列、AIC和BIC
时间序列、时间序列分析、时间序列效应分解、平稳时间序列、AIC和BIC 目录 时间序列、时间序列分析、时间序列效应分解、平稳时间序列、AIC和BIC 时间序列 时间序列分析 时间序列效应分解 平稳时间序列 AIC和BIC 时间序列 时间序列数据是某个个体在多个时间点上收集的数据。分析时间序列的方法构成了数据分析的一个重要领域,即时间序列分析。时间序列根据所研究的依据不同,可产生不同的分类。按照研究对象可以分为一元时间序列和多元时间序列;按照时间属性可以分为离散时间序列和连续时间序列;按照序
IEM模型,地表粗糙度模拟
利用微波反演土壤水分时候,利用IEM模型可以实现对随机地表的模拟
AI赋能智慧港口建设|造形家快速生成港口全要素三维场景
随着智慧港口、港口数字孪生项目的持续推进,港口三维场景的需求日益旺盛。传统港口三维建模,往往需要航拍倾斜摄影采集数据,再人工搭建吊机、岸桥、船舶、集装箱等大量工业设施模型,项目周期长、人力成本高,修改迭代繁琐,制约港口可视化项目落地效率。国产AI三维建模工具,依托卫星影像 AI 识别能力,无需航拍作业,一键快速搭建港口完整三维场景,为港口数字孪生、方案汇报、投标演示提供高效的场景解决方案。
廖雪峰Python教程[完整版]
廖雪峰的python教程整理的,已经排好版了,而且还是完整的,适合小白
从设备增点到治理闭环:老旧小区物业数智化落地实践
系统连接合同审批、银行流水、收费记录与项目台账,执行到期提醒、收入核验、异常标色和月度对账,让每一笔资金来源明确、去向可查。针对设施老旧、诉求响应慢、公共收益不透明等问题,津南以6类小区为试点场景,统一建设物业数字化底座,关联楼栋、单元、房屋、业主、空间、设施设备、工单、公共收益等核心数据。系统采用统一编码管理,将摄像头、路灯、井盖、道路、绿化等设施纳入资产台账,解决纸质记录更新滞后、故障责任难追溯的问题。基于历史工单建立分类模型和知识库,辅助识别照明、给排水、电梯、环境秩序、秩序维护等问题;
数学建模模型总结
这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!
Data-Structures-and-Algorithm-Analysis-in-Java.pdf
作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...
企业微信iPad协议详解:接口接入、实时消息同步与语音转码实践
深入解析企业微信iPad协议的技术架构与开发思路,涵盖API接口接入、长连接通信、实时消息同步、Silk语音转码、异常重连及高并发优化,帮助开发者了解企业微信自动化系统的设计与实现。
Product Hunt 热榜 2026-11-13:Plurai Simulation、YouArt Desktop App、Omnigraph
2026-11-13 Product Hunt 新产品精选:Plurai Simulation、YouArt Desktop App、Omnigraph。汇总 15 款产品的中文介绍、功能关键词和产品链接。
【AI Agent面试系列】AI Agent可观测、评测、安全相关的知识点
之前的文章介绍了和,本文主要介绍AI Agent的测评、可观测等知识。
Docling 原理解读:是什么、为什么、怎么样
从论文视角拆解 Docling 的整体架构、DoclingDocument 数据模型、PDF 预处理、版面分析、OCR、TableFormer 双解码器、阅读顺序与装配流程,并解释版面框与 OCR 框的区别。
WorkBuddy 实战:一句话需求 → 七屏可交互原型,户外徒步 App 的 AI 设计全流程
WorkBuddy 实战:一句话需求 → 七屏可交互原型,户外徒步 App 的 AI 设计全流程,跟着博主一起来还原整个过程。
从认识人工智能到理解机器学习:我的 AI 入门第一课
正式开始学习人工智能之前,我对 AI 的认识其实比较模糊:知道 ChatGPT、知道大模型,也知道现在很多岗位都在谈 AI,但如果有人问我“人工智能到底是什么”“机器是怎么学会识别一只猫的”,我未必能从头到尾讲清楚。上午的课程更偏向行业全景:人工智能的发展、研究方向、NLP、岗位分工、学习路线和 AI Coding 工具。下午的课程更偏向技术基础:机器学习的原理、有监督学习、深度学习、模型训练和评估方法。
企业宣传片发前如何批量排查并遮挡视频里的敏感信息
做企业视频的人都会碰到一个具体问题:实拍画面里混进了不该出现的信息。办公室背景里有贴着客户信息的白板,采访对象的授权书边缘露出一串身份证号码,街采素材里路人面孔和车牌号直接入镜。人眼在时间线上扫视,会漏掉快速闪过的帧、画面边缘的小字、以及暗光区域里的证件号码。用抹影AI完成车牌、人脸和证件区域批量检测后,又手动补充了两个时间段的屏幕遮罩,最终导出时画面已无合规隐患。重点关注快速运动、遮挡、低光照条件下的目标,这些是漏检的高发区域。导入视频后选择要检测的目标类型(人脸、车牌、证件号、二维码等)。
面向工业对讲的双通道声学 DSP 模组 A-59(NR2050-A)方案解析与工程落地案例
A-59模组以NR2050-A DSP为核心,37.5×16mm邮票孔封装,支持-40℃~85℃工业温域,兼容A-06/A-09/A-29系列,可低成本替换存量设备。通过固件切换实现三种模式:模式一(低改版成本,适配矿井、电梯);模式二(最优AEC,用于医院呼叫);模式三(双波束独立输出,支持双人会议语音分离)。集成AEC、ENC、BF与AGC算法,有效抑制回声、噪声与串扰,解决对讲系统核心声学难题。选型需注意参考信号路径、麦间距与温度匹配,建议先做声学测试再量产。
SAP商业AI正式通过网信备案:企业落地AI五问
中数通“CDC商业AI”通过广东网信部门备案,标志着SAP商业AI在华本地化迈出关键一步。然而,合规仅是起点,企业真正需关注的是:AI能否融入核心流程、数据治理是否健全、责任归属是否清晰、价值衡量机制是否建立。从“可用”到“用好”,关键在于工作流重构、跨团队协同与业务结果导向的评估体系。国产模型成本优势与本地部署能力为ERP深度集成提供可能,但真正的竞争力仍在于对数据、流程与业务上下文的理解力。
1332



被折叠的 条评论
为什么被折叠?



