Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

FIX (email): Add SMTP_INSECURE_SKIP_VERIFY for self-signed SMTP certs (issue #624)

Rostislav Dugind37c3a73531e
diff --git a/.env.example b/.env.example
index 8e1ab969..8a841b1d 100644
--- a/.env.example
+++ b/.env.example
@@ -57,6 +57,7 @@ SMTP_PORT=1025
SMTP_PASSWORD=password
+SMTP_INSECURE_SKIP_VERIFY=false
# domain (used in email links)
DATABASUS_URL=
diff --git a/backend/internal/config/config.go b/backend/internal/config/config.go
index ec85ff90..c891b1ec 100644
--- a/backend/internal/config/config.go
+++ b/backend/internal/config/config.go
@@ -99,11 +99,12 @@ type EnvVariables struct {
CloudflareTurnstileSiteKey string `env:"CLOUDFLARE_TURNSTILE_SITE_KEY"`
// SMTP configuration (optional)
- SMTPHost string `env:"SMTP_HOST"`
- SMTPPort int `env:"SMTP_PORT"`
- SMTPUser string `env:"SMTP_USER"`
- SMTPPassword string `env:"SMTP_PASSWORD"`
- SMTPFrom string `env:"SMTP_FROM"`
+ SMTPHost string `env:"SMTP_HOST"`
+ SMTPPort int `env:"SMTP_PORT"`
+ SMTPUser string `env:"SMTP_USER"`
+ SMTPPassword string `env:"SMTP_PASSWORD"`
+ SMTPFrom string `env:"SMTP_FROM"`
+ SMTPInsecureSkipVerify bool `env:"SMTP_INSECURE_SKIP_VERIFY"`
// Application URL (optional) - used for email links
DatabasusURL string `env:"DATABASUS_URL"`
diff --git a/backend/internal/features/email/di.go b/backend/internal/features/email/di.go
index 7e593dda..e0c0505a 100644
--- a/backend/internal/features/email/di.go
+++ b/backend/internal/features/email/di.go
@@ -17,6 +17,7 @@ var emailSMTPSender = &EmailSMTPSender{
env.SMTPUser,
env.SMTPPassword,
env.SMTPFrom,
+ env.SMTPInsecureSkipVerify,
env.SMTPHost != "" && env.SMTPPort != 0,
}
diff --git a/backend/internal/features/email/email.go b/backend/internal/features/email/email.go
index 22d3f30b..accc0de1 100644
--- a/backend/internal/features/email/email.go
+++ b/backend/internal/features/email/email.go
@@ -20,13 +20,14 @@ const (
)
type EmailSMTPSender struct {
- logger *slog.Logger
- smtpHost string
- smtpPort int
- smtpUser string
- smtpPassword string
- smtpFrom string
- isConfigured bool
+ logger *slog.Logger
+ smtpHost string
+ smtpPort int
+ smtpUser string
+ smtpPassword string
+ smtpFrom string
+ isInsecureSkipVerify bool
+ isConfigured bool
}
func (s *EmailSMTPSender) SendEmail(to, subject, body string) error {
@@ -112,7 +113,7 @@ func (s *EmailSMTPSender) sendStartTLS(
func (s *EmailSMTPSender) createImplicitTLSClient() (*smtp.Client, func(), error) {
addr := net.JoinHostPort(s.smtpHost, fmt.Sprintf("%d", s.smtpPort))
- tlsConfig := &tls.Config{ServerName: s.smtpHost}
+ tlsConfig := &tls.Config{ServerName: s.smtpHost, InsecureSkipVerify: s.isInsecureSkipVerify}
dialer := &net.Dialer{Timeout: DefaultTimeout}
conn, err := (&tls.Dialer{NetDialer: dialer, Config: tlsConfig}).DialContext(context.Background(), "tcp", addr)
@@ -151,7 +152,10 @@ func (s *EmailSMTPSender) createStartTLSClient() (*smtp.Client, func(), error) {
}
if ok, _ := client.Extension("STARTTLS"); ok {
- if err := client.StartTLS(&tls.Config{ServerName: s.smtpHost}); err != nil {
+ if err := client.StartTLS(&tls.Config{
+ ServerName: s.smtpHost,
+ InsecureSkipVerify: s.isInsecureSkipVerify,
+ }); err != nil {
_ = client.Quit()
_ = conn.Close()
return nil, nil, fmt.Errorf("STARTTLS failed: %w", err)
diff --git a/backend/internal/features/email/email_test.go b/backend/internal/features/email/email_test.go
new file mode 100644
index 00000000..857efb9b
--- /dev/null
+++ b/backend/internal/features/email/email_test.go
@@ -0,0 +1,161 @@
+package email
+
+import (
+ "bufio"
+ "crypto/ecdsa"
+ "crypto/elliptic"
+ "crypto/rand"
+ "crypto/tls"
+ "crypto/x509"
+ "crypto/x509/pkix"
+ "fmt"
+ "math/big"
+ "net"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
+
+ "databasus-backend/internal/util/logger"
+ "databasus-backend/internal/util/testing/containers"
+ "databasus-backend/internal/util/testing/mailpit"
+)
+
+func Test_EmailSMTPSenderSendEmail_WhenSmtpServerAccepts_DeliversMessageToRecipient(t *testing.T) {
+ mailpitEndpoint := containers.StartMailpit(t)
+ mailpitClient := mailpit.NewClient(
+ fmt.Sprintf("%s:%d", mailpitEndpoint.HTTP.Host, mailpitEndpoint.HTTP.Port),
+ )
+
+ sender := &EmailSMTPSender{
+ logger: logger.GetLogger(),
+ smtpHost: mailpitEndpoint.SMTP.Host,
+ smtpPort: mailpitEndpoint.SMTP.Port,
+ smtpFrom: "[email protected]",
+ isConfigured: true,
+ }
+
+ err := sender.SendEmail("[email protected]", "Password Reset Code", "<b>123456</b>")
+ require.NoError(t, err)
+
+ var delivered []mailpit.Message
+ require.Eventually(t, func() bool {
+ messages, fetchErr := mailpitClient.FetchMessages()
+ if fetchErr != nil {
+ return false
+ }
+
+ delivered = messages
+
+ return len(messages) == 1
+ }, 5*time.Second, 100*time.Millisecond, "Mailpit should receive exactly one message")
+
+ assert.Equal(t, "Password Reset Code", delivered[0].Subject)
+ require.Len(t, delivered[0].To, 1)
+ assert.Equal(t, "[email protected]", delivered[0].To[0].Address)
+}
+
+func Test_EmailSMTPSenderImplicitTLS_WithUntrustedCert_FailsUnlessSkipVerify(t *testing.T) {
+ host, port := startImplicitTLSGreetingServer(t, newSelfSignedTLSConfig(t))
+
+ t.Run("verification on rejects the untrusted certificate", func(t *testing.T) {
+ sender := &EmailSMTPSender{logger: logger.GetLogger(), smtpHost: host, smtpPort: port}
+
+ _, _, dialErr := sender.createImplicitTLSClient()
+
+ require.Error(t, dialErr)
+ assert.Contains(t, dialErr.Error(), "certificate")
+ })
+
+ t.Run("skip verify accepts the untrusted certificate", func(t *testing.T) {
+ sender := &EmailSMTPSender{
+ logger: logger.GetLogger(),
+ smtpHost: host,
+ smtpPort: port,
+ isInsecureSkipVerify: true,
+ }
+
+ client, cleanup, dialErr := sender.createImplicitTLSClient()
+ require.NoError(t, dialErr)
+ defer cleanup()
+
+ require.NotNil(t, client)
+ })
+}
+
+// newSelfSignedTLSConfig builds a TLS config whose certificate is not signed by any trusted
+// root, so a verifying client rejects it and a skip-verify client accepts it.
+func newSelfSignedTLSConfig(t *testing.T) *tls.Config {
+ t.Helper()
+
+ key, err := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
+ require.NoError(t, err)
+
+ template := x509.Certificate{
+ SerialNumber: big.NewInt(1),
+ Subject: pkix.Name{CommonName: "127.0.0.1"},
+ NotBefore: time.Now().UTC().Add(-time.Hour),
+ NotAfter: time.Now().UTC().Add(time.Hour),
+ KeyUsage: x509.KeyUsageDigitalSignature | x509.KeyUsageCertSign,
+ ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+ IPAddresses: []net.IP{net.ParseIP("127.0.0.1"), net.IPv6loopback},
+ IsCA: true,
+ }
+
+ der, err := x509.CreateCertificate(rand.Reader, &template, &template, &key.PublicKey, key)
+ require.NoError(t, err)
+
+ return &tls.Config{
+ Certificates: []tls.Certificate{{Certificate: [][]byte{der}, PrivateKey: key}},
+ }
+}
+
+// startImplicitTLSGreetingServer accepts implicit-TLS connections and speaks just enough SMTP
+// (greeting, EHLO, QUIT) for createImplicitTLSClient to connect and disconnect cleanly.
+func startImplicitTLSGreetingServer(t *testing.T, tlsConfig *tls.Config) (host string, port int) {
+ t.Helper()
+
+ listener, err := tls.Listen("tcp", "127.0.0.1:0", tlsConfig)
+ require.NoError(t, err)
+ t.Cleanup(func() { _ = listener.Close() })
+
+ go func() {
+ for {
+ conn, acceptErr := listener.Accept()
+ if acceptErr != nil {
+ return
+ }
+
+ go serveMinimalSMTP(conn)
+ }
+ }()
+
+ addr := listener.Addr().(*net.TCPAddr)
+
+ return addr.IP.String(), addr.Port
+}
+
+func serveMinimalSMTP(conn net.Conn) {
+ defer func() { _ = conn.Close() }()
+
+ if _, err := conn.Write([]byte("220 test ESMTP\r\n")); err != nil {
+ return
+ }
+
+ reader := bufio.NewReader(conn)
+ for {
+ line, err := reader.ReadString('\n')
+ if err != nil {
+ return
+ }
+
+ if strings.HasPrefix(strings.ToUpper(line), "QUIT") {
+ _, _ = conn.Write([]byte("221 Bye\r\n"))
+ return
+ }
+
+ _, _ = conn.Write([]byte("250 OK\r\n"))
+ }
+}