Compare commits

...

2 Commits

Author SHA1 Message Date
2ac056edde 补充后端基础模块审查检查点
Some checks are pending
Security Checks / security (push) Waiting to run
2026-09-06 04:41:05 +08:00
9849f8f11c 补充插件通信审查证据与覆盖记录 2026-09-06 04:33:34 +08:00
30 changed files with 3899 additions and 0 deletions

View File

@ -0,0 +1,634 @@
# Smail 代码逐行审查阶段报告
## 审查范围与状态
- 请求:对全部代码逐行审查,不能用搜索命中、编译成功或测试通过代替逐行检查。
- 开始时间:2026-09-06 01:46:05,时区 Asia/Shanghai。
- 基线:`9849f8f11c9f49efd1bc877d7fedd8da265e32df`,分支 `main`。
- 审查前已建立中文提交检查点,远端 `smail/main` 已核验一致。
- 当前结论:**审查进行中,尚未完成全仓逐行覆盖;发现的问题尚未修复。**
- 本轮只新增隔离审查测试、覆盖工具和报告,未修改业务源码,未清空真实数据库,未停止开发服务。
## 需求确认与任务清单
按用户明确要求,审查范围包括业务源码、测试、构建部署脚本、配置模板及前端页面。锁文件、第三方资源、二进制资源单独分类,不伪装成已逐行审查的业务代码。
- [✓] 核验工作区及审查前 Git 检查点。
- [x] 运行原有前后端测试基线,结果通过,等待结合新增场景复审。
- [~] 建立逐文件、行范围和哈希覆盖账本。
- [~] 检查认证恢复、迁移、邮件列表、IMAP、配置与前端交互。
- [~] 用隔离 SQLite、真实本地协议和真实前端函数验证问题。
- [ ] 补齐全仓其余文件的逐行审查。
- [ ] 浏览器 MCP 验收完整业务流程。
- [ ] MySQL、PostgreSQL 实库及 Linux/Windows 部署验收。
- [ ] 全部发现项修复后的独立复审;本轮未执行修复。
## 已确认问题
优先级:P1 为安全授权、数据完整性或核心功能问题;P2 为特定场景故障及一致性问题。编号固定,便于后续复现和修复。
### R01 / P1:迁移成功切库,但自定义唯一索引静默丢失
- 位置:`backend/services/dbmigration/portable_schema.go:9-28`;`portable_executor.go:177-223`;`portable_data.go:72-95,111-117`。
- 前提:源库包含版本化表之外的自定义唯一索引。
- 原因:源对象校验未识别这些索引,目标库按内置结构重建,之后只验证数据,不验证自定义约束等价性。
- 实测:完整版本化 SQLite 源库增加唯一索引后执行迁移,结果为 `switched=true custom_index_count=0 duplicate_insert_error=<nil>`。
- 影响:迁移被报告成功,但源库禁止的重复值可以写入目标库。
- 建议:无法忠实迁移的结构在预览和执行时明确拒绝,或完整迁移并比较索引、约束。
- 边界:只实测 SQLite,不将结果泛化为三种数据库实库均已验证。
- 复现:`TestAuditCustomUniqueIndexMustNotDisappear`。
### R02 / P1:登录二次验证重发接口错误要求先登录
- 位置:`backend/listen/http_server/https_server.go:168-170,194-200`;`api_v1_compat.go:19`;`http_server.go:52`;`frontend/src/views/LoginVerification/LoginVerification.js:93-103`。
- 前提:密码已验证,但尚未完成登录二次验证,用户需要重发验证码。
- 原因:登录前安全接口白名单遗漏 `/api/v1/security/login/resend`,请求未到验证码控制器就被登录拦截。
- 实测:真实路由、内存会话返回 HTTP 200,响应体业务码 403:`Login has expired.`。
- 影响:未登录用户无法在二次验证页重发验证码。
- 建议:将该接口归入登录前安全路由,保留挑战票据、限频及 CSRF 等校验。
- 边界:未发送真实验证码;不能据此断言前端必然跳回登录页。
- 复现:`TestAuditAnonymousLoginResendMustReachController`。
### R03 / P2:迁移排空请求不响应取消
- 位置:`backend/services/dbmigration/maintenance.go:62-70`;`service.go:224-232`。
- 原因:持有或升级请求租约时使用不可取消的 `RWMutex.Lock()`,传入的上下文未参与等待。
- 实测:30ms 上下文超时,200ms 后仍未退出,必须释放在途读锁才恢复。
- 影响:在途请求长期不结束时,迁移取消/超时不能及时结束排空,还可能让新 HTTP 请求排队等待。
- 建议:采用可取消的排空协调方式,确保请求租约、迁移状态和错误路径一致释放。
- 边界:证明的是超时不生效,不是已经复现永久死锁。
- 复现:`TestAuditRequestDrainMustRespectCancellation`。
### R04 / P2:邮件列表第二页起返回总数 0
- 位置:`backend/services/list/list.go:28-30,98-107`;`backend/controllers/email/list.go:120-129`。
- 原因:聚合计数查询错误附带分页偏移和排序。
- 实测:31 封邮件,每页 15 封;偏移 0/15/30 分别返回行数 15/15/1,总数却为 31/0/0。
- 影响:接口分页元数据错误,依赖每次响应总数的调用方会出现错误页数。
- 建议:计数与列表查询分离,仅共享筛选条件。
- 边界:当前网页翻页函数未逐次刷新总页数,不能声称网页翻页后分页控件必然消失。
- 复现:`TestAuditPaginationMustPreserveTotal`。
### R05 / P1:撤销安全密钥后,旧恢复票据仍允许改密
- 位置:`backend/services/recovery/service.go:315-328,390-417`;`backend/services/webauthn/service.go:323-333`。
- 前提:安全密钥验证后已签发恢复票据,随后该凭据被撤销,票据仍未过期。
- 原因:恢复完成阶段只对邮箱来源重新检查凭据;WebAuthn 来源没有同等撤销检查。
- 实测:真实撤销凭据后,旧票据完成改密返回成功,并用密码校验函数确认新密码生效。
- 影响:用户撤销凭据后,先前依赖该凭据产生的改密授权仍有效到票据过期。
- 建议:完成改密时重新校验票据所绑定的凭据归属、撤销状态及版本,或撤销时使关联票据失效。
- 边界:隔离测试从签发恢复票据阶段开始,不验证真实设备的 WebAuthn 签名链;不是未认证直接获取票据的证明。
- 复现:`TestAuditRevokedWebAuthnMustInvalidateRecoveryTicket`。
### R06 / P2:配置审计导出下载内容为 undefined
- 位置:`frontend/src/utils/axios.js:71-78`;`frontend/src/views/components/ConfigSettings/ConfigSettings.js:549-561`。
- 原因:公共响应拦截器已返回 `response.data`,导出函数却再次读取结果的 `.data`。
- 实测:执行真实响应拦截器和真实导出函数,CSV、JSON 两种格式下载内容均为字符串 `undefined`。
- 影响:导出请求可成功,但生成的文件没有审计记录。
- 建议:统一请求工具的返回类型,直接使用返回的 Blob,并覆盖两种导出格式。
- 边界:网络和下载 DOM 被隔离,未做真实浏览器文件下载验收。
- 复现:`frontend-findings.test.mjs` 中的审计导出测试。
### R07 / P2:写信页附件按钮未绑定文件输入框
- 位置:`frontend/src/views/Editer/Editer.vue:12,116-134`;`Editer.js:197-199`。
- 原因:`usePage()` 已返回 `fileRef`,但 Vue 文件的解构遗漏该变量,模板引用没有连接到组合函数的引用。
- 实测:编译真实 SFC、挂载真实组合函数后,`template_file_ref_connected=false`,调用附件按钮方法触发 `dispatchEvent` 空引用错误。
- 影响:通过附件按钮选择文件失败。
- 建议:在页面脚本中正确接收并绑定 `fileRef`,增加挂载后点击测试。
- 边界:使用 Vue 自定义渲染器,不是操作系统文件选择框的浏览器验收。
- 复现:`frontend-findings.test.mjs` 中的附件按钮测试。
### R08 / P2:IMAP COPY 后,网页移动误判邮件不属于当前用户
- 位置:`backend/services/group/group.go:393-403,741-751`;`backend/controllers/email/move.go`。
- 前提:IMAP COPY 为同一封邮件建立多个当前用户的文件夹关系。
- 原因:移动服务将关系行数和唯一邮件 ID 数量直接比较,没有正确处理合法副本。
- 实测:真实本地 TLS IMAP COPY 后,关系行数为 2;网页调用的服务返回 `one or more messages are not owned by the user`。
- 影响:用户自己的邮件因存在 IMAP 副本而不能通过网页正常移动。
- 建议:定义清晰的邮箱关系身份,区分邮件内容 ID 与文件夹中的关系 ID,所有权校验按实际目标关系执行。
- 边界:当前服务器没有声明 MOVE 扩展,客户端 `Move()` 回退 COPY/STORE/EXPUNGE 且成功;不能报告成 IMAP 客户端 MOVE 必然失败。
- 复现:`TestAuditCopyThenMoveMustKeepMailboxIdentity`。
### R09 / P2:安全运行时发布和读取存在数据竞争
- 位置:`backend/controllers/security.go:89`;`backend/controllers/webauthn.go:63`;`backend/res_init/init.go:252-259,394-402`。
- 原因:全局 WebAuthn 服务指针无同步读写,关闭流程在 HTTP 停止前清空服务,可能与在途控制器读取并发。
- 实测:`-race` 报告 `ConfigureWebAuthnRuntime` 与 `webAuthnRuntime` 的数据竞争。
- 影响:生命周期切换期间并发访问不安全,运行时可见性无保证。
- 建议:用互斥锁或原子发布一致的安全运行时快照,调整停止顺序并补并发生命周期测试。
- 边界:尚未复现真实重启崩溃;普通测试模式显示通过不能消除 race 证据。
- 复现:`TestAuditWebAuthnRuntimePublication`,必须使用 `-race`。
### R10 / P2:IMAP EXAMINE 只读选择仍持久化修改邮件标记
- 位置:`backend/listen/imap_server/session_select.go:10-44`;`session_store.go:18-20,81-91`;`server.go:50-58`。
- 原因:会话未保存 `SelectOptions.ReadOnly`,STORE 没有只读状态检查。
- 实测:真实 TLS IMAP 使用 EXAMINE 打开 INBOX 后执行 STORE,返回成功,临时数据库的 `is_read` 从 0 变为 1。
- 影响:客户端要求的只读邮箱状态没有生效。
- 建议:保存只读选中状态,对 STORE、EXPUNGE 及非 PEEK FETCH 等写入路径统一检查。
- 复现:`TestAuditExamineMustNotPersistStore`。
### R11 / P1:IMAP 同文件夹副本复用可变对象,覆盖 UID 并遗漏 FETCH 响应
- 位置:`backend/services/list/list.go:307-322`;`backend/listen/imap_server/session_fetch.go:147-157,253-300`。
- 前提:同一邮件经 IMAP COPY 在同一文件夹生成两个不同 UID 的关系,并在一次范围查询中读取。
- 原因:内容缓存按 `email_id` 保存同一个响应指针,在遍历关系时直接覆盖该指针的 UID、序号和标记;两个结果最终指向同一对象。
- 实测:数据库为 UID 17、18,均在 INBOX;真实列表函数返回 `hydrated_uids=18,18 same_pointer=true`;TLS IMAP FETCH 两个 UID 只收集到 1 封响应且没有错误。
- 影响:邮箱副本身份和状态被混淆,客户端同步可能漏信;使用相同构造函数的批量操作也需逐项复查。
- 建议:为每个邮箱关系构造独立响应对象,允许共享不可变内容但不能共享 UID、序号和状态;增加 COPY 后范围 FETCH/STORE 的回归测试。
- 边界:协议层实测为漏响应,不将其表述成客户端已收到两条重复 UID 响应。
- 复现:`TestAuditCopiedMessagesMustKeepDistinctUIDs`。
### R12 / P2:IMAP 顶层文件夹枚举遗漏默认文件夹
- 位置:`backend/listen/imap_server/session_list.go:14-16,62-66`。
- 原因:仅 `LIST "" "*"` 分支生成默认文件夹;标准顶层通配符 `%` 分支只查询自定义文件夹表,且通配规则直接复用 SQL LIKE。
- 实测:真实协议 `LIST "" "%"` 返回空列表,尽管同一账户有 INBOX 和真实邮件。
- 影响:按层级枚举邮箱的客户端无法发现默认收件箱等文件夹。
- 建议:先组合默认和自定义文件夹,再统一按 IMAP 的 reference、`%` 和 `*` 规则匹配,不能直接等同 SQL 通配符。
- 复现:`TestAuditListPercentMustIncludeInbox`。
### R13 / P2:移走最大 UID 邮件后,UIDNEXT 倒退
- 位置:`backend/services/group/group.go:573-575,631-651`。
- 原因:用当前仍在文件夹内的最大关系 ID 加一计算 UIDNEXT,没有保存已分配 UID 的高水位。
- 实测:将最新邮件从 INBOX 移到 Junk,STATUS 返回 UIDNEXT 从 20 降为 19,但 UIDVALIDITY 始终为 2000000000。
- 影响:违反同一 UIDVALIDITY 下 UIDNEXT 不应倒退的同步约定,客户端缓存与增量检测可能不一致。
- 建议:使用单调分配的邮箱 UID 状态,不能根据剩余邮件反推下一个 UID。
- 边界:实测是 UIDNEXT 倒退,不是已经证明数据库复用了旧 UID。
- 复现:`TestAuditUIDNextMustNotDecrease`。
### R14 / P2:UID FETCH * 无法读取最后一封邮件
- 位置:`backend/listen/imap_server/session_fetch.go:147-151`;`backend/services/list/list.go:250-252`。
- 原因:协议动态 UID `*` 用 0 表示,未解析为当前最大 UID 就传入查询函数,被判定为空条件返回空列表。
- 实测:非空 INBOX 中最大 UID 为 20,真实协议 `UID FETCH *` 返回 0 封且没有错误。
- 影响:依赖标准动态 UID 查询的客户端拿不到最后一封邮件。
- 建议:在协议入口统一解析动态 UID、反向范围及空邮箱边界,再交给数据库查询;同步检查 COPY/STORE。
- 复现:`TestAuditFetchWildcardUIDMustReturnLastMessage`。
### R15 / P2:登录邮箱绑定被计入收件箱邮件数量
- 位置:`backend/services/group/group.go:654-662`;`backend/models/user_email.go`。
- 原因:`user_email` 同时保存邮件关系和登录邮箱绑定,绑定记录的 `email_id=0`;邮箱计数未排除这类记录,但邮件内容查询会排除它们。
- 实测:真实本地 TLS IMAP STATUS 返回 `login_bindings=1 real_messages=15 status_messages=16`,与临时数据库中有效邮件数量不一致。
- 影响:客户端看到的收件箱数量大于实际可读取数量。
- 建议:统一有效邮件关系的筛选条件,或把账户绑定与邮件关系分表;同步检查 SELECT、STATUS、IDLE、Poll 的计数定义。
- 边界:已复现 STATUS 数量错误;其他命令的实际客户端影响仍需分别验证。
- 复现:`TestAuditInboxCountMustExcludeLoginBindings`。
### R16 / P2:符合权限条件的用户角色修改仍被拒绝
- 位置:`backend/controllers/authorization.go:13-24`;`backend/controllers/user.go:218-240`;`backend/services/access/authorize.go:89-95`。
- 前提:超级管理员近期认证有效,目标普通用户已配置恢复码,拟将其调整为管理员。
- 原因:控制器调用通用授权适配器时没有传递 `NewRole`,而 `role.manage` 策略明确要求 `NewRole.Valid()`,因此总是拒绝。
- 实测:直接构造完整授权请求可通过;同样前提下执行真实 EditUser 控制器返回业务码 405,数据库角色仍为 `user`。
- 影响:已有用户的角色提升和降低流程不可用。
- 建议:明确传递旧角色和新角色;修复后同时复查角色变化时会话版本递增逻辑,避免启用当前不可达分支时引入新问题。
- 边界:已验证控制器及临时数据库,不是浏览器用户管理界面的操作验收。
- 复现:`TestAuditAuthorizedRoleChangeMustSucceed`。
### R17 / P1:密码恢复 Cookie 路径不覆盖前端使用的版本化接口
- 位置:`backend/controllers/security.go:583-586,595-598`;`backend/listen/http_server/api_v1_compat.go:27-31`;`frontend/src/views/PasswordRecovery/PasswordRecovery.js:65,130,143`。
- 原因:恢复上下文 Cookie 的 Path 固定为 `/api/security/recovery`,前端接口已改为 `/api/v1/security/recovery/...`;服务端内部路由重写不会改变浏览器的 Cookie 路径匹配。
- 实测:真实恢复申请控制器签发 Cookie;TLS HTTP 客户端配合标准 CookieJar,旧接口后续请求携带 1 个 Cookie、上下文可读取;版本化接口携带 0 个、上下文不可读取。
- 影响:邮箱恢复在验证阶段被拒绝;离线恢复即使得到票据,也会在完成阶段因缺少上下文被拒绝。安全密钥恢复使用同一 Cookie,需纳入修复回归。
- 建议:为新旧接口制定一致且足够窄的 Cookie Path,并同步更新签发、读取、清除与历史 Cookie 兼容测试;不能删除上下文校验来绕过故障。
- 边界:已验证真实 TLS 传输、控制器和 Cookie 路径;未操作浏览器、未投递真实邮件、未完成真实安全密钥恢复。
- 复现:`TestAuditRecoveryCookieMustReachVersionedAPI`,旧路径为通过对照组。
### R18 / P2:POP3 消息序号错误使用全局邮件 ID
- 位置:`backend/listen/pop3_server/action.go:145-176,195-208,215-235,243-245`。
- 原因:没有会话级邮箱快照和从 1 开始的消息序号映射,列表和读取参数直接使用全局邮件 ID。
- 实测:临时邮箱只有两封邮件,LIST 返回编号 305、101,查询 `LIST 1` 返回 `Not authorized`。
- 影响:按 STAT 得到的数量依次读取 1..N 的标准 POP3 客户端不能正确下载邮件,连接期间新增邮件也缺乏稳定序号视图。
- 建议:认证成功后建立稳定的有效邮箱关系快照,分离消息序号和 UIDL 唯一标识,读取、删除和统计共用该映射。
- 边界:已验证真实 Action 和临时数据库;未操作外部 POP3 客户端。
- 复现:`TestAuditPOP3MessageNumbersMustStartAtOne`。
### R19 / P2:POP3 删除标记没有影响当前会话的邮箱视图
- 位置:`backend/listen/pop3_server/action.go:130-138,142-180,190-239,267-272`。
- 原因:DELE 只追加 `session.DeleteIds`,没有校验消息存在性;STAT、LIST、UIDL 没有排除已标记删除项。
- 实测:DELE 后 LIST 和 STAT 仍返回 1 封、UIDL 仍可查询;重复 DELE 和不存在消息的 DELE 都返回成功。
- 影响:客户端看到错误的删除状态,后续同步和退出提交不符合 POP3 事务约定。
- 建议:统一检查会话内有效消息及删除标记,直到 RSET 撤销或 QUIT 提交;不能直接在 DELE 时物理删除邮件。
- 边界:本项验证临时库的真实 Action,不证明跨用户越权删除。
- 复现:`TestAuditPOP3MarkedDeletionMustHideMessage`。
### R20 / P2:POP3 STAT 与 LIST 查询不同的邮箱集合
- 位置:`backend/services/list/list.go:63-64,87-89,117-123`;`backend/listen/pop3_server/action.go:133,215`。
- 原因:STAT 统计全部未删除的接收邮件,LIST 只查询收件箱状态和分组。
- 实测:收件箱 1 封、垃圾箱 1 封时,STAT 返回 2,LIST 只列出 1 封。
- 影响:客户端得到的邮箱数量与实际列表不一致;这与 R19 的会话删除标记遗漏是不同原因。
- 建议:明确 POP3 邮箱可见范围,并让统计、列表、UIDL 和读取共享同一快照。
- 复现:`TestAuditPOP3STATMustMatchVisibleMailbox`。
### R21 / P2:POP3 将标准 RSET 拼成 REST,无法撤销待提交删除
- 位置:`backend/internal/gopop/pop3.go:309-326`;`backend/listen/pop3_server/action.go:61,275-278,327-334`。
- 原因:解析器只识别 `REST`,标准命令 `RSET` 落入不支持的自定义命令分支。
- 实测:通过 `net.Pipe` 执行真实解析器,DELE 后发送 RSET 返回 `-ERR unsupported command`,随后 QUIT 仍把 `[1]` 传给删除提交操作。
- 影响:标准客户端不能用 RSET 撤销删除;若忽略错误继续 QUIT,原有删除集合仍会提交。
- 建议:支持标准 RSET 并测试事务回滚;如保留旧拼写兼容,应明确其非标准身份。
- 边界:数据提供层使用测试 Action,真实解析器和协议响应未替换;没有删除真实或临时数据库邮件。
- 复现:`TestAuditPOP3RSETMustCancelPendingDeletion`。
### R22 / P2:单封 LIST 和 UIDL 被错误编码成多行响应
- 位置:`backend/internal/gopop/pop3.go:232-258`。
- 原因:没有按命令是否携带消息序号区分单行与多行响应,两种情况都输出列表和终止点。
- 实测:真实解析器对 `LIST 1` 和 `UIDL 1` 的首行都只返回 `+OK`,其后还残留 10 和 20 字节的额外列表响应。
- 影响:客户端不能从成功首行解析消息大小或唯一标识,后续命令可能读取到前一命令残留响应。
- 建议:携带消息序号时使用单行成功响应;无参数列表才使用多行与终止点。
- 边界:通过内存连接验证真实响应编码,数据提供层为确定性夹具。
- 复现:`TestAuditPOP3SingleMessageRepliesMustBeSingleLine`。
### R23 / P1:POP3 TOP 负数行参数触发未恢复的切片越界 panic
- 位置:`backend/internal/gopop/pop3.go:77,111,260-267`;`backend/listen/pop3_server/action.go:299-311`。
- 前提:已通过 POP3 认证,拥有一封可正常读取的邮件。
- 原因:解析器只校验整数格式、不拒绝负数;Top 用该值直接计算切片上界,连接处理 goroutine 未设置 panic 恢复。
- 实测:真实解析器把 `-100000` 传入 Top;另一个隔离测试先确认正常 Top 成功,再调用真实 Action,捕获 `slice bounds out of range [:-99992]`。
- 影响:持有有效协议授权码的客户端可以触发未恢复 panic,按 Go 的运行规则会终止后端进程,不只关闭这一条连接。
- 建议:协议入口和处理层双重校验非负行数及有效消息序号,使用安全边界计算;panic 防护只能作为兜底,不能代替参数修复。
- 边界:解析器参数传递与真实 Action panic 分段验证;测试捕获 panic,未向正在运行的服务发送恶意命令,也未实际终止后端进程。
- 复现:`TestAuditPOP3ParserMustRejectNegativeTOPLines`、`TestAuditPOP3NegativeTOPMustNotPanic`。
### R24 / P1:普通收件人的邮件详情响应泄露密送收件地址
- 位置:`backend/dto/parsemail/email.go:381-397`;`backend/listen/smtp_server/read_content.go:275-288`;`backend/models/email.go:19,67-86`;`backend/controllers/email/detail.go:29-36`。
- 前提:同一 SMTP 事务同时投递给可见收件人和密送收件人,原始邮件头不含密送地址。
- 原因:解析器把信封中未出现在 To 的地址推导为 Bcc,完整存入多用户共享的邮件内容记录;收件人详情响应直接序列化 Bcc,没有按收件身份隐藏。
- 实测:原始 MIME 不含测试密送地址,真实解析和入库生成两个用户关系;以普通可见收件人身份执行真实详情服务和 HTTP 响应序列化,响应包含该密送地址。
- 影响:普通收件人可以从 API 获知应保密的其他收件地址,无需拥有管理员权限,也不取决于页面是否展示 Bcc。
- 建议:区分投递信封元数据与用户可见邮件内容;发送者可见的密送清单不能共享给收件人,检查详情、列表、导出等所有序列化入口。
- 边界:隔离 SQLite 验证解析、真实入库、授权详情查询及响应编码;未运行网络 SMTP 投递或浏览器界面。
- 复现:`TestAuditInboundBCCMustNotLeakToVisibleRecipient`。
### R25 / P2:标准 Reply-To 在解析和邮件重建时丢失
- 位置:`backend/dto/parsemail/email.go:402,824-840`。
- 原因:读取的头名是 `ReplyTo` 而非标准 `Reply-To`,BuildBytes 也没有输出已有的 ReplyTo 字段。
- 实测:含标准 Reply-To 的原始 MIME 解析后回复地址数量为 0;单独补入合法 ReplyTo 后重建,结果头仍为空。
- 影响:SMTP 接收、POP3/IMAP 重建读取及发送流程会丢失指定回复地址,客户端可能回复到错误的 From 地址。
- 建议:按标准头名解析并保留回复地址列表,补充解析、持久化、重建的完整往返测试。
- 边界:真实解析和 MIME 重建验证,未实测外部客户端发送回复。
- 复现:`TestAuditReplyToMustSurviveParseAndBuild`。
### R26 / P2:带逗号的合法收件人姓名被拆成无效地址
- 位置:`backend/dto/parsemail/email.go:579-591`;`backend/utils/validation/email.go:40-44`。
- 原因:地址列表直接使用 `strings.Split(line, ",")`,忽略带引号的姓名、注释和标准地址列表语法。
- 实测:`"Doe, Jane" <jane@example.com>` 被解析为两个收件项,第一个是无效片段,第二个姓名也不完整。
- 影响:正常客户端提交这类常见显示姓名时,后续验证可拒绝原本合法的邮件;接收邮件的地址元数据也被污染。
- 建议:使用标准地址列表解析器,错误时明确拒绝,不能按逗号切割后把无效片段当邮箱地址。
- 边界:已验证真实 MIME 解析输出;验证拒绝的调用链来自源码,未操作外部 SMTP 客户端。
- 复现:`TestAuditQuotedRecipientNameMustNotSplitAddress`。
### R27 / P2:邮件重建丢失内嵌图片的 Content-ID
- 位置:`backend/dto/parsemail/email.go:689-700,890-902`。
- 原因:附件重建只写 Content-Type 和文件名,没有输出存储的 Content-ID,也没有保留内嵌附件语义。
- 实测:构造含 `cid:audit-inline` 的 HTML 和同名 Content-ID 的图片附件,真实 BuildBytes 后再次解析,HTML 引用仍在,但附件 Content-ID 变为空。
- 影响:POP3/IMAP 下载、重建转发或发送后,客户端无法把 HTML 内嵌图片引用匹配到附件。
- 建议:保留 Content-ID 和内嵌/下载附件类型,覆盖原始 MIME 到存储再到协议读取的往返流程。
- 边界:本项直接实测 BuildBytes;ForwardBuildBytes 有同样字段遗漏,实际转发客户端显示仍需回归。
- 复现:`TestAuditInlineAttachmentMustPreserveContentID`。
### R28 / P1:数据库迁移丢失自增历史高水位,复用已删除邮件的 UID
- 位置:`backend/services/dbmigration/portable_data.go:23-24,107-155`;`portable_executor.go:208-223`;`backend/services/group/group.go:576-577,600-601`。
- 前提:源库正常分配过邮箱关系 ID,随后删除最大 ID 对应的关系,再执行数据库迁移。
- 原因:迁移只复制现存业务行,不保存源库的自增序列高水位;SQLite 系统序列表被排除,目标序列由剩余行重新生成,文件夹 UIDVALIDITY 又没有重置。
- 实测:正常分配关系 ID 1、2,再删除 2,源序列仍为 2;真实 PortableExecutor 成功迁移后,目标序列为 1,新关系再次获得 ID 2。日志为 `switched=true removed_uid=2 source_sequence=2 target_sequence=1 newly_allocated_uid=2`。
- 影响:迁移成功后复用历史邮件 UID,可能让客户端把新邮件与已缓存或已删除邮件混淆;其他依赖历史唯一身份的自增表也需逐一核验。
- 建议:迁移并校验源库序列及自增历史高水位,目标下一值必须超过历史已分配范围,而不能只使用现存行的 MAX(id)。
- 边界:只实测 SQLite→SQLite,没有执行迁移前后真实 IMAP 客户端缓存验证;与 R13 的 UIDNEXT 倒退不同,本项已经实测数据库 ID 重用。PostgreSQL 的 MAX(id) 序列重建仅有源码证据,未做实库验证。
- 复现:`TestAuditMigrationMustPreserveAllocatedMailboxUIDs`。
### R29 / P1:配置提交失败后的成功重试,会在重启时被旧事务回滚
- 位置:`backend/config/manager_v2.go:163-166,395-397`;`backend/config/transaction.go:101-106,146-161,229-239`;`backend/controllers/config.go:130-150`。
- 前提:一次配置应用在分区提交阶段中断,管理员在同一进程中重新应用,收到成功结果,之后重启服务。
- 原因:失败事务留在事务目录;后续重试新建事务并成功提交,但启动恢复仍对旧的未完成事务无条件恢复原始文件,没有识别它已被更新的成功提交取代。
- 实测:真实 manager 和 loader 配合项目已有故障注入钩子,第一次应用失败、重试成功;重启前磁盘代次为 2、邮件大小策略为 8 MiB,新建 manager 触发启动恢复后变为代次 1、旧值 0。
- 影响:用户已经确认保存成功的配置在下次启动时丢失,当前代次和安全、邮件等配置可能退回旧状态。
- 建议:允许重试或新提交前处理未决事务;恢复时核对代次、内容摘要与事务关系,不能让过期失败事务覆盖后续已确认提交。
- 边界:只操作临时配置目录,使用真实提交、加载和恢复实现;没有重启用户后端,也没有模拟物理磁盘故障。
- 复现:`TestAuditSuccessfulConfigRetryMustSurviveRestart`。
### R30 / P2:保存候选配置后编辑或刷新,页面失去继续操作入口
- 位置:`frontend/src/views/components/ConfigSettings/ConfigSettings.js:131-149,188-200,468-496,587-588`;`backend/config/manager_v2.go:299-300,328-332,368-369,608-609`。
- 前提:保存候选配置成功,但尚未应用;用户继续编辑字段,或确认刷新配置页面。
- 原因:前端清空候选代次及对应输入,后端却继续保留唯一候选并拒绝后续保存;应用方法又在没有本地候选代次时直接返回。重新登录还会因候选绑定旧 SessionID 而不能应用。
- 实测:两种操作均得到 `server_pending=true saved_generation=0 apply_requested=false`,再次保存返回代次冲突;真实后端 manager 另行验证原会话再次保存冲突、新会话保存冲突及应用拒绝。保留代次的原会话可以成功应用,作为对照组。
- 影响:正常编辑或刷新即可让在线配置管理卡住,影响所有共享该候选状态的分区,不是单次按钮提示错误。
- 建议:设计有明确授权的候选查询、取消和重新保存流程,并在刷新后恢复状态;不能简单允许其他会话无条件应用敏感配置。
- 边界:执行真实前端组合函数和表单工具,网络按真实 manager 已验证的约束隔离;未做浏览器与后端连通验收,不宣称重启是唯一恢复方式。
- 复现:前端 `edit`、`refresh` 两项候选测试;后端 `TestAuditPendingConfigBlocksFurtherUpdates` 是约束对照测试,当前通过不代表业务问题已修复。
### R31 / P2:外部邮箱验证码输错一次后,页面不能继续验证原绑定
- 位置:`frontend/src/views/components/SecuritySettings/SecuritySettings.js:212-240`;`SecuritySettings.vue:60-69`;`backend/services/externalemail/repository.go:60-77`;`backend/controllers/security.go:631-673`。
- 前提:第一次绑定已成功发码,用户输错验证码,随后再次点击“绑定并验证”。
- 原因:前端虽然保存了挑战和绑定 ID,但每次点击都重新请求绑定;后端拒绝同地址重复绑定,因而第二次不会弹出验证码输入框。待验证列表也没有继续验证或重发入口。
- 实测:真实前端函数输出 `binding_pending=true prompt_count=1 verify_count=1`,提示先为验证失败、再为绑定失败。真实控制器、仓储及验证码服务对照输出 `after_wrong_status=pending retry_bind_error=100 continued_verify_error=0`,证明服务端允许原挑战正确重试,问题出在页面无法进入该路径。
- 影响:一次普通输入错误即可中断该地址的安全邮箱配置;待验证记录继续占用相应用途名额。取消、刷新及验证码过期场景也需要在修复时补齐恢复策略。
- 建议:显式区分创建绑定、输入验证码、重发和取消状态,失败后保留原挑战并允许再次输入;为已有待验证记录提供受授权的恢复和取消流程。
- 边界:前端网络隔离,后端使用临时 SQLite 和测试发送器,未连通真实浏览器或投递真实邮件;不把停用后重绑定策略直接列为另一项已确认缺陷。
- 复现:前端“外部邮箱验证码输入错误后必须能够再次输入”失败测试;后端 `TestAuditPendingExternalBindingRequiresExistingChallenge` 为当前通过的约束对照测试,不代表页面问题已修复。
### R32 / P1:外部安全邮箱绑定没有执行近期重新认证
- 位置:`backend/controllers/security.go:631-641,655-665`;`backend/listen/http_server/https_server.go:157-165,180`。
- 要求:`docs/超级管理员重置与邮箱验证码需求文档.md:418-437` 明确要求绑定及更换外部邮箱先完成近期重新认证。
- 原因:中间件正确计算 `RecentAuth`,但绑定和验证控制器只检查登录用户与服务是否存在,没有执行近期认证授权。
- 实测:真实 TLS HTTP、版本化路由、CookieJar、会话和 CSRF 配合临时 SQLite。1 分钟会话为成功对照;11 分钟会话已经超过 10 分钟近期认证时限,仍返回 `bind_error=0 verify_error=0 verified_binding=true`。同一会话不携带 CSRF 时返回 100,证明不是绕过 CSRF 得出的结果。
- 影响:持有仍有效但未近期认证会话的人,可以将自己控制的邮箱注册为账户恢复凭据,绕过设计要求的再次确认身份边界。
- 建议:绑定前统一执行近期认证要求,并明确挑战期间认证过期的处理方式;不能把前端弹窗或 CSRF 当成重新认证。
- 边界:测试入口只签发确定年龄的真实会话,被审查接口及安全中间件没有替换;测试发送器捕获验证码,不投递邮件,未实测浏览器或完整账户接管。
- 复现:`TestAuditExternalBindingMustRequireRecentAuthentication`,近期会话及缺失 CSRF 为对照。
### R33 / P2:用户的 Smail 主邮箱可被绑定为外部安全邮箱
- 位置:`backend/controllers/security.go:641-646`;`backend/services/externalemail/repository.go:40-60`;`backend/controllers/login_verification.go:90-103`。
- 要求:`docs/超级管理员重置与邮箱验证码需求文档.md:428,481-487` 禁止外部邮箱与当前用户主邮箱相同,也禁止将登录验证码发回正在登录的 Smail 邮箱。
- 原因:绑定只验证地址格式、指纹和名额,没有与用户主邮箱及认证地址映射比较;后续登录验证直接使用该主要外部邮箱。
- 实测:临时库建立真实主邮箱关系,`auth.ResolveIdentifier` 确认其对应当前用户,再经真实 TLS 版本化接口绑定并验证,结果 `primary_identity_resolved=true sent_to_own_mailbox=true bind_error=0 verify_error=0 verified_primary_external=true`。
- 影响:系统接受不能独立于 Smail 登录访问的恢复渠道;之后登录或忘记密码时可能需要先进入同一个邮箱取码,形成无法完成的流程,并违反外部验证渠道要求。
- 建议:规范化后与用户当前主邮箱及相关认证地址核验,绑定及使用阶段都应保证目标符合外部渠道要求。
- 边界:实测完整绑定及验证,发送目标由测试发送器捕获;登录验证目标选择已核对源码,未执行真实邮件投递和完整登录恢复流程。
- 复现:`TestAuditExternalBindingMustRejectOwnPrimaryMailbox`。
### R34 / P2:邮件详情页的正常附件下载链接被后端拒绝
- 位置:`backend/controllers/attachments.go:37-44`;`backend/listen/http_server/http_server.go:93-94`;`frontend/src/views/EmailDetail/EmailDetail.vue:59`。
- 原因:前端生成 `/attachments/download/{邮件ID}/{索引}`,去掉两端斜杠后实际只有四段;控制器却要求五段并读取索引 3、4,尚未访问附件服务即返回参数错误。
- 实测:临时 SQLite 存入真实附件和用户邮件关系;服务层正确返回内容,其他用户访问被拒绝。相同已登录用户经真实 TLS、Cookie 和完整路由请求 `/attachments/download/1/0`,得到 HTTP 200 和 `errorNo=100`,没有下载响应头或附件内容。
- 影响:从普通邮件详情页点击附件无法下载,不是缺少附件数据、服务未运行或所有权检查导致。
- 建议:统一生成与解析下载路由,严格解析正整数邮件 ID 和非负索引;补充正常链接、越界和非所有者请求的端到端测试。
- 边界:真实 HTTP 层验证,无浏览器点击及真实用户数据操作;未将所有权校验误报为缺失。
- 复现:`TestAuditAttachmentPageDownloadMustReturnStoredContent`。
### R35 / P2:邮件列表表格引用断连,选择和批量操作失效
- 位置:`frontend/src/views/List/List.vue:43,100-117`;`frontend/src/views/List/List.js:26,91-105,120-123,142-145,195`。
- 原因:组合函数返回了 `taskTableDataRef`,但页面没有解构;模板同名字符串引用没有写入组合函数持有的 ref。
- 实测:编译并挂载真实 SFC 和组合函数,模拟表格正常发出选中事件,`selectedRows` 已有一行;点击全选、反选以及三种批量操作,结果 `connected=false cleared=0 toggled=0 requests=[]`,连续三次提示“请先选择邮件”。仅测试内手工连接该引用后,全选及已读、移动、删除请求均正常,作为对照。
- 影响:全选和反选无效果,即使用户已在表格勾选邮件,批量已读、移动、删除仍无法执行。
- 建议:在页面显式绑定组合函数返回的 ref,补真实页面挂载后的操作测试,而非只测试孤立函数。
- 边界:使用真实 Vue 编译器和渲染器,Element Plus 表格与网络为隔离桩;尚未在浏览器用实际表格验收。与 R07 写信页引用遗漏为不同页面的问题。
- 复现:前端“邮件列表挂载后,表格选中项必须用于全选和批量操作”。
### R36 / P1:Windows 升级在备份前失败,回滚会删除旧程序
- 位置:`deploy/install-windows.ps1:131-138,171-183`。
- 前提:已安装实例执行安装或升级,停止服务、复制候选程序或备份旧程序时发生异常。
- 原因:异常处理没有记录哪些目标已备份或替换,直接删除两个现有目标;只有备份存在才恢复。提前失败时,删除的就是尚未替换的旧程序。
- 实测:从当前脚本 AST 抽取真实事务语句,所有文件及服务命令改由内存函数桩执行。停止服务、两次复制、第一次备份失败均让两份旧程序丢失;第二次备份失败只恢复主程序,旧管理程序丢失。两份备份都完成后再失败则能恢复,作为对照。
- 影响:本应保持原安装的普通升级失败会破坏可用安装,导致服务下次无法启动或本地管理程序丢失。
- 建议:按目标记录备份和替换状态,仅清理本次真正安装的新文件;成功备份后才能覆盖,回滚失败时必须保留恢复材料并明确报告。
- 边界:没有执行真实安装脚本主体、删除磁盘文件、停止服务、调用系统安装工具或改变 ACL;此处确认的是实际控制流在指定异常下的结果,双平台部署验收仍未完成。
- 复现:`node test/review/run-windows.mjs`,六个失败阶段内存验证。
### R37 / P2:规则编辑取消后点击新建,提交的仍是对旧规则的修改
- 位置:`frontend/src/views/components/RuleSettings/RuleSettings.js:76-83,93-98`;`RuleSettings.vue:35,101`;`backend/controllers/rule.go:122-128`。
- 原因:编辑表单直接共享原列表的条件数组,取消只隐藏弹窗;新建按钮又只显示弹窗,没有重置旧规则 ID 和草稿。
- 实测:编译并挂载真实 SFC 和组合函数,修改条件后通过真实模板点击取消、再点击新建和提交。原列表已变成未保存条件 `unsaved`,新建表单 ID 仍为 7,实际请求为 `/api/v1/rule/update` 且携带旧 ID。后端已核对会按该 ID 更新当前用户的原规则。
- 影响:用户取消的修改没有被丢弃,之后原本想新增的规则会覆盖已有规则,而非创建新记录。
- 建议:编辑时深拷贝条件;新建、取消和关闭均显式管理草稿生命周期,保证新建 ID 为 0;覆盖取消、关闭图标、遮罩关闭后重新新建的测试。
- 边界:真实 Vue 渲染器和模板事件,表格、弹窗容器和网络为桩;没有操作真实用户规则,尚未进行浏览器验收。早期渲染器桩错误不作为业务证据。
- 复现:`node --test test/review/rule-frontend.test.mjs`。
### R38 / P1:ACME 正常返回的完整证书链被重复拼接,自动签发和续期无法保存
- 位置:`backend/services/setup/ssl/ssl.go:366-376,430-446`;`backend/config/ssl_storage.go:221-230,282-290`。
- 原因:签发请求设置 `Bundle: true`,lego 返回的 `Certificate` 已包含中间证书,`IssuerCertificate` 又提供相同链。导入函数把 issuer 无条件追加到已完整的链尾,随后按相邻证书校验签名,最终尝试让非自签中间证书验证自身签名。
- 实测:生成根、中间及叶证书,完整链独立通过私钥匹配及域名、签名链校验;将与 lego `Bundle=true` 一致的完整链及独立 issuer 一起传入真实 `writeCertificateFiles`,返回 `invalid SSL certificate material`。当前依赖 lego v4.34.0 的 `acme/api/certificate.go:83-94` 与 `certificate/certificates.go:409-411` 已核对这种响应结构。
- 影响:常见的叶证书加非自签中间证书响应会被拒绝,初次自动签发不能进入完成阶段,自动续期也不能安装新证书。
- 建议:明确叶证书、完整链与 issuer 的接口语义,按证书 DER 去重或只使用已完整的链;保留真正的不匹配、过期和非法链拒绝测试。
- 边界:使用本地生成的证书复现实际存储入口,没有请求真实 CA、提交 DNS 挑战或消耗签发配额;不声称所有可能的证书链均会失败。
- 复现:`TestAuditACMEBundledChainMustBeImportable`。
### R39 / P2:有效泛域名证书被判定名称不匹配,每次检查都触发续期
- 位置:`backend/services/setup/ssl/ssl.go:298-315,512-518,530-548`;`backend/listen/cron_server/ssl_update.go:69-76`。
- 原因:DNS 模式主动申请 `*.example.test`,但健康检查只判断 SAN 文本是否包含 `imap`,而不是按 X.509 域名匹配规则判断服务名称。
- 实测:通过真实受控存储写入 90 天有效的 `*.example.test` 完整链,真实 `VerifyHostname("imap.example.test")` 成功;`CheckSSLCrtInfo` 却返回 `days_remaining=89 name_match_fail=true`,续期条件为 true。
- 影响:DNS 泛域名模式在证书足够有效时仍反复申请证书,需要重复人工 DNS 挑战,并可能消耗签发配额;成功更新时还触发不必要的重启。
- 建议:根据实际服务域名调用标准域名校验,支持泛域名,不使用名称子串推断证书有效性。
- 边界:为隔离 R38,本测试不重复附加 issuer;只验证真实检查结果与续期条件,没有向 CA 发请求或实际重启服务。
- 复现:`TestAuditFreshWildcardCertificateMustNotRequireRenewal`。
### R40 / P1:分区配置下自动续期调用旧写入器,报错后证书目录却已切换
- 位置:`backend/services/setup/ssl/ssl.go:256-267,376-377,541-548`;`backend/config/config.go:281-288`;`backend/config/ssl_storage.go:137-160`。
- 前提:已经迁移为分区配置,使用系统管理的自动证书;证书签发结果本身有效。
- 原因:续期先调用 `ImportManagedSSL` 切换受控 `current` 目录,再调用明确禁止覆盖分区配置的旧版 `WriteConfig`。后者失败后没有回滚证书,调用方按失败退出,不发送成功更新后的重启信号。
- 实测:临时根目录中生成有效证书、真实迁移并加载 ready 状态分区配置,再调用真实续期存储入口。结果为 `root_unchanged=true current_changed=true current_is_new=true loaded_tls_is_old=true`,错误为“分区配置不能通过旧版写入接口覆盖,请使用配置管理”。
- 影响:续期无法完成正常提交和重启路径,磁盘证书已经换新,但已加载的 TLS 配置仍持有旧证书;外部看到失败状态,实际受控存储却已变化。
- 建议:接入分区配置管理器的提交及运行时应用流程,协调证书切换、配置提交和失败回滚;不能简单移除旧写入器对分区根的保护。
- 边界:为独立于 R38,本测试不重复附加 issuer;未请求 CA、启动真实 TLS 监听或重启用户服务,已加载证书对象作为运行时持有旧材料的对照。
- 复现:`TestAuditPartitionedRenewalMustCommitBeforeSwitch`。
### R41 / P2:旧配置迁移静默将自动 DNS 证书改成 HTTP 挑战
- 位置:`backend/config/migrate.go:717-733`;`backend/config/partitioned_compatibility.go:75-78`;`backend/services/setup/ssl/ssl.go:337-347,400-409`。
- 原因:迁移仅区分系统管理和用户上传,不保存原来的自动 HTTP / DNS 签发方式;兼容加载将所有 `managed_default` 固定映射成 `SSLTypeAutoHTTP`。
- 实测:真实迁移输入 `SSLTypeAutoDNS` 并重读分区配置,得到 `before_ssl_type=2 after_ssl_type=0 before_dns_challenge=true after_http_challenge=true`;迁移没有拒绝或提示这一配置丢失。
- 影响:原本依赖 DNS 挑战的部署后续走 HTTP 挑战,在没有公网 HTTP 可达条件时不能续期,泛域名申请策略也改变。
- 建议:把 ACME 挑战方式作为独立配置保留和校验;暂不支持时明确阻止迁移并提示人工处理,不能静默换成另一种方式。
- 边界:验证配置迁移、兼容加载和挑战分支选择;未进行真实网络挑战。与 R40 保存阶段失败属于不同根因。
- 复现:`TestAuditPartitionedMigrationMustPreserveDNSChallengeMode`。
### R42 / P1:旧配置迁移丢弃 SQLite 目录,现有数据库被改指向空库
- 位置:`backend/config/migrate.go:581-592`;`backend/config/partitioned_compatibility.go:89-92`;`backend/config/config.go:370-372,403-428`。
- 前提:旧版 SQLite 数据库使用带子目录的有效路径,例如 `./config/archive/review.db`。
- 原因:迁移通过 `filepath.Base` 只保留文件名,兼容加载再将文件名固定拼到根目录的 `config` 下,没有搬迁原库或验证路径等价。
- 实测:临时原库保存真实 SQLite 标记表,旧配置能够正确解析其位置;执行真实配置迁移后重读得到另一个路径。结果 `source_exists=true target_missing_before_open=true same_path=false marker=""`,查询报 `no such table: audit_marker`。
- 影响:配置格式迁移成功,但后续数据库连接指向新建空库,原有账号和邮件不再从原路径读取。原数据库仍存在,不是文件被删除。
- 建议:完整保留并验证已有数据库位置;若新格式只允许固定位置,应明确拒绝迁移或在备份及校验后受控搬迁,不能静默改变连接目标。
- 边界:使用临时标记表验证配置迁移和真实 SQLite 打开行为,不是三种数据库搬迁服务测试,也未启动正式用户实例。
- 复现:`TestAuditLegacyMigrationMustPreserveSQLiteLocation`。
### R43 / P1:生产 DKIM 校验保留特殊域名放行分支,无效签名被判为通过
- 位置:`backend/dto/parsemail/dkim.go:134-142`;`backend/utils/consts/consts.go:4`;`backend/listen/smtp_server/read_content.go:121,131-148,295`。
- 原因:检查签名错误之前,只要验证结果中的域名等于测试常量就立即返回 true。该函数由正常匿名 SMTP 收信路径调用,不受测试构建或开发模式限制。
- 实测:构造缺少必要签名标签的邮件,真实 DKIM 库返回 `signature missing required tag`;普通保留示例域名的应用结果为 false,相同无效结构改用特殊常量域名则为 `application_passed=true`。
- 影响:外部发件人可以使无效 DKIM 被记录为通过,污染认证结果及依赖该结果的插件判断;不能把该结果当作可信邮件认证依据。
- 建议:删除运行时代码中的测试域名放行,只依据实际校验结果判断;测试通过注入验证器或真实隔离密钥实现,不能保留生产后门分支。
- 边界:直接执行真实 DKIM 校验入口,验证器在 DNS 查询前失败,不请求外网。SMTP 调用、认证对象和落库字段已核对源码,未做真实外部 SMTP 投递;不声称绕过所有其他反垃圾检查。
- 复现:`TestAuditInvalidDKIMMustNotPassForSpecialDomain`,包含普通域名拒绝对照。
### R44 / P2:IMAP SEARCH 的多个独立搜索键被错误取并集
- 位置:`backend/services/list/imap_search.go:172-187,191-205,465-512`;`backend/listen/imap_server/session_search.go:20`。
- 原因:UID、序号过滤命中任意一个集合就保留;多个 OR 键也共享同一个累计结果集合。同一 SEARCH 中独立键应互相 AND,只有单个 OR 键内部两项取并集。
- 实测:真实本地 TLS IMAP 创建三封邮件,对 `{A,B}` 和 `{B,C}` 两个 UID 键搜索,返回 A/B/C;两个独立 OR 键的相同组合也返回 A/B/C,均应只返回 B。
- 影响:客户端组合筛选返回不符合全部条件的邮件,搜索结果集合错误。
- 建议:按搜索语法树逐键求交,OR 节点内部求并,并覆盖多个 UID、序号、OR 及其嵌套组合。
- 边界:真实 TLS 协议验证 UID 和 OR 组合;序号分支具有相同静态逻辑,但未在本用例单独实测。不涉及跨用户访问结论。
- 复现:`TestAuditSearchKeysMustIntersect`。
### R45 / P2:IMAP SEARCH DELETED 与 STORE/FETCH 使用不同状态字段
- 位置:`backend/services/list/imap_search.go:239-245`;`backend/listen/imap_server/session_store.go:154-170`。
- 原因:STORE 持久化 `is_deleted`,FETCH 据此返回删除标记;SEARCH 却检查用于网页文件夹分类的 `status == 3`。
- 实测:真实 TLS IMAP 对收件箱邮件执行 `STORE +FLAGS (\Deleted)` 后,FETCH 明确返回该标记,但同 UID 的 `SEARCH DELETED` 返回空集合。
- 影响:客户端不能正确搜索已标记删除的邮件,`UNDELETED` 的判断也与实际标记不一致。
- 建议:协议层统一使用独立的 `is_deleted` 标记,不混用网页垃圾箱状态;补充设置、搜索、撤销、再次搜索的协议测试。
- 边界:使用隔离 SQLite 和本地 TLS,验证 STORE、FETCH、SEARCH,未对真实用户邮箱执行删除或 EXPUNGE。
- 复现:`TestAuditSearchDeletedMustMatchStoredFlag`。
### R46 / P1:关闭 Telegram 附件推送仍上传邮件附件
- 位置:`plugins/pmail_telegram_push/hook/hook.go:83-94`;`hook/send.go:172-177,181-218`。
- 原因:用户设置正确传入 `SendAttachments=false`,但通知发送和附件批次发送均不检查该字段。
- 实测:通过真实 `ConfigureUserSettings`、`ReceiveSaveAfter` 和 Telegram SDK,在内存 HTTP 客户端捕获到 `enabled=false messages=1 uploaded_files=2`;启用开关的对照同样发送两个附件。
- 影响:用户明确关闭附件外发后,附件内容仍进入第三方上传请求,违反隐私设置。
- 建议:在附件发送入口检查用户开关,并覆盖直接调用和收信钩子两条路径。
- 边界:使用虚构测试 token 和内存客户端,未向 Telegram 发送真实请求;生产插件的启动与隔离仍需平台验收。
- 复现:`TestAuditDisabledAttachmentsMustNotBeSent`。
### R47 / P2:Telegram 普通主题和正文未转义却按 HTML 发送
- 位置:`plugins/pmail_telegram_push/hook/send.go:24-28,87-95,157-160`。
- 原因:邮件主题和 `Text` 原样插入通知,`sendText` 固定指定 `ParseModeHTML`。
- 实测:真实 SDK multipart 请求中 `parse_mode="HTML" raw_subject=true raw_body=true`;正常文本里的尖括号和 `&` 没有转义。
- 影响:普通文本可能被解释为格式或链接,含不支持标签时会导致 Telegram 拒绝通知;附件依赖文本发送成功,也会受影响。
- 建议:普通文本统一 HTML 转义,只对经过白名单处理的邮件 HTML 保留受支持标记。
- 边界:已验证真实请求构造,未请求真实 Telegram API,不能将模拟响应当成 Telegram 接收结果。
- 复现:`TestAuditTelegramPlainTextMustBeEscaped`。
### R48 / P2:Telegram 长中文通知截断破坏 UTF-8
- 位置:`plugins/pmail_telegram_push/hook/send.go:120-128`。
- 原因:用字节长度和 `text[:4076]` 截断 Unicode 文本,没有字符边界检查。
- 实测:合法中文输入在三种前缀长度中有两种生成 `output_bytes=4079 output_valid=false`,另一种恰好对齐字节边界的对照通过。
- 影响:正常中文通知末尾损坏;还需独立检查截断后的 HTML 标签与实体完整性。
- 建议:按 Telegram 文本限制与 Unicode 边界处理长度,再保证 HTML 标签、实体和 spoiler 闭合。
- 边界:证明函数输出无效 UTF-8,不声称真实 API 必然返回某个错误码。
- 复现:`TestAuditTelegramTruncationMustKeepUTF8`。
### R49 / P2:第三方协议关闭失败后仍显示已关闭
- 位置:`frontend/src/views/components/ThirdPartyAuthorization/ThirdPartyAuthorization.js:41-56`;`ThirdPartyAuthorization.vue:34-39`。
- 原因:`v-model` 在 `change` 前更新 `item.enabled`,处理函数保存的 `previous` 已是新值,失败回滚不能恢复原状态。
- 实测:编译并挂载真实 Vue 模板,按已核对的 Element Plus 事件顺序触发开关;模拟请求失败后 `serverEnabled=true uiEnabled=false`。成功请求的对照通过。
- 影响:用户以为 IMAP 等客户端访问已关闭,但服务端没有关闭;虽出现失败通知,页面持续状态仍然误导。
- 建议:改用受控状态或 `before-change`,请求成功才提交新值;失败时回读服务端状态。
- 边界:组件事件与请求失败为隔离模拟,未做浏览器或真实协议关闭验收。
- 复现:`test/review/protocol-frontend.test.mjs`。
### R50 / P2:Telegram 设置页与 iframe 隔离策略不兼容,初始化和 API 均被阻断
- 位置:`frontend/src/views/components/PluginSettings/PluginSettings.vue:13-16`;`plugins/pmail_telegram_push/src/App.vue:241-249`;`backend/listen/http_server/https_server.go:244-246`。
- 原因:插件 iframe 只有 `allow-scripts`,页面挂载时却先读取 `localStorage`,之后才获取设置;同时插件响应的 CSP 明确 `connect-src 'none'`,页面却直接通过 Axios 调用主程序 API。
- 实测:在 Smail 专属 MCP 浏览器中运行源码提取的真实挂载函数、sandbox 和 CSP。`localStorage` 产生 `SecurityError`,后面的获取设置函数未执行;独立请求探针触发 `connect-src` 违规,服务端未收到 API 请求。
- 影响:Telegram 设置页无法正常初始化、读取或保存设置;不是简单重启或清浏览器缓存能解决的问题。
- 建议:保留插件隔离,采用主程序原生配置页面或严格限定来源、动作和字段的消息桥接。不能简单同时给不可信插件添加 `allow-same-origin` 和 `allow-scripts` 来绕过安全边界。
- 边界:这是使用源码策略和挂载函数的浏览器隔离夹具,不是当前生产插件二进制或完整页面部署验收;未修改真实配置和数据库。
- 复现:`node test/review/plugin-browser.mjs`;MCP 内联结果转录在 `test-log/review-plugin-browser-1788639873115/browser-evidence.json`。MCP 自带文件输出因工具工作区限制失败,随后读取内联结果并明确标记转录来源。
### R51 / P2:投递失败信息不能通过插件 RPC,发送后钩子被跳过
- 位置:`backend/hooks/framework/framework.go:40-46,162-170,195-202`;`backend/hooks/base.go:67,131-132`。
- 原因:通信对象直接使用 `map[string]error`。非空 Go 错误被 JSON 编码为对象,接收端不能将该对象反序列化到 `error` 接口,因此尚未执行钩子就返回 400。
- 实测:使用真实 DTO、JSON 编解码和 `handleHookDTO`,成功投递对照为 `status=200 callback=true`;投递失败为 `status=400 callback=false`,错误消息没有到达插件。
- 影响:插件不能可靠接收发送失败通知或执行其失败处理逻辑,恰好在需要错误信息时丢失回调。
- 建议:为 RPC 定义明确的可序列化错误对象或字符串映射;接口适配层负责与 Go `error` 转换,并保留成功和失败对照测试。
- 边界:验证的是实际处理函数和序列化链,不是外部邮件投递或生产插件进程验收;不声称现有插件都实现了发送失败通知。
- 复现:`node test/review/run.mjs --framework-only`;日志 `test-log/run-2026-09-05T20-29-56-638Z-30704/backend.log`。
## 已排除线索与通过的对照
- 首次管理员角色:使用全新临时 SQLite、真实 15 次版本化迁移、真实 `SetAdminPassword` 并关闭重开数据库。新建和重启后均为 `is_admin=1 role="" effective_role="super_admin" config_read=true role_manage=true`。xorm 实际写入空角色,兼容回退生效,不能仅凭 schema 默认值推断管理员降为普通用户。不登记为缺陷,也不泛化为 MySQL/PostgreSQL 实库已验证。
- TOTP 登记密钥并发线索:16 个 goroutine 各执行 150 次真实 `BeginEnrollment`,`-race` 通过,没有复现数据竞争;当前全仓 Go 调用搜索也未找到该服务被业务包引用。不列为确认问题,不能据此声称完整 TOTP 用户流程已经接入或通过验收。
## 待诊断项,不列为已确认问题
- 同文件夹 COPY 的身份覆盖已验证为 R11,其他批量副本操作仍需分别验证。
- Windows 正式模式插件隔离存在明确不可用分支,仍需核对功能开关、实际调用链和文档承诺。
- SMTP MX 回退、IMAP 动态序列其他命令、HTML 入库与插件路径等尚需继续检查;UIDNEXT 和 UID FETCH 通配符的已验证问题见 R13、R14。
## 复现与验证记录
```powershell
# 原有测试基线
node test/run.mjs all -count=1 ./...
# 独立审查测试:当前预期会失败,失败断言用于暴露尚未修复的业务问题
node test/review/run.mjs
node test/review/run.mjs -race
node test/review/run.mjs --pop3-only
node test/review/run.mjs --message-only
node test/review/run.mjs --migration-only
node test/review/run.mjs --config-only
node test/review/run.mjs --controllers-only -run=^TestAuditPendingExternalBindingRequiresExistingChallenge$
node test/review/run.mjs --http-only -run=^TestAuditExternalBinding
node test/review/run.mjs --http-only -run=^TestAuditAttachment
node test/review/run-windows.mjs
node test/review/run.mjs --setup-only -run=^TestAuditFirstAdministrator
node test/review/run.mjs --ssl-only
node --test test/review/rule-frontend.test.mjs
node --test test/review/frontend-findings.test.mjs
node test/review/run-telegram.mjs
node --test test/review/protocol-frontend.test.mjs
node test/review/run.mjs --framework-only
# 逐行覆盖账本,不代表测试覆盖率或功能验收率
node test/review/coverage.mjs
```
- 原有前端 50/50 及后端全量通过:`test-log/run-2026-09-05T17-49-53-054Z-47380/`。
- 重点包原有 race 基线:`test-log/run-2026-09-05T17-51-55-556Z-29640/backend.log`,通过不代表新增并发路径已覆盖。
- 已确认后端复现:`test-log/run-2026-09-05T18-13-47-945Z-448/backend.log`。
- 运行时 race 证据:`test-log/run-2026-09-05T18-09-57-603Z-29380/backend.log`。
- 新增副本身份复现:`test-log/run-2026-09-05T18-20-32-820Z-49756/backend.log`。
- 三项标准 IMAP 行为及 race 重跑:`test-log/run-2026-09-05T18-23-59-068Z-51124/backend.log`。
- 包含 R15 的后端复现:`test-log/run-2026-09-05T18-25-37-339Z-30964/backend.log`。
- 包含 R16、R17 的后端复现:`test-log/run-2026-09-05T18-32-47-015Z-27832/backend.log`。
- POP3 的 R18–R23 隔离复现:`test-log/run-2026-09-05T18-44-16-845Z-41276/backend.log`。
- MIME 与密送隐私的 R24–R27 隔离复现:`test-log/run-2026-09-05T18-48-38-700Z-47076/backend.log`。
- 迁移的 R01、R03、R28 隔离复现:`test-log/run-2026-09-05T18-55-32-900Z-28932/backend.log`。
- 配置事务的 R29 隔离复现:`test-log/run-2026-09-05T19-02-28-851Z-43688/backend.log`。
- 配置事务重跑与 R30 后端约束:`test-log/run-2026-09-05T19-09-01-546Z-43540/backend.log`。
- R31 后端真实约束及已知问题重跑:`test-log/run-2026-09-05T19-17-39-345Z-44436/backend.log`。
- R31 修正测试筛选参数后精确重跑通过:`test-log/run-2026-09-05T19-19-04-347Z-42100/backend.log`;仅对照测试通过,不表示页面问题修复。
- R32、R33 真实 TLS 和 CSRF 隔离复现:`test-log/run-2026-09-05T19-26-18-382Z-44472/backend.log`;近期会话对照通过,两项安全边界断言预期失败。
- R34 附件下载及 R32、R33 完整路由重跑:`test-log/run-2026-09-05T19-34-58-471Z-48248/backend.log`。
- R35 列表引用挂载复现及手工连接对照:`test-log/review-list-1788636898383.log`。
- R36 Windows 安装事务内存隔离验证:`test-log/review-windows-1788637055598/windows.log`;前五种阶段暴露缺陷,备份完成后的失败能恢复。
- R37 规则编辑取消再新建:`test-log/review-rules-1788637601791.log`;旧 ID 与未保存条件一起提交到更新接口。
- 首次管理员角色排除对照:`test-log/run-2026-09-05T19-44-36-177Z-37720/backend.log`,新建及重启均通过。
- R38 完整链重复与 R39 泛域名误续期:`test-log/run-2026-09-05T19-51-15-151Z-40896/backend.log`,两项缺陷断言失败。
- TOTP 并发线索隔离对照:`test-log/run-2026-09-05T19-53-03-838Z-34048/backend.log`,`-race` 通过,未确认缺陷。
- R40 分区续期保存与 R41 DNS 挑战方式丢失:`test-log/run-2026-09-05T19-58-24-637Z-33360/backend.log`,两项缺陷断言失败。
- R42 SQLite 配置迁移路径丢失:`test-log/run-2026-09-05T20-02-12-179Z-39988/backend.log`,真实原库仍存在,新连接目标缺少标记表。
- R43 无效 DKIM 放行、R44 搜索键并集、R45 删除标记搜索:`test-log/run-2026-09-05T20-07-31-623Z-3388/backend.log`,三个问题的安全或语义断言均失败;普通域名 DKIM 拒绝对照通过。
- R46–R48 Telegram 附件开关、HTML 与中文截断:`test-log/review-telegram-2026-09-05T20-16-00-530Z/telegram.log`,三个缺陷断言失败,附件开启与对齐截断对照通过。
- R49 协议开关失败回滚:`test-log/review-protocol-20260906-041737.log`,失败请求状态一致性断言失败,成功请求对照通过。
- 包含候选配置与外部邮箱重试的五项前端失败复现:`test-log/review-frontend-2026-09-05T19-15-56-197Z/frontend.log`。
- 前端两项复现日志:`test-log/frontend-review-20260906-022032.log`。
- 测试源码:`test/review/`;Go overlay 将测试注入对应包,不改业务源码;运行产物放在 `test-log/`。
- `^TestAudit` 还会匹配项目原有审计接口测试,因此测试用例总数不等于新增问题数。
- 未运行带 `--fix` 的 lint,不用自动格式化或文本替换悄悄改动业务源码。
## 覆盖说明
- 覆盖记录源:`test/review/reviewed-ranges.json`。
- 生成账本包含每个受版本控制文件的路径、分类、行数、SHA-256、阅读行范围及发现编号。
- `read-not-accepted` 只表示全文已读,不表示无问题,也不表示复审通过。
- `partial-read` 表示只读取部分行;`not-recorded` 表示没有登记,接续摘要中模糊描述的已读内容不冒充全文覆盖。
- 新增且尚未提交的审查文件不属于基线受控文件,单独验证;日志和运行数据库不纳入业务源码逐行统计。
- **当前不能声称“每一行都审查完成”或“全部功能已实现并验收”。**

View File

@ -0,0 +1,55 @@
package http_server
import (
"encoding/json"
"errors"
"fmt"
"io"
"testing"
"time"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/attachments"
"git.pcux.cn/xuans/Smail/utils/context"
)
// 使用真实路由、TLS 会话及附件数据;服务层成功和非所有者拒绝为对照。
func TestAuditAttachmentPageDownloadMustReturnStoredContent(t *testing.T) {
fixture := newAuditExternalHTTPFixture(t, time.Minute)
payload := "audit attachment content"
encoded, err := json.Marshal([]parsemail.Attachment{{
Filename: "audit.txt", ContentType: "text/plain", Content: []byte(payload),
}})
if err != nil {
t.Fatal(err)
}
email := &models.Email{Subject: "Audit attachment", Attachments: string(encoded)}
if _, err := fixture.engine.Insert(email); err != nil {
t.Fatal(err)
}
if _, err := fixture.engine.Insert(&models.UserEmail{UserID: fixture.user.ID, EmailID: email.Id}); err != nil {
t.Fatal(err)
}
name, content, err := attachments.GetAttachmentsByIndex(&context.Context{UserID: fixture.user.ID}, email.Id, 0)
if err != nil || name != "audit.txt" || string(content) != payload {
t.Fatal("附件服务正向对照未成立")
}
if _, _, err := attachments.GetAttachmentsByIndex(&context.Context{UserID: fixture.user.ID + 1}, email.Id, 0); !errors.Is(err, attachments.ErrAttachmentUnavailable) {
t.Fatal("非所有者访问附件未被拒绝")
}
path := fmt.Sprintf("/attachments/download/%d/0", email.Id)
result, err := fixture.client.Get(fixture.server.URL + path)
if err != nil {
t.Fatal(err)
}
defer result.Body.Close()
body, err := io.ReadAll(result.Body)
if err != nil {
t.Fatal(err)
}
t.Logf("service_content_matches=true outsider_denied=true path=%s status=%d content_type=%s body=%s", path, result.StatusCode, result.Header.Get("Content-Type"), body)
if string(body) != payload || result.Header.Get("Content-Disposition") == "" {
t.Fatal("邮件详情页生成的正常下载链接未返回附件内容")
}
}

View File

@ -0,0 +1,158 @@
package config
import (
"context"
"database/sql"
"encoding/json"
"errors"
"os"
"path/filepath"
"testing"
_ "modernc.org/sqlite"
)
// 审查专用:模拟配置落盘中断,只操作测试创建的临时配置根目录。
func TestAuditSuccessfulConfigRetryMustSurviveRestart(t *testing.T) {
root := t.TempDir()
writeRuntimeFixture(t, root, validRuntimeConfig())
options := ConfigLoaderOptions{Validation: RuntimeValidationOptions{HasSuperAdmin: true, Production: true}}
manager, err := NewConfigManager(root, options)
if err != nil {
t.Fatal(err)
}
current := manager.Snapshot()
email := current.Email
email.Policy.MaxMessageBytes = 8 << 20
payload, err := json.Marshal(email)
if err != nil {
t.Fatal(err)
}
actor := authorizedConfigActor()
updated, err := manager.Update(context.Background(), UpdateRequest{
Section: SectionEmail, ExpectedGeneration: current.Generation, Payload: payload, Actor: actor,
})
if err != nil {
t.Fatal(err)
}
interrupted := errors.New("审查注入的一次性分区提交失败")
manager.transactions.WithHooks(TransactionHooks{BeforePhase: func(phase TransactionPhase) error {
if phase == TransactionSectionsCommitted {
return interrupted
}
return nil
}})
if _, err := manager.ApplyAuthorized(context.Background(), updated.Generation, actor); !errors.Is(err, interrupted) {
t.Fatalf("中断前提不成立: %v", err)
}
manager.transactions.WithHooks(TransactionHooks{})
if _, err := manager.ApplyAuthorized(context.Background(), updated.Generation, actor); err != nil {
t.Fatalf("重试没有成功: %v", err)
}
before, err := NewConfigLoader(root, options).Load()
if err != nil {
t.Fatal(err)
}
if before.Generation != updated.Generation || before.Email.Policy.MaxMessageBytes != email.Policy.MaxMessageBytes {
t.Fatal("重试结果未实际持久化")
}
restarted, err := NewConfigManager(root, options)
if err != nil {
t.Fatal(err)
}
after := restarted.Snapshot()
t.Logf("successful_generation=%d before_restart=%d after_restart=%d expected_bytes=%d actual_bytes=%d", updated.Generation, before.Generation, after.Generation, email.Policy.MaxMessageBytes, after.Email.Policy.MaxMessageBytes)
if after.Generation != before.Generation || after.Email.Policy.MaxMessageBytes != before.Email.Policy.MaxMessageBytes {
t.Fatal("旧失败事务在启动恢复时撤销了后续已成功落盘的配置")
}
}
// 记录真实后端候选状态约束,供前端丢失候选代次的复现使用。
func TestAuditPendingConfigBlocksFurtherUpdates(t *testing.T) {
root := t.TempDir()
writeRuntimeFixture(t, root, validRuntimeConfig())
manager, err := NewConfigManager(root, ConfigLoaderOptions{Validation: RuntimeValidationOptions{HasSuperAdmin: true, Production: true}})
if err != nil {
t.Fatal(err)
}
current := manager.Snapshot()
email := current.Email
email.Policy.MaxMessageBytes = 8 << 20
payload, err := json.Marshal(email)
if err != nil {
t.Fatal(err)
}
actor := authorizedConfigActor()
request := UpdateRequest{Section: SectionEmail, ExpectedGeneration: current.Generation, Payload: payload, Actor: actor}
updated, err := manager.Update(context.Background(), request)
if err != nil {
t.Fatal(err)
}
_, retryErr := manager.Update(context.Background(), request)
if !errors.Is(retryErr, ErrGenerationConflict) {
t.Fatalf("原会话再次保存的后端前提变化: %v", retryErr)
}
newActor := actor
newActor.SessionID = "audit-new-session"
request.Actor = newActor
_, newSaveErr := manager.Update(context.Background(), request)
_, newApplyErr := manager.ApplyAuthorized(context.Background(), updated.Generation, newActor)
if !errors.Is(newSaveErr, ErrGenerationConflict) || !errors.Is(newApplyErr, ErrAuthorizationRequired) {
t.Fatalf("重新登录后的后端前提变化: save=%v apply=%v", newSaveErr, newApplyErr)
}
t.Logf("active=%d pending=%d retry_conflict=%t new_session_save_conflict=%t new_session_apply_denied=%t", manager.Status().ActiveGeneration, updated.Generation, errors.Is(retryErr, ErrGenerationConflict), errors.Is(newSaveErr, ErrGenerationConflict), errors.Is(newApplyErr, ErrAuthorizationRequired))
// 原会话保留代次时可以应用,问题不是所有应用请求都无条件失败。
if _, err := manager.ApplyAuthorized(context.Background(), updated.Generation, actor); err != nil {
t.Fatalf("原会话应用的对照组失败: %v", err)
}
}
func TestAuditLegacyMigrationMustPreserveSQLiteLocation(t *testing.T) {
root := t.TempDir()
oldRoot := ROOT_PATH
ROOT_PATH = root
t.Cleanup(func() { ROOT_PATH = oldRoot })
sourcePath := filepath.Join(root, "config", "archive", "review.db")
if err := os.MkdirAll(filepath.Dir(sourcePath), 0700); err != nil {
t.Fatal(err)
}
database, err := sql.Open("sqlite", sourcePath)
if err != nil {
t.Fatal(err)
}
defer database.Close()
if _, err := database.Exec("CREATE TABLE audit_marker (value TEXT); INSERT INTO audit_marker VALUES ('original')"); err != nil {
t.Fatal(err)
}
writeLegacyMigrationFixture(t, root, map[string]any{
"logLevel": "info", "domain": "mail.example.test", "webDomain": "mail.example.test",
"dbType": "sqlite", "dbDSN": "./config/archive/review.db", "isInit": true,
"sslType": "1", "SSLPublicKeyPath": "./config/ssl/public.crt", "SSLPrivateKeyPath": "./config/ssl/private.key",
"httpPort": 80, "httpsPort": 443, "httpsEnabled": 1,
})
before, err := ReadConfig()
if err != nil || before.DbDSN != sourcePath {
t.Fatalf("原配置读取路径前提不成立: %v", err)
}
if _, err := MigrateLegacyConfig(root, RuntimeValidationOptions{HasSuperAdmin: true, Production: true}); err != nil {
t.Fatal(err)
}
after, err := ReadConfig()
if err != nil {
t.Fatal(err)
}
_, sourceErr := os.Stat(sourcePath)
_, targetErr := os.Stat(after.DbDSN)
target, err := sql.Open("sqlite", after.DbDSN)
if err != nil {
t.Fatal(err)
}
defer target.Close()
var marker string
queryErr := target.QueryRow("SELECT value FROM audit_marker").Scan(&marker)
t.Logf("source_exists=%t target_missing_before_open=%t same_path=%t marker=%q query_error=%v",
sourceErr == nil, os.IsNotExist(targetErr), before.DbDSN == after.DbDSN, marker, queryErr)
if before.DbDSN != after.DbDSN || queryErr != nil || marker != "original" {
t.Fatal("仅迁移配置不应把已有 SQLite 指向一个新建的空库")
}
}

View File

@ -0,0 +1,194 @@
package controllers
import (
"encoding/json"
"net/http"
"net/http/cookiejar"
"net/http/httptest"
"net/url"
"strings"
"testing"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto/response"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/access"
"git.pcux.cn/xuans/Smail/services/credentials"
"git.pcux.cn/xuans/Smail/services/externalemail"
"git.pcux.cn/xuans/Smail/services/verification"
appcontext "git.pcux.cn/xuans/Smail/utils/context"
)
// 真实控制器约束对照:输错后绑定仍待验证,重新绑定失败,但原挑战可继续验证。
func TestAuditPendingExternalBindingRequiresExistingChallenge(t *testing.T) {
_, _, engine, user, _ := newPublicSecurityFixture(t)
previous := securityRuntime
t.Cleanup(func() { securityRuntime = previous })
vault := externalemail.NewVaultWithKeys([]byte("01234567890123456789012345678901"), []byte("abcdefabcdefabcdefabcdefabcdefab"))
repo, err := externalemail.NewRepository(engine, vault)
if err != nil {
t.Fatal(err)
}
store, err := verification.NewStore(32)
if err != nil {
t.Fatal(err)
}
var issued verification.Challenge
var deliveredCode string
service, err := verification.NewService(store, func(challenge verification.Challenge, code string) error {
issued, deliveredCode = challenge, code
return nil
}, nil)
if err != nil {
t.Fatal(err)
}
securityRuntime.external, securityRuntime.verification = repo, service
ctx := &appcontext.Context{UserID: user.ID, UserAccount: user.Account, Role: access.RoleUser, RecentAuth: true, Lang: "zhCn"}
invoke := func(handler func(*appcontext.Context, http.ResponseWriter, *http.Request), input any) response.Response {
t.Helper()
body, err := json.Marshal(input)
if err != nil {
t.Fatal(err)
}
recorder := httptest.NewRecorder()
request := httptest.NewRequest(http.MethodPost, "https://example.com/api/v1/security/external-email", strings.NewReader(string(body)))
request.RemoteAddr = "192.0.2.10:12345"
handler(ctx, recorder, request)
var result response.Response
if err := json.Unmarshal(recorder.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
return result
}
bind := map[string]any{"email": "binding@example.com", "type": "backup"}
if result := invoke(BindExternalEmail, bind); result.ErrorNo != 0 || issued.ID == "" || deliveredCode == "" {
t.Fatalf("首次绑定前置条件未成立: error=%d", result.ErrorNo)
}
check := map[string]any{"id": issued.ID, "binding_id": issued.ResourceID, "email": "binding@example.com", "code": "incorrect"}
wrong := invoke(VerifyExternalEmail, check)
if wrong.ErrorNo == 0 {
t.Fatal("错误验证码意外通过")
}
var stored models.ExternalEmail
if has, err := engine.ID(issued.ResourceID).Get(&stored); err != nil || !has || stored.Status != models.ExternalEmailStatusPending {
t.Fatalf("错误验证码后绑定状态异常: found=%v err=%v status=%s", has, err, stored.Status)
}
retry := invoke(BindExternalEmail, bind)
if retry.ErrorNo == 0 {
t.Fatal("重复绑定应被真实仓储拒绝,前端必须恢复原挑战")
}
check["code"] = deliveredCode
continued := invoke(VerifyExternalEmail, check)
if continued.ErrorNo != 0 {
t.Fatalf("原挑战正确验证码未通过: error=%d", continued.ErrorNo)
}
t.Logf("after_wrong_status=%s retry_bind_error=%d continued_verify_error=%d", stored.Status, retry.ErrorNo, continued.ErrorNo)
}
// 使用临时数据库和真实控制器,正向验证授权器允许的角色调整能够到达持久化。
func TestAuditAuthorizedRoleChangeMustSucceed(t *testing.T) {
_, _, engine, user, super := newPublicSecurityFixture(t)
previousDB, previousRuntime := db.Instance, securityRuntime
db.Instance = engine
t.Cleanup(func() {
db.Instance = previousDB
securityRuntime = previousRuntime
})
credentialService, err := credentials.NewService(engine)
if err != nil {
t.Fatal(err)
}
securityRuntime.credentials = credentialService
if _, err := credentialService.GenerateRecoveryCodes(user.ID, 5); err != nil {
t.Fatal(err)
}
request := access.Request{
ActorRole: access.RoleSuperAdmin, Capability: access.CapabilityRoleManage,
TargetRole: access.RoleUser, NewRole: access.RoleAdmin,
RecentAuth: true, TargetRecoveryConfigured: true,
}
if err := access.Authorize(request); err != nil {
t.Fatalf("角色变更授权前置条件未成立: %v", err)
}
ctx := &appcontext.Context{
UserID: super.ID, UserAccount: super.Account, Role: access.RoleSuperAdmin,
RecentAuth: true, Lang: "zhCn",
}
result := editUserRequest(t, ctx, `{"id":`+itoa(user.ID)+`,"role":"admin","disabled":0}`)
var stored models.User
if found, err := engine.ID(user.ID).Get(&stored); err != nil || !found {
t.Fatalf("读取目标角色失败: found=%v err=%v", found, err)
}
t.Logf("policy_allows=true controller_error=%d stored_role=%s", result, stored.EffectiveRole())
if result != 0 || stored.EffectiveRole() != access.RoleAdmin {
t.Fatal("符合近期认证和目标恢复码条件的超级管理员仍无法修改用户角色")
}
}
// 使用真实 TLS HTTP 客户端及标准 CookieJar 检查浏览器同样遵循的 Path 匹配。
// 只核对 Cookie 是否随请求携带,不把隔离发送器当成真实邮件投递验收。
func TestAuditRecoveryCookieMustReachVersionedAPI(t *testing.T) {
for _, prefix := range []string{"/api/security/recovery", "/api/v1/security/recovery"} {
t.Run(prefix, func(t *testing.T) {
enablePublicRecoveryForTest(t)
recover, _, _, _, _ := newPublicSecurityFixture(t)
previous := securityRuntime
securityRuntime.recovery = recover
t.Cleanup(func() { securityRuntime = previous })
server := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if strings.HasSuffix(r.URL.Path, "/begin") {
BeginPasswordRecovery(&appcontext.Context{}, w, r)
return
}
_, ok := recoveryBrowserContext(r, w, false)
_ = json.NewEncoder(w).Encode(map[string]bool{"context_received": ok})
}))
defer server.Close()
client := server.Client()
jar, err := cookiejar.New(nil)
if err != nil {
t.Fatal(err)
}
client.Jar = jar
begin, err := client.Post(server.URL+prefix+"/begin", "application/json", strings.NewReader(`{"identifier":"alice","email":"alice@example.com"}`))
if err != nil {
t.Fatal(err)
}
var result response.Response
err = json.NewDecoder(begin.Body).Decode(&result)
_ = begin.Body.Close()
if err != nil || result.ErrorNo != 0 {
t.Fatalf("恢复申请前置条件失败: code=%d err=%v", result.ErrorNo, err)
}
cookiePath := ""
for _, cookie := range begin.Cookies() {
if cookie.Name == recoveryContextCookieName {
cookiePath = cookie.Path
}
}
if cookiePath == "" {
t.Fatal("恢复申请没有签发浏览器上下文 Cookie")
}
target, err := url.Parse(server.URL + prefix + "/verify")
if err != nil {
t.Fatal(err)
}
verify, err := client.Get(target.String())
if err != nil {
t.Fatal(err)
}
var received struct {
ContextReceived bool `json:"context_received"`
}
err = json.NewDecoder(verify.Body).Decode(&received)
_ = verify.Body.Close()
if err != nil {
t.Fatal(err)
}
t.Logf("request_prefix=%s cookie_path=%s sent_cookie_count=%d context_received=%v", prefix, cookiePath, len(jar.Cookies(target)), received.ContextReceived)
if !received.ContextReceived {
t.Fatal("恢复上下文 Cookie 的路径不覆盖前端使用的版本化接口,后续验证无法获取上下文")
}
})
}
}

61
test/review/coverage.mjs Normal file
View File

@ -0,0 +1,61 @@
import { execFileSync } from 'node:child_process'
import { readFile, mkdir, writeFile } from 'node:fs/promises'
import { createHash } from 'node:crypto'
import { fileURLToPath } from 'node:url'
import path from 'node:path'
const root = fileURLToPath(new URL('../../', import.meta.url))
const git = args => execFileSync('git', args, { cwd: root, encoding: 'utf8', windowsHide: true }).trim()
const head = git(['rev-parse', 'HEAD'])
const records = JSON.parse(await readFile(new URL('./reviewed-ranges.json', import.meta.url), 'utf8'))
if (head !== records.baseline) throw new Error('审查基线已改变,需要先复核覆盖记录')
const files = git(['ls-files', '-z']).split('\0').filter(Boolean)
const trackedFiles = new Set(files)
for (const name of Object.keys(records.files)) {
if (!trackedFiles.has(name)) throw new Error(`审查记录路径不在 Git 清单中,请核对大小写: ${name}`)
}
const directory = path.join(root, 'test-log', `coverage-${new Date().toISOString().replace(/[:.]/g, '-')}`)
await mkdir(directory, { recursive: true })
const rows = []
for (const name of files) {
const bytes = await readFile(path.join(root, name))
let text = null
try { text = new TextDecoder('utf-8', { fatal: true }).decode(bytes) } catch {}
if (bytes.includes(0)) text = null
const lines = text === null ? 0 : text.length ? text.split('\n').length - Number(text.endsWith('\n')) : 0
const extension = path.extname(name).toLowerCase()
let category = 'configuration'
if (text === null) category = 'binary'
else if (/(^|\/)(package-lock\.json|pnpm-lock\.yaml|yarn\.lock|go\.sum)$/.test(name)) category = 'dependency-lock'
else if (/\.min\.|\/static\/|\/lib\/|\/nuisance\/|\.csv$/.test(name)) category = 'vendor-or-data'
else if (/\.md$|LICENSE/.test(name)) category = 'documentation'
else if (/\.(svg|gif|png|jpg|ico|txt)$/.test(name)) category = 'asset-or-data'
else if (name.startsWith('test/') || /_test\.go$|\.test\./.test(name)) category = 'test'
else if (['.go', '.js', '.mjs', '.cjs', '.vue', '.css', '.html', '.sh', '.ps1', '.bat', '.ts'].includes(extension)) category = 'source'
const review = records.files[name]
const ranges = review?.ranges?.map(([first, last]) => [first, last === 'EOF' ? lines : last]) || []
const covered = new Set()
for (const [first, last] of ranges) {
if (first < 1 || last > lines || first > last) throw new Error(`无效覆盖行范围: ${name}`)
for (let line = first; line <= last; line++) covered.add(line)
}
rows.push({
path: name, category, lines, sha256: createHash('sha256').update(bytes).digest('hex'),
status: covered.size === 0 ? 'not-recorded' : covered.size === lines ? 'read-not-accepted' : 'partial-read',
readLines: covered.size, ranges, evidence: review?.evidence || '', findings: review?.findings || []
})
}
const summary = {
baseline: head, generatedAt: new Date().toISOString(), files: rows.length,
textLines: rows.reduce((sum, row) => sum + row.lines, 0),
recordedReadLines: rows.reduce((sum, row) => sum + row.readLines, 0),
recordedFullReads: rows.filter(row => row.status === 'read-not-accepted').length,
recordedPartialReads: rows.filter(row => row.status === 'partial-read').length,
notRecorded: rows.filter(row => row.status === 'not-recorded').length,
categories: Object.fromEntries([...new Set(rows.map(row => row.category))].map(category => [category, {
files: rows.filter(row => row.category === category).length,
lines: rows.filter(row => row.category === category).reduce((sum, row) => sum + row.lines, 0)
}]))
}
await writeFile(path.join(directory, 'inventory.json'), JSON.stringify({ summary, rows }, null, 2) + '\n')
console.log(JSON.stringify({ directory: path.relative(root, directory), ...summary }, null, 2))

View File

@ -0,0 +1,151 @@
package dbmigration
import (
"context"
"errors"
"testing"
"time"
"git.pcux.cn/xuans/Smail/config"
)
// 审查专用:只使用临时数据库,不连接正在运行的服务。
func TestAuditCustomUniqueIndexMustNotDisappear(t *testing.T) {
root, source := portableFixture(t)
switched := false
executor := &PortableExecutor{
root: root,
switchConfig: func(context.Context, uint64, config.DatabaseConfig, config.AuditActor) error {
switched = true
return nil
},
}
defer executor.Close()
database, err := executor.connect(context.Background(), source)
if err != nil {
t.Fatal(err)
}
if _, err := database.Exec(`CREATE UNIQUE INDEX audit_unique_user_name ON "user"(name)`); err != nil {
_ = database.Close()
t.Fatal(err)
}
_ = database.Close()
plan, err := buildTargetPlan(source, config.DatabaseConfig{Type: config.DatabaseTypeSQLite, LocalRef: "target.db"})
if err != nil {
t.Fatal(err)
}
err = executor.Run(context.Background(), plan, func(Status) error { return nil })
if errors.Is(err, ErrSQLUnsupportedObject) && !switched {
return
}
if err != nil {
t.Fatal(err)
}
target, err := executor.connect(context.Background(), plan.targetConfig)
if err != nil {
t.Fatal(err)
}
defer target.Close()
var count int
if err := target.QueryRow(`SELECT COUNT(*) FROM sqlite_master WHERE type='index' AND name='audit_unique_user_name'`).Scan(&count); err != nil {
t.Fatal(err)
}
_, duplicateErr := target.Exec(`INSERT INTO "user" (account,name,password) SELECT 'audit-duplicate',name,'hash' FROM "user" LIMIT 1`)
t.Logf("switched=%v custom_index_count=%d duplicate_insert_error=%v", switched, count, duplicateErr)
if count == 0 || duplicateErr == nil {
t.Fatal("迁移成功切库,但自定义唯一索引丢失且重复数据能够写入")
}
}
func TestAuditRequestDrainMustRespectCancellation(t *testing.T) {
service := NewService(nil)
service.requests.RLock()
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Millisecond)
defer cancel()
done := make(chan struct{})
go func() {
release := service.drainRequests(ctx)
release()
close(done)
}()
select {
case <-done:
service.requests.RUnlock()
case <-time.After(200 * time.Millisecond):
service.requests.RUnlock()
<-done
t.Fatalf("请求上下文已结束,但排空仍等待在途请求释放锁: %v", ctx.Err())
}
}
func TestAuditMigrationMustPreserveAllocatedMailboxUIDs(t *testing.T) {
root, source := portableFixture(t)
switched := false
executor := &PortableExecutor{
root: root,
switchConfig: func(context.Context, uint64, config.DatabaseConfig, config.AuditActor) error {
switched = true
return nil
},
}
defer executor.Close()
database, err := executor.connect(context.Background(), source)
if err != nil {
t.Fatal(err)
}
// 正常分配两次关系 ID,再模拟清除最后一封邮件;不手工修改序列表。
var allocated int64
for range 2 {
result, err := database.Exec(`INSERT INTO user_email (user_id,email_id) VALUES (40,82)`)
if err != nil {
_ = database.Close()
t.Fatal(err)
}
allocated, err = result.LastInsertId()
if err != nil {
_ = database.Close()
t.Fatal(err)
}
}
if _, err := database.Exec(`DELETE FROM user_email WHERE id=?`, allocated); err != nil {
_ = database.Close()
t.Fatal(err)
}
var sourceSequence int64
if err := database.QueryRow(`SELECT seq FROM sqlite_sequence WHERE name='user_email'`).Scan(&sourceSequence); err != nil {
_ = database.Close()
t.Fatal(err)
}
_ = database.Close()
plan, err := buildTargetPlan(source, config.DatabaseConfig{Type: config.DatabaseTypeSQLite, LocalRef: "target.db"})
if err != nil {
t.Fatal(err)
}
if err := executor.Run(context.Background(), plan, func(Status) error { return nil }); err != nil {
t.Fatal(err)
}
target, err := executor.connect(context.Background(), plan.targetConfig)
if err != nil {
t.Fatal(err)
}
defer target.Close()
var targetSequence int64
if err := target.QueryRow(`SELECT seq FROM sqlite_sequence WHERE name='user_email'`).Scan(&targetSequence); err != nil {
t.Fatal(err)
}
result, err := target.Exec(`INSERT INTO user_email (user_id,email_id) VALUES (40,82)`)
if err != nil {
t.Fatal(err)
}
next, err := result.LastInsertId()
if err != nil {
t.Fatal(err)
}
t.Logf("switched=%v removed_uid=%d source_sequence=%d target_sequence=%d newly_allocated_uid=%d", switched, allocated, sourceSequence, targetSequence, next)
if !switched || sourceSequence < allocated {
t.Fatal("迁移或源库序列前提未成立")
}
if next <= allocated {
t.Fatal("迁移丢失已分配序号的高水位,新关系复用已删除邮件的 UID")
}
}

View File

@ -0,0 +1,170 @@
package http_server
import (
"encoding/json"
"net/http"
"net/http/cookiejar"
"net/http/httptest"
"path/filepath"
"strings"
"testing"
"time"
"git.pcux.cn/xuans/Smail/config"
"git.pcux.cn/xuans/Smail/controllers"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto/response"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/auth"
"git.pcux.cn/xuans/Smail/services/externalemail"
"git.pcux.cn/xuans/Smail/services/verification"
"git.pcux.cn/xuans/Smail/session"
"git.pcux.cn/xuans/Smail/utils/csrf"
"github.com/alexedwards/scs/v2"
"xorm.io/xorm"
)
type auditExternalHTTPFixture struct {
engine *xorm.Engine
user models.User
repository *externalemail.Repository
server *httptest.Server
client *http.Client
csrfToken string
issued verification.Challenge
deliveredCode string
}
// 仅测试专用入口签发真实会话;被审查的路由、会话中间件、CSRF 和数据库均不替换。
func newAuditExternalHTTPFixture(t *testing.T, age time.Duration) *auditExternalHTTPFixture {
t.Helper()
oldConfig, oldInit, oldDevelopment := config.Instance, config.IsInit, config.DevelopmentMode
oldDB, oldSession, oldManager := db.Instance, session.Instance, config.CurrentManager()
engine, err := xorm.NewEngine("sqlite", filepath.Join(t.TempDir(), "external-http.db"))
if err != nil { t.Fatal(err) }
t.Cleanup(func() {
controllers.ConfigureSecurityRuntime(nil, nil, nil, nil)
config.Instance, config.DevelopmentMode = oldConfig, oldDevelopment
config.SetInitState(oldInit)
config.SetRuntimeManager(oldManager)
db.Instance, session.Instance = oldDB, oldSession
_ = engine.Close()
})
for _, model := range []any{&models.User{}, &models.UserEmail{}, &models.Email{}, &models.ExternalEmail{}, &models.RecoveryCode{}} {
if err := engine.Sync2(model); err != nil { t.Fatal(err) }
}
fixture := &auditExternalHTTPFixture{engine: engine, user: models.User{
Account: "audit-user", Name: "Audit", Role: "user", SessionVersion: 1, SecurityVersion: 1,
}}
if _, err := engine.Insert(&fixture.user); err != nil { t.Fatal(err) }
config.SetRuntimeManager(nil)
config.Instance = &config.Config{Domain: "mail.example.test", WebDomain: "127.0.0.1"}
config.DevelopmentMode = false
config.SetInitState(true)
db.Instance = engine
session.Instance = scs.New()
session.Instance.Cookie.Secure = true
vault := externalemail.NewVaultWithKeys([]byte("01234567890123456789012345678901"), []byte("abcdefabcdefabcdefabcdefabcdefab"))
fixture.repository, err = externalemail.NewRepository(engine, vault)
if err != nil { t.Fatal(err) }
store, err := verification.NewStore(32)
if err != nil { t.Fatal(err) }
service, err := verification.NewService(store, func(challenge verification.Challenge, code string) error {
fixture.issued, fixture.deliveredCode = challenge, code
return nil
}, nil)
if err != nil { t.Fatal(err) }
controllers.ConfigureSecurityRuntime(service, fixture.repository, nil, nil)
mux := http.NewServeMux()
if err := router(mux); err != nil {
t.Fatal(err)
}
mux.HandleFunc("/audit/session", func(w http.ResponseWriter, r *http.Request) {
if err := session.PutUser(r.Context(), &fixture.user); err != nil { http.Error(w, "session", 500); return }
identity, err := session.GetUser(r.Context())
if err != nil { http.Error(w, "identity", 500); return }
identity.AuthenticatedAt = time.Now().Add(-age).Unix()
encoded, err := json.Marshal(identity)
if err != nil { http.Error(w, "encoding", 500); return }
session.Instance.Put(r.Context(), "user", string(encoded))
token, err := csrf.Issue(w, r, true)
if err != nil { http.Error(w, "csrf", 500); return }
_ = json.NewEncoder(w).Encode(map[string]any{"token": token, "recent": identity.HasRecentAuthentication(time.Now())})
})
fixture.server = httptest.NewTLSServer(session.Instance.LoadAndSave(mux))
t.Cleanup(fixture.server.Close)
fixture.client = fixture.server.Client()
fixture.client.Jar, err = cookiejar.New(nil)
if err != nil { t.Fatal(err) }
seed, err := fixture.client.Get(fixture.server.URL + "/audit/session")
if err != nil { t.Fatal(err) }
defer seed.Body.Close()
var seeded struct { Token string `json:"token"`; Recent bool `json:"recent"` }
if err := json.NewDecoder(seed.Body).Decode(&seeded); err != nil { t.Fatal(err) }
if seeded.Recent != (age < 10*time.Minute) || seeded.Token == "" { t.Fatal("会话近期认证前置条件不符") }
fixture.csrfToken = seeded.Token
return fixture
}
func (fixture *auditExternalHTTPFixture) post(t *testing.T, path string, input any, withCSRF bool) response.Response {
t.Helper()
body, err := json.Marshal(input)
if err != nil { t.Fatal(err) }
request, err := http.NewRequest(http.MethodPost, fixture.server.URL+path, strings.NewReader(string(body)))
if err != nil { t.Fatal(err) }
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Origin", fixture.server.URL)
if withCSRF { request.Header.Set(csrf.HeaderName, fixture.csrfToken) }
result, err := fixture.client.Do(request)
if err != nil { t.Fatal(err) }
defer result.Body.Close()
var decoded response.Response
if err := json.NewDecoder(result.Body).Decode(&decoded); err != nil { t.Fatal(err) }
return decoded
}
// 近期会话为正向对照,过期近期认证的会话仍登录有效,但不应能新增恢复凭据。
func TestAuditExternalBindingMustRequireRecentAuthentication(t *testing.T) {
for _, age := range []time.Duration{time.Minute, 11*time.Minute} {
t.Run(age.String(), func(t *testing.T) {
fixture := newAuditExternalHTTPFixture(t, age)
input := map[string]any{"email": "external@example.com", "type": "primary"}
blocked := fixture.post(t, "/api/v1/security/external-email/bind", input, false)
if blocked.ErrorNo == 0 || fixture.issued.ID != "" { t.Fatal("缺少 CSRF 的对照请求未被拒绝") }
bound := fixture.post(t, "/api/v1/security/external-email/bind", input, true)
if bound.ErrorNo != 0 {
if age < 10*time.Minute { t.Fatalf("近期会话绑定对照失败: %d", bound.ErrorNo) }
return
}
if fixture.issued.ID == "" || fixture.deliveredCode == "" { t.Fatal("成功绑定未签发挑战") }
verified := fixture.post(t, "/api/v1/security/external-email/verify", map[string]any{
"id": fixture.issued.ID, "binding_id": fixture.issued.ResourceID,
"email": input["email"], "code": fixture.deliveredCode,
}, true)
stored, err := fixture.repository.FindVerifiedPrimaryByUser(fixture.user.ID)
t.Logf("session_age=%s missing_csrf_error=%d bind_error=%d verify_error=%d verified_binding=%v", age, blocked.ErrorNo, bound.ErrorNo, verified.ErrorNo, err == nil && stored != nil)
if verified.ErrorNo != 0 || err != nil { t.Fatal("绑定成功后的验证前置条件未成立") }
if age >= 10*time.Minute { t.Fatal("已失去近期认证的会话仍能添加并验证外部安全邮箱") }
})
}
}
// 真实主邮箱绑定可被认证解析,不能再被当作独立的外部邮箱绑定和验证。
func TestAuditExternalBindingMustRejectOwnPrimaryMailbox(t *testing.T) {
fixture := newAuditExternalHTTPFixture(t, time.Minute)
address, now := fixture.user.Account+"@mail.example.test", time.Now().UTC()
primary := &models.UserEmail{UserID: fixture.user.ID, Address: address, AddressCanonical: &address, IsPrimary: 1, VerifiedAt: &now}
if _, err := fixture.engine.Insert(primary); err != nil { t.Fatal(err) }
identity, err := auth.ResolveIdentifier(address)
if err != nil || identity.UserID != fixture.user.ID { t.Fatal("主邮箱真实身份解析前置条件未成立") }
bound := fixture.post(t, "/api/v1/security/external-email/bind", map[string]any{"email": address, "type": "primary"}, true)
if bound.ErrorNo != 0 { return }
verified := fixture.post(t, "/api/v1/security/external-email/verify", map[string]any{
"id": fixture.issued.ID, "binding_id": fixture.issued.ResourceID,
"email": address, "code": fixture.deliveredCode,
}, true)
stored, err := fixture.repository.FindVerifiedPrimaryByUser(fixture.user.ID)
t.Logf("primary_identity_resolved=true sent_to_own_mailbox=%v bind_error=%d verify_error=%d verified_primary_external=%v", fixture.issued.Email == address, bound.ErrorNo, verified.ErrorNo, err == nil && stored != nil)
if err != nil || verified.ErrorNo != 0 { t.Fatal("自身邮箱绑定成功但验证前置条件未成立") }
t.Fatal("已确认的 Smail 主邮箱仍可绑定为主要外部邮箱,验证码发往同一邮箱")
}

View File

@ -0,0 +1,282 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import { readFileSync } from 'node:fs'
import { compileFunction } from 'node:vm'
import { createRequire } from 'node:module'
import { readFormConfig, updateFormConfig, validateFormConfig } from '../../frontend/src/views/components/ConfigSettings/ConfigForm/ConfigForm.js'
const require = createRequire(new URL('../../frontend/package.json', import.meta.url))
const Vue = require('vue')
const { parse, compileScript } = require('@vue/compiler-sfc')
const read = name => readFileSync(new URL(`../../frontend/${name}`, import.meta.url), 'utf8')
test('邮件列表挂载后,表格选中项必须用于全选和批量操作', async () => {
const source = read('src/views/List/List.js').replace(/^import .*$/gm, '')
.replace('export function usePage', 'function usePage').replace(/export \{[^}]+\}\s*$/, '')
const icons = ['CircleCheck', 'Switch', 'Delete', 'View', 'Folder', 'EpArrowDownBold', 'EditPen', 'Warning']
const messages = []
const requests = []
const rows = [{ id: 1 }, { id: 2 }]
const transport = {
post: async url => {
requests.push(url)
return { errorNo: 0, data: { list: rows, total_page: 1 } }
},
get: async () => ({ errorNo: 0, data: [] })
}
const usePage = compileFunction(source + '\nreturn usePage', [
'Vue', 'ref', 'watch', 'useRouter', 'useGroupStore', 'lang', 'http', 'ElMessage', 'ElMessageBox', ...icons
])(
Vue, Vue.ref, Vue.watch, () => ({ push() {} }), () => Vue.reactive({ tag: '', name: '收件箱' }), {}, transport,
{ warning: value => messages.push(value), success() {}, error() {} }, { confirm: async () => true },
...icons.map(() => ({}))
)
let page
let table
let cleared = 0
let toggled = 0
const { descriptor, errors } = parse(read('src/views/List/List.vue'))
assert.deepEqual(errors, [])
const compiled = compileScript(descriptor, { id: 'audit-list', inlineTemplate: true })
const script = compiled.content
.replace(/import \{([^}]+)\} from ["']vue["']/g, (_, fields) => `const {${fields.replace(/\bas\b/g, ':')}} = Vue`)
.replace(/^import .*$/gm, '').replace('export default', 'return')
const component = compileFunction(script, ['Vue', 'usePage', ...icons])(
Vue, () => { page = usePage(); return page }, ...icons.map(() => ({}))
)
const tableComponent = {
props: ['data'],
emits: ['selection-change'],
setup(props, { expose, emit }) {
let selection = []
table = {
getSelectionRows: () => selection,
clearSelection: () => { cleared++; selection = []; emit('selection-change', selection) },
toggleRowSelection: (row, selected) => {
toggled++
selection = selection.filter(item => item.id !== row.id)
if (selected) selection.push(row)
emit('selection-change', selection)
},
selectRow: row => { selection = [row]; emit('selection-change', selection) }
}
expose(table)
return () => Vue.h('audit-table')
}
}
const node = type => ({ type, children: [] })
const renderer = Vue.createRenderer({
createElement: node, createText: text => ({ ...node('text'), text }), createComment: node,
setText: (item, text) => { item.text = text }, setElementText: (item, text) => { item.text = text },
parentNode: item => item.parent, nextSibling: () => null, remove() {},
insert: (item, parent) => { item.parent = parent; parent.children.push(item) },
patchProp: (item, key, previous, value) => { item[key] = value }
})
const app = renderer.createApp(component)
app.component('ElTable', tableComponent)
app.config.warnHandler = () => {}
app.mount(node('root'))
try {
await Vue.nextTick()
assert.ok(table)
table.selectRow(rows[0])
assert.equal(page.selectedRows.value.length, 1)
requests.length = 0
page.selectAll()
page.invertSelection()
page.markRead()
page.move(0, '归档')
page.del()
await Promise.resolve()
await Promise.resolve()
const actual = { connected: !!page.taskTableDataRef.value, cleared, toggled, requests: [...requests], warnings: [...messages] }
console.log(`list_actual=${JSON.stringify(actual)}`)
// 只在测试内连接缺失引用,证明操作函数和模拟表格本身可用,不修改页面源码。
page.taskTableDataRef.value = table
page.selectAll()
page.markRead()
page.move(0, '归档')
page.del()
await Promise.resolve()
await Promise.resolve()
assert.equal(cleared, 1)
assert.equal(toggled, 2)
for (const action of ['read', 'move', 'del']) assert.ok(requests.includes(`/api/v1/email/${action}`))
console.log('list_reference_control=true batch_requests_control=true')
assert.equal(actual.connected, true, '真实模板必须连接组合函数返回的表格引用')
assert.equal(actual.cleared, 1)
assert.equal(actual.requests.filter(url => !url.endsWith('/list')).length, 3)
} finally {
app.unmount()
}
})
// 后端约束由 TestAuditPendingConfigBlocksFurtherUpdates 使用真实 manager 单独验证。
for (const action of ['edit', 'refresh']) {
test(`保存候选配置后 ${action} 不应让页面失去继续保存或应用的入口`, async () => {
const source = read('src/views/components/ConfigSettings/ConfigSettings.js')
.replace(/^import .*$/gm, '').replace('export function usePage', 'function usePage')
const initial = { generation: 1, policy: { smtpPort: 25, imapPort: 993, pop3Port: 995, maxMessageBytes: 0 } }
let pending = false
let applied = false
const errors = []
const transport = {
get: async url => ({ errorNo: 0, data: url.endsWith('/status') ? { activeGeneration: 1, setupState: 'ready' } : initial }),
put: async () => {
if (pending) return { errorNo: 409, errorMsg: '配置代次冲突' }
pending = true
return { errorNo: 0, data: { generation: 2, pending: true } }
},
post: async url => {
assert.ok(url.endsWith('/apply'))
applied = true
return { errorNo: 0, data: { generation: 2 } }
}
}
const page = compileFunction(source + '\nreturn usePage("email")', [
'computed', 'onMounted', 'onBeforeUnmount', 'reactive', 'ref', 'ElMessage', 'ElMessageBox',
'http', 'useGlobalStatusStore', 'readFormConfig', 'updateFormConfig', 'validateFormConfig'
])(
Vue.computed, () => {}, () => {}, Vue.reactive, Vue.ref,
{ success() {}, warning() {}, error: message => errors.push(message) }, { confirm: async () => true },
transport, () => ({ hasCapability: () => true }), readFormConfig, updateFormConfig, validateFormConfig
)
await page.loadAll()
page.updateField(['policy', 'maxMessageBytes'], 8 << 20)
await page.saveConfig()
assert.equal(page.savedGeneration.value, 2)
assert.deepEqual(errors, [])
if (action === 'edit') page.updateField(['policy', 'maxMessageBytes'], 16 << 20)
else await page.refreshPage()
await page.saveConfig()
await page.applyConfig()
console.log(`action=${action} server_pending=${pending} saved_generation=${page.savedGeneration.value} apply_requested=${applied} errors=${JSON.stringify(errors)}`)
assert.equal(applied, true, '页面必须保留恢复或取消候选配置的可用路径,而不是保存冲突且应用不发请求')
})
}
// 使用真实响应拦截器和页面函数;仅隔离网络、消息提示以及下载所需的浏览器对象。
test('外部邮箱验证码输入错误后必须能够再次输入,而不是重新绑定同一地址', async () => {
const source = read('src/views/components/SecuritySettings/SecuritySettings.js')
.replace(/^import .*$/gm, '').replace('export function usePage', 'function usePage')
let bound = false
let prompts = 0
let verifies = 0
const notifications = []
const page = compileFunction(source + '\nreturn usePage()', [
'computed', 'onMounted', 'reactive', 'ref', 'watch', 'ElMessageBox', 'ElNotification',
'lang', 'http', 'useGlobalStatusStore', 'webAuthnSupported'
])(
Vue.computed, () => {}, Vue.reactive, Vue.ref, () => {},
{ prompt: async () => { prompts++; return { value: prompts === 1 ? 'incorrect' : 'correct' } } },
notification => notifications.push(notification.message), {},
{ post: async url => {
if (url.endsWith('/bind')) {
if (bound) return { errorNo: 400, errorMsg: '外部邮箱绑定失败' }
bound = true
return { errorNo: 0, data: { id: 1, challenge_id: 'audit-binding', email: 'b***@example.com' } }
}
assert.ok(url.endsWith('/verify'))
verifies++
return verifies === 1 ? { errorNo: 400, errorMsg: '验证失败' } : { errorNo: 0 }
} },
() => ({ role: 'user', userInfos: {}, securityActiveSection: 'external-email' }), () => false
)
page.bindForm.email = 'binding@example.com'
await page.bindExternalEmail()
assert.equal(prompts, 1)
assert.equal(verifies, 1)
await page.bindExternalEmail()
console.log(`binding_pending=${bound} prompt_count=${prompts} verify_count=${verifies} notifications=${JSON.stringify(notifications)}`)
assert.equal(prompts, 2, '验证码首次输入错误后应允许重试验证现有绑定')
})
// 使用真实响应拦截器和页面函数;仅隔离网络、消息提示以及下载所需的浏览器对象。
test('审计导出必须保存服务端返回的 Blob 内容', async () => {
let interceptor
const transport = { interceptors: { response: { use: success => { interceptor = success } } } }
const axiosSource = read('src/utils/axios.js')
.replace(/^import .*$/gm, '')
.replace('import.meta.env.VITE_APP_URL', 'undefined')
.replace('export {http};', '')
compileFunction(axiosSource, ['axios', 'lang', 'router', 'createLoginRedirectHandler'])(
{ create: () => transport }, { lang: 'zhCn' }, {}, () => () => {}
)
assert.equal(typeof interceptor, 'function')
const source = read('src/views/components/ConfigSettings/ConfigSettings.js')
.replace(/^import .*$/gm, '').replace('export function usePage', 'function usePage')
const results = []
for (const format of ['csv', 'json']) {
const payload = format === 'csv' ? 'id,operation\n1,update\n' : '[{"id":1,"operation":"update"}]'
let downloaded
let clicked = false
const errors = []
const page = compileFunction(source + '\nreturn usePage("audit")', [
'computed', 'onMounted', 'onBeforeUnmount', 'reactive', 'ref', 'ElMessage', 'ElMessageBox',
'http', 'useGlobalStatusStore', 'readFormConfig', 'updateFormConfig', 'validateFormConfig', 'URL', 'document'
])(
Vue.computed, () => {}, () => {}, Vue.reactive, Vue.ref,
{ success() {}, error: message => errors.push(message) }, {},
{ post: async (url, body, config) => {
assert.equal(url, '/api/v1/audits/config')
assert.equal(config.responseType, 'blob')
assert.equal(body.format, format)
return interceptor({ data: new Blob([payload]), config: { url } })
} },
() => ({ hasCapability: () => true }), () => ({}), () => '', () => ({}),
{ createObjectURL: blob => { downloaded = blob; return 'blob:audit' }, revokeObjectURL() {} },
{ createElement: () => ({ click: () => { clicked = true } }) }
)
await page.exportAudit(format)
assert.deepEqual(errors, [])
assert.equal(clicked, true)
assert.ok(downloaded instanceof Blob)
const actual = await downloaded.text()
console.log(`format=${format} downloaded=${JSON.stringify(actual)}`)
results.push({ format, actual, payload })
}
for (const { actual, payload } of results) assert.equal(actual, payload, '下载文件必须保留真实审计记录,而不是 undefined')
})
// 挂载真实 SFC 的编译结果和真实组合函数,使用 Vue 自定义渲染器代替浏览器 DOM。
test('写信页挂载后,附件按钮必须连接到文件输入框', async () => {
const source = read('src/views/Editer/Editer.js').replace(/^import .*$/gm, '')
.replace('export function usePage', 'function usePage').replace(/export \{[^}]+\}\s*$/, '')
const names = ['onBeforeUnmount', 'reactive', 'ref', 'shallowRef', 'ElMessage', 'Close', 'Paperclip',
'Position', 'ArrowDown', 'Document', 'lang', 'Editor', 'Toolbar', 'i18nChangeLanguage', 'useRouter',
'http', 'useGroupStore', 'useGlobalStatusStore', 'MouseEvent']
const values = [Vue.onBeforeUnmount, Vue.reactive, Vue.ref, Vue.shallowRef, {}, {}, {}, {}, {}, {},
{ lang: 'zhCn' }, {}, {}, () => {}, () => ({}), {}, () => ({}),
() => ({ userInfos: { account: 'audit', name: 'audit', domains: ['example.test'], is_admin: false } }),
class { constructor(type) { this.type = type } }]
const usePage = compileFunction(source + '\nreturn usePage', names)(...values)
let page
const { descriptor, errors } = parse(read('src/views/Editer/Editer.vue'))
assert.deepEqual(errors, [])
const compiled = compileScript(descriptor, { id: 'audit-editor', inlineTemplate: true })
const script = compiled.content
.replace(/import \{([^}]+)\} from ["']vue["']/g, (_, fields) => `const {${fields.replace(/\bas\b/g, ':')}} = Vue`)
.replace(/^import .*$/gm, '').replace('export default', 'return')
const component = compileFunction(script, ['Vue', 'usePage', 'Paperclip', 'Position', 'ArrowDown', 'Toolbar', 'Editor', 'Document', 'Close'])(
Vue, () => { page = usePage(); return page }, {}, {}, {}, {}, {}, {}, {}
)
const node = type => ({ type, style: {}, children: [], dispatchEvent(event) { this.lastEvent = event.type; return true } })
const renderer = Vue.createRenderer({
createElement: node, createText: text => ({ ...node('text'), text }), createComment: node,
setText: (item, text) => { item.text = text }, setElementText: (item, text) => { item.text = text },
parentNode: item => item.parent, nextSibling: () => null, remove() {},
insert: (item, parent) => { item.parent = parent; parent.children.push(item) },
patchProp: (item, key, previous, value) => { item[key] = value }
})
const app = renderer.createApp(component)
app.config.warnHandler = () => {}
app.mount(node('root'))
try {
await Vue.nextTick()
console.log(`template_file_ref_connected=${!!page.fileRef.value}`)
assert.doesNotThrow(() => page.upload(), '挂载后点击添加附件不应抛出异常')
assert.equal(page.fileRef.value?.lastEvent, 'click')
} finally {
app.unmount()
}
})

View File

@ -0,0 +1,44 @@
package http_server
import (
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"git.pcux.cn/xuans/Smail/config"
"git.pcux.cn/xuans/Smail/dto/response"
"git.pcux.cn/xuans/Smail/session"
"github.com/alexedwards/scs/v2"
)
// 审查专用:使用内存会话和真实路由,不发送验证码。
func TestAuditAnonymousLoginResendMustReachController(t *testing.T) {
previousConfig, previousInit := config.Instance, config.IsInit
previousSession, previousManager := session.Instance, config.CurrentManager()
t.Cleanup(func() {
config.Instance = previousConfig
config.SetInitState(previousInit)
session.Instance = previousSession
config.SetRuntimeManager(previousManager)
})
config.SetRuntimeManager(nil)
config.Instance = &config.Config{Domain: "localhost"}
config.SetInitState(true)
session.Instance = scs.New()
mux := http.NewServeMux()
registerV1Routes(mux)
request := httptest.NewRequest(http.MethodPost, "https://localhost/api/v1/security/login/resend", strings.NewReader(`{"id":"audit-invalid","account":"audit"}`))
request.Header.Set("Content-Type", "application/json")
recorder := httptest.NewRecorder()
session.Instance.LoadAndSave(mux).ServeHTTP(recorder, request)
var result response.Response
if err := json.Unmarshal(recorder.Body.Bytes(), &result); err != nil {
t.Fatal(err)
}
t.Logf("HTTP=%d body=%s", recorder.Code, recorder.Body.String())
if result.ErrorNo == response.NeedLogin {
t.Fatal("尚未完成二次验证的用户无法调用验证码重发接口")
}
}

View File

@ -0,0 +1,266 @@
package imap_server
import (
"testing"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/group"
"git.pcux.cn/xuans/Smail/services/list"
"git.pcux.cn/xuans/Smail/utils/context"
"github.com/emersion/go-imap/v2"
)
// 使用现有 TestMain 创建的临时 SQLite 和随机本地 TLS 端口,不连接开发服务。
func TestAuditCopyThenMoveMustKeepMailboxIdentity(t *testing.T) {
var user models.User
if found, err := db.Instance.Where("account=?", "testCase").Get(&user); err != nil || !found {
t.Fatalf("临时测试账户不可用: found=%v err=%v", found, err)
}
message := models.Email{Subject: "audit-copy-move"}
if _, err := db.Instance.Insert(&message); err != nil {
t.Fatal(err)
}
relation := models.UserEmail{UserID: user.ID, EmailID: message.Id, Status: 0}
if _, err := db.Instance.Insert(&relation); err != nil {
t.Fatal(err)
}
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
t.Fatal(err)
}
uid := imap.UIDSetNum(imap.UID(relation.ID))
if _, err := clientLogin.Copy(uid, "Junk").Wait(); err != nil {
t.Fatalf("复制前置条件失败: %v", err)
}
count, err := db.Instance.Where("user_id=? AND email_id=?", user.ID, message.Id).Count(&models.UserEmail{})
if err != nil || count != 2 {
t.Fatalf("未生成预期副本: count=%d err=%v", count, err)
}
// 当前服务器未声明 MOVE 扩展,客户端会回退 COPY/STORE/EXPUNGE。
// 另外验证网页移动所用的服务,避免把回退成功误判为原生 MOVE 已通过。
webMoveErr := group.Move2DefaultBox(&context.Context{UserID: user.ID}, []int{message.Id}, "Deleted Messages")
t.Logf("web_move_after_imap_copy_error=%v", webMoveErr)
if webMoveErr != nil {
t.Errorf("IMAP 复制后网页移动不应把自己的邮件判断为不属于自己: %v", webMoveErr)
}
_, err = clientLogin.Move(uid, "Deleted Messages").Wait()
t.Logf("copy_relation_count=%d move_error=%v", count, err)
if err != nil {
t.Fatalf("同一用户复制邮件后,移动原文件夹中的 UID 不应失败: %v", err)
}
}
func auditIMAPMessage(t *testing.T) models.UserEmail {
t.Helper()
var user models.User
if found, err := db.Instance.Where("account=?", "testCase").Get(&user); err != nil || !found {
t.Fatalf("测试账户不可用: found=%v err=%v", found, err)
}
message := models.Email{Subject: t.Name()}
if _, err := db.Instance.Insert(&message); err != nil {
t.Fatal(err)
}
relation := models.UserEmail{UserID: user.ID, EmailID: message.Id, Status: 0}
if _, err := db.Instance.Insert(&relation); err != nil {
t.Fatal(err)
}
return relation
}
func TestAuditExamineMustNotPersistStore(t *testing.T) {
relation := auditIMAPMessage(t)
if _, err := clientLogin.Select("INBOX", &imap.SelectOptions{ReadOnly: true}).Wait(); err != nil {
t.Fatal(err)
}
err := clientLogin.Store(imap.UIDSetNum(imap.UID(relation.ID)), &imap.StoreFlags{
Op: imap.StoreFlagsAdd, Flags: []imap.Flag{imap.FlagSeen}, Silent: true,
}, nil).Close()
var updated models.UserEmail
if found, lookupErr := db.Instance.ID(relation.ID).Get(&updated); lookupErr != nil || !found {
t.Fatalf("读取测试邮件失败: found=%v err=%v", found, lookupErr)
}
t.Logf("readonly=true store_error=%v persisted_is_read=%d", err, updated.IsRead)
if updated.IsRead != relation.IsRead {
t.Fatal("EXAMINE 只读打开后,STORE 仍持久化修改已读状态")
}
}
func TestAuditCopiedMessagesMustKeepDistinctUIDs(t *testing.T) {
relation := auditIMAPMessage(t)
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
t.Fatal(err)
}
if _, err := clientLogin.Copy(imap.UIDSetNum(imap.UID(relation.ID)), "INBOX").Wait(); err != nil {
t.Fatal(err)
}
var relations []models.UserEmail
if err := db.Instance.Where("user_id=? AND email_id=?", relation.UserID, relation.EmailID).Find(&relations); err != nil || len(relations) != 2 {
t.Fatalf("复制前置条件失败: count=%d err=%v", len(relations), err)
}
for _, stored := range relations {
t.Logf("stored_uid=%d status=%d group=%d", stored.ID, stored.Status, stored.GroupId)
}
rows, lookupErr := list.GetEmailListByGroup(&context.Context{UserID: relation.UserID}, "INBOX", list.ImapListReq{
UidList: []int{relations[0].ID, relations[1].ID},
}, true)
if lookupErr != nil || len(rows) != 2 {
t.Fatalf("直接查询副本失败: count=%d err=%v", len(rows), lookupErr)
}
t.Logf("hydrated_uids=%d,%d same_pointer=%v", rows[0].UeId, rows[1].UeId, rows[0] == rows[1])
if rows[0] == rows[1] || rows[0].UeId == rows[1].UeId {
t.Error("不同邮箱关系复用了同一个可变响应对象,UID 被后一个副本覆盖")
}
uids := imap.UIDSetNum(imap.UID(relations[0].ID), imap.UID(relations[1].ID))
messages, err := clientLogin.Fetch(uids, &imap.FetchOptions{UID: true, Flags: true}).Collect()
if err != nil || len(messages) != 2 {
t.Fatalf("读取两个副本失败: count=%d err=%v", len(messages), err)
}
t.Logf("stored_uids=%d,%d fetched_uids=%d,%d", relations[0].ID, relations[1].ID, messages[0].UID, messages[1].UID)
if messages[0].UID == messages[1].UID {
t.Fatal("不同副本在实际 IMAP FETCH 响应中使用了同一个 UID")
}
}
func TestAuditListPercentMustIncludeInbox(t *testing.T) {
mailboxes, err := clientLogin.List("", "%", nil).Collect()
if err != nil {
t.Fatal(err)
}
names := make([]string, 0, len(mailboxes))
found := false
for _, mailbox := range mailboxes {
names = append(names, mailbox.Mailbox)
found = found || mailbox.Mailbox == "INBOX"
}
t.Logf("top_level_mailboxes=%v", names)
if !found {
t.Fatal("LIST 顶层通配符遗漏 INBOX 和默认文件夹")
}
}
func TestAuditUIDNextMustNotDecrease(t *testing.T) {
relation := auditIMAPMessage(t)
before, err := clientLogin.Status("INBOX", &imap.StatusOptions{UIDNext: true, UIDValidity: true}).Wait()
if err != nil {
t.Fatal(err)
}
if err := group.Move2DefaultBox(&context.Context{UserID: relation.UserID}, []int{relation.EmailID}, "Junk"); err != nil {
t.Fatal(err)
}
after, err := clientLogin.Status("INBOX", &imap.StatusOptions{UIDNext: true, UIDValidity: true}).Wait()
if err != nil {
t.Fatal(err)
}
t.Logf("uidnext_before=%d uidnext_after=%d validity_before=%d validity_after=%d", before.UIDNext, after.UIDNext, before.UIDValidity, after.UIDValidity)
if after.UIDValidity == before.UIDValidity && after.UIDNext < before.UIDNext {
t.Fatal("同一 UIDVALIDITY 下,移走最大 UID 邮件导致 UIDNEXT 倒退")
}
}
func TestAuditFetchWildcardUIDMustReturnLastMessage(t *testing.T) {
relation := auditIMAPMessage(t)
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
t.Fatal(err)
}
messages, err := clientLogin.Fetch(imap.UIDSetNum(0), &imap.FetchOptions{UID: true}).Collect()
if err != nil {
t.Fatal(err)
}
t.Logf("wildcard_uid_count=%d expected_uid=%d", len(messages), relation.ID)
if len(messages) != 1 || messages[0].UID != imap.UID(relation.ID) {
t.Fatal("UID FETCH * 没有返回非空文件夹中最大 UID 的邮件")
}
}
func TestAuditInboxCountMustExcludeLoginBindings(t *testing.T) {
relation := auditIMAPMessage(t)
bindings, err := db.Instance.Where("user_id=? AND email_id=0 AND group_id=0 AND status=0", relation.UserID).Count(&models.UserEmail{})
if err != nil || bindings < 1 {
t.Fatalf("临时登录邮箱绑定前置条件未成立: count=%d err=%v", bindings, err)
}
want, err := db.Instance.Where("user_id=? AND email_id>0 AND group_id=0 AND status=0", relation.UserID).Count(&models.UserEmail{})
if err != nil {
t.Fatal(err)
}
status, err := clientLogin.Status("INBOX", &imap.StatusOptions{NumMessages: true}).Wait()
if err != nil || status.NumMessages == nil {
t.Fatalf("查询邮箱数量失败: status=%v err=%v", status, err)
}
t.Logf("login_bindings=%d real_messages=%d status_messages=%d", bindings, want, *status.NumMessages)
if int64(*status.NumMessages) != want {
t.Fatal("登录邮箱绑定被当作邮件计入 INBOX,状态数量与可读取邮件不一致")
}
}
func TestAuditSearchKeysMustIntersect(t *testing.T) {
first := auditIMAPMessage(t)
second := auditIMAPMessage(t)
third := auditIMAPMessage(t)
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
t.Fatal(err)
}
uidCriterion := func(ids ...int) imap.SearchCriteria {
var set imap.UIDSet
for _, id := range ids {
set.AddNum(imap.UID(id))
}
return imap.SearchCriteria{UID: []imap.UIDSet{set}}
}
cases := map[string]imap.SearchCriteria{
"multiple_or": {Or: [][2]imap.SearchCriteria{
{uidCriterion(first.ID), uidCriterion(second.ID)},
{uidCriterion(second.ID), uidCriterion(third.ID)},
}},
"multiple_uid": {UID: []imap.UIDSet{
imap.UIDSetNum(imap.UID(first.ID), imap.UID(second.ID)),
imap.UIDSetNum(imap.UID(second.ID), imap.UID(third.ID)),
}},
}
for name, criteria := range cases {
t.Run(name, func(t *testing.T) {
result, err := clientLogin.UIDSearch(&criteria, nil).Wait()
if err != nil {
t.Fatal(err)
}
uids := result.AllUIDs()
t.Logf("returned=%v expected_only=%d", uids, second.ID)
if len(uids) != 1 || uids[0] != imap.UID(second.ID) {
t.Fatal("同一个 SEARCH 的多个键应取交集,而不是并集")
}
})
}
}
func TestAuditSearchDeletedMustMatchStoredFlag(t *testing.T) {
relation := auditIMAPMessage(t)
if _, err := clientLogin.Select("INBOX", nil).Wait(); err != nil {
t.Fatal(err)
}
uid := imap.UIDSetNum(imap.UID(relation.ID))
if err := clientLogin.Store(uid, &imap.StoreFlags{
Op: imap.StoreFlagsAdd, Flags: []imap.Flag{imap.FlagDeleted}, Silent: true,
}, nil).Close(); err != nil {
t.Fatal(err)
}
messages, err := clientLogin.Fetch(uid, &imap.FetchOptions{Flags: true, UID: true}).Collect()
if err != nil || len(messages) != 1 {
t.Fatalf("读取标记前置条件失败: count=%d err=%v", len(messages), err)
}
deleted := false
for _, flag := range messages[0].Flags {
deleted = deleted || flag == imap.FlagDeleted
}
if !deleted {
t.Fatal("STORE 后 FETCH 没有返回删除标记,不能继续归因 SEARCH")
}
result, err := clientLogin.UIDSearch(&imap.SearchCriteria{
UID: []imap.UIDSet{uid}, Flag: []imap.Flag{imap.FlagDeleted},
}, nil).Wait()
if err != nil {
t.Fatal(err)
}
t.Logf("fetch_deleted=%t search_uids=%v expected_uid=%d", deleted, result.AllUIDs(), relation.ID)
if len(result.AllUIDs()) != 1 || result.AllUIDs()[0] != imap.UID(relation.ID) {
t.Fatal("已通过 STORE 设置且 FETCH 确认的删除标记未被 SEARCH 识别")
}
}

View File

@ -0,0 +1,42 @@
package list
import (
"fmt"
"testing"
"git.pcux.cn/xuans/Smail/config"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/dto"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/context"
)
// 审查专用:每次新建临时邮箱,不读取真实账户或邮件。
func TestAuditPaginationMustPreserveTotal(t *testing.T) {
previousConfig, previousDB := config.Instance, db.Instance
t.Cleanup(func() {
config.Instance, db.Instance = previousConfig, previousDB
})
initListTestDB(t)
for index := 0; index < 31; index++ {
message := models.Email{Subject: fmt.Sprintf("audit-%d", index)}
if _, err := db.Instance.Insert(&message); err != nil {
t.Fatal(err)
}
relation := models.UserEmail{UserID: 1, EmailID: message.Id}
if _, err := db.Instance.Insert(&relation); err != nil {
t.Fatal(err)
}
}
tag := dto.SearchTag{Type: 0, Status: -1, GroupId: -1}
for _, offset := range []int{0, 15, 30} {
messages, total, err := GetEmailList(&context.Context{UserID: 1}, tag, "", false, offset, 15)
if err != nil {
t.Fatal(err)
}
t.Logf("offset=%d rows=%d total=%d", offset, len(messages), total)
if total != 31 {
t.Errorf("分页计数应保持为 31,实际为 %d", total)
}
}
}

View File

@ -0,0 +1,104 @@
package parsemail
import (
"bytes"
"strings"
"testing"
"git.pcux.cn/xuans/Smail/utils/context"
"github.com/emersion/go-message"
"github.com/emersion/go-msgauth/dkim"
)
func auditRawMessage(extraHeaders, to string) string {
return "From: sender@example.com\r\n" +
"To: " + to + "\r\n" +
"Message-ID: <audit-message@example.com>\r\n" +
"Subject: audit\r\n" + extraHeaders +
"Content-Type: text/plain; charset=UTF-8\r\n\r\nbody"
}
func TestAuditInvalidDKIMMustNotPassForSpecialDomain(t *testing.T) {
for _, domain := range []string{"ordinary.example.test", "test.domain"} {
t.Run(domain, func(t *testing.T) {
// 缺少必要签名标签,验证器在查询 DNS 前就应拒绝。
raw := auditRawMessage("DKIM-Signature: v=1; d="+domain+"\r\n", "recipient@example.com")
verifications, err := dkim.Verify(strings.NewReader(raw))
if err != nil || len(verifications) != 1 || verifications[0].Err == nil {
t.Fatalf("无效签名前置条件不成立: verifications=%v err=%v", verifications, err)
}
accepted := Check(&context.Context{}, strings.NewReader(raw))
t.Logf("domain=%q verifier_error=%v application_passed=%t", domain, verifications[0].Err, accepted)
if accepted {
t.Fatal("不能仅因签名域名是特殊常量就把无效 DKIM 判为通过")
}
})
}
}
func TestAuditReplyToMustSurviveParseAndBuild(t *testing.T) {
raw := auditRawMessage("Reply-To: replies@example.com\r\n", "recipient@example.com")
parsed, err := NewEmailFromReader([]string{"recipient@example.com"}, strings.NewReader(raw), len(raw))
if err != nil {
t.Fatal(err)
}
t.Logf("parsed_reply_to_count=%d", len(parsed.ReplyTo))
if len(parsed.ReplyTo) != 1 || parsed.ReplyTo[0].EmailAddress != "replies@example.com" {
t.Error("标准 Reply-To 在解析时丢失")
}
// 独立补入合法回复地址,检查重建层,避免解析失败遮挡第二层问题。
parsed.ReplyTo = []*User{{EmailAddress: "replies@example.com"}}
built, err := parsed.BuildBytes(nil, false)
if err != nil {
t.Fatal(err)
}
message, err := message.Read(bytes.NewReader(built))
if err != nil {
t.Fatal(err)
}
replyTo := message.Header.Get("Reply-To")
t.Logf("rebuilt_reply_to=%q", replyTo)
if !strings.Contains(replyTo, "replies@example.com") {
t.Error("合法 ReplyTo 字段在 MIME 重建时丢失")
}
}
func TestAuditQuotedRecipientNameMustNotSplitAddress(t *testing.T) {
raw := auditRawMessage("", `"Doe, Jane" <jane@example.com>`)
parsed, err := NewEmailFromReader([]string{"jane@example.com"}, strings.NewReader(raw), len(raw))
if err != nil {
t.Fatal(err)
}
addresses := make([]string, 0, len(parsed.To))
for _, recipient := range parsed.To {
addresses = append(addresses, recipient.EmailAddress)
}
t.Logf("quoted_recipient_addresses=%q", addresses)
if len(parsed.To) != 1 || parsed.To[0].EmailAddress != "jane@example.com" || parsed.To[0].Name != "Doe, Jane" {
t.Fatal("带引号姓名中的合法逗号被当作地址列表分隔符")
}
}
func TestAuditInlineAttachmentMustPreserveContentID(t *testing.T) {
email := &Email{
From: &User{EmailAddress: "sender@example.com"},
To: []*User{{EmailAddress: "recipient@example.com"}},
MsgID: "audit-cid@example.com", HTML: []byte(`<img src="cid:audit-inline">`),
Attachments: []*Attachment{{Filename: "inline.png", ContentType: "image/png", ContentID: "audit-inline", Content: []byte{1, 2, 3}}},
}
built, err := email.BuildBytes(nil, false)
if err != nil {
t.Fatal(err)
}
parsed, err := NewEmailFromReader([]string{"recipient@example.com"}, bytes.NewReader(built), len(built))
if err != nil {
t.Fatal(err)
}
if len(parsed.Attachments) != 1 {
t.Fatalf("附件重建前置条件失败: count=%d", len(parsed.Attachments))
}
t.Logf("original_content_id=%q rebuilt_content_id=%q html_references_cid=%v", email.Attachments[0].ContentID, parsed.Attachments[0].ContentID, bytes.Contains(parsed.HTML, []byte("cid:audit-inline")))
if parsed.Attachments[0].ContentID != email.Attachments[0].ContentID {
t.Fatal("附件 Content-ID 在重建时丢失,HTML 的 cid 引用无法匹配")
}
}

View File

@ -0,0 +1,55 @@
import { createServer } from 'node:http'
import { readFile, mkdir, writeFile } from 'node:fs/promises'
import { fileURLToPath } from 'node:url'
import path from 'node:path'
const root = fileURLToPath(new URL('../../', import.meta.url))
const directory = path.join(root, 'test-log', `review-plugin-browser-${Date.now()}`)
await mkdir(directory, { recursive: true })
const page = await readFile(path.join(root, 'plugins/pmail_telegram_push/src/App.vue'), 'utf8')
const container = await readFile(path.join(root, 'frontend/src/views/components/PluginSettings/PluginSettings.vue'), 'utf8')
const headers = await readFile(path.join(root, 'backend/listen/http_server/https_server.go'), 'utf8')
const mounted = page.match(/onMounted\(\(\) => \{([\s\S]*?)\n\}\)/)?.[1]
const sandbox = container.match(/sandbox="([^"]+)"/)?.[1]
const policy = headers.match(/"Content-Security-Policy", "([^"]*connect-src 'none'[^"]*)"/)?.[1]
if (!mounted || !sandbox || !policy) throw new Error('未找到被审查的真实模板、安全策略或挂载函数')
// 浏览器隔离夹具:使用源码中的挂载函数、sandbox 和 CSP,不访问业务服务或数据库。
const events = []
const send = (response, type, body) => {
response.setHeader('Content-Type', type)
response.setHeader('Cache-Control', 'no-store')
response.end(body)
}
const server = createServer((request, response) => {
if (request.url === '/health') return send(response, 'application/json', JSON.stringify({ ready: true, events }))
if (request.url === '/api/audit') {
events.push('api-request')
return send(response, 'application/json', '{"errorNo":0}')
}
if (request.url === '/frame') {
response.setHeader('Content-Security-Policy', policy)
return send(response, 'text/html; charset=utf-8', `<!doctype html><html><head><meta charset="utf-8"></head><body><script>
const report = value => parent.postMessage({audit: true, ...value}, '*');
const tourOpen = { value: false };
const resizeIframeHeight = () => report({stage: 'resize'});
const fetchBotInfo = () => report({stage: 'bot-info'});
const fetchSetting = () => report({stage: 'settings'});
addEventListener('securitypolicyviolation', event => report({stage: 'csp', directive: event.effectiveDirective}));
try { (() => { ${mounted} })(); report({stage: 'mounted-complete'}); }
catch (error) { report({stage: 'mounted-error', name: error.name, message: error.message}); }
fetch('/api/audit').then(() => report({stage: 'request-ok'})).catch(error => report({stage: 'request-error', message: error.message}));
</script></body></html>`)
}
send(response, 'text/html; charset=utf-8', `<!doctype html><html><head><meta charset="utf-8"><title>Smail 插件隔离审查</title></head><body>
<h1>Smail 插件隔离审查</h1><p>不连接业务数据库,不发送第三方消息。</p>
<pre id="evidence"></pre><script>window.auditEvents=[];addEventListener('message',event=>{if(event.data?.audit){auditEvents.push(event.data);document.querySelector('#evidence').textContent=JSON.stringify(auditEvents,null,2);}});</script>
<iframe sandbox="${sandbox}" src="/frame" title="插件隔离夹具"></iframe></body></html>`)
})
await new Promise(resolve => server.listen(0, '127.0.0.1', resolve))
const state = { url: `http://127.0.0.1:${server.address().port}`, sandbox, policy }
await writeFile(path.join(directory, 'state.json'), JSON.stringify(state, null, 2) + '\n')
console.log(JSON.stringify({ ...state, directory: path.relative(root, directory) }))
const stop = () => { server.close(); server.closeAllConnections() }
process.once('SIGINT', stop)
process.once('SIGTERM', stop)

View File

@ -0,0 +1,43 @@
package framework
import (
"bytes"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"testing"
)
func TestAuditSendAfterFailureMustReachPlugin(t *testing.T) {
for _, failed := range []bool{false, true} {
name := "success"
failure := error(nil)
if failed {
name = "delivery-failed"
failure = errors.New("audit delivery rejected")
}
t.Run(name, func(t *testing.T) {
payload := HookDTO{ErrMap: map[string]error{"example.invalid": failure}}
body, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
plugin := &Plugin{name: "audit"}
called := false
received := ""
handler := plugin.handleHookDTO("SendAfter", func(dto *HookDTO) {
called = true
if dto.ErrMap["example.invalid"] != nil {
received = dto.ErrMap["example.invalid"].Error()
}
})
recorder := httptest.NewRecorder()
handler(recorder, httptest.NewRequest(http.MethodPost, "/SendAfter", bytes.NewReader(body)))
t.Logf("failed=%v status=%d callback=%v preserved_error=%v", failed, recorder.Code, called, received == "audit delivery rejected")
if recorder.Code != http.StatusOK || !called || (failed && received != "audit delivery rejected") {
t.Error("发送失败时插件回调必须收到可序列化的错误信息")
}
})
}
}

View File

@ -0,0 +1,119 @@
package pop3_server
import (
"testing"
"git.pcux.cn/xuans/Smail/config"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/internal/gopop"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/context"
)
// 复用临时 SQLite 和协议授权码夹具,不访问用户运行库。
func auditPOP3Session(t *testing.T) *gopop.Session {
t.Helper()
engine, user, code := newPOP3ProtocolAuthFixture(t)
oldDB, oldConfig := db.Instance, config.Instance
db.Instance = engine
config.Instance = &config.Config{Domain: "example.com", Domains: []string{"example.com"}}
t.Cleanup(func() {
db.Instance, config.Instance = oldDB, oldConfig
})
session := &gopop.Session{User: "alice@example.com", InTls: true, Ctx: &context.Context{}}
if err := (action{}).Pass(session, code); err != nil {
t.Fatal(err)
}
if session.Ctx.(*context.Context).UserID != user.ID {
t.Fatal("临时会话未关联预期用户")
}
return session
}
func auditPOP3Message(t *testing.T, session *gopop.Session, id int, status int8) {
t.Helper()
message := models.Email{Id: id, Subject: "audit-pop3", Size: 100}
if _, err := db.Instance.Insert(&message); err != nil {
t.Fatal(err)
}
relation := models.UserEmail{UserID: session.Ctx.(*context.Context).UserID, EmailID: id, Status: status}
if _, err := db.Instance.Insert(&relation); err != nil {
t.Fatal(err)
}
}
func TestAuditPOP3MessageNumbersMustStartAtOne(t *testing.T) {
session := auditPOP3Session(t)
auditPOP3Message(t, session, 101, 0)
auditPOP3Message(t, session, 305, 0)
rows, err := (action{}).List(session, "")
if err != nil || len(rows) != 2 {
t.Fatalf("列表前置条件失败: rows=%v err=%v", rows, err)
}
_, lookupErr := (action{}).List(session, "1")
t.Logf("message_count=%d list_message_numbers=%d,%d list_1_error=%v", len(rows), rows[0].Id, rows[1].Id, lookupErr)
if rows[0].Id != 1 || rows[1].Id != 2 || lookupErr != nil {
t.Fatal("POP3 消息编号使用全局邮件 ID,未建立会话级 1..N 映射")
}
}
func TestAuditPOP3MarkedDeletionMustHideMessage(t *testing.T) {
session := auditPOP3Session(t)
auditPOP3Message(t, session, 1, 0)
if err := (action{}).Delete(session, 1); err != nil {
t.Fatal(err)
}
rows, err := (action{}).List(session, "")
if err != nil {
t.Fatal(err)
}
count, _, err := (action{}).Stat(session)
if err != nil {
t.Fatal(err)
}
_, uidlErr := (action{}).Uidl(session, "1")
duplicateErr := (action{}).Delete(session, 1)
missingErr := (action{}).Delete(session, 999999)
t.Logf("after_dele_list_count=%d stat_count=%d uidl_error=%v duplicate_dele_error=%v missing_dele_error=%v", len(rows), count, uidlErr, duplicateErr, missingErr)
if len(rows) != 0 || count != 0 || uidlErr == nil || duplicateErr == nil || missingErr == nil {
t.Fatal("已标记删除邮件仍出现在会话查询中,重复及不存在的 DELE 也未被拒绝")
}
}
func TestAuditPOP3STATMustMatchVisibleMailbox(t *testing.T) {
session := auditPOP3Session(t)
auditPOP3Message(t, session, 1, 0)
auditPOP3Message(t, session, 2, 5)
rows, err := (action{}).List(session, "")
if err != nil {
t.Fatal(err)
}
count, _, err := (action{}).Stat(session)
if err != nil {
t.Fatal(err)
}
t.Logf("inbox_messages=1 junk_messages=1 list_count=%d stat_count=%d", len(rows), count)
if count != int64(len(rows)) {
t.Fatal("STAT 纳入垃圾箱邮件,但 LIST 排除了垃圾箱,邮箱视图不一致")
}
}
func TestAuditPOP3NegativeTOPMustNotPanic(t *testing.T) {
session := auditPOP3Session(t)
auditPOP3Message(t, session, 1, 0)
if _, err := db.Instance.ID(1).Cols("from_address").Update(&models.Email{FromAddress: "sender@example.com"}); err != nil {
t.Fatal(err)
}
if _, err := (action{}).Top(session, 1, 0); err != nil {
t.Fatalf("正常 TOP 前置条件失败: %v", err)
}
defer func() {
if recovered := recover(); recovered != nil {
t.Logf("negative_top_panic=%v", recovered)
t.Error("负数 TOP 行参数进入切片表达式并触发 panic")
}
}()
if _, err := (action{}).Top(session, 1, -100000); err == nil {
t.Error("负数 TOP 行参数必须明确拒绝")
}
}

View File

@ -0,0 +1,149 @@
package gopop
import (
"bufio"
"errors"
"net"
"strings"
"testing"
"time"
)
// 仅替换数据提供层,命令解析和响应编码执行真实实现;不启动公网监听。
type auditPOP3Action struct {
securityTestAction
committed []int64
topLines []int
}
func (a *auditPOP3Action) Delete(session *Session, id int64) error {
session.DeleteIds = append(session.DeleteIds, id)
return nil
}
func (a *auditPOP3Action) Rest(session *Session) error {
session.DeleteIds = nil
return nil
}
func (a *auditPOP3Action) Quit(session *Session) error {
a.committed = append([]int64(nil), session.DeleteIds...)
return nil
}
func (a *auditPOP3Action) Custom(session *Session, cmd string, args []string) ([]string, error) {
return nil, errors.New("unsupported command")
}
func (a *auditPOP3Action) List(session *Session, msg string) ([]MailInfo, error) {
return []MailInfo{{Id: 1, Size: 100}}, nil
}
func (a *auditPOP3Action) Uidl(session *Session, msg string) ([]UidlItem, error) {
return []UidlItem{{Id: 1, UnionId: "audit-message"}}, nil
}
func (a *auditPOP3Action) Top(session *Session, id int64, n int) (string, error) {
a.topLines = append(a.topLines, n)
return "fixture", nil
}
func auditPOP3Pipe(t *testing.T, action Action) (net.Conn, *bufio.Reader, <-chan struct{}) {
t.Helper()
serverConn, clientConn := net.Pipe()
server := &Server{Domain: "audit.invalid", Action: action}
done := make(chan struct{})
go func() {
server.handleClient(serverConn)
close(done)
}()
t.Cleanup(func() {
_ = clientConn.Close()
_ = serverConn.Close()
select {
case <-done:
case <-time.After(2 * time.Second):
t.Error("隔离 POP3 解析器未及时退出")
}
})
if err := clientConn.SetDeadline(time.Now().Add(2 * time.Second)); err != nil {
t.Fatal(err)
}
reader := bufio.NewReader(clientConn)
readResponseLine(t, reader, "+OK")
writeCommand(t, clientConn, "USER audit")
readResponseLine(t, reader, "+OK")
writeCommand(t, clientConn, "PASS fixture-only")
readResponseLine(t, reader, "+OK")
return clientConn, reader, done
}
func TestAuditPOP3RSETMustCancelPendingDeletion(t *testing.T) {
action := &auditPOP3Action{}
conn, reader, done := auditPOP3Pipe(t, action)
writeCommand(t, conn, "DELE 1")
readResponseLine(t, reader, "+OK")
writeCommand(t, conn, "RSET")
response, err := reader.ReadString('\n')
if err != nil {
t.Fatal(err)
}
writeCommand(t, conn, "QUIT")
readResponseLine(t, reader, "+OK")
<-done
t.Logf("rset_response=%q committed_ids=%v", strings.TrimSpace(response), action.committed)
if !strings.HasPrefix(response, "+OK") || len(action.committed) != 0 {
t.Fatal("标准 RSET 没有撤销删除标记,QUIT 仍提交原删除集合")
}
}
func TestAuditPOP3SingleMessageRepliesMustBeSingleLine(t *testing.T) {
for _, test := range []struct {
command string
want string
}{
{command: "LIST 1", want: "+OK 1 100"},
{command: "UIDL 1", want: "+OK 1 audit-message"},
} {
t.Run(test.command, func(t *testing.T) {
conn, reader, _ := auditPOP3Pipe(t, &auditPOP3Action{})
writeCommand(t, conn, test.command)
response, err := reader.ReadString('\n')
if err != nil {
t.Fatal(err)
}
t.Logf("command=%q first_response_line=%q buffered_extra_bytes=%d", test.command, strings.TrimSpace(response), reader.Buffered())
if strings.TrimSpace(response) != test.want || reader.Buffered() != 0 {
t.Fatal("指定消息编号的 LIST/UIDL 被错误编码成多行响应")
}
})
}
}
func TestAuditPOP3ParserMustRejectNegativeTOPLines(t *testing.T) {
action := &auditPOP3Action{}
conn, reader, done := auditPOP3Pipe(t, action)
writeCommand(t, conn, "TOP 1 -100000")
response, err := reader.ReadString('\n')
if err != nil {
t.Fatal(err)
}
if strings.HasPrefix(response, "+OK") {
for {
line, err := reader.ReadString('\n')
if err != nil {
t.Fatal(err)
}
if line == ".\r\n" {
break
}
}
}
writeCommand(t, conn, "QUIT")
readResponseLine(t, reader, "+OK")
<-done
t.Logf("negative_top_response=%q dispatched_line_counts=%v", strings.TrimSpace(response), action.topLines)
if !strings.HasPrefix(response, "-ERR") || len(action.topLines) != 0 {
t.Fatal("TOP 的负数行参数未在协议入口拒绝")
}
}

View File

@ -0,0 +1,75 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import { readFileSync } from 'node:fs'
import { compileFunction } from 'node:vm'
import { createRequire } from 'node:module'
const require = createRequire(new URL('../../frontend/package.json', import.meta.url))
const Vue = require('vue')
const { parse, compileScript } = require('@vue/compiler-sfc')
const read = extension => readFileSync(new URL(`../../frontend/src/views/components/ThirdPartyAuthorization/ThirdPartyAuthorization.${extension}`, import.meta.url), 'utf8')
for (const succeeded of [false, true]) {
test(`关闭协议后界面状态必须与服务端一致:请求成功=${succeeded}`, async () => {
const source = read('js').replace(/^import .*$/gm, '').replace('export function usePage', 'function usePage')
let serverEnabled = true
const requests = []
const notices = []
const transport = {
get: async () => ({ errorNo: 0, data: [{ protocol: 'imap', enabled: serverEnabled, configured: true }] }),
put: async (url, data) => {
requests.push({ url, ...data })
if (!succeeded) throw new Error('隔离模拟网络失败')
serverEnabled = data.enabled
return { errorNo: 0 }
}
}
const usePage = compileFunction(source + '\nreturn usePage', ['onMounted', 'ref', 'ElMessageBox', 'ElNotification', 'http'])(
Vue.onMounted, Vue.ref, {}, value => notices.push(value), transport
)
const { descriptor, errors } = parse(read('vue'))
assert.deepEqual(errors, [])
const compiled = compileScript(descriptor, { id: 'audit-protocol', inlineTemplate: true })
const script = compiled.content
.replace(/import \{([^}]+)\} from ["']vue["']/g, (_, fields) => `const {${fields.replace(/\bas\b/g, ':')}} = Vue`)
.replace(/^import .*$/gm, '').replace('export default', 'return')
let page
let toggle
const component = compileFunction(script, ['Vue', 'usePage'])(Vue, () => { page = usePage(); return page })
const node = tag => ({ tag, children: [] })
const renderer = Vue.createRenderer({
createElement: node, createText: text => ({ ...node('text'), text }), createComment: node,
setText: (item, text) => { item.text = text }, setElementText: (item, text) => { item.text = text },
parentNode: item => item.parent, nextSibling: () => null, remove() {},
insert: (item, parent) => { item.parent = parent; parent.children.push(item) },
patchProp: (item, key, previous, value) => { item[key] = value }
})
const app = renderer.createApp(component)
app.component('ElSwitch', {
props: ['modelValue'], emits: ['update:modelValue', 'change'],
setup(props, { emit }) {
// 与本机 Element Plus 源码一致:先更新 v-model,再触发 change。
toggle = value => { emit('update:modelValue', value); emit('change', value) }
return () => Vue.h('audit-switch', { enabled: props.modelValue })
}
})
app.config.warnHandler = () => {}
app.mount(node('root'))
try {
await Vue.nextTick()
await Vue.nextTick()
assert.equal(page.protocolCredentials.value[0].enabled, true)
assert.equal(typeof toggle, 'function')
toggle(false)
await Vue.nextTick()
await Vue.nextTick()
assert.equal(requests.length, 1)
assert.equal(notices[0].type, succeeded ? 'success' : 'error')
const uiEnabled = page.protocolCredentials.value[0].enabled
console.log(JSON.stringify({ succeeded, serverEnabled, uiEnabled, request: requests[0] }))
assert.equal(uiEnabled, serverEnabled, '失败时应恢复仍然开启的服务端状态,不能误显示已关闭')
} finally {
app.unmount()
}
})
}

View File

@ -0,0 +1,64 @@
package recovery
import (
"errors"
"testing"
"time"
"git.pcux.cn/xuans/Smail/models"
webauthnservice "git.pcux.cn/xuans/Smail/services/webauthn"
"git.pcux.cn/xuans/Smail/utils/password"
)
// 审查专用:从已验证后签发票据的位置开始,仅验证撤销后的授权有效性。
// 本测试不模拟或绕过真实 WebAuthn 签名验证,也不调用真实服务。
func TestAuditRevokedWebAuthnMustInvalidateRecoveryTicket(t *testing.T) {
service, _, engine, user := newRecoveryFixture(t)
credential := models.WebAuthnCredential{
UserID: user.ID, CredentialID: "audit-credential",
CredentialData: "unused", DisplayName: "audit", Discoverable: true, CreatedAt: time.Now(),
}
if _, err := engine.Insert(&credential); err != nil {
t.Fatal(err)
}
verifier, err := webauthnservice.NewService(engine, webauthnservice.Config{
RPID: "localhost", RPDisplayName: "audit", RPOrigins: []string{"https://localhost"}, VaultRoot: t.TempDir(),
})
if err != nil {
t.Fatal(err)
}
ticketID, err := service.issueTicketFor(user.ID, user.SessionVersion, "webauthn", credential.ID, 0, "audit-browser")
if err != nil {
t.Fatal(err)
}
if err := verifier.RevokeCredential(user.ID, credential.ID); err != nil {
t.Fatal(err)
}
var revoked models.WebAuthnCredential
if found, err := engine.ID(credential.ID).Get(&revoked); err != nil || !found || revoked.RevokedAt == nil {
t.Fatalf("撤销凭据的前置条件未成立: found=%v err=%v", found, err)
}
const newPassword = "AuditPass123"
if err := password.ValidateUserPassword(newPassword); err != nil {
t.Fatalf("测试密码不符合当前策略: %v", err)
}
err = service.CompleteWithContext(ticketID, newPassword, "audit-browser")
var updated models.User
if found, lookupErr := engine.ID(user.ID).Get(&updated); lookupErr != nil || !found {
t.Fatal("无法检查临时账户")
}
t.Logf("revoked=true completion_error=%v password_changed=%v", err, updated.Password != user.Password)
if errors.Is(err, ErrRecoveryDenied) || errors.Is(err, ErrRecoveryExpired) {
if updated.Password != user.Password {
t.Fatal("恢复被拒绝后不应改变密码")
}
return
}
if err != nil {
t.Fatalf("出现非授权类错误,本次结果不能证明撤销失效: %v", err)
}
if !password.Verify(updated.Password, newPassword) {
t.Fatal("完成接口未返回错误,但新密码未生效,需要单独诊断")
}
t.Fatal("用于签发恢复票据的安全密钥已经撤销,但旧票据仍然允许修改密码")
}

View File

@ -0,0 +1,355 @@
{
"baseline": "9849f8f11c9f49efd1bc877d7fedd8da265e32df",
"note": "仅记录本段有准确路径和完整输出的逐行阅读范围;接续摘要的其他阅读记录需补齐,未记录不等于未读。阅读不等于功能验收或复审通过。",
"files": {
"frontend/src/views/components/ConfigSettings/ConfigSettings.js": { "ranges": [[1, "EOF"]], "evidence": "本段分三段完整读取,真实函数复现导出和候选状态错误", "findings": ["R06", "R30"] },
"frontend/src/utils/axios.js": { "ranges": [[1, "EOF"]], "evidence": "本段全文及真实响应拦截器复现", "findings": ["R06"] },
"frontend/src/views/Editer/Editer.js": { "ranges": [[1, "EOF"]], "evidence": "本段全文及组合函数挂载复现", "findings": ["R07"] },
"frontend/src/views/Editer/Editer.vue": { "ranges": [[1, "EOF"]], "evidence": "本段全文及真实模板编译挂载复现", "findings": ["R07"] },
"backend/utils/password/encode.go": { "ranges": [[1, "EOF"]], "evidence": "本段全文及恢复测试密码校验" },
"backend/services/recovery/service.go": { "ranges": [[1, "EOF"]], "evidence": "已补齐 1-274 和 420-560,全文完成", "findings": ["R05"] },
"backend/services/group/group.go": { "ranges": [[1, 738], [739, "EOF"]], "evidence": "分段全文读取,复核移动、UIDNEXT 和计数", "findings": ["R08", "R13", "R15"] },
"backend/listen/imap_server/session_move.go": { "ranges": [[1, "EOF"]], "evidence": "本段全文读取", "findings": ["R08"] },
"backend/listen/imap_server/session_copy.go": { "ranges": [[1, "EOF"]], "evidence": "已补齐早期截断的开头,复核真实协议复制", "findings": ["R08", "R11"] },
"backend/listen/imap_server/session_select.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,真实 TLS 协议复现只读写入", "findings": ["R10"] },
"backend/listen/imap_server/session_store.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取并复核持久化写入路径", "findings": ["R10"] },
"backend/listen/imap_server/session_fetch.go": { "ranges": [[1, "EOF"]], "evidence": "分段完整读取,复现副本身份覆盖和动态 UID", "findings": ["R11", "R14"] },
"backend/listen/imap_server/server.go": { "ranges": [[1, "EOF"]], "evidence": "分两段完整读取会话与 APPEND" },
"backend/listen/imap_server/session_list.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,真实协议复现顶层枚举遗漏", "findings": ["R12"] },
"backend/listen/imap_server/session_search.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,搜索调用链待补齐" },
"backend/listen/imap_server/session_expunge.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,检查序号展开及删除边界" },
"backend/listen/imap_server/imap_server.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取,核对协议能力与测试服务器" },
"backend/services/list/list.go": { "ranges": [[1, "EOF"]], "evidence": "前段补齐截断缺口,复核副本构造和动态 UID", "findings": ["R04", "R11", "R14"] },
"backend/services/dbmigration/portable_schema.go": { "ranges": [[1, "EOF"]], "evidence": "全文复核源对象校验", "findings": ["R01"] },
"backend/services/dbmigration/maintenance.go": { "ranges": [[1, "EOF"]], "evidence": "全文复核租约和排空路径", "findings": ["R03"] },
"backend/config/audit_export.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取审计导出调用链" },
"backend/config/audit_query.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取审计查询" },
"backend/config/backup_list.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取备份列表" },
"backend/config/manager_backups.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取备份管理" },
"backend/controllers/config_audit.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取导出控制器" },
"backend/controllers/email/move.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取网页移动入口", "findings": ["R08"] },
"backend/dto/response/email.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取邮件响应模型" },
"backend/models/user_email.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取关系模型", "findings": ["R15"] },
"backend/models/group.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取文件夹模型" },
"backend/services/adminreset/transport_unix.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取本地 IPC 边界,平台验收未完成" },
"backend/services/adminreset/transport_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取本地 IPC 边界,平台验收未完成" },
"backend/services/adminreset/reset.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取管理员重置" },
"backend/services/adminreset/protocol.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取本地协议" },
"backend/plugins/catalog/catalog.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取插件目录" },
"backend/hooks/registry.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取插件注册同步" },
"backend/hooks/plugin_isolation.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取插件隔离接口" },
"backend/hooks/plugin_isolation_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取 Windows 不可用分支" },
"backend/hooks/plugin_isolation_linux.go": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取 Linux 隔离代码,未做 Linux 实机验证" },
"backend/hooks/base.go": { "ranges": [[1, "EOF"]], "evidence": "前段已补读 526-739,全文完成,平台运行验收未完成" },
"backend/res_init/init.go": { "ranges": [[1, "EOF"]], "evidence": "接续段补齐 119-216、284-320、412-508,全文完成", "findings": ["R09"] },
"backend/go.mod": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取依赖声明,未验证全部依赖供应链" },
".gitignore": { "ranges": [[1, "EOF"]], "evidence": "接续前已完整读取产物与秘密材料忽略规则" },
"backend/listen/imap_server/imap_server_test.go": { "ranges": [[1, 170]], "evidence": "本段验证临时 TLS 和 SQLite 测试入口" },
"backend/controllers/security.go": { "ranges": [[1, "EOF"]], "evidence": "分段全文,真实控制器和 TLS HTTP 复核恢复路径与外部邮箱", "findings": ["R09", "R17", "R31", "R32", "R33"] },
"backend/controllers/webauthn.go": { "ranges": [[1, "EOF"]], "evidence": "分段补齐 81 至文件尾,复核密钥管理及恢复入口", "findings": ["R09"] },
"test/frontend/config-settings.test.mjs": { "ranges": [[1, "EOF"]], "evidence": "本段全文读取及核对测试桩约定" },
"test/frontend/vue.mjs": { "ranges": [[1, "EOF"]], "evidence": "本段全文读取" },
"test/run.mjs": { "ranges": [[1, "EOF"]], "evidence": "本段全文读取,验证测试运行根隔离" },
"backend/utils/send/send.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取,SMTP 回退待隔离验证" },
"backend/utils/send/send_test.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/utils/smtp/smtp.go": { "ranges": [[1, "EOF"]], "evidence": "前段分段补齐 236-715,236-308 截断缺口已单独补读" },
"backend/services/auth/auth.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/services/auth/protocol_limiter.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/services/auth/identifier.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/services/credentials/service.go": { "ranges": [[1, "EOF"]], "evidence": "前段分段全文读取,尾部 331-333 已补齐" },
"backend/services/credentials/protocol.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/session/init.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/session/user.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/session/migration_store.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_login.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_idle.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_status.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取", "findings": ["R15"] },
"backend/listen/imap_server/session_create.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_delete.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_rename.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_namespace.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/listen/imap_server/session_poll.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取,选中邮箱计数待验证" },
"backend/listen/imap_server/numbers.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"frontend/src/router/index.js": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取,浏览器验收未完成" },
"frontend/src/stores/useGlobalStatusStore.js": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"frontend/src/views/LoginVerification/LoginVerification.js": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取", "findings": ["R02"] },
"frontend/src/views/Login/Login.js": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"frontend/src/utils/auth.mjs": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"frontend/src/utils/navigation.mjs": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"frontend/src/utils/webauthn.js": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/controllers/authorization.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取并隔离复现新角色遗漏", "findings": ["R16"] },
"backend/controllers/login.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取登录限频和会话创建" },
"backend/controllers/login_verification.go": { "ranges": [[1, "EOF"]], "evidence": "分段补齐截断的 180-232,全文完成" },
"backend/controllers/security_setup.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取引导确认状态" },
"backend/controllers/user.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取并隔离复现角色变更失败", "findings": ["R16"] },
"backend/models/User.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取角色兼容和敏感字段序列化,已核对 Git 受控路径大小写" },
"backend/services/access/authorize.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取能力授权与目标角色条件", "findings": ["R16"] },
"backend/services/access/catalog.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取端点能力映射" },
"backend/services/access/capability.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取权限矩阵和高风险条件" },
"backend/services/access/role.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取" },
"backend/controllers/password_reset_permissions_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取测试与夹具" },
"backend/controllers/user_security_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取测试与调用辅助函数" },
"backend/controllers/security_authentication_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取" },
"backend/controllers/security_public_response_test.go": { "ranges": [[1, 135]], "evidence": "精确读取临时安全服务夹具及前置条件" },
"backend/controllers/login_verification_policy_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取策略测试,未覆盖设备识别" },
"backend/listen/http_server/api_v1_compat.go": { "ranges": [[1, "EOF"]], "evidence": "两次输出补齐截断,核对版本化路由和 Cookie 路径不受内部重写影响", "findings": ["R02", "R17"] },
"frontend/src/views/PasswordRecovery/PasswordRecovery.js": { "ranges": [[1, "EOF"]], "evidence": "全文读取,复核版本化恢复接口", "findings": ["R17"] },
"frontend/src/views/Recovery/Recovery.js": { "ranges": [[1, "EOF"]], "evidence": "全文读取" },
"backend/listen/pop3_server/action.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,临时库验证消息序号、删除、计数和 TOP 边界", "findings": ["R18", "R19", "R20", "R21", "R23"] },
"backend/listen/pop3_server/pop3server.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,未启动实际监听" },
"backend/listen/pop3_server/action_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,原有 RETR 测试未断言结果" },
"backend/listen/pop3_server/protocol_auth_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,复用临时协议认证夹具" },
"backend/internal/gopop/pop3.go": { "ranges": [[1, "EOF"]], "evidence": "两段完整读取,真实解析器内存连接验证", "findings": ["R21", "R22", "R23"] },
"backend/internal/gopop/pop3_security_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,复用内存连接测试辅助函数" },
"backend/internal/gopop/session.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取" },
"backend/internal/gopop/action.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取" },
"backend/services/del_email/del_email.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,核对事务与删除关系作用域" },
"backend/services/detail/detail.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,复核所有权和读取标记" },
"backend/consts/consts.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取" },
"backend/models/email.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取邮件模型和序列化" },
"backend/listen/smtp_server/action.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取认证和会话重置" },
"backend/listen/smtp_server/login.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取 LOGIN 状态机" },
"backend/listen/smtp_server/smtp.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取端口和 TLS 策略,未启动实际监听" },
"backend/listen/smtp_server/read_content.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取收发、认证和入库链路" },
"backend/dto/parsemail/email.go": { "ranges": [[1, "EOF"]], "evidence": "分段完整补齐 135-298、367-779,复现解析和重建问题", "findings": ["R24", "R25", "R26", "R27"] },
"backend/dto/parsemail/email_build_security_test.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,检查既有边界测试" },
"backend/dto/parsemail/email_test.go": { "ranges": [[1, 130]], "evidence": "精确读取时间往返测试及辅助函数" },
"backend/listen/smtp_server/audit_persistence.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,复核原子入库和多收件人归属", "findings": ["R24"] },
"backend/listen/smtp_server/audit_persistence_test.go": { "ranges": [[433, "EOF"]], "evidence": "精确读取并复用隔离 SQLite 夹具及断言" },
"backend/listen/smtp_server/delivery_error.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取远端投递错误映射" },
"backend/listen/smtp_server/read_content_test.go": { "ranges": [[1, 200]], "evidence": "精确读取测试初始化及 SPF 既有契约,未把历史夹具当实际投递证据" },
"backend/utils/validation/email.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取消息体和地址校验", "findings": ["R26"] },
"backend/utils/validation/input.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取账户、姓名和域名规范化" },
"backend/utils/validation/sender.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取发件地址授权" },
"backend/controllers/email/detail.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取响应序列化入口", "findings": ["R24"] },
"backend/dto/response/response.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取并验证真实 HTTP 响应序列化" },
"backend/services/dbmigration/target.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取迁移目标规划" },
"backend/services/dbmigration/service.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取迁移状态和维护流程", "findings": ["R03"] },
"backend/services/dbmigration/portable_executor.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取当前运行入口及成功切换路径", "findings": ["R01", "R28"] },
"backend/services/dbmigration/portable_data.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文及本段复核,隔离验证序列历史高水位丢失", "findings": ["R01", "R28"] },
"backend/services/dbmigration/sqlite_executor.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取旧实现,不当作当前执行入口" },
"backend/services/dbmigration/sql_executor.go": { "ranges": [[1, "EOF"]], "evidence": "前段分两段完整读取 1-470、471-927,不当作当前执行入口" },
"backend/services/dbmigration/portable_test.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取并复用版本化临时 SQLite 夹具" },
"backend/config/database_migration.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/loader.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/parser.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/storage.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/model.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/security.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/runtime_access.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/runtime_validator.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/validator.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/sections.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/manager.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/snapshot.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/partitioned_compatibility.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/db/migration/schema.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取,核对版本化 schema 和身份字段" },
"backend/config/manager_v2.go": { "ranges": [[1, "EOF"]], "evidence": "前段三段完整读取,真实 manager 复现失败重试与启动恢复冲突和候选约束", "findings": ["R29", "R30"] },
"backend/config/transaction.go": { "ranges": [[1, "EOF"]], "evidence": "前段三段完整读取,故障注入验证旧事务恢复覆盖成功配置", "findings": ["R29"] },
"backend/config/migrate.go": { "ranges": [[1, "EOF"]], "evidence": "前段三段完整读取,补复核 270-897 及真实 SSL 和 SQLite 配置迁移", "findings": ["R41", "R42"] },
"backend/config/runtime_manager.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/secret.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/sensitive.go": { "ranges": [[1, "EOF"]], "evidence": "前段全文读取" },
"backend/config/config.go": { "ranges": [[1, "EOF"]], "evidence": "前段两段完整读取,分区写入与 SQLite 路径复核", "findings": ["R40", "R42"] },
"backend/config/audit_store.go": { "ranges": [[1, "EOF"]], "evidence": "前段两段完整读取" },
"backend/controllers/config.go": { "ranges": [[1, "EOF"]], "evidence": "前段两段完整读取,核对实际应用配置入口", "findings": ["R29"] },
"backend/config/manager_v2_test.go": { "ranges": [[1, 430]], "evidence": "前段精确读取夹具与已有候选配置测试" },
"backend/config/runtime_validator_test.go": { "ranges": [[1, 92]], "evidence": "接续段精确读取运行配置夹具" },
"frontend/src/views/components/ConfigSettings/ConfigForm/ConfigForm.js": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,真实表单函数验证候选状态", "findings": ["R30"] },
"frontend/src/views/components/SecuritySettings/SecuritySettings.js": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,真实函数复核绑定挑战重试", "findings": ["R31"] },
"frontend/src/views/components/SecuritySettings/SecuritySettings.vue": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,复核待验证绑定可用操作", "findings": ["R31"] },
"backend/services/webauthn/service.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取挑战消费和撤销" },
"backend/services/verification/service.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,本段复核发码和资源绑定" },
"backend/services/verification/store.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取锁与挑战消费" },
"backend/services/verification/rate_limit.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取持久化限频" },
"backend/services/verification/delivery.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取验证码发送" },
"backend/services/verification/event_store.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取安全事件存储" },
"backend/services/verification/cleanup.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/services/verification/event_cleanup.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/services/verification/runtime.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/services/verification/rate_limit_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取限频测试" },
"backend/services/externalemail/repository.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,真实控制器和 TLS HTTP 复核绑定约束", "findings": ["R31", "R33"] },
"backend/services/externalemail/vault.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取外部邮箱加密存储" },
"backend/services/externalemail/repository_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,本段全文复核隔离夹具和名额限制" },
"backend/models/external_email.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/listen/http_server/https_server.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,真实 TLS HTTP 复核会话及近期认证注入", "findings": ["R02", "R32"] },
"backend/listen/http_server/http_server.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,已单独补齐截断的 1-115", "findings": ["R02"] },
"backend/listen/http_server/setup_server.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/listen/http_server/setup_security.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/listen/http_server/session_validation_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,本段全文复核真实会话夹具" },
"backend/controllers/setup.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/settings.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,修改密码后会话交互仍待验证" },
"backend/controllers/request.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"docs/超级管理员重置与邮箱验证码需求文档.md": { "ranges": [[270, 520]], "evidence": "接续前精确读取安全邮箱绑定需求,其他范围仅搜索不计覆盖" },
"backend/utils/csrf/csrf.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取,真实 HTTP 缺失 CSRF 请求作为拒绝对照" },
"deploy/build.ps1": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取构建流程" },
"deploy/install-systemd.sh": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,Linux 安装实测未完成" },
"deploy/prepare-frontend.mjs": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取前端产物复制" },
"deploy/start-dev.ps1": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取开发启动和端口检查" },
"deploy/install-windows.ps1": { "ranges": [[1, "EOF"]], "evidence": "全文复读,真实事务 AST 和内存命令桩验证失败回滚", "findings": ["R36"] },
"deploy/uninstall-windows.ps1": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,未执行真实卸载" },
"deploy/systemd/smail.service": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取服务定义" },
"deploy/systemd/smail-admin.service": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取本地管理服务定义" },
"Makefile": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取构建目标" },
"backend/internal/release/release.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取发布元数据" },
"backend/internal/app/app.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取应用生命周期" },
"backend/cmd/smail/main.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取启动入口" },
"backend/cmd/smail/run_nonwindows.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取非 Windows 启动适配" },
"backend/cmd/smail/run_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取 Windows 服务适配,未执行系统安装" },
"frontend/src/views/ForcePasswordChange/ForcePasswordChange.js": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,已区分强制改密和普通改密页面" },
"frontend/src/views/ForcePasswordChange/ForcePasswordChange.vue": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"frontend/src/views/ForcePasswordChange/ForcePasswordChange.css": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,未浏览器验收" },
"frontend/src/views/EmailDetail/EmailDetail.js": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取详情调用链" },
"frontend/src/views/EmailDetail/EmailDetail.vue": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,真实 TLS HTTP 复现附件下载路径", "findings": ["R34"] },
"frontend/src/views/List/List.js": { "ranges": [[1, "EOF"]], "evidence": "全文复读,真实 SFC 挂载及引用连接对照", "findings": ["R35"] },
"frontend/src/views/List/List.vue": { "ranges": [[1, "EOF"]], "evidence": "全文复读,真实 SFC 挂载及引用连接对照", "findings": ["R35"] },
"frontend/src/views/components/GroupSettings/GroupSettings.js": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"frontend/src/views/components/GroupSettings/GroupSettings.vue": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/attachments.go": { "ranges": [[1, "EOF"]], "evidence": "全文复读,真实 HTTP 路由及所有权对照验证", "findings": ["R34"] },
"backend/controllers/attachments_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,既有测试只覆盖文件名" },
"backend/services/attachments/attachments.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取,已确认附件所有权检查" },
"backend/controllers/email/list.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/email/delete.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/email/read.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/email/request.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/email/send.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/controllers/group.go": { "ranges": [[1, "EOF"]], "evidence": "接续前全文读取" },
"backend/services/setup/finish.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取初始化完成事务" },
"backend/services/setup/domain.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/dns.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/db.go": { "ranges": [[1, "EOF"]], "evidence": "接续段 1-340、341-671 全文完成,本段真实迁移证明首次管理员角色线索不成立" },
"backend/services/setup/db_security_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文,本段复读并增加独立角色对照测试" },
"backend/services/setup/finish_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/db_database_test.go": { "ranges": [[1, 125]], "evidence": "接续段精确读取,其他部分未读" },
"backend/controllers/rule.go": { "ranges": [[1, "EOF"]], "evidence": "全文复读,确认页面旧 ID 进入更新而不是插入路径", "findings": ["R37"] },
"backend/services/rule/rule.go": { "ranges": [[1, "EOF"]], "evidence": "全文复读规则读取和执行" },
"backend/services/rule/match/base.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/rule/match/contains_match.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/rule/match/equal_match.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/rule/match/regex_match.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/dto/rule.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/models/rule.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"frontend/src/views/components/RuleSettings/RuleSettings.js": { "ranges": [[1, "EOF"]], "evidence": "全文复读并挂载真实 SFC 验证取消编辑再新建的状态残留", "findings": ["R37"] },
"frontend/src/views/components/RuleSettings/RuleSettings.vue": { "ranges": [[1, "EOF"]], "evidence": "全文复读,真实模板取消及新建点击处理器复现", "findings": ["R37"] },
"frontend/src/views/components/UserManagement/UserManagement.js": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"frontend/src/views/components/UserManagement/UserManagement.vue": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/db/init.go": { "ranges": [[1, "EOF"]], "evidence": "全文复读,临时 SQLite 真实初始化及重启对照" },
"backend/db/migration/migration.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/db/migration/registry.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/db/migration/runner.go": { "ranges": [[1, "EOF"]], "evidence": "接续段 1-165、166-334 全文读取" },
"backend/db/migration/user_email.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/totp/service.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取,并发线索未复现且业务接入未确认" },
"backend/services/totp/service_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/storage.go": { "ranges": [[1, "EOF"]], "evidence": "接续段及本段全文读取" },
"backend/services/setup/ssl/challenge.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/dnsProvide.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/ssl.go": { "ranges": [[1, "EOF"]], "evidence": "接续段 1-285、286-555 全文读取,本段复核真实分区续期调用链", "findings": ["R38", "R39", "R40", "R41"] },
"backend/services/setup/ssl/ssl_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/wildcard_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/user_certificate_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/storage_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/services/setup/ssl/challenge_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/listen/cron_server/ssl_update.go": { "ranges": [[1, "EOF"]], "evidence": "接续段及本段全文读取,续期条件已验证", "findings": ["R39"] },
"backend/config/ssl_storage.go": { "ranges": [[1, "EOF"]], "evidence": "接续段 1-270、271-519 全文读取,本段验证分区提交失败后的证书状态", "findings": ["R38", "R40"] },
"backend/config/ssl_storage_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段 1-175、176-EOF 全文读取" },
"backend/config/acme_key.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/config/ssl_storage_links_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/config/ssl_storage_links_unix.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/config/runtime_manager.go": { "ranges": [[1, "EOF"]], "evidence": "接续段及本段全文读取" },
"backend/config/partitioned_compatibility.go": { "ranges": [[1, "EOF"]], "evidence": "接续段及本段全文读取,真实 SSL 和 SQLite 配置迁移复核", "findings": ["R41", "R42"] },
"backend/config/partitioned_compatibility_test.go": { "ranges": [[1, "EOF"]], "evidence": "接续段及本段全文读取" },
"backend/utils/context/context.go": { "ranges": [[1, "EOF"]], "evidence": "接续段单独补齐全文" },
"frontend/src/views/Setup/Setup.js": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确记录 1-250、251-510、511-748 全文,异步及表单线索未验收" },
"frontend/src/views/Setup/Setup.vue": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确记录 1-135、136-310、311-430 全文" },
"frontend/src/views/Setup/SetupNavigation.js": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"frontend/vite.config.js": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取" },
"backend/controllers/ping.go": { "ranges": [[1, "EOF"]], "evidence": "接续段全文读取,setup 误跳转线索未确认" },
"backend/services/list/imap_search.go": { "ranges": [[1, "EOF"]], "evidence": "本段补复读全文,真实 TLS 复现搜索键与删除标记错误", "findings": ["R44", "R45"] },
"backend/services/auth/dkim_keys.go": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文读取,PKCS1 兼容线索待核对" },
"backend/dto/parsemail/dkim.go": { "ranges": [[1, "EOF"]], "evidence": "本段全文复读及无效签名真实验证器对照", "findings": ["R43"] },
"backend/utils/consts/consts.go": { "ranges": [[1, "EOF"]], "evidence": "全文读取特殊域名常量", "findings": ["R43"] },
"backend/controllers/plugin.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/controllers/plugin_v1.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/plugin/catalog.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/plugin/config.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记 1-270、271-803 全文读取" },
"backend/models/plugin.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/hooks/plugin_isolation_unsupported.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/hooks/debug/debug.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/controllers/config_error.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/controllers/database_migration.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/controllers/base.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/controllers/interceptor.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/controllers/restart.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/restart/registry.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/restart/service.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/signal/signal.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/db/retry.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/cmd/smail-admin/main.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/cmd/smail-config/main.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/client.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/control.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/control_linux.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/control_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/control_unsupported.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/doctor.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/doctor_linux.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取,未做 Linux 实机验收" },
"backend/services/adminreset/doctor_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取,平台验收未完成" },
"backend/services/adminreset/doctor_unsupported.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/password_linux.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取,未做 Linux 实机验收" },
"backend/services/adminreset/password_windows.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取,平台验收未完成" },
"backend/services/adminreset/password_unsupported.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/services/adminreset/transport_unsupported.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/res_init/admin_reset_mode.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/internal/buildinfo/buildinfo.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/internal/buildinfo/errors.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/main.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/utils/credential/vault.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/utils/credential/encryption.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"backend/utils/credential/credential.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"frontend/src/views/components/PluginSettings/PluginSettings.js": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"frontend/src/views/components/PluginSettings/PluginSettings.vue": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确登记全文读取" },
"frontend/src/views/components/ThirdPartyAuthorization/ThirdPartyAuthorization.js": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文,真实模板挂载失败回滚复现", "findings": ["R49"] },
"frontend/src/views/components/ThirdPartyAuthorization/ThirdPartyAuthorization.vue": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文,真实模板挂载失败回滚复现", "findings": ["R49"] },
"plugins/pmail_telegram_push/hook/runtime.go": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文读取,真实用户配置入口验证" },
"plugins/pmail_telegram_push/hook/setting.go": { "ranges": [[1, "EOF"]], "evidence": "接续全文,本段补齐输出截断部分" },
"plugins/pmail_telegram_push/hook/send.go": { "ranges": [[1, "EOF"]], "evidence": "全文复读及真实 SDK 内存请求复现", "findings": ["R46", "R47", "R48"] },
"plugins/pmail_telegram_push/hook/hook.go": { "ranges": [[1, "EOF"]], "evidence": "全文复读及真实收信钩子入口验证", "findings": ["R46"] },
"plugins/pmail_telegram_push/hook/bot.go": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文读取" },
"plugins/pmail_telegram_push/hook/html_utils.go": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文读取" },
"plugins/pmail_telegram_push/model/telegram_push.go": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文读取" },
"plugins/pmail_telegram_push/go.mod": { "ranges": [[1, "EOF"]], "evidence": "接续及本段全文读取依赖声明" },
"plugins/pmail_telegram_push/logger/logger.go": { "ranges": [[1, "EOF"]], "evidence": "本段全文读取" },
"backend/hooks/wechat_push/wechat_push.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要确认已补齐 206-399,全文完成" },
"backend/hooks/spam_block/export/export.go": { "ranges": [[1, "EOF"]], "evidence": "本段全文读取" },
"backend/hooks/framework/framework.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要确认全文,本段复核发送后钩子并隔离复现", "findings": ["R51"] },
"backend/hooks/spam_block/spam_block.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"backend/hooks/spam_block/tools/tools.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"backend/utils/async/async.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要及本段全文读取,并发线索待验证" },
"backend/utils/array/array.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"backend/utils/atomicfile/atomicfile.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"backend/utils/file/secure.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"backend/utils/ip/ip.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/App.vue": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取,真实挂载函数浏览器夹具验证", "findings": ["R50"] },
"plugins/pmail_telegram_push/src/utils/requests.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/utils/resize.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/types/index.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/api/setting.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/api/bot.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/api/resource.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/api/index.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/main.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/src/mock/index.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/main.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/package.json": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/vite.config.ts": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/index.html": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/config/config.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取,旧代码可达性待验证" },
"plugins/pmail_telegram_push/db/db.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取,旧代码可达性待验证" },
"plugins/pmail_telegram_push/dao/dao.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/dao/setting_dao_impl.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/db/repository/repository.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"plugins/pmail_telegram_push/service/setting_service.go": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"test/frontend/settings-menu.test.mjs": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取" },
"test/run.mjs": { "ranges": [[1, "EOF"]], "evidence": "接续摘要明确全文读取,核对隔离运行入口" }
}
}

View File

@ -0,0 +1,95 @@
import assert from 'node:assert/strict'
import test from 'node:test'
import { readFileSync } from 'node:fs'
import { compileFunction } from 'node:vm'
import { createRequire } from 'node:module'
const require = createRequire(new URL('../../frontend/package.json', import.meta.url))
const Vue = require('vue')
const { parse, compileScript } = require('@vue/compiler-sfc')
const read = extension => readFileSync(new URL(`../../frontend/src/views/components/RuleSettings/RuleSettings.${extension}`, import.meta.url), 'utf8')
test('规则编辑取消后,新建按钮必须创建独立规则且不能污染原列表', async () => {
const source = read('js').replace(/^import .*$/gm, '')
.replace('export function usePage', 'function usePage').replace(/export \{[^}]+\}\s*$/, '')
const original = {
id: 7, name: '原有规则', sort: 0, action: 1, params: '',
rules: [{ field: 'Subject', type: 'contains', rule: 'original' }]
}
const requests = []
const transport = {
post: async (url, body) => {
if (url.endsWith('/get')) return { errorNo: 0, data: [structuredClone(original)] }
requests.push({ url, body: JSON.parse(JSON.stringify(body)) })
return { errorNo: 0, data: '' }
},
get: async () => ({ errorNo: 0, data: [] })
}
const lang = { cancel: '取消', submit: '提交', new_rule: '新建规则' }
const usePage = compileFunction(source + '\nreturn usePage', [
'reactive', 'ref', 'lang', 'http', 'ElNotification', 'Delete', 'Edit', 'InfoFilled', 'Plus'
])(Vue.reactive, Vue.ref, lang, transport, () => {}, {}, {}, {}, {})
const { descriptor, errors } = parse(read('vue'))
assert.deepEqual(errors, [])
const compiled = compileScript(descriptor, { id: 'audit-rules', inlineTemplate: true })
const script = compiled.content
.replace(/import \{([^}]+)\} from ["']vue["']/g, (_, fields) => `const {${fields.replace(/\bas\b/g, ':')}} = Vue`)
.replace(/^import .*$/gm, '').replace('export default', 'return')
let page
const component = compileFunction(script, ['Vue', 'usePage', 'Plus'])(
Vue, () => { page = usePage(); return page }, {}
)
const node = tag => ({ tag, children: [] })
const renderer = Vue.createRenderer({
createElement: node, createText: text => ({ ...node('text'), text }), createComment: node,
setText: (item, text) => { item.text = text }, setElementText: (item, text) => { item.text = text },
parentNode: item => item.parent, nextSibling: () => null, remove() {},
insert: (item, parent) => { item.parent = parent; parent.children.push(item) },
patchProp: (item, key, previous, value) => { item[key] = value }
})
const app = renderer.createApp(component)
app.component('ElTable', { setup: () => () => Vue.h('audit-table') })
// 保留真实页面模板和点击处理器,只用简单容器呈现弹窗插槽。
app.component('ElDialog', {
setup(props, { slots }) {
return () => Vue.h('audit-dialog', [...(slots.default?.() || []), ...(slots.footer?.() || [])])
}
})
app.config.warnHandler = () => {}
const root = node('root')
app.mount(root)
const flatten = item => [item, ...item.children.flatMap(flatten)]
const textOf = item => (item.text || '') + item.children.map(textOf).join('')
try {
await Vue.nextTick()
await Vue.nextTick()
assert.equal(page.data.value.length, 1)
page.editRule(page.data.value[0])
page.addRuleForm.rules[0].rule = 'unsaved'
await Vue.nextTick()
const buttons = flatten(root).filter(item => item.tag === 'el-button')
const cancel = buttons.find(item => textOf(item).trim() === lang.cancel)
const create = buttons.find(item => item.class === 'add-btn')
console.log(`rule_buttons=${JSON.stringify(buttons.map(item => ({ text: textOf(item), class: item.class, click: typeof item.onClick })))}`)
assert.equal(typeof cancel?.onClick, 'function')
assert.equal(typeof create?.onClick, 'function')
cancel.onClick()
await Vue.nextTick()
assert.equal(page.dialogVisible.value, false)
const cancelledListRule = page.data.value[0].rules[0].rule
create.onClick()
await Vue.nextTick()
assert.equal(page.dialogVisible.value, true)
const newRuleID = page.addRuleForm.id
page.addRuleForm.name = '用户想新建的规则'
buttons.find(item => textOf(item).trim() === lang.submit).onClick()
await Vue.nextTick()
assert.equal(requests.length, 1)
console.log(`rule_actual=${JSON.stringify({ cancelledListRule, newRuleID, request: requests[0] })}`)
assert.deepEqual({ cancelledListRule, newRuleID, url: requests[0].url }, {
cancelledListRule: 'original', newRuleID: 0, url: '/api/v1/rule/add'
}, '取消必须丢弃编辑草稿,新建必须重置旧规则 ID')
} finally {
app.unmount()
}
})

View File

@ -0,0 +1,32 @@
import { spawn } from 'node:child_process'
import { createWriteStream } from 'node:fs'
import { mkdir, writeFile } from 'node:fs/promises'
import { fileURLToPath } from 'node:url'
import path from 'node:path'
const root = fileURLToPath(new URL('../../', import.meta.url))
const directory = path.join(root, 'test-log', `review-telegram-${new Date().toISOString().replace(/[:.]/g, '-')}`)
const temporary = path.join(directory, 'tmp')
await mkdir(temporary, { recursive: true })
const overlay = path.join(directory, 'overlay.json')
await writeFile(overlay, JSON.stringify({ Replace: {
[path.join(root, 'plugins/pmail_telegram_push/hook/audit_findings_test.go')]:
path.join(root, 'test/review/telegram_findings_test.go')
} }, null, 2) + '\n')
// 仅使用内存 HTTP 客户端;临时根和日志与开发配置隔离。
const log = createWriteStream(path.join(directory, 'telegram.log'))
const env = { ...process.env, SMAIL_ROOT: temporary, GOTMPDIR: temporary, TMPDIR: temporary, TEMP: temporary, TMP: temporary }
const extra = process.argv.slice(2)
const child = spawn('go', ['test', '-mod=readonly', `-overlay=${overlay}`, '-count=1', '-v', '-run=^TestAudit', ...extra, './hook'], {
cwd: path.join(root, 'plugins/pmail_telegram_push'), env, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe']
})
child.stdout.on('data', data => { process.stdout.write(data); log.write(data) })
child.stderr.on('data', data => { process.stderr.write(data); log.write(data) })
const code = await new Promise(resolve => {
child.once('error', error => { console.error(error); resolve(1) })
child.once('close', value => resolve(value ?? 1))
})
await new Promise(resolve => log.end(resolve))
console.log(`测试记录:${path.relative(root, directory)}`)
process.exitCode = code

View File

@ -0,0 +1,23 @@
import { spawnSync } from 'node:child_process'
import { mkdirSync, writeFileSync } from 'node:fs'
import { fileURLToPath } from 'node:url'
import path from 'node:path'
const root = fileURLToPath(new URL('../../', import.meta.url))
const directory = path.join(root, 'test-log', `review-windows-${Date.now()}`)
mkdirSync(directory, { recursive: true })
// Windows PowerShell 5 使用显式 UTF-8 读取,避免依赖系统代码页解释测试源码。
const command = `
[Console]::OutputEncoding = [Text.UTF8Encoding]::new($false)
$source = [IO.File]::ReadAllText('test/review/windows-install-findings.ps1', [Text.Encoding]::UTF8)
& ([scriptblock]::Create($source)) -WorkspaceRoot (Get-Location).Path
`
const result = spawnSync('powershell.exe', ['-NoProfile', '-Command', command], {
cwd: root, encoding: 'utf8', windowsHide: true
})
writeFileSync(path.join(directory, 'windows.log'), (result.stdout || '') + (result.stderr || ''))
process.stdout.write(result.stdout || '')
process.stderr.write(result.stderr || '')
if (result.error) console.error(result.error)
console.log(`测试记录:${path.relative(root, directory)}`)
process.exitCode = result.status ?? 1

64
test/review/run.mjs Normal file
View File

@ -0,0 +1,64 @@
import { spawn } from 'node:child_process'
import { mkdir, writeFile } from 'node:fs/promises'
import { fileURLToPath } from 'node:url'
import path from 'node:path'
const root = fileURLToPath(new URL('../../', import.meta.url))
const stamp = new Date().toISOString().replace(/[:.]/g, '-')
const directory = path.join(root, 'test-log', `audit-${stamp}-${process.pid}`)
await mkdir(directory, { recursive: true })
const replacements = {
'backend/hooks/framework/audit_findings_test.go': 'test/review/plugin_framework_findings_test.go',
'backend/services/totp/audit_findings_test.go': 'test/review/totp_findings_test.go',
'backend/services/setup/ssl/audit_findings_test.go': 'test/review/ssl_findings_test.go',
'backend/services/setup/audit_findings_test.go': 'test/review/setup_findings_test.go',
'backend/config/audit_findings_test.go': 'test/review/config_findings_test.go',
'backend/services/dbmigration/audit_findings_test.go': 'test/review/dbmigration_findings_test.go',
'backend/listen/http_server/audit_findings_test.go': 'test/review/http_findings_test.go',
'backend/listen/http_server/audit_external_email_findings_test.go': 'test/review/external_email_http_findings_test.go',
'backend/listen/http_server/audit_attachment_findings_test.go': 'test/review/attachment_http_findings_test.go',
'backend/services/list/audit_findings_test.go': 'test/review/list_findings_test.go',
'backend/services/recovery/audit_findings_test.go': 'test/review/recovery_findings_test.go',
'backend/listen/imap_server/audit_findings_test.go': 'test/review/imap_findings_test.go',
'backend/controllers/audit_findings_test.go': 'test/review/runtime_findings_test.go',
'backend/controllers/audit_controller_findings_test.go': 'test/review/controller_findings_test.go',
'backend/internal/gopop/audit_findings_test.go': 'test/review/pop3_parser_findings_test.go',
'backend/listen/pop3_server/audit_findings_test.go': 'test/review/pop3_action_findings_test.go',
'backend/dto/parsemail/audit_findings_test.go': 'test/review/message_findings_test.go',
'backend/listen/smtp_server/audit_findings_test.go': 'test/review/smtp_findings_test.go'
}
const Replace = Object.fromEntries(
Object.entries(replacements).map(([target, source]) => [path.join(root, target), path.join(root, source)])
)
const overlay = path.join(directory, 'overlay.json')
await writeFile(overlay, JSON.stringify({ Replace }, null, 2) + '\n')
// Go overlay 注入独立审查测试,不改动后端源码和默认测试入口。
const pop3Only = process.argv.includes('--pop3-only')
const messageOnly = process.argv.includes('--message-only')
const migrationOnly = process.argv.includes('--migration-only')
const configOnly = process.argv.includes('--config-only')
const controllersOnly = process.argv.includes('--controllers-only')
const httpOnly = process.argv.includes('--http-only')
const setupOnly = process.argv.includes('--setup-only')
const sslOnly = process.argv.includes('--ssl-only')
const totpOnly = process.argv.includes('--totp-only')
const frameworkOnly = process.argv.includes('--framework-only')
const packages = frameworkOnly ? ['./hooks/framework'] : totpOnly ? ['./services/totp'] : sslOnly ? ['./services/setup/ssl'] : setupOnly ? ['./services/setup'] : httpOnly ? ['./listen/http_server'] : controllersOnly ? ['./controllers'] : configOnly ? ['./config'] : migrationOnly ? ['./services/dbmigration'] : pop3Only ? ['./internal/gopop', './listen/pop3_server'] : messageOnly ? [
'./dto/parsemail', './listen/smtp_server'
] : [
'./services/dbmigration', './listen/http_server', './services/list', './services/recovery',
'./listen/imap_server', './controllers', './internal/gopop', './listen/pop3_server',
'./dto/parsemail', './listen/smtp_server', './config', './services/setup', './services/setup/ssl', './services/totp', './hooks/framework'
]
const extra = process.argv.slice(2).filter(argument => !['--pop3-only', '--message-only', '--migration-only', '--config-only', '--controllers-only', '--http-only', '--setup-only', '--ssl-only', '--totp-only', '--framework-only'].includes(argument))
const selection = extra.some(argument => argument === '-run' || argument.startsWith('-run=')) ? [] : ['-run=^TestAudit']
const child = spawn(process.execPath, [
path.join(root, 'test/run.mjs'), 'backend', `-overlay=${overlay}`,
...extra, '-count=1', '-v', ...selection, ...packages
], { cwd: root, windowsHide: true, stdio: 'inherit' })
child.once('error', error => {
console.error(error)
process.exitCode = 1
})
child.once('close', code => { process.exitCode = code ?? 1 })

View File

@ -0,0 +1,31 @@
package controllers
import (
"sync"
"testing"
)
// 并发模拟停止阶段清空安全服务与在途控制器获取服务;必须以 -race 运行。
func TestAuditWebAuthnRuntimePublication(t *testing.T) {
previous := webAuthnRuntime()
t.Cleanup(func() { ConfigureWebAuthnRuntime(previous) })
start := make(chan struct{})
var workers sync.WaitGroup
workers.Add(2)
go func() {
defer workers.Done()
<-start
for index := 0; index < 1000; index++ {
ConfigureWebAuthnRuntime(nil)
}
}()
go func() {
defer workers.Done()
<-start
for index := 0; index < 1000; index++ {
_ = webAuthnRuntime()
}
}()
close(start)
workers.Wait()
}

View File

@ -0,0 +1,66 @@
package setup
import (
"path/filepath"
"testing"
"git.pcux.cn/xuans/Smail/config"
"git.pcux.cn/xuans/Smail/db"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/access"
requestcontext "git.pcux.cn/xuans/Smail/utils/context"
)
// 使用独立临时库和真实版本化迁移,不读取或改动开发服务数据库。
func TestAuditFirstAdministratorMustHaveSuperAdminRole(t *testing.T) {
oldConfig, oldSnapshot := config.Instance, config.CurrentConfig()
oldManager, oldDB := config.CurrentManager(), db.Instance
t.Setenv("SMAIL_ENABLE_LEGACY_SYNC2", "0")
config.Instance = &config.Config{
DbType: config.DBTypeSQLite,
DbDSN: filepath.Join(t.TempDir(), "first-admin.db"),
}
config.PublishConfigSnapshot(config.Instance)
config.SetRuntimeManager(nil)
db.Instance = nil
t.Cleanup(func() {
if db.Instance != nil && db.Instance != oldDB {
_ = db.Instance.Close()
}
db.Instance = oldDB
config.Instance = oldConfig
config.PublishConfigSnapshot(oldSnapshot)
config.SetRuntimeManager(oldManager)
})
if err := db.Init(""); err != nil {
t.Fatal(err)
}
if err := SetAdminPassword(&requestcontext.Context{}, "audit-admin", "AuditPass12"); err != nil {
t.Fatal(err)
}
for _, stage := range []string{"created", "restarted"} {
if stage == "restarted" {
if err := db.Instance.Close(); err != nil {
t.Fatal(err)
}
db.Instance = nil
if err := db.Init(""); err != nil {
t.Fatal(err)
}
}
var user models.User
found, err := db.Instance.Where("account = ?", "audit-admin").Get(&user)
if err != nil || !found {
t.Fatalf("读取初始化账户失败: found=%t err=%v", found, err)
}
canReadConfig, canManageRole := false, false
for _, capability := range access.Capabilities(user.EffectiveRole()) {
canReadConfig = canReadConfig || capability == access.CapabilityConfigRead
canManageRole = canManageRole || capability == access.CapabilityRoleManage
}
t.Logf("stage=%s is_admin=%d role=%q effective_role=%q config_read=%t role_manage=%t", stage, user.IsAdmin, user.Role, user.EffectiveRole(), canReadConfig, canManageRole)
if user.EffectiveRole() != access.RoleSuperAdmin || !canReadConfig || !canManageRole {
t.Errorf("%s: 初始化管理员必须获得超级管理员角色和管理能力", stage)
}
}
}

View File

@ -0,0 +1,47 @@
package smtp_server
import (
"net/http/httptest"
"strings"
"testing"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/dto/response"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/services/detail"
"git.pcux.cn/xuans/Smail/utils/context"
)
func TestAuditInboundBCCMustNotLeakToVisibleRecipient(t *testing.T) {
engine, _ := newAuditTestEngine(t)
visible := models.User{Account: "visible", Name: "Visible"}
hidden := models.User{Account: "hidden", Name: "Hidden"}
if _, err := engine.Insert(&visible, &hidden); err != nil {
t.Fatal(err)
}
raw := "From: sender@example.net\r\n" +
"To: visible@example.com\r\n" +
"Message-ID: <audit-private-recipient@example.net>\r\n" +
"Subject: privacy\r\nContent-Type: text/plain\r\n\r\nbody"
envelope := []string{"visible@example.com", "hidden@example.com"}
parsed, err := parsemail.NewEmailFromReader(envelope, strings.NewReader(raw), len(raw))
if err != nil {
t.Fatal(err)
}
users, stored, err := saveEmail(&context.Context{}, len(raw), parsed, 0, 0, envelope, true, true)
if err != nil || stored == nil || len(users) != 2 {
t.Fatalf("多收件人入库前置条件失败: users=%d stored=%v err=%v", len(users), stored != nil, err)
}
data, err := detail.GetEmailDetail(&context.Context{UserID: visible.ID}, stored.Id, false)
if err != nil {
t.Fatal(err)
}
// 执行网页详情使用的真实服务和响应序列化,不依赖 UI 是否显示该字段。
recorder := httptest.NewRecorder()
response.NewSuccessResponse(data).FPrint(recorder)
leaked := strings.Contains(recorder.Body.String(), "hidden@example.com")
t.Logf("raw_contains_hidden_recipient=%v persisted_recipient_count=%d visible_response_contains_hidden_recipient=%v", strings.Contains(raw, "hidden@example.com"), len(users), leaked)
if leaked {
t.Fatal("普通可见收件人的邮件详情响应泄露了仅存在于信封中的密送地址")
}
}

View File

@ -0,0 +1,215 @@
package ssl
import (
"bytes"
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/tls"
"crypto/x509"
"crypto/x509/pkix"
"encoding/json"
"encoding/pem"
"math/big"
"os"
"path/filepath"
"testing"
"time"
"git.pcux.cn/xuans/Smail/config"
"github.com/go-acme/lego/v4/certificate"
)
// 构造根、中间和叶证书,模拟 ACME 的完整链响应;不请求真实 CA。
func auditCertificateChain(t *testing.T, domain string, extraDomains ...string) certificate.Resource {
t.Helper()
createKey := func() *ecdsa.PrivateKey {
key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
if err != nil {
t.Fatal(err)
}
return key
}
rootKey, issuerKey, leafKey := createKey(), createKey(), createKey()
makeTemplate := func(serial int64, name string, ca bool) *x509.Certificate {
return &x509.Certificate{
SerialNumber: big.NewInt(serial), Subject: pkix.Name{CommonName: name},
NotBefore: time.Now().Add(-time.Hour), NotAfter: time.Now().Add(90 * 24 * time.Hour),
IsCA: ca, BasicConstraintsValid: true, KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
}
}
root := makeTemplate(1, "Audit Root", true)
issuer := makeTemplate(2, "Audit Intermediate", true)
leaf := makeTemplate(3, domain, false)
leaf.DNSNames = []string{domain}
leaf.DNSNames = append(leaf.DNSNames, extraDomains...)
leaf.KeyUsage = x509.KeyUsageDigitalSignature
leaf.ExtKeyUsage = []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth}
encode := func(template, parent *x509.Certificate, key, signingKey *ecdsa.PrivateKey) []byte {
der, err := x509.CreateCertificate(rand.Reader, template, parent, &key.PublicKey, signingKey)
if err != nil {
t.Fatal(err)
}
return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
}
issuerPEM := encode(issuer, root, issuerKey, rootKey)
leafPEM := encode(leaf, issuer, leafKey, issuerKey)
privateDER, err := x509.MarshalECPrivateKey(leafKey)
if err != nil {
t.Fatal(err)
}
return certificate.Resource{
PrivateKey: pem.EncodeToMemory(&pem.Block{Type: "EC PRIVATE KEY", Bytes: privateDER}),
Certificate: append(leafPEM, issuerPEM...), IssuerCertificate: issuerPEM,
}
}
func auditSSLRoot(t *testing.T) {
t.Helper()
oldRoot, oldConfig, oldSnapshot := config.ROOT_PATH, config.Instance, config.CurrentConfig()
oldManager := config.CurrentManager()
config.ROOT_PATH = t.TempDir()
config.SetRuntimeManager(nil)
t.Cleanup(func() {
config.ROOT_PATH, config.Instance = oldRoot, oldConfig
config.PublishConfigSnapshot(oldSnapshot)
config.SetRuntimeManager(oldManager)
})
}
func TestAuditACMEBundledChainMustBeImportable(t *testing.T) {
auditSSLRoot(t)
resource := auditCertificateChain(t, "imap.example.test")
if _, err := tls.X509KeyPair(resource.Certificate, resource.PrivateKey); err != nil {
t.Fatal(err)
}
if err := config.ValidateSSLMaterial(resource.PrivateKey, resource.Certificate, nil, []string{"imap.example.test"}); err != nil {
t.Fatalf("正常完整链对照失败: %v", err)
}
cfg := &config.Config{Domain: "imap.example.test", SSLType: config.SSLTypeAutoHTTP}
err := writeCertificateFiles(cfg, resource.PrivateKey, resource.Certificate, resource.IssuerCertificate)
t.Logf("bundle_only_valid=true bundle_plus_issuer_write_error=%v", err)
if err != nil {
t.Fatalf("ACME Bundle=true 的完整链与单独 issuer 字段不应导致正常签发结果被拒绝: %v", err)
}
}
func TestAuditFreshWildcardCertificateMustNotRequireRenewal(t *testing.T) {
auditSSLRoot(t)
cfg := &config.Config{Domain: "example.test", WebDomain: "web.example.test", SSLType: config.SSLTypeAutoDNS}
resource := auditCertificateChain(t, "*.example.test")
// 不再附加 issuer,以隔离完整链重复问题和续期判断问题。
if err := writeCertificateFiles(cfg, resource.PrivateKey, resource.Certificate, nil); err != nil {
t.Fatal(err)
}
pair, err := config.LoadRuntimeTLSCertificate(cfg)
if err != nil {
t.Fatal(err)
}
leaf, err := x509.ParseCertificate(pair.Certificate[0])
if err != nil {
t.Fatal(err)
}
if err := leaf.VerifyHostname("imap.example.test"); err != nil {
t.Fatalf("泛域名覆盖 IMAP 的前提不成立: %v", err)
}
days, _, mismatch, err := CheckSSLCrtInfo()
if err != nil {
t.Fatal(err)
}
t.Logf("days_remaining=%d imap_hostname_valid=true name_match_fail=%t renewal_predicate=%t", days, mismatch, days < 30 || mismatch)
if days < 30 || mismatch {
t.Fatal("新签发且覆盖服务域名的泛域名证书不应立即触发续期")
}
}
// 只在临时根目录建立受控证书和真实分区配置,不接触运行中的实例。
func auditMigratedSSL(t *testing.T, mode string) (*config.Config, []byte) {
t.Helper()
auditSSLRoot(t)
resource := auditCertificateChain(t, "imap.example.test", "smtp.imap.example.test", "pop.imap.example.test", "imap.imap.example.test")
reference, err := config.ImportManagedSSL(config.ManagedSSLModeDefault, resource.PrivateKey, resource.Certificate, nil, nil)
if err != nil {
t.Fatal(err)
}
legacy := map[string]any{
"logLevel": "info",
"domain": "imap.example.test",
"webDomain": "imap.example.test",
"dbType": "sqlite",
"dbDSN": "./config/review.db",
"isInit": true,
"sslType": mode,
"SSLPublicKeyPath": reference.CertificateRef,
"SSLPrivateKeyPath": reference.PrivateKeyRef,
"httpPort": 80,
"httpsPort": 443,
"httpsEnabled": 1,
}
data, err := json.Marshal(legacy)
if err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(config.ROOT_PATH, "config", "config.json"), data, 0600); err != nil {
t.Fatal(err)
}
if _, err := config.MigrateLegacyConfig(config.ROOT_PATH, config.RuntimeValidationOptions{HasSuperAdmin: true, Production: true}); err != nil {
t.Fatal(err)
}
cfg, err := config.ReadConfig()
if err != nil {
t.Fatal(err)
}
if !cfg.IsSetupReady() {
t.Fatal("分区配置未达到可用状态,无法验证续期路径")
}
return cfg, resource.Certificate
}
func TestAuditPartitionedRenewalMustCommitBeforeSwitch(t *testing.T) {
cfg, original := auditMigratedSSL(t, config.SSLTypeAutoHTTP)
loaded, err := config.LoadRuntimeTLSCertificate(cfg)
if err != nil {
t.Fatal(err)
}
rootPath := filepath.Join(config.ROOT_PATH, "config", "config.json")
before, err := os.ReadFile(rootPath)
if err != nil {
t.Fatal(err)
}
resource := auditCertificateChain(t, "imap.example.test", "smtp.imap.example.test", "pop.imap.example.test", "imap.imap.example.test")
writeErr := writeCertificateFiles(cfg, resource.PrivateKey, resource.Certificate, nil)
after, err := os.ReadFile(rootPath)
if err != nil {
t.Fatal(err)
}
persisted, err := config.ReadConfig()
if err != nil {
t.Fatal(err)
}
certificatePath, _, err := config.ResolveRuntimeSSLPaths(persisted)
if err != nil {
t.Fatal(err)
}
current, err := os.ReadFile(certificatePath)
if err != nil {
t.Fatal(err)
}
currentPair, err := config.LoadRuntimeTLSCertificate(persisted)
if err != nil {
t.Fatal(err)
}
t.Logf("write_error=%v root_unchanged=%t current_changed=%t current_is_new=%t loaded_tls_is_old=%t",
writeErr, bytes.Equal(before, after), !bytes.Equal(original, current), bytes.Equal(current, resource.Certificate), !bytes.Equal(loaded.Certificate[0], currentPair.Certificate[0]))
if writeErr != nil {
t.Fatal("分区配置的自动续期仍调用旧写入接口,失败后受控证书已经切换")
}
}
func TestAuditPartitionedMigrationMustPreserveDNSChallengeMode(t *testing.T) {
cfg, _ := auditMigratedSSL(t, config.SSLTypeAutoDNS)
t.Logf("before_ssl_type=%s after_ssl_type=%s before_dns_challenge=true after_http_challenge=%t", config.SSLTypeAutoDNS, cfg.SSLType, cfg.SSLType == config.SSLTypeAutoHTTP)
if cfg.SSLType != config.SSLTypeAutoDNS {
t.Fatal("自动 DNS 配置迁移后不应静默改成 HTTP 挑战")
}
}

View File

@ -0,0 +1,152 @@
package hook
import (
"bytes"
"encoding/json"
"fmt"
"html"
"io"
"mime"
"mime/multipart"
"net/http"
"path"
"strings"
"testing"
"time"
"unicode/utf8"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"github.com/go-telegram/bot"
"github.com/ydzydzydz/pmail_telegram_push/model"
)
type auditTelegramRequest struct {
method string
fields map[string]string
files int
}
type auditTelegramClient struct {
requests []auditTelegramRequest
}
func (c *auditTelegramClient) Do(request *http.Request) (*http.Response, error) {
// 完整消费 SDK 的管道请求体,不建立任何网络连接。
data, err := io.ReadAll(request.Body)
if err != nil {
return nil, err
}
defer request.Body.Close()
_, params, err := mime.ParseMediaType(request.Header.Get("Content-Type"))
if err != nil {
return nil, err
}
reader := multipart.NewReader(bytes.NewReader(data), params["boundary"])
captured := auditTelegramRequest{method: path.Base(request.URL.Path), fields: make(map[string]string)}
for {
part, err := reader.NextPart()
if err == io.EOF {
break
}
if err != nil {
return nil, err
}
value, err := io.ReadAll(part)
if err != nil {
return nil, err
}
captured.fields[part.FormName()] = string(value)
if part.FileName() != "" {
captured.files++
}
}
c.requests = append(c.requests, captured)
result := `{"ok":true,"result":{"message_id":1}}`
if captured.method == "sendMediaGroup" {
result = `{"ok":true,"result":[]}`
}
return &http.Response{StatusCode: http.StatusOK, Body: io.NopCloser(strings.NewReader(result)), Header: make(http.Header)}, nil
}
func auditTelegramHook(t *testing.T) (*PmailTelegramPushHook, *auditTelegramClient) {
t.Helper()
client := &auditTelegramClient{}
instance, err := bot.New("1:audit-placeholder-not-a-real-token", bot.WithSkipGetMe(), bot.WithHTTPClient(time.Second, client))
if err != nil {
t.Fatal(err)
}
hook := NewPmailTelegramPushHook()
hook.bot = instance
hook.pluginConfig = pluginSettings{Timeout: 5}
return hook, client
}
func TestAuditDisabledAttachmentsMustNotBeSent(t *testing.T) {
for _, enabled := range []bool{false, true} {
t.Run(fmt.Sprintf("enabled=%v", enabled), func(t *testing.T) {
hook, client := auditTelegramHook(t)
settings := json.RawMessage(fmt.Sprintf(`{"chatId":"123","sendAttachments":%v}`, enabled))
if err := hook.ConfigureUserSettings(1, settings); err != nil {
t.Fatal(err)
}
email := &parsemail.Email{MessageId: 1, From: &parsemail.User{EmailAddress: "sender@example.invalid"},
Attachments: []*parsemail.Attachment{
{Filename: "first.txt", Content: []byte("audit-first")},
{Filename: "second.txt", Content: []byte("audit-second")},
}}
hook.ReceiveSaveAfter(nil, email, []*models.UserEmail{{UserID: 1}})
messages, files := 0, 0
for _, request := range client.requests {
if request.method == "sendMessage" {
messages++
}
files += request.files
}
t.Logf("enabled=%v messages=%d uploaded_files=%d", enabled, messages, files)
if messages != 1 {
t.Fatalf("通知调用链未成功执行:%d", messages)
}
if !enabled && files != 0 {
t.Errorf("已关闭附件发送,仍上传 %d 个附件", files)
}
if enabled && files != 2 {
t.Errorf("启用附件发送的对照未上传完整附件")
}
})
}
}
func TestAuditTelegramPlainTextMustBeEscaped(t *testing.T) {
hook, client := auditTelegramHook(t)
subject := "<audit-subject> & status"
content := "<audit-body> & details"
email := &parsemail.Email{From: &parsemail.User{}, Subject: subject, Text: []byte(content)}
_, err := hook.sendText(email, &model.TelegramPushSetting{ChatID: "123", ShowContent: true})
if err != nil {
t.Fatal(err)
}
request := client.requests[0]
t.Logf("parse_mode=%q raw_subject=%v raw_body=%v", request.fields["parse_mode"],
strings.Contains(request.fields["text"], subject), strings.Contains(request.fields["text"], content))
if request.fields["parse_mode"] != "HTML" {
t.Fatal("测试前提不满足:未启用 HTML 解析")
}
if !strings.Contains(request.fields["text"], html.EscapeString(subject)) || !strings.Contains(request.fields["text"], html.EscapeString(content)) {
t.Error("主题和纯文本正文没有作为普通文字转义")
}
}
func TestAuditTelegramTruncationMustKeepUTF8(t *testing.T) {
hook, _ := auditTelegramHook(t)
for prefix := 0; prefix < 3; prefix++ {
t.Run(fmt.Sprintf("prefix=%d", prefix), func(t *testing.T) {
email := &parsemail.Email{From: &parsemail.User{}, Text: []byte(strings.Repeat("x", prefix) + strings.Repeat("中", 2000))}
text := hook.buildSendText(email, &model.TelegramPushSetting{ShowContent: true})
t.Logf("source_valid=%v output_bytes=%d output_valid=%v", utf8.Valid(email.Text), len(text), utf8.ValidString(text))
if !utf8.ValidString(text) {
t.Error("正常中文被截断为无效 UTF-8")
}
})
}
}

View File

@ -0,0 +1,27 @@
package totp
import (
"sync"
"testing"
)
// 同一用户并发打开绑定流程,检查返回密钥与旧登记清理之间的数据竞争。
func TestAuditConcurrentEnrollmentMustNotRaceSecretEncoding(t *testing.T) {
service, engine := newTestService(t)
engine.SetMaxOpenConns(1)
var workers sync.WaitGroup
for index := 0; index < 16; index++ {
workers.Add(1)
go func() {
defer workers.Done()
for attempt := 0; attempt < 150; attempt++ {
if _, err := service.BeginEnrollment(1, "audit-user"); err != nil {
t.Errorf("并发初始化认证器失败: %v", err)
return
}
}
}()
}
workers.Wait()
t.Log("concurrent_enrollment_requests=2400")
}

View File

@ -0,0 +1,126 @@
param([string]$WorkspaceRoot = (Join-Path $PSScriptRoot '..\..'))
$ErrorActionPreference = 'Stop'
$workspace = [IO.Path]::GetFullPath($WorkspaceRoot)
$scriptPath = Join-Path $workspace 'deploy\install-windows.ps1'
$tokens = $null
$parseErrors = $null
$scriptText = [IO.File]::ReadAllText($scriptPath, [Text.Encoding]::UTF8)
$ast = [Management.Automation.Language.Parser]::ParseInput($scriptText, [ref]$tokens, [ref]$parseErrors)
if ($parseErrors.Count -ne 0) {
throw '安装脚本存在语法错误,停止隔离验证'
}
$tries = @($ast.EndBlock.Statements | Where-Object { $_ -is [Management.Automation.Language.TryStatementAst] })
if ($tries.Count -ne 1) {
throw '安装脚本事务结构已改变,需要重新审核测试入口'
}
$allowedCommands = @('Stop-SmailService', 'Copy-Item', 'Test-Path', 'Move-Item', 'Get-Service', 'Invoke-Native', 'Set-RestrictedAcl', 'Write-Output', 'Start-Service', 'Remove-Item', 'Join-Path')
$commands = $tries[0].FindAll({ param($node) $node -is [Management.Automation.Language.CommandAst] }, $true)
foreach ($command in $commands) {
if ($command.GetCommandName() -notin $allowedCommands) {
throw "发现未隔离的命令,拒绝执行:$($command.GetCommandName())"
}
}
# 只执行真实事务语句,所有文件和服务操作均为内存函数桩,不执行安装脚本主体。
$transaction = [scriptblock]::Create($tries[0].Extent.Text)
$results = @()
foreach ($stage in @('stop', 'copy-main', 'copy-admin', 'backup-main', 'backup-admin', 'install-main')) {
$results += & {
param($failureStage, $body)
$virtualRoot = [IO.Path]::GetFullPath((Join-Path $workspace 'test-log\virtual-install-audit'))
$resolvedInstallRoot = Join-Path $virtualRoot 'install'
$transactionRoot = Join-Path $resolvedInstallRoot '.upgrade-audit'
$backupRoot = Join-Path $resolvedInstallRoot '.backup-audit'
$mainSource = Join-Path $virtualRoot 'package\smail.exe'
$adminSource = Join-Path $virtualRoot 'package\smail-admin.exe'
$mainTarget = Join-Path $resolvedInstallRoot 'smail.exe'
$adminTarget = Join-Path $resolvedInstallRoot 'smail-admin.exe'
$mainBackup = Join-Path $backupRoot 'smail.exe'
$adminBackup = Join-Path $backupRoot 'smail-admin.exe'
$serviceCreated = $false
$StartService = $false
$state = @{
Files = @{}
Operations = [Collections.Generic.List[string]]::new()
Injected = $false
}
$state.Files[$mainSource] = 'new-main'
$state.Files[$adminSource] = 'new-admin'
$state.Files[$mainTarget] = 'old-main'
$state.Files[$adminTarget] = 'old-admin'
function Assert-AuditPath {
param([string]$Value)
$absolute = [IO.Path]::GetFullPath($Value)
if (-not $absolute.StartsWith($virtualRoot + '\', [StringComparison]::OrdinalIgnoreCase)) {
throw '模拟路径超出隔离范围'
}
}
function Invoke-Failure {
param([string]$Stage)
if ($failureStage -eq $Stage -and -not $state.Injected) {
$state.Injected = $true
throw "audit-injected:$Stage"
}
}
function Stop-SmailService {
Invoke-Failure 'stop'
}
function Test-Path {
param([string]$LiteralPath)
Assert-AuditPath $LiteralPath
return $state.Files.ContainsKey($LiteralPath)
}
function Copy-Item {
param([string]$LiteralPath, [string]$Destination)
Assert-AuditPath $LiteralPath
Assert-AuditPath $Destination
if ($LiteralPath -eq $mainSource) { Invoke-Failure 'copy-main' }
if ($LiteralPath -eq $adminSource) { Invoke-Failure 'copy-admin' }
$state.Files[$Destination] = $state.Files[$LiteralPath]
$state.Operations.Add("copy:$LiteralPath")
}
function Move-Item {
param([string]$LiteralPath, [string]$Destination, [switch]$Force)
Assert-AuditPath $LiteralPath
Assert-AuditPath $Destination
if ($LiteralPath -eq $mainTarget) { Invoke-Failure 'backup-main' }
if ($LiteralPath -eq $adminTarget) { Invoke-Failure 'backup-admin' }
if ($Destination -eq $mainTarget -and $LiteralPath -ne $mainBackup) { Invoke-Failure 'install-main' }
$state.Files[$Destination] = $state.Files[$LiteralPath]
$state.Files.Remove($LiteralPath)
$state.Operations.Add("move:$LiteralPath")
}
function Remove-Item {
param([string]$LiteralPath, [switch]$Recurse, [switch]$Force)
Assert-AuditPath $LiteralPath
$state.Files.Remove($LiteralPath)
$state.Operations.Add("remove:$LiteralPath")
}
function Get-Service { throw '不得调用真实系统服务' }
function Invoke-Native { throw '不得调用原生系统工具' }
function Set-RestrictedAcl { throw '不得修改真实权限' }
function Start-Service { throw '不得启动真实服务' }
$caught = ''
try {
& $body
} catch {
$caught = $_.Exception.Message
}
if ($caught -ne "audit-injected:$failureStage") {
throw "隔离失败注入未按预期命中:$caught"
}
[pscustomobject]@{
Stage = $failureStage
OriginalMainPreserved = $state.Files[$mainTarget] -eq 'old-main'
OriginalAdminPreserved = $state.Files[$adminTarget] -eq 'old-admin'
Operations = @($state.Operations.ToArray())
}
} $stage $transaction
}
$results | ConvertTo-Json -Depth 5
if (@($results | Where-Object { -not $_.OriginalMainPreserved -or -not $_.OriginalAdminPreserved }).Count -gt 0) {
throw '安装事务在备份完成前失败时,回滚会删除未被替换的旧程序;以上操作全部为内存模拟'
}