整理前后端与测试构建目录并完善配置和安全引导
Security Checks / security (push) Waiting to run

统一 frontend、backend、test、test-log 和 out 目录,更新构建、部署及测试入口;纳入配置管理兼容与首次安全引导修复;排除本机配置、密钥和测试产物。
This commit is contained in:
xuans committed 2026-09-05 19:19:52 +08:00
1 parent 28cd9d3406
commit f60d3b0880
603 files changed
+2351 -660

No files matched your search

+328
View File
@@ -0,0 +1,328 @@
package send
import (
"crypto/tls"
"errors"
"fmt"
"git.pcux.cn/xuans/Smail/config"
"git.pcux.cn/xuans/Smail/dto/parsemail"
"git.pcux.cn/xuans/Smail/models"
"git.pcux.cn/xuans/Smail/utils/array"
"git.pcux.cn/xuans/Smail/utils/async"
"git.pcux.cn/xuans/Smail/utils/consts"
"git.pcux.cn/xuans/Smail/utils/context"
"git.pcux.cn/xuans/Smail/utils/smtp"
log "github.com/sirupsen/logrus"
"net"
"net/mail"
"net/textproto"
"strings"
"sync"
)
type mxDomain struct {
domain string
mxHost string
localTest bool
}
type temporaryMXFallbackError struct {
lookupErr error
fallbackErr error
}
func (e *temporaryMXFallbackError) Error() string {
return fmt.Sprintf("temporary MX lookup failed (%v); fallback delivery failed: %v", e.lookupErr, e.fallbackErr)
}
func (e *temporaryMXFallbackError) Unwrap() error {
return e.lookupErr
}
// Forward 转发邮件
func Forward(ctx *context.Context, e *parsemail.Email, forwardAddress string, user *models.User) error {
log.WithContext(ctx).Debugf("开始转发邮件")
b, err := e.ForwardBuildBytes(ctx, user, forwardAddress)
if err != nil {
return fmt.Errorf("build forwarded message: %w", err)
}
log.WithContext(ctx).Debug("forward message prepared")
domains := config.CurrentMailDomains()
if len(domains.Accepted) == 0 {
return errors.New("runtime configuration is unavailable")
}
from := user.Account + "@" + domains.Primary
return forwardData(ctx, domains.Primary, b, forwardAddress, from)
}
func ForwardRaw(ctx *context.Context, e *parsemail.Email, rawEmailData []byte, forwardAddress string, user *models.User) error {
log.WithContext(ctx).Debugf("开始原始邮件转发")
domains := config.CurrentMailDomains()
if len(domains.Accepted) == 0 {
return errors.New("runtime configuration is unavailable")
}
from := user.Account + "@" + domains.Primary
return forwardData(ctx, domains.Primary, rawEmailData, forwardAddress, from)
}
func forwardData(ctx *context.Context, fromDomain string, data []byte, forwardAddress string, from string) error {
var to []*parsemail.User
to = []*parsemail.User{
{EmailAddress: forwardAddress},
}
err, _ := doSend(ctx, fromDomain, data, to, from)
return err
}
func Send(ctx *context.Context, e *parsemail.Email) (error, map[string]error) {
_, fromDomain := e.From.GetDomainAccount()
b, err := e.BuildBytes(ctx, true)
if err != nil {
return fmt.Errorf("build message: %w", err), nil
}
var to []*parsemail.User
to = append(append(append(to, e.To...), e.Cc...), e.Bcc...)
return doSend(ctx, fromDomain, b, to, e.From.EmailAddress)
}
func parseRecipientAddress(user *parsemail.User) (string, string, error) {
if user == nil {
return "", "", errors.New("recipient is nil")
}
address := strings.TrimSpace(user.EmailAddress)
if address == "" || address != user.EmailAddress {
return address, "", errors.New("recipient address is empty or contains surrounding whitespace")
}
parsed, err := mail.ParseAddress(address)
if err != nil || parsed.Address != address {
return address, "", errors.New("recipient address is invalid")
}
at := strings.LastIndexByte(address, '@')
if at <= 0 || at >= len(address)-1 {
return address, "", errors.New("recipient address has no valid domain")
}
domain := strings.ToLower(address[at+1:])
if strings.ContainsAny(domain, " \t\r\n") {
return address, "", errors.New("recipient domain is invalid")
}
return address, domain, nil
}
func doSend(ctx *context.Context, fromDomain string, data []byte, to []*parsemail.User, from string) (error, map[string]error) {
if len(to) == 0 {
err := errors.New("no recipients")
return err, map[string]error{"recipients": err}
}
invalidAddresses := make([]string, 0)
invalidErrors := make(map[string]error)
// 按域名整理
toByDomain := map[mxDomain][]*parsemail.User{}
mxLookupErrors := map[mxDomain]error{}
for _, s := range to {
address, domain, addressErr := parseRecipientAddress(s)
if addressErr != nil {
if address == "" {
address = "<empty>"
}
invalidAddresses = append(invalidAddresses, address)
invalidErrors[address] = addressErr
log.WithContext(ctx).WithError(addressErr).Error("invalid recipient address")
continue
}
args := []string{address, domain}
if len(args) == 2 {
if args[1] == consts.TEST_DOMAIN {
// 测试使用
address := mxDomain{
domain: "localhost",
mxHost: "127.0.0.1",
localTest: true,
}
toByDomain[address] = append(toByDomain[address], s)
} else {
//查询dns mx记录
mxInfo, lookupErr := net.LookupMX(args[1])
address := mxDomain{
domain: "smtp." + args[1],
mxHost: "smtp." + args[1],
}
if lookupErr != nil {
log.WithContext(ctx).Errorf("%s 域名mx记录查询失败,检查邮箱是否存在!", s.EmailAddress)
}
if len(mxInfo) > 0 {
address = mxDomain{
domain: args[1],
mxHost: mxInfo[0].Host,
}
}
if lookupErr != nil {
mxLookupErrors[address] = lookupErr
}
toByDomain[address] = append(toByDomain[address], s)
}
} else {
log.WithContext(ctx).Errorf("邮箱地址解析错误! %s", s)
continue
}
}
errEmailAddress := append([]string(nil), invalidAddresses...)
var errEmailAddressMu sync.Mutex
errMap := sync.Map{}
for address, err := range invalidErrors {
errMap.Store(address, err)
}
as := async.New(ctx)
for domain, tos := range toByDomain {
domain := domain
tos := tos
mxLookupErr := mxLookupErrors[domain]
as.WaitProcess(func(p any) {
recordFailure := func(err error) {
err = deliveryFailureCause(mxLookupErr, err)
log.WithContext(ctx).Errorf("%v 邮件投递失败%+v", tos, err)
errEmailAddressMu.Lock()
for _, user := range tos {
errEmailAddress = append(errEmailAddress, user.EmailAddress)
}
errEmailAddressMu.Unlock()
errMap.Store(domain.domain, err)
}
if allowUnsafeSMTP(domain) {
err := smtp.SendMailUnsafe("localhost", domain.mxHost+":25", nil, from, fromDomain, buildAddress(tos), data)
if err != nil {
recordFailure(err)
}
return
}
// 优先尝试25端口,starttls方式投递
err := smtp.SendMail("", domain.mxHost+":25", nil, from, fromDomain, buildAddress(tos), data)
if err == nil {
return
}
if isCertificateVerificationError(err) {
recordFailure(err)
return
}
if isPermanentSMTPResponse(err) {
recordFailure(err)
return
}
log.WithContext(ctx).Infof("SMTP STARTTLS on 25 Send Error. %s", err.Error())
// 再试用587投递
err = smtp.SendMailWithTls(strings.TrimSuffix(domain.mxHost, "."), domain.mxHost+":587", nil, from, fromDomain, buildAddress(tos), data)
if err == nil {
return
}
if isCertificateVerificationError(err) {
recordFailure(err)
return
}
if isPermanentSMTPResponse(err) {
recordFailure(err)
return
}
log.WithContext(ctx).Infof("SMTPS on 587 Send Error. %s", err.Error())
// 再次尝试465投递
err = smtp.SendMailWithTls(strings.TrimSuffix(domain.mxHost, "."), domain.mxHost+":465", nil, from, fromDomain, buildAddress(tos), data)
if err == nil {
return
}
if isCertificateVerificationError(err) {
recordFailure(err)
return
}
if isPermanentSMTPResponse(err) {
recordFailure(err)
return
}
log.WithContext(ctx).Infof("SMTPS on 465 Send Error. %s", err.Error())
// 所有安全投递方式均失败后记录错误,不允许回退到明文连接。
recordFailure(err)
}, nil)
}
as.Wait()
orgMap := map[string]error{}
errMap.Range(func(key, value any) bool {
if value != nil {
orgMap[key.(string)] = value.(error)
} else {
orgMap[key.(string)] = nil
}
return true
})
if len(errEmailAddress) > 0 {
return errors.New("以下收件人投递失败:" + array.Join(errEmailAddress, ",")), orgMap
}
return nil, orgMap
}
func allowUnsafeSMTP(domain mxDomain) bool {
return domain.localTest && domain.domain == "localhost" && domain.mxHost == "127.0.0.1"
}
func isCertificateVerificationError(err error) bool {
var certificateErr *tls.CertificateVerificationError
return errors.As(err, &certificateErr)
}
func isPermanentSMTPResponse(err error) bool {
var protocolErr *textproto.Error
return errors.As(err, &protocolErr) && protocolErr.Code >= 500 && protocolErr.Code <= 599
}
func deliveryFailureCause(mxLookupErr, fallbackErr error) error {
if fallbackErr == nil || isPermanentSMTPResponse(fallbackErr) {
return fallbackErr
}
var lookupDNSErr *net.DNSError
if !errors.As(mxLookupErr, &lookupDNSErr) || (!lookupDNSErr.IsTimeout && !lookupDNSErr.IsTemporary) {
return fallbackErr
}
var networkErr net.Error
if !errors.As(fallbackErr, &networkErr) {
return fallbackErr
}
return &temporaryMXFallbackError{
lookupErr: mxLookupErr,
fallbackErr: fallbackErr,
}
}
func buildAddress(u []*parsemail.User) []string {
var ret []string
for _, user := range u {
ret = append(ret, user.EmailAddress)
}
return ret
}
+160
View File
@@ -0,0 +1,160 @@
package send
import (
"crypto/tls"
"errors"
"fmt"
"net"
"net/textproto"
"testing"
"git.pcux.cn/xuans/Smail/dto/parsemail"
appcontext "git.pcux.cn/xuans/Smail/utils/context"
)
func TestIsPermanentSMTPResponse(t *testing.T) {
tests := []struct {
name string
err error
want bool
}{
{name: "nil"},
{name: "network error", err: errors.New("connection refused")},
{name: "temporary SMTP response", err: &textproto.Error{Code: 451, Msg: "try later"}},
{name: "wrapped temporary SMTP response", err: fmt.Errorf("delivery: %w", &textproto.Error{Code: 421, Msg: "service unavailable"})},
{name: "permanent SMTP response", err: &textproto.Error{Code: 550, Msg: "mailbox unavailable"}, want: true},
{name: "wrapped permanent SMTP response", err: fmt.Errorf("delivery: %w", &textproto.Error{Code: 554, Msg: "transaction failed"}), want: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := isPermanentSMTPResponse(tt.err); got != tt.want {
t.Fatalf("isPermanentSMTPResponse() = %v, want %v", got, tt.want)
}
})
}
}
func TestDeliveryFailureCausePreservesTemporaryMXError(t *testing.T) {
tests := []struct {
name string
lookupErr *net.DNSError
}{
{
name: "SERVFAIL before fallback NXDOMAIN",
lookupErr: &net.DNSError{Err: "server misbehaving", Name: "example.com", IsTemporary: true},
},
{
name: "timeout before fallback NXDOMAIN",
lookupErr: &net.DNSError{Err: "i/o timeout", Name: "example.com", IsTimeout: true},
},
}
fallbackErr := &net.OpError{
Op: "dial",
Net: "tcp",
Err: &net.DNSError{Err: "no such host", Name: "smtp.example.com", IsNotFound: true},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := deliveryFailureCause(tt.lookupErr, fallbackErr)
var dnsErr *net.DNSError
if !errors.As(err, &dnsErr) {
t.Fatalf("deliveryFailureCause() = %T, want wrapped DNS error", err)
}
if dnsErr.IsNotFound {
t.Fatalf("deliveryFailureCause() selected fallback NXDOMAIN: %v", dnsErr)
}
if !dnsErr.IsTemporary && !dnsErr.IsTimeout {
t.Fatalf("deliveryFailureCause() selected non-temporary DNS error: %v", dnsErr)
}
})
}
}
func TestDeliveryFailureCauseKeepsExplicitSMTPRejection(t *testing.T) {
lookupErr := &net.DNSError{Err: "server misbehaving", Name: "example.com", IsTemporary: true}
rejection := &textproto.Error{Code: 550, Msg: "mailbox unavailable"}
if got := deliveryFailureCause(lookupErr, rejection); got != rejection {
t.Fatalf("deliveryFailureCause() = %v, want explicit SMTP rejection %v", got, rejection)
}
}
func TestCertificateVerificationErrorStopsFallback(t *testing.T) {
verificationErr := &tls.CertificateVerificationError{Err: errors.New("hostname mismatch")}
if !isCertificateVerificationError(fmt.Errorf("STARTTLS failed: %w", verificationErr)) {
t.Fatal("wrapped certificate verification error was not detected")
}
if isCertificateVerificationError(errors.New("connection refused")) {
t.Fatal("network error was treated as a certificate verification error")
}
}
func TestAllowUnsafeSMTPRequiresExplicitLoopbackTestTarget(t *testing.T) {
tests := []struct {
name string
domain mxDomain
want bool
}{
{name: "explicit local test", domain: mxDomain{domain: "localhost", mxHost: "127.0.0.1", localTest: true}, want: true},
{name: "external domain", domain: mxDomain{domain: "example.com", mxHost: "mx.example.com"}},
{name: "forged localhost name", domain: mxDomain{domain: "localhost", mxHost: "127.0.0.1"}},
{name: "test flag with external host", domain: mxDomain{domain: "localhost", mxHost: "192.0.2.1", localTest: true}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := allowUnsafeSMTP(tt.domain); got != tt.want {
t.Fatalf("allowUnsafeSMTP() = %v, want %v", got, tt.want)
}
})
}
}
func TestParseRecipientAddressRejectsUnsafeInput(t *testing.T) {
tests := []struct {
name string
user *parsemail.User
}{
{name: "nil recipient"},
{name: "empty address", user: &parsemail.User{}},
{name: "missing domain", user: &parsemail.User{EmailAddress: "recipient"}},
{name: "surrounding whitespace", user: &parsemail.User{EmailAddress: " recipient@example.com"}},
{name: "header injection", user: &parsemail.User{EmailAddress: "recipient@example.com\r\nBcc: victim@example.com"}},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if _, _, err := parseRecipientAddress(tt.user); err == nil {
t.Fatal("unsafe recipient address was accepted")
}
})
}
}
func TestDoSendReportsInvalidRecipients(t *testing.T) {
err, failures := doSend(
&appcontext.Context{},
"example.com",
[]byte("message"),
[]*parsemail.User{{EmailAddress: "invalid"}, nil},
"sender@example.com",
)
if err == nil {
t.Fatal("invalid recipients were reported as delivered")
}
if len(failures) != 2 {
t.Fatalf("failure count = %d, want 2", len(failures))
}
}
func TestDoSendRejectsEmptyRecipientList(t *testing.T) {
err, failures := doSend(&appcontext.Context{}, "example.com", []byte("message"), nil, "sender@example.com")
if err == nil {
t.Fatal("empty recipient list was reported as delivered")
}
if len(failures) != 1 {
t.Fatalf("failure count = %d, want 1", len(failures))
}
}