wandering1/STM32F4-Base
1
0
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects 2 Releases Wiki Activity

W5波+N-19收口：FTP鉴权落地、Trap25三连定案修复(N-30)、N-20/N-23/N-26

Browse Source 
N-19 FTP 鉴权：
- lftpd_auth（USER/PASS 状态机 + 连续5次失败锁60s）+ SHA-256
  (user||pwd) 口令哈希；config.ini [ftp] 段 user/pwd_hash/write，
  出厂 admin/admin 在用有启动告警；lftpd_log.c 删除并入 lftpd_auth
- ftp_cfg 配置读写；台架 ftp_auth_bench.py 13/13

N-30 / Trap 25（CH395F_Trap_Records.md 四次定案全记录）：
- 修复1 closed-with-data accept：客户端发完正常 FIN 后芯片按
  FUN_PARA(0x09) §5.52② 保留 Socket+RX 缓冲，旧代码把 CLOSED 一律
  relisten 自毁缓冲 → STOR 必挂 425；改为接受"已关但可读"连接排空
- 修复2 丢 CONNECT 中断探针 net_lost_connect_probe + last_peer_port
  幽灵甄别（拆链窗口握手完成但中断丢失，双信源去抖补 accept）
- 修复3 send_list/send_nlst 批量单发：背靠背 ~60B 小段毒化芯片 TX
  （芯片报 SEND_OK 但对端全丢），整份目录一次性写入
- 证伪存档：固定沉降/Socket 轮换冷却/listen 门控（台架 v7 矩阵）
- 台架工具 test/board/ch395f_reuse_bench.{c,h} + host 脚本存档
  （不注册编译；实验分支 n30-chip-bench 保留）

N-20：Error_Handler 死循环降级（记录+复位路径）
N-23：scripts/check_registration.py 双端注册反向校验（pre-commit）
N-26：GD5F NAND 直 DMA 调用方缓冲窗口断言

验证：BUILD_OK 0/0；ftp_regression 连跑 4 轮 11/11（修复前
LIST#4/#7 100% 挂、STOR#2 曾 100% 425）；ftp_auth_bench 13/13；
@test 启动标记 PASS；ci_local L0+L0.5 全过；doc-links 通过。
登记簿 N-30 已销项。
This commit is contained in:
Wanderingss
2026-10-11 18:50:24 +08:00
parent eddbedeee8
commit d1e6bb4ba7
75 changed files with 3928 additions and 352 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/board/ch395f_reuse_bench.c
+373
View File
@@ -0,0 +1,373 @@
/**
* @file ch395f_reuse_bench.c
* @brief N-30 芯片级 Socket 复用时序台架（裸机，内核前运行，OS/net/FTP 全剥离）
* @details 直接调用 ch395f_* 命令，循环执行受控时序矩阵（延迟/关闭次序/载荷/Socket 号），
* 每步打印芯片状态与中断寄存器，定位"关→开→监听→连接"复用时序中
* 芯片行为的确切规律。配套主机脚本 test/host/ch395f_reuse_host.py。
* 定案结论与实验矩阵演进 → CH395F_Trap_Records.md Trap 25。
*
* 存档状态：本文件在主分支**不注册编译**（未加入 uvprojx），仅作实验工具存档；
* 运行方法：在实验分支（如 n30-chip-bench）把本 .c 注册进 uvprojx Test 组、
* Src/main.c 的 USER CODE 2 区在 app_main_init() 之前调 ch395f_reuse_bench()
* （内核前裸机循环，永不返回，断电退出），烧录后跑主机脚本对照芯片日志。
* 当前矩阵为定案轮（对照 vs "丢 CONNECT 捕获自 accept"修复组），见 s_vars[]。
*
* close_mode：0=主机先关（芯片等 DISCONNECT）；1=芯片先关；2=无数据连上即关
* verify：0=无修复；1=listen 后确认 LISTEN 重试；2=缓冲重分配；
* 3=幽灵耐心等；4=等 CONNECT 期轮询状态+自 accept（定案修复）
*/
#include "ch395f_reuse_bench.h"
#if N30_CHIP_BENCH
#include "ch395f.h"
#include "dbg_log.h"
#include "stm32f4xx_hal.h"
/* 变体表：{sock, close 后复开延迟 ms, TX 字节数, close_mode, verify_listen} */
typedef struct {
uint8_t sock;
uint16_t delay_ms;
uint16_t tx_len;
uint8_t close_mode;
uint8_t verify; /* 1 = listen 后确认 TCP==0x01，否则 close 重试（修复假设） */
} bench_var_t;
static const bench_var_t s_vars[] = {
{ 3, 0, 100, 0, 0 }, /* 0ms 对照 */
{ 3, 300, 100, 0, 0 }, /* 300ms 对照 */
{ 3, 800, 2000, 0, 0 }, /* 2KB 对照 */
{ 3, 0, 100, 0, 4 }, /* 0ms + 丢CONNECT捕获自accept */
{ 3, 300, 100, 0, 4 }, /* 300ms + 丢CONNECT捕获 */
{ 3, 800, 2000, 0, 4 }, /* 2KB + 丢CONNECT捕获 */
};
#define BENCH_N_VARS (sizeof(s_vars) / sizeof(s_vars[0]))
#define BENCH_PORT(i) (5000U + (uint16_t)(i))
/* TX 图案缓冲（静态，SRAM；2KB = 最大变体载荷） */
static uint8_t s_tx_pat[2048];
/* RX 排空缓冲 */
static uint8_t s_rx_buf[2048];
/*
* 函数功能：轮询本 Socket 中断（读全局→读本 Socket，读即清）
* 入口参数：sock - Socket 号 uint8_t
* timeout - 超时 ms uint32_t
* out_bits - 输出最后一次读到的 SINT 位 uint8_t *
* 返回值：1=拿到中断 0=超时 int
*/
static int bench_wait_sock_int(uint8_t sock, uint32_t timeout, uint8_t *out_bits) {
uint32_t t0 = HAL_GetTick();
while ((uint32_t)(HAL_GetTick() - t0) < timeout) {
uint16_t glob = ch395f_get_glob_int_status_all();
if ((glob & (1U << (sock + 4U))) != 0U) {
uint8_t si = ch395f_get_sock_int_status(sock);
if (out_bits != 0) {
*out_bits = si;
}
return 1;
}
HAL_Delay(10);
}
return 0;
}
/* 打印芯片两字节状态（Socket 态 / TCP 态） */
static void bench_log_state(const char *tag, uint8_t sock) {
uint8_t st[2] = { 0, 0 };
ch395f_get_socket_status(sock, st);
DBG_INFO("BENCH %s sock%u st=0x%02X/0x%02X t=%u", tag, (unsigned)sock,
st[0], st[1], (unsigned)HAL_GetTick());
}
/* 芯片级初始化（复刻 net_init 序列，剥离全部内核 API） */
static int bench_chip_init(void) {
if (ch395f_check_exist() != CH395F_STATUS_OK) {
DBG_ERROR("BENCH chip not found");
return -1;
}
ch395f_reset();
/* 等 PHY link（Trap 09：link up 前 open 必失败） */
for (int i = 0; i < 100; i++) {
if (ch395f_get_phy_status() != 0U) {
break;
}
HAL_Delay(100);
}
ch395f_set_fun_para(0x09);
ch395f_set_tcp_mss(CH395F_TCP_MSS);
ch395f_set_retrans_count(3);
ch395f_set_retrans_period(200);
ch395f_set_keepalive_idle(60000);
ch395f_set_keepalive_intvl(5000);
ch395f_set_keepalive_cnt(3);
/* 静态 IP（与生产一致） */
{
uint8_t ip[4] = { 192, 168, 1, 100 };
uint8_t gw[4] = { 192, 168, 1, 1 };
uint8_t msk[4] = { 255, 255, 255, 0 };
ch395f_set_ip_addr(ip);
ch395f_set_gwip_addr(gw);
ch395f_set_mask_addr(msk);
}
if (ch395f_init() != CH395F_STATUS_OK) {
DBG_ERROR("BENCH ch395f_init failed");
return -1;
}
/* 8 Socket 缓冲布局（与生产一致） */
for (int i = 7; i >= 0; i--) {
uint8_t recv_start = (uint8_t)(i * 6);
ch395f_set_send_buf((uint8_t)i, (uint8_t)(recv_start + 4), 2);
ch395f_set_recv_buf((uint8_t)i, recv_start, 4);
}
ch395f_ping_enable(1);
return 0;
}
/* 单轮实验 */
static void bench_round(unsigned idx) {
const bench_var_t *v = &s_vars[idx];
uint8_t sock = v->sock;
uint16_t port = BENCH_PORT(idx);
uint8_t si = 0;
/* 幽灵等待期已见 CONNECT 的标志（跳过后续 CONNECT 等待） */
int pre_connected = 0;
DBG_INFO("BENCH === r%u sock%u port%u delay%u tx%u mode%u t=%u",
idx, (unsigned)sock, (unsigned)port, (unsigned)v->delay_ms,
(unsigned)v->tx_len, (unsigned)v->close_mode, (unsigned)HAL_GetTick());
/* 1. open + listen（Trap 09：close 后需延时重开，失败重试 ×3） */
ch395f_set_proto_type(sock, CH395F_PROTO_TYPE_TCP);
ch395f_set_sour_port(sock, port);
uint8_t ost = CH395F_ERR_SUCCESS;
for (int open_try = 0; open_try < 3; open_try++) {
ost = ch395f_open_socket(sock);
if (ost == CH395F_ERR_SUCCESS) {
break;
}
DBG_INFO("BENCH open retry%d err=0x%02X t=%u", open_try, ost, (unsigned)HAL_GetTick());
ch395f_close_socket(sock);
HAL_Delay(500);
}
if (ost != CH395F_ERR_SUCCESS) {
DBG_ERROR("BENCH open fail 0x%02X", ost);
return;
}
uint8_t lst = ch395f_tcp_listen(sock);
if (lst != CH395F_ERR_SUCCESS) {
DBG_ERROR("BENCH listen fail 0x%02X", lst);
ch395f_close_socket(sock);
return;
}
/* 缓冲重分配变体：listen 后重设收发缓冲（隔离"缓冲管理残留"假设） */
if (v->verify == 2U) {
uint8_t recv_start = (uint8_t)(sock * 6);
ch395f_clear_recv_buf(sock);
ch395f_set_send_buf(sock, (uint8_t)(recv_start + 4), 2);
ch395f_set_recv_buf(sock, recv_start, 4);
DBG_INFO("BENCH realloc done sock%u t=%u", (unsigned)sock, (unsigned)HAL_GetTick());
}
/* 清残留中断（与生产 listen 后一致） */
for (int j = 0; j < 8; j++) {
(void)ch395f_get_sock_int_status((uint8_t)j);
}
(void)ch395f_get_glob_int_status_all();
bench_log_state("post-listen", sock);
/* 修复假设验证：listen 后 TCP 态必须真正 == 0x01(LISTEN)；
* mode1：close 快速重试；mode3：耐心等幽灵消退（5s，每 100ms 复查），
* 期间幽灵→LISTEN 转变会补发 CONNECT 中断则直接放行 */
if (v->verify == 1U || v->verify == 3U) {
uint32_t budget = (v->verify == 3U) ? 5000U : 1000U;
int att_max = (v->verify == 3U) ? 2 : 4;
for (int att = 0; att < att_max; att++) {
uint8_t st[2] = { 0, 0 };
uint32_t tw = HAL_GetTick();
int connect_fired = 0;
/* 等 TCP 进 LISTEN（幽灵消退）或 CONNECT 中断补发 */
while ((uint32_t)(HAL_GetTick() - tw) < budget) {
uint16_t glob = ch395f_get_glob_int_status_all();
if ((glob & (1U << (sock + 4U))) != 0U) {
uint8_t si = ch395f_get_sock_int_status(sock);
if ((si & CH395F_SINT_STAT_CONNECT) != 0U) {
connect_fired = 1;
DBG_INFO("BENCH verify CONNECT during ghost-wait att%d t=%u",
att, (unsigned)HAL_GetTick());
break;
}
}
ch395f_get_socket_status(sock, st);
if (st[1] == 0x01U) {
break;
}
HAL_Delay(100);
}
DBG_INFO("BENCH verify att%d st=0x%02X/0x%02X cf=%d t=%u",
att, st[0], st[1], connect_fired, (unsigned)HAL_GetTick());
if (connect_fired) {
/* 幽灵期主机已连上：跳过 CONNECT 等待直接进流程 */
pre_connected = 1;
break;
}
if (st[1] == 0x01U) {
break;
}
/* 幽灵未消：close → 50ms → 重新 open+listen（mode3 只试一次） */
ch395f_close_socket(sock);
HAL_Delay(50);
ch395f_open_socket(sock);
ch395f_tcp_listen(sock);
for (int j = 0; j < 8; j++) {
(void)ch395f_get_sock_int_status((uint8_t)j);
}
(void)ch395f_get_glob_int_status_all();
}
}
/* 2. 等 CONNECT（10s；幽灵等待期已见 CONNECT 则跳过）
* v6 关键探针：等待期每 500ms 读芯片状态；若已 ESTABLISHED(0x04)
* 说明握手完成但 CONNECT 中断丢失 → 补做 accept（对账②模拟） */
int got = pre_connected;
uint32_t t0 = HAL_GetTick();
while (!got && (uint32_t)(HAL_GetTick() - t0) < 10000U) {
if (bench_wait_sock_int(sock, 100, &si)) {
if ((si & CH395F_SINT_STAT_CONNECT) != 0U) {
got = 1;
break;
}
DBG_INFO("BENCH unexpected int=0x%02X while wait", si);
}
if (v->verify == 4U) {
uint8_t st[2] = { 0, 0 };
ch395f_get_socket_status(sock, st);
if ((uint32_t)(HAL_GetTick() - t0) % 1000U < 110U) {
DBG_INFO("BENCH wait-state st=0x%02X/0x%02X t=%u",
st[0], st[1], (unsigned)HAL_GetTick());
}
if (st[1] == 0x04U) {
DBG_INFO("BENCH LOST-CONNECT caught: state ESTABLISHED, self-accept t=%u",
(unsigned)HAL_GetTick());
got = 1;
break;
}
}
}
if (!got) {
DBG_ERROR("BENCH no CONNECT within 10s (host not synced?)");
ch395f_close_socket(sock);
HAL_Delay(v->delay_ms);
return;
}
bench_log_state("post-accept", sock);
/* 对端信息 + RX 残渣检查（旧连接残留的直接证据） */
{
uint8_t rem[6] = { 0 };
ch395f_get_remot_ipp(sock, rem);
uint16_t rl = ch395f_get_recv_len(sock);
DBG_INFO("BENCH remote port=%u recv_len=%u",
(unsigned)(rem[4] | (rem[5] << 8)), (unsigned)rl);
if (rl > 0U) {
uint16_t n = (rl > 2048U) ? 2048U : rl;
ch395f_read_recv_buf(sock, s_rx_buf, n);
DBG_INFO("BENCH drained %u residue bytes", (unsigned)n);
}
}
/* 3. TX 探针（1KB 分块，Trap 20） */
if (v->tx_len > 0U) {
uint16_t sent = 0;
while (sent < v->tx_len) {
uint16_t chunk = (uint16_t)(v->tx_len - sent);
if (chunk > 1024U) {
chunk = 1024U;
}
ch395f_write_send_buf(sock, &s_tx_pat[sent], chunk);
sent += chunk;
/* 等 SENBUF_FREE（500ms） */
if (sent < v->tx_len) {
uint32_t tw = HAL_GetTick();
while ((uint32_t)(HAL_GetTick() - tw) < 500U) {
if (bench_wait_sock_int(sock, 50, &si)) {
if ((si & CH395F_SINT_STAT_SENBUF_FREE) != 0U) {
break;
}
}
}
}
}
DBG_INFO("BENCH tx %u written t=%u", (unsigned)v->tx_len, (unsigned)HAL_GetTick());
/* 连接存活观察窗：500ms 内每 50ms 记状态+中断（抓"秒杀"） */
for (int k = 0; k < 10; k++) {
uint16_t glob = ch395f_get_glob_int_status_all();
if ((glob & (1U << (sock + 4U))) != 0U) {
si = ch395f_get_sock_int_status(sock);
DBG_INFO("BENCH int during window=0x%02X t=%u", si, (unsigned)HAL_GetTick());
}
HAL_Delay(50);
bench_log_state("window", sock);
}
}
/* 4. 关闭次序 */
if (v->close_mode == 1U) {
/* 芯片先关 */
HAL_Delay(300);
ch395f_close_socket(sock);
DBG_INFO("BENCH chip closed first t=%u", (unsigned)HAL_GetTick());
} else {
/* 等主机关（DISCONNECT 事件，5s） */
uint32_t tw = HAL_GetTick();
int disc = 0;
while ((uint32_t)(HAL_GetTick() - tw) < 5000U) {
if (bench_wait_sock_int(sock, 100, &si)) {
if ((si & (CH395F_SINT_STAT_DISCONNECT | CH395F_SINT_STAT_SOCK_TIMEOUT)) != 0U) {
disc = 1;
break;
}
}
}
DBG_INFO("BENCH host-close seen=%d t=%u", disc, (unsigned)HAL_GetTick());
ch395f_close_socket(sock);
}
/* 5. 关闭后拆链观察：1s 内每 50ms 记状态 + 中断（Trap 14 滞后中断取证） */
for (int k = 0; k < 20; k++) {
uint16_t glob = ch395f_get_glob_int_status_all();
uint8_t late = 0;
if ((glob & (1U << (sock + 4U))) != 0U) {
late = ch395f_get_sock_int_status(sock);
}
if (late != 0U) {
DBG_INFO("BENCH late-int=0x%02X t=%u", late, (unsigned)HAL_GetTick());
}
if ((k % 4) == 0) {
bench_log_state("post-close", sock);
}
HAL_Delay(50);
}
/* 6. 受控延迟后进入下一轮 */
HAL_Delay(v->delay_ms);
}
void ch395f_reuse_bench(void) {
DBG_INFO("BENCH ===== N30 chip-level reuse bench START =====");
if (bench_chip_init() != 0) {
DBG_ERROR("BENCH init failed, giving up (normal boot continues)");
return;
}
DBG_INFO("BENCH chip ready, cycling %u variants forever", (unsigned)BENCH_N_VARS);
for (unsigned i = 0; i < 2048U; i++) {
s_tx_pat[i] = (uint8_t)(0xA5U + (i % 251U));
}
unsigned idx = 0;
for (;;) {
bench_round(idx);
idx = (idx + 1U) % (unsigned)BENCH_N_VARS;
}
}
#endif /* N30_CHIP_BENCH */
test/board/ch395f_reuse_bench.h
+13
View File
@@ -0,0 +1,13 @@
/*
* ch395f_reuse_bench.h - N-30 芯片级 Socket 复用时序台架（裸机实验，临时分支专用）
*/
#ifndef CH395F_REUSE_BENCH_H
#define CH395F_REUSE_BENCH_H
/* 实验总开关：1 = 内核前进入裸机台架（OS 永不启动，断电退出） */
#define N30_CHIP_BENCH 1
void ch395f_reuse_bench(void);
#endif /* CH395F_REUSE_BENCH_H */
test/host/ch395f_reuse_host.py
+92
View File
@@ -0,0 +1,92 @@
# N-30 芯片级复用时序台架：主机端（与 test/board/ch395f_reuse_bench.c 共用变体表）
# 用法: python ch395f_reuse_host.py [--host IP] [--cycles N]
# 纯 TCP，无 FTP。按 idx 轮转连接 5000+idx 端口，记录收发结果与时刻。
import argparse
import socket
import sys
import time
# {idx: (tx_len, close_mode)} 与固件表一致
VARS = {
0: (100, 0), # 0ms control
1: (100, 0), # 300ms control
2: (2000, 0), # 2KB control
3: (100, 0), # 0ms + ghost-wait fix
4: (100, 0), # 300ms + ghost-wait fix
5: (2000, 0), # 2KB + ghost-wait fix
}
def ts():
return time.strftime("%H:%M:%S") + ".%03d" % (int(time.time() * 1000) % 1000)
def run_round(host, idx, tx_len, close_mode):
port = 5000 + idx
# 等端口监听（芯片还没 open 时连接被拒，重试）
s = None
t0 = time.time()
while time.time() - t0 < 12.0:
try:
s = socket.create_connection((host, port), timeout=5)
break
except OSError:
time.sleep(0.2)
if s is None:
print("%s r%u CONNECT timeout" % (ts(), idx))
return False
ok = True
try:
s.settimeout(5)
got = 0
while got < tx_len:
chunk = s.recv(min(1024, tx_len - got))
if not chunk:
break
got += len(chunk)
note = ""
if got != tx_len:
note = " <<<< SWALLOWED (want %d)" % tx_len
ok = False
if close_mode == 1:
# 等芯片 FIN（mode1 芯片先关）
try:
fin = s.recv(1)
if fin:
note += " unexpected data after tx: %r" % fin
except socket.timeout:
note += " <<<< no FIN from chip (mode1)"
ok = False
print("%s r%u connected got=%d/%d%s" % (ts(), idx, got, tx_len, note))
except socket.timeout:
print("%s r%u recv timeout <<<< STALL" % (ts(), idx))
ok = False
except OSError as e:
print("%s r%u sock error %r" % (ts(), idx, e))
ok = False
finally:
s.close() # 主机关闭（mode0/2 主机先关）
return ok
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--host", default="192.168.1.100")
ap.add_argument("--cycles", type=int, default=3)
args = ap.parse_args()
fails = []
for c in range(args.cycles):
for idx in sorted(VARS):
tx_len, mode = VARS[idx]
print("%s === cycle%u r%u (tx=%d mode=%d) ===" % (ts(), c, idx, tx_len, mode))
if not run_round(args.host, idx, tx_len, mode):
fails.append((c, idx))
time.sleep(0.3)
print("RESULT: %d failures %s" % (len(fails), fails))
return 1 if fails else 0
if __name__ == "__main__":
sys.exit(main())
test/host/ftp_auth/ftp_auth_test.c
+203
View File
@@ -0,0 +1,203 @@
/*
* 模块名称：FTP 鉴权状态机（lftpd_auth）主机侧单元测试
* 模块功能：在 PC 上对 Drivers/BSP/NET/lftpd/lftpd_auth.c 做离线验证
* （用户名匹配 / 口令校验 / 失败计数 / 限时锁定 / tick 回绕）。
*
* 被测对象：真实源文件 lftpd_auth.c + 其依赖 sha256.c（均以 #include 原样
* 纳入，保证测的是生产代码而非副本；两模块零平台依赖，无需桩——
* tick 由参数注入正是本模块的纯函数设计意图）。
*
* 为什么要主机侧单测（而不是只用台架）：
* 锁定 60 s / 解锁 / 成功清零 / tick 32 位回绕是"防口令爆破"契约的核心，
* 板端每验一条要真等 60 s 且回绕要跑满 49.7 天；主机侧注入合成 tick
* 毫秒级穷举。用户名侧信道路径（错用户名也走哈希）同属纯逻辑。
*
* 覆盖点：
* TC-FA-001 user_match：相等 / 大小写不敏感 / 不等 / NULL
* TC-FA-002 正确用户名+正确口令 → OK，计数 0
* TC-FA-003 错口令 → FAIL，计数 1
* TC-FA-004 错用户名+对口令 → FAIL（哈希路径已走，时间拉平）
* TC-FA-005 连续 5 次失败 → 第 6 次（锁定期内）LOCKED，对口令也拒
* TC-FA-006 锁定期满（+60000 tick）→ 对口令 OK，计数清零
* TC-FA-007 成功清零计数：3 败 + 1 成 → 再 4 败不触发锁定（第 5 败才锁）
* TC-FA-008 tick 32 位回绕：锁定期内回绕点仍 LOCKED，期满回绕点放行
* TC-FA-009 配置 pwd_hash 非法 hex → 恒 FAIL（fail-closed）
* TC-FA-010 空口令 / NULL 口令 → FAIL；NULL creds/state → FAIL
*
* 通过：全部 TC PASS（main 返回 0）。
* 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
*
* 创建日期：2026-10-11
*/
#include <stdio.h>
#include <string.h>
/* 生产源文件原样纳入（顺序敏感：先 sha256 后 lftpd_auth） */
#include "sha256.c"
#include "lftpd_auth.c"
/* ===================== 断言框架 ===================== */
static int s_total;
static int s_passed;
static int s_failed;
#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)
/* 与 ftp_cfg.h FTP_CFG_DEF_HASH 同源钉值（SHA256("adminadmin")） */
#define DEF_HASH "d82494f05d6917ba02f7aaa29689ccb444bb73f20380876cb05d1f37537b7892"
static const ftp_auth_creds_t s_creds = { "admin", DEF_HASH, 1u };
/* ===================== TC-FA-001：user_match ===================== */
static void tc_user_match(void)
{
CHECK(ftp_auth_user_match("admin", "admin") == 1, "TC-FA-001a 相等匹配");
CHECK(ftp_auth_user_match("admin", "ADMIN") == 1, "TC-FA-001b 大小写不敏感");
CHECK(ftp_auth_user_match("admin", "root") == 0, "TC-FA-001c 不等拒绝");
CHECK(ftp_auth_user_match("admin", "admin2") == 0, "TC-FA-001d 前缀不算匹配");
CHECK(ftp_auth_user_match("admin", NULL) == 0, "TC-FA-001e NULL 拒绝");
}
/* ===================== TC-FA-002..004：基本判定 ===================== */
static void tc_basic(void)
{
ftp_auth_state_t st;
(void)memset(&st, 0, sizeof(st));
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st, 1000u) == FTP_AUTH_OK,
"TC-FA-002 对用户名+对口令 → OK");
CHECK(st.fail_count == 0u, "TC-FA-002b 成功后计数为 0");
(void)memset(&st, 0, sizeof(st));
CHECK(ftp_auth_check(&s_creds, 1u, "wrong", &st, 1000u) == FTP_AUTH_FAIL,
"TC-FA-003 错口令 → FAIL");
CHECK(st.fail_count == 1u, "TC-FA-003b 失败计数 1");
(void)memset(&st, 0, sizeof(st));
CHECK(ftp_auth_check(&s_creds, 0u, "admin", &st, 1000u) == FTP_AUTH_FAIL,
"TC-FA-004 错用户名+对口令 → FAIL（哈希路径已走）");
}
/* ===================== TC-FA-005..006：锁定与解锁 ===================== */
static void tc_lock(void)
{
ftp_auth_state_t st;
uint32_t t = 10000u;
(void)memset(&st, 0, sizeof(st));
for (int i = 0; i < 5; i++) {
CHECK(ftp_auth_check(&s_creds, 1u, "wrong", &st, t) == FTP_AUTH_FAIL,
"TC-FA-005 第 1..5 次失败 → FAIL");
}
CHECK(st.fail_count == 5u, "TC-FA-005b 计数到达 FAIL_MAX");
/* 锁定期内：对口令也 LOCKED，且不再计数 */
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st, t + 1u) == FTP_AUTH_LOCKED,
"TC-FA-005c 锁定期内对口令 → LOCKED");
CHECK(st.fail_count == 5u, "TC-FA-005d LOCKED 不改变计数");
/* 59999 tick：仍在窗内（差值 < 60000） */
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st,
st.lock_until_tick - 1u) == FTP_AUTH_LOCKED,
"TC-FA-005e 窗内最后 1 tick 仍 LOCKED");
/* 期满：恰好到达 lock_until → 放行 */
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st,
st.lock_until_tick) == FTP_AUTH_OK,
"TC-FA-006 期满对口令 → OK");
CHECK(st.fail_count == 0u, "TC-FA-006b 解锁成功后计数清零");
}
/* ===================== TC-FA-007：成功清零计数 ===================== */
static void tc_reset(void)
{
ftp_auth_state_t st;
uint32_t t = 5000u;
(void)memset(&st, 0, sizeof(st));
for (int i = 0; i < 3; i++) {
(void)ftp_auth_check(&s_creds, 1u, "wrong", &st, t);
}
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st, t) == FTP_AUTH_OK,
"TC-FA-007a 3 败后成功 → OK");
CHECK(st.fail_count == 0u, "TC-FA-007b 成功清零");
for (int i = 0; i < 4; i++) {
CHECK(ftp_auth_check(&s_creds, 1u, "wrong", &st, t) == FTP_AUTH_FAIL,
"TC-FA-007c 清零后再 4 败仍 FAIL（未锁）");
}
CHECK(ftp_auth_check(&s_creds, 1u, "wrong", &st, t) == FTP_AUTH_FAIL,
"TC-FA-007d 第 5 败 FAIL 并上锁");
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st, t + 1u) == FTP_AUTH_LOCKED,
"TC-FA-007e 连续 5 败后 LOCKED");
}
/* ===================== TC-FA-008：tick 32 位回绕 ===================== */
static void tc_wraparound(void)
{
ftp_auth_state_t st;
/* 手工构造：锁定截止在 0xFFFFFFF0（距 32 位翻转仅 16 tick） */
(void)memset(&st, 0, sizeof(st));
st.fail_count = 5u;
st.lock_until_tick = 0xFFFFFFF0u;
/* 回绕前 240 tick：仍在窗内 */
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st, 0xFFFFFF00u) == FTP_AUTH_LOCKED,
"TC-FA-008a 回绕前窗内 → LOCKED");
/* 回绕后 32 tick：now=0x10，(int32_t)(0x10-0xFFFFFFF0)=+32 → 期满 */
CHECK(ftp_auth_check(&s_creds, 1u, "admin", &st, 0x00000010u) == FTP_AUTH_OK,
"TC-FA-008b 回绕后期满 → OK（有符号差抗回绕）");
}
/* ===================== TC-FA-009..010：fail-closed 边界 ===================== */
static void tc_fail_closed(void)
{
ftp_auth_state_t st;
ftp_auth_creds_t bad_creds = { "admin", "zz2494f05d6917ba02f7aaa29689ccb444bb73f20380876cb05d1f37537b7892", 1u };
(void)memset(&st, 0, sizeof(st));
CHECK(ftp_auth_check(&bad_creds, 1u, "admin", &st, 1000u) == FTP_AUTH_FAIL,
"TC-FA-009 非法 hex 配置 → 恒 FAIL（无人能登录，fail-closed）");
(void)memset(&st, 0, sizeof(st));
CHECK(ftp_auth_check(&s_creds, 1u, "", &st, 1000u) == FTP_AUTH_FAIL,
"TC-FA-010a 空口令 → FAIL");
CHECK(ftp_auth_check(&s_creds, 1u, NULL, &st, 1000u) == FTP_AUTH_FAIL,
"TC-FA-010b NULL 口令 → FAIL");
CHECK(ftp_auth_check(NULL, 1u, "admin", &st, 1000u) == FTP_AUTH_FAIL,
"TC-FA-010c NULL creds → FAIL");
CHECK(ftp_auth_check(&s_creds, 1u, "admin", NULL, 1000u) == FTP_AUTH_FAIL,
"TC-FA-010d NULL state → FAIL");
}
/* ===================== main ===================== */
int main(void)
{
printf("=== FTP Auth Tests ===\n");
printf("-- user match --\n");
tc_user_match();
printf("-- basic check --\n");
tc_basic();
printf("-- lock / unlock --\n");
tc_lock();
printf("-- success reset --\n");
tc_reset();
printf("-- tick wraparound --\n");
tc_wraparound();
printf("-- fail-closed --\n");
tc_fail_closed();
printf("\n=== FTP Auth Tests: %d/%d PASSED (failed=%d) ===\n",
s_passed, s_total, s_failed);
return (s_failed == 0) ? 0 : 1;
}
test/host/ftp_auth/run_unit_test.py
+50
View File
@@ -0,0 +1,50 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""FTP 鉴权状态机（lftpd_auth）的主机侧单元测试运行器（L0.5，纯标准库）。
做什么：
用本机 MSVC 编译 test/host/ftp_auth/ftp_auth_test.c（它以 #include 纳入
**生产源文件** Drivers/BSP/NET/lftpd/lftpd_auth.c 与 App/util/sha256.c），
在 PC 上离线跑口令校验/失败计数/限时锁定/tick 回绕，失败即非 0 退出。
零硬件、零烧录、毫秒级。
工具链探测 / INCLUDE-LIB 拼接 / 编译运行 / 退出码判定全部委托给通用 harness
`test/host/common/unit_test_harness.py`（本文件只做声明）。
为什么要主机侧单测（而不是只用台架）：
锁定 60s / 解锁 / 成功清零 / tick 32 位回绕是"防口令爆破"契约核心，
板端每验一条要真等 60s、回绕要跑满 49.7 天；lftpd_auth 的纯函数设计
（tick 参数注入）正是为了让这些分支在主机侧毫秒级穷举。
两被测模块零平台依赖，无需任何桩。
用法（仓库根目录）：
python test/host/ftp_auth/run_unit_test.py
或统一用 .venv： & '.venv\\Scripts\\python.exe' test/host/ftp_auth/run_unit_test.py
退出码：0=PASS / 1=测试失败 / 2=环境错误（找不到编译器 / 编译失败 / 无汇总行）。
设计依据：Drivers/BSP/NET/lftpd/lftpd_auth.h；创建日期：2026-10-11
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
# harness 位于 test/host/common/
sys.path.insert(0, os.path.join(ROOT, "test", "host", "common"))
from unit_test_harness import TestBuild, run_host_unit_test # noqa: E402
BUILD = TestBuild(
name="FTP Auth Tests",
src=os.path.join(HERE, "ftp_auth_test.c"),
include_dirs=[
os.path.join(ROOT, "Drivers", "BSP", "NET", "lftpd"),
os.path.join(ROOT, "App", "util"),
HERE,
],
summary_marker="=== FTP Auth Tests:",
)
if __name__ == "__main__":
sys.exit(run_host_unit_test(BUILD))
test/host/ftp_auth_bench.py
+173
View File
@@ -0,0 +1,173 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""FTP 鉴权台架回归（N-19，需真机在线）
验证固件侧 lftpd 鉴权集成的完整行为矩阵（主机单测 test/host/ftp_auth 覆盖
不到的"协议接线"部分：命令门、530/331/230/550 响应码、跨会话锁定）：
T1 匿名登录（anonymous） → 期望 530 拒
T2 未登录直接 NLST → 期望 530（命令门）
T3 对用户名 + 错口令 ×5 → 期望 530 ×5（并触发锁定）
T4 锁定窗内正确口令 → 期望 530（LOCKED，不算哈希）
T5 等待锁定期满后正确口令 → 期望 230（60s + 余量）
T6 登录后 NLST / STOR / RETR / DELE → 期望全通（出厂 write=1）
T7 会话结束重连、错口令一次 → 期望 530 且计数已清零（T5 成功清零）
注意：CH395F 单连接——每步用完必须 quit() 释放 socket，否则下一步连不上；
跑之前确保 UI 远程显示(7003)/对时(8888)客户端未占用 socket。
用法（设备默认 192.168.1.100，出厂口令 admin/admin）：
& '.venv\\Scripts\\python.exe' test/host/ftp_auth_bench.py
改过口令： ... --pwd <新口令>
跳过 60s 锁定等待（只验锁定触发不验解锁）： ... --skip-unlock
退出码：0=全部通过 / 1=任一失败 / 2=环境错误（连不上设备）
创建日期：2026-10-11
"""
import argparse
import io
import socket
import sys
import time
from ftplib import FTP, error_perm
LOCK_WAIT_S = 62 # 固件锁定 60 s + 余量
def _try_login(host, port, timeout, user, pwd):
"""尝试一次登录；返回 (ok, code_or_exc)。失败不断言连接状态。
单连接 socket：上一次会话结束后 net 层 auto_relisten ~50 ms，但 accept
失败会走"毁监听→重建"路径（3 s 重试窗）→ connect 被拒时重试 3 次。
"""
f = FTP()
last_err = None
for attempt in range(3):
try:
time.sleep(0.5)
f.connect(host, port, timeout=timeout)
break
except (ConnectionRefusedError, socket.timeout, OSError) as e:
last_err = e
f = FTP()
else:
return None, repr(last_err), None
try:
try:
f.login(user, pwd)
return True, "230", f
except error_perm as e:
f.close()
return False, str(e), None
except (socket.timeout, OSError) as e:
return None, repr(e), None
def main(argv=None):
ap = argparse.ArgumentParser(description="FTP auth bench matrix (N-19)")
ap.add_argument("--host", default="192.168.1.100")
ap.add_argument("--port", type=int, default=21)
ap.add_argument("--timeout", type=int, default=15)
ap.add_argument("--user", default="admin")
ap.add_argument("--pwd", default="admin")
ap.add_argument("--skip-unlock", action="store_true",
help="不验 60s 解锁（省 1 分钟；锁定触发仍验）")
args = ap.parse_args(argv)
fails = []
def expect(name, cond, detail=""):
tag = "PASS" if cond else "FAIL"
print(" [%s] %s %s" % (tag, name, detail))
if not cond:
fails.append(name)
# ---- T1 匿名登录被拒 ----
ok, code, conn = _try_login(args.host, args.port, args.timeout, "anonymous", "x@x")
if ok is None:
print("[env] 连不上 %s:%d → %s" % (args.host, args.port, code))
return 2
expect("T1 匿名登录 → 530", (ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
# ---- T2 未登录直接 NLST → 530（命令门）----
time.sleep(0.5) # 单连接 socket：等 auto_relisten 沉降（~50 ms + 余量）
f = FTP()
f.connect(args.host, args.port, timeout=args.timeout)
try:
f.sendcmd("NLST")
expect("T2 未登录 NLST → 530", False, "居然放行")
except error_perm as e:
expect("T2 未登录 NLST → 530", str(e).startswith("530"), str(e))
except Exception as e: # noqa: BLE001
expect("T2 未登录 NLST → 530", False, repr(e))
# ⚠ 必须 close：单连接模型下不关 = 占住 socket，后续步骤全被拒
# （2026-10-11 台架实测：QUIT 后不 close → 芯片视角旧连接仍 ESTABLISHED）
try:
f.quit()
except Exception: # noqa: BLE001
try:
f.close()
except Exception: # noqa: BLE001
pass
time.sleep(0.5)
# ---- T3 错口令 ×5 → 530 ×5 ----
for i in range(1, 6):
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, "wrong-pass-%d" % i)
expect("T3.%d 错口令 → 530" % i, (ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
# ---- T4 锁定窗内正确口令 → 530 ----
ok, code, conn = _try_login(args.host, args.port, args.timeout, args.user, args.pwd)
expect("T4 锁定窗内对口令 → 530", (ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
if args.skip_unlock:
print("[skip] 未验 60s 解锁（--skip-unlock）")
else:
# ---- T5 期满正确口令 → 230 ----
print(" [wait] 等锁定期满 %d s ..." % LOCK_WAIT_S)
time.sleep(LOCK_WAIT_S)
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, args.pwd)
expect("T5 期满对口令 → 230", ok is True, code)
if conn:
# ---- T6 登录后读写全通（出厂 write=1）----
try:
names = conn.nlst()
expect("T6a NLST", len(names) >= 0, "%d 项" % len(names))
payload = b"N19-auth-bench-" + b"X" * 500
conn.storbinary("STOR n19t.tmp", io.BytesIO(payload))
got = io.BytesIO()
conn.retrbinary("RETR n19t.tmp", got.write)
expect("T6b STOR/RETR 往返一致", got.getvalue() == payload)
conn.delete("n19t.tmp")
expect("T6c DELE", True)
except Exception as e: # noqa: BLE001
expect("T6 登录后读写", False, repr(e))
# ---- T7 成功已清零计数：本会话退出后错一次只算 1（不锁）----
conn.quit()
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, "one-wrong")
expect("T7 成功后错 1 次 → 530 且未锁（下次对口令可登）",
(ok is False) and code.startswith("530"), code)
if conn:
conn.quit()
ok, code, conn = _try_login(args.host, args.port, args.timeout,
args.user, args.pwd)
expect("T7b 紧接对口令 → 230", ok is True, code)
if conn:
conn.quit()
print("\nVERDICT: %s (%d fail)" % ("PASS" if not fails else "FAIL", len(fails)))
return 0 if not fails else 1
if __name__ == "__main__":
sys.exit(main())
test/host/ftp_regression.py
+5 -1
View File
@@ -30,6 +30,10 @@ def main(argv=None):
ap.add_argument("--host", default="192.168.1.100", help="device IP")
ap.add_argument("--port", type=int, default=21, help="FTP control port")
ap.add_argument("--timeout", type=int, default=20, help="socket timeout (s)")
# N-19（2026-10-11）：FTP 已强制鉴权，匿名登录被 530 拒；默认口令 admin/admin
# （出厂值，见 ftp_cfg.h），改过 [ftp] pwd_hash 后用这两个参数覆盖
ap.add_argument("--user", default="admin", help="FTP user ([ftp] user)")
ap.add_argument("--pwd", default="admin", help="FTP password")
args = ap.parse_args(argv)
results = []
@@ -52,7 +56,7 @@ def main(argv=None):
f = FTP()
print("[ftp] connecting %s:%d ..." % (args.host, args.port))
f.connect(args.host, args.port, timeout=args.timeout)
f.login("anonymous", "x@x")
f.login(args.user, args.pwd)
print("[ftp] login ok: %s" % f.getwelcome())
# 同一会话内连续 8 次数据连接（含两次大文件）—— D20 的失败点是第 2 次
test/host/n30_repro.py
+74
View File
@@ -0,0 +1,74 @@
# N-30 确定性复现：连续快速 STOR（无间隔），统计 425/超时失败次数
# 用法: python n30_repro.py [--host IP] [--user U --pwd P] [--n 10] [--size 1024]
# 退出码: 0=全部成功 / 1=有失败 / 2=连接错误
import argparse
import io
import sys
from ftplib import FTP, error_temp, error_perm
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--host", default="192.168.1.100")
ap.add_argument("--port", type=int, default=21)
ap.add_argument("--user", default=None, help="None=anonymous")
ap.add_argument("--pwd", default=None)
ap.add_argument("--n", type=int, default=10)
ap.add_argument("--size", type=int, default=1024)
args = ap.parse_args()
data = b"X" * args.size
fails = []
try:
f = FTP()
f.connect(args.host, args.port, timeout=15)
if args.user is None:
f.login("anonymous", "x@x")
else:
f.login(args.user, args.pwd)
f.voidcmd("TYPE I")
for i in range(args.n):
name = "n30_%02d.tmp" % i
try:
with io.BytesIO(data) as b:
f.storbinary("STOR " + name, b)
print("STOR #%02d OK" % (i + 1))
except (error_temp, error_perm, OSError, EOFError) as e:
print("STOR #%02d FAIL %r" % (i + 1, e))
fails.append(i + 1)
# 会话可能已重启：尝试重登继续计数
try:
f.quit()
except Exception:
pass
try:
f = FTP()
f.connect(args.host, args.port, timeout=15)
if args.user is None:
f.login("anonymous", "x@x")
else:
f.login(args.user, args.pwd)
f.voidcmd("TYPE I")
except Exception as e2:
print("re-login failed: %r" % e2)
break
# 清理
try:
for i in range(args.n):
try:
f.delete("n30_%02d.tmp" % i)
except Exception:
pass
f.quit()
except Exception:
pass
except Exception as e:
print("connect error: %r" % e)
return 2
print("RESULT: %d/%d failed %s" % (len(fails), args.n, fails))
return 1 if fails else 0
if __name__ == "__main__":
sys.exit(main())
test/host/sha256/run_unit_test.py
+48
View File
@@ -0,0 +1,48 @@
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""SHA-256（sha256）的主机侧单元测试运行器（L0.5，纯标准库）。
做什么：
用本机 MSVC 编译 test/host/sha256/sha256_test.c（它以 #include 纳入
**生产源文件** App/util/sha256.c），在 PC 上离线跑 FIPS 180-4 标准向量、
流式等价、hex_eq 边界，失败即非 0 退出。零硬件、零烧录、毫秒级。
工具链探测 / INCLUDE-LIB 拼接 / 编译运行 / 退出码判定全部委托给通用 harness
`test/host/common/unit_test_harness.py`（本文件只做声明）。
为什么要主机侧单测（而不是只用板端）：
sha256 是 FTP pwd_hash 校验（N-19）的地基——哈希算错是"正确口令被拒 /
错误口令放行"的静默语义错误，板端只见 530/230 看不出根因；标准向量
（空串/abc/56B 补位跨界/1MB 长度进第二分组）主机侧一次钉死。
本模块零平台依赖，无需任何桩。
用法（仓库根目录）：
python test/host/sha256/run_unit_test.py
或统一用 .venv： & '.venv\\Scripts\\python.exe' test/host/sha256/run_unit_test.py
退出码：0=PASS / 1=测试失败 / 2=环境错误（找不到编译器 / 编译失败 / 无汇总行）。
设计依据：App/util/sha256.h；创建日期：2026-10-11
"""
import os
import sys
HERE = os.path.dirname(os.path.abspath(__file__))
ROOT = os.path.dirname(os.path.dirname(os.path.dirname(HERE)))
# harness 位于 test/host/common/
sys.path.insert(0, os.path.join(ROOT, "test", "host", "common"))
from unit_test_harness import TestBuild, run_host_unit_test # noqa: E402
BUILD = TestBuild(
name="SHA-256 Tests",
src=os.path.join(HERE, "sha256_test.c"),
include_dirs=[
os.path.join(ROOT, "App", "util"),
HERE,
],
summary_marker="=== SHA-256 Tests:",
)
if __name__ == "__main__":
sys.exit(run_host_unit_test(BUILD))
test/host/sha256/sha256_test.c
+192
View File
@@ -0,0 +1,192 @@
/*
* 模块名称：SHA-256 主机侧单元测试
* 模块功能：在 PC 上对 App/util/sha256.c 做离线验证（FIPS 180-4 标准向量 +
* 流式等价 + sha256_hex_eq 边界）。
*
* 被测对象：真实源文件 ../../../App/util/sha256.c（以 #include 原样纳入，
* 保证测的是生产代码而非副本；本模块零平台依赖，无需任何桩）。
*
* 为什么要主机侧单测（而不是只靠台架）：
* sha256 是 FTP pwd_hash 校验（N-19）的地基——哈希算错的后果是
* "正确口令被拒 / 错误口令放行"这类静默语义错误，板端只看到 530/230，
* 看不出哪一步坏；标准向量在主机侧毫秒级钉死。
*
* 覆盖点：
* TC-SH-001 FIPS 180-4 向量：空串
* TC-SH-002 FIPS 180-4 向量："abc"
* TC-SH-003 FIPS 180-4 向量：56 字节（补位跨分组边界）
* TC-SH-004 FIPS 180-4 向量：1,000,000 × 'a'（流式，长度字段进第二分组）
* TC-SH-005 流式任意切分与一次性计算等价（逐字节喂入）
* TC-SH-006 hex_eq：小写匹配 / 大写匹配
* TC-SH-007 hex_eq：内容不等 / 非法字符 / 长度 63/65 / NULL → 全 0
* TC-SH-008 默认口令哈希钉值：SHA256("adminadmin") = FTP_CFG_DEF_HASH 同源值
*
* 通过：全部 TC PASS（main 返回 0）。
* 入口：int main(void)，返回 0=PASS / 1=FAIL（由 run 脚本判读）。
*
* 创建日期：2026-10-11
*/
#include <stdio.h>
#include <string.h>
/* 生产源文件原样纳入（零平台依赖，直接编） */
#include "sha256.c"
/* ===================== 断言框架 ===================== */
static int s_total;
static int s_passed;
static int s_failed;
#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)
/* 摘要 → hex 小写串（仅测试用，允许栈上 sprintf） */
static void digest_to_hex(const uint8_t d[SHA256_DIGEST_SIZE], char out[65])
{
static const char hexd[] = "0123456789abcdef";
for (int i = 0; i < 32; i++) {
out[2 * i] = hexd[(d[i] >> 4) & 0xF];
out[2 * i + 1] = hexd[d[i] & 0xF];
}
out[64] = '\0';
}
static int hex_eq_vector(const uint8_t d[SHA256_DIGEST_SIZE], const char *want)
{
char got[65];
digest_to_hex(d, got);
return strcmp(got, want) == 0;
}
/* ===================== TC-SH-001..004：标准向量 ===================== */
static void tc_vectors(void)
{
uint8_t d[SHA256_DIGEST_SIZE];
sha256_calc("", 0u, d);
CHECK(hex_eq_vector(d, "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"),
"TC-SH-001 空串向量");
sha256_calc("abc", 3u, d);
CHECK(hex_eq_vector(d, "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"),
"TC-SH-002 \"abc\" 向量");
sha256_calc("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56u, d);
CHECK(hex_eq_vector(d, "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"),
"TC-SH-003 56 字节向量（补位跨分组）");
{
sha256_ctx_t ctx;
sha256_init(&ctx);
for (int i = 0; i < 1000000; i++) {
sha256_update(&ctx, "a", 1u);
}
sha256_final(&ctx, d);
}
CHECK(hex_eq_vector(d, "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"),
"TC-SH-004 1e6 × 'a' 向量（流式）");
}
/* ===================== TC-SH-005：流式等价 ===================== */
static void tc_stream_equiv(void)
{
static const char msg[] = "the quick brown fox jumps over the lazy dog";
uint8_t d1[SHA256_DIGEST_SIZE];
uint8_t d2[SHA256_DIGEST_SIZE];
sha256_ctx_t ctx;
sha256_calc(msg, strlen(msg), d1);
sha256_init(&ctx);
for (size_t i = 0; i < strlen(msg); i++) {
sha256_update(&ctx, &msg[i], 1u);
}
sha256_final(&ctx, d2);
CHECK(memcmp(d1, d2, sizeof(d1)) == 0, "TC-SH-005 逐字节喂入与一次性等价");
}
/* ===================== TC-SH-006..007：hex_eq ===================== */
static void tc_hex_eq(void)
{
uint8_t d[SHA256_DIGEST_SIZE];
char lower[65];
char upper[65];
char shortv[65];
char longv[66];
sha256_calc("adminadmin", 10u, d);
digest_to_hex(d, lower);
for (int i = 0; i < 64; i++) {
upper[i] = (char)((lower[i] >= 'a') ? (lower[i] - 32) : lower[i]);
}
upper[64] = '\0';
CHECK(sha256_hex_eq(d, lower) == 1, "TC-SH-006a 小写 hex 匹配");
CHECK(sha256_hex_eq(d, upper) == 1, "TC-SH-006b 大写 hex 匹配（大小写不敏感）");
lower[63] = (char)((lower[63] == '0') ? '1' : '0');
CHECK(sha256_hex_eq(d, lower) == 0, "TC-SH-007a 内容不等 → 0");
lower[63] = (char)((lower[63] == '0') ? '1' : '0'); /* 还原 */
{
char bad[65];
memcpy(bad, lower, 64);
bad[64] = '\0';
bad[10] = 'g';
CHECK(sha256_hex_eq(d, bad) == 0, "TC-SH-007b 非法 hex 字符 → 0");
}
memcpy(shortv, lower, 63);
shortv[63] = '\0';
CHECK(sha256_hex_eq(d, shortv) == 0, "TC-SH-007c 长度 63 → 0");
memcpy(longv, lower, 64);
longv[64] = 'a';
longv[65] = '\0';
CHECK(sha256_hex_eq(d, longv) == 0, "TC-SH-007d 长度 65 → 0");
CHECK(sha256_hex_eq(d, NULL) == 0, "TC-SH-007e NULL → 0");
}
/* ===================== TC-SH-008：默认口令哈希钉值 ===================== */
static void tc_default_hash(void)
{
uint8_t d[SHA256_DIGEST_SIZE];
/* 与 ftp_cfg.h FTP_CFG_DEF_HASH 同源钉值（两处若漂移本测试立刻红） */
sha256_calc("adminadmin", 10u, d);
CHECK(sha256_hex_eq(d, "d82494f05d6917ba02f7aaa29689ccb444bb73f20380876cb05d1f37537b7892") == 1,
"TC-SH-008 SHA256(\"adminadmin\") = 出厂默认 pwd_hash");
}
/* ===================== main ===================== */
int main(void)
{
printf("=== SHA-256 Tests ===\n");
printf("-- FIPS 180-4 vectors --\n");
tc_vectors();
printf("-- streaming equivalence --\n");
tc_stream_equiv();
printf("-- hex_eq --\n");
tc_hex_eq();
printf("-- default password hash --\n");
tc_default_hash();
printf("\n=== SHA-256 Tests: %d/%d PASSED (failed=%d) ===\n",
s_passed, s_total, s_failed);
return (s_failed == 0) ? 0 : 1;
}