Skip to content

Modern Docker Management, Designed for Everyone

16.6 KB
Raw Blame
package notifications

import (
	"bufio"
	"crypto/rand"
	"crypto/rsa"
	"crypto/tls"
	"crypto/x509"
	"crypto/x509/pkix"
	"encoding/base64"
	"encoding/pem"
	"errors"
	"fmt"
	"io"
	"math/big"
	"mime"
	"mime/multipart"
	"net"
	"net/mail"
	"net/textproto"
	"strings"
	"sync"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	kit "go.getarcane.app/kit/pkg"
)

const (
	smtpTestHost        = "localhost"
	smtpTestConnTimeout = 2 * time.Second
)

type smtpTestServer struct {
	listener           net.Listener
	tlsConfig          *tls.Config
	clientTLSConfig    *tls.Config
	done               chan error
	authMechanismUsed  string
	authMechanisms     []string
	commands           []string
	message            string
	mu                 sync.Mutex
	supportStartTLS    bool
	authBeforeTLS      bool
	authAfterTLS       bool
	startTLSNegotiated bool
}

func TestSendEmailStartTLSRequiresTLSBeforeAuth(t *testing.T) {
	server := newSMTPTestServerInternal(t, true, []string{"PLAIN"})
	defer server.Close()

	config := EmailConfig{
		SMTPHost:     smtpTestHost,
		SMTPPort:     server.Port(),
		SMTPUsername: "user",
		SMTPPassword: "password",
		FromAddress:  "[email protected]",
		ToAddresses:  []string{"[email protected]"},
		TLSMode:      EmailTLSModeStartTLS,
	}

	err := sendEmailInternal(
		t.Context(),
		config,
		"Arcane STARTTLS Test",
		"<p>Test</p>",
		"",
		smtpBuildOptions{tlsConfig: server.ClientTLSConfig()},
	)
	require.NoError(t, err)
	require.NoError(t, server.Wait())

	assert.True(t, server.StartTLSNegotiated(), "expected STARTTLS to be negotiated")
	assert.True(t, server.AuthAfterTLS(), "expected AUTH to happen after STARTTLS")
	assert.False(t, server.AuthBeforeTLS(), "expected no AUTH attempt before STARTTLS")
	assertCommandOrderInternal(t, server.Commands(), "EHLO", "STARTTLS", "EHLO", "AUTH", "MAIL", "RCPT", "DATA", "QUIT")
}

func TestSendEmailStartTLSFailsWhenServerDoesNotSupportIt(t *testing.T) {
	server := newSMTPTestServerInternal(t, false, []string{"PLAIN"})
	defer server.Close()

	config := EmailConfig{
		SMTPHost:     smtpTestHost,
		SMTPPort:     server.Port(),
		SMTPUsername: "user",
		SMTPPassword: "password",
		FromAddress:  "[email protected]",
		ToAddresses:  []string{"[email protected]"},
		TLSMode:      EmailTLSModeStartTLS,
	}

	err := SendEmail(t.Context(), config, "Arcane STARTTLS Test", "<p>Test</p>", "")
	require.Error(t, err)
	assert.Contains(t, err.Error(), "STARTTLS")
	assert.NotContains(t, err.Error(), "unencrypted connection")
	require.NoError(t, server.Wait())

	assert.False(t, server.StartTLSNegotiated(), "did not expect STARTTLS to be negotiated")
	assert.False(t, server.AuthBeforeTLS(), "did not expect plaintext AUTH attempt")
	assert.False(t, server.AuthAfterTLS(), "did not expect AUTH after failed STARTTLS setup")
}

func TestSendEmailAuthLoginAgainstExchangeStyleServer(t *testing.T) {
	server := newSMTPTestServerInternal(t, true, []string{"LOGIN"})
	defer server.Close()

	config := EmailConfig{
		SMTPHost:     smtpTestHost,
		SMTPPort:     server.Port(),
		SMTPUsername: "user",
		SMTPPassword: "password",
		FromAddress:  "[email protected]",
		ToAddresses:  []string{"[email protected]"},
		TLSMode:      EmailTLSModeStartTLS,
		AuthMode:     EmailAuthModeLogin,
	}

	err := sendEmailInternal(
		t.Context(),
		config,
		"Arcane AUTH LOGIN Test",
		"<p>Test</p>",
		"",
		smtpBuildOptions{tlsConfig: server.ClientTLSConfig()},
	)
	require.NoError(t, err)
	require.NoError(t, server.Wait())

	assert.True(t, server.StartTLSNegotiated(), "expected STARTTLS to be negotiated")
	assert.Equal(t, "LOGIN", server.AuthMechanismUsed(), "expected AUTH LOGIN to be used")
	assertCommandOrderInternal(t, server.Commands(), "EHLO", "STARTTLS", "EHLO", "AUTH", "MAIL", "RCPT", "DATA", "QUIT")
}

func TestSendEmailStalePasswordWithoutUsernameSkipsAuth(t *testing.T) {
	server := newSMTPTestServerInternal(t, false, nil)
	defer server.Close()

	config := EmailConfig{
		SMTPHost:     smtpTestHost,
		SMTPPort:     server.Port(),
		SMTPPassword: "stale-password",
		FromAddress:  "[email protected]",
		ToAddresses:  []string{"[email protected]"},
		TLSMode:      EmailTLSModeNone,
		AuthMode:     EmailAuthModeAuto,
	}

	err := sendEmailInternal(t.Context(), config, "Arcane No-Auth Test", "<p>Test</p>", "", smtpBuildOptions{})
	require.NoError(t, err)
	require.NoError(t, server.Wait())

	assert.NotContains(t, server.Commands(), "AUTH", "expected no AUTH attempt without complete credentials")
}

func TestSendEmailWithTextBodySendsMultipartAlternative(t *testing.T) {
	server := newSMTPTestServerInternal(t, false, nil)
	defer server.Close()

	config := EmailConfig{
		SMTPHost:    smtpTestHost,
		SMTPPort:    server.Port(),
		FromAddress: "[email protected]",
		ToAddresses: []string{"[email protected]"},
		TLSMode:     EmailTLSModeNone,
	}

	err := sendEmailInternal(t.Context(), config, "Arcane Multipart Test", "<p>HTML body</p>", "Plain body", smtpBuildOptions{})
	require.NoError(t, err)
	require.NoError(t, server.Wait())

	msg, err := mail.ReadMessage(strings.NewReader(server.Message()))
	require.NoError(t, err)

	mediaType, params, err := mime.ParseMediaType(msg.Header.Get("Content-Type"))
	require.NoError(t, err)
	require.Equal(t, "multipart/alternative", mediaType)

	parts := map[string]string{}
	reader := multipart.NewReader(msg.Body, params["boundary"])
	for {
		part, partErr := reader.NextPart()
		if errors.Is(partErr, io.EOF) {
			break
		}
		require.NoError(t, partErr)

		partType, _, typeErr := mime.ParseMediaType(part.Header.Get("Content-Type"))
		require.NoError(t, typeErr)

		body, readErr := io.ReadAll(part)
		require.NoError(t, readErr)
		parts[partType] = strings.TrimSpace(string(body))
	}

	assert.Equal(t, map[string]string{
		"text/plain": "Plain body",
		"text/html":  "<p>HTML body</p>",
	}, parts)
}

func newSMTPTestServerInternal(t *testing.T, supportStartTLS bool, authMechanisms []string) *smtpTestServer {
	t.Helper()

	serverCert, certPool := generateServerCertificateInternal(t, smtpTestHost)

	listener, err := net.Listen("tcp4", "127.0.0.1:0")
	require.NoError(t, err)

	server := &smtpTestServer{
		listener:        listener,
		tlsConfig:       &tls.Config{Certificates: []tls.Certificate{serverCert}, MinVersion: tls.VersionTLS12},
		clientTLSConfig: &tls.Config{RootCAs: certPool, ServerName: smtpTestHost, MinVersion: tls.VersionTLS12},
		supportStartTLS: supportStartTLS,
		authMechanisms:  authMechanisms,
		done:            make(chan error, 1),
	}

	go func() {
		conn, acceptErr := listener.Accept()
		if acceptErr != nil {
			server.done <- acceptErr
			return
		}

		server.done <- server.handleConnection(conn)
	}()

	return server
}

func (s *smtpTestServer) Port() int {
	return s.listener.Addr().(*net.TCPAddr).Port
}

func (s *smtpTestServer) Close() {
	_ = s.listener.Close()
}

func (s *smtpTestServer) ClientTLSConfig() *tls.Config {
	return s.clientTLSConfig.Clone()
}

func (s *smtpTestServer) Wait() error {
	select {
	case err := <-s.done:
		return kit.Ternary(err != nil && (isUseOfClosedNetworkConnInternal(err) || isConnectionTimeoutInternal(err)), nil, err)
	case <-time.After(4 * time.Second):
		return errors.New("timed out waiting for SMTP test server")
	}
}

func (s *smtpTestServer) Commands() []string {
	s.mu.Lock()
	defer s.mu.Unlock()

	out := make([]string, len(s.commands))
	copy(out, s.commands)
	return out
}

func (s *smtpTestServer) AuthBeforeTLS() bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.authBeforeTLS
}

func (s *smtpTestServer) AuthAfterTLS() bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.authAfterTLS
}

func (s *smtpTestServer) StartTLSNegotiated() bool {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.startTLSNegotiated
}

func (s *smtpTestServer) AuthMechanismUsed() string {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.authMechanismUsed
}

func (s *smtpTestServer) ehloLinesInternal() []string {
	lines := []string{"arcane smtp test server"}
	if s.supportStartTLS {
		lines = append(lines, "STARTTLS")
	}
	if len(s.authMechanisms) > 0 {
		lines = append(lines, "AUTH "+strings.Join(s.authMechanisms, " "))
	}
	return lines
}

func (s *smtpTestServer) ehloLinesAfterTLSInternal() []string {
	lines := []string{"arcane smtp test server"}
	if len(s.authMechanisms) > 0 {
		lines = append(lines, "AUTH "+strings.Join(s.authMechanisms, " "))
	}
	return lines
}

func (s *smtpTestServer) handleConnection(conn net.Conn) error {
	defer func() { _ = conn.Close() }()
	_ = conn.SetDeadline(time.Now().Add(smtpTestConnTimeout))

	reader := textproto.NewReader(bufio.NewReader(conn))
	writer := textproto.NewWriter(bufio.NewWriter(conn))
	tlsActive := false

	if err := writeSMTPResponseInternal(writer, 220, false, "arcane smtp test server"); err != nil {
		return err
	}

	for {
		line, err := reader.ReadLine()
		if err != nil {
			return kit.Ternary(errors.Is(err, io.EOF), nil, err)
		}

		verb, rest, _ := strings.Cut(line, " ")
		verb = strings.ToUpper(strings.TrimSpace(verb))
		s.recordCommand(verb, tlsActive)

		switch verb {
		case "EHLO", "HELO":
			var lines []string
			if tlsActive {
				lines = s.ehloLinesAfterTLSInternal()
			} else {
				lines = s.ehloLinesInternal()
			}
			if writeSMTPMultiLineResponseErr := writeSMTPMultiLineResponseInternal(writer, 250, lines); writeSMTPMultiLineResponseErr != nil {
				return writeSMTPMultiLineResponseErr
			}
		case "STARTTLS":
			if !s.supportStartTLS {
				if writeSMTPResponseErr := writeSMTPResponseInternal(writer, 502, false, "STARTTLS not supported"); writeSMTPResponseErr != nil {
					return writeSMTPResponseErr
				}
				continue
			}

			if writeSMTPResponseErr2 := writeSMTPResponseInternal(writer, 220, false, "ready to start TLS"); writeSMTPResponseErr2 != nil {
				return writeSMTPResponseErr2
			}

			tlsConn := tls.Server(conn, s.tlsConfig)
			if handshakeErr := tlsConn.Handshake(); handshakeErr != nil {
				return handshakeErr
			}

			conn = tlsConn
			_ = conn.SetDeadline(time.Now().Add(smtpTestConnTimeout))
			reader = textproto.NewReader(bufio.NewReader(conn))
			writer = textproto.NewWriter(bufio.NewWriter(conn))
			tlsActive = true
			s.markStartTLSNegotiated()
		default:
			quit, commandErr := s.handleCommandInternal(reader, writer, verb, rest)
			if commandErr != nil {
				return commandErr
			}
			if quit {
				return nil
			}
		}
	}
}

func (s *smtpTestServer) handleCommandInternal(reader *textproto.Reader, writer *textproto.Writer, verb, rest string) (bool, error) {
	switch verb {
	case "AUTH":
		mechanism, _, _ := strings.Cut(strings.TrimSpace(rest), " ")
		mechanism = strings.ToUpper(mechanism)
		s.recordAuthMechanismInternal(mechanism)
		if handleAuthErr := s.handleAuthInternal(reader, writer, mechanism); handleAuthErr != nil {
			return false, handleAuthErr
		}
	case "NOOP", "RSET":
		if writeSMTPResponseErr3 := writeSMTPResponseInternal(writer, 250, false, "2.0.0 OK"); writeSMTPResponseErr3 != nil {
			return false, writeSMTPResponseErr3
		}
	case "MAIL":
		if writeSMTPResponseErr4 := writeSMTPResponseInternal(writer, 250, false, "2.1.0 Sender OK"); writeSMTPResponseErr4 != nil {
			return false, writeSMTPResponseErr4
		}
	case "RCPT":
		if writeSMTPResponseErr5 := writeSMTPResponseInternal(writer, 250, false, "2.1.5 Recipient OK"); writeSMTPResponseErr5 != nil {
			return false, writeSMTPResponseErr5
		}
	case "DATA":
		if writeSMTPResponseErr6 := writeSMTPResponseInternal(writer, 354, false, "End data with <CR><LF>.<CR><LF>"); writeSMTPResponseErr6 != nil {
			return false, writeSMTPResponseErr6
		}
		dataLines, dataErr := reader.ReadDotLines()
		if dataErr != nil {
			return false, dataErr
		}
		s.recordMessage(strings.Join(dataLines, "\r\n"))
		if writeSMTPResponseErr7 := writeSMTPResponseInternal(writer, 250, false, "2.0.0 queued"); writeSMTPResponseErr7 != nil {
			return false, writeSMTPResponseErr7
		}
	case "QUIT":
		if writeSMTPResponseErr8 := writeSMTPResponseInternal(writer, 221, false, "2.0.0 bye"); writeSMTPResponseErr8 != nil {
			return false, writeSMTPResponseErr8
		}
		return true, nil
	default:
		if writeSMTPResponseErr9 := writeSMTPResponseInternal(writer, 502, false, "command not implemented"); writeSMTPResponseErr9 != nil {
			return false, writeSMTPResponseErr9
		}
	}
	return false, nil
}

func (s *smtpTestServer) handleAuthInternal(reader *textproto.Reader, writer *textproto.Writer, mechanism string) error {
	if mechanism == "LOGIN" {
		if err := writeSMTPResponseInternal(writer, 334, false, base64.StdEncoding.EncodeToString([]byte("Username:"))); err != nil {
			return err
		}
		if _, err := reader.ReadLine(); err != nil {
			return err
		}
		if err := writeSMTPResponseInternal(writer, 334, false, base64.StdEncoding.EncodeToString([]byte("Password:"))); err != nil {
			return err
		}
		if _, err := reader.ReadLine(); err != nil {
			return err
		}
	}
	return writeSMTPResponseInternal(writer, 235, false, "2.7.0 Authentication successful")
}

func (s *smtpTestServer) recordCommand(command string, tlsActive bool) {
	s.mu.Lock()
	defer s.mu.Unlock()

	s.commands = append(s.commands, command)
	if command == "AUTH" {
		if tlsActive {
			s.authAfterTLS = true
		} else {
			s.authBeforeTLS = true
		}
	}
}

func (s *smtpTestServer) recordAuthMechanismInternal(mechanism string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.authMechanismUsed = mechanism
}

func (s *smtpTestServer) recordMessage(message string) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.message = message
}

func (s *smtpTestServer) Message() string {
	s.mu.Lock()
	defer s.mu.Unlock()
	return s.message
}

func (s *smtpTestServer) markStartTLSNegotiated() {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.startTLSNegotiated = true
}

func writeSMTPMultiLineResponseInternal(writer *textproto.Writer, code int, lines []string) error {
	for i, line := range lines {
		if err := writeSMTPResponseInternal(writer, code, i < len(lines)-1, line); err != nil {
			return err
		}
	}
	return nil
}

func writeSMTPResponseInternal(writer *textproto.Writer, code int, continued bool, message string) error {
	line := fmt.Sprintf("%d %s", code, message)
	if continued {
		line = fmt.Sprintf("%d-%s", code, message)
	}
	if err := writer.PrintfLine("%s", line); err != nil {
		return err
	}
	return writer.W.Flush()
}

func assertCommandOrderInternal(t *testing.T, commands []string, expected ...string) {
	t.Helper()

	start := 0
	for _, want := range expected {
		found := false
		for i := start; i < len(commands); i++ {
			if commands[i] == want {
				start = i + 1
				found = true
				break
			}
		}
		require.Truef(t, found, "expected command %q in order within %v", want, commands)
	}
}

func generateServerCertificateInternal(t *testing.T, host string) (tls.Certificate, *x509.CertPool) {
	t.Helper()

	caKey, err := rsa.GenerateKey(rand.Reader, 2048)
	require.NoError(t, err)

	caTemplate := &x509.Certificate{
		SerialNumber:          mustSerialNumberInternal(t),
		Subject:               pkix.Name{CommonName: "Arcane SMTP Test CA"},
		NotBefore:             time.Now().Add(-time.Hour),
		NotAfter:              time.Now().Add(24 * time.Hour),
		KeyUsage:              x509.KeyUsageCertSign | x509.KeyUsageCRLSign,
		BasicConstraintsValid: true,
		IsCA:                  true,
	}

	caDER, err := x509.CreateCertificate(rand.Reader, caTemplate, caTemplate, &caKey.PublicKey, caKey)
	require.NoError(t, err)

	serverKey, err := rsa.GenerateKey(rand.Reader, 2048)
	require.NoError(t, err)

	serverTemplate := &x509.Certificate{
		SerialNumber: mustSerialNumberInternal(t),
		Subject:      pkix.Name{CommonName: strings.TrimSuffix(host, ".")},
		NotBefore:    time.Now().Add(-time.Hour),
		NotAfter:     time.Now().Add(24 * time.Hour),
		KeyUsage:     x509.KeyUsageDigitalSignature | x509.KeyUsageKeyEncipherment,
		ExtKeyUsage:  []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
		DNSNames:     []string{strings.TrimSuffix(host, "."), host},
	}

	serverDER, err := x509.CreateCertificate(rand.Reader, serverTemplate, caTemplate, &serverKey.PublicKey, caKey)
	require.NoError(t, err)

	certPEM := pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: serverDER})
	keyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(serverKey)})
	serverCert, err := tls.X509KeyPair(certPEM, keyPEM)
	require.NoError(t, err)

	certPool := x509.NewCertPool()
	require.True(t, certPool.AppendCertsFromPEM(pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: caDER})))

	return serverCert, certPool
}

func mustSerialNumberInternal(t *testing.T) *big.Int {
	t.Helper()

	serialNumber, err := rand.Int(rand.Reader, new(big.Int).Lsh(big.NewInt(1), 128))
	require.NoError(t, err)
	return serialNumber
}

func isUseOfClosedNetworkConnInternal(err error) bool {
	return err != nil && strings.Contains(err.Error(), "use of closed network connection")
}

func isConnectionTimeoutInternal(err error) bool {
	var netErr net.Error
	return err != nil && errors.As(err, &netErr) && netErr.Timeout()
}