完善 Scert 前后端与部署支持
This commit is contained in:
1 parent
afdb947bea
commit
7f0af703ed
85 files changed
+7530
-800
No files matched your search
@@ -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)
|
||||
}
|
||||
}
|
||||
@@ -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 + ">"
|
||||
}
|
||||
@@ -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)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user