fix:"隔离验证码投递并统一密码重置受理"
Repository verification / backend (push) Canceled after 0s
Repository verification / frontend (push) Canceled after 0s

This commit is contained in:
xpp committed 2026-10-22 08:49:04 +08:00
1 parent 02c21e5c19
commit ba5dbc195e
16 files changed
+639 -57

No files matched your search

+3 -1
View File
@@ -8,10 +8,12 @@
## 当前工程状态
2026-10-21:当前产品为 Java/Vue 自研控制面与多模型网关,已补请求模块化、账务恢复、异步幂等和审计核账,并继续加固认证与 HTTP 边界。本轮补齐了服务端参考图下载的 DNS 地址绑定与直连隔离;生产网络策略仍需验收。下文包含产品演进目标,不等于功能均已实现。**尚未完成完整 Codex WebSocket/续接、长请求续租、公平排队、账号全生命周期和生产安全验收。**
2026-10-22:当前产品为 Java/Vue 自研控制面与多模型网关,已补请求模块化、账务恢复、异步幂等和审计核账,并继续加固认证与 HTTP 边界。服务端参考图下载已补 DNS 地址绑定;注册/重置已补事务原子性与加密异步验证码投递,重置请求不再查询账号存在性或等待外部发送结果。生产网络策略仍需验收。下文包含产品演进目标,不等于功能均已实现。**尚未完成完整 Codex WebSocket/续接、长请求续租、公平排队、账号全生命周期和生产安全验收。**
逐项完成状态与剩余验收见 [安全与 CPR 任务追踪](docs/24-security-and-cpr-task-tracker.md),认证边界见 [认证及有界 HTTP 增量](docs/25-auth-and-bounded-transport.md),出站加固与验收阻塞见 [媒体 DNS 绑定与验收状态](docs/26-media-dns-binding-and-acceptance.md),注册/重置原子性见 [验证码与账号事务](docs/27-verified-account-transactions.md)。本地验证通过不代表已部署或全仓库安全审计完成。
最新 [验证码投递隔离](docs/28-verification-delivery-isolation.md) 需要先迁移 V50,并配置 `CREDENTIAL_ENCRYPTION_KEY` 及邮件/短信服务。2026-10-22 用户要求的每半小时本地提交检查已取消;产品内部的任务与投递 worker 不属于该聊天自动化。
## 一、产品简介
模亦灵枢是由模灵科技与亦城财富等合作方共同推动的多模型智能服务平台。
@@ -26,6 +26,11 @@ public class CloudVerificationSender implements VerificationSender {
@Override
public void send(String channel,String account,String code) {
send(channel,account,code,VerificationPurpose.REGISTRATION);
}
@Override
public void send(String channel,String account,String code,VerificationPurpose purpose) {
if(!available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503);
try {
if("email".equals(channel)) {
@@ -47,8 +52,8 @@ public class CloudVerificationSender implements VerificationSender {
SimpleMailMessage message=new SimpleMailMessage();
message.setFrom(value("MOYI_SMTP_FROM"));
message.setTo(account);
message.setSubject("MOYI 注册验证码");
message.setText("您的注册验证码为:"+code+",5 分钟内有效。请勿向他人泄露。若非本人操作,请忽略此邮件。");
message.setSubject("MOYI "+purpose.label+"验证码");
message.setText("您的"+purpose.label+"验证码为:"+code+",5 分钟内有效。请勿向他人泄露。若非本人操作,请忽略此邮件。");
mail.send(message);
} else {
Config config=new Config().setAccessKeyId(value("MOYI_SMS_ACCESS_KEY_ID")).setAccessKeySecret(value("MOYI_SMS_ACCESS_KEY_SECRET")).setEndpoint("dysmsapi.aliyuncs.com").setProtocol("https");
@@ -57,8 +62,7 @@ public class CloudVerificationSender implements VerificationSender {
.setSignName(value("MOYI_SMS_SIGN_NAME")).setTemplateCode(value("MOYI_SMS_TEMPLATE_CODE")).setTemplateParam("{\"code\":\""+code+"\"}");
var response=client.sendSmsWithOptions(request,new RuntimeOptions().setAutoretry(false).setConnectTimeout(5000).setReadTimeout(10000));
if(response.getBody()==null || !"OK".equals(response.getBody().getCode())) {
String resultCode = response.getBody() == null ? "EMPTY_RESPONSE" : String.valueOf(response.getBody().getCode());
log.warn("Aliyun SMS verification rejected: resultCode={}", resultCode);
log.warn("Aliyun SMS verification rejected");
throw new IllegalStateException("SMS rejected");
}
}
@@ -0,0 +1,134 @@
package com.moyi.controlplane.auth;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.moyi.controlplane.common.ApiException;
import com.moyi.controlplane.security.SecretCipher;
import jakarta.annotation.PreDestroy;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.RejectedExecutionException;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.support.TransactionTemplate;
/** Durable, encrypted single-attempt delivery. Never hold a DB transaction over a mail/SMS call. */
@Service
public class VerificationDispatchService {
private static final Logger log = LoggerFactory.getLogger(VerificationDispatchService.class);
private final JdbcTemplate jdbc;
private final VerificationSender sender;
private final SecretCipher cipher;
private final ObjectMapper json;
private final TransactionTemplate transactions;
private final ExecutorService workers = new ThreadPoolExecutor(0, 2, 30, TimeUnit.SECONDS, new SynchronousQueue<>(),
task -> { var thread=new Thread(task, "verification-delivery"); thread.setDaemon(true); return thread; },
new ThreadPoolExecutor.AbortPolicy());
public VerificationDispatchService(JdbcTemplate jdbc, VerificationSender sender, SecretCipher cipher,
ObjectMapper json, PlatformTransactionManager manager) {
this.jdbc=jdbc; this.sender=sender; this.cipher=cipher; this.json=json;
transactions=new TransactionTemplate(manager);
transactions.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
}
public boolean available(String channel) { return cipher.isConfigured() && sender.available(channel); }
/** Called only after common quotas; code generation and queue insert commit or roll back together. */
@Transactional(propagation=Propagation.MANDATORY)
public void enqueue(VerificationPurpose purpose, String account, String code, String codeHash) {
UUID id=UUID.randomUUID();
String payload;
try { payload=cipher.encrypt(json.writeValueAsString(Map.of("id",id.toString(),"purpose",purpose.key,"account",account,"code",code))); }
catch (ApiException error) { throw error; }
catch (Exception error) { throw new ApiException("VERIFICATION_QUEUE_FAILED", "验证码服务暂时不可用", 503); }
jdbc.update("INSERT INTO "+purpose.table+"(account,code_hash,expires_at,delivery_id) VALUES (?,?,clock_timestamp()+interval '5 minutes',?) ON CONFLICT(account) DO UPDATE SET code_hash=excluded.code_hash,expires_at=excluded.expires_at,attempts=0,consumed=false,created_at=clock_timestamp(),delivery_id=excluded.delivery_id", account,codeHash,id);
jdbc.update("INSERT INTO verification_delivery_outbox(id,purpose,payload_ciphertext) VALUES (?,?,?)",id,purpose.key,payload);
}
@Scheduled(fixedDelayString="${moyi.auth.verification-dispatch-interval-ms:1000}")
public void dispatchPending() {
// No queue behind these two workers: a slow provider cannot consume unbounded threads/tasks.
for (int i=0;i<2;i++) {
try { workers.submit(() -> {
try { dispatchOne(); }
catch (RuntimeException error) { log.warn("Verification delivery persistence failed; no automatic replay"); }
}); } catch (RejectedExecutionException busyOrStopping) { break; }
}
}
private record Attempt(UUID id, VerificationPurpose purpose, String ciphertext) {
@Override public String toString() { return "VerificationAttempt[id="+id+"]"; }
}
/** Package-visible for isolated deterministic database tests; not an HTTP operation. */
boolean dispatchOne() {
Attempt attempt=transactions.execute(status -> {
var rows=jdbc.queryForList("SELECT id,purpose,payload_ciphertext FROM verification_delivery_outbox WHERE status='queued' AND expires_at>clock_timestamp() ORDER BY created_at,id LIMIT 1 FOR UPDATE SKIP LOCKED");
if (rows.isEmpty()) return null;
var row=rows.getFirst(); UUID id=(UUID)row.get("id");
jdbc.update("UPDATE verification_delivery_outbox SET status='sending',started_at=clock_timestamp() WHERE id=?",id);
return new Attempt(id,VerificationPurpose.fromKey(String.valueOf(row.get("purpose"))),String.valueOf(row.get("payload_ciphertext")));
});
if (attempt==null) { cleanupExpired(); return false; }
try {
var payload=json.readTree(cipher.decrypt(attempt.ciphertext()));
if (!attempt.id().toString().equals(payload.path("id").asText())
|| !attempt.purpose().key.equals(payload.path("purpose").asText())
|| !payload.path("code").asText().matches("[0-9]{6}")) throw new IllegalArgumentException("Invalid delivery envelope");
String account=payload.path("account").asText(), code=payload.path("code").asText();
if (!isCurrent(attempt,account)) { finish(attempt,"discarded","SUPERSEDED_OR_INACTIVE"); return true; }
if (Thread.currentThread().isInterrupted()) { finish(attempt,"failed","INTERRUPTED"); return true; }
String channel=account.contains("@")?"email":"phone";
// At this point the claim is committed and its connection is released.
sender.send(channel,account,code,attempt.purpose());
} catch (Exception error) {
// Do not attach/log exceptions: providers can echo recipients, OTPs or credentials.
finish(attempt,"failed","DELIVERY_FAILED");
return true;
}
// A storage failure here leaves 'sending'. Never re-send an ambiguously accepted message.
finish(attempt,"sent",null);
return true;
}
private boolean isCurrent(Attempt attempt, String account) {
String activeUser=attempt.purpose()==VerificationPurpose.PASSWORD_RESET
? " AND EXISTS(SELECT 1 FROM users WHERE account=c.account AND status='active')" : "";
return Boolean.TRUE.equals(jdbc.queryForObject("SELECT EXISTS(SELECT 1 FROM "+attempt.purpose().table+" c WHERE account=? AND delivery_id=? AND consumed=false AND attempts<5 AND expires_at>clock_timestamp()"+activeUser+")",Boolean.class,account,attempt.id()));
}
private void finish(Attempt attempt, String state, String failureCode) {
transactions.executeWithoutResult(status -> {
int changed=jdbc.update("UPDATE verification_delivery_outbox SET status=?,payload_ciphertext=NULL,finished_at=clock_timestamp(),failure_code=? WHERE id=? AND status='sending'",state,failureCode,attempt.id());
if (changed>0 && !"sent".equals(state)) {
jdbc.update("UPDATE "+attempt.purpose().table+" SET consumed=true WHERE delivery_id=?",attempt.id());
}
});
}
private void cleanupExpired() {
transactions.executeWithoutResult(status -> {
// 'sending' abandoned on restart is never retried. Erase the encrypted payload after expiry.
jdbc.update("UPDATE verification_delivery_outbox SET status='discarded',payload_ciphertext=NULL,finished_at=clock_timestamp(),failure_code='EXPIRED' WHERE id IN (SELECT id FROM verification_delivery_outbox WHERE status IN ('queued','sending') AND expires_at<=clock_timestamp() LIMIT 100 FOR UPDATE SKIP LOCKED)");
jdbc.update("DELETE FROM verification_delivery_outbox WHERE id IN (SELECT id FROM verification_delivery_outbox WHERE finished_at<clock_timestamp()-interval '2 days' LIMIT 100)");
for (var purpose : VerificationPurpose.values()) jdbc.update("DELETE FROM "+purpose.table+" WHERE account IN (SELECT account FROM "+purpose.table+" WHERE expires_at<clock_timestamp()-interval '1 day' LIMIT 100 FOR UPDATE SKIP LOCKED)");
});
}
@PreDestroy public void close() {
workers.shutdownNow();
try { workers.awaitTermination(3,TimeUnit.SECONDS); }
catch (InterruptedException error) { Thread.currentThread().interrupt(); }
}
}
@@ -0,0 +1,14 @@
package com.moyi.controlplane.auth;
/** Closed purpose set: SQL identifiers and message intent must never come from a request. */
public enum VerificationPurpose {
REGISTRATION("registration", "registration_codes", "注册"),
PASSWORD_RESET("password-reset", "password_reset_codes", "密码重置");
final String key, table, label;
VerificationPurpose(String key, String table, String label) { this.key=key; this.table=table; this.label=label; }
static VerificationPurpose fromKey(String key) {
for (var purpose : values()) if (purpose.key.equals(key)) return purpose;
throw new IllegalArgumentException("Invalid verification purpose");
}
}
@@ -3,4 +3,5 @@ package com.moyi.controlplane.auth;
public interface VerificationSender {
boolean available(String channel);
void send(String channel, String account, String code);
default void send(String channel, String account, String code, VerificationPurpose purpose) { send(channel,account,code); }
}
@@ -4,7 +4,6 @@ import com.moyi.controlplane.common.ApiException;
import java.security.MessageDigest;
import java.security.SecureRandom;
import java.nio.charset.StandardCharsets;
import java.time.OffsetDateTime;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
@@ -16,13 +15,13 @@ import org.springframework.transaction.annotation.Transactional;
@Service
public class VerificationService {
private final JdbcTemplate jdbc;
private final VerificationSender sender;
private final VerificationDispatchService dispatch;
private final String pepper;
private final SecureRandom random=new SecureRandom();
public VerificationService(JdbcTemplate jdbc,VerificationSender sender,@Value("${moyi.auth.password-pepper}") String pepper) {
this.jdbc=jdbc; this.sender=sender; this.pepper=pepper;
public VerificationService(JdbcTemplate jdbc,VerificationDispatchService dispatch,@Value("${moyi.auth.password-pepper}") String pepper) {
this.jdbc=jdbc; this.dispatch=dispatch; this.pepper=pepper;
}
public Map<String,Boolean> capabilities() { return Map.of("email",sender.available("email"),"phone",sender.available("phone")); }
public Map<String,Boolean> capabilities() { return Map.of("email",dispatch.available("email"),"phone",dispatch.available("phone")); }
public String normalize(String raw) {
String account=raw==null?"":raw.trim().toLowerCase(Locale.ROOT);
if(!account.contains("@")) account=account.replaceAll("[\\s-]","");
@@ -33,29 +32,33 @@ public class VerificationService {
private String registrationDigest(String account,String code) { return digest("registration",account,code); }
private String resetDigest(String account,String code) { return digest("password-reset",account,code); }
@Transactional(noRollbackFor=ApiException.class)
@Transactional
public Map<String,Object> send(String raw,String invitation,String ip) {
String account=normalize(raw), channel=account.contains("@")?"email":"phone";
if(!sender.available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503);
if(!dispatch.available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503);
Integer invites=jdbc.queryForObject("SELECT count(*) FROM invitation_codes WHERE code_hash=? AND disabled_at IS NULL AND used_count<max_uses AND (expires_at IS NULL OR expires_at>now())",Integer.class,AuthService.hashSecret(invitation==null?"":invitation.trim()));
if(invites==null || invites==0) throw new ApiException("INVITATION_INVALID","请先填写有效邀请码",403);
String source=ip==null?"unknown":ip;
// One global lock bounds aggregate sending and serializes account/IP limits across replicas.
jdbc.queryForList("SELECT pg_advisory_xact_lock(734092615)");
Integer limited=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>now()-interval '60 seconds'",Integer.class,account);
Integer daily=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>now()-interval '24 hours'",Integer.class,account);
Integer hourly=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE ip_address=? AND created_at>now()-interval '1 hour'",Integer.class,source);
Integer total=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE created_at>now()-interval '24 hours'",Integer.class);
if(limited>0 || daily>=10 || hourly>=30 || total>=1000) throw new ApiException("VERIFICATION_RATE_LIMIT","发送过于频繁,请稍后重试",429);
admitSend(account,ip);
String code=String.format(Locale.ROOT,"%06d",random.nextInt(1000000));
jdbc.update("INSERT INTO verification_send_events(id,account,ip_address) VALUES (?,?,?)",UUID.randomUUID(),account,source);
jdbc.update("INSERT INTO registration_codes(account,code_hash,expires_at) VALUES (?,?,now()+interval '5 minutes') ON CONFLICT(account) DO UPDATE SET code_hash=excluded.code_hash, expires_at=excluded.expires_at, attempts=0, consumed=false, created_at=now()",account,registrationDigest(account,code));
try { sender.send(channel,account,code); }
catch(ApiException exception) { jdbc.update("UPDATE registration_codes SET consumed=true WHERE account=?",account); throw exception; }
jdbc.update("DELETE FROM verification_send_events WHERE created_at<now()-interval '2 days'");
return Map.of("sent",true,"retryAfterSeconds",60,"expiresInSeconds",300);
dispatch.enqueue(VerificationPurpose.REGISTRATION,account,code,registrationDigest(account,code));
return accepted();
}
private void admitSend(String account,String ip) {
String source=ip==null || ip.isBlank()?"unknown":ip;
// This lock covers only bounded DB work, NEVER the mail/SMS provider.
jdbc.queryForObject("SELECT set_config('lock_timeout','2s',true)",String.class);
jdbc.queryForList("SELECT pg_advisory_xact_lock(734092615)");
jdbc.update("DELETE FROM verification_send_events WHERE id IN (SELECT id FROM verification_send_events WHERE created_at<clock_timestamp()-interval '2 days' LIMIT 500)");
Integer limited=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>clock_timestamp()-interval '60 seconds'",Integer.class,account);
Integer daily=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>clock_timestamp()-interval '24 hours'",Integer.class,account);
Integer hourly=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE ip_address=? AND created_at>clock_timestamp()-interval '1 hour'",Integer.class,source);
Integer total=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE created_at>clock_timestamp()-interval '24 hours'",Integer.class);
if(limited>0 || daily>=10 || hourly>=30 || total>=1000) throw new ApiException("VERIFICATION_RATE_LIMIT","发送过于频繁,请稍后重试",429);
jdbc.update("INSERT INTO verification_send_events(id,account,ip_address,created_at) VALUES (?,?,?,clock_timestamp())",UUID.randomUUID(),account,source);
}
private Map<String,Object> accepted() { return Map.of("sent",true,"retryAfterSeconds",60,"expiresInSeconds",300); }
@Transactional(noRollbackFor=ApiException.class)
public void consume(String raw,String code) {
String account=normalize(raw);
@@ -69,39 +72,30 @@ public class VerificationService {
jdbc.update("UPDATE registration_codes SET consumed=true WHERE account=?",account);
}
@Transactional(noRollbackFor=ApiException.class)
@Transactional
public Map<String,Object> sendReset(String raw,String ip) {
String account=normalize(raw), channel=account.contains("@")?"email":"phone";
if(!sender.available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503);
Integer exists=jdbc.queryForObject("SELECT count(*) FROM users WHERE account=? AND status='active'",Integer.class,account);
// Do not reveal whether an account exists. The client receives the same response either way.
if(exists==null || exists==0) return Map.of("sent",true,"retryAfterSeconds",60,"expiresInSeconds",300);
String source=ip==null?"unknown":ip;
jdbc.queryForList("SELECT pg_advisory_xact_lock(734092615)");
Integer limited=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>now()-interval '60 seconds'",Integer.class,account);
Integer daily=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account=? AND created_at>now()-interval '24 hours'",Integer.class,account);
Integer hourly=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE ip_address=? AND created_at>now()-interval '1 hour'",Integer.class,source);
Integer total=jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE created_at>now()-interval '24 hours'",Integer.class);
if(limited>0 || daily>=10 || hourly>=30 || total>=1000) throw new ApiException("VERIFICATION_RATE_LIMIT","发送过于频繁,请稍后重试",429);
if(!dispatch.available(channel)) throw new ApiException("VERIFICATION_UNAVAILABLE","该验证码发送服务尚未配置,请联系管理员",503);
// Exact same request-side DB/crypto path for active, unknown and disabled accounts.
// Existence is checked ONLY in the worker; no network result reaches this receipt.
admitSend(account,ip);
String code=String.format(Locale.ROOT,"%06d",random.nextInt(1000000));
jdbc.update("INSERT INTO verification_send_events(id,account,ip_address) VALUES (?,?,?)",UUID.randomUUID(),account,source);
jdbc.update("INSERT INTO password_reset_codes(account,code_hash,expires_at) VALUES (?,?,now()+interval '5 minutes') ON CONFLICT(account) DO UPDATE SET code_hash=excluded.code_hash, expires_at=excluded.expires_at, attempts=0, consumed=false, created_at=now()",account,resetDigest(account,code));
try { sender.send(channel,account,code); }
catch(ApiException exception) { jdbc.update("UPDATE password_reset_codes SET consumed=true WHERE account=?",account); throw exception; }
return Map.of("sent",true,"retryAfterSeconds",60,"expiresInSeconds",300);
dispatch.enqueue(VerificationPurpose.PASSWORD_RESET,account,code,resetDigest(account,code));
return accepted();
}
@Transactional(noRollbackFor=ApiException.class)
public String consumeReset(String raw,String code) {
String account=normalize(raw);
var rows=jdbc.queryForList("SELECT * FROM password_reset_codes WHERE account=? FOR UPDATE",account);
if(rows.isEmpty()) throw new ApiException("VERIFICATION_INVALID","请先获取验证码");
if(rows.isEmpty()) throw invalidResetCode();
var row=rows.getFirst();
java.time.Instant expiry=((java.sql.Timestamp)row.get("expires_at")).toInstant();
if(Boolean.TRUE.equals(row.get("consumed")) || expiry.isBefore(java.time.Instant.now()) || ((Number)row.get("attempts")).intValue()>=5) throw new ApiException("VERIFICATION_EXPIRED","验证码已失效,请重新获取");
if(Boolean.TRUE.equals(row.get("consumed")) || !expiry.isAfter(java.time.Instant.now()) || ((Number)row.get("attempts")).intValue()>=5) throw invalidResetCode();
jdbc.update("UPDATE password_reset_codes SET attempts=attempts+1 WHERE account=?",account);
if(code==null || !code.matches("[0-9]{6}") || !MessageDigest.isEqual(String.valueOf(row.get("code_hash")).getBytes(StandardCharsets.UTF_8),resetDigest(account,code).getBytes(StandardCharsets.UTF_8))) throw new ApiException("VERIFICATION_INVALID","验证码错误");
if(code==null || !code.matches("[0-9]{6}") || !MessageDigest.isEqual(String.valueOf(row.get("code_hash")).getBytes(StandardCharsets.UTF_8),resetDigest(account,code).getBytes(StandardCharsets.UTF_8))) throw invalidResetCode();
jdbc.update("UPDATE password_reset_codes SET consumed=true WHERE account=?",account);
return account;
}
private ApiException invalidResetCode() { return new ApiException("VERIFICATION_INVALID","验证码无效或已失效,请重新获取"); }
}
@@ -40,6 +40,9 @@ public class SecretCipher {
}
}
/** Readiness only; never expose key material. */
public boolean isConfigured() { return key != null; }
public String decrypt(String encoded) {
if (key == null) throw new ApiException("CREDENTIAL_ENCRYPTION_NOT_CONFIGURED", "请先配置供应商凭证加密密钥", 500);
try {
@@ -0,0 +1,21 @@
-- One immutable generation per delivery. No plaintext recipient or OTP is stored in this queue.
ALTER TABLE registration_codes ADD COLUMN delivery_id uuid;
ALTER TABLE password_reset_codes ADD COLUMN delivery_id uuid;
CREATE INDEX registration_codes_expiry_idx ON registration_codes(expires_at);
CREATE TABLE verification_delivery_outbox (
id uuid PRIMARY KEY,
purpose varchar(24) NOT NULL CHECK (purpose IN ('registration','password-reset')),
payload_ciphertext text,
status varchar(16) NOT NULL DEFAULT 'queued' CHECK (status IN ('queued','sending','sent','failed','discarded')),
created_at timestamptz NOT NULL DEFAULT clock_timestamp(),
expires_at timestamptz NOT NULL DEFAULT clock_timestamp()+interval '5 minutes',
started_at timestamptz,
finished_at timestamptz,
failure_code varchar(32),
CHECK ((status IN ('queued','sending') AND payload_ciphertext IS NOT NULL)
OR (status IN ('sent','failed','discarded') AND payload_ciphertext IS NULL))
);
CREATE INDEX verification_delivery_queue_idx ON verification_delivery_outbox(created_at,id) WHERE status='queued';
CREATE INDEX verification_delivery_expiry_idx ON verification_delivery_outbox(expires_at) WHERE status IN ('queued','sending');
CREATE INDEX verification_delivery_finished_idx ON verification_delivery_outbox(finished_at) WHERE status IN ('sent','failed','discarded');
@@ -54,6 +54,7 @@ class PlatformAdminPostgresTest {
private CatalogService catalog;
private WalletService wallet;
private VerificationService verification;
private VerificationDispatchService dispatch;
private TestSender sender;
@BeforeEach void setup() throws Exception {
@@ -87,12 +88,14 @@ class PlatformAdminPostgresTest {
context.registerBean(WalletService.class, () -> new WalletService(jdbc, context.getBean(AuthService.class)));
context.registerBean(UsageAuditService.class, () -> new UsageAuditService(jdbc,json));
context.registerBean(ChatBillingService.class, () -> new ChatBillingService(jdbc,json,context.getBean(UsageAuditService.class)));
context.registerBean(VerificationService.class, () -> new VerificationService(jdbc, sender, "test-pepper"));
context.registerBean(VerificationDispatchService.class, () -> new VerificationDispatchService(jdbc,sender,new SecretCipher("test-delivery-encryption"),json,context.getBean(DataSourceTransactionManager.class)));
context.registerBean(VerificationService.class, () -> new VerificationService(jdbc, context.getBean(VerificationDispatchService.class), "test-pepper"));
context.refresh();
auth = context.getBean(AuthService.class);
catalog = context.getBean(CatalogService.class);
wallet = context.getBean(WalletService.class);
verification = context.getBean(VerificationService.class);
dispatch = context.getBean(VerificationDispatchService.class);
auth.ensureAdmin("test_owner", "local-password", "Test Owner");
ownerToken = auth.login("test_owner", "local-password", meta).token();
memberId = auth.createUser(ownerToken, "test_member", "local-password", "Test Member", meta).id();
@@ -335,6 +338,7 @@ class PlatformAdminPostgresTest {
http.perform(post("/api/auth/register").contentType("application/json").content(json.writeValueAsBytes(input))).andExpect(status().isBadRequest());
http.perform(post("/api/auth/verification").contentType("application/json").content(json.writeValueAsBytes(input)))
.andExpect(status().isOk()).andExpect(jsonPath("$.code").doesNotExist()).andExpect(jsonPath("$.sent").value(true));
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
String code = sender.codes.get(account);
assertNotEquals(code,jdbc.queryForObject("SELECT code_hash FROM registration_codes WHERE account=?",String.class,account));
input.put("verificationCode",code);
@@ -350,16 +354,19 @@ class PlatformAdminPostgresTest {
assertThrows(ApiException.class, () -> verification.send(account,"bad-invite","127.0.0.1"));
verification.send(account,invite,"127.0.0.1");
assertThrows(ApiException.class, () -> verification.send(account,invite,"127.0.0.1"));
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
String correct=sender.codes.get(account);
String wrong=correct.equals("000000")?"111111":"000000";
for(int i=0;i<5;i++) assertThrows(ApiException.class, () -> verification.consume(account,wrong));
assertEquals(5,jdbc.queryForObject("SELECT attempts FROM registration_codes WHERE account=?",Integer.class,account));
assertThrows(ApiException.class, () -> verification.consume(account,correct));
verification.send("expired@example.test",invite,"127.0.0.1");
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
jdbc.update("UPDATE registration_codes SET expires_at=now()-interval '1 second' WHERE account='expired@example.test'");
assertThrows(ApiException.class, () -> verification.consume("expired@example.test",sender.codes.get("expired@example.test")));
sender.fail=true;
assertThrows(ApiException.class, () -> verification.send("failed@example.test",invite,"127.0.0.1"));
assertEquals(true,verification.send("failed@example.test",invite,"127.0.0.1").get("sent"));
assertTrue(VerificationDeliveryFixture.deliverOne(dispatch));
assertTrue(jdbc.queryForObject("SELECT consumed FROM registration_codes WHERE account='failed@example.test'",Boolean.class));
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM verification_send_events WHERE account='failed@example.test'",Integer.class));
sender.enabled=false;
@@ -0,0 +1,7 @@
package com.moyi.controlplane.auth;
/** Deterministic test-only access; no public production dispatch endpoint. */
public final class VerificationDeliveryFixture {
private VerificationDeliveryFixture() {}
public static boolean deliverOne(VerificationDispatchService dispatch) { return dispatch.dispatchOne(); }
}
@@ -0,0 +1,343 @@
package com.moyi.controlplane.auth;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.moyi.controlplane.common.ApiException;
import com.moyi.controlplane.common.ApiExceptionHandler;
import com.moyi.controlplane.security.SecretCipher;
import java.util.ArrayList;
import java.util.Map;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import javax.sql.DataSource;
import org.flywaydb.core.Flyway;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledIfEnvironmentVariable;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Configuration;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.transaction.IllegalTransactionStateException;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import org.springframework.transaction.support.TransactionTemplate;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@EnabledIfEnvironmentVariable(named="MOYI_AUTH_TEST_JDBC_URL",matches="jdbc:postgresql://127[.]0[.]0[.]1:[0-9]+/.+")
class VerificationDispatchPostgresTest {
@Configuration @EnableTransactionManagement(proxyTargetClass=true) static class Transactions {}
private static final String ACTIVE="active@example.test", UNKNOWN="unknown@example.test", DISABLED="disabled@example.test";
private final ObjectMapper json=new ObjectMapper().findAndRegisterModules();
private final SecretCipher cipher=new SecretCipher("isolated-delivery-encryption");
private DriverManagerDataSource base;
private String schema, invitation;
private JdbcTemplate jdbc;
private AnnotationConfigApplicationContext context;
private VerificationDispatchService dispatch;
private VerificationService verification;
private MockMvc http;
private final TestSender sender=new TestSender();
static class TestSender implements VerificationSender {
final Map<String,String> codes=new ConcurrentHashMap<>();
final AtomicInteger calls=new AtomicInteger();
volatile boolean available=true, fail=false;
volatile CountDownLatch arrived, release;
volatile VerificationPurpose lastPurpose;
public boolean available(String channel) { return available; }
public void send(String channel,String account,String code) { send(channel,account,code,VerificationPurpose.REGISTRATION); }
public void send(String channel,String account,String code,VerificationPurpose purpose) {
assertFalse(TransactionSynchronizationManager.isActualTransactionActive(),"Network delivery must not hold a DB transaction");
calls.incrementAndGet(); lastPurpose=purpose;
if (arrived!=null) arrived.countDown();
if (release!=null) try { assertTrue(release.await(10,TimeUnit.SECONDS)); }
catch (InterruptedException error) { Thread.currentThread().interrupt(); throw new IllegalStateException("Interrupted fixture"); }
if (fail) throw new ApiException("VERIFICATION_SEND_FAILED","Synthetic provider detail must stay private",502);
codes.put(account,code);
}
}
@BeforeEach void setup() {
String url=System.getenv("MOYI_AUTH_TEST_JDBC_URL");
schema="verification_dispatch_"+UUID.randomUUID().toString().replace("-","");
base=new DriverManagerDataSource(url,"moyi_role_test","");
var source=new DriverManagerDataSource(url+"?currentSchema="+schema,"moyi_role_test","");
Flyway.configure().dataSource(base).schemas(schema).defaultSchema(schema).load().migrate();
jdbc=new JdbcTemplate(source); UUID creator=UUID.randomUUID(); invitation="synthetic-invite-"+UUID.randomUUID();
jdbc.update("INSERT INTO users(id,account,account_kind,password_hash,display_name,status) VALUES (?,?,'email','not-a-login-hash','Synthetic','active'),(?,?,'email','not-a-login-hash','Synthetic','disabled')",creator,ACTIVE,UUID.randomUUID(),DISABLED);
jdbc.update("INSERT INTO invitation_codes(id,code_hash,code_prefix,label,max_uses,created_by) VALUES (?,?,?,'Synthetic',100,?)",UUID.randomUUID(),AuthService.hashSecret(invitation),"synthetic",creator);
context=new AnnotationConfigApplicationContext(); context.register(Transactions.class);
context.registerBean(DataSource.class,()->source);
context.registerBean(DataSourceTransactionManager.class,()->new DataSourceTransactionManager(source));
context.registerBean(VerificationDispatchService.class,()->new VerificationDispatchService(jdbc,sender,cipher,json,context.getBean(DataSourceTransactionManager.class)));
context.registerBean(VerificationService.class,()->new VerificationService(jdbc,context.getBean(VerificationDispatchService.class),"isolated-pepper"));
context.refresh(); dispatch=context.getBean(VerificationDispatchService.class); verification=context.getBean(VerificationService.class);
http=MockMvcBuilders.standaloneSetup(new AuthController(mock(AuthService.class),verification,mock(VerifiedAccountService.class),168,true))
.setControllerAdvice(new ApiExceptionHandler()).build();
}
@AfterEach void cleanup() {
if (sender.release!=null) sender.release.countDown();
if (context!=null) context.close();
if (base!=null && schema!=null) new JdbcTemplate(base).execute("DROP SCHEMA "+schema+" CASCADE");
}
private UUID delivery(String account,VerificationPurpose purpose) {
return jdbc.queryForObject("SELECT delivery_id FROM "+purpose.table+" WHERE account=?",UUID.class,account);
}
private void releaseQuota(String account) { jdbc.update("UPDATE verification_send_events SET created_at=clock_timestamp()-interval '61 seconds' WHERE account=?",account); }
private void assertTerminal(UUID id,String state) {
var row=jdbc.queryForMap("SELECT status,payload_ciphertext,finished_at FROM verification_delivery_outbox WHERE id=?",id);
assertEquals(state,row.get("status")); assertNull(row.get("payload_ciphertext")); assertNotNull(row.get("finished_at"));
}
@Test void resetRequestsHaveIdenticalReceiptsAndNoRequestSideDeliveryForAllAccountStates() throws Exception {
String reference=null;
for (String account : java.util.List.of(ACTIVE,UNKNOWN,DISABLED)) {
var response=http.perform(post("/api/auth/password-reset/code").contentType("application/json").content(json.writeValueAsBytes(Map.of("account",account))))
.andExpect(status().isOk()).andExpect(jsonPath("$.sent").value(true)).andExpect(jsonPath("$.code").doesNotExist())
.andExpect(jsonPath("$.token").doesNotExist()).andExpect(cookie().doesNotExist("moyi_session")).andReturn().getResponse().getContentAsString();
if (reference==null) reference=response; else assertEquals(json.readTree(reference),json.readTree(response));
}
assertEquals(0,sender.calls.get());
assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM verification_send_events",Integer.class));
assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox WHERE status='queued'",Integer.class));
assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM password_reset_codes",Integer.class));
}
@Test void knownAndUnknownRepeatedRequestsExposeTheSameLimit() throws Exception {
for (String account : java.util.List.of(ACTIVE,UNKNOWN,DISABLED)) {
verification.sendReset(account,"127.0.0.1");
http.perform(post("/api/auth/password-reset/code").contentType("application/json").content(json.writeValueAsBytes(Map.of("account",account))))
.andExpect(status().isTooManyRequests()).andExpect(jsonPath("$.error.code").value("VERIFICATION_RATE_LIMIT"));
}
assertEquals(3,jdbc.queryForObject("SELECT count(*) FROM verification_send_events",Integer.class));
}
@Test void workerDeliversOnlyToActiveUsersAndPurgesAllFinishedPayloads() {
for (String account : java.util.List.of(ACTIVE,UNKNOWN,DISABLED)) verification.sendReset(account,"127.0.0.1");
for (int i=0;i<3;i++) assertTrue(dispatch.dispatchOne());
assertEquals(1,sender.calls.get()); assertEquals(VerificationPurpose.PASSWORD_RESET,sender.lastPurpose);
assertTrue(sender.codes.containsKey(ACTIVE)); assertFalse(sender.codes.containsKey(UNKNOWN)); assertFalse(sender.codes.containsKey(DISABLED));
assertTerminal(delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET),"sent");
assertTerminal(delivery(UNKNOWN,VerificationPurpose.PASSWORD_RESET),"discarded");
assertTerminal(delivery(DISABLED,VerificationPurpose.PASSWORD_RESET),"discarded");
}
@Test void payloadContainsNoPlaintextAccountOrOtpAndIsBoundToItsGeneration() throws Exception {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID id=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
String stored=jdbc.queryForObject("SELECT payload_ciphertext FROM verification_delivery_outbox WHERE id=?",String.class,id);
var decoded=json.readTree(cipher.decrypt(stored));
assertTrue(stored.startsWith("v1$")); assertFalse(stored.contains(ACTIVE)); assertFalse(stored.contains("account"));
assertEquals(id.toString(),decoded.path("id").asText()); assertEquals("password-reset",decoded.path("purpose").asText());
assertTrue(decoded.path("code").asText().matches("[0-9]{6}"));
assertNotEquals(decoded.path("code").asText(),jdbc.queryForObject("SELECT code_hash FROM password_reset_codes WHERE account=?",String.class,ACTIVE));
}
@Test void providerFailureStaysOutOfTheReceiptAndIsNotRetried() {
sender.fail=true;
assertEquals(true,verification.sendReset(ACTIVE,"127.0.0.1").get("sent"));
UUID id=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET); assertTrue(dispatch.dispatchOne());
assertTerminal(id,"failed"); assertEquals(1,sender.calls.get()); assertFalse(dispatch.dispatchOne()); assertEquals(1,sender.calls.get());
assertTrue(jdbc.queryForObject("SELECT consumed FROM password_reset_codes WHERE delivery_id=?",Boolean.class,id));
assertEquals("DELIVERY_FAILED",jdbc.queryForObject("SELECT failure_code FROM verification_delivery_outbox WHERE id=?",String.class,id));
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM verification_send_events",Integer.class));
}
@Test void sendingDoesNotHoldTheGlobalQuotaLockOrADatabaseTransaction() throws Exception {
verification.sendReset(ACTIVE,"127.0.0.1");
sender.arrived=new CountDownLatch(1); sender.release=new CountDownLatch(1);
try (var executor=Executors.newFixedThreadPool(2)) {
var worker=executor.submit(dispatch::dispatchOne); assertTrue(sender.arrived.await(3,TimeUnit.SECONDS));
var request=executor.submit(()->verification.sendReset(UNKNOWN,"127.0.0.2"));
assertEquals(true,request.get(3,TimeUnit.SECONDS).get("sent"));
assertEquals("sending",jdbc.queryForObject("SELECT status FROM verification_delivery_outbox WHERE id=?",String.class,delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET)));
sender.release.countDown(); assertTrue(worker.get(3,TimeUnit.SECONDS));
}
}
@Test void supersededQueueEntriesCannotDeliverOldCodesOrInvalidateNewOnes() {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID old=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
releaseQuota(ACTIVE); verification.sendReset(ACTIVE,"127.0.0.1"); UUID current=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
assertNotEquals(old,current); assertTrue(dispatch.dispatchOne()); assertTerminal(old,"discarded"); assertEquals(0,sender.calls.get());
assertFalse(jdbc.queryForObject("SELECT consumed FROM password_reset_codes WHERE delivery_id=?",Boolean.class,current));
assertTrue(dispatch.dispatchOne()); assertTerminal(current,"sent"); assertEquals(1,sender.calls.get());
assertEquals(ACTIVE,verification.consumeReset(ACTIVE,sender.codes.get(ACTIVE)));
}
@Test void oldInFlightFailureDoesNotConsumeTheReplacementCode() throws Exception {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID old=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
sender.fail=true; sender.arrived=new CountDownLatch(1); sender.release=new CountDownLatch(1);
try (var executor=Executors.newSingleThreadExecutor()) {
var worker=executor.submit(dispatch::dispatchOne); assertTrue(sender.arrived.await(3,TimeUnit.SECONDS));
releaseQuota(ACTIVE); verification.sendReset(ACTIVE,"127.0.0.2"); UUID replacement=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
sender.release.countDown(); assertTrue(worker.get(3,TimeUnit.SECONDS)); assertTerminal(old,"failed");
assertFalse(jdbc.queryForObject("SELECT consumed FROM password_reset_codes WHERE delivery_id=?",Boolean.class,replacement));
sender.fail=false; sender.arrived=null; sender.release=null; assertTrue(dispatch.dispatchOne()); assertTerminal(replacement,"sent");
}
}
@Test void expiredAndAmbiguousSendingRowsAreErasedWithoutAutomaticReplay() {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID id=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
jdbc.update("UPDATE verification_delivery_outbox SET status='sending',started_at=clock_timestamp() WHERE id=?",id);
assertFalse(dispatch.dispatchOne()); assertEquals(0,sender.calls.get());
jdbc.update("UPDATE verification_delivery_outbox SET expires_at=clock_timestamp()-interval '1 second' WHERE id=?",id);
assertFalse(dispatch.dispatchOne()); assertTerminal(id,"discarded"); assertEquals(0,sender.calls.get());
jdbc.update("UPDATE verification_delivery_outbox SET finished_at=clock_timestamp()-interval '3 days' WHERE id=?",id);
assertFalse(dispatch.dispatchOne()); assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox",Integer.class));
}
@Test void disabledAfterEnqueueAndAlreadyConsumedCodesAreNotSent() {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID id=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
jdbc.update("UPDATE users SET status='disabled' WHERE account=?",ACTIVE); assertTrue(dispatch.dispatchOne()); assertTerminal(id,"discarded");
jdbc.update("UPDATE users SET status='active' WHERE account=?",ACTIVE); releaseQuota(ACTIVE); verification.sendReset(ACTIVE,"127.0.0.1");
id=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET); jdbc.update("UPDATE password_reset_codes SET consumed=true WHERE delivery_id=?",id);
assertTrue(dispatch.dispatchOne()); assertTerminal(id,"discarded"); assertEquals(0,sender.calls.get());
}
@Test void missingEncryptionOrDisabledSenderIsAccountIndependentAndCreatesNoWork() {
var missingKey=new VerificationDispatchService(jdbc,sender,new SecretCipher(""),json,context.getBean(DataSourceTransactionManager.class));
try { assertFalse(missingKey.available("email")); assertFalse(missingKey.available("phone")); } finally { missingKey.close(); }
sender.available=false;
for (String account : java.util.List.of(ACTIVE,UNKNOWN,DISABLED)) {
assertEquals("VERIFICATION_UNAVAILABLE",assertThrows(ApiException.class,()->verification.sendReset(account,"127.0.0.1")).getCode());
}
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox",Integer.class));
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM verification_send_events",Integer.class));
}
@Test void queueFailureRollsBackTheCodeAndQuotaRecordTogether() {
jdbc.execute("ALTER TABLE verification_delivery_outbox ADD CONSTRAINT injected_failure CHECK (purpose <> 'password-reset') NOT VALID");
assertThrows(DataIntegrityViolationException.class,()->verification.sendReset(ACTIVE,"127.0.0.1"));
for (String table : java.util.List.of("verification_delivery_outbox","verification_send_events","password_reset_codes")) {
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM "+table,Integer.class));
}
jdbc.execute("ALTER TABLE verification_delivery_outbox DROP CONSTRAINT injected_failure");
assertEquals(true,verification.sendReset(ACTIVE,"127.0.0.1").get("sent"));
}
@Test void concurrentRequestsAcrossConnectionsCannotDuplicateTheSameAccountAdmission() throws Exception {
var start=new CountDownLatch(1); var results=new ArrayList<String>();
try (var executor=Executors.newFixedThreadPool(2)) {
var requests=new ArrayList<java.util.concurrent.Future<String>>();
for (int i=0;i<2;i++) requests.add(executor.submit(()->{
assertTrue(start.await(3,TimeUnit.SECONDS));
try { verification.sendReset(UNKNOWN,"127.0.0.1"); return "accepted"; } catch (ApiException error) { return error.getCode(); }
}));
start.countDown(); for (var request : requests) results.add(request.get(5,TimeUnit.SECONDS));
}
assertEquals(1,results.stream().filter("accepted"::equals).count()); assertEquals(1,results.stream().filter("VERIFICATION_RATE_LIMIT"::equals).count());
assertEquals(1,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox",Integer.class));
}
@Test void concurrentWorkerClaimsSendAGenerationAtMostOnce() throws Exception {
verification.sendReset(ACTIVE,"127.0.0.1"); var start=new CountDownLatch(1);
try (var executor=Executors.newFixedThreadPool(2)) {
var first=executor.submit(()->{start.await(); return dispatch.dispatchOne();});
var second=executor.submit(()->{start.await(); return dispatch.dispatchOne();}); start.countDown();
assertNotEquals(first.get(5,TimeUnit.SECONDS),second.get(5,TimeUnit.SECONDS));
}
assertEquals(1,sender.calls.get()); assertTerminal(delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET),"sent");
}
@Test void accountDailySourceHourlyAndGlobalBudgetsIncludeUnknownAccounts() {
for (int i=0;i<10;i++) {
verification.sendReset(UNKNOWN,"127.0.0.1"); releaseQuota(UNKNOWN);
}
assertEquals("VERIFICATION_RATE_LIMIT",assertThrows(ApiException.class,()->verification.sendReset(UNKNOWN,"127.0.0.2")).getCode());
jdbc.update("DELETE FROM verification_send_events");
jdbc.execute("INSERT INTO verification_send_events(id,account,ip_address) SELECT md5('source-'||g)::uuid,'synthetic-'||g||'@example.test','127.0.0.9' FROM generate_series(1,30) g");
assertEquals("VERIFICATION_RATE_LIMIT",assertThrows(ApiException.class,()->verification.sendReset(ACTIVE,"127.0.0.9")).getCode());
assertEquals("VERIFICATION_RATE_LIMIT",assertThrows(ApiException.class,()->verification.sendReset("other@example.test","127.0.0.9")).getCode());
jdbc.update("DELETE FROM verification_send_events");
jdbc.execute("INSERT INTO verification_send_events(id,account,ip_address) SELECT md5('global-'||g)::uuid,'synthetic-'||g||'@example.test','192.0.2.1' FROM generate_series(1,1000) g");
assertEquals("VERIFICATION_RATE_LIMIT",assertThrows(ApiException.class,()->verification.sendReset(ACTIVE,"127.0.0.1")).getCode());
assertEquals("VERIFICATION_RATE_LIMIT",assertThrows(ApiException.class,()->verification.sendReset("another@example.test","127.0.0.2")).getCode());
}
@Test void crossPurposeQuotaIsSharedWhileCodesRemainPurposeBound() {
verification.send(UNKNOWN,invitation,"127.0.0.1");
assertEquals("VERIFICATION_RATE_LIMIT",assertThrows(ApiException.class,()->verification.sendReset(UNKNOWN,"127.0.0.1")).getCode());
assertTrue(dispatch.dispatchOne()); String code=sender.codes.get(UNKNOWN);
assertEquals(VerificationPurpose.REGISTRATION,sender.lastPurpose); verification.consume(UNKNOWN,code);
assertEquals("VERIFICATION_INVALID",assertThrows(ApiException.class,()->verification.consumeReset(UNKNOWN,code)).getCode());
}
@Test void allInvalidResetCodeStatesHaveTheSamePublicError() {
String expected=assertThrows(ApiException.class,()->verification.consumeReset(UNKNOWN,"000000")).getMessage();
verification.sendReset(ACTIVE,"127.0.0.1"); assertTrue(dispatch.dispatchOne());
String correct=sender.codes.get(ACTIVE), wrong="000000".equals(correct)?"111111":"000000";
assertEquals(expected,assertThrows(ApiException.class,()->verification.consumeReset(ACTIVE,wrong)).getMessage());
jdbc.update("UPDATE password_reset_codes SET attempts=5 WHERE account=?",ACTIVE);
assertEquals(expected,assertThrows(ApiException.class,()->verification.consumeReset(ACTIVE,correct)).getMessage());
jdbc.update("UPDATE password_reset_codes SET attempts=0,expires_at=clock_timestamp()-interval '1 second' WHERE account=?",ACTIVE);
assertEquals(expected,assertThrows(ApiException.class,()->verification.consumeReset(ACTIVE,correct)).getMessage());
}
@Test void ciphertextTamperingAndEnvelopeSwappingNeverReachTheSender() {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID first=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
jdbc.update("UPDATE verification_delivery_outbox SET payload_ciphertext='v1$invalid$ciphertext' WHERE id=?",first);
assertTrue(dispatch.dispatchOne()); assertTerminal(first,"failed"); assertEquals(0,sender.calls.get());
releaseQuota(ACTIVE); verification.sendReset(ACTIVE,"127.0.0.1");
UUID second=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET); String valid=jdbc.queryForObject("SELECT payload_ciphertext FROM verification_delivery_outbox WHERE id=?",String.class,second);
verification.sendReset(UNKNOWN,"127.0.0.2"); UUID third=delivery(UNKNOWN,VerificationPurpose.PASSWORD_RESET);
jdbc.update("UPDATE verification_delivery_outbox SET payload_ciphertext=? WHERE id=?",valid,third);
assertTrue(dispatch.dispatchOne()); assertTerminal(second,"sent"); assertTrue(dispatch.dispatchOne()); assertTerminal(third,"failed");
assertEquals(1,sender.calls.get());
}
@Test void enqueuingRequiresTheCallingTransaction() {
assertThrows(IllegalTransactionStateException.class,()->dispatch.enqueue(VerificationPurpose.REGISTRATION,UNKNOWN,"123456","a".repeat(64)));
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox",Integer.class));
}
@Test void failedReceiptPersistenceNeverResendsTheMessage() {
verification.sendReset(ACTIVE,"127.0.0.1"); UUID id=delivery(ACTIVE,VerificationPurpose.PASSWORD_RESET);
jdbc.execute("ALTER TABLE verification_delivery_outbox ADD CONSTRAINT injected_receipt_failure CHECK (status <> 'sent') NOT VALID");
assertThrows(DataIntegrityViolationException.class,dispatch::dispatchOne); assertEquals(1,sender.calls.get());
assertEquals("sending",jdbc.queryForObject("SELECT status FROM verification_delivery_outbox WHERE id=?",String.class,id));
jdbc.execute("ALTER TABLE verification_delivery_outbox DROP CONSTRAINT injected_receipt_failure");
assertFalse(dispatch.dispatchOne()); assertEquals(1,sender.calls.get());
}
@Test void scheduledDeliveryHasOnlyTwoWorkersAndNoUnboundedWaitingQueue() throws Exception {
for (int i=0;i<6;i++) verification.send("queued-"+i+"@example.test",invitation,"127.0.0.1");
sender.arrived=new CountDownLatch(2); sender.release=new CountDownLatch(1);
try {
dispatch.dispatchPending(); assertTrue(sender.arrived.await(3,TimeUnit.SECONDS));
for (int i=0;i<10;i++) dispatch.dispatchPending();
assertEquals(2,sender.calls.get());
assertEquals(2,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox WHERE status='sending'",Integer.class));
assertEquals(4,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox WHERE status='queued'",Integer.class));
} finally { sender.release.countDown(); dispatch.close(); }
}
@Test void blockedQuotaLockTimesOutAndDoesNotLeavePartialAdmission() throws Exception {
var locked=new CountDownLatch(1); var unlock=new CountDownLatch(1);
try (var executor=Executors.newSingleThreadExecutor()) {
var blocker=executor.submit(()->new TransactionTemplate(context.getBean(DataSourceTransactionManager.class)).executeWithoutResult(status->{
jdbc.queryForList("SELECT pg_advisory_xact_lock(734092615)"); locked.countDown();
try { assertTrue(unlock.await(8,TimeUnit.SECONDS)); } catch (InterruptedException error) { Thread.currentThread().interrupt(); throw new IllegalStateException(error); }
}));
assertTrue(locked.await(3,TimeUnit.SECONDS)); long start=System.nanoTime();
try {
assertThrows(org.springframework.dao.DataAccessException.class,()->verification.sendReset(UNKNOWN,"127.0.0.1"));
assertTrue(TimeUnit.NANOSECONDS.toMillis(System.nanoTime()-start)<5000);
} finally { unlock.countDown(); }
blocker.get(3,TimeUnit.SECONDS);
}
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM verification_send_events",Integer.class));
assertEquals(0,jdbc.queryForObject("SELECT count(*) FROM verification_delivery_outbox",Integer.class));
assertEquals(true,verification.sendReset(UNKNOWN,"127.0.0.1").get("sent"));
}
}
@@ -64,7 +64,7 @@ class VerifiedAccountPostgresTest {
context.registerBean(DataSourceTransactionManager.class, () -> new DataSourceTransactionManager(source));
context.registerBean(AuthService.class, () -> new AuthService(jdbc, hasher, json, 168));
context.registerBean(TotpService.class, () -> new TotpService(jdbc, new SecretCipher("isolated-totp")));
context.registerBean(VerificationService.class, () -> new VerificationService(jdbc, mock(VerificationSender.class), "isolated-verified-pepper"));
context.registerBean(VerificationService.class, () -> new VerificationService(jdbc, mock(VerificationDispatchService.class), "isolated-verified-pepper"));
context.registerBean(VerifiedAccountService.class); context.refresh();
auth = context.getBean(AuthService.class); verification = context.getBean(VerificationService.class); verified = context.getBean(VerifiedAccountService.class);
http = MockMvcBuilders.standaloneSetup(new AuthController(auth, verification, verified, 168, true))
@@ -166,7 +166,7 @@ class VerifiedAccountPostgresTest {
status.setRollbackOnly();
});
assertUnconsumed(reset, 5);
assertEquals("VERIFICATION_EXPIRED", assertThrows(ApiException.class, () -> {
assertEquals(reset ? "VERIFICATION_INVALID" : "VERIFICATION_EXPIRED", assertThrows(ApiException.class, () -> {
if (reset) verified.resetPassword(ACCOUNT, CODE, "replacement-password", meta);
else verified.register(invite, ACCOUNT, PASSWORD, "Test", CODE, meta);
}).getCode());
@@ -206,7 +206,7 @@ class VerifiedAccountPostgresTest {
for (var future : futures) results.add(future.get(15, TimeUnit.SECONDS));
}
assertEquals(1, results.stream().filter("completed"::equals).count());
assertEquals(1, results.stream().filter("VERIFICATION_EXPIRED"::equals).count());
assertEquals(1, results.stream().filter((reset ? "VERIFICATION_INVALID" : "VERIFICATION_EXPIRED")::equals).count());
assertEquals(1, jdbc.queryForObject("SELECT count(*) FROM users WHERE account=?", Integer.class, ACCOUNT));
assertEquals(1, jdbc.queryForObject("SELECT count(*) FROM auth_audit_log WHERE event_type=?", Integer.class, reset ? "user.password_reset" : "user.registered"));
if (!reset) assertEquals(1, jdbc.queryForObject("SELECT count(*) FROM invitation_redemptions", Integer.class));
+7 -3
View File
@@ -1,6 +1,6 @@
# 安全与 CPR 差距任务追踪
审查日期:2026-10-21。对照用户粘贴的 CPR 比对报告与本地代码,不将建议清单视为已完成验收。
最新增量审查日期:2026-10-22。对照用户粘贴的 CPR 比对报告与本地代码,不将建议清单视为已完成验收。
## 已交付基线
@@ -21,7 +21,7 @@
| SEC-04 | 任务用户隔离与回执安全 | 已实现核心用户级查询/幂等/冻结/核账,并补跨用户读取回归;完整授权审计仍待继续 | 跨用户读取/列表不可见;核账拒绝普通用户 |
| SEC-05 | Provider 有界 HTTP Transport | 部分完成:异步 JSON/multipart/音频/媒体已接有界读取和总期限;同步/SSE 生命周期尚未统一抽取 | 超大 chunk、慢响应体、已观察拒绝状态、取消、重定向及原适配器回归 |
| SEC-06 | 媒体下载出站 / SSRF | 服务端参考图下载的代码级 DNS 绑定已实现并通过本地回归;生产网络隔离与实际部署验收仍未完成 | 一次解析、整组地址校验、固定地址直连、原域名 TLS/SNI、禁代理与跳转;109 项新增回归,见 26 号文档 |
| SEC-07 | 整体安全审查与生产验收 | 未完成:本轮已补注册/重置中验证码成功消费与业务修改的原子性;管理接口全审查、重置发送侧信道、默认配置、依赖与备份恢复仍需继续 | 新增 12 项真实数据库回归;独立验收、部署与恢复演练未完成,禁止宣称“全仓库安全” |
| SEC-07 | 整体安全审查与生产验收 | 未完成:已补验证码/账号原子性;本轮进一步分离加密投递、统一已知/未知账号重置受理和限额,外部投递不再持 DB 事务;管理接口全审查、时序残余、默认配置、依赖与备份恢复仍需继续 | 本轮新增 22 项投递数据库回归,全量 390 项通过;真实邮件/短信与规格驱动验收未执行,禁止宣称“全仓库安全” |
| COD-01 | Codex 协议能力及验收矩阵 | 未实现完整兼容;保留有限文本 Responses 的明确拒绝语义 | 指定客户端版本、模型、工具和计费联合验收 |
| COD-02 | Responses WebSocket 与响应归属续接 | 未实现,不可宣传完整 Codex 支持 | 原账号/凭据版本归属、断线、取消、租约、费用一致性 |
| COD-03 | 长请求连接/空闲/总期限与续租 | 未完成,不只修改 90 秒常量 | 并发租约、钱包预留恢复、长流/取消共同验证 |
@@ -32,7 +32,7 @@
## 实施边界
已补 SEC-01/02/03、SEC-06 的本地下载代码边界,以及注册/密码重置中成功验证码与业务修改的原子性。下一优先级是验证发送侧信道和资源约束、管理授权审查、同步 Transport 与完整 provider 配置版本,再处理 COD-01/02/03 的协议/续接/长请求合同。SEC-06 的生产网络隔离仍属待验收。Codex WebSocket 与 OAuth 不是添加 URL 即可安全完成的能力,须连同状态归属、计量、预留续期和客户端验收逐步实施。未部署、未真实供应商验证或待设计的项必须保持未完成标记。
已补 SEC-01/02/03、SEC-06 的本地下载代码边界、验证码/账号事务,以及请求侧一致的验证码受理和加密异步投递。下一优先级是管理授权审查、同步 Transport 与完整 provider 配置版本,再处理 COD-01/02/03 的协议/续接/长请求合同。投递真实环境、残余时序与生产网络隔离仍属待验收。Codex WebSocket 与 OAuth 不是添加 URL 即可安全完成的能力,须连同状态归属、计量、预留续期和客户端验收逐步实施。未部署、未真实供应商验证或待设计的项必须保持未完成标记。
本轮设计与验证细节见 `25-auth-and-bounded-transport.md`。这份表按用户粘贴报告的锁定基线追踪本地实施,不把旧的 CPR 版本号冒充实时最新版,也没有重新部署 CPR。只做本地 Git commit,不 push,不修改业务数据库。
@@ -41,3 +41,7 @@
2026-10-21 媒体安全后续增量:使用 HttpClient 5.6.5 / HttpCore 5.4.4 重新执行 `mvn -B -o clean verify`,356 项后端测试通过(0 失败/错误/跳过),前端构建及 25 项测试通过。服务端本地下载不再使用 DNS 预检后交给 JDK 客户端二次解析的路径。用户指定的规格驱动验收尚未执行:`testingflow` 的 `.venv` 指向不存在的 Python,首个 `qa project list` 失败;没有绕过工具门禁,也没有自行批准规格。细节及下一步审阅范围见 `26-media-dns-binding-and-acceptance.md`。
2026-10-21 验证码事务后续增量:新增 `VerifiedAccountService`,公开注册/重置不再在业务成功前永久消费有效验证码;错误验证码尝试仍提交,审计失败时成功消费、账号、邀请码和会话一起回滚。`mvn -B -o clean verify` 最终 368 项全部通过(0 失败/错误/跳过,2026-10-21 23:05:46 Asia/Shanghai),包含新增 12 项数据库验证;前端沿用本轮已通过的构建及 25 项测试,未修改前端代码。详见 `27-verified-account-transactions.md`。规格驱动验收环境阻塞未解除,没有生成通过报告。
2026-10-22 投递隔离增量:新建 V50 加密 outbox、`VerificationDispatchService` 与封闭目的枚举;发送请求与投递分离,未知/停用账号不触发真实发送,但参与完全相同的请求端限额与写入路径。错误重置码统一公开错误,后台最多双线程、无内存等待队列,旧代次失败不影响新码,投递结果不明不自动重发。后端 `mvn -B -o clean verify` **390 项,0 失败/错误/跳过**,2026-10-22 08:41:38(Asia/Shanghai)结束;前端构建与 25 项测试通过,并通过独立容器的完整 Spring Boot 启动/健康检查。见 `28-verification-delivery-isolation.md`。
用户于 2026-10-22 明确取消每半小时提交检查,聊天自动化 `moyi` 已删除,不再自动轮询或提交;不停止产品内部 worker。当前开发仍只做经审查验证的本地提交,不 push、不部署、不迁移业务数据库;规格驱动验收环境未修复,未自行批准或执行业务验收。
+1 -1
View File
@@ -32,6 +32,6 @@
## 保留的待办
这不是注册/找回密码的全部安全闭环。`sendReset` 对不存在账号提前返回,对存在账号可能暴露限速/发送错误差异,仍需统一可观察语义与资源预算;短信/邮件调用持事务锁的设计、发送失败和超时、验证码行生命周期、管理敏感操作二次验证也要继续审查。未做真实发送、付费请求、部署或生产迁移。
这不是注册/找回密码的全部安全闭环。该提交时 `sendReset` 对不存在账号提前返回,对存在账号可能暴露限速/发送错误差异,且短信/邮件调用持事务锁。2026-10-22 的后续增量已分离加密异步投递、统一请求端处理与配额、清理过期记录,详见 `28-verification-delivery-isolation.md`。真实投递时序、SDK 期限、管理敏感操作二次验证及完整授权审查仍需继续;未做付费请求、部署或生产迁移。
用户指定的规格驱动功能验收仍受共享 `testingflow` 虚拟环境缺失 Python 阻塞,详见 26 号文档。本次仅为源码、单元/数据库集成回归,不能称作 `qa run --project` 验收通过。修复共享环境与人工审阅 draft 规格仍是正式执行前置条件。只对已审阅且验证通过的本任务改动创建本地 Git 提交,绝不 push。
@@ -0,0 +1,48 @@
# 验证码投递隔离与重置受理一致性
日期:2026-10-22(Asia/Shanghai)。本增量继续处理 24 号任务表中的认证逻辑缺陷,不代表所有系统开发任务完成。
## 发现与设计
此前重置发送对未知账号立即返回,对已有账号等待邮件/短信网络响应,并只对已有账号执行限额。单次成功 JSON 相同并不能消除 429、发送失败和网络等待带来的账号枚举差异。注册/重置发送还持有全局 PostgreSQL 事务锁等待外部服务。
本轮依照 OWASP Forgot Password Cheat Sheet 的统一消息、相似执行路径、异步处理和配额原则,将受理、投递、账号变更分为三个边界:
- `VerificationService`:仅做输入规范化、公开配置可用性、共享配额、随机码摘要和原子入队。重置请求**不查 users**,已知、未知、停用账号均执行相同 DB/加密写入路径;未知账号同样计入账户、来源及全局预算,不再快速返回。注册仍须有效邀请码。
- `VerificationDispatchService`:事务内原子写码和加密 outbox;后台领取提交后才解密、复查当前代次和账号可用性并调用 sender。网络调用期间没有数据库事务或全局配额锁。`VerifiedAccountService` 原有验证码/账号业务原子性和错误码计数保留。
- `VerificationPurpose`:封闭的注册/密码重置用途枚举,同时提供固定 SQL 表标识及消息目的。邮件不再把重置验证码误写成注册验证码;SMS 沿用服务器配置的通用模板,生产须核对其适用范围。
## 数据与资源边界
V50 给两张验证码表增加 `delivery_id`,并新建 `verification_delivery_outbox`。payload 使用已有 `SecretCipher` 的 AES-GCM,加密账户、验证码、用途与随机代次 ID;工作者检查密文内容中的 ID/用途与队列行一致,防止跨行替换投递。队列表不存明文账户或 OTP;原有码表继续保存摘要,原有发送事件仍含账户/IP,因此**并未声称所有认证表均匿名化或加密**。
共享预算沿用每账户 60 秒 1 次/24 小时 10 次、每来源每小时 30 次、全平台每日 1000 次,注册与重置共同计数。限额锁只覆盖 DB 工作,锁等待最多 2 秒;使用 `clock_timestamp()` 防止排队事务沿用早先开始时间。仍需部署侧 WAF/入口请求上限,不能把发送配额当成全站 DoS 防护。配额计算保留全局序列化与事件扫描,适用于当前低容量内测,未来扩容需专用窗口桶及多租户公平策略。
后台每秒调度,最多两个本机工作线程,`SynchronousQueue` 无内存等待队列;重复调度在繁忙时直接退出。多副本用 `FOR UPDATE SKIP LOCKED` 原子领取,领取状态先提交为 `sending`。领取后的消息只尝试一次:崩溃、网络结果不明或成功回执保存失败都不自动重发。该策略是**至多一次尝试**而不是可靠必达;某些消息可能丢失,用户可在受理冷却期后重新申请。
发送前复查当前 `delivery_id`、未消费、未超过五次、未过期;重置再查账号是否仍 active,未知/停用账号丢弃且不发送。投递失败只按原代次作废,不会消耗后来生成的新码;消费成功/新申请后迟到的旧消息不具备新码效力。状态终结即清除密文 payload,不保留收件人、OTP、异常堆栈或原供应商错误消息到队列表/公开响应。终态保留固定故障码。未处理消息五分钟过期,终态两天后、过期码一天后分批删除;清理当前由空闲 worker 驱动,持续繁忙时物理清理可能延后,过期判断仍生效。
原 SMTP 连接/读写超时和短信 SDK 禁自动重试保持不变。本轮没有证明底层 SDK 的 DNS 或整体调用具备不可绕过的绝对墙钟期限;双线程上限只能限制资源规模,不能保证阻塞线程及时释放。任意网络迟到、数据缓存、不同历史状态造成的可测时序仍未做生产统计验收;本轮不承诺严格恒定时间或消除所有枚举侧信道。
## 对外兼容与上线要求
- 发送接口仍返回 200、`sent: true`、60 秒冷却和 300 秒有效期;`sent` 是历史兼容字段,**只表示受理,并非邮件/短信送达证明**。不返回任务 ID、验证码、内部丢弃原因或凭据。公开重置页改为“若账号存在且可用,将收到重置验证码”。
- 未获取、已消费、已过期、次数耗尽及错误的重置验证码统一返回 `VERIFICATION_INVALID` 与同一消息;不再以“缺失/过期”差异表达内部状态。注册验证码既有错误语义不变。
- 部署本版本前先应用 V50,再启动新后端;所有副本必须使用相同且安全持久化的 `CREDENTIAL_ENCRYPTION_KEY`,并配置 SMTP 或 SMS。缺失加密密钥时能力查询关闭该功能,发送安全失败,不回退明文或同步发送。不要在仍有待发送消息时直接更换密钥。
- 本轮仅在隔离测试库执行迁移;没有修改业务库、真实发送、部署或 push。数据库备份中的历史密文不因在线清理被擦除,仍需备份保留和密钥管理策略。
## 验证证据
新增 `VerificationDispatchPostgresTest` 22 项真实 PostgreSQL 回归,覆盖请求一致性、未知账号同额限制、只向 active 发送、加密/代次校验、供应商失败不外泄和不重试、网络期间无事务/锁、新旧代次隔离、崩溃/过期清理、缺加密密钥、写入失败原子回滚、多连接领取、跨用途预算、统一错误、密文篡改、成功回执保存失败不重发、双线程无队列和 2 秒锁超时。测试用专用合成账户和内存 sender,真实网络只用于本地应用健康检查,没有邮件/短信付费调用。
最终后端命令:`mvn -B -o clean verify`,Java 21 / Maven 3.9.9、独立 PostgreSQL 15.18/Redis 7。**390 项,0 失败、0 错误、0 跳过,JAR 构建成功**,结束于 2026-10-22 08:41:38(Asia/Shanghai)。新增迁移和全部既有认证/MFA/验证码事务/媒体出站/账务/任务回归均参与。日志 `.tools/verification-delivery-final.log` 被忽略。
前端重新运行 `npm run build` 与 `npm test`:构建通过、25 项测试通过。另在本轮独立容器完整启动打包 JAR,Flyway 迁移至 V50,Spring 组件和定时方法成功初始化,`/health` 返回正常;未配置真实邮件/短信,`/api/auth/verification` 返回两通道均关闭,符合安全关闭状态。这只是本地启动冒烟,不替代真实投递或产品验收。
`spec-driven-acceptance-testing` 的共享 Python 环境阻塞仍未解除;本轮没有获授权修改其环境,未自行批准规格,也没有执行或声称 `qa run --project` 通过。仍须用户审阅 draft 后走正式验收。
参考原则:`https://cheatsheetseries.owasp.org/cheatsheets/Forgot_Password_Cheat_Sheet.html`。该文档是设计参考,不是对本产品的认证或第三方审计结果。
## 自动化与后续
按用户本轮明确要求,已删除聊天内 `moyi` 每半小时本地提交检查自动化。没有删除产品内部任务/投递 worker。当前按 `git-commit-conventions` 审查完整差异和暂存区,只提交本任务已验证文件,不 push。后续按 24 号表继续管理授权、配置版本、请求传输统一、长请求租约和协议能力;不把本次增量称作全部开发完成。
+2 -2
View File
@@ -62,7 +62,7 @@ async function sendCode() {
cooldown.value = result.retryAfterSeconds
clearInterval(cooldownTimer)
cooldownTimer = setInterval(() => { if (cooldown.value > 0) cooldown.value--; else clearInterval(cooldownTimer) }, 1000)
emit('notify', '验证码已发送,5 分钟内有效')
emit('notify', '验证码发送请求已受理,请查收;验证码 5 分钟内有效')
} catch (error) {
emit('notify', error instanceof Error ? error.message : '验证码发送失败')
} finally { sendingCode.value = false }
@@ -81,7 +81,7 @@ async function sendResetCode() {
cooldown.value = result.retryAfterSeconds
clearInterval(cooldownTimer)
cooldownTimer = setInterval(() => { if (cooldown.value > 0) cooldown.value--; else clearInterval(cooldownTimer) }, 1000)
emit('notify', '验证码已发送,5 分钟内有效')
emit('notify', '若账号存在且可用,将收到重置验证码;验证码 5 分钟内有效')
} catch (error) {
emit('notify', error instanceof AuthApiError ? error.message : '验证码发送失败')
} finally { sendingCode.value = false }