Files
STM32F4-Base/test/host/prot_set/prot_set_test.c
T
wandering1 7da5c7b74c fix(iec104): 拒绝 SN!=0 的假成功写入,并删除 prot_set 的错误第二真源
问题一(安全级):绑定真实参数源后,Type203 走 SN=1..4 的预置与固化会回
COT=7 肯定确认,但 parameter_apply 一次都没被调用 —— 区域 1..4 的分段项在
mapped() 里凑不出 changes[],commit_stage() 的 n==0 让 apply 被跳过,而
values[] 与 parameter_commits 照旧更新,回读也返回出厂镜像冒充当前值。
主站看到"改成功",保护定值一个字没动。

修法:remote_action() 在绑定真实源后对 SN!=0 一律否定确认;remote_lookup()
对 SN!=0 的读返回错误而不是镜像;READ_AREA 绑定后只报区域 0;提交计数移到
真调过 apply 之后。未绑定模拟面保留 0..4 与原有语义,模拟器不受影响。

新增 preset_to_prot_set_test:真实 TCP 夹具 + 手写线上字节,链接
iec104_core/iec104_source/iec104_dtu_table/prot_set,钉住五条契约。四个
变异体(删入口守卫、计数移回无条件、删读侧守卫、READ_AREA 恒报 4)分别
红在对应断言上,证明用例不是为变绿而放松。

问题二:prot_set 的 g_prot_set_meta[].comm_addr 是与语义桥表冲突的错误
第二真源,17 项里 13 项地址指向完全不同的点表语义(如 0x8842 过流一段
定值被标成检同期压差闭锁定值),另有 10 项地址在点表里根本不存在。产品
代码零引用,但 adc_cal.h 已把它当"变比的家"引用,等于给错表盖章。

修法:删除 comm_addr 字段与全部地址注释,元数据表改 4 字段;协议地址的
唯一真源是 iec104_dtu_table.c 的 17 项语义桥表。同步改 check_setview_limits
的 meta 解析、两处单测与四篇活文档。armcc 实测 .constdata 640 B 不变。

验证:Keil 0 错误 0 警告(Code=365,928 / RO=45,764 / RW=2,752 /
ZI=168,392,RW_IRAM1=113,720 B / 86.76%);transport 11/11、真实 TCP
验收 13/13、prot_set 173/173、prot_elm 60/60、prot_dim 44/44、
prot_set_store 16/16、adc_cal 150/150、iec104_serv 60/60、iec104_dtu
7/7;check_setview_limits 40/40/40 OK;模拟器构建 OK;pre-commit RC=0。
2026-11-19 17:16:56 +08:00

837 lines
37 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
/*
* 模块名称:保护定值模型(P1)主机侧单元测试
* 模块功能:在 PC 上对 App/algo/prot_set.c 做离线验证。
*
* 被测对象:真实源文件(#include 原样纳入)。纯逻辑,无需桩。
*
* 覆盖点(docs/算法/继电保护功能复现规划.md §5.2 / §3.4 定值校验和):
* TC-PROTSET-001 init:默认值装载、越界位图 0、selfcheck 通过、未闭锁
* TC-PROTSET-002 set:范围内写入生效;越界拒写且原值不动
* TC-PROTSET-003 校验和封存语义:set 后未 seal → selfcheck 失败并闭锁;
* seal → 通过并解锁(定值校验和 核心闭环)
* TC-PROTSET-004 load_raw:合法整表装载并封存;含越界项 → 整表不装载 +
* bad_mask 指认越界项(定值一致性:宁可全旧不可半新)
* TC-PROTSET-005 Q10 往返精度(±1 LSB)
* TC-PROTSET-006 元数据表自检:min<=max、投退项 0..1
* TC-PROTSET-007 越界编号守卫(get/set)
* TC-PROTSET-008 全局软压板 PS_GLOBAL_EN(B7):默认投入、set_sealed 原子写
* 不破坏 selfcheck、脏标志三件套(peek/take/mark)
* TC-PROTSET-009 持久化 blob 往返:serialize → init 清场 → parse 恢复
* (位精确 + 封存自洽 + parse 不置脏)
* TC-PROTSET-010 损坏 blob 整表拒绝(all-or-nothing):值区位翻转/坏 magic/
* 截断/超长/坏版本/伪造自洽越界 → 全部拒绝且活跃值区一字不动
* TC-PROTSET-011 OF/UF 定值行(B8):40 项 / blob 版本 2 / 本地项地址 0 /
* 默认值与范围 / 返回系数独立性 / 64 位 bad_mask(bit 39)/
* B7 旧档(32 项)换代拒绝
* 批量原子写与写事务锁(104 定值下发接线):
* tc_batch_write_and_seal 整批写 3 项 → 读回 / 自检通过 / 未闭锁 / 置脏
* tc_batch_reject_is_all_or_nothing 一项越界 → 整批拒且值区一字未改
* tc_batch_reject_duplicate_id 同批重复 id → 拒
* tc_batch_reject_over_limit 项数超上限 → 拒
* tc_validate_only_has_no_side_effect 预检全合法 → 值区/脏位/锁位/钩子全不动
* tc_validate_only_reports_bad_item 预检有越界 → 拒且全不动
* tc_read_batch_guards 正常读回;越界 id / n 为 0 / 空指针 → 拒
* tc_write_lock_pairs 成功写 enter/exit 各一次;预检与失败分支不进钩子
* tc_selfcheck_tolerates_commit_window 提交窗口内自检只跳过、不误锁
* tc_lock_uninstall 卸载钩子后仍能正常写
* tc_selfcheck_odd_streak_failsafe 写者永久停在提交窗口内 → 8 拍宽限后闭锁
* (fail-safe;用故意漏 exit 的缺陷写者样本驱动)
* tc_bad_mask_tracks_whole_table_only 位图只跟整表装载/解析走,增量写入
* 既不置也不清(契约钉死)
*
* 通过:全部 TC PASS(main 返回 0)。
* 创建日期:2026-10-11;2026-10-12 扩 OF/UF(B8)
*/
#include <stdint.h>
#include <stdio.h>
static int s_total = 0, s_passed = 0, s_failed = 0;
#define CHECK(cond, name) do { \
s_total++; \
if (cond) { s_passed++; printf(" [PASS] %s\n", name); } \
else { s_failed++; printf(" [FAIL] %s (line %d)\n", name, __LINE__); } \
} while (0)
#include "prot_set.c"
/* TC-PROTSET-001 */
static void tc_init(void) {
prot_set_init();
CHECK(prot_set_bad_mask() == 0u, "TC-PROTSET-001 init: no bad items");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-001 init: selfcheck pass");
CHECK(prot_set_locked() == 0u, "TC-PROTSET-001 init: not locked");
CHECK(prot_set_get_f(PS_OC1_CUR) > 9.99f && prot_set_get_f(PS_OC1_CUR) < 10.01f,
"TC-PROTSET-001 default OC1 current = 10.0 A");
CHECK(prot_set_get_ctl(PS_OC3_TRIP) == 0u,
"TC-PROTSET-001 default OC3 = alarm (trip off)");
}
/* TC-PROTSET-002 */
static void tc_set_range(void) {
prot_set_init();
CHECK(prot_set_set(PS_OC2_CUR, PROT_SET_Q10(7.5)) == 0,
"TC-PROTSET-002 in-range set accepted");
CHECK(prot_set_get_f(PS_OC2_CUR) > 7.49f && prot_set_get_f(PS_OC2_CUR) < 7.51f,
"TC-PROTSET-002 value readable after set");
CHECK(prot_set_set(PS_OC2_CUR, PROT_SET_Q10(101.0)) == -1,
"TC-PROTSET-002 over-max set rejected");
CHECK(prot_set_get_f(PS_OC2_CUR) > 7.49f && prot_set_get_f(PS_OC2_CUR) < 7.51f,
"TC-PROTSET-002 rejected set leaves value unchanged");
CHECK(prot_set_set(PS_OC1_EN, PROT_SET_Q10(2)) == -1,
"TC-PROTSET-002 ctl item rejects value 2");
}
/* TC-PROTSET-003 */
static void tc_seal_selfcheck(void) {
prot_set_init();
CHECK(prot_set_set(PS_OC1_CUR, PROT_SET_Q10(8.0)) == 0, "TC-PROTSET-003 set ok");
CHECK(prot_set_selfcheck() == -1,
"TC-PROTSET-003 set-without-seal => selfcheck FAIL (tamper detect)");
CHECK(prot_set_locked() == 1u, "TC-PROTSET-003 selfcheck failure latches lock");
prot_set_seal();
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-003 seal => selfcheck pass");
CHECK(prot_set_locked() == 0u, "TC-PROTSET-003 seal clears lock");
}
/* TC-PROTSET-004 */
static void tc_load_raw(void) {
int32_t tbl[PS_ID_COUNT];
uint32_t i;
prot_set_init();
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = prot_set_get((prot_set_id_t)i);
}
tbl[PS_OL_CUR] = PROT_SET_Q10(1.5);
CHECK(prot_set_load_raw(tbl) == 0, "TC-PROTSET-004 valid table loads");
CHECK(prot_set_get_f(PS_OL_CUR) > 1.49f && prot_set_get_f(PS_OL_CUR) < 1.51f,
"TC-PROTSET-004 loaded value visible");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-004 load_raw auto-seals");
tbl[PS_OC3_DLY] = PROT_SET_Q10(60001.0); /* 越上限 */
tbl[PS_OL_CUR] = PROT_SET_Q10(2.5); /* 合法改动 */
CHECK(prot_set_load_raw(tbl) == -1, "TC-PROTSET-004 bad table rejected");
CHECK(prot_set_bad_mask() == (1uLL << PS_OC3_DLY),
"TC-PROTSET-004 bad_mask points at the offending item");
CHECK(prot_set_get_f(PS_OL_CUR) > 1.49f && prot_set_get_f(PS_OL_CUR) < 1.51f,
"TC-PROTSET-004 rejected load keeps OLD table (all-or-nothing)");
CHECK(prot_set_load_raw(0) == -1, "TC-PROTSET-004 NULL table rejected");
}
/* TC-PROTSET-005 */
static void tc_q10_roundtrip(void) {
float v = 12.345f;
int32_t q;
prot_set_init();
q = PROT_SET_Q10(v);
CHECK(prot_set_set(PS_OC1_CUR, q) == 0, "TC-PROTSET-005 set ok");
{
float back = prot_set_get_f(PS_OC1_CUR);
float err = back - v;
if (err < 0.0f) { err = -err; }
CHECK(err < 0.001f, "TC-PROTSET-005 Q10 roundtrip error < 1 LSB");
}
}
/* TC-PROTSET-006 */
static void tc_meta_sanity(void) {
uint32_t i;
int ok_range = 1, ok_ctl = 1;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
const prot_set_meta_t *m = &g_prot_set_meta[i];
if (m->min > m->max) { ok_range = 0; }
if ((m->def < m->min) || (m->def > m->max)) { ok_range = 0; }
if ((m->is_ctl != 0u) &&
((m->min != 0) || (m->max != PROT_SET_Q10(1)))) { ok_ctl = 0; }
}
CHECK(ok_range, "TC-PROTSET-006 meta: min<=def<=max for all items");
CHECK(ok_ctl, "TC-PROTSET-006 meta: ctl items are 0..1");
CHECK((uint32_t)PS_ID_COUNT <= 64u, "TC-PROTSET-006 item count fits 64-bit bad_mask (B8: 40)");
}
/* TC-PROTSET-007 */
static void tc_id_guard(void) {
prot_set_init();
CHECK(prot_set_get(PS_ID_COUNT) == 0, "TC-PROTSET-007 get out-of-range id -> 0");
CHECK(prot_set_set(PS_ID_COUNT, 0) == -1, "TC-PROTSET-007 set out-of-range id -> -1");
CHECK(prot_set_set_sealed(PS_ID_COUNT, 0) == -1, "TC-PROTSET-007 set_sealed id guard");
}
/* TC-PROTSET-008(B7:全局软压板 + 原子写 + 脏标志) */
static void tc_global_plate_dirty(void) {
prot_set_init();
CHECK(prot_set_dirty_peek() == 0u, "TC-PROTSET-008 init not dirty");
CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 1u, "TC-PROTSET-008 global plate default IN");
CHECK(prot_set_set(PS_GLOBAL_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-008 plate rejects 2");
CHECK(prot_set_set_sealed(PS_GLOBAL_EN, 0) == 0, "TC-PROTSET-008 plate OUT via set_sealed");
CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "TC-PROTSET-008 plate OUT readable");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-008 set_sealed leaves selfcheck PASS (no unsealed window)");
CHECK(prot_set_locked() == 0u, "TC-PROTSET-008 set_sealed no lock");
CHECK(prot_set_dirty_peek() == 1u, "TC-PROTSET-008 set_sealed marks dirty");
CHECK(prot_set_dirty_take() == 1u, "TC-PROTSET-008 dirty take consumes");
CHECK(prot_set_dirty_peek() == 0u, "TC-PROTSET-008 dirty cleared after take");
prot_set_dirty_mark();
CHECK(prot_set_dirty_peek() == 1u, "TC-PROTSET-008 dirty mark re-arms (write-fail retry)");
CHECK(prot_set_set_sealed(PS_GLOBAL_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-008 set_sealed range check");
CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "TC-PROTSET-008 rejected set_sealed keeps value");
}
/* TC-PROTSET-009(B7:blob 往返) */
static void tc_store_roundtrip(void) {
uint8_t blob[PROT_SET_BLOB_SZ];
uint32_t len = 0u;
int32_t cur;
prot_set_init();
(void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(12.5));
(void)prot_set_set_sealed(PS_GLOBAL_EN, 0);
(void)prot_set_dirty_take();
cur = prot_set_get(PS_OC1_CUR);
CHECK(prot_set_store_serialize(blob, sizeof(blob), &len) == 0, "TC-PROTSET-009 serialize ok");
CHECK(len == (uint32_t)PROT_SET_BLOB_SZ, "TC-PROTSET-009 blob exact size");
prot_set_init();
CHECK(prot_set_get(PS_OC1_CUR) != cur, "TC-PROTSET-009 init wiped to defaults");
CHECK(prot_set_store_parse(blob, len) == 0, "TC-PROTSET-009 parse ok");
CHECK(prot_set_get(PS_OC1_CUR) == cur, "TC-PROTSET-009 value round-trip bit-exact");
CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "TC-PROTSET-009 plate state round-trip");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-009 parsed table sealed");
CHECK(prot_set_dirty_peek() == 0u, "TC-PROTSET-009 parse does not mark dirty");
}
/* 伪造辅助:按 blob 值区重算尾部 sum/sumn(构造"自洽但越界"的对抗样本) */
static void s_forge_tail(uint8_t *b, uint32_t len) {
uint32_t sum = 0u;
uint32_t inv;
uint32_t i;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
sum += s_get32(b + PROT_SET_BLOB_HDR_SZ + 4u * i);
}
inv = ~sum;
s_put32(b + len - 8u, sum);
s_put32(b + len - 4u, inv);
}
/* TC-PROTSET-010(B7:损坏 blob 整表拒绝,all-or-nothing) */
static void tc_store_corrupt(void) {
uint8_t blob[PROT_SET_BLOB_SZ];
uint32_t len = 0u;
int32_t keep;
prot_set_init();
(void)prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(6.0));
keep = prot_set_get(PS_OC2_CUR);
CHECK(prot_set_store_serialize(blob, sizeof(blob), &len) == 0, "TC-PROTSET-010 serialize ok");
blob[PROT_SET_BLOB_HDR_SZ] ^= 0x01u; /* 值区一位翻转:sum 对不符 */
CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 flipped value byte rejected (sum pair)");
CHECK(prot_set_get(PS_OC2_CUR) == keep, "TC-PROTSET-010 reject leaves values untouched");
(void)prot_set_store_serialize(blob, sizeof(blob), &len);
blob[0] ^= 0xFFu; /* magic 破坏 */
CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 bad magic rejected");
(void)prot_set_store_serialize(blob, sizeof(blob), &len);
CHECK(prot_set_store_parse(blob, len - 4u) == -1, "TC-PROTSET-010 truncated blob rejected");
CHECK(prot_set_store_parse(blob, len + 4u) == -1, "TC-PROTSET-010 oversized blob rejected");
(void)prot_set_store_serialize(blob, sizeof(blob), &len);
blob[5] ^= 0x02u; /* version 高字节:1 -> 0x200 */
CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 version mismatch rejected");
/* 对抗样本:越限定值 + 重算 sum 对(校验全过、范围必拦) */
(void)prot_set_store_serialize(blob, sizeof(blob), &len);
s_put32(blob + PROT_SET_BLOB_HDR_SZ + 4u * (uint32_t)PS_OC1_CUR,
(uint32_t)(g_prot_set_meta[PS_OC1_CUR].max + 1));
s_forge_tail(blob, len);
CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-010 forged consistent out-of-range rejected");
CHECK(prot_set_bad_mask() == (1uLL << PS_OC1_CUR), "TC-PROTSET-010 bad_mask points at item");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(10.0), "TC-PROTSET-010 defaults still intact");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-010 active table still self-consistent after all rejects");
}
/* TC-PROTSET-011(B8:OF/UF 定值行 + 40 项 + 64 位 bad_mask + 换代拒绝) */
static void tc_of_uf_meta(void) {
uint8_t blob[PROT_SET_BLOB_SZ];
uint32_t len = 0u;
prot_set_init();
/* 结构:40 项、blob 版本 2、尺寸随项数自适应 */
CHECK((uint32_t)PS_ID_COUNT == 40u, "TC-PROTSET-011 PS_ID_COUNT == 40 (32 + 8 OF/UF)");
CHECK(PROT_SET_BLOB_VER == 2u, "TC-PROTSET-011 blob version bumped to 2 (B8)");
CHECK((uint32_t)PROT_SET_BLOB_SZ == (PROT_SET_BLOB_HDR_SZ + 4u * 40u + 8u),
"TC-PROTSET-011 blob size = hdr + 4*40 + tail");
/* 本地项判定已由 104 侧桥表 iec104_dtu_protection_mapping() 承担:
* OF/UF 八项的地址不在桥表内 → 104 C_RD/C_SE 不可寻址。本模块不再有
* 地址概念,故此处不再断言(且本编译单元不链 iec104_dtu_table.c)。 */
/* 投退 = ctl 项(0/1),其余 = 模拟量 Q10 */
CHECK((g_prot_set_meta[PS_OF_EN].is_ctl == 1u) && (g_prot_set_meta[PS_UF_EN].is_ctl == 1u)
&& (g_prot_set_meta[PS_OF_HZ].is_ctl == 0u) && (g_prot_set_meta[PS_RET_UF].is_ctl == 0u),
"TC-PROTSET-011 EN items are ctl, HZ/DLY/RET are Q10 analog");
/* 出厂默认(拟定值)与范围 */
CHECK(prot_set_get(PS_OF_EN) == PROT_SET_Q10(1.0), "TC-PROTSET-011 OF EN default 1");
CHECK(prot_set_get(PS_UF_EN) == PROT_SET_Q10(1.0), "TC-PROTSET-011 UF EN default 1");
CHECK(prot_set_get(PS_OF_HZ) == PROT_SET_Q10(51.0), "TC-PROTSET-011 OF default 51.0 Hz");
CHECK(prot_set_get(PS_UF_HZ) == PROT_SET_Q10(49.0), "TC-PROTSET-011 UF default 49.0 Hz");
CHECK(prot_set_get(PS_OF_DLY) == PROT_SET_Q10(1000.0), "TC-PROTSET-011 OF default 1000 ms");
CHECK(prot_set_get(PS_UF_DLY) == PROT_SET_Q10(1000.0), "TC-PROTSET-011 UF default 1000 ms");
CHECK(prot_set_get(PS_RET_OF) == PROT_SET_Q10(0.99), "TC-PROTSET-011 RET_OF default 0.99");
CHECK(prot_set_get(PS_RET_UF) == PROT_SET_Q10(1.01), "TC-PROTSET-011 RET_UF default 1.01");
CHECK((g_prot_set_meta[PS_OF_HZ].min == PROT_SET_Q10(50.0))
&& (g_prot_set_meta[PS_OF_HZ].max == PROT_SET_Q10(55.0)),
"TC-PROTSET-011 OF range 50.0~55.0 Hz");
CHECK((g_prot_set_meta[PS_UF_HZ].min == PROT_SET_Q10(45.0))
&& (g_prot_set_meta[PS_UF_HZ].max == PROT_SET_Q10(50.0)),
"TC-PROTSET-011 UF range 45.0~50.0 Hz");
/* 频率返回系数与电气量系数独立:返回**门槛** = 定值×系数(Q10 乘积
* /1024)——OF 门槛 < 动作门槛、UF 门槛 > 动作门槛(方向相反) */
CHECK(((int64_t)prot_set_get(PS_OF_HZ) * (int64_t)prot_set_get(PS_RET_OF)) / 1024
< (int64_t)prot_set_get(PS_OF_HZ),
"TC-PROTSET-011 OF return threshold (set x 0.99) below pickup");
CHECK(((int64_t)prot_set_get(PS_UF_HZ) * (int64_t)prot_set_get(PS_RET_UF)) / 1024
> (int64_t)prot_set_get(PS_UF_HZ),
"TC-PROTSET-011 UF return threshold (set x 1.01) above pickup");
/* 投退可经 set_sealed 投/退(YK 口径同 GLOBAL_EN;Q10(2)=2048 越界拒) */
CHECK(prot_set_set_sealed(PS_OF_EN, 0) == 0, "TC-PROTSET-011 OF EN set_sealed OK");
CHECK(prot_set_get_ctl(PS_OF_EN) == 0u, "TC-PROTSET-011 OF EN readable after seal");
CHECK(prot_set_set_sealed(PS_OF_EN, PROT_SET_Q10(2)) == -1, "TC-PROTSET-011 OF EN rejects Q10(2)");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-011 no lock after OF/UF seal ops");
/* 64 位 bad_mask:末项(bit 39 > 31)越界可指认 */
(void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(11.0));
(void)prot_set_dirty_take();
CHECK(prot_set_store_serialize(blob, sizeof(blob), &len) == 0, "TC-PROTSET-011 serialize ok");
s_put32(blob + PROT_SET_BLOB_HDR_SZ + 4u * (uint32_t)PS_RET_UF,
(uint32_t)(g_prot_set_meta[PS_RET_UF].max + 1));
s_forge_tail(blob, len);
CHECK(prot_set_store_parse(blob, len) == -1, "TC-PROTSET-011 out-of-range RET_UF rejected");
CHECK(prot_set_bad_mask() == (1uLL << PS_RET_UF),
"TC-PROTSET-011 bad_mask bit 39 addressable (64-bit mask, B8)");
CHECK(prot_set_get(PS_RET_UF) == PROT_SET_Q10(1.01), "TC-PROTSET-011 default RET_UF intact");
/* 换代语义:B7 旧档(ver=1 / 32 项 = 144 B)在新固件必被拒 -> 出厂默认 */
CHECK(prot_set_store_parse(blob, 8u + 4u * 32u + 8u) == -1,
"TC-PROTSET-011 legacy 32-item blob length rejected");
CHECK(prot_set_selfcheck() == 0, "TC-PROTSET-011 active table intact after legacy reject");
}
/* 整表快照:值区 + 脏位 + 闭锁位("一字未改"与"零副作用"的比对基准) */
typedef struct {
int32_t vals[PS_ID_COUNT];
uint8_t dirty;
uint8_t locked;
} tc_snapshot_t;
/*
* 函数功能:把当前定值状态拍成快照
* 入口参数:s - 输出快照
* 返 回 值:无
*/
static void tc_snapshot(tc_snapshot_t *s) {
uint32_t i;
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
s->vals[i] = prot_set_get((prot_set_id_t)i);
}
s->dirty = prot_set_dirty_peek();
s->locked = prot_set_locked();
}
/*
* 函数功能:比对两份快照是否逐字相同
* 入口参数:a/b - 待比快照
* 返 回 值:1 完全相同 / 0 有差异
*/
static int tc_snapshot_same(const tc_snapshot_t *a, const tc_snapshot_t *b) {
uint32_t i;
if ((a->dirty != b->dirty) || (a->locked != b->locked)) {
return 0;
}
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
if (a->vals[i] != b->vals[i]) {
return 0;
}
}
return 1;
}
/* 计数版写事务钩子:证明"哪条分支真的进了临界区" */
static int s_hook_enter = 0;
static int s_hook_exit = 0;
/*
* 函数功能:计数钩子——进入写事务
* 入口参数:无
* 返 回 值:无
*/
static void tc_hook_enter(void) {
s_hook_enter++;
}
/*
* 函数功能:计数钩子——退出写事务
* 入口参数:无
* 返 回 值:无
*/
static void tc_hook_exit(void) {
s_hook_exit++;
}
static const prot_set_lock_t s_test_lock = { tc_hook_enter, tc_hook_exit };
/*
* 函数功能:装钩子并清零计数
* 入口参数:无
* 返 回 值:无
*/
static void tc_lock_on(void) {
s_hook_enter = 0;
s_hook_exit = 0;
prot_set_lock_install(&s_test_lock);
}
/* 批量写:正常整批提交的闭环(值/自检/闭锁/脏位) */
static void tc_batch_write_and_seal(void) {
prot_set_change_t chg[3];
prot_set_id_t ids[3];
int32_t got[3];
prot_set_init();
prot_set_lock_install(0);
CHECK(prot_set_dirty_peek() == 0u, "batch write: clean table before commit");
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.5);
chg[1].id = PS_OC2_DLY; chg[1].q10 = PROT_SET_Q10(250.0);
chg[2].id = PS_GLOBAL_EN; chg[2].q10 = 0;
CHECK(prot_set_apply_batch(chg, 3u, 0) == 0, "batch write: three items committed");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(7.5), "batch write: OC1 current updated");
CHECK(prot_set_get(PS_OC2_DLY) == PROT_SET_Q10(250.0), "batch write: OC2 delay updated");
CHECK(prot_set_get_ctl(PS_GLOBAL_EN) == 0u, "batch write: global plate switched out");
CHECK(prot_set_selfcheck() == 0, "batch write: selfcheck passes right after commit");
CHECK(prot_set_locked() == 0u, "batch write: no lock after commit");
CHECK(prot_set_dirty_peek() == 1u, "batch write: commit marks dirty for persistence");
ids[0] = PS_OC1_CUR;
ids[1] = PS_OC2_DLY;
ids[2] = PS_GLOBAL_EN;
CHECK(prot_set_read_batch(ids, 3u, got) == 0, "batch write: read back same three items");
CHECK((got[0] == PROT_SET_Q10(7.5)) && (got[1] == PROT_SET_Q10(250.0)) && (got[2] == 0),
"batch write: read-back values match what was written");
}
/* 批量写:一项越界 → 整批拒绝且值区一字未改(all-or-nothing) */
static void tc_batch_reject_is_all_or_nothing(void) {
prot_set_change_t chg[3];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
prot_set_lock_install(0);
(void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(9.0)); /* 先建立一个非默认现状 */
(void)prot_set_dirty_take();
tc_snapshot(&before);
chg[0].id = PS_OC2_CUR; chg[0].q10 = PROT_SET_Q10(6.0); /* 合法 */
chg[1].id = PS_OC3_DLY; chg[1].q10 = PROT_SET_Q10(60001.0); /* 越上限 */
chg[2].id = PS_OL_CUR; chg[2].q10 = PROT_SET_Q10(2.0); /* 合法 */
CHECK(prot_set_apply_batch(chg, 3u, 0) == -1, "batch reject: one bad item rejects the batch");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after),
"batch reject: every item, dirty flag and lock state untouched");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(9.0),
"batch reject: pre-existing value survives the rejected batch");
CHECK(prot_set_selfcheck() == 0, "batch reject: table still self-consistent");
}
/* 批量写:同批重复编号 → 拒(语义不确定) */
static void tc_batch_reject_duplicate_id(void) {
prot_set_change_t chg[2];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
prot_set_lock_install(0);
tc_snapshot(&before);
chg[0].id = PS_OC2_CUR; chg[0].q10 = PROT_SET_Q10(6.0);
chg[1].id = PS_OC2_CUR; chg[1].q10 = PROT_SET_Q10(7.0);
CHECK(prot_set_apply_batch(chg, 2u, 0) == -1, "batch reject: duplicate id rejected");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after), "batch reject duplicate: table untouched");
}
/* 批量写:项数超上限 → 拒(整表只有 40 项,批量接口不接受更多) */
static void tc_batch_reject_over_limit(void) {
prot_set_change_t chg[PROT_SET_BATCH_MAX + 1u];
tc_snapshot_t before;
tc_snapshot_t after;
size_t i;
prot_set_init();
prot_set_lock_install(0);
tc_snapshot(&before);
for (i = 0u; i < (PROT_SET_BATCH_MAX + 1u); i++) {
chg[i].id = (prot_set_id_t)(i % (size_t)PS_ID_COUNT);
chg[i].q10 = prot_set_get(chg[i].id); /* 值全合法,只考项数 */
}
CHECK(prot_set_apply_batch(chg, PROT_SET_BATCH_MAX + 1u, 0) == -1,
"batch reject: item count above limit rejected");
CHECK(prot_set_apply_batch(chg, 0u, 0) == -1, "batch reject: empty batch rejected");
CHECK(prot_set_apply_batch(0, 1u, 0) == -1, "batch reject: NULL change list rejected");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after), "batch reject over limit: table untouched");
}
/* 预检(validate_only):全合法时零副作用——值区、脏位、闭锁位、钩子全不动 */
static void tc_validate_only_has_no_side_effect(void) {
prot_set_change_t chg[2];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
(void)prot_set_set_sealed(PS_OC1_CUR, PROT_SET_Q10(8.0));
(void)prot_set_dirty_take();
tc_lock_on();
tc_snapshot(&before);
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(9.0);
chg[1].id = PS_UF_HZ; chg[1].q10 = PROT_SET_Q10(47.0);
CHECK(prot_set_apply_batch(chg, 2u, 1) == 0, "validate only: valid batch reported OK");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after),
"validate only: values, dirty flag and lock state all unchanged");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(8.0),
"validate only: proposed value NOT applied");
CHECK(prot_set_get(PS_UF_HZ) == PROT_SET_Q10(49.0),
"validate only: untouched item keeps its old value");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"validate only: write lock hook never entered");
prot_set_lock_install(0);
}
/* 预检(validate_only):有越界项 → 拒,同样全不动 */
static void tc_validate_only_reports_bad_item(void) {
prot_set_change_t chg[2];
tc_snapshot_t before;
tc_snapshot_t after;
prot_set_init();
tc_lock_on();
tc_snapshot(&before);
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(9.0);
chg[1].id = PS_UF_HZ; chg[1].q10 = PROT_SET_Q10(44.0); /* 低于下限 45 */
CHECK(prot_set_apply_batch(chg, 2u, 1) == -1, "validate only: out-of-range item reported");
tc_snapshot(&after);
CHECK(tc_snapshot_same(&before, &after), "validate only reject: nothing changed");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"validate only reject: write lock hook never entered");
prot_set_lock_install(0);
}
/* 批量读:正常读回;越界编号 / 零项 / 空指针 → 拒 */
static void tc_read_batch_guards(void) {
prot_set_id_t ids[2];
prot_set_id_t bad[1];
int32_t got[2];
prot_set_init();
(void)prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(6.5));
ids[0] = PS_OC2_CUR;
ids[1] = PS_RET_UF;
got[0] = 0;
got[1] = 0;
CHECK(prot_set_read_batch(ids, 2u, got) == 0, "read batch: two items read");
CHECK(got[0] == PROT_SET_Q10(6.5), "read batch: first value matches");
CHECK(got[1] == PROT_SET_Q10(1.01), "read batch: second value matches");
bad[0] = PS_ID_COUNT;
CHECK(prot_set_read_batch(bad, 1u, got) == -1, "read batch: out-of-range id rejected");
CHECK(prot_set_read_batch(ids, 0u, got) == -1, "read batch: zero count rejected");
CHECK(prot_set_read_batch(0, 2u, got) == -1, "read batch: NULL id list rejected");
CHECK(prot_set_read_batch(ids, 2u, 0) == -1, "read batch: NULL output rejected");
}
/* 写事务锁:成功写 enter/exit 各一次;预检与失败分支不进钩子 */
static void tc_write_lock_pairs(void) {
prot_set_change_t chg[2];
int32_t tbl[PS_ID_COUNT];
uint32_t i;
prot_set_init();
tc_lock_on();
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.0);
chg[1].id = PS_OL_CUR; chg[1].q10 = PROT_SET_Q10(1.2);
CHECK(prot_set_apply_batch(chg, 2u, 0) == 0, "lock pairs: batch commit succeeds");
CHECK((s_hook_enter == 1) && (s_hook_exit == 1),
"lock pairs: batch commit enters and exits the write lock exactly once");
s_hook_enter = 0;
s_hook_exit = 0;
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(999.0); /* 越界 */
CHECK(prot_set_apply_batch(chg, 1u, 0) == -1, "lock pairs: out-of-range batch rejected");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"lock pairs: rejected batch never enters the write lock");
s_hook_enter = 0;
s_hook_exit = 0;
CHECK(prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(4.0)) == 0,
"lock pairs: single item write succeeds");
CHECK((s_hook_enter == 1) && (s_hook_exit == 1),
"lock pairs: single item write enters and exits exactly once");
s_hook_enter = 0;
s_hook_exit = 0;
CHECK(prot_set_set_sealed(PS_ID_COUNT, 0) == -1, "lock pairs: bad id rejected");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"lock pairs: rejected single write never enters the write lock");
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = prot_set_get((prot_set_id_t)i);
}
tbl[PS_OC3_CUR] = PROT_SET_Q10(3.0);
s_hook_enter = 0;
s_hook_exit = 0;
CHECK(prot_set_load_raw(tbl) == 0, "lock pairs: whole table load succeeds");
CHECK((s_hook_enter == 1) && (s_hook_exit == 1),
"lock pairs: whole table load enters and exits exactly once");
s_hook_enter = 0;
s_hook_exit = 0;
tbl[PS_OC3_CUR] = PROT_SET_Q10(999.0);
CHECK(prot_set_load_raw(tbl) == -1, "lock pairs: bad table rejected");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0),
"lock pairs: rejected table load never enters the write lock");
prot_set_lock_install(0);
}
/* 提交窗口内自检不得误判失配(多写者引入的安全级风险) */
static void tc_selfcheck_tolerates_commit_window(void) {
uint32_t keep_sum;
uint32_t keep_sumn;
prot_set_init();
/* 模拟"封存对已改、活跃区未交换"的窗口:这是另一写者抢占时的真实中间态,
* 巡检撞上它绝不能闭锁整台保护 */
keep_sum = s_sum;
keep_sumn = s_sumn;
prot_write_enter();
s_sum = prot_sum_buf(s_val[s_act]) + 1u;
s_sumn = ~s_sum;
CHECK(prot_set_selfcheck() == 0, "commit window: selfcheck skips instead of latching");
CHECK(prot_set_locked() == 0u, "commit window: no lock latched during commit");
s_sum = keep_sum;
s_sumn = keep_sumn;
prot_write_exit();
CHECK(prot_set_selfcheck() == 0, "commit window: selfcheck passes once commit settles");
/* 无提交在飞时的真失配仍必须闭锁(防篡改语义不许被上述跳过放宽) */
s_val[s_act][(uint32_t)PS_OC1_CUR] ^= 1u;
CHECK(prot_set_selfcheck() == -1, "tamper: real mismatch still caught when idle");
CHECK(prot_set_locked() == 1u, "tamper: real mismatch still latches the lock");
prot_set_init();
CHECK(prot_set_selfcheck() == 0, "tamper: re-init clears the lock");
}
/* 卸载钩子后仍能正常写(模拟器 / 主机单测的单写者假设) */
static void tc_lock_uninstall(void) {
prot_set_change_t chg[1];
prot_set_init();
tc_lock_on();
prot_set_lock_install(0);
s_hook_enter = 0;
s_hook_exit = 0;
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(6.25);
CHECK(prot_set_apply_batch(chg, 1u, 0) == 0, "lock uninstall: batch commit works without hook");
CHECK(prot_set_get(PS_OC1_CUR) == PROT_SET_Q10(6.25), "lock uninstall: value applied");
CHECK(prot_set_selfcheck() == 0, "lock uninstall: table self-consistent");
CHECK((s_hook_enter == 0) && (s_hook_exit == 0), "lock uninstall: hook not called anymore");
}
/*
* 缺陷写者样本:**故意**在 prot_write_enter() 之后提前 return、忘了 exit。
* 这是 prot_set.c 里明令禁止的形态(四条真实路径都把校验放在 enter 之前),
* 但"以后有人加路径时忘了这条纪律"是真实可能——本用例用它把自检的 fail-safe
* 兜底钉死:序号一旦永久停在奇数,防篡改自检必须自己发现写者已死、置闭锁,
* 而不是永远"本轮跳过"。
*/
static int tc_buggy_writer_early_return(const prot_set_change_t *changes, size_t n) {
uint32_t cur_act;
prot_write_enter();
if ((n == 0u) || (changes == 0)) {
return -1; /* 缺陷:锁内提前返回,没有 prot_write_exit() */
}
if ((changes[0].q10 < g_prot_set_meta[changes[0].id].min)
|| (changes[0].q10 > g_prot_set_meta[changes[0].id].max)) {
return -1; /* 缺陷同上 */
}
cur_act = s_act;
prot_copy_buf(s_val[cur_act ^ 1u], s_val[cur_act]);
s_val[cur_act ^ 1u][(uint32_t)changes[0].id] = (uint32_t)changes[0].q10;
s_sum = prot_sum_buf(s_val[cur_act ^ 1u]);
s_sumn = ~s_sum;
s_locked = 0u;
s_act = (uint8_t)(cur_act ^ 1u);
s_dirty = 1u;
prot_write_exit();
return 0;
}
/* 自检 fail-safe:写者永久停在提交窗口内 → 有界宽限后必须闭锁 */
static void tc_selfcheck_odd_streak_failsafe(void) {
prot_set_change_t chg[1];
uint32_t i;
int early_ok = 1;
int all_clear = 1;
prot_set_init();
CHECK(prot_set_selfcheck() == 0, "odd streak: healthy table selfchecks clean");
/* 真实缺陷路径:enter 之后越界提前 return → 序号永久停在奇数 */
chg[0].id = PS_OC1_CUR;
chg[0].q10 = g_prot_set_meta[PS_OC1_CUR].max + 1;
CHECK(tc_buggy_writer_early_return(chg, 1u) == -1, "odd streak: buggy writer returns -1");
CHECK((s_seq & 1u) == 1u, "odd streak: sequence number left permanently odd");
/* ① 宽限期内的前 7 拍:跳过但不误锁 */
for (i = 0u; i < (uint32_t)(PROT_SET_ODD_STREAK_MAX - 1u); i++) {
if ((prot_set_selfcheck() != 0) || (prot_set_locked() != 0u)) {
early_ok = 0;
}
}
CHECK(early_ok, "odd streak: first seven ticks skip WITHOUT latching the lock");
/* ② 第 8 拍起:判写者已死 → 闭锁并返回 -1 */
CHECK(prot_set_selfcheck() == -1, "odd streak: eighth tick trips the fail-safe lock");
CHECK(prot_set_locked() == 1u, "odd streak: fail-safe latches the protection lock");
CHECK(prot_set_selfcheck() == -1, "odd streak: lock stays latched on later ticks");
/* ③ 恢复偶数(写者"复活")→ 宽限计数归零,但闭锁仍按既有语义保持到 seal/init */
prot_write_exit();
CHECK((s_seq & 1u) == 0u, "odd streak: sequence number back to even after recovery");
CHECK(prot_set_selfcheck() == -1, "odd streak: lock latched until an explicit seal");
CHECK(s_odd_streak == 0u, "odd streak: grace counter cleared once sequence settles even");
/* ④ fail-safe 的闭锁必须是**可恢复**的:写者恢复后走合法封存路径能解锁,
* 否则一次写者崩溃就等于设备永久报废,现场只能整机返修 */
prot_set_seal();
CHECK(prot_set_locked() == 0u, "odd streak: seal is the documented unlock path after a fail-safe lock");
CHECK(prot_set_selfcheck() == 0, "odd streak: selfcheck clean after re-seal");
prot_set_init();
CHECK(s_odd_streak == 0u, "odd streak: init also zeroes the grace counter");
CHECK(prot_set_locked() == 0u, "odd streak: init clears the fail-safe lock");
CHECK(prot_set_selfcheck() == 0, "odd streak: selfcheck healthy again after init");
/* 反复"撞一下立刻恢复"的健康抖动不该累积:每拍都能看到偶数就每次归零 */
for (i = 0u; i < (uint32_t)(PROT_SET_ODD_STREAK_MAX * 3u); i++) {
prot_write_enter();
prot_write_exit();
if ((prot_set_selfcheck() != 0) || (prot_set_locked() != 0u)) {
all_clear = 0;
}
}
CHECK(all_clear, "odd streak: short commit windows never accumulate into a false lock");
}
/* 契约:bad_mask 只跟整表装载/解析走,增量写入既不置也不清 */
static void tc_bad_mask_tracks_whole_table_only(void) {
int32_t tbl[PS_ID_COUNT];
prot_set_change_t chg[2];
uint64_t bad_before;
uint32_t i;
prot_set_init();
CHECK(prot_set_bad_mask() == 0u, "bad mask: clean after init");
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = prot_set_get((prot_set_id_t)i);
}
tbl[PS_OC3_DLY] = PROT_SET_Q10(60001.0); /* 越上限 */
CHECK(prot_set_load_raw(tbl) == -1, "bad mask: whole-table load with a bad item rejected");
CHECK(prot_set_bad_mask() == (1uLL << PS_OC3_DLY),
"bad mask: whole-table load reports the offending item");
bad_before = prot_set_bad_mask();
/* 一笔成功的批量提交不碰位图——这是刻意契约(不是漏刷) */
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(7.0);
chg[1].id = PS_OL_CUR; chg[1].q10 = PROT_SET_Q10(1.5);
CHECK(prot_set_apply_batch(chg, 2u, 0) == 0, "bad mask: successful batch committed");
CHECK(prot_set_bad_mask() == bad_before,
"bad mask: successful batch leaves the stale bitmap untouched (by contract)");
/* 一笔失败的批量提交同样不碰位图 */
chg[0].id = PS_OC1_CUR; chg[0].q10 = PROT_SET_Q10(999.0);
CHECK(prot_set_apply_batch(chg, 1u, 0) == -1, "bad mask: bad batch rejected");
CHECK(prot_set_bad_mask() == bad_before,
"bad mask: failed batch does not record anything in the bitmap");
/* 单项写入同理 */
CHECK(prot_set_set_sealed(PS_OC2_CUR, PROT_SET_Q10(3.0)) == 0, "bad mask: single write ok");
CHECK(prot_set_bad_mask() == bad_before, "bad mask: single write leaves the bitmap untouched");
/* 只有整表操作与 init 会覆写它(用各项出厂默认值组一张必然合法的表) */
for (i = 0u; i < (uint32_t)PS_ID_COUNT; i++) {
tbl[i] = g_prot_set_meta[i].def;
}
CHECK(prot_set_load_raw(tbl) == 0, "bad mask: all-legal table load accepted");
CHECK(prot_set_bad_mask() == 0u, "bad mask: successful whole-table load rewrites it to clean");
prot_set_init();
CHECK(prot_set_bad_mask() == 0u, "bad mask: init clears it");
}
int main(void) {
printf("=== Prot Set Tests ===\n");
tc_init();
tc_set_range();
tc_seal_selfcheck();
tc_load_raw();
tc_q10_roundtrip();
tc_meta_sanity();
tc_id_guard();
tc_global_plate_dirty();
tc_store_roundtrip();
tc_store_corrupt();
tc_of_uf_meta();
tc_batch_write_and_seal();
tc_batch_reject_is_all_or_nothing();
tc_batch_reject_duplicate_id();
tc_batch_reject_over_limit();
tc_validate_only_has_no_side_effect();
tc_validate_only_reports_bad_item();
tc_read_batch_guards();
tc_write_lock_pairs();
tc_selfcheck_tolerates_commit_window();
tc_lock_uninstall();
tc_selfcheck_odd_streak_failsafe();
tc_bad_mask_tracks_whole_table_only();
printf("\n=== Prot Set Tests: %d/%d PASSED (failed=%d) ===\n",
s_passed, s_total, s_failed);
return (s_failed == 0) ? 0 : 1;
}