完善 Scert 前后端与部署支持

This commit is contained in:
xuans committed 2026-08-30 17:44:54 +08:00
1 parent afdb947bea
commit 7f0af703ed
85 files changed
+7530 -800

No files matched your search

+17 -14
View File
@@ -6,6 +6,7 @@ import (
"crypto/hmac"
"crypto/rand"
"crypto/sha256"
"crypto/tls"
"encoding/hex"
"encoding/json"
"errors"
@@ -88,17 +89,18 @@ func (e *sessionExpiredError) Error() string {
// Service 通过 HTTP 邮件 API 发送通知。
type Service struct {
config config.NotificationConfig
credentials CredentialReader
client HTTPDoer
now func() time.Time
requestID func() string
sleep func(context.Context, time.Duration) error
config config.NotificationConfig
credentials CredentialReader
client HTTPDoer
now func() time.Time
requestID func() string
sleep func(context.Context, time.Duration) error
smtpTLSConfig func(string) *tls.Config
}
// New 创建 HTTP 通知服务。SMTP 配置暂保留为兼容字段,当前发送器只执行 HTTP 通知。
func New(cfg config.NotificationConfig, credentials CredentialReader) *Service {
return &Service{
service := &Service{
config: cfg,
credentials: credentials,
client: &http.Client{},
@@ -106,18 +108,19 @@ func New(cfg config.NotificationConfig, credentials CredentialReader) *Service {
requestID: newRequestID,
sleep: sleepContext,
}
service.smtpTLSConfig = func(host string) *tls.Config {
return &tls.Config{ServerName: host, MinVersion: tls.VersionTLS12}
}
return service
}
// Send 按配置发送通知;未启用任何通知通道时直接返回成功。
func (s *Service) Send(ctx context.Context, event Event) error {
func (s *Service) sendHTTP(ctx context.Context, event Event) error {
if s == nil {
return errors.New("通知服务未初始化")
}
if !s.config.HTTPEnabled && !s.config.SMTPEnabled {
return nil
}
if !s.config.HTTPEnabled {
return errors.New("当前仅支持 HTTP 邮件通知,SMTP 通知发送器尚未接入")
return nil
}
if err := ctx.Err(); err != nil {
return err
@@ -272,7 +275,7 @@ func (s *Service) sendOnce(ctx context.Context, endpoint string, body []byte, cr
func (s *Service) loginSession(ctx context.Context, credentials map[string]string) (sessionAuth, error) {
account := credentialValue(credentials, "account", "username", "identifier")
password := credentials["password"]
if account == "" || strings.TrimSpace(password) == "" {
if account == "" || password == "" {
return sessionAuth{}, errors.New("HTTP 通知会话凭据必须包含账号和密码")
}
loginURL, err := notificationURL(s.config.Endpoint, s.config.HTTPLoginPath)
@@ -321,7 +324,7 @@ func (s *Service) loginSession(ctx context.Context, credentials map[string]strin
if strings.TrimSpace(envelope.ErrorMsg) == "" {
return sessionAuth{}, fmt.Errorf("HTTP 通知登录失败,错误码 %d", *envelope.ErrorNo)
}
return sessionAuth{}, fmt.Errorf("HTTP 通知登录失败,错误码 %d", *envelope.ErrorNo)
return sessionAuth{}, fmt.Errorf("HTTP 通知登录失败,错误码 %d:%s", *envelope.ErrorNo, strings.TrimSpace(envelope.ErrorMsg))
}
cookies := make([]string, 0, len(response.Cookies()))
csrf := ""
@@ -271,3 +271,80 @@ func TestSendRefreshesExpiredSession(t *testing.T) {
t.Fatalf("未使用刷新后的会话:%v", cookies)
}
}
func TestSendRejectsEmptySessionPasswordWithoutTrimmingValidPassword(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
writer.WriteHeader(http.StatusInternalServerError)
}))
defer server.Close()
cfg := newTestConfig(server.URL)
cfg.HTTPAuthMode = "session"
cfg.HTTPCredentialRef = "secret://mail-session"
service := New(cfg, credentialReaderStub{values: map[string]string{
"account": "xuans",
"password": "",
}})
err := service.Send(context.Background(), Event{Status: "success", Domain: "example.com"})
if err == nil || !strings.Contains(err.Error(), "必须包含账号和密码") {
t.Fatalf("空密码应在发起登录请求前被拒绝:%v", err)
}
}
func TestSessionLoginPreservesWhitespacePassword(t *testing.T) {
var loginPayload map[string]string
server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
if request.URL.Path != "/api/login" {
writer.WriteHeader(http.StatusNoContent)
return
}
body, err := io.ReadAll(request.Body)
if err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(body, &loginPayload); err != nil {
t.Fatal(err)
}
writer.Header().Add("Set-Cookie", "session=whitespace-session; Path=/; HttpOnly")
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
_, _ = writer.Write([]byte(`{"errorNo":0,"errorMsg":""}`))
}))
defer server.Close()
cfg := newTestConfig(server.URL)
cfg.HTTPAuthMode = "session"
cfg.HTTPCredentialRef = "secret://mail-session"
service := New(cfg, credentialReaderStub{values: map[string]string{
"account": "xuans",
"password": " test-password ",
}})
if err := service.Send(context.Background(), Event{Status: "success", Domain: "example.com"}); err != nil {
t.Fatalf("保留空白密码的会话登录失败:%v", err)
}
if loginPayload["password"] != " test-password " {
t.Fatalf("密码不应被 TrimSpace:%q", loginPayload["password"])
}
}
func TestSessionLoginReturnsBusinessMessageWithoutCredentials(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(writer http.ResponseWriter, request *http.Request) {
writer.Header().Set("Content-Type", "application/json; charset=utf-8")
_, _ = writer.Write([]byte(`{"errorNo":403,"errorMsg":"账号或密码错误"}`))
}))
defer server.Close()
cfg := newTestConfig(server.URL)
cfg.HTTPAuthMode = "session"
cfg.HTTPCredentialRef = "secret://mail-session"
service := New(cfg, credentialReaderStub{values: map[string]string{
"account": "xuans",
"password": "test-password",
}})
err := service.Send(context.Background(), Event{Status: "success", Domain: "example.com"})
if err == nil || !strings.Contains(err.Error(), "错误码 403") || !strings.Contains(err.Error(), "账号或密码错误") {
t.Fatalf("登录业务错误应包含安全诊断:%v", err)
}
if strings.Contains(err.Error(), "test-password") {
t.Fatalf("登录错误不得包含密码:%v", err)
}
}
+228
View File
@@ -0,0 +1,228 @@
package notification
import (
"context"
"crypto/tls"
"errors"
"fmt"
"mime"
"net"
"net/mail"
"net/smtp"
"strconv"
"strings"
"time"
)
// Send 通过所有已启用的出站通道发送通知。
func (s *Service) Send(ctx context.Context, event Event) error {
if s == nil {
return errors.New("通知服务未初始化")
}
if !s.config.HTTPEnabled && !s.config.SMTPEnabled {
return nil
}
if err := ctx.Err(); err != nil {
return err
}
var errs []error
if s.config.HTTPEnabled {
if err := s.sendHTTP(ctx, event); err != nil {
errs = append(errs, err)
}
}
if s.config.SMTPEnabled {
payload, err := s.buildPayload(event)
if err != nil {
errs = append(errs, err)
} else if err := s.sendSMTPWithRetry(ctx, payload); err != nil {
errs = append(errs, err)
}
}
return errors.Join(errs...)
}
func (s *Service) sendSMTPWithRetry(ctx context.Context, payload mailPayload) error {
if strings.TrimSpace(s.config.SMTPHost) == "" {
return errors.New("SMTP 主机不能为空")
}
credentials, err := s.loadSMTPCredentials(ctx)
if err != nil {
return err
}
var lastErr error
for attempt := 0; attempt <= s.config.RetryCount; attempt++ {
if attempt > 0 {
interval := time.Duration(0)
if attempt-1 < len(s.config.RetryIntervalsSecs) {
interval = time.Duration(s.config.RetryIntervalsSecs[attempt-1]) * time.Second
}
if err := s.sleep(ctx, interval); err != nil {
return err
}
}
if err := s.sendSMTPOnce(ctx, payload, credentials); err == nil {
return nil
} else {
lastErr = err
}
}
return fmt.Errorf("发送 SMTP 通知失败,已重试 %d 次:%w", s.config.RetryCount, lastErr)
}
func (s *Service) loadSMTPCredentials(ctx context.Context) (map[string]string, error) {
ref := strings.TrimSpace(s.config.SMTPCredentialRef)
if ref == "" {
return nil, nil
}
if s.credentials == nil {
return nil, errors.New("SMTP 通知凭据存储未配置")
}
values, err := s.credentials.Get(ctx, ref)
if err != nil {
return nil, fmt.Errorf("读取 SMTP 通知凭据失败:%w", err)
}
return values, nil
}
func (s *Service) sendSMTPOnce(ctx context.Context, payload mailPayload, credentials map[string]string) error {
host := strings.TrimSpace(s.config.SMTPHost)
if host == "" {
return errors.New("SMTP 主机不能为空")
}
timeout := time.Duration(s.config.TimeoutSecs) * time.Second
if timeout < time.Second {
timeout = time.Second
}
address := net.JoinHostPort(strings.Trim(host, "[]"), strconv.Itoa(s.config.SMTPPort))
conn, err := s.dialSMTP(ctx, address, host, s.config.SMTPMode, timeout)
if err != nil {
return fmt.Errorf("连接 SMTP 服务器失败:%w", err)
}
defer conn.Close()
_ = conn.SetDeadline(time.Now().Add(timeout))
client, err := smtp.NewClient(conn, host)
if err != nil {
return fmt.Errorf("初始化 SMTP 客户端失败:%w", err)
}
defer client.Close()
if s.config.SMTPMode == "starttls" {
tlsConfig := s.smtpTLSConfig(host)
if ok, _ := client.Extension("STARTTLS"); !ok {
return errors.New("SMTP 服务器不支持 STARTTLS")
}
if err := client.StartTLS(tlsConfig); err != nil {
return fmt.Errorf("建立 SMTP STARTTLS 连接失败:%w", err)
}
}
username := strings.TrimSpace(s.config.SMTPUsername)
if username == "" {
username = credentialValue(credentials, "username", "account", "email")
}
password := credentialValue(credentials, "password", "pass")
if username != "" {
if password == "" {
return errors.New("SMTP 凭据中缺少密码")
}
if s.config.SMTPMode == "plain" && !s.config.SMTPAllowPlaintextAuth {
return errors.New("SMTP 明文连接禁止认证,请启用 TLS 或明确允许明文认证")
}
if err := client.Auth(smtp.PlainAuth("", username, password, host)); err != nil {
return fmt.Errorf("SMTP 认证失败:%w", err)
}
}
recipients := make([]string, 0, len(payload.To))
for _, item := range payload.To {
recipients = append(recipients, item.Email)
}
if err := client.Mail(payload.From.Email); err != nil {
return fmt.Errorf("设置 SMTP 发件人失败:%w", err)
}
for _, recipient := range recipients {
if err := client.Rcpt(recipient); err != nil {
return fmt.Errorf("设置 SMTP 收件人失败:%w", err)
}
}
writer, err := client.Data()
if err != nil {
return fmt.Errorf("打开 SMTP 邮件数据通道失败:%w", err)
}
if _, err := writer.Write(buildSMTPMessage(payload)); err != nil {
_ = writer.Close()
return fmt.Errorf("写入 SMTP 邮件内容失败:%w", err)
}
if err := writer.Close(); err != nil {
return fmt.Errorf("提交 SMTP 邮件失败:%w", err)
}
if err := client.Quit(); err != nil {
return fmt.Errorf("关闭 SMTP 会话失败:%w", err)
}
return nil
}
func (s *Service) dialSMTP(ctx context.Context, address, host, mode string, timeout time.Duration) (net.Conn, error) {
dialer := &net.Dialer{Timeout: timeout}
conn, err := dialer.DialContext(ctx, "tcp", address)
if err != nil {
return nil, err
}
if mode != "implicit_tls" {
return conn, nil
}
tlsConfig := s.smtpTLSConfig
if tlsConfig == nil {
tlsConfig = func(serverName string) *tls.Config {
return &tls.Config{ServerName: serverName, MinVersion: tls.VersionTLS12}
}
}
tlsConn := tls.Client(conn, tlsConfig(host))
if err := tlsConn.SetDeadline(time.Now().Add(timeout)); err != nil {
_ = conn.Close()
return nil, err
}
if err := tlsConn.HandshakeContext(ctx); err != nil {
_ = conn.Close()
return nil, err
}
_ = tlsConn.SetDeadline(time.Time{})
return tlsConn, nil
}
func buildSMTPMessage(payload mailPayload) []byte {
from := formatSMTPAddress(payload.From)
to := make([]string, 0, len(payload.To))
for _, item := range payload.To {
to = append(to, formatSMTPAddress(item))
}
subject := mime.QEncoding.Encode("UTF-8", payload.Subject)
content := payload.Text
content = strings.ReplaceAll(content, "\r\n", "\n")
content = strings.ReplaceAll(content, "\r", "\n")
content = strings.ReplaceAll(content, "\n", "\r\n")
if !strings.HasSuffix(content, "\r\n") {
content += "\r\n"
}
message := "From: " + from + "\r\n" +
"To: " + strings.Join(to, ", ") + "\r\n" +
"Subject: " + subject + "\r\n" +
"Date: " + time.Now().Format(time.RFC1123Z) + "\r\n" +
"MIME-Version: 1.0\r\n" +
"Content-Type: text/plain; charset=UTF-8\r\n" +
"Content-Transfer-Encoding: 8bit\r\n\r\n" + content
return []byte(message)
}
func formatSMTPAddress(value address) string {
parsed, err := mail.ParseAddress(value.Email)
if err != nil || parsed.Address == "" {
return value.Email
}
name := strings.TrimSpace(value.Name)
if name == "" {
name = parsed.Name
}
if name == "" {
return parsed.Address
}
return mime.QEncoding.Encode("UTF-8", name) + " <" + parsed.Address + ">"
}
+365
View File
@@ -0,0 +1,365 @@
package notification
import (
"bufio"
"context"
"crypto/rand"
"crypto/rsa"
"crypto/tls"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"io"
"math/big"
"net"
"strings"
"sync"
"testing"
"time"
"git.pcux.cn/xuans/Scert/backend/internal/config"
)
type smtpTestServer struct {
listener net.Listener
tlsConfig *tls.Config
implicitTLS bool
failMailOnce bool
rejectAuth bool
mu sync.Mutex
messages [][]byte
connections int
}
func newSMTPTestServer(t *testing.T, implicitTLS, startTLS bool) *smtpTestServer {
t.Helper()
listener, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
t.Fatalf("create SMTP test listener: %v", err)
}
server := &smtpTestServer{listener: listener, implicitTLS: implicitTLS}
if implicitTLS || startTLS {
server.tlsConfig = newSMTPTestTLSConfig(t)
}
go server.serve(startTLS)
t.Cleanup(func() { _ = listener.Close() })
return server
}
func (s *smtpTestServer) address() (string, int) {
address := s.listener.Addr().(*net.TCPAddr)
return address.IP.String(), address.Port
}
func (s *smtpTestServer) serve(startTLS bool) {
for {
connection, err := s.listener.Accept()
if err != nil {
return
}
s.mu.Lock()
s.connections++
s.mu.Unlock()
go s.handle(connection, startTLS)
}
}
func (s *smtpTestServer) handle(connection net.Conn, startTLS bool) {
defer connection.Close()
if s.implicitTLS {
tlsConnection := tls.Server(connection, s.tlsConfig)
if err := tlsConnection.Handshake(); err != nil {
return
}
connection = tlsConnection
}
reader := bufio.NewReader(connection)
writeLine := func(value string) error {
_, err := io.WriteString(connection, value+"\r\n")
return err
}
if writeLine("220 smtp.test.local ESMTP") != nil {
return
}
for {
line, err := reader.ReadString('\n')
if err != nil {
return
}
command := strings.TrimSpace(line)
upper := strings.ToUpper(command)
switch {
case strings.HasPrefix(upper, "EHLO"), strings.HasPrefix(upper, "HELO"):
if writeLine("250-smtp.test.local") != nil {
return
}
if startTLS && writeLine("250-STARTTLS") != nil {
return
}
if writeLine("250 AUTH PLAIN") != nil {
return
}
case strings.HasPrefix(upper, "STARTTLS"):
if !startTLS || writeLine("220 ready for TLS") != nil {
return
}
tlsConnection := tls.Server(connection, s.tlsConfig)
if err := tlsConnection.Handshake(); err != nil {
return
}
connection = tlsConnection
reader = bufio.NewReader(connection)
case strings.HasPrefix(upper, "AUTH PLAIN"):
if s.rejectAuth {
if writeLine("535 authentication failed") != nil {
return
}
continue
}
if writeLine("235 authentication successful") != nil {
return
}
case strings.HasPrefix(upper, "MAIL FROM:"):
s.mu.Lock()
fail := s.failMailOnce
s.failMailOnce = false
s.mu.Unlock()
if fail {
if writeLine("451 temporary failure") != nil {
return
}
return
}
if writeLine("250 sender accepted") != nil {
return
}
case strings.HasPrefix(upper, "RCPT TO:"):
if writeLine("250 recipient accepted") != nil {
return
}
case upper == "DATA":
if writeLine("354 end with <CRLF>.<CRLF>") != nil {
return
}
var message strings.Builder
for {
dataLine, readErr := reader.ReadString('\n')
if readErr != nil {
return
}
if dataLine == ".\r\n" {
break
}
message.WriteString(dataLine)
}
s.mu.Lock()
s.messages = append(s.messages, []byte(message.String()))
s.mu.Unlock()
if writeLine("250 queued") != nil {
return
}
case upper == "QUIT":
_ = writeLine("221 closing connection")
return
default:
if writeLine("250 ok") != nil {
return
}
}
}
}
func (s *smtpTestServer) clientTLSConfig(host string) *tls.Config {
s.mu.Lock()
defer s.mu.Unlock()
pool := x509.NewCertPool()
if len(s.tlsConfig.Certificates) == 0 || len(s.tlsConfig.Certificates[0].Certificate) == 0 {
return &tls.Config{ServerName: host, MinVersion: tls.VersionTLS12}
}
pool.AppendCertsFromPEM(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: s.tlsConfig.Certificates[0].Certificate[0]}))
return &tls.Config{ServerName: host, RootCAs: pool, MinVersion: tls.VersionTLS12}
}
func (s *smtpTestServer) message() []byte {
s.mu.Lock()
defer s.mu.Unlock()
if len(s.messages) == 0 {
return nil
}
return append([]byte(nil), s.messages[len(s.messages)-1]...)
}
func newSMTPTestTLSConfig(t *testing.T) *tls.Config {
t.Helper()
key, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
t.Fatalf("generate SMTP test key: %v", err)
}
serial, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 120))
if err != nil {
t.Fatalf("generate SMTP test serial: %v", err)
}
template := &x509.Certificate{
SerialNumber: serial,
Subject: pkix.Name{CommonName: "127.0.0.1"},
DNSNames: []string{"smtp.test.local"},
IPAddresses: []net.IP{net.ParseIP("127.0.0.1")},
NotBefore: time.Now().Add(-time.Minute),
NotAfter: time.Now().Add(time.Hour),
KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
}
der, err := x509.CreateCertificate(rand.Reader, template, template, &key.PublicKey, key)
if err != nil {
t.Fatalf("generate SMTP test certificate: %v", err)
}
certificate, err := tls.X509KeyPair(
pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der}),
pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)}),
)
if err != nil {
t.Fatalf("load SMTP test certificate: %v", err)
}
return &tls.Config{Certificates: []tls.Certificate{certificate}, MinVersion: tls.VersionTLS12}
}
func smtpTestConfig(host string, port int, mode string) config.NotificationConfig {
return config.NotificationConfig{
SMTPEnabled: true,
SMTPHost: host,
SMTPPort: port,
SMTPUsername: "user",
SMTPCredentialRef: "secret://notification/smtp/test",
SMTPMode: mode,
TimeoutSecs: 2,
RetryCount: 0,
SenderName: "Scert",
SenderEmail: "sender@example.com",
Recipients: []string{"receiver@example.com"},
}
}
func TestSMTPRejectsPlainAuthenticationByDefault(t *testing.T) {
server := newSMTPTestServer(t, false, false)
host, port := server.address()
service := New(smtpTestConfig(host, port, "plain"), credentialReaderStub{values: map[string]string{
"username": "user",
"password": "test-password",
}})
err := service.Send(context.Background(), Event{Type: "certificate_issue", Status: "success", Domain: "example.com"})
if err == nil || !strings.Contains(err.Error(), "\u660e\u6587\u8fde\u63a5\u7981\u6b62\u8ba4\u8bc1") {
t.Fatalf("plain SMTP authentication should be rejected: %v", err)
}
if strings.Contains(err.Error(), "test-password") {
t.Fatalf("SMTP errors must not expose password: %v", err)
}
}
func TestSMTPSendsUTF8WithAllowedPlainAuthentication(t *testing.T) {
server := newSMTPTestServer(t, false, false)
host, port := server.address()
cfg := smtpTestConfig(host, port, "plain")
cfg.SMTPAllowPlaintextAuth = true
service := New(cfg, credentialReaderStub{values: map[string]string{
"username": "user",
"password": "test-password",
}})
if err := service.Send(context.Background(), Event{Type: "certificate_renewal", Status: "success", Domain: "example.test"}); err != nil {
t.Fatalf("send UTF-8 SMTP notification: %v", err)
}
message := string(server.message())
if !strings.Contains(message, "Subject: =?UTF-8?") || !strings.Contains(message, "example.test") {
t.Fatalf("SMTP message was not generated correctly: %q", message)
}
}
func TestSMTPStartTLS(t *testing.T) {
server := newSMTPTestServer(t, false, true)
host, port := server.address()
service := New(smtpTestConfig(host, port, "starttls"), credentialReaderStub{values: map[string]string{
"username": "user",
"password": "test-password",
}})
service.smtpTLSConfig = server.clientTLSConfig
if err := service.Send(context.Background(), Event{Type: "certificate_issue", Status: "success", Domain: "example.com"}); err != nil {
t.Fatalf("send SMTP STARTTLS notification: %v", err)
}
}
func TestSMTPImplicitTLS(t *testing.T) {
server := newSMTPTestServer(t, true, false)
host, port := server.address()
service := New(smtpTestConfig(host, port, "implicit_tls"), credentialReaderStub{values: map[string]string{
"username": "user",
"password": "test-password",
}})
service.smtpTLSConfig = server.clientTLSConfig
if err := service.Send(context.Background(), Event{Type: "certificate_issue", Status: "success", Domain: "example.com"}); err != nil {
t.Fatalf("send SMTP implicit TLS notification: %v", err)
}
}
func TestSMTPRetriesTemporaryFailure(t *testing.T) {
server := newSMTPTestServer(t, false, false)
server.failMailOnce = true
host, port := server.address()
cfg := smtpTestConfig(host, port, "plain")
cfg.SMTPAllowPlaintextAuth = true
cfg.RetryCount = 1
cfg.RetryIntervalsSecs = []int{0}
service := New(cfg, credentialReaderStub{values: map[string]string{
"username": "user",
"password": "test-password",
}})
service.sleep = func(context.Context, time.Duration) error { return nil }
if err := service.Send(context.Background(), Event{Type: "certificate_issue", Status: "success", Domain: "example.com"}); err != nil {
t.Fatalf("SMTP retry should recover from temporary failure: %v", err)
}
server.mu.Lock()
connections := server.connections
messages := len(server.messages)
server.mu.Unlock()
if connections < 2 || messages != 1 {
t.Fatalf("SMTP retry result is incorrect: connections=%d messages=%d", connections, messages)
}
}
func TestSMTPAuthFailureDoesNotLeakPassword(t *testing.T) {
server := newSMTPTestServer(t, false, true)
server.rejectAuth = true
host, port := server.address()
service := New(smtpTestConfig(host, port, "starttls"), credentialReaderStub{values: map[string]string{
"username": "user",
"password": "wrong-password",
}})
service.smtpTLSConfig = server.clientTLSConfig
err := service.Send(context.Background(), Event{Type: "certificate_issue", Status: "success", Domain: "example.com"})
if err == nil || !strings.Contains(err.Error(), "\u8ba4\u8bc1\u5931\u8d25") {
t.Fatalf("SMTP authentication failure should be reported: %v", err)
}
if strings.Contains(err.Error(), "wrong-password") {
t.Fatalf("SMTP authentication errors must not expose password: %v", err)
}
}
func TestSMTPRejectsMissingHost(t *testing.T) {
cfg := smtpTestConfig("", 587, "starttls")
service := New(cfg, nil)
err := service.Send(context.Background(), Event{Type: "certificate_issue", Status: "success", Domain: "example.com"})
if err == nil || !strings.Contains(err.Error(), "SMTP \u4e3b\u673a\u4e0d\u80fd\u4e3a\u7a7a") {
t.Fatalf("missing SMTP host should return a clear error: %v", err)
}
}
func TestSMTPAddressFormatting(t *testing.T) {
value := formatSMTPAddress(address{Name: "\u7ba1\u7406\u670d\u52a1", Email: "admin@example.com"})
if !strings.Contains(value, "admin@example.com") || !strings.Contains(value, "=?UTF-8?") {
t.Fatalf("SMTP address encoding is incorrect: %s", value)
}
}