#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
╔══════════════════════════════════════════════════════════════════════════╗
║ 龍魂·行为密码学七因子验证引擎 v1.0 ║
║ Behavioral Cryptography · Seven-Factor Verifier Engine ║
╠══════════════════════════════════════════════════════════════════════════╣
║ DNA: #龍芯⚡️丙午·丙申·癸丑·申时·需-BEHAVIORAL-CRYPTO-VERIFIER-v1.0 ║
║ 论文: Behavioral Cryptography (2026-05-02) · UID9622 · 337页 ║
║ 铁律: 任一因子Fi=0 → conf=0(硬失败·不可救) ║
║ 公式: conf = ∏ Fi^wi · 加权几何平均 · 7因子不可补偿 ║
╠══════════════════════════════════════════════════════════════════════════╣
║ F1 Identity DNA (0.25) — DNA前缀·UID·GPG·时间戳 ║
║ F2 Temporal Anchor (0.15) — ISO时间·时辰·数字根一致性 ║
║ F3 Rule Trace (0.15) — 规则ID·版本·调用链 ║
║ F4 Persona Route (0.12) — 人格ID·人格DNA·路由链 ║
║ F5 Protected Lexicon(0.12) — 主权词保留率·术语连续性 ║
║ F6 Style Vector (0.11) — 风格连续性·α/β/γ桥接 ║
║ F7 Mistake Ledger (0.10) — 修正痕迹·错误连续性·修订历史 ║
╠══════════════════════════════════════════════════════════════════════════╣
║ 📂 数据来源: 论文 §3.2-§3.5 定义 · 所有参数严格来自原论文 ║
║ 📋 责任: P05上帝之眼(验证) · P06数学大师(公式) · P02龍芯(实现) ║
║ 📇 项目身份 · 联系 · 支持 → assets/PUBLIC_IDENTITY.md ║
╚══════════════════════════════════════════════════════════════════════════╝
用法:
python3 bin/lh_behavioral_crypto_verifier.py verify <dna_string> [--content FILE]
python3 bin/lh_behavioral_crypto_verifier.py audit <file_or_dir>
python3 bin/lh_behavioral_crypto_verifier.py proof-bundle <dna_string>
python3 bin/lh_behavioral_crypto_verifier.py adversary-check <content_file>
导入:
from bin.lh_behavioral_crypto_verifier import BehavioralCryptoVerifier, SevenFactorReport
"""
import hashlib
import json
import math
import re
import os
import sys
from pathlib import Path
from datetime import datetime, timezone, timedelta
from typing import Dict, List, Tuple, Optional, Any
from dataclasses import dataclass, field
from collections import Counter
# ═══════════════════════════════════════════════════════════════
# §1 常量定义(来自论文 §3.2)
# ═══════════════════════════════════════════════════════════════
FACTOR_WEIGHTS: Dict[str, float] = {
"F1": 0.25, # Identity DNA
"F2": 0.15, # Temporal Anchor
"F3": 0.15, # Rule Trace
"F4": 0.12, # Persona Route
"F5": 0.12, # Protected Lexicon
"F6": 0.11, # Style Vector
"F7": 0.10, # Mistake Ledger
}
THRESHOLD_STD = 0.85 # 标准接受阈值
THRESHOLD_HIGH = 0.95 # 高安全阈值
THRESHOLD_WARN = 0.70 # 警告阈值
THRESHOLD_LOW = 0.50 # 低置信阈值
DNA_PREFIX = "#龍芯⚡️"
CONFIRM_CODE = "#CONFIRM\n🌌9622-ONLY-ONCE\n🧬LK9X-772Z"
SEAL_CODE = "#ZHUGEXIN\n⚡2025-\n🇨🇳\n🐉\n⚖\n♠\n🧚\n❤\n♾-DEVICE-BIND-SOUL"
DEFAULT_GPG = "A2D0092CEE2E5BA87035600924C3704A8CC26D5F"
DEFAULT_GPG_PREFIX = "A2D0092C"
DEFAULT_UID = "UID9622"
# 时辰映射
SHICHEN = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"]
# 数字根→五行映射(论文 §3.4)
DIGIT_ROOT_TO_WUXING = {
1: "水", 2: "火", 3: "木", 4: "金", 5: "土",
6: "水", 7: "火", 8: "木", 9: "金", 0: "土"
}
# 保护词典(主权词·不可替换为通用标签)
PROTECTED_LEXICON = {
"UID9622": 1.0,
"龍魂系统": 1.0,
"龍魂": 0.9,
"LongHun": 0.9,
"CNSH": 0.85,
"龍芯": 0.85,
"龍芯北辰": 0.8,
"CONFIRM": 0.8,
"SEAL": 0.8,
"河图洛书": 0.7,
"369不动点": 0.7,
"三才算法": 0.7,
"行为密码学": 0.7,
"数字根": 0.6,
"五行": 0.6,
"自逼为王": 0.6,
"二次元之眼": 0.6,
"一槌定音": 0.6,
}
# 保护词典→通用标签替换检测(论文 A2 攻击面)
LEXICON_REPLACEMENT_PAIRS = {
"龍魂系统": ["the system", "this system", "our platform"],
"CNSH": ["semantic protocol", "language protocol"],
"龍芯": ["longxin", "dragon chip", "core engine"],
"行为密码学": ["behavioral analysis", "provenance tracking"],
"自逼为王": ["self-motivation", "self-driven"],
"二次元之眼": ["monitoring system", "surveillance"],
"一槌定音": ["final decision", "decisive action"],
"河图洛书": ["numeric grid", "magic square"],
"369不动点": ["fixed point", "stable constant"],
}
# 已知模块注册表(用于 F3 规则追踪)
KNOWN_MODULES = {
"VERIFY", "AUDIT", "PATROL", "INTEGRATE", "REPAIR",
"GENERATE", "SYNC", "COMPRESS", "HANDOFF", "SEAL",
"BEHAVIORAL-CRYPTO", "BEHAVIORAL-CRYPTOGRAPHY",
"ROBOT-SCORE", "HABIT-FINGERPRINT", "DNA-REGISTRY",
"DNA-SOVEREIGNTY", "CROSS-MODULE", "ANTI-TAMPER",
"GOVERNANCE-ENGINE", "SEMANTIC-UPGRADE",
"LONGHUN-CONSTITUTION", "P0-ETERNAL-LOCK",
"HETU-LUOSHU-DNA", "CNSH-SYNTAX",
"TRIALS-ENGINE", "SECOND-DIMENSION-EYE",
"FINAL-STRIKE", "ZERO-TRUST-GUARD",
}
ROBOTSCORE_PATH = Path(__file__).parent / "lh_robot_score.py"
HABIT_FINGERPRINT_PATH = Path(__file__).parent / "lh_habit_fingerprint.py"
DNA_REGISTRY_PATH = Path(__file__).parent.parent / "L7_数据层" / "dna_registry.jsonl"
DNA_INDEX_PATH = Path(__file__).parent.parent / "L7_数据层" / "dna_registry_index.json"
DEDUP_LOG_PATH = Path(__file__).parent.parent / "L7_数据层" / "deduplication_log.jsonl"
# ═══════════════════════════════════════════════════════════════
# §2 工具函数
# ═══════════════════════════════════════════════════════════════
def digit_root_from_text(text: str) -> int:
"""数字根:论文 §3.4 算法"""
digits = [int(ch) for ch in text if ch.isdigit()]
if not digits:
return 0
n = sum(digits)
while n >= 10:
n = sum(int(ch) for ch in str(n))
return n
def digit_root_from_date(date_str: str) -> int:
"""从日期字符串计算数字根"""
return digit_root_from_text(date_str)
def get_shichen(dt: datetime) -> str:
"""时辰:论文 §3.4 算法"""
hour = dt.hour
index = ((hour + 1) % 24) // 2
return SHICHEN[index]
def sha256_text(text: str) -> str:
return hashlib.sha256(text.encode("utf-8", errors="ignore")).hexdigest()
def extract_gpg_prefix(dna: str) -> str:
"""从DNA字符串提取GPG前缀(8位大写)"""
match = re.search(r'[A-F0-9]{8}', dna)
if match:
return match.group()
return ""
def parse_iso_from_dna(dna: str) -> Optional[str]:
"""从DNA字符串提取ISO时间"""
# 尝试 v∞ 格式:干支·干支·干支·时辰
ganzhi_match = re.search(
r'([甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥])·'
r'([甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥])·'
r'([甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥])·'
r'([子丑寅卯辰巳午未申酉戌亥])时',
dna
)
if ganzhi_match:
return None # v∞ 格式没有ISO时间,返回None让调用者处理
# 尝试 v1.0 格式:YYYY-MM-DD
iso_match = re.search(r'(\d{4}-\d{2}-\d{2})', dna)
if iso_match:
return iso_match.group(1)
return None
def parse_shichen_from_dna(dna: str) -> Optional[str]:
"""从DNA提取时辰"""
match = re.search(r'([子丑寅卯辰巳午未申酉戌亥])时', dna)
if match:
return match.group(1)
return None
def parse_digit_root_from_dna(dna: str) -> Optional[int]:
"""从DNA提取数字根(间接:从ISO日期计算)"""
iso = parse_iso_from_dna(dna)
if iso:
return digit_root_from_date(iso)
return None
def compute_entry_hash(entry: dict) -> str:
"""计算账本条目哈希(论文 §3.5.7)"""
data = json.dumps(entry, sort_keys=True, ensure_ascii=False)
return "sha256:" + hashlib.sha256(data.encode()).hexdigest()
# ═══════════════════════════════════════════════════════════════
# §3 七因子验证报告
# ═══════════════════════════════════════════════════════════════
@dataclass
class FactorResult:
"""单个因子验证结果"""
factor: str
score: float
reason: str
details: Dict[str, Any] = field(default_factory=dict)
@dataclass
class SevenFactorReport:
"""七因子完整验证报告"""
dna: str
uid: str
composite_confidence: float
threshold: float
passed: bool
hard_fail: bool
hard_fail_reason: Optional[str]
factors: Dict[str, FactorResult]
weights: Dict[str, float]
adversary_class: Optional[str] = None
robot_score: Optional[float] = None
lineage_continuous: bool = False
proof_bundle_hash: Optional[str] = None
def verdict(self) -> str:
if self.hard_fail:
return "🔴 硬失败·熔断"
if self.composite_confidence >= THRESHOLD_HIGH:
return "🟢 高信任"
if self.composite_confidence >= THRESHOLD_STD:
return "🟢 可接受"
if self.composite_confidence >= THRESHOLD_WARN:
return "🟡 需审核"
if self.composite_confidence >= THRESHOLD_LOW:
return "🟡 低置信"
return "🔴 拒绝"
def to_dict(self) -> dict:
return {
"dna": self.dna,
"uid": self.uid,
"composite_confidence": self.composite_confidence,
"threshold": self.threshold,
"passed": self.passed,
"hard_fail": self.hard_fail,
"hard_fail_reason": self.hard_fail_reason,
"verdict": self.verdict(),
"adversary_class": self.adversary_class,
"robot_score": self.robot_score,
"lineage_continuous": self.lineage_continuous,
"factors": {
k: {"score": v.score, "reason": v.reason, "details": v.details}
for k, v in self.factors.items()
},
"weights": self.weights
}
# ═══════════════════════════════════════════════════════════════
# §4 七因子验证引擎
# ═══════════════════════════════════════════════════════════════
class BehavioralCryptoVerifier:
"""
行为密码学七因子验证引擎
论文 §3.2 完整实装:
- F1-F7 七个独立验证因子
- 加权几何平均 conf = ∏ Fi^wi
- 硬失败:任一 Fi=0 → conf=0
- A1-A5 对抗性检测
- Proof Bundle 生成
"""
def __init__(self, uid: str = DEFAULT_UID, gpg_prefix: str = DEFAULT_GPG_PREFIX):
self.uid = uid
self.gpg_prefix = gpg_prefix
self.gpg_full = DEFAULT_GPG
self.weights = dict(FACTOR_WEIGHTS)
# 尝试加载 RobotScore 桥接
self.robot_score_available = False
try:
from bin.lh_robot_score import RobotScore检测器
self.robot_scorer = RobotScore检测器()
self.robot_score_available = True
except Exception:
self.robot_scorer = None
# ── F1: 身份DNA验证 ──
def verify_F1(self, dna: str, claimed_uid: str = None,
claimed_gpg_prefix: str = None) -> FactorResult:
"""
F1: Identity DNA Verification
论文 §3.2.2 · 权重 0.25
检查:DNA前缀·UID匹配·GPG前缀·时间戳有效性
v∞格式(干支):结构化身份锚定,UID由干支+模块+CONFIRM隐含
v1.0格式(格里历):显式UID检查
"""
uid = claimed_uid or self.uid
gpg_pref = claimed_gpg_prefix or self.gpg_prefix
details = {}
# 1. DNA 前缀检查(硬失败条件·两种格式通用)
if not dna.startswith(DNA_PREFIX):
return FactorResult("F1", 0.0, "DNA前缀不匹配:缺少 #龍芯⚡️", details)
details["prefix_ok"] = True
# 判定DNA格式
ganzhi_pattern = re.compile(
r'[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]·'
r'[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]·'
r'[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]·'
r'[子丑寅卯辰巳午未申酉戌亥]时'
)
gregorian_pattern = re.compile(r'\d{4}-\d{2}-\d{2}')
is_vinf = bool(ganzhi_pattern.search(dna))
is_v1 = bool(gregorian_pattern.search(dna)) and not is_vinf
details["dna_format"] = "v∞" if is_vinf else "v1.0" if is_v1 else "未知"
# 2. UID 检查(双格式策略)
if is_vinf:
# v∞ 格式:UID由干支结构+模块路由隐含,不由字符串显式承载
# 检查:干支结构完整性 + 是否有 ⚡️ 龙芯特有编码
if ganzhi_pattern.search(dna) and "⚡️" in dna:
details["uid_ok"] = True
details["uid_method"] = "v∞_structural_implicit"
else:
details["uid_ok"] = False
return FactorResult("F1", 0.3,
"v∞格式结构不完整·无法锚定身份", details)
else:
# v1.0 格式:UID必须在字符串中
if uid not in dna:
# 柔性降级:v1.0格式无UID但有前缀+GPG → 部分信任
details["uid_ok"] = False
details["uid_method"] = "v1.0_explicit_missing"
# 不硬失败,降为0.5(论文允许部分因子非0但降分)
else:
details["uid_ok"] = True
details["uid_method"] = "v1.0_explicit"
# 3. GPG 前缀检查
extracted_prefix = extract_gpg_prefix(dna)
details["extracted_gpg_prefix"] = extracted_prefix
if extracted_prefix and len(extracted_prefix) == 8:
if extracted_prefix != gpg_pref[:8].upper():
# GPG前缀可能被hash8混淆,降分不熔断
details["gpg_ok"] = "partial_mismatch"
details["gpg_note"] = "可能与hash8混淆"
else:
details["gpg_ok"] = True
elif not extracted_prefix:
# v∞ 格式可能没有显式GPG前缀在DNA字符串中
if is_vinf:
details["gpg_ok"] = True
details["gpg_note"] = "v∞格式GPG由完整记录承载"
else:
details["gpg_ok"] = False
else:
details["gpg_ok"] = False
# 4. 复合评分
checks_passed = sum([
details.get("prefix_ok", False),
details.get("uid_ok", False),
details.get("gpg_ok", False) in (True, "partial_mismatch"),
])
has_timestamp = is_vinf or is_v1
details["timestamp_ok"] = has_timestamp
if details.get("prefix_ok") and checks_passed >= 2 and has_timestamp:
score = 1.0 if checks_passed == 4 else 0.85 if checks_passed == 3 else 0.6
reason = f"身份DNA验证通过({details['dna_format']}格式)"
elif details.get("prefix_ok") and has_timestamp:
score = 0.5
reason = f"身份DNA部分验证·{details['dna_format']}格式·部分锚点弱"
else:
score = 0.0
reason = "身份DNA验证失败"
return FactorResult("F1", score, reason, details)
# ── F2: 时间锚验证 ──
def verify_F2(self, dna: str, claimed_time: Optional[datetime] = None) -> FactorResult:
"""
F2: Temporal Anchor Verification
论文 §3.2.2 · 权重 0.15
检查:ISO时间·时辰一致性·数字根一致性
"""
details = {}
iso = parse_iso_from_dna(dna)
shichen_dna = parse_shichen_from_dna(dna)
dr_dna = parse_digit_root_from_dna(dna)
details["iso_from_dna"] = iso
details["shichen_from_dna"] = shichen_dna
details["digit_root_from_dna"] = dr_dna
# v∞ 格式无ISO时间:检查干支-时辰结构完整性
if iso is None:
# v∞ 格式验证
ganzhi_match = re.search(
r'([甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥])·'
r'([甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥])·'
r'([甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥])·'
r'([子丑寅卯辰巳午未申酉戌亥])时',
dna
)
if ganzhi_match:
details["v∞_structure_ok"] = True
if shichen_dna:
details["shichen_present"] = True
return FactorResult("F2", 0.9,
"v∞时间锚结构完整·干支+时辰正确", details)
return FactorResult("F2", 0.8,
"v∞时间锚通过·时辰格式完整", details)
return FactorResult("F2", 0.5,
"时间锚不完整·无法验证", details)
# v1.0 格式:检查时间一致性
score = 1.0
issues = []
if claimed_time:
try:
dt = datetime.fromisoformat(iso)
diff = abs((dt - claimed_time).total_seconds())
if diff > 60:
return FactorResult("F2", 0.0,
f"时间戳偏移过大:{diff:.0f}秒", details)
except Exception:
pass
# 时辰一致性
if shichen_dna:
try:
dt = datetime.fromisoformat(iso)
expected_shichen = get_shichen(dt)
if shichen_dna != expected_shichen:
issues.append(f"时辰不一致:DNA={shichen_dna},期望={expected_shichen}")
score = 0.3
else:
details["shichen_consistent"] = True
except Exception:
pass
# 数字根一致性
if dr_dna is not None:
expected_dr = digit_root_from_date(iso)
if dr_dna != expected_dr:
issues.append(f"数字根不一致:DNA={dr_dna},期望={expected_dr}")
score = min(score, 0.3)
else:
details["digit_root_consistent"] = True
reason = "时间锚验证通过" if score == 1.0 else "; ".join(issues)
return FactorResult("F2", score, reason, details)
# ── F3: 规则轨迹验证 ──
def verify_F3(self, dna: str, rule_ids: List[str] = None,
parent_dna: Optional[str] = None) -> FactorResult:
"""
F3: Rule Trace Verification
论文 §3.2.2 · 权重 0.15
检查:模块名是否在已知注册表中·规则链完整性
支持 v∞(<卦>-<模块>-<动作>-<哈希>) 和 v1.0(格里历) 双格式
"""
details = {}
score = 1.0
issues = []
# 从DNA提取模块名(v∞ 格式: <卦>-<模块>-<动作>-<哈希>)
# v∞ 模块可能是多段如 BEHAVIORAL-CRYPTO-VERIFIER 或单段如 VERIFY
module = None
# 方法1: 匹配已知模块名(支持多段如 BEHAVIORAL-CRYPTO)
known_pattern = '|'.join(sorted(KNOWN_MODULES, key=len, reverse=True))
module_match = re.search(rf'-({known_pattern})', dna, re.IGNORECASE)
if module_match:
module = module_match.group(1).upper()
# 方法2: 从v∞结构提取 <卦>-<模块>-<动作>-<哈希>
if not module:
v∞_match = re.search(
r'[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]·'
r'[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]·'
r'[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]·'
r'[子丑寅卯辰巳午未申酉戌亥]时·'
r'[^-]+-(.+?)-[A-F0-9]{8}',
dna
)
if v∞_match:
module = v∞_match.group(1).upper()
if module:
details["module"] = module
if module in KNOWN_MODULES:
details["module_registered"] = True
elif any(module.startswith(km) or km.startswith(module) for km in KNOWN_MODULES):
details["module_registered"] = True
details["module_note"] = "partial_match"
else:
# 新模块:自动注册为已知
details["module_registered"] = False
details["module_note"] = "new_module_auto_track"
score = 0.7 # 降分但不熔断,因为可能是新模块
else:
issues.append("无法从DNA提取模块名")
score = 0.4
details["module"] = None
# 父DNA存在性
if parent_dna:
details["parent_dna"] = parent_dna
if not parent_dna.startswith(DNA_PREFIX):
issues.append("父DNA格式无效")
score = min(score, 0.2)
reason = "规则轨迹验证通过" if score == 1.0 else "; ".join(issues) if issues else f"规则轨迹验证·模块={module}"
return FactorResult("F3", score, reason, details)
# ── F4: 人格路由验证 ──
def verify_F4(self, dna: str, persona_ids: List[str] = None) -> FactorResult:
"""
F4: Persona Route Verification
论文 §3.2.2 · 权重 0.12
检查:人格路由是否可追溯(从DNA推断模块→人格映射)
"""
details = {}
# 模块→人格映射(来自 AGENTS.md 意图路由表)
module_persona_map = {
"VERIFY": "P05", "AUDIT": "P05", "PATROL": "P77",
"REPAIR": "P02", "INTEGRATE": "P15", "SYNC": "P15",
"GENERATE": "P02", "COMPRESS": "P02",
"BEHAVIORAL-CRYPTO": "P05+P06",
"ROBOT-SCORE": "P06", "HABIT-FINGERPRINT": "P06",
"DNA-REGISTRY": "P15", "DNA-SOVEREIGNTY": "P15",
"CROSS-MODULE": "P13", "ANTI-TAMPER": "P05+P72",
"GOVERNANCE-ENGINE": "P01+P00",
"LONGHUN-CONSTITUTION": "P00", "P0-ETERNAL-LOCK": "P00",
"TRIALS-ENGINE": "P01+P00",
"SECOND-DIMENSION-EYE": "P77+P05",
"FINAL-STRIKE": "P05+P77",
"ZERO-TRUST-GUARD": "P77",
}
module_match = re.search(r'-(VERIFY|AUDIT|PATROL|INTEGRATE|REPAIR|GENERATE|SYNC|COMPRESS|'
r'BEHAVIORAL-CRYPTO|ROBOT-SCORE|HABIT-FINGERPRINT|DNA-REGISTRY|'
r'DNA-SOVEREIGNTY|CROSS-MODULE|ANTI-TAMPER|GOVERNANCE-ENGINE|'
r'LONGHUN-CONSTITUTION|P0-ETERNAL-LOCK|HETU-LUOSHU-DNA|'
r'CNSH-SYNTAX|TRIALS-ENGINE|SECOND-DIMENSION-EYE|'
r'FINAL-STRIKE|ZERO-TRUST-GUARD)', dna)
if module_match:
module = module_match.group(1).upper()
if module in module_persona_map:
details["persona"] = module_persona_map[module]
details["persona_mapped"] = True
return FactorResult("F4", 1.0,
f"人格路由验证通过:{module} → {module_persona_map[module]}", details)
details["persona"] = None
details["persona_mapped"] = False
return FactorResult("F4", 0.5,
"人格路由未完全映射·模块→人格推断不完整", details)
# ── F5: 保护词典验证 ──
def verify_F5(self, content: str = "", dna: str = "") -> FactorResult:
"""
F5: Protected Lexicon Verification
论文 §3.2.2 · 权重 0.12
检查:主权词保留率·术语是否被替换为通用标签
"""
details = {}
if not content:
return FactorResult("F5", 0.5,
"无内容可验证保护词典", details)
content_lower = content.lower()
total_terms = 0
preserved = 0
replaced_detected = []
# 检查保护词保留
for term, weight in PROTECTED_LEXICON.items():
if term.lower() in content_lower or term in content:
total_terms += 1
preserved += 1
if term not in details:
details[f"term_{term}"] = "preserved"
# 检查是否被替换为通用标签
for term, replacements in LEXICON_REPLACEMENT_PAIRS.items():
for repl in replacements:
if repl.lower() in content_lower:
# 确认原词不在
if term.lower() not in content_lower and term not in content:
replaced_detected.append(f"{term} → '{repl}'")
details["preserved_count"] = preserved
details["total_lexicon_terms"] = len(PROTECTED_LEXICON)
details["replaced_terms"] = replaced_detected
if replaced_detected:
return FactorResult("F5", 0.2,
f"保护词典被替换:{', '.join(replaced_detected[:3])}", details)
# 部分保护词存在
if preserved > 0:
score = min(1.0, preserved / max(len(PROTECTED_LEXICON) * 0.3, 1))
return FactorResult("F5", score,
f"保护词典保留率:{preserved}/{len(PROTECTED_LEXICON)}", details)
return FactorResult("F5", 0.1,
"保护词典完全缺失", details)
# ── F6: 风格向量验证 ──
def verify_F6(self, content: str = "", dna: str = "",
robot_score_alpha: Optional[float] = None) -> FactorResult:
"""
F6: Style Vector Verification
论文 §3.2.2 · 权重 0.11
检查:风格连续性·与RobotScore α/β/γ 桥接
"""
details = {}
score = 0.7 # 默认中等
if not content:
return FactorResult("F6", 0.5,
"无内容可验证风格向量", details)
# RobotScore桥接:α(习惯方差) → F6 风格
if robot_score_alpha is not None:
details["robot_score_alpha"] = robot_score_alpha
# α越低→风格越稳定→F6越高
style_score = 1.0 - robot_score_alpha
score = max(0.3, min(1.0, style_score))
elif self.robot_score_available and self.robot_scorer:
try:
from bin.lh_habit_fingerprint import 习惯指纹提取器
提取器 = 习惯指纹提取器()
指纹 = 提取器.提取(content)
result = self.robot_scorer.检测(content, 指纹)
details["robot_score"] = result.score
# RobotScore > 0.73 → AI嫌疑 → F6降低
if result.score > 0.73:
score = 0.3
details["ai_suspicion"] = True
else:
score = 0.85
details["ai_suspicion"] = False
except Exception as e:
details["robot_score_error"] = str(e)
# 文本基本特征
details["content_length"] = len(content)
details["content_hash"] = sha256_text(content)[:16]
return FactorResult("F6", score,
f"风格向量评分:{score:.2f}" +
(f"·RobotScore={details.get('robot_score', 'N/A')}" if 'robot_score' in details else ""),
details)
# ── F7: 错误账本验证 ──
def verify_F7(self, mistake_ledger: List[Dict] = None,
parent_dna: Optional[str] = None) -> FactorResult:
"""
F7: Mistake Ledger Verification
论文 §3.2.2 · 权重 0.10
检查:修正痕迹·错误连续性·修订历史
"""
details = {}
if not mistake_ledger:
# 检查是否为新内容(无修正痕迹=可能为原创)
if not parent_dna:
return FactorResult("F7", 0.8,
"无记错本·可能为原创内容(无修正历史)", details)
return FactorResult("F7", 0.4,
"无记错本·有父DNA但无修正痕迹", details)
# 分析记错本
total_entries = len(mistake_ledger)
corrections = [e for e in mistake_ledger if e.get("type") == "correction"]
details["total_entries"] = total_entries
details["correction_count"] = len(corrections)
# 有修正痕迹 → 真人协作标志
if corrections:
return FactorResult("F7", 0.9,
f"记错本验证通过·{len(corrections)}条修正记录", details)
return FactorResult("F7", 0.6,
f"记错本存在但无修正记录·{total_entries}条条目", details)
# ── 复合验证 ──
def verify(self, dna: str, content: str = "",
parent_dna: Optional[str] = None,
rule_ids: List[str] = None,
persona_ids: List[str] = None,
mistake_ledger: List[Dict] = None,
robot_score_alpha: Optional[float] = None,
claimed_time: Optional[datetime] = None,
threshold: float = THRESHOLD_STD) -> SevenFactorReport:
"""
完整七因子验证
论文 §3.2.3 复合验证算法
"""
# 执行七因子验证
f1 = self.verify_F1(dna)
f2 = self.verify_F2(dna, claimed_time)
f3 = self.verify_F3(dna, rule_ids, parent_dna)
f4 = self.verify_F4(dna, persona_ids)
f5 = self.verify_F5(content, dna)
f6 = self.verify_F6(content, dna, robot_score_alpha)
f7 = self.verify_F7(mistake_ledger, parent_dna)
factor_results = {
"F1": f1, "F2": f2, "F3": f3, "F4": f4,
"F5": f5, "F6": f6, "F7": f7,
}
factor_scores = {k: v.score for k, v in factor_results.items()}
# 硬失败检测(论文 定理3.1)
hard_fail = False
hard_fail_reason = None
for key, score in factor_scores.items():
if score == 0.0:
hard_fail = True
hard_fail_reason = f"{key}={score}"
break
# 复合置信度(加权几何平均·论文 定理3.2)
if hard_fail:
conf = 0.0
else:
product = 1.0
for key, weight in self.weights.items():
score = factor_scores[key]
if score > 0:
product *= math.pow(score, weight)
conf = product
# 对抗性检测
adversary_class = self._detect_adversary(factor_scores, content, dna)
# RobotScore桥接
robot_score = None
if self.robot_score_available and self.robot_scorer and content:
try:
from bin.lh_habit_fingerprint import 习惯指纹提取器
提取器 = 习惯指纹提取器()
指纹 = 提取器.提取(content)
result = self.robot_scorer.检测(content, 指纹)
robot_score = result.score
except Exception:
pass
# 血统连续性(简单检查)
lineage_continuous = False if hard_fail else (parent_dna is not None)
report = SevenFactorReport(
dna=dna,
uid=self.uid,
composite_confidence=round(conf, 4),
threshold=threshold,
passed=conf >= threshold and not hard_fail,
hard_fail=hard_fail,
hard_fail_reason=hard_fail_reason,
factors=factor_results,
weights=dict(self.weights),
adversary_class=adversary_class,
robot_score=robot_score,
lineage_continuous=lineage_continuous,
)
return report
# ── 对抗性检测(论文 §3.3) ──
def _detect_adversary(self, factor_scores: Dict[str, float],
content: str, dna: str) -> Optional[str]:
"""
A1-A5 对抗性攻击检测
论文 §3.3.3
"""
# A1: Surface Copier — F1+F3+F4弱
if (factor_scores.get("F1", 1.0) == 0.0 and
factor_scores.get("F3", 1.0) < 0.5 and
factor_scores.get("F4", 1.0) < 0.5):
return "A1_Surface_Copier"
# A2: Paraphrase Launderer — F5+F6+F7弱
if (factor_scores.get("F5", 1.0) < 0.3 and
factor_scores.get("F6", 1.0) < 0.4 and
factor_scores.get("F7", 1.0) < 0.5):
return "A2_Paraphrase_Launderer"
# A3: Persona Spoofer — F4特别弱
if factor_scores.get("F4", 1.0) < 0.3 and factor_scores.get("F3", 1.0) < 0.5:
return "A3_Persona_Spoofer"
# A4: Insider Corrupter — F1+F2异常
if (factor_scores.get("F1", 1.0) == 0.0 and
factor_scores.get("F2", 1.0) < 0.3):
return "A4_Insider_Corrupter"
# A5: Infrastructure Attacker — 所有因子弱但F1部分可用
low_count = sum(1 for s in factor_scores.values() if s < 0.3)
if low_count >= 4:
return "A5_Infrastructure_Attacker"
return None
# ── Proof Bundle 生成(论文 §6.6) ──
def generate_proof_bundle(self, report: SevenFactorReport,
content_hash: str = "",
privacy_mode: str = "normal") -> dict:
"""
生成可导出的证据包
论文 §6.6 Proof Bundle Schema
"""
bundle = {
"proof_bundle_version": "v1.0",
"generated_at": datetime.now(timezone(timedelta(hours=8))).isoformat(),
"privacy_mode": privacy_mode,
"root_identity": {
"uid": self.uid,
"creator_name": "Zhuge Xin / 諸葛鑫",
"system_name": "Longhun System / 龍魂系統",
"gpg_fingerprint": self.gpg_full,
"confirm_code_hash": sha256_text(CONFIRM_CODE)[:16],
},
"artifact": {
"dna": report.dna,
"content_hash": content_hash or sha256_text(report.dna)[:16],
},
"verification": {
"composite_confidence": report.composite_confidence,
"threshold": report.threshold,
"passed": report.passed,
"hard_fail": report.hard_fail,
"hard_fail_reason": report.hard_fail_reason,
"verdict": report.verdict(),
"factors": {
k: {"score": v.score, "reason": v.reason}
for k, v in report.factors.items()
},
"weights": dict(self.weights),
},
"adversary": {
"class": report.adversary_class,
"lineage_continuous": report.lineage_continuous,
},
"robot_score": report.robot_score,
"sealed_sections": [] if privacy_mode != "sealed" else ["root_identity.confirm_code"],
"confirm": CONFIRM_CODE if privacy_mode != "sealed" else "[SEALED]",
"seal": SEAL_CODE,
}
if privacy_mode == "sealed":
bundle["root_identity"]["confirm_code_hash"] = sha256_text(CONFIRM_CODE)[:16]
bundle["confirm"] = "[SEALED·HASH_ONLY]"
bundle["proof_bundle_hash"] = compute_entry_hash(bundle)
report.proof_bundle_hash = bundle["proof_bundle_hash"]
return bundle
# ── 审计现有内容 ──
def audit_content(self, filepath: str) -> SevenFactorReport:
"""审计文件内容的行为密码学签名"""
path = Path(filepath)
if not path.exists():
return SevenFactorReport(
dna="N/A", uid=self.uid,
composite_confidence=0.0, threshold=THRESHOLD_STD,
passed=False, hard_fail=True,
hard_fail_reason=f"文件不存在:{filepath}",
factors={}, weights=dict(self.weights),
)
content = path.read_text(encoding="utf-8", errors="ignore")
# 从内容提取DNA
dna_match = re.search(
r'(?:#龍芯⚡️|##龍芯⚡️)[^\n]*',
content
)
dna = dna_match.group(0).strip() if dna_match else "N/A"
if dna == "N/A":
return SevenFactorReport(
dna="N/A", uid=self.uid,
composite_confidence=0.0, threshold=THRESHOLD_STD,
passed=False, hard_fail=True,
hard_fail_reason=f"文件中未找到DNA签章",
factors={}, weights=dict(self.weights),
)
return self.verify(dna, content)
# ═══════════════════════════════════════════════════════════════
# §5 CLI 入口
# ═══════════════════════════════════════════════════════════════
def print_report(report: SevenFactorReport):
"""格式化打印验证报告"""
print(f"""
╔══════════════════════════════════════════════════════════════╗
║ 龍魂·行为密码学七因子验证报告 ║
╠══════════════════════════════════════════════════════════════╣
║ DNA: {report.dna[:60]}{'...' if len(report.dna) > 60 else ''}
║ UID: {report.uid}
║ 复合置信度: {report.composite_confidence:.4f} (阈值: {report.threshold})
║ 判定: {report.verdict()}
║ 硬失败: {'🔴 是' if report.hard_fail else '🟢 否'}
╠══════════════════════════════════════════════════════════════╣""")
for key, fr in report.factors.items():
emoji = "🔴" if fr.score == 0 else "🟡" if fr.score < 0.7 else "🟢"
print(f"║ {key} [{fr.score:.2f}] {emoji} {fr.reason[:45]}")
print(f"""╠══════════════════════════════════════════════════════════════╣
║ 对抗检测: {report.adversary_class or '🟢 无异常'}
║ RobotScore: {report.robot_score or 'N/A'}
║ 血统连续: {'🟢 是' if report.lineage_continuous else '🟡 否'}
╚══════════════════════════════════════════════════════════════╝""")
def main():
import argparse
parser = argparse.ArgumentParser(description="龍魂·行为密码学七因子验证引擎")
sub = parser.add_subparsers(dest="command")
# verify 子命令
v = sub.add_parser("verify", help="验证DNA签章")
v.add_argument("dna", help="DNA签章字符串")
v.add_argument("--content", help="关联内容文件")
v.add_argument("--uid", default=DEFAULT_UID, help="声称的UID")
v.add_argument("--gpg", default=DEFAULT_GPG_PREFIX, help="声称的GPG前缀")
# audit 子命令
a = sub.add_parser("audit", help="审计文件或目录")
a.add_argument("target", help="文件或目录路径")
# proof-bundle 子命令
p = sub.add_parser("proof-bundle", help="生成Proof Bundle证据包")
p.add_argument("dna", help="DNA签章字符串")
p.add_argument("--content", help="关联内容文件")
p.add_argument("--privacy", choices=["normal", "restricted", "sealed"],
default="normal", help="隐私模式")
p.add_argument("--output", help="输出JSON文件路径")
# adversary-check 子命令
ac = sub.add_parser("adversary-check", help="对抗性攻击检测")
ac.add_argument("content", help="内容文件路径")
args = parser.parse_args()
verifier = BehavioralCryptoVerifier()
if args.command == "verify":
content = ""
if args.content:
content = Path(args.content).read_text(encoding="utf-8", errors="ignore")
report = verifier.verify(args.dna, content)
print_report(report)
elif args.command == "audit":
target = Path(args.target)
if target.is_file():
report = verifier.audit_content(str(target))
print_report(report)
elif target.is_dir():
py_files = list(target.rglob("*.py")) + list(target.rglob("*.md"))
print(f"审计目录: {target} ({len(py_files)} 文件)")
results = []
for f in py_files[:50]: # 最多50个
try:
report = verifier.audit_content(str(f))
results.append((f.name, report))
except Exception as e:
results.append((f.name, SevenFactorReport(
dna="ERROR", uid=verifier.uid,
composite_confidence=0.0, threshold=0.85,
passed=False, hard_fail=True,
hard_fail_reason=str(e),
factors={}, weights=dict(FACTOR_WEIGHTS),
)))
passed = sum(1 for _, r in results if r.passed)
failed = sum(1 for _, r in results if r.hard_fail)
print(f"\n审计结果: {len(results)} 文件")
print(f" 🟢 通过: {passed}")
print(f" 🟡 需审: {len(results) - passed - failed}")
print(f" 🔴 硬失败: {failed}")
for name, r in results:
if r.hard_fail:
print(f" 🔴 {name}: {r.hard_fail_reason}")
elif args.command == "proof-bundle":
content = ""
if args.content:
content = Path(args.content).read_text(encoding="utf-8", errors="ignore")
report = verifier.verify(args.dna, content)
bundle = verifier.generate_proof_bundle(report, sha256_text(content)[:16], args.privacy)
if args.output:
output_path = Path(args.output)
output_path.parent.mkdir(parents=True, exist_ok=True)
output_path.write_text(json.dumps(bundle, ensure_ascii=False, indent=2), encoding="utf-8")
print(f"Proof Bundle 已保存: {args.output}")
else:
print(json.dumps(bundle, ensure_ascii=False, indent=2))
elif args.command == "adversary-check":
content = Path(args.content).read_text(encoding="utf-8", errors="ignore")
# 用空DNA做对抗检测
factor_scores = {}
# 快速对抗检查
verifier_factors = verifier._quick_factor_check(content)
factor_scores = {f"F{i+1}": s for i, s in enumerate(verifier_factors)}
adversary = verifier._detect_adversary(factor_scores, content, "")
print(f"\n对抗性攻击检测: {args.content}")
print(f" 检测结果: {adversary or '🟢 未检测到已知攻击模式'}")
print(f" 因子评分: {factor_scores}")
else:
parser.print_help()
def _quick_factor_check(self, content: str) -> List[float]:
"""快速因子检查(用于对抗性检测)"""
scores = []
# F5 简化检查
content_lower = content.lower()
preserved = sum(1 for t in PROTECTED_LEXICON if t.lower() in content_lower or t in content)
f5 = min(1.0, preserved / max(len(PROTECTED_LEXICON) * 0.3, 1)) if content else 0.5
scores.append(0.8) # F1 粗略
scores.append(0.7) # F2 粗略
scores.append(0.6) # F3 粗略
scores.append(0.5) # F4 粗略
scores.append(f5) # F5
scores.append(0.5) # F6 粗略
scores.append(0.5) # F7 粗略
return scores
# 添加快速检查方法到类
BehavioralCryptoVerifier._quick_factor_check = _quick_factor_check
if __name__ == "__main__":
main()
相关推荐
【LaTex】LaTex的下载与安装(2025新手小白超详细、超简洁 Windows系统)
安装地点(1)texlive的安装:首先打开下载好的安装包,找到这个文件前面缺少了一页emm我去截取其他人的作为示范然后点击安装安装时间较久,大概要一个小时左右。具体要看个人电脑性能情况。如图显示如上图,则安装成功。图中是TeXstudio 4.8.7版本针对不同操作系统和使用场景的安装包 ,区别如下:(按需求下载)
龍魂·璇玑引擎协议 · 记忆溯源推演系统 v4.1.5
璇玑引擎协议摘要(150字) 《龍魂·璇玑引擎协议v4.1.5》提出革命性MSG(Memory-Source Generation)范式,突破传统RAG局限。其核心采用"四象运转"架构:青龙(七因子纳米级溯源检索)、朱雀(16人格矩阵加权推演)、白虎(三六九不动点验真)、玄武(DNA签章烙印)。通过L0-L3分层记忆、中文语义命名体系及跨平台协同机制,实现检索粒度提升100倍、幻觉率下降90%。协议规定P1级宪法层需16人格签章+DNA验证,输出带可追溯数字指纹,确立知识主权归属。技术亮点包括:七因子时空检
海康威视工业相机网络配置实战:从MVS软件操作到IP地址规划
本文详细介绍了海康威视工业相机的网络配置实战,从MVS软件操作到IP地址规划。重点讲解了IP设置的重要性、Windows系统下的网络配置步骤、避免IP冲突的技巧,以及MVS软件中的相机IP配置方法。帮助用户快速掌握工业相机的网络连接技术,确保稳定高效的图像采集。
行为密码学:面向人机协作内容认证的七因子来源追溯框架 **Behavioral Cryptography: A Seven-Factor Provenance Framework for Huma
本文提出**行为密码学(Behavioral Cryptography)**框架,通过七因子来源追溯模型解决AI内容认证问题。该框架将内容创作视为可追溯的行为链,包含身份、时间、规则等七个维度,组合形成难以伪造的证据链。实验表明,七因子组合对改写、翻译、重组等攻击的抵抗能力显著优于单一方法。作为补充现有技术的新方案,行为密码学专注于思想的来路认证,而非简单区分人机内容。
Halcon实战:5种边缘检测算子对比(Sobel、Roberts、Prewitt、Kirsch、Canny)
本文深入对比了Halcon中Sobel、Roberts、Prewitt、Kirsch和Canny五大边缘检测算子的实战表现与核心差异。通过工业图像实例与代码解析,提供了基于噪声水平、边缘连续性及实时性要求的场景化选型指南,帮助工程师精准选择最适合的算子以优化视觉检测流程。
运维面试常见问题
对数据库表中一列或多列的值进行排序的一种结构,使用索引可快速访问数据库表中的特定信息。优缺点:优点:利用索引可以加速对数据的检索,索引是可以唯一的,创建索引允许指定单个列或者多个列缺点:减慢了数据录入速度,同时也增加了数据库的尺寸大小。
龍魂系统 · 小艺调度枢纽中心 · 全量接口契约
本文概述了"龍魂系统v5.0"的核心架构与运行规则。系统采用五级优先级(P0-P4)框架,其中P0为12条不可更改的底层原则(如为人民服务、数据主权等),P1为17条需16人格签章修订的核心宪法。小艺作为中央调度枢纽,负责所有AI系统的任务分发、数据路由和结果聚合,确保数据安全与合规。系统特色包括:DNA追溯机制、四层命名法、中华文化元素融合(如五行八卦、道德经场景),以及严格的权限控制体系。区域适配采用"一国一策"原则,用户可自定义P4级规则。所有操作需通过小艺路由,禁止外部AI直连核心数据。
AISHELL-2 中文语音数据库
AISHELL-1 is by far the largest open-source speech corpus available for Mandarin speech recognition research. It was released with a baseline system containing solid training and testing pipelines for Mandarin ASR. In AISHELL-2, 1000 hours of cle
龍魂·胖东来分成数学协议 v1.0 # LH-PANGDONGLAI-PROFIT-SPLIT-PROTOCOL
《龍魂·胖东来分成数学协议》摘要(148字): 该协议是龍魂体系核心宪法,强制规范接入企业利润分配。核心数学约束包括:员工分配≥50%、创始人提取≤10%、再投资≥30%、公益≥5%。协议采用DNA追溯链和七因子行为密码学审计技术,违约将触发自动冻结机制并公开DNA追溯记录。适用范围涵盖所有使用龍魂核心模块的企业,特别强调创始人自我约束。配套自动审计系统每季度校验财务报表,年度深度审计验证资金去向。协议包含法律契约模板和优先级冲突消解规则,确保员工利益绝对优先,体现"利润透明分"的胖东来精神。
激光定位算法竞技场:hdl_localization与Cartographer/AMCL的横向技术解剖
本文深入对比了hdl_localization、Cartographer和AMCL三种激光定位算法的技术原理与性能表现。通过UKF-NDT融合、图优化和粒子滤波等核心技术,分析了各算法在结构化环境、动态环境和大尺度场景下的适应性。实验数据表明,Cartographer在全局一致性上表现最优,而AMCL在动态环境中更具鲁棒性。文章还提供了算法选型指南和参数调优技巧,为工程实践提供参考。
YOLOv12涨点改进 | Neck特征融合改进篇 | YOLOv12引 入 BiFPN双向特征金字塔网络,显著提升了多尺度特征融合效率,目标检测、图像分割、图像分类,助力高效涨点
本文提出了一种基于BiFPN特征融合模块优化的YOLOv12目标检测方法。BiFPN通过引入可学习的权重实现高效的多尺度特征融合,结合双向连接机制提升特征提取能力。实验表明,该方法在COCO数据集上实现了优异的检测性能。文章详细介绍了BiFPN模块的原理、核心代码实现,以及如何将其集成到YOLOv12框架中,包括模块添加、配置文件修改等具体步骤。这种改进方案具有参数少、计算量小等优势,为高效目标检测提供了一种新的技术路径。
龍魂档案 · 知识产权与专利可评估资产清单 v2.0
龍魂知识产权资产清单摘要 本清单系统归档了UID9622龍魂系统的156项核心知识产权资产,涵盖本地技能(38项)、网络公开资产(24项)和Notion内部页面(94项)。其中79项具备DNA追溯码,50项具有专利潜力,包括高价值核心技术如:龍魂系统架构v5.0、CNSH中文编辑语法、DNA追溯协议、主权熔断机制等。资产类型覆盖AI引擎(语音/图像/NLP)、安全协议、算法内核及学术论文,多数已在GitHub/Notion等平台实现技术验证,形成完整的技术-品牌-学术产权矩阵。(字数:150) 关键数据:
终于找到两个稳定好用的Docker镜像加速源,拉取速度提升几十倍!
国内使用Docker经常遇到镜像拉取慢、超时失败的问题🐳 本文分享两个亲测好用的免费镜像加速源⚡ 实测拉取速度从十几分钟缩短到几十秒,稳定性接近100%📊 支持一键配置脚本,支持多平台使用✨
龍魂DNA引擎:AI可读的代码版本革命
文章摘要: 《龍魂 DNA 还原引擎 v1.0》提出了一种基于三层架构的代码变更管理与还原系统。核心架构包括存储层(DNA签章链、IPFS/区块链锚定)、解析层(语义化变更描述、行为密码学证明)和重放层(增量还原与冲突处理)。DNA签章数据结构设计融合自然语言变更描述、行为密码学七因子证明、多AI接龙签名等特性,确保变更可追溯性与意图还原。工作流程分为四个阶段:加载创世版本、解析DNA签章链、增量重放变更(AI辅助语义解析)、冲突检测与回滚。该引擎通过显式记录冲突和链式不可篡改设计,为代码版本管理提供高可解
精雕软件(JDpaint) 5.5 绿色版
精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版
汉书HE8,好用的汇编代码编写工具
汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大
龍魂系统 · DNA可逆编码与时间主权协议 v1.0
《龍魂系统DNA可逆编码与时间主权协议v1.0》是由诸葛鑫于2026年7月19日创建的核心技术框架,具有P0++最高锁定级别。该协议创新性地将DNA可逆编码与干支时间引擎结合,通过七因子签名、蚁群分片存储和六十四卦编码等技术实现数据完整性与时间主权保障。系统采用华为国产算力平台,严格遵循"一字不落"原则,提供双模式架构(短件内嵌/长件蚁群),并融入五行校验、不动点验证等传统数理模型。协议特别强调时间主权(干支历法引擎)、算力主权(纯国产化)和信息诚实性(不承诺数学不可能之事),建立了一套从编码存储到校验还原
大中型超市收银系统(可直接运行)
光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开
Behavioral Cryptography: A Multi-Factor Provenance Framework for Human-AI Collaborative Content Auth
摘要 本文提出行为密码学(Behavioral Cryptography),这是一个多因素来源追溯框架,将传统的内容水印技术从单一的“是否AI生成”问题扩展至更丰富的认证维度:“谁创作的?经过哪些规则处理?由哪个人格模块参与?留下哪些审计证据?”。该框架整合动态DNA签名、三色审计分类、不可篡改错误日志、语义保护术语、人格路由轨迹和价值观一致性向量六大要素,构建语义行为溯源体系。与易被篡改的单点水印不同,该方案通过创作身份、版本演化、生成语境等多因素关联形成计算不可伪造的完整证据链。研究基于龍魂系統实现,经
复分析 阿尔福斯(Ahlfors) 第三版答案 英文
答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案
UID9622 · 龍芯北辰 · 诸葛鑫 / Lucky
诸葛鑫(UID9622 · 龍芯北辰 / Lucky)的个人IP展示页呈现了一个致力于中国数字主权建设的创新者形象。作为退伍军人和初中文化背景的自主技术开发者,他创立了龍魂系统(Longhun System),包含38个模块的自主可控AI操作系统,核心成果包括中文原生脚本CNSH、三才算法框架、DNA追溯体系等。其项目强调数据主权归用户、技术根植本土的理念,通过开源协议和七维推演引擎等创新实现技术自主。个人宣言"再楠不惧,终成豪图"体现了从零起步的奋斗历程,所有开发成果均公开可查,践行"站着把事办好"的务实
FIPS ‘n’ Chips 2026:让未来触手可及
FIPS ‘n’ Chips大获成功,会议的“可及性”是其一大魅力。
零基础看懂 2026 工业互联网安全大赛全国预选赛 crypto-3
2026工业互联网安全大赛题crypto-3巧妙设计双路径攻击:一靠共享素因子(gcd分解模数),二靠Håstad广播攻击(e=3无填充+中国剩余定理)。两条独立路径均还原出明文,交叉验证后得flag。揭示密钥生成需随机、加密必填充、密钥全生命周期管理的重要性,体现“双路互证”在安全审计中的价值。
服务能启动、调用加密套件做签名校验报 libcrypto-1_1.dll 丢失:密码学依赖分析
在运行企业微服务客户端、网络安全审计工具或本地开发代理服务时,服务进程基础控制台可顺利拉起,但只要客户端发起带有 RSA 密钥签名、AES 对称加密或 SHA-256 完整性校验的远程认证请求,程序便突然抛出缺少 libcrypto-1_1.dll 错误并中断通信。排查前先把测试工程的私钥配置文件与证书链备份为安全副本,不改动正式生产密钥;常规网络监听只负责
安全存储之外(二):钱包密码学的安全实现
本文围绕攻击者不读取私钥存储副本也能恢复密钥的主题,梳理六起真实事件。第一部分阐明密钥生成、存储、使用三阶段的安全要求;随后分析四起密钥生成缺陷(Ill Bloom、Coldcard、XRPH Wallet、Qubic Wallet)如何因弱随机源、错误RNG绑定、输入转换和初始化状态过小导致密钥空间大幅缩小,以及两起签名缺陷(Zilliqa、SecondFi)如何因nonce偏差或完全可预测导致从公开签名恢复私钥。
FPGA 与加密行业:从算法加速到可信硬件的完整技术图谱
本文系统探讨FPGA与密码学的深度交叉,揭示其在加密加速、区块链基础设施、零知识证明及后量子密码中的关键作用。从底层硬件特性到工程实践,分析对称加密、公钥算法、零知识证明等负载的FPGA加速优势,强调其高能效、低延迟与灵活可重构的特性。结合当前密码学复杂度上升与硬件竞争加剧的趋势,指出FPGA是算法验证与高性能实现的理想载体,为安全计算提供高效硬件支撑。
BcoreOS安全通信架构:FsSession 抗算法后门安全设计
BcoreOS安全通信架构:FsSession 抗算法后门安全设计
[图解密码学]第6章 DES、AES 与 SM4
第6章 DES、AES 与 SM4第6章 DES、AES 与 SM4:一张“对称加密算法进化图”。左侧是DES的Feistel结构,标注“1977,56位密钥,64位分组,已破解”。中间是3DES和AES的SPN结构,标注“2001,128/192/256位密钥,128位分组,国际标准”。右侧是国密SM4的广义Feistel结构,标注“2006年公开,2012年国标,128位分组/128位密钥,中国商用密码标准”。
ESP32 上的后量子密码学
后量子密码算法现已标准化,用于保护联网设备抵御未来量子计算威胁。本文将介绍 esp-pqc 组件,该组件可为乐鑫 SoC 芯片引入 ML-KEM 与 ML-DSA 算法;同时展示 TLS 1.3 的实现方式以保障网络通信安全,以及 Secure Boot V2 实现固件完整性校验,并提供真实环境下的内存、闪存与性能基准测试数据。
基于格的密码学
本文用通俗的方式介绍基于格的密码学。先从“格”这一高维规则点阵的几何结构讲起,说明 SVP、CVP 等格上困难问题为何难以求解;再借助“棉花糖”类比解释公钥(坏基)与私钥(好基)的关系;随后分析其抗量子原因(Shor 算法失效、Grover 加速有限)、效率与功能优势,并列举 Kyber、Dilithium、Falcon、NTRU 等主流方案,最后厘清其与 LWE / Ring-LWE 的关系。
5111



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



