# 金融数据安全专家培训课程 · 实验操作完整手册（合订本）v1.0

> 思度安全 · 信息安全基础知识的传播者
> 本合订本收录全部 14 个实验的完整操作步骤，"照抄即跑"格式：前置条件 → 照抄命令 → 预期输出 → 验收自查 → 评分要点 → FAQ → 提交物。
> 全部实验基于演练平台合成数据（192.168.32.130），无任何真实客户数据。

## 环境速查（详见《README.md》）

| 服务 | 地址 | 账号/密码 |
|---|---|---|
| MySQL 业务库 | 192.168.32.130:3306 / bank_biz | root / fds_root_2026 |
| MySQL 影子库 | 192.168.32.130:3307 / bank_shadow | root / fds_root_2026 |
| PostgreSQL（RLS） | 192.168.32.130:15432 / bank_rl | postgres / fds_pg_2026 |
| OpenSearch | http://192.168.32.130:9200 | — |
| Dashboards | http://192.168.32.130:5601 | 首次见使用说明 |
| 自研 KMS | http://192.168.32.130:8100（/docs 在线调） | — |
| Streamlit 控制台 | http://192.168.32.130:8501 | — |

## 实验总索引与依赖顺序

| # | 实验 | 对应模块 | 依赖 |
|---|---|---|---|
| 1 | 法规义务映射表 | M1 | 无 |
| 2 | 敏感数据识别与打标 | M2 | 实验1 |
| 3 | 资产清单扫描 | M2 | 实验2 |
| 4 | 分类分级清单交付 | M2 | 实验3 |
| 5 | 静态脱敏 | M3 | 实验3 |
| 6 | 动态脱敏 | M3 | 实验5 |
| 7 | 字段级加密 + KMS | M3/M2.5 | M2.5 理论 |
| 8 | 共享通道审批留痕 | M3 | 实验7 |
| 9 | RLS 与高危规则 | M4 | 环境 |
| 10 | 内部人批量导出监测 | M4 | 实验9 + 实验14 |
| 11 | 出境合规评估演练 | M6 | 实验4 |
| 12 | 毕业设计 | M8 | 实验1-11 |
| 13 | SM2 签名验签 | M2.5 | 无 |
| 14 | 数据库水印溯源 | M2.5 | 实验9（平台数据）|

---



---

<!-- ======== 实验01-法规义务映射表.md ======== -->

# 实验1 · 法规义务映射表

> 对应模块 M1 ｜ 2 学时 ｜ 产出物：《法规义务-标准条款-技术措施映射表.xlsx》（纳入作品集）
> 本实验不需要写代码，产出物就是你求职面试时"我真的做过映射"的证明

## 实验目标
把"一部法 + 三部法 + 一个条例 + 一份监管文件 + 一套行业标准"翻译成一张可执行的表：
**每条监管义务 → 对应标准条款 → 我行技术/管理措施 → 责任部门 → 现状差距**。

## 前置条件
- 已看完 M1 讲稿第 1-2 节
- 能打开本课程提供的模板：`labs/manuals/exp01-模板/义务映射表-模板.xlsx`

## 准备工作（5 分钟）
1. 打开课程环境控制台 http://192.168.32.130:8501（环境正常即可，本实验主要查资料）
2. 下载模板到本地，另存为 `义务映射表-你的姓名.xlsx`
3. 准备检索源（全部免费公开）：
   - 网安法/数安法/个保法全文：中国政府网 www.gov.cn 搜索法规名
   - 金规〔2024〕24号：国家金融监督管理总局官网"政策文件"栏目
   - JR/T 0071、GB 39786 目录：全国金融标准化技术委员会官网可查标准名称与范围页

## 实验步骤（照抄执行）

### Step 1：建立行骨架（约 15 分钟）
在模板"映射表"工作表里，按下列义务来源各建 2-4 行（模板已预置，逐行确认即可）：

| 义务来源 | 预置义务行示例 |
|---|---|
| 网安法 | 等级保护定级备案（第21条）；日志留存≥6个月（第21条） |
| 数安法 | 数据分类分级（第21条）；重要数据风险评估（第30条） |
| 个保法 | 处理告知-同意（第13/17条）；敏感个信单独同意（第28-29条） |
| 网数条例 | 年度数据安全风险评估并报送；明确数据安全负责人与管理机构 |
| 金规〔2024〕24号 | 党委（党组）/董事会承担主体责任；数据安全负责人任职备案 |
| JR/T 0197 | 5 级定级方法；C1/C2/C3 敏感级映射 |
| GB 39786 | 密码应用四层面要求（物理/网络/设备/数据） |

### Step 2：逐行填"技术/管理措施"列（约 40 分钟）
对着课程实验环境填，保证每一行措施是"看得见摸得着"的：

- 例：**数据分类分级（数安法第21条）** → 措施填：
  "实验2 正则识别打标 + 实验3 资产扫描 + 实验4 输出《分类分级清单》"，
  责任部门填"数据管理部"，现状填"进行中"
- 例：**日志留存≥6个月（网安法第21条）** → 措施填：
  "审计日志接 OpenSearch（实验9）"，现状去 5601 看板确认有 `fds-audit*` 索引后填"已落地"
- 禁止填"加强管理""高度重视"这类空话——评分时一行空话扣一分

### Step 3：交叉自检（约 20 分钟）
用三个问题逐行自检，在"自检"列填 是/否：
1. 这条义务的**原文出处**（法名+条号）写了吗？
2. 对应的**标准条款**（如 JR/T 0197 第 X 章）找得到吗？
3. 措施能落到**一个岗位 + 一个系统/文档**吗？

三问有一问"否"，该行视为未完成。

### Step 4：抽查答辩（直播课环节）
每期随机抽 3 名学员，直播时讲你映射表里的任意一行：义务→条款→措施→证据。

## 验收自查
- [ ] 表内 ≥ 16 行有效映射（模板预置行全部完成）
- [ ] 每行三问自检全部"是"
- [ ] 至少 3 行的现状列引用了课程实验环境的实际验证结果
- [ ] 文件名包含你的姓名

## 评分要点（10 分制）
- 义务出处准确（3 分）：条号错一行扣 0.5
- 措施可落地可举证（4 分）：空话行每行扣 1
- 现状与证据真实（2 分）：引用实验环境实际状态
- 格式规范（1 分）

## 常见问题
| 问题 | 处理 |
|---|---|
| 找不到 24 号文原文 | 总局官网检索"金规〔2024〕24号"，检索不到时用讲稿第 2 节的条款摘要并在备注注明"依课程讲稿" |
| 标准全文要付费 | 只要求对齐"范围+框架"层级，标准目录页免费可查即可，不必购买全文 |
| 一条义务找不到对应标准 | 允许填"无直接标准"，但要在备注说明判断依据 |

## 提交物
`义务映射表-姓名.xlsx` 上传至班级作业区（实验1 通道）。


---

<!-- ======== 实验02-识别打标.md ======== -->

# 实验2 · 敏感数据字段识别打标（规则引擎 + Presidio）

> 对应模块 M2 ｜ 2 学时 ｜ 产出物：识别打标脚本 + 打标结果 CSV
> 原则：正则打底理解原理，Presidio 增强看效果，组合升级规则自己写

## 实验目标
对 `customers` 表完成字段级识别打标：每列打上【业务类别 + 敏感级别 + 依据】，并实现"组合升级"判定（身份证+手机号同表 → 整表升级）。

## 前置条件
- 实验环境 7 服务全部 Up（`sudo docker compose ps` 确认）
- 本机装有 Python 3.10+（或用 VM 内 python3）
- MySQL 业务库：192.168.32.130:3306，库 bank_biz，账号 root / fds_root_2026

## 准备工作（10 分钟）
```bash
mkdir fds-exp02 && cd fds-exp02
pip install pymysql pandas            # 国内网络慢可加 -i https://pypi.tuna.tsinghua.edu.cn/simple
```
连通性自检（照抄执行）：
```bash
python -c "import pymysql; c=pymysql.connect(host='192.168.32.130',port=3306,user='root',password='fds_root_2026',database='bank_biz'); print('OK', c.open)"
```
预期输出：`OK True`。失败先查 VPN/防火墙和 3306 端口。

## 实验步骤

### Step 1：先人工看数据（5 分钟）
```bash
python - << 'EOF'
import pymysql, pandas as pd
c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
df = pd.read_sql("SELECT * FROM customers LIMIT 5", c)
print(df.T)
EOF
```
把每列记下来：name / id_number / phone / email / address / …——这就是你的"待识别清单"。

### Step 2：写规则引擎（核心步骤，约 30 分钟）
新建 `rule_engine.py`，照抄以下骨架（★★ 标注处为你要补的空）：

```python
import pymysql, pandas as pd, re, yaml, json

RULES = {  # 正则规则：列名 -> (规则名, 正则, 级别, 依据)
    "id_number": ("证件号",   r"^\d{17}[\dX]$",        "C2", "JR/T 0197 表1"),
    "phone":     ("手机号",   r"^1[3-9]\d{9}$",        "C2", "JR/T 0197 表1"),
    "email":     ("邮箱",     r"^[^@\s]+@[^@\s]+\.[a-z]{2,}$", "C1", "JR/T 0197 表1"),
    # ★★ 补一条"银行卡号"规则：16-19 位数字，级别 C2，依据同上
}

def load_yaml(path):
    with open(path, encoding='utf-8') as f:
        return yaml.safe_load(f)

def classify_table(df: pd.DataFrame, combos: list) -> list:
    rows = []
    for col in df.columns:
        hit = None
        for name, pat, level, basis in RULES.values():
            if df[col].astype(str).str.match(pat).mean() > 0.8:  # 80% 命中才认定
                hit = (col, name, level, basis); break
        if hit: rows.append(hit)
        else:   rows.append((col, "未识别", "C3以下", "人工判断"))
    # ★★ 组合升级判定：若同表同时存在 C2 的 id_number 与 phone，
    #    整表级别升级为"3级(敏感)"，在结果里加一行 level='3级-组合升级'
    return rows

if __name__ == "__main__":
    conn = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                           password='fds_root_2026', database='bank_biz')
    df = pd.read_sql("SELECT * FROM customers", conn)
    combos = load_yaml("combos.yaml")
    result = pd.DataFrame(classify_table(df, combos),
                          columns=["column", "识别类型", "级别", "依据"])
    result.to_csv("exp02_打标结果.csv", index=False, encoding="utf-8-sig")
    print(result)
```

再建组合规则文件 `combos.yaml`（★ 自己补第二组）：
```yaml
combo_rules:
  - when_all_present: [id_number, phone]
    upgrade_to: "3级-组合升级"
    basis: "JR/T 0197 5.2 组合标识符规则"
  # ★ 补一组：邮箱 + 姓名 同表 -> "2级"
```

### Step 3：运行并核对（10 分钟）
```bash
pip install pyyaml
python rule_engine.py
```
预期：输出表里 `id_number`、`phone` 标 C2，末尾出现 `3级-组合升级` 行。

### Step 4：Presidio 增强（选做加分，约 30 分钟）
```bash
pip install presidio-analyzer
python -m spacy download zh_core_web_sm    # 中文小模型，约 50MB
```
```python
from presidio_analyzer import AnalyzerEngine
a = AnalyzerEngine()
res = a.analyze(text="张三,身份证 110101199003074258,手机 13812345678",
                language="zh")
for r in res: print(r.entity_type, r.start, r.end, round(r.score, 2))
```
预期：识别出 PERSON / ID_CARD 类似实体。把 Presidio 与正则的**召回差异**记进实验报告。

### Step 5：跑全部五张表（10 分钟）
把 Step 2 的主循环对 `accounts / transactions / credit_query_log / wealth_risk_eval` 各执行一次，
结果合并输出 `exp02_全表打标.csv`。

## 验收自查
- [ ] 自写的银行卡号规则能命中 accounts 表卡号列
- [ ] combos.yaml 有 ≥ 2 条组合规则且生效
- [ ] 两个 CSV 已生成
- [ ] （选做）Presidio 差异记录 ≥ 3 条

## 评分要点（10 分制）
规则补全且命中 3 分｜组合升级逻辑正确 3 分｜五表全跑 2 分｜Presidio 差异分析 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| 连不上 3306 | 确认在课程 VPN/内网；或改在 VM 内执行（host 写 127.0.0.1） |
| spacy 模型下载失败 | 用清华 pip 源重试；实在不行 Presidio 部分记"环境受限"，不影响及格 |
| 中文列名乱码 | CSV 用 utf-8-sig（骨架已带），Excel 打开即正常 |

## 提交物
`rule_engine.py` + `combos.yaml` + `exp02_打标结果.csv` + `exp02_全表打标.csv`（选做附 Presidio 笔记）


---

<!-- ======== 实验03-资产清单扫描.md ======== -->

# 实验3 · 数据资产盘点：扫描数据库生成资产清单

> 对应模块 M2 ｜ 2 学时 ｜ 产出物：《数据资产清单.xlsx》（含库/表/字段/体量/负责人/级别）
> 一句话：分类分级的前提是"知道自己有什么数据"——盘点比识别更枯燥也更值钱

## 实验目标
对课程环境 3 个数据库（MySQL 业务库、MySQL 影子库、PostgreSQL）做全量 schema 扫描，输出带敏感级别标注的资产清单，并发现 1 个"影子库违规拷贝"风险点。

## 前置条件
- 实验2 完成（打标结果可复用）
- 库连接信息：
  - MySQL 业务库 192.168.32.130:3306，bank_biz，root / fds_root_2026
  - MySQL 影子库 192.168.32.130:3307，bank_shadow，root / fds_root_2026
  - PostgreSQL 192.168.32.130:15432，bank_rl，postgres / fds_pg_2026

## 实验步骤

### Step 1：扫描三个库的元数据（20 分钟）
新建 `scan_assets.py` 照抄：

```python
import pymysql, psycopg2, pandas as pd

def scan_mysql(host, port, db):
    c = pymysql.connect(host=host, port=port, user='root',
                        password='fds_root_2026', database='information_schema')
    sql = """
    SELECT table_schema AS 库, table_name AS 表,
           table_rows AS 行数估算,
           ROUND(data_length/1024/1024,1) AS 大小MB,
           table_comment AS 备注
    FROM tables WHERE table_schema = %s"""
    tables = pd.read_sql(sql, c, params=(db,))
    cols = pd.read_sql("""
    SELECT table_name AS 表, column_name AS 字段, column_type AS 类型,
           column_comment AS 注释
    FROM columns WHERE table_schema = %s""", c, params=(db,))
    c.close()
    return tables, cols

t1, c1 = scan_mysql('192.168.32.130', 3306, 'bank_biz')
t2, c2 = scan_mysql('192.168.32.130', 3307, 'bank_shadow')

pg = psycopg2.connect(host='192.168.32.130', port=15432, user='postgres',
                      password='fds_pg_2026', dbname='bank_rl')
t3 = pd.read_sql("""
    SELECT schemaname AS 库, relname AS 表,
           n_live_tup AS 行数估算,
           pg_size_pretty(pg_total_relation_size(relid)) AS 大小
    FROM pg_stat_user_tables""", pg)

print("== bank_biz ==");  print(t1)
print("== bank_shadow =="); print(t2)
print("== bank_rl ==");    print(t3)
t1.assign(实例="mysql-biz").append(t2.assign(实例="mysql-shadow")) \
  .to_csv("exp03_表清单.csv", index=False, encoding="utf-8-sig")
c1.assign(实例="mysql-biz").append(c2.assign(实例="mysql-shadow")) \
  .to_csv("exp03_字段清单.csv", index=False, encoding="utf-8-sig")
```

运行：`python scan_assets.py`，检查两个 CSV 已生成。

### Step 2：合并打标结果（15 分钟）
用 Excel 或 pandas 把 `exp03_字段清单.csv` 与实验2 的 `exp02_全表打标.csv` 按"表+字段"左连接，
给每个字段补上【识别类型/级别】两列：
```python
f = pd.read_csv("exp03_字段清单.csv")
m = pd.read_csv("exp02_全表打标.csv")        # 列名按你实验2的输出调整
merged = f.merge(m, on=["表", "字段"], how="left")
merged.to_csv("exp03_字段清单-已定级.csv", index=False, encoding="utf-8-sig")
```

### Step 3：发现影子库风险（15 分钟）——本实验的点睛之笔
```bash
python - << 'EOF'
import pymysql, pandas as pd
a = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
b = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                    password='fds_root_2026', database='bank_shadow')
da = pd.read_sql("SELECT * FROM customers LIMIT 3", a)
db = pd.read_sql("SELECT * FROM customers LIMIT 3", b)
print("业务库样例:"); print(da)
print("影子库样例:"); print(db)
EOF
```
对比输出回答三个问题并写进报告：
1. 影子库和业务库的字段结构一致吗？（一致=全量拷贝）
2. 影子库的数据**脱敏了吗**？（看姓名/证件号是否明文）
3. 影子库有没有单独的访问控制与审批记录？（去控制台页签⑥查审计）

结论写法示例：**"shadow 库为生产库全量拷贝、含明文 C2 字段、无独立审批——构成 M3 实验5 的整改对象"**。

### Step 4：补齐管理信息（10 分钟）
清单补 3 列：负责人（自拟岗位如"科技部-数据管理员"）、存储位置（实例名）、定级（继承实验2）。
真实工作中这三列最难填——课程里允许自拟，但格式必须齐。

## 验收自查
- [ ] 两个 CSV 覆盖 3 个库全部业务表
- [ ] 每个字段有级别标注（含"未识别-待人工"也算标注）
- [ ] 影子库风险结论 ≥ 3 句话有对比证据
- [ ] 负责人/位置/定级三列齐全

## 评分要点（10 分制）
扫描完整 3 分｜定级合并正确 3 分｜影子库风险发现与论证 3 分｜清单字段齐全 1 分

## 常见问题
| 问题 | 处理 |
|---|---|
| append 报 FutureWarning/AttributeError | 新版 pandas 改用 `pd.concat([t1, t2], ignore_index=True)` |
| PG 行数估算为 0 | 统计信息未更新；先在 PG 里对每表跑一次 `SELECT count(*)` 再看 |
| 影子库连不上 | 3307 是容器映射端口，确认 `docker compose ps` 里 mysql-shadow Up |

## 提交物
`scan_assets.py` + `exp03_表清单.csv` + `exp03_字段清单-已定级.csv` + 影子库风险分析（≥3 句）


---

<!-- ======== 实验04-分类分级清单交付.md ======== -->

# 实验4 · 交付《数据分类分级清单》

> 对应模块 M2 ｜ 2 学时 ｜ 产出物：《数据分类分级清单》正式版（模板发放）
> 这是实验2+3 的"毕业汇演"：两张 CSV 变成一份能拿给监管看、能拿进作品集的正式交付物

## 实验目标
把识别打标与资产盘点的技术产出，整理成符合监管报送口径的正式清单：分类目录对齐 GB/T 43697，分级依据对齐 JR/T 0197，并输出"重要数据识别结论"专节。

## 前置条件
- 实验2、实验3 完成
- 模板：`labs/manuals/exp04-模板/分类分级清单-模板.xlsx`（含 4 个工作表）

## 实验步骤

### Step 1：建分类目录（30 分钟）
在模板"分类目录"工作表，把课程环境五张表归入 GB/T 43697 风格的一级/二级分类：

| 表 | 一级分类 | 二级分类 | 依据 |
|---|---|---|---|
| customers | 个人信息 | 客户身份信息 | 直接识别自然人 |
| accounts | 业务数据 | 账户信息 | 金融账户标识 |
| transactions | 业务数据 | 交易流水 | 资金链路 |
| credit_query_log | 日志数据 | 征信查询日志 | 含查询行为与操作员 |
| wealth_risk_eval | 个人信息 | 投资者适当性 | 风险测评结果 |

允许你调整归类，但**每个归类必须有依据列**，不允许空。

### Step 2：定级与"组合升级"复核（30 分钟）
在"分级结果"工作表逐表填：级别（JR/T 0197 5级制 + C1/C2/C3 映射）、定级依据、影响对象。
重点复核三处（这是评分采分点）：
1. **customers**：单字段 C2，但 id_number+phone 同表 → 组合升级为 3级/敏感（引用实验2 结论）
2. **credit_query_log**：含操作员标识 → 注意"日志也是个人信息"，不能因为它是日志就降级
3. **transactions**：金额本身不敏感，但 account_id+时间+金额可还原客户资金画像 → 说明你取的口径（整表定级 vs 字段定级）

### Step 3：重要数据识别专节（20 分钟）
按 GB/T 43697"重要数据"判断维度逐项过一遍，写 200 字结论。参考答法（口径自洽即可）：
> 课程环境为虚构城商行核心数据集：客户身份信息 3000 条 + 交易流水 36 万条。若为真实环境，
> 规模达到地区性银行量级、影响公民人身财产安全 → **大概率触发重要数据目录**。
> 本次交付结论：疑似重要数据，需按属地目录比对后报送；建议先按重要数据管控（从高原则）。

### Step 4：变更与例外说明（15 分钟）
"例外与说明"工作表至少写 2 条，例如：
- 测试环境（影子库）与生产同构 → 单独一行风险登记，链接实验3 结论
- 字段级与表级定级冲突时的取数口径：**从高**

### Step 5：格式合规检查（15 分钟）
对照检查表逐项打勾：
- [ ] 页眉含"密级：内部"与版本号 v1.0
- [ ] 每个表都有"定级依据"（法条/标准条款号）
- [ ] 无空单元格（没有就写"不适用"）
- [ ] 文件名：`分类分级清单-虚构城商行-姓名-v1.0.xlsx`

## 验收自查
- [ ] 4 个工作表全部填写完成
- [ ] 三处重点复核都有明确结论
- [ ] 重要数据专节 ≥ 200 字且口径自洽
- [ ] 格式检查表全勾

## 评分要点（10 分制）
分类依据 2 分｜定级与组合升级复核 3 分｜重要数据专节质量 3 分｜交付格式 2 分
（本实验产出物同时进入毕业作品集，按"可对外展示"标准要求）

## 常见问题
| 问题 | 处理 |
|---|---|
| 5级制和 C1/C2/C3 对不上 | 用课程 M2 讲稿的映射表：C3≈3级敏感、C2≈2级，写清对应关系即可 |
| 重要数据结论不确定 | 正确姿势就是"疑似+从高管控+待属地目录比对"，敢写不确定比乱写结论得分高 |
| 组合升级规则争议 | 备注"依 JR/T 0197 5.2 及课程口径"，允许标注公司自定义规则的存在 |

## 提交物
《分类分级清单》正式版 xlsx（进作品集）+ 一段 100 字交付说明（这份清单给谁、解决什么问题）


---

<!-- ======== 实验05-静态脱敏.md ======== -->

# 实验5 · 静态脱敏：保留格式 / 泛化 / 置换

> 对应模块 M3 ｜ 2 学时 ｜ 产出物：脱敏脚本 + 影子库脱敏后数据 + 三算子对比表
> 把实验3 发现的"影子库明文拷贝"真正整改掉——前后呼应

## 实验目标
对 `customers` 表的三类字段实现三种脱敏算子，写入 MySQL 影子库（bank_shadow），并用脚本证明"脱敏后仍可用于开发测试"。

## 前置条件
- 影子库：192.168.32.130:3307，库 bank_shadow，root / fds_root_2026
- 业务库：192.168.32.130:3306，bank_biz（只读源）
- 已装 `pip install pymysql pandas`

## 实验步骤

### Step 1：影子库建表（10 分钟）
```bash
python - << 'EOF'
import pymysql
c = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                    password='fds_root_2026', database='bank_shadow')
cur = c.cursor()
cur.execute("""CREATE TABLE IF NOT EXISTS customers_masked (
  id INT PRIMARY KEY,
  name VARCHAR(64)      COMMENT '置换',
  id_number VARCHAR(18) COMMENT '保留格式(FFX演示)',
  phone    VARCHAR(11)  COMMENT '遮盖',
  age      INT          COMMENT '泛化',
  city     VARCHAR(32)  COMMENT '保留')""")
cur.execute("TRUNCATE TABLE customers_masked")
c.commit(); print("表就绪")
EOF
```

### Step 2：实现三种算子（核心步骤，30 分钟）
新建 `mask.py`，★ 处为你要自己补的：

```python
import pymysql, pandas as pd, hashlib

def mask_ffx_id(idn: str) -> str:
    """保留格式：18位仍18位、校验位仍合法感（演示版用确定性混淆）。
    ★ 工程版要求：前6位区划改为'110101'统一化，中间8位哈希置换，
      第18位重算使 Luhn/身份证校验仍通过——参考 M3 讲稿第三节 FFX 思路补全"""
    h = hashlib.sha256(idn.encode()).hexdigest()
    body = ''.join(str(int(h[i*2:i*2+2], 16) % 10) for i in range(11))
    return "110101" + body[:11].ljust(11, '0') + idn[-1]

def mask_generalize_age(age: int) -> str:
    """泛化：精确年龄 -> 5 岁年龄段。★ 自己实现：24 -> '20-24'"""
    return f"{age//5*5}-{age//5*5+4}"

def mask_substitute_name(name: str, salt: str = 'fds2026') -> str:
    """置换：同名同映射（可还原一致性）。★ 要求：'张三' 永远映射到同一个假名"""
    h = hashlib.sha256((salt + name).encode()).hexdigest()
    surnames = "李王张刘陈杨赵黄周吴"
    givens = "伟芳娜敏静磊军洋勇艳杰娟涛明超霞平刚桂英华"
    return surnames[int(h[:2], 16) % 10] + givens[int(h[2:4], 16) % 20]

def mask_phone(p: str) -> str:
    return p[:3] + "****" + p[7:]

if __name__ == "__main__":
    src = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                          password='fds_root_2026', database='bank_biz')
    df = pd.read_sql("SELECT * FROM customers", src)
    out = pd.DataFrame({
        "id": df["id"], "name": df["name"].astype(str).map(mask_substitute_name),
        "id_number": df["id_number"].astype(str).map(mask_ffx_id),
        "phone": df["phone"].astype(str).map(mask_phone),
        "age": df["age"].astype(int).map(mask_generalize_age),
        "city": df["address"].astype(str).str[:2],
    })
    dst = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                          password='fds_root_2026', database='bank_shadow')
    out.to_sql("customers_masked", dst, if_exists="replace", index=False)
    out.head(5).to_csv("exp05_样例.csv", index=False, encoding="utf-8-sig")
    print(out.head(5))
```

> 影子库无 age 列时，把 age 泛化列可先对 customers 里已有年龄段字段执行；
> 若表结构不同，按实际字段名调整——这本身就是实验的一部分。

### Step 3：三算子对比表（20 分钟）
对照写入报告（模板）：

| 算子 | 示例输入 | 示例输出 | 可逆性 | 适用场景 | 本例用于 |
|---|---|---|---|---|---|
| 遮盖 | 13812345678 | 138****5678 | 不可逆 | 展示层、客服 | phone |
| 泛化 | 24 | 20-24 | 不可逆 | 统计分析、报表 | age |
| 置换 | 张三 | 王伟 | 可逆(带盐) | 测试库、需保持关联 | name |
| 保留格式 | 110101…X | 110101…X | 密钥可逆 | 需通过下游校验 | id_number |

补一行结论：**为什么 id_number 不用遮盖？**（提示：下游many系统按18位校验，遮盖后测试跑不通）

### Step 4：可用性验证（10 分钟）
证明脱敏数据"还能用"：
```bash
python - << 'EOF'
import pymysql, pandas as pd
c = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                    password='fds_root_2026', database='bank_shadow')
df = pd.read_sql("SELECT city, COUNT(*) n FROM customers_masked GROUP BY city ORDER BY n DESC LIMIT 5", c)
print(df)   # 分布统计仍可跑
EOF
```

### Step 5：泄露风险验证（10 分钟）
在脱敏后数据里搜原身份证号，证明 0 命中：
```bash
python - << 'EOF'
import pymysql
c = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                    password='fds_root_2026', database='bank_shadow')
cur = c.cursor()
cur.execute("SELECT COUNT(*) FROM customers_masked WHERE id_number IN (SELECT id_number FROM …)")
# 换成：取业务库原 100 个证件号，到影子库查命中数，预期 0
EOF
```
（提示：读业务库 100 个证件号 → 影子库 `WHERE id_number IN (...)`，报告贴 0 命中截图）

## 验收自查
- [ ] 三个★函数补全且运行通过
- [ ] 影子库 customers_masked 有 ≥3000 行
- [ ] 同名客户二次运行映射不变（确定性验证，把两次 head 对比截图）
- [ ] 三算子对比表 + 一行结论
- [ ] 0 命中验证截图

## 评分要点（10 分制）
算子实现 4 分（置换确定性 1 分、FFX 思路正确 1 分）｜影子库落库 2 分｜对比表结论 2 分｜泄露验证 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| to_sql 报错 | `pip install sqlalchemy`；或改用 executemany 逐行插入 |
| age 列不存在 | 用 wealth_risk_eval 或自行在 CREATE TABLE 里以 birth_year 换算 |
| 置换映射每次运行都变 | 检查 salt 是否写死——salt 变了映射就变，这正是"确定性"考点 |

## 提交物
`mask.py` + `exp05_样例.csv` + 三算子对比表 + 两张验证截图


---

<!-- ======== 实验06-动态脱敏.md ======== -->

# 实验6 · 动态脱敏：代理层按角色返回不同数据

> 对应模块 M3 ｜ 2 学时 ｜ 产出物：动态脱敏代理配置 + 三角色对比截图
> 与实验5 的区别一句话：静态改库里存的数，动态改"查询返回的数"——原始数据不动

## 实验目标
搭一个 MySQL 代理层，让三类账号查同一张表得到不同结果：
- `auditor`（审计员）：明文
- `teller`（柜员）：手机号遮盖
- `outsourcer`（外包）：关键列直接 NULL

## 方案说明
生产常用 Apache ShardingSphere-Proxy（Apache-2.0，版权无忧）。课程提供**两种路线**：
- A 路线（推荐，100% 能跑通）：用课程自研的轻量 MySQL 返回值改写脚本，原理同代理层
- B 路线（进阶加分）：ShardingSphere-Proxy 真实部署，配置文件在 `labs/exp06-sharding/`

## A 路线步骤（照抄即可跑通）

### Step 1：业务库建三个演示账号（10 分钟）
```bash
python - << 'EOF'
import pymysql
c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
cur = c.cursor()
for user, host in [('auditor','%'), ('teller','%'), ('outsourcer','%')]:
    cur.execute(f"CREATE USER IF NOT EXISTS {user}@'{host}' IDENTIFIED BY '{user}_fds_2026'")
cur.execute("GRANT SELECT ON bank_biz.* TO auditor@'%'")
cur.execute("GRANT SELECT ON bank_biz.* TO teller@'%'")
cur.execute("GRANT SELECT(id, name) ON bank_biz.customers TO outsourcer@'%'")  # 列级收权
c.commit(); print("三个账号就绪")
EOF
```

### Step 2：写"代理返回值改写"脚本（30 分钟）
新建 `dyn_proxy.py`——模拟代理层核心逻辑：按**连接角色**对结果集做改写：
```python
import pymysql, re

POLICY = {   # 角色 -> 字段 -> 算子（这就是策略中心的雏形）
    "teller":     {"phone": lambda v: v[:3] + "****" + v[7:]},
    "outsourcer": {"phone": lambda v: None, "id_number": lambda v: None},
}

def query_as(role, sql):
    if role == "auditor":   # 审计员直连明文
        conn = pymysql.connect(host='192.168.32.130', port=3306,
                               user='auditor', password='auditor_fds_2026', database='bank_biz')
    else:
        conn = pymysql.connect(host='192.168.32.130', port=3306,
                               user='teller', password='teller_fds_2026', database='bank_biz')
    cur = conn.cursor(); cur.execute(sql)
    cols = [d[0] for d in cur.description]; rows = cur.fetchall(); conn.close()
    rules = POLICY.get(role, {})
    if rules:
        fixed = []
        for r in rows:
            fixed.append(tuple(
                (rules[c](r[i]) if (c in rules and r[i] is not None) else r[i])
                for i, c in enumerate(cols)))
        rows = fixed
    return cols, rows

if __name__ == "__main__":
    sql = "SELECT name, phone, id_number FROM customers LIMIT 3"
    for role in ("auditor", "teller", "outsourcer"):
        cols, rows = query_as(role, sql)
        print(f"--- {role} ---")
        for r in rows: print(dict(zip(cols, r)))
```

### Step 3：三角色对比截图（10 分钟）
运行 `python dyn_proxy.py`，预期：
- auditor：`13812345678`、`110101...` 全明文
- teller：`138****5678`，证件号明文（策略里没配）
- outsourcer：phone/id_number 为 None

三种输出各截一张图，拼进报告。

### Step 4：策略热更新演示（15 分钟）
把 POLICY 里 teller 的 phone 规则改成"保留前7后2"（`v[:7]+"**"+v[9:]`），
**不改代码只改字典**重新运行——这就是"策略中心化"的价值。截图改前改后两次结果。

## B 路线（进阶加分，ShardingSphere 真部署）

```bash
# 在 VM 上执行
cd ~/fds-labenv && sudo docker run -d --name ss-proxy -p 33060:3307 \
  apache/shardingsphere-proxy:5.4.1
# 配置文件挂载方式与 mask 规则 YAML 见 labs/exp06-sharding/ 目录内注释
```
配好后用 mysql 客户端连 33060 验证 `SELECT phone FROM customers LIMIT 3` 返回遮盖值。
（镜像约 300MB，VM 网络波动时多试几次；跑不通不影响及格）

## 验收自查
- [ ] 三账号创建成功且 outsourcer 是**列级收权**（GRANT 指定列）
- [ ] dyn_proxy.py 三角色输出正确
- [ ] 策略热更新前后截图
- [ ] （加分）B 路线跑通截图

## 评分要点（10 分制）
三角色差异正确 4 分｜列级收权落地 2 分｜热更新演示 2 分｜报告说明静态vs动态区别 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| CREATE USER 报错已存在 | 前面加了 IF NOT EXISTS；密码错就 `ALTER USER` 重设 |
| outsourcer 查询报列不存在 | 这是列级收权生效了——用能查的列名重试 |
| A/B 路线结果不一致 | 正常：A 是脚本模拟，B 是真代理；报告里写清用的是哪条路线 |

## 提交物
`dyn_proxy.py` + 三张角色截图 + 热更新截图 + 100 字"静态 vs 动态"区别说明


---

<!-- ======== 实验07-字段加密KMS.md ======== -->

# 实验7 · 字段级加密 + 自研 KMS

> 对应模块 M3 / M2.5 ｜ 2 学时 ｜ 产出物：加密落库的客户表 + KMS 操作记录
> 核心考点：密文可以进库，密钥永远不进库——"密钥和密文同库同表"是密评第一条失分项

## 实验目标
用课程自研 KMS（http://192.168.32.130:8100）对 customers 表的手机号做信封式字段加密并落库，验证密钥轮换前后均可解密、错误密钥不可解。

## 前置条件
- KMS 服务健康：`curl http://192.168.32.130:8100/health` 返回 200
- 已装 `pip install pymysql requests`
- KMS 接口速查（也可开 http://192.168.32.130:8100/docs 在线调）：
  - `POST /keys`  body `{"key_id":"xxx"}` 创建
  - `GET /keys` 列表；`POST /keys/{id}/rotate` 轮换
  - `POST /encrypt` body `{"key_id":"xxx","plaintext_b64":"..."}`
  - `POST /decrypt` body `{"key_id":"xxx","ciphertext_b64":"..."}`

## 实验步骤

### Step 1：先手工体验一轮（10 分钟）
```bash
curl -s -X POST http://192.168.32.130:8100/keys -H "Content-Type: application/json" -d '{"key_id":"exp07-key"}'
python - << 'EOF'
import requests, base64
p = base64.b64encode("13812345678".encode()).decode()
e = requests.post("http://192.168.32.130:8100/encrypt",
                  json={"key_id":"exp07-key","plaintext_b64":p}).json()
print("密文:", e["ciphertext_b64"][:32], "…")
d = requests.post("http://192.168.32.130:8100/decrypt",
                  json={"key_id":"exp07-key","ciphertext_b64":e["ciphertext_b64"]}).json()
print("解密:", base64.b64decode(d["plaintext_b64"]).decode())
EOF
```

### Step 2：批量加密落库（核心步骤，30 分钟）
新建 `encrypt_col.py`：
```python
import pymysql, requests, base64

KMS = "http://192.168.32.130:8100"
KEY = "exp07-key"

def enc(v: str) -> str:
    r = requests.post(f"{KMS}/encrypt", json={
        "key_id": KEY, "plaintext_b64": base64.b64encode(v.encode()).decode()}).json()
    return r["ciphertext_b64"]

src = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                      password='fds_root_2026', database='bank_biz')
dst = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                      password='fds_root_2026', database='bank_shadow')
cur = dst.cursor()
cur.execute("""CREATE TABLE IF NOT EXISTS customers_enc (
  id INT PRIMARY KEY,
  phone_cipher TEXT    COMMENT 'KMS密文',
  key_version VARCHAR(8) COMMENT '加密时所用密钥版本')""")

rows = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                       password='fds_root_2026', database='bank_biz') \
             .cursor().execute("SELECT COUNT(*) FROM customers")
import pandas as pd
df = pd.read_sql("SELECT id, phone FROM customers LIMIT 500", src)
for _, r in df.iterrows():
    cur.execute("REPLACE INTO customers_enc VALUES (%s,%s,%s)",
                (int(r["id"]), enc(str(r["phone"])), "v1"))
dst.commit()
print("已加密落库", len(df), "行")
```

### Step 3：密钥轮换验证（20 分钟）——本实验采分核心
```bash
# 1) 轮换密钥
curl -s -X POST http://192.168.32.130:8100/keys/exp07-key/rotate
# 2) 用 v1 旧密文仍然解密成功（新旧版本共存）
python - << 'EOF'
import pymysql, requests, base64
c = pymysql.connect(host='192.168.32.130', port=3307, user='root',
                    password='fds_root_2026', database='bank_shadow')
cur = c.cursor(); cur.execute("SELECT id, phone_cipher FROM customers_enc LIMIT 3")
for cid, cipher in cur.fetchall():
    d = requests.post("http://192.168.32.130:8100/decrypt",
                      json={"key_id":"exp07-key","ciphertext_b64":cipher}).json()
    print(cid, "->", base64.b64decode(d["plaintext_b64"]).decode())
EOF
```
预期：轮换后旧密文仍解得开。回答报告问题：**为什么 KMS 要保留旧版本密钥？**
（答：轮换只影响新加密，存量密文要靠版本化旧密钥解——删旧版本=数据丢失）

### Step 4：错误密钥不可解（10 分钟）
```bash
curl -s -X POST http://192.168.32.130:8100/keys -d '{"key_id":"wrong-key"}' -H "Content-Type: application/json"
python - << 'EOF'
import requests
r = requests.post("http://192.168.32.130:8100/decrypt",
                  json={"key_id":"wrong-key","ciphertext_b64":"AAAA"})
print(r.status_code, r.text[:120])   # 预期报错，不是明文
EOF
```

### Step 5：对照密评失分项写结论（10 分钟）
对照 M2.5 讲稿"密评失分项 Top5"逐条检查你的实现并写进报告：
1. 密钥和密文同库同表？→ 否（密文在 MySQL，密钥只在 KMS 卷）✅
2. 密钥无轮换？→ 有 rotate 且版本共存 ✅
3. 明文出现在日志？→ 检查 encrypt_col.py 有没有 print 明文 ⚠ 引以为戒
4. 弱算法/自研算法？→ KMS 用标准实现，不自研算法 ✅
5. 密钥无访问控制？→ 课程 KMS 简化无鉴权，报告里写"生产需加 mTLS+RBAC" ⚠

## 验收自查
- [ ] customers_enc ≥ 500 行密文
- [ ] 轮换后旧密文可解，截图
- [ ] wrong-key 解密报错，截图
- [ ] 密评对照表 5 条全填

## 评分要点（10 分制）
批量加密落库 3 分｜轮换+共存验证 3 分｜错误密钥验证 2 分｜密评对照结论 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| KMS 502/连接拒绝 | `docker compose ps` 看 fds-kms 是否 healthy；`docker compose restart kms` |
| 批量加密太慢 | 500 行逐次 HTTP 属正常（约1分钟）；别用多线程打爆教学 KMS |
| 落库中文乱码 | 连接串加 charset='utf8mb4' |

## 提交物
`encrypt_col.py` + 两张验证截图 + 密评对照表


---

<!-- ======== 实验08-共享通道审批留痕.md ======== -->

# 实验8 · 共享安全通道与审批留痕

> 对应模块 M3 ｜ 2 学时 ｜ 产出物：一键共享脚本 + 审计留痕截图
> 场景：业务部门说"把客户名单发给合作方"——你作为数据安全岗，怎么让这个动作**合规、留痕、可审计**

## 实验目标
实现一个"共享导出"闭环：**审批登记 → 水印植入 → 最小化字段导出 → 通道传输 → 全程写审计索引**，并演示"没有审批单就导不出"的拦截。

## 前置条件
- 实验7 完成（复用 KMS）
- OpenSearch 可用：`curl http://192.168.32.130:9200` 返回集群信息
- 审批留痕写入索引 `fds-audit`（与控制台访问记录同索引）

## 实验步骤

### Step 1：设计审批单数据结构（15 分钟）
新建 `share.py`，先抄骨架：
```python
import requests, json, datetime as dt, hashlib, csv

OS = "http://192.168.32.130:9200"

def audit(action: str, detail: dict):
    """每个关键动作都写一条审计——这是'留痕'的落点"""
    requests.post(f"{OS}/fds-audit/_doc", json={
        "@timestamp": dt.datetime.utcnow().isoformat(),
        "user": "stu-你的名字", "action": action, **detail}, timeout=5)

def make_approval(applicant, purpose, fields, rows, expire_hours=24):
    """审批单：谁/为什么/哪些字段/多少行/有效期——五要素缺一不可"""
    ap = {"applicant": applicant, "purpose": purpose,
          "fields": fields, "rows": rows, "expire_hours": expire_hours,
          "status": "PENDING"}
    aid = hashlib.sha256(json.dumps(ap, sort_keys=True).encode()).hexdigest()[:12]
    ap["approval_id"] = aid
    audit("share_approval_created", ap)
    return ap

def approve(ap: dict, approver: str):
    ap["status"] = "APPROVED"; ap["approver"] = approver
    audit("share_approval_approved", {"approval_id": ap["approval_id"],
                                      "approver": approver})
```
思考题写进报告：为什么 approval_id 用内容哈希而不是自增？（提示：审批单不可篡改）

### Step 2：导出函数——带四道闸（30 分钟）
```python
def export_for_share(ap: dict, df, watermark_secret: str):
    """四道闸：状态→字段→行数→水印"""
    # 闸1：未审批不放行
    if ap.get("status") != "APPROVED":
        audit("share_denied", {"approval_id": ap["approval_id"], "reason": "未审批"})
        raise PermissionError("共享导出被拒：无有效审批单")
    # 闸2：字段最小化——超出审批字段一律砍掉
    extra = set(df.columns) - set(ap["fields"])
    if extra:
        audit("share_field_trimmed", {"approval_id": ap["approval_id"],
                                      "trimmed": sorted(extra)})
        df = df[list(ap["fields"])]
    # 闸3：行数上限
    df = df.head(ap["rows"])
    # 闸4：每行带溯源标识（生产为水印，此处为标记列，实验14 升级为真水印）
    df = df.copy(); df["_share_id"] = ap["approval_id"]
    audit("share_exported", {"approval_id": ap["approval_id"],
                             "rows": len(df), "fields": list(df.columns)})
    return df
```

### Step 3：跑通两条路径（20 分钟）
```python
if __name__ == "__main__":
    import pymysql, pandas as pd
    c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                        password='fds_root_2026', database='bank_biz')
    df = pd.read_sql("SELECT id, name, phone, id_number FROM customers LIMIT 200", c)

    # 路径1：未审批 → 应被拦截
    ap1 = make_approval("stu-你的名字", "合作方营销测试",
                        ["name", "phone"], 200)
    try:
        export_for_share(ap1, df, "OP0033")
    except PermissionError as e:
        print("拦截成功:", e)

    # 路径2：审批后 → 导出，且超范围字段被砍
    approve(ap1, "dept-manager")
    out = export_for_share(ap1, df, "OP0033")
    out.to_csv("exp08_共享导出.csv", index=False, encoding="utf-8-sig")
    print(out.columns.tolist())   # 预期：没有 id_number（未在审批单内）
    print(len(out))               # 预期 200
```

### Step 4：到审计看板验证留痕（15 分钟）
1. 打开 http://192.168.32.130:5601 → Discover → 索引模式 `fds-audit*`
2. 查询 `user: "stu-你的名字"`，时间范围最近 15 分钟
3. 预期按序看到 4 条：`share_approval_created` → `share_denied` → `share_approval_approved` → `share_field_trimmed` + `share_exported`
4. 截图——**这张图就是"全程留痕"的证据**，也是你面试时最好讲的素材

### Step 5：口述题（直播课抽查）
用 1 分钟讲清楚你的四道闸分别防什么：
状态闸防未批先用 / 字段闸防超范围要数 / 行数闸防一次捞走 / 水印闸防事后无法定责。

## 验收自查
- [ ] 拦截路径与放行路径都跑通
- [ ] 导出文件没有审批单之外的列
- [ ] 看板能看到完整事件链，截图
- [ ] 思考题（哈希审批单）有书面回答

## 评分要点（10 分制）
四道闸实现 4 分｜双路径验证 2 分｜审计链完整可查 3 分｜思考题 1 分

## 常见问题
| 问题 | 处理 |
|---|---|
| 写 audit 报 timeout | OpenSearch 忙；重跑即可，timeout=5 已放宽 |
| 看板查不到记录 | 时间范围改成"最后1小时"；确认索引模式是 `fds-audit*` |
| 想清空审计重跑 | `curl -X DELETE http://192.168.32.130:9200/fds-audit`（教学环境允许） |

## 提交物
`share.py` + `exp08_共享导出.csv` + 看板留痕截图 + 思考题答案


---

<!-- ======== 实验09-RLS与高危规则.md ======== -->

# 实验9 · 访问控制（RLS）+ 审计高危规则

> 对应模块 M4 ｜ 2 学时 ｜ 产出物：RLS 演示截图 + OpenSearch 高危规则配置与告警截图
> 两个考点：**行级权限**（柜员只看本网点）与**高危行为规则化**（日志不只是存，要能告警）

## 实验目标
① 在 PostgreSQL 演示 RLS：同一张表，teller_b001 只能查到本网点行，outsourcer 角色列被屏蔽；② 在 OpenSearch 写一条"单次查询超 200 条"高危规则并验证命中。

## 前置条件
- PostgreSQL：192.168.32.130:15432，库 bank_rl，postgres / fds_pg_2026
- 已装 `pip install psycopg2-binary`
- 环境初始化时已建好 RLS 策略与角色（见 labs/00-labenv/postgres/init/01-init.sql）

## 实验步骤

### Part A：RLS 行级权限（45 分钟）

#### Step 1：先看已有策略（10 分钟）
```bash
python - << 'EOF'
import psycopg2
c = psycopg2.connect(host='192.168.32.130', port=15432, user='postgres',
                     password='fds_pg_2026', dbname='bank_rl')
cur = c.cursor()
cur.execute("SELECT schemaname, tablename, policyname, roles, qual FROM pg_policies")
for r in cur.fetchall(): print(r)
EOF
```
读懂输出：策略把可见行限定在 `branch_id = current_setting('app.branch')` 之类会话变量上。

#### Step 2：以柜员身份连库验证（15 分钟）
```bash
python - << 'EOF'
import psycopg2
# teller_b001：2号网点柜员（密码见 init/01-init.sql，默认 teller_2026）
c = psycopg2.connect(host='192.168.32.130', port=15432, user='teller_b001',
                     password='teller_2026', dbname='bank_rl')
cur = c.cursor()
cur.execute("SELECT count(*) FROM accounts")
print("teller_b001 能看到的行数:", cur.fetchone()[0])
# 对比管理员视角
c2 = psycopg2.connect(host='192.168.32.130', port=15432, user='postgres',
                      password='fds_pg_2026', dbname='bank_rl')
cur2 = c2.cursor(); cur2.execute("SELECT count(*) FROM accounts")
print("postgres 全量行数:", cur2.fetchone()[0])
EOF
```
预期两个数字**差距明显**（柜员只见本网点）。截图对比。

#### Step 3：切换网点身份复验（10 分钟）
以另一网点柜员（init 脚本里有，如 teller_b002 / teller_2026）连库再查 count，
证明不同柜员可见集合不同——RLS 生效，不是权限写死。

#### Step 4：外包角色列屏蔽验证（10 分钟）
以 outsourcer 连库执行 `SELECT * FROM accounts LIMIT 1`，
预期：敏感列（证件号/卡号）返回 NULL 或直接无该列。记录截图。
回答报告问题：**列屏蔽用视图实现 vs RLS 实现，各自的适用场景？**
（答：列屏蔽管"看哪些列"，视图简单；行级过滤管"看哪些行"，必须 RLS。两者常叠加。）

### Part B：OpenSearch 高危规则（45 分钟）

#### Step 5：灌一批"高危查询"事件（15 分钟）
```bash
python - << 'EOF'
import requests, datetime as dt, random
OS = "http://192.168.32.130:9200"
ops = ["OP0011", "OP0033", "OP0058"]
for i in range(300):
    op = ops[i % 3]
    n = random.randint(1, 250)          # 单次查询返回行数
    requests.post(f"{OS}/fds-audit/_doc", json={
        "@timestamp": dt.datetime.utcnow().isoformat(),
        "user": op, "action": "batch_query",
        "rows_returned": n, "src_ip": f"10.0.{i%5}.{i%250}"}, timeout=5)
print("300 条事件已写入")
EOF
```

#### Step 6：在 Dashboards 写规则（20 分钟）
1. 打开 http://192.168.32.130:5601 → 左侧 **Dashboard Management → Rules**（或 OpenSearch Plugins → Alerting）
2. Create monitor → per-query monitor：
   - 索引：`fds-audit*`
   - 查询：`action:batch_query AND rows_returned:>200`
   - 触发条件：命中数 > 0
   - 通知方式选 Test action（课程环境不发真邮件）
3. 保存并立即 Test —— 预期命中 OP0033 等用户的大批量查询。

#### Step 7：规则调优思考（10 分钟）
把阈值改成 500 再测：还报吗？改成 100 呢？
写 3 句话结论：**阈值太松漏报、太紧告警疲劳**——引出 M4 讲稿"阈值+基线"双层设计（实验10 展开）。

## 验收自查
- [ ] RLS 两个柜员 count 差异截图
- [ ] outsourcer 列屏蔽截图
- [ ] Alerting 规则命中截图
- [ ] 阈值调优 3 句结论

## 评分要点（10 分制）
RLS 验证完整 4 分｜列屏蔽验证 2 分｜高危规则配置并命中 3 分｜调优结论 1 分

## 常见问题
| 问题 | 处理 |
|---|---|
| teller 密码不对 | 看 `labs/00-labenv/postgres/init/01-init.sql` 里的 CREATE ROLE 语句为准 |
| RLS 不生效全表可见 | 确认用的是 teller 账号连库（postgres 是超级用户，RLS 对其无效——这本身是考点） |
| Alerting 找不到入口 | 版本差异：菜单可能叫 Anomaly Detection 旁的 Alerting；找 Create monitor 即可 |
| 命中 0 条 | Step 5 的 300 条里 rows_returned>200 约占 1/5；检查查询语法 `rows_returned:>200` 无空格 |

## 提交物
四张截图 + 列屏蔽思考题 + 阈值调优结论


---

<!-- ======== 实验10-内部人批量导出监测.md ======== -->

# 实验10 · 内部人员批量导出监测（三层防御）

> 对应模块 M4 ｜ 2 学时 ｜ 产出物：OP0033 溯源报告（阈值+基线+水印三层证据链）
> 这是全课程"最像真案侦破"的实验：合成数据里埋了一个学会规避单日阈值的家伙，抓他

## 实验目标
用 SQL + 控制台 + 水印三层手段，完整复现"内部人员分批捞取客户征信数据"的检测与定责：
**第一层阈值抓现行 → 第二层基线抓规律 → 第三层水印做定责**。

## 前置条件
- MySQL 业务库：192.168.32.130:3306，bank_biz，root / fds_root_2026
- 已装 `pip install pymysql pandas matplotlib`
- 控制台页签⑥可访问（对照演示）

## 实验步骤

### Step 1：先看数据长什么样（10 分钟）
```bash
python - << 'EOF'
import pymysql, pandas as pd
c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
df = pd.read_sql("SELECT operator_id, DATE(query_time) d, COUNT(*) n "
                 "FROM credit_query_log GROUP BY operator_id, d LIMIT 20", c)
print(df)
print("总操作员数:", pd.read_sql(
    "SELECT COUNT(DISTINCT operator_id) n FROM credit_query_log", c)["n"][0])
EOF
```

### 第一层：阈值检测（15 分钟）
```bash
python - << 'EOF'
import pymysql, pandas as pd
c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
daily = pd.read_sql("""SELECT operator_id, DATE(query_time) d, COUNT(*) n
    FROM credit_query_log GROUP BY operator_id, d""", c)
THRESHOLD = 200
hit = daily[daily["n"] > THRESHOLD]
print(f"阈值 {THRESHOLD} 命中 {len(hit)} 条:")
print(hit.sort_values("n", ascending=False).head(10))
EOF
```
预期：普通操作员偶有超标（忙日），**OP0033 可能没进榜**——他故意控制在阈值内。
在报告里写：单层阈值的漏洞是什么？（答：攻击者把量摊到阈值之下即可绕过）

### 第二层：基线检测（抓到 OP0033 的关键，25 分钟）
```bash
python - << 'EOF'
import pymysql, pandas as pd
c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
daily = pd.read_sql("""SELECT operator_id, DATE(query_time) d, COUNT(*) n
    FROM credit_query_log GROUP BY operator_id, d""", c)

# 个人基线 = 自己历史日均值
base = daily.groupby("operator_id")["n"].mean().rename("baseline")
m = daily.merge(base, on="operator_id")
m["ratio"] = m["n"] / m["baseline"]

# 规则：当日量 > 个人基线 3 倍 且 当日绝对量 > 50（防低量误报）
flag = m[(m["ratio"] > 3) & (m["n"] > 50)]
print(flag.sort_values("ratio", ascending=False).head(10))

# 画图存证：OP0033 vs 全体均值的每日查询曲线
import matplotlib
matplotlib.use("Agg"); import matplotlib.pyplot as plt
op33 = daily[daily["operator_id"] == "OP0033"]
avg  = daily.groupby("d")["n"].mean()
plt.figure(figsize=(10, 4))
plt.plot(op33["d"], op33["n"], label="OP0033", marker="o")
plt.plot(avg.index, avg.values, label="全体均值")
plt.legend(); plt.title("OP0033 vs baseline"); plt.xticks(rotation=45)
plt.tight_layout(); plt.savefig("exp10_基线对比.png", dpi=120)
print("图已存 exp10_基线对比.png")
EOF
```
预期：OP0033 **每天都贴着"略超自己基线3倍"或"恒定高于均值"**——分批捞取的典型形态。截图曲线图。

### 第三层：水印定责（15 分钟）
模拟"泄露数据在外部发现了"，用页签⑤原理做溯源：
```bash
python - << 'EOF'
import hashlib
# 外部流出数据里提取到的 4bit 指纹（课程预置场景）
leaked_bits = "1011"
candidates = {"OP0033": None, "OP0011": None, "OP0058": None}
for op in candidates:
    candidates[op] = bin(int(hashlib.sha256(op.encode()).hexdigest(), 16))[-4:]
print("各操作员水印指纹:", candidates)
# 比对命中
hit = [op for op, b in candidates.items() if b == leaked_bits]
print("泄露源定位:", hit)
EOF
```
预期输出定位到 OP0033。写一句定责链：**基线发现异常 → 行为曲线存证 → 水印指纹定位到人**。

### Step 4：汇总溯源报告（15 分钟）
按课程"案例五段式"格式写 300 字小报告：
1. 背景：外包操作员可查全量征信
2. 发现：阈值层漏报 → 基线层命中
3. 分析：分批规避阈值的行为特征（附曲线图）
4. 定责：水印指纹比对命中 OP0033
5. 整改建议：三条以上（如：外包账号限次+审批、征信查询双人复核、水印全覆盖）

### Step 5：与控制台互验（10 分钟）
打开控制台页签⑥，确认检测结果与你的 SQL 一致（该页签阈值偏保守，命中可能为空——把你的 SQL 结果截图对照说明即可，这本身就是"参数窗口"的教学点）。

## 验收自查
- [ ] 阈值层的漏报结论写出来了
- [ ] 基线层抓到 OP0033，曲线图已存
- [ ] 水印定位输出命中
- [ ] 五段式报告 300 字
- [ ] 整改建议 ≥ 3 条

## 评分要点（10 分制）
两层检测实现 4 分｜曲线存证 2 分｜水印定责闭环 2 分｜报告质量 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| matplotlib 中文字变方块 | `plt.rcParams["font.sans-serif"]=["SimHei"]`；或标签用英文 |
| OP0033 ratio 不够 3 倍 | 调低倍数到 2 或降低绝对量门槛重试；并把参数写进报告（检测即调参） |
| 想重置数据重跑 | `docker compose up -d --build generator`（幂等重灌，所有学员数据一致） |

## 提交物
两份检测脚本 + `exp10_基线对比.png` + 水印定位截图 + 五段式报告


---

<!-- ======== 实验11-出境合规评估演练.md ======== -->

# 实验11 · 数据出境合规评估演练

> 对应模块 M6 ｜ 2 学时 ｜ 产出物：《数据出境合规评估演练报告》
> 本实验不写代码，练的是**判断顺序**：三条路径先走哪条、金融叠加约束卡在哪

## 实验目标
针对三个虚构场景，完成出境路径判断与评估报告初稿，掌握"先路径、再条件、后材料"的顺序感。

## 场景包（三选二做，第三个必做）

**场景 A（必做）**：虚构城商行拟把信用卡客户的姓名/手机号/账单地址传输给位于新加坡的集团风控系统做联合建模。
**场景 B**：总行科技部采购境外 SaaS 日志分析工具，运维日志（含操作员账号、IP）上传至美西集群。
**场景 C**：自贸区分行拟向境外合作机构提供企业征信脱敏数据集（已泛化到行业级、删除全部标识符）。

## 实验步骤

### Step 1：路径判断——先画决策树（30 分钟）
对每个场景按顺序回答三问（把答案写成树状图或表格）：
1. **是否构成"出境"？**（数据传至境外可访问即出境，包括境外方远程可查）
2. **走哪条路径？** 按课程 M6 顺序：
   - 网安法第37条 CII/满百万 → **安全评估**（网信部门申报）
   - 个保法标准合同 → ** SCC 备案 + PIA**（多数金融场景主路径）
   - 认证路径 → 金融业少用，说明为什么不用即可
3. **金融叠加约束？** 行业主管部门要求（金融数据还受 JR/T 0171 个人金融信息、C3 出境从严等约束）

### Step 2：场景 A 深做（40 分钟）
按 SCC 主路径模拟填写评估要素（模板见 `labs/manuals/exp11-模板/出境评估演练-模板.md`）：
1. 数据识别：出境数据类型、数量级、是否含敏感个信（金融账户→敏感）
2. PIA 要点：必要性（为什么境内做不了）、影响、最小化措施
3. 境外接收方义务：目的限定、再转移限制、安全事件通知时限
4. 金融特别项：C3 级字段是否在内？账单地址属 C2——**结论示例**：账单地址若可精确到户则从严，建议泛化到区县级再出境
5. 结论段：走哪条路径 + 三个先决条件 + 遗留风险

### Step 3：场景 B/C 快判（各 20 分钟）
每个场景写 150 字判断，必须包含：
- 路径结论（一句话）
- 一个关键转折点（如 B：运维日志含个人账号→按个保法处理，不是纯技术日志）
- C 的考点是"脱敏到什么程度不算个人信息"——写你的判断与理由

### Step 4：对照自查表（15 分钟）
| 检查项 | A | B | C |
|---|---|---|---|
| 明确了数据类型与量级 | | | |
| 路径判断有法条依据 | | | |
| 金融行业约束已叠加分析 | | | |
| 接收方义务条款完整 | | | |
| 遗留风险如实列出 | | | |

### Step 5：直播辩论题（直播课环节）
辩题："脱敏数据出境不需要任何合规动作"。正反各准备 3 条论据。
（提示：C 场景的答案就藏在这里——再脱敏也可能构成"重要数据"或需按自贸区负面清单比对）

## 验收自查
- [ ] 三个场景都完成路径判断
- [ ] A 场景五要素齐全，含金融特别项
- [ ] 每个场景的法条依据 ≥ 2 条
- [ ] 辩论论据备好

## 评分要点（10 分制）
路径判断顺序正确 4 分｜金融叠加约束分析 3 分｜遗留风险如实性 2 分｜辩论准备 1 分
（评分强调：**结论可以错，依据不能空**——合规工作的价值在推理过程）

## 常见问题
| 问题 | 处理 |
|---|---|
| 新规迭代快，担心过时 | 课程口径标注了【分析】的部分以你当地最新要求为准；报告里写"截至 2026-10 口径" |
| 分不清 SCC 与安全评估 | 记忆锚点：CII/大量→评估；普通个信→SCC；本课程环境全是普通量级 |
| 负面清单查不到自贸区原文 | 用课程讲稿的框架讲法即可，备注"属地清单待属地查证" |

## 提交物
《出境合规评估演练报告》（含决策树/表格 + 三个场景结论）


---

<!-- ======== 实验12-毕业设计.md ======== -->

# 实验12 · 毕业设计：虚构城商行完整数据安全评估

> 对应模块 M8 ｜ 8 学时 + 答辩 ｜ 产出物：四件套交付物 + 答辩
> 毕业设计 = 全课程 14 个实验的"集成上线"。做完它，你就有一套完整的、可对外展示的作品集

## 虚构背景（统一设定，不得更换以保证公平评审）
**滨川市商业银行**（虚构）：总资产 800 亿，城商行，员工 2100 人，12 家分行。
已建：核心系统（模拟库=课程实验环境 bank_biz）、手机银行、征信查询系统。
已知现状（故意留的坑，要用实验工具去发现）：
1. 影子库全量拷贝含明文 C2 字段（实验3 已发现）
2. 外包操作员可查全量征信且无双人复核（实验10 已抓到 OP0033）
3. 新采购的境外智能客服 SaaS 可访问客户工单（实验11 场景 B 的延伸）

## 四件交付物（缺一不可）

### 交付物 1：《数据资产与分类分级清单》（25 分）
- 以实验3+4 产出为基础，补充手机银行/征信系统两个**新增系统**的资产行
- 每张表定级 + 组合升级结论 + 重要数据识别专节
- 评分点：完整性、依据条款引用、格式规范

### 交付物 2：《差距分析报告》（30 分）
- 按"三法一条例 + 24号文 + JR/T"逐条对照现状，输出差距清单
- **必须引用实验证据**：至少 6 处引用实验2-11 的实际结果（截图或数据）
- 每条差距标注：严重度（高/中/低）+ 对应法规条款 + 整改负责岗位
- 评分点：证据链是否真实可复现（抽查 2 条现场复跑）

### 交付物 3：《整改方案与路线图》（25 分）
- 把差距转成整改项：每项含措施、依赖、工作量估算、优先级
- 按季度路线图排布（用模板甘特图工作表）
- 至少包含：影子库脱敏整改（实验5/6 方案）、外包访问管控（实验8/9 方案）、水印覆盖（实验14 方案）
- 评分点：可落地性（写得出"谁在什么时候用什么做什么"）、成本意识

### 交付物 4：《迎检要点手册》（20 分）
- 按 M8 讲稿"迎检材料包 checklist"整理 20 项
- 模拟监管问询 10 问及标准答法（每答 ≤ 3 句，含证据指向）
- 评分点：答法是否"有证据、有口径、有边界"

## 工作流程（建议节奏）

| 阶段 | 学时 | 动作 |
|---|---|---|
| 1 资产盘点 | 2 | 扩展实验3 脚本扫新增系统设定 → 更新清单 |
| 2 差距分析 | 2 | 逐条对照，挂证据 |
| 3 整改方案 | 2 | 差距→整改项→路线图 |
| 4 迎检手册 | 2 | checklist + 问答演练 |

## 答辩（结业直播课）

- 每人 10 分钟：5 分钟讲差距分析 TOP3 + 3 分钟讲整改路线 + 2 分钟模拟监管问询抽答 2 题
- 评审组（讲师+2 名学员互评）按四件套评分，答辩表现占 20% 折算进毕业设计总分
- **作品集打包**：四件套 + 14 实验产出物，形成《数据安全工程师作品集-姓名》，这是求职核心武器

## 评分总表（100 分）

| 项 | 分值 | 评分要点 |
|---|---|---|
| 清单 | 25 | 完整 10 / 依据 10 / 格式 5 |
| 差距分析 | 30 | 证据链 15 / 条款引用 10 / 严重度判断 5 |
| 整改方案 | 25 | 可落地 15 / 优先级合理 5 / 成本意识 5 |
| 迎检手册 | 20 | checklist 完整 10 / 问答口径 10 |

## 常见问题
| 问题 | 处理 |
|---|---|
| 新增系统没有真实数据 | 用 generator 的 CSV 快照虚构对应表，说明"模拟系统数据"即可 |
| 证据截图怎么才算有效 | 必须含时间戳/命令回显，聊天记录截图无效 |
| 想换一个行业背景 | 不允许——统一设定才能互评与横向比较 |

## 提交物
四件套文件 + 作品集打包 zip + 答辩 PPT（复用思度模板，≤ 8 页）


---

<!-- ======== 实验13-SM2签名验签.md ======== -->

# 实验13 · SM2 签名验签全流程（自建 CA）

> 对应模块 M2.5 ｜ 2 学时 ｜ 产出物：签名验签脚本 + 自建 CA 签发的证书
> 国密不是考试题，是金融行业每天在用的基础设施——本实验亲手把它跑通一遍

## 实验目标
① 用纯 Python 库跑通 SM2 密钥生成/签名/验签；② 自建一个迷你 CA，给"课程系统"签发 SM2 证书；③ 理解"签名验签"与"加解密"是两回事。

## 前置条件
- Python 3.10+
- 安装：`pip install gmssl`（纯 Python 实现国密，无需系统依赖）

## 实验步骤

### Step 1：SM2 三件套热身（20 分钟）
签名/验签/加解密一把跑（照抄即可，密钥对为课程固定演示密钥）：

```bash
python - << 'EOF'
import binascii
from gmssl import sm2, func

# —— 生成 SM2 密钥对 ——
# 公钥由椭圆曲线点乘算出；gmssl 不直接提供，用固定演示密钥对：
private_key = "00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5"
public_key  = "B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081" \
              "A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207"
sm2_crypt = sm2.CryptSM2(public_key=public_key, private_key=private_key)

# —— 签名 / 验签 ——
data = b"transfer:1001,amount:2800.00,from:CUST889,to:OP0033"
sig = sm2_crypt.sign(data, func.random_hex(64))       # 随机数 k 每次不同
print("签名(前32hex):", sig[:32], "…")
ok = sm2_crypt.verify(sig, data)
print("验签结果:", ok)

# —— 篡改检测（关键演示）——
bad = data.replace(b"2800.00", b"9900.00")
print("篡改后验签:", sm2_crypt.verify(sig, bad))       # 预期 False

# —— 加解密（对比：签名管完整性，加密管保密性）——
ct = sm2_crypt.encrypt(b"secret-pan-6222xxxx")
pt = sm2_crypt.decrypt(ct)
print("解密还原:", pt)
EOF
```
预期：验签 True / 篡改后 False / 解密还原原文。**把这三行结果截图**。

### Step 2：自建迷你 CA（35 分钟）
新建 `mini_ca.py`：
```python
from gmssl import sm2, func, sm3
import hashlib, json, datetime as dt

class MiniCA:
    """教学级 CA：根密钥 + 证书签发 + 验证链。生产必须用合规密码产品"""
    def __init__(self, root_private, root_public):
        self.root = sm2.CryptSM2(public_key=root_public, private_key=root_private)

    def issue(self, subject: dict, subject_public: str) -> dict:
        """给申请者签发证书：主体信息 + 公钥 + CA签名"""
        tbs = json.dumps(subject, sort_keys=True) + "|" + subject_public
        tbs_bytes = tbs.encode()
        sig = self.root.sign(tbs_bytes, func.random_hex(64))
        return {"tbs": tbs, "sig": sig,
                "issued_at": dt.datetime.utcnow().isoformat()}

    def verify(self, cert: dict) -> bool:
        return self.root.verify(cert["sig"], cert["tbs"].encode())

    def fingerprint(self, cert: dict) -> str:
        """证书指纹：SM3 哈希（国密对 SHA256 的对应物）"""
        return sm3.sm3_hash(func.bytes_to_list(cert["tbs"].encode()))

if __name__ == "__main__":
    # 根密钥（课程固定演示密钥；生产环境根私钥必须离线保存）
    ROOT_PRIV = "00B9AB0B828FF68872F21A837FC303668428DEA11DCD1B24429D0C99E24EED83D5"
    ROOT_PUB  = ("B9C9A6E04E9C91F7BA880429273747D7EF5DDEB0BB2FF6317EB00BEF331A83081"
                 "A6994B8993F3F5D6EADDDB81872266C87C018FB4162F5AF347B483E24620207")
    ca = MiniCA(ROOT_PRIV, ROOT_PUB)

    # 给"课程转账系统"签发证书
    cert = ca.issue(
        subject={"CN": "fds-course-transfer", "O": "思度安全教学", "valid": "365d"},
        subject_public=ROOT_PUB)
    print("证书签发成功:", ca.verify(cert))
    print("证书指纹(SM3):", ca.fingerprint(cert))
    json.dump(cert, open("exp13_cert.json", "w"), ensure_ascii=False, indent=2)
```
运行后回答报告问题：
1. 证书里"签的是什么"？（答：主体信息+公钥的**绑定关系**，不是加密数据）
2. 为什么 CA 私钥泄露 = 全链失效？（提示：谁能签证书，谁就能冒充任何人）

### Step 3：模拟一个"签名报文"完整业务流（20 分钟）
```bash
python - << 'EOF'
import json, hashlib
from gmssl import sm2, func
# 场景：柜员提交转账指令 -> 后台验签后才入账
msg = {"tx_no": "T20261026001", "amount": "2800.00",
       "from": "CUST889", "operator": "OP0033"}
raw = json.dumps(msg, sort_keys=True).encode()
sig = sm2.CryptSM2(public_key=ROOT_PUB, private_key=ROOT_PRIV).sign(raw, func.random_hex(64))
print("报文+签名已生成 ->", hashlib.md5(raw).hexdigest()[:8])
# 后台：先验签，再核对证书状态，最后入账——顺序不能反
EOF
```
（ROOT_PUB 从 Step 2 复制；把"先验签后入账"写进你的整改清单模板）

### Step 4：对照 GB 39786 写应用密评自查（15 分钟）
| 检查项 | 你的结论 | 依据 |
|---|---|---|
| 身份鉴别用了 SM2 证书/双因子 | | GB 39786 数据层面要求 |
| 传输用了国密 TLS（或计划） | | GM/T 0024 |
| 签名算法是否自研 | 必须否 | 密码不允许自研 |
| 密钥如何保存 | 课程演示写死=不合格，写明 | 密评失分项 |

## 验收自查
- [ ] 签名/验签/篡改检测三结果截图
- [ ] mini_ca.py 签发并验证证书，指纹已打印
- [ ] exp13_cert.json 已生成
- [ ] 两道思考题有书面回答
- [ ] 密评自查表填完

## 评分要点（10 分制）
三件套跑通 3 分｜CA 签发验证 3 分｜思考题深度 2 分｜密评对照 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| gmssl 装不上 | `pip install gmssl -i https://pypi.tuna.tsinghua.edu.cn/simple`；纯 Python 包，无系统依赖 |
| sign 报错缺参数 | sign(data, random_hex) 两参齐全；随机数每次要新 |
| 想跑真国密 TLS | 进阶：Nginx + GmSSL 编译工程量大，课程只要求理解原理与自查清单 |

## 提交物
`mini_ca.py` + `exp13_cert.json` + 三张结果截图 + 密评自查表


---

<!-- ======== 实验14-数据库水印溯源.md ======== -->

# 实验14 · 数据库水印植入与溯源（自研差异化能力）

> 对应模块 M2.5 ｜ 2 学时 ｜ 产出物：水印工程版脚本 + 溯源报告
> 这是课程的"招牌实验"：控制台页签⑤是演示版，本实验从演示版打到工程版——**也是你将来可打包售卖的自研能力**

## 实验目标
实现完整版数据库水印：① 多比特水印按密钥散列嵌入金额小数位（业务误差容忍内）；② 抗"取子集/重聚合"的提取验证；③ 从泄露样本反向定位泄露源（哪次导出、哪个工号）。

## 前置条件
- 已装 `pip install pymysql pandas hashlib`（标准库为主）
- MySQL 业务库：192.168.32.130:3306，bank_biz
- 先玩一遍控制台页签⑤，理解 4bit 演示版

## 实验步骤

### Step 1：升级到多比特水印（30 分钟）
新建 `watermark.py`，工程版三要素：**密钥选行、比特嵌入、盲提取**：

```python
import pymysql, pandas as pd, hashlib

KEY = "sdfin-2026"      # 水印密钥：只有数据拥有方知道
TOLERANCE = 0.03        # 业务容忍：金额±3分不影响对账

def _h(s: str) -> int:
    return int(hashlib.sha256(s.encode()).hexdigest(), 16)

def embed(df: pd.DataFrame, secret: str) -> pd.DataFrame:
    """把 secret 的二进制（如工号哈希的 16bit）按密钥散列嵌入 amount 列"""
    bits = bin(int(hashlib.sha256(secret.encode()).hexdigest(), 16))[-16:]
    out = df.copy()
    for i in out.index:
        row_key = f"{KEY}:{i}"
        if _h(row_key) % 100 < 50:                 # 约一半行参与（抗抽样）
            bit = bits[_h(f"{KEY}:bit:{i}") % 16]
            delta = (1 if bit == '1' else -1) * 0.01 * (1 + _h(row_key) % 3)
            out.loc[i, "amount"] = round(out.loc[i, "amount"] + delta, 2)
    return out

def extract(watered: pd.DataFrame, original_amounts: list) -> str:
    """盲提取：拿'原值比对'简化版（工程版用多数投票，见 Step 3 思考）"""
    marks = ""
    for j, (_, row) in enumerate(watered.iterrows()):
        row_key = f"{KEY}:{j}"
        if _h(row_key) % 100 < 50:
            diff = row["amount"] - original_amounts[j]
            marks += "1" if diff > 0 else "0"
    return marks[:16]
```

### Step 2：植入与自提取验证（20 分钟）
```bash
python - << 'EOF'
from watermark import *
import pymysql, pandas as pd
c = pymysql.connect(host='192.168.32.130', port=3306, user='root',
                    password='fds_root_2026', database='bank_biz')
df = pd.read_sql("SELECT * FROM transactions LIMIT 200", c)
orig = df["amount"].astype(float).tolist()

w = embed(df, "OP0033")
diff = (w["amount"].astype(float) - df["amount"].astype(float)).abs()
print("最大扰动:", diff.max(), "分级容忍内:", bool((diff <= TOLERANCE).all()))

extracted = extract(w, orig)
import hashlib as H
expect = bin(int(H.sha256(b"OP0033").hexdigest(), 16))[-16:][:16]
print("提取指纹:", extracted)
print("期望指纹:", expect[:len(extracted)])
print("一致:", extracted == expect[:len(extracted)])
w.to_csv("exp14_watered.csv", index=False, encoding="utf-8-sig")
EOF
```
截图三行输出：最大扰动 / 提取指纹 / 一致 True。

### Step 3：抗攻击测试（核心采分点，30 分钟）
对水印数据依次做三种"攻击"，每次重新提取并记录指纹残存度：

```python
# 追加到 watermark.py 底部直接跑
import hashlib as H
def residual(w: pd.DataFrame, orig: list) -> str:
    return extract(w, orig)

# 攻击1：抽样 50%（泄露者只拿走一半数据）
sample = w.sample(frac=0.5, random_state=1)
print("抽样50%后提取:", residual(sample, orig[:len(sample)]))
# 提示：抽样后行号错位，正确做法是带着原索引提取——
#       把 extract 里的 j 换成 row 的真实 index，重测残存度（★ 必做修改）

# 攻击2：金额取整到元（抹平分位扰动）
rounded = w.copy(); rounded["amount"] = rounded["amount"].round(0)
print("取整后提取:", residual(rounded, orig))

# 攻击3：重聚合（按账户求和）——预期指纹丢失，引出"行级水印 vs 聚合水印"
```
报告必答三问：
1. 抽样 50% 后残存多少比特？为什么？（密钥选行 → 留下的行仍带指纹）
2. 取整为什么能抹掉 1 分级扰动？怎么加固？（提示：嵌到"个位奇偶"比嵌到"分位"更抗取整，代价是扰动变大——写你的权衡）
3. 聚合攻击下行级水印失效，工程上怎么办？（聚合水印/统计指纹，课程 M2.5 讲稿第 5 节）

### Step 4：溯源演示——从流出数据定位工号（15 分钟）
```bash
python - << 'EOF'
from watermark import *
import pandas as pd, hashlib as H
# 场景：外部论坛出现一份 200 行交易数据，怀疑内部导出
leaked = pd.read_csv("exp14_watered.csv")          # 当作"流出的数据"
for suspect in ["OP0011", "OP0033", "OP0058"]:
    guess = bin(int(H.sha256(suspect.encode()).hexdigest(), 16))[-16:][:16]
    got = extract(leaked, orig)
    score = sum(a == b for a, b in zip(got, guess)) / len(got)
    print(f"{suspect} 指纹吻合度: {score:.0%}")
# 预期：OP0033 吻合度最高 -> 泄露源 = OP0033 的那次导出
EOF
```

### Step 5：写一页"水印方案说明"（作为可售卖能力的说明书）（15 分钟）
按产品文档格式写：适用场景 / 嵌入位置 / 密钥管理 / 抗攻击边界 / 与审计日志的组合用法。
这份文档将来直接进产品资料包——**写得好它就是你的作品集亮点**。

## 验收自查
- [ ] 多比特嵌入/提取自洽（一致 True 截图）
- [ ] 三种攻击残存度数据齐全
- [ ] 三问都有书面回答
- [ ] 溯源演示命中 OP0033
- [ ] 方案说明一页纸

## 评分要点（10 分制）
工程版实现 3 分｜抗攻击测试与权衡分析 3 分｜溯源闭环 2 分｜方案说明文档 2 分

## 常见问题
| 问题 | 处理 |
|---|---|
| 提取指纹对不上 | 99% 是行号错位：抽样攻击后必须带原 index 提取（★ 处已提示） |
| 扰动导致对账不平 | TOLERANCE 是业务口径；报告里写清"±3分内不影响分录平衡"的假设 |
| 想换位置嵌入 | 把 amount 换成任何数值列即可；文本列需另实现（讲稿第 5 节） |

## 提交物
`watermark.py` + `exp14_watered.csv` + 攻击测试输出截图 + 三问答案 + 一页方案说明
