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

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 已销项。

test/host/ch395f_reuse_host.py

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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

@@ -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;
+}