feat(config): relay TLS, credentials and CA settings with validation

- Add relay.tls, server_name, ca_file, helo, username and password_file
- Refuse credentials over a clear connection to a remote relay, naming the setting to change
- Read the password and CA bundle from files; an empty or missing file is an error
- Check that relay.addr is host:port
This commit is contained in:
tgiachi 2026-11-10 11:04:41 +01:00
commit b4e8644757
2 changed files with 196 additions and 0 deletions

View file

@ -3,6 +3,8 @@ package config
import (
"bytes"
"crypto/x509"
"errors"
"fmt"
"net"
"os"
@ -33,6 +35,16 @@ type Config struct {
Relay struct {
Addr string `yaml:"addr"` // host:port of the outgoing SMTP relay
Concurrency int `yaml:"concurrency"` // simultaneous deliveries
// TLS is "none" (default: a local Postfix), "starttls" (required, never silently skipped)
// or "tls" (encrypted from the first byte, port 465).
TLS string `yaml:"tls"`
ServerName string `yaml:"server_name"` // name the certificate must match; the host of addr by default
CAFile string `yaml:"ca_file"` // PEM bundle of the CAs to trust; the system's by default
Helo string `yaml:"helo"` // EHLO name; this machine's host name by default
// Username and the content of PasswordFile are the SMTP AUTH PLAIN credentials. The password
// is never in the config itself.
Username string `yaml:"username"`
PasswordFile string `yaml:"password_file"`
} `yaml:"relay"`
}
@ -72,7 +84,71 @@ func parseNet(s string) (*net.IPNet, error) {
return &net.IPNet{IP: ip, Mask: net.CIDRMask(bits, bits)}, nil
}
func isLoopbackHost(host string) bool {
if host == "localhost" {
return true
}
ip := net.ParseIP(host)
return ip != nil && ip.IsLoopback()
}
// RelayPassword reads the relay password from its file (only the line ending is removed). It is
// empty when no username is configured.
func (c Config) RelayPassword() (string, error) {
if c.Relay.Username == "" {
return "", nil
}
b, err := os.ReadFile(c.Relay.PasswordFile)
if err != nil {
return "", fmt.Errorf("relay.password_file: %w", err)
}
pw := strings.TrimRight(string(b), "\r\n")
if pw == "" {
return "", fmt.Errorf("relay.password_file %s is empty", c.Relay.PasswordFile)
}
return pw, nil
}
// RelayRootCAs reads relay.ca_file. It returns nil when none is set: the system roots apply.
func (c Config) RelayRootCAs() (*x509.CertPool, error) {
if c.Relay.CAFile == "" {
return nil, nil
}
b, err := os.ReadFile(c.Relay.CAFile)
if err != nil {
return nil, fmt.Errorf("relay.ca_file: %w", err)
}
pool := x509.NewCertPool()
if !pool.AppendCertsFromPEM(b) {
return nil, fmt.Errorf("relay.ca_file %s contains no certificate", c.Relay.CAFile)
}
return pool, nil
}
func (c Config) validateRelay() error {
r := c.Relay
host, _, err := net.SplitHostPort(r.Addr)
if err != nil {
return fmt.Errorf("relay.addr %q must be host:port", r.Addr)
}
switch r.TLS {
case "", "none", "starttls", "tls":
default:
return fmt.Errorf("relay.tls must be none, starttls or tls, not %q", r.TLS)
}
if (r.Username == "") != (r.PasswordFile == "") {
return errors.New("relay.username and relay.password_file go together")
}
if r.Username != "" && (r.TLS == "" || r.TLS == "none") && !isLoopbackHost(host) {
return fmt.Errorf("relay.username is set but relay.tls is not: the password would cross the network in clear to %s; set relay.tls to starttls or tls", host)
}
return nil
}
func (c Config) validate() error {
if err := c.validateRelay(); err != nil {
return err
}
for i, a := range c.LMTP.Allow {
if _, err := parseNet(a); err != nil {
return fmt.Errorf("lmtp.allow[%d]: %w", i, err)

View file

@ -1,11 +1,19 @@
package config
import (
"crypto/ecdsa"
"crypto/elliptic"
"crypto/rand"
"crypto/x509"
"crypto/x509/pkix"
"encoding/pem"
"math/big"
"net"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func write(t *testing.T, content string) string {
@ -126,3 +134,115 @@ func TestLoadRejectsABadLMTPAllowEntry(t *testing.T) {
}
}
}
func TestLoadRelayTLSSettings(t *testing.T) {
c, err := Load(write(t, "relay:\n addr: email-smtp.eu-west-1.amazonaws.com:587\n tls: starttls\n username: AKIAEXAMPLE\n password_file: /run/secrets/relay\n ca_file: /etc/ssl/private-ca.pem\n server_name: smtp.example.com\n helo: lists.example.org\n concurrency: 8\n"))
if err != nil {
t.Fatal(err)
}
r := c.Relay
if r.TLS != "starttls" || r.Username != "AKIAEXAMPLE" || r.PasswordFile != "/run/secrets/relay" || r.CAFile != "/etc/ssl/private-ca.pem" ||
r.ServerName != "smtp.example.com" || r.Helo != "lists.example.org" || r.Concurrency != 8 {
t.Fatalf("relay: %+v", r)
}
if d, _ := Load(write(t, "{}\n")); d.Relay.TLS != "" || d.Relay.Username != "" {
t.Fatalf("defaults must keep the plain local relay: %+v", d.Relay)
}
}
func TestLoadRejectsBadRelaySettings(t *testing.T) {
for name, y := range map[string]string{
"unknown tls mode": "relay:\n tls: ssl\n",
"username without password file": "relay:\n addr: smtp.example.com:587\n tls: starttls\n username: u\n",
"password file without username": "relay:\n addr: smtp.example.com:587\n tls: starttls\n password_file: /p\n",
"credentials in clear to a host": "relay:\n addr: smtp.example.com:587\n username: u\n password_file: /p\n",
"credentials, tls none, a remote": "relay:\n addr: smtp.example.com:587\n tls: none\n username: u\n password_file: /p\n",
"inline password": "relay:\n addr: smtp.example.com:587\n tls: starttls\n username: u\n password: hunter2\n",
"relay address without a port": "relay:\n addr: smtp.example.com\n",
} {
if _, err := Load(write(t, y)); err == nil {
t.Errorf("%s: want an error", name)
}
}
_, err := Load(write(t, "relay:\n addr: smtp.example.com:587\n username: u\n password_file: /p\n"))
if err == nil || !strings.Contains(err.Error(), "relay.tls") {
t.Fatalf("the error says what to set: %v", err)
}
}
func TestCredentialsToALoopbackRelayNeedNoTLS(t *testing.T) {
for _, addr := range []string{"127.0.0.1:587", "localhost:587", "[::1]:587"} {
if _, err := Load(write(t, "relay:\n addr: \""+addr+"\"\n username: u\n password_file: /p\n")); err != nil {
t.Errorf("%s: a local relay with SASL is fine in clear: %v", addr, err)
}
}
for _, mode := range []string{"starttls", "tls"} {
if _, err := Load(write(t, "relay:\n addr: smtp.example.com:587\n tls: "+mode+"\n username: u\n password_file: /p\n")); err != nil {
t.Errorf("%s: %v", mode, err)
}
}
}
func TestRelayPasswordIsReadFromItsFile(t *testing.T) {
dir := t.TempDir()
path := filepath.Join(dir, "relay-password")
os.WriteFile(path, []byte(" s3cret with spaces \n"), 0o600)
c, _ := Load(write(t, "relay:\n addr: smtp.example.com:587\n tls: starttls\n username: u\n password_file: "+path+"\n"))
pw, err := c.RelayPassword()
if err != nil || pw != " s3cret with spaces " {
t.Fatalf("only the line ending is removed: %q %v", pw, err)
}
os.WriteFile(path, []byte("with-crlf\r\n"), 0o600)
if pw, _ := c.RelayPassword(); pw != "with-crlf" {
t.Fatalf("%q", pw)
}
os.WriteFile(path, []byte("\n"), 0o600)
if _, err := c.RelayPassword(); err == nil || !strings.Contains(err.Error(), "empty") {
t.Fatalf("an empty password file is an error: %v", err)
}
os.Remove(path)
if _, err := c.RelayPassword(); err == nil {
t.Fatal("a missing password file is an error")
}
if none, _ := Load(write(t, "{}\n")); true {
if pw, err := none.RelayPassword(); err != nil || pw != "" {
t.Fatalf("no username, no password: %q %v", pw, err)
}
}
}
func TestRelayCAFile(t *testing.T) {
good := filepath.Join(t.TempDir(), "ca.pem")
os.WriteFile(good, testCAPEM(t), 0o600)
c, _ := Load(write(t, "relay:\n ca_file: "+good+"\n"))
pool, err := c.RelayRootCAs()
if err != nil || pool == nil {
t.Fatalf("%v %v", pool, err)
}
bad := filepath.Join(t.TempDir(), "bad.pem")
os.WriteFile(bad, []byte("not a certificate"), 0o600)
c, _ = Load(write(t, "relay:\n ca_file: "+bad+"\n"))
if _, err := c.RelayRootCAs(); err == nil || !strings.Contains(err.Error(), "certificate") {
t.Fatalf("a CA file without a certificate is an error: %v", err)
}
c, _ = Load(write(t, "relay:\n ca_file: /nonexistent.pem\n"))
if _, err := c.RelayRootCAs(); err == nil {
t.Fatal("a missing CA file is an error")
}
if none, _ := Load(write(t, "{}\n")); true {
if pool, err := none.RelayRootCAs(); err != nil || pool != nil {
t.Fatalf("without ca_file the system roots are used: %v %v", pool, err)
}
}
}
func testCAPEM(t *testing.T) []byte {
t.Helper()
key, _ := ecdsa.GenerateKey(elliptic.P256(), rand.Reader)
tmpl := &x509.Certificate{SerialNumber: big.NewInt(1), Subject: pkix.Name{CommonName: "test"}, NotBefore: time.Now(), NotAfter: time.Now().Add(time.Hour), IsCA: true, BasicConstraintsValid: true}
der, err := x509.CreateCertificate(rand.Reader, tmpl, tmpl, &key.PublicKey, key)
if err != nil {
t.Fatal(err)
}
return pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: der})
}