算子级别
● L1 完整 7 阶段流程动画 + 数据表 + 算法对比
@@ -439,17 +434,19 @@
diff --git a/demo/assets/secure_scenario/index.html b/demo/assets/secure_scenario/index.html
index 119d3e8..54a00a2 100644
--- a/demo/assets/secure_scenario/index.html
+++ b/demo/assets/secure_scenario/index.html
@@ -191,6 +191,32 @@
const $ = s => document.querySelector(s);
function esc(s){ return (s==null)?'':String(s).replace(/[&<>"']/g,c=>({'&':'&','<':'<','>':'>','"':'"',"'":'''}[c])); }
+/* 渲染「推理中」面板。
+ *
+ * 思考片段是长文本,外层提示是居中的 —— 继承居中会让一段英文推理被折成
+ * 居中几行,左右留大片空白,极难读。这里用 .thinking-panel 强制左对齐,
+ * 让它像日志一样从左往右顺读。
+ *
+ * `tail` 是后端保留的思考尾部(滚动窗口),所以渲染完自动滚到底部。
+ */
+function renderThinking(stage, tail) {
+ const t = (tail || '').replace(/[&<>]/g, c => ({'&':'&','<':'<','>':'>'}[c]));
+ const n = t.length;
+ return `
+
${esc(stage || '推理中')}…
+
+
模型思考过程${n ? n + ' 字符' : ''}
+
${t}
+
+
`;
+}
+
+/* 轮询刷新后把思考区滚到底部(tail 是尾部窗口,最新内容在最后)。 */
+function scrollThinkingToBottom() {
+ const b = document.getElementById('tp-body');
+ if (b) b.scrollTop = b.scrollHeight;
+}
+
let PRESET_DESC = {}, CURRENT = 'epidemiology', LAST_CODE = '';
const CHIPS = [
@@ -444,8 +470,8 @@ $('#btn-gen').onclick = async () => {
const job = await (await fetch(`/api/job/${j0.job_id}`)).json();
if (job.status === 'running') {
const p = job.progress || {};
- const tail = (p.thinking_tail || '').replace(/[&<>]/g, c => ({'&':'&','<':'<','>':'>'}[c]));
- $('#understanding').innerHTML = `
${esc(p.stage || '推理中')}…
${tail}
`;
+ $('#understanding').innerHTML = renderThinking(p.stage, p.thinking_tail);
+ scrollThinkingToBottom();
} else if (job.status === 'done') {
clearInterval(timer);
renderGen(job.result || {ok:false});
diff --git a/demo/assets/security_audit/index.html b/demo/assets/security_audit/index.html
index f9c03cb..12faef6 100644
--- a/demo/assets/security_audit/index.html
+++ b/demo/assets/security_audit/index.html
@@ -186,6 +186,33 @@ const $ = s => document.querySelector(s);
const LEVELS = ['Critical','High','Medium','Low','Info'];
const LEVEL_COLOR = { Critical:'var(--warn)', High:'#fb923c', Medium:'var(--bob)', Low:'var(--alice)', Info:'var(--text-dim)' };
+/* 渲染「推理中」面板。
+ *
+ * 思考片段是长文本,外层提示是居中的 —— 继承居中会让一段英文推理被折成
+ * 居中几行,左右留大片空白,极难读。这里用 .thinking-panel 强制左对齐,
+ * 让它像日志一样从左往右顺读。
+ *
+ * `tail` 是后端保留的思考尾部(滚动窗口),所以渲染完自动滚到底部,
+ * 免得每次轮询都把用户甩回中间。
+ */
+function renderThinking(stage, tail) {
+ const t = (tail || '').replace(/[&<>]/g, c => ({'&':'&','<':'<','>':'>'}[c]));
+ const n = t.length;
+ return `
+
${esc(stage || '推理中')}…
+
+
模型思考过程${n ? n + ' 字符' : ''}
+
${t}
+
+
`;
+}
+
+/* 轮询刷新后把思考区滚到底部(tail 是尾部窗口,最新内容在最后)。 */
+function scrollThinkingToBottom() {
+ const b = document.getElementById('tp-body');
+ if (b) b.scrollTop = b.scrollHeight;
+}
+
let TEMPLATES = {};
async function loadTpls() {
const r = await fetch('/security_audit/api/templates');
@@ -305,8 +332,8 @@ $('#btn-audit').onclick = async () => {
const job = await (await fetch(`/api/job/${j0.job_id}`)).json();
if (job.status === 'running') {
const p = job.progress || {};
- const tail = (p.thinking_tail || '').replace(/[&<>]/g, c => ({'&':'&','<':'<','>':'>'}[c]));
- $('#result').innerHTML = `
${esc(p.stage || '推理中')}…
${tail}
`;
+ $('#result').innerHTML = renderThinking(p.stage, p.thinking_tail);
+ scrollThinkingToBottom();
} else if (job.status === 'done') {
clearInterval(timer);
renderResult(job.result || {ok:false});
diff --git a/demo/src/ops/compliance_rules.rs b/demo/src/ops/compliance_rules.rs
index 4b87d11..deea4a7 100644
--- a/demo/src/ops/compliance_rules.rs
+++ b/demo/src/ops/compliance_rules.rs
@@ -117,12 +117,21 @@ fn digit_runs(line: &str) -> (usize, bool) {
}
/// 硬编码密钥:`api_key = "……"` 且值不短于 12 位字母数字。
+///
+/// # 必须兼容 Rust 的类型标注
+///
+/// Python 写 `API_KEY = "sk-live-..."`,Rust 写 `const API_KEY: &str = "sk-live-..."`
+/// —— 等号前夹着 `: &str`。只按「名字后面紧跟 `=`」匹配,Rust 这种**最常见**的
+/// 硬编码写法会整个漏掉(这正是本规则的真实盲区)。
+/// 所以这里允许在名字与等号之间跳过一段 Rust 类型标注。
fn hardcoded_secret(line: &str) -> bool {
let l = line.to_ascii_lowercase();
for name in ["api_key", "api-key", "apikey", "secret", "token", "passwd", "password"] {
let Some(pos) = l.find(name) else { continue };
- let rest = l[pos + name.len()..].trim_start();
- let Some(rest) = rest.strip_prefix('=') else { continue };
+ // `skip_type_annotation` 返回**等号之后**的内容。
+ let Some(rest) = skip_type_annotation(&l[pos + name.len()..]) else {
+ continue;
+ };
let rest = rest.trim_start();
let Some(quote) = rest.chars().next().filter(|c| *c == '"' || *c == '\'') else {
continue;
@@ -139,6 +148,38 @@ fn hardcoded_secret(line: &str) -> bool {
false
}
+/// 跳过「名字」与「=` 之间可能的 Rust 类型标注,返回**等号之后**的切片。
+///
+/// 认得的形式:
+/// - `API_KEY = "..."`(Python,无标注)→ 直接取 `=` 之后
+/// - `const API_KEY: &str = "..."` → 跳过 `: &str`
+/// - `let api_key: String = "..."` → 跳过 `: String`
+///
+/// 标注只允许类型里会出现的字符,且长度有上限 —— 否则容易跳到别的语句里去。
+fn skip_type_annotation(rest: &str) -> Option<&str> {
+ let trimmed = rest.trim_start();
+ // 无标注:直接是 `=`
+ if let Some(r) = trimmed.strip_prefix('=') {
+ return Some(r);
+ }
+ // 有标注:必须是 `:` 开头,且整段只含类型字符
+ let after_colon = trimmed.strip_prefix(':')?;
+ for (i, c) in after_colon.char_indices() {
+ if c == '=' {
+ return Some(&after_colon[i + 1..]);
+ }
+ let ok = c.is_alphanumeric()
+ || matches!(c, '_' | '&' | '*' | '<' | '>' | '[' | ']' | ',' | '(' | ')' | ' ' | ':');
+ if !ok {
+ return None;
+ }
+ if i > 48 {
+ return None;
+ }
+ }
+ None
+}
+
/// `let _ = ...` 是否真的**丢掉了返回值**(吞异常的典型写法)。
///
/// 只丢掉一个 `Result` 才算吞异常;`let _ = (sha256, derive, Stream::new);`
diff --git a/demo/src/ops/security_audit.rs b/demo/src/ops/security_audit.rs
index aa2b6f1..c1d90fb 100644
--- a/demo/src/ops/security_audit.rs
+++ b/demo/src/ops/security_audit.rs
@@ -698,47 +698,76 @@ fn job_poll(ctx: &Ctx) -> Result
{
// ─────────────────────────── 案例模板 ───────────────────────────
-const BAD_CODE: &str = r#"import hashlib, json, pickle, random, subprocess
-import pandas as pd, requests
+/// 反面案例:**Rust** 写的错误实现(ssw-mpc / Rust 风格)。
+///
+/// 为什么必须是 Rust 而不是 Python:本平台是 Rust 框架,审计引擎收到的
+/// 待审代码绝大多数是 Rust。拿一份 Python 反例当默认样例,会让人误以为
+/// 「平台审的是 Python」,也让规则引擎的 Rust 分支(方法调用、Rust 专有
+/// 弱哈希、`let _ =` 吞异常)失去演示意义。
+///
+/// 这份代码刻意覆盖 F01–F11 全部规则,且**故意用错 API 签名**
+/// (`blind` 传 4 参、`match_across` 传 4 参、`Handle::new` 少传 Label)
+/// —— 真实模型生成里最常见、也最难自查出来的错误。
+const BAD_CODE: &str = r#"//! 两家医院联合统计糖尿病阳性率 · 错误实现(反面案例)。
+//!
+//! 典型毛病:明文 join / 明文落盘 / md5 假匿名 / 假 DP / eval 注入 /
+//! 无远程证明 / 吞异常 / API 签名写错。
-# 从两家医院拉全量患者明细做联合统计
-patients = pd.read_csv("/data/hospital_a_patients.csv") # 含身份证、手机号、诊断
-peer = pd.read_csv("/data/hospital_b_patients.csv")
+use mpc_core::hash::sha256;
+use mpc_core::prg::Stream;
-API_KEY = "sk-live-9f3c1a77b2e04d6890ffab12cd34ef56" # 直连第三方分析服务
+use mpc_fl::{clip_l2, gaussian_noise};
+use mpc_policy::{Guard, Handle, Label};
+use mpc_psi::{blind, match_across, reblind};
-# 用身份证号做主键碰撞,直接明文 join
-merged = patients.merge(peer, on="id_card", how="inner")
-print("联合后的患者明细:", merged.head(20).to_dict())
+// 硬编码第三方服务密钥(应从 KMS 注入)
+const API_KEY: &str = "sk-live-9f3c1a77b2e04d6890ffab12cd34ef56";
-# 口令与匿名 id 都用 md5
-merged["pseudo_id"] = merged["id_card"].apply(lambda s: hashlib.md5(s.encode()).hexdigest())
-admin_pwd = hashlib.md5(b"Hosp!2026").hexdigest()
+fn main() {
+ // 从两家医院拉全量患者明细做联合统计(含身份证、手机号、诊断)
+ let patients = std::fs::read_to_string("/data/hospital_a_patients.csv").unwrap();
+ let peer = std::fs::read_to_string("/data/hospital_b_patients.csv").unwrap();
-# 结果落盘 + 回传第三方
-merged.to_csv("/tmp/joint_patients.csv", index=False)
-with open("/tmp/cache.pkl", "wb") as f:
- pickle.dump(merged, f)
-requests.post("https://analytics.example.com/upload",
- json={"key": API_KEY, "rows": merged.to_dict("records")})
+ // 用身份证号做主键碰撞,直接明文 join
+ let merged = format!("{patients}\n{peer}");
+ println!("联合后的患者明细: {}", &merged[..120]);
-# 号称"差分隐私",实际只是随便加了个噪声,没有任何预算记账
-positive = int(merged["diabetes"].sum()) + random.gauss(0, 1.0)
+ // 口令与匿名 id 都用 md5
+ let pseudo_id = md5::compute(b"310101199001011234");
+ let admin_pwd = md5::compute(b"Hosp!2026");
-# 运营方传进来的过滤条件直接拼进查询并 eval
-flt = get_user_filter()
-subset = eval(f"merged[merged['age'] {flt}]", {"merged": merged})
-subprocess.run(f"rsync -a /tmp/joint_patients.csv backup:{flt}", shell=True)
+ // 结果落盘 + 回传第三方
+ std::fs::write("/tmp/joint_patients.csv", merged.as_bytes()).unwrap();
+ let _cache = std::fs::write("/tmp/cache.pkl", merged.as_bytes()).unwrap();
+ let _client = reqwest::Client::new();
+ let _resp = reqwest::Client::new().post("https://analytics.example.com/upload").body(merged.clone()).send();
-# 模型侧:不做远程证明就把明文推进 enclave
-enclave.load_plaintext(merged.values)
+ // 号称"差分隐私",实际只是随便加了个噪声,没有任何预算记账
+ let positive = 42.0 + gaussian_noise(1, 1.0, 7)[0];
-try:
- verify_partner_signature(peer)
-except:
- pass # 签名验不过也继续跑
+ // 运营方传进来的过滤条件直接拼进查询并 eval
+ let flt = get_user_filter();
+ let subset = eval(f"merged[merged['age'] {flt}]");
+ let _cmd = std::process::Command::new("/bin/sh").arg("-c").arg(format!("rsync -a /tmp/joint_patients.csv backup:{flt}")).spawn();
-print(f"阳性人数(加噪) = {positive}, 身份证样例 = 310101199001011234")
+ // 模型侧:不做远程证明就把明文推进 enclave
+ let _plain = enclave.load_plaintext(merged.as_bytes());
+
+ // 签名验不过也继续跑
+ if let Err(_e) = verify_partner_signature(&peer) {
+ let _ = std::fs::write("/tmp/verify_failed.log", b"ignored");
+ }
+
+ // API 签名写错:blind 传了 4 个参数(真实签名 3 个),
+ // match_across 传了 4 个(真实 2 个),Handle::new 少传 Label
+ let key_a = sha256(b"psi-key-a");
+ let mut stream = Stream::new(&key_a);
+ let _pts = blind(&[], &key_a, &mut stream, "extra-domain");
+ let _hits = match_across(&[], &[], &key_a, &key_b);
+ let _handle = Handle::new("hospital_a");
+
+ println!("阳性人数(加噪) = {positive}, 身份证样例 = 310101199001011234");
+}
"#;
const GOOD_CODE: &str = r#"//! 两家医院联合统计糖尿病阳性率 · 可信数据空间合规实现(ssw-mpc / Rust)。
@@ -852,7 +881,7 @@ fn templates(_ctx: &Ctx) -> Result {
crate::jobj! {
"id" => "bad_v1",
"name" => "反面案例 · 联合统计的错误实现",
- "desc" => "明文 join / 明文回传 / md5 假匿名 / 假 DP / eval 注入 / 无远程证明",
+ "desc" => "Rust 写法 · 明文 join / 明文落盘回传 / md5 假匿名 / 假 DP / eval 注入 / 无远程证明 / 吞异常 / API 签名写错",
"code" => BAD_CODE,
},
crate::jobj! {
@@ -886,18 +915,26 @@ mod tests {
);
}
- /// 反面案例(Python)应命中全套 F01–F10。
+ /// 反面案例(Rust)应命中全套 F01–F11。
#[test]
- fn bad_python_example_hits_all_rules() {
+ fn bad_rust_example_hits_all_rules() {
let found = ids(BAD_CODE);
- for id in ["F01", "F02", "F03", "F04", "F05", "F06", "F07", "F09", "F10"] {
+ for id in ["F01", "F02", "F03", "F04", "F05", "F06", "F07", "F08", "F09", "F10", "F11"] {
assert!(found.contains(&id), "反面案例漏判 {id},实际命中 {found:?}");
}
}
- /// Rust 反例:明文落盘 + 弱哈希 + 外发未证明 + 加噪未记账 + 吞异常。
+ /// 反面案例里故意写错的 API 签名必须被 F11 抓到 —— 这是「代码编译不过」的
+ /// 唯一可机检信号,也是平台自生成代码最常见的翻车点。
#[test]
- fn bad_rust_example_hits_rules() {
+ fn bad_rust_example_catches_wrong_signatures() {
+ let found = ids(BAD_CODE);
+ assert!(found.contains(&"F11"), "反面案例里的错签名没被 F11 抓到");
+ }
+
+ /// 最小 Rust 反例:明文落盘 + 弱哈希 + 外发未证明 + 加噪未记账 + 吞异常。
+ #[test]
+ fn minimal_bad_rust_snippet_hits_rules() {
let code = r#"
fn main() {
let rows = std::fs::write("/tmp/plain.csv", b"id_card,name").unwrap();
@@ -1098,6 +1135,44 @@ fn run(mut guard: Guard, tee: &mut dyn Tee) -> Result<(), String> {
);
}
+ /// F04 必须认 Rust 的**类型标注写法**:`const API_KEY: &str = "..."`。
+ ///
+ /// 这是本规则的真实盲区:原来只按「名字后面紧跟 `=`」匹配,Rust 最常见的
+ /// 硬编码密钥写法(中间夹着 `: &str`)会整个漏掉 —— 等号前有标注就匹配不上。
+ #[test]
+ fn f04_detects_rust_const_with_type_annotation() {
+ let rust_const = r#"
+const API_KEY: &str = "sk-live-9f3c1a77b2e04d6890ffab12cd34ef56";
+fn main() {}
+"#;
+ assert!(
+ ids(rust_const).contains(&"F04"),
+ "Rust const + 类型标注的硬编码密钥漏判(盲区未修)"
+ );
+
+ let rust_let = r#"
+fn main() {
+ let api_key: String = "sk-live-9f3c1a77b2e04d6890ffab12cd34ef56".to_string();
+}
+"#;
+ assert!(
+ ids(rust_let).contains(&"F04"),
+ "Rust let + 类型标注的硬编码密钥漏判(盲区未修)"
+ );
+
+ // Python 写法仍要认
+ assert!(
+ ids(r#"API_KEY = "sk-live-9f3c1a77b2e04d6890ffab12cd34ef56""#).contains(&"F04"),
+ "Python 硬编码密钥漏判"
+ );
+
+ // 短值 / 非密钥名不该误报
+ assert!(
+ !ids(r#"const NAME: &str = "hospital";"#).contains(&"F04"),
+ "普通常量被误判成硬编码密钥"
+ );
+ }
+
/// F09 认 Rust 的 `AuditLog` / `audit.record`。
#[test]
fn f09_detects_rust_audit() {