- float, default 0 (unlimited); negative, NaN, infinite or non-numeric values are refused with an error naming the key - tests with 14, 0.5, 0, 1e2 and -1, .nan, .inf, nan, fast, lists
310 lines
12 KiB
Go
310 lines
12 KiB
Go
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 {
|
|
t.Helper()
|
|
p := filepath.Join(t.TempDir(), "c.yaml")
|
|
if err := os.WriteFile(p, []byte(content), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return p
|
|
}
|
|
|
|
func TestLoadDefaults(t *testing.T) {
|
|
c, err := Load(write(t, "{}\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if c.DB != "parsimony.db" || c.LMTP.Network != "tcp" || c.LMTP.Addr != "127.0.0.1:2424" || c.Relay.Addr != "127.0.0.1:25" || c.Relay.Concurrency != 4 || c.API.Listen != "127.0.0.1:8080" || c.Web.Listen != "127.0.0.1:8081" {
|
|
t.Fatalf("defaults: %+v", c)
|
|
}
|
|
}
|
|
|
|
func TestLoadValues(t *testing.T) {
|
|
c, err := Load(write(t, "db: /var/lib/p.db\nbase_url: https://l.example.org\nlmtp:\n network: unix\n addr: /run/p.sock\nrelay:\n addr: mx:587\n concurrency: 9\napi:\n listen: 0.0.0.0:9000\nweb:\n listen: 0.0.0.0:9001\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if c.DB != "/var/lib/p.db" || c.BaseURL != "https://l.example.org" || c.LMTP.Network != "unix" || c.LMTP.Addr != "/run/p.sock" || c.Relay.Addr != "mx:587" || c.Relay.Concurrency != 9 || c.API.Listen != "0.0.0.0:9000" || c.Web.Listen != "0.0.0.0:9001" {
|
|
t.Fatalf("values: %+v", c)
|
|
}
|
|
}
|
|
|
|
func TestLoadMissingFile(t *testing.T) {
|
|
if _, err := Load("/nonexistent.yaml"); err == nil {
|
|
t.Fatal("want error")
|
|
}
|
|
}
|
|
|
|
func TestLoadUnknownField(t *testing.T) {
|
|
if _, err := Load(write(t, "bogus: 1\n")); err == nil {
|
|
t.Fatal("unknown fields must be rejected")
|
|
}
|
|
}
|
|
|
|
func TestWebCanBeDisabled(t *testing.T) {
|
|
c, err := Load(write(t, "web:\n listen: \"\"\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if c.Web.Listen != "" {
|
|
t.Fatalf("an empty listen address disables the web: %q", c.Web.Listen)
|
|
}
|
|
}
|
|
|
|
func TestLoadDKIMKeys(t *testing.T) {
|
|
c, err := Load(write(t, "dkim:\n - domain: lists.example.org\n selector: mail\n key_file: /run/secrets/dkim.pem\n - domain: news.example.org\n selector: s2\n key_file: keys/news.pem\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(c.DKIM) != 2 || c.DKIM[0].Domain != "lists.example.org" || c.DKIM[0].Selector != "mail" || c.DKIM[0].KeyFile != "/run/secrets/dkim.pem" ||
|
|
c.DKIM[1].KeyFile != "keys/news.pem" {
|
|
t.Fatalf("dkim: %+v", c.DKIM)
|
|
}
|
|
if c, _ := Load(write(t, "{}\n")); len(c.DKIM) != 0 {
|
|
t.Fatalf("no keys by default: %+v", c.DKIM)
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsIncompleteOrDuplicateDKIMKeys(t *testing.T) {
|
|
for name, y := range map[string]string{
|
|
"missing domain": "dkim:\n - selector: mail\n key_file: k.pem\n",
|
|
"missing selector": "dkim:\n - domain: a.org\n key_file: k.pem\n",
|
|
"missing key file": "dkim:\n - domain: a.org\n selector: mail\n",
|
|
"duplicate domain": "dkim:\n - {domain: a.org, selector: x, key_file: k1.pem}\n - {domain: A.ORG, selector: y, key_file: k2.pem}\n",
|
|
"inline key": "dkim:\n - {domain: a.org, selector: x, key_file: k.pem, private_key: SECRET}\n",
|
|
} {
|
|
if _, err := Load(write(t, y)); err == nil {
|
|
t.Errorf("%s: want an error", name)
|
|
}
|
|
}
|
|
_, err := Load(write(t, "dkim:\n - selector: mail\n key_file: k.pem\n"))
|
|
if err == nil || !strings.Contains(err.Error(), "dkim[0]") {
|
|
t.Fatalf("the error names the entry: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestLoadLMTPAllowList(t *testing.T) {
|
|
c, err := Load(write(t, "lmtp:\n allow: [127.0.0.0/8, 172.16.0.0/12, 10.1.2.3, \"::1\", \"fd00::/8\"]\n"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
nets := c.LMTPAllowed()
|
|
if len(nets) != 5 {
|
|
t.Fatalf("nets: %v", nets)
|
|
}
|
|
for ip, want := range map[string]bool{
|
|
"127.0.0.1": true, "172.20.0.5": true, "10.1.2.3": true, "10.1.2.4": false, "::1": true, "fd00::5": true, "8.8.8.8": false,
|
|
} {
|
|
got := false
|
|
for _, n := range nets {
|
|
if n.Contains(net.ParseIP(ip)) {
|
|
got = true
|
|
}
|
|
}
|
|
if got != want {
|
|
t.Errorf("%s allowed = %v, want %v", ip, got, want)
|
|
}
|
|
}
|
|
if c, _ := Load(write(t, "{}\n")); len(c.LMTPAllowed()) != 0 {
|
|
t.Fatal("no allow list by default")
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsABadLMTPAllowEntry(t *testing.T) {
|
|
for _, bad := range []string{"not-an-ip", "10.0.0.0/33", "10.0.0/8", "", "10.0.0.1/"} {
|
|
_, err := Load(write(t, "lmtp:\n allow: [\"127.0.0.1\", \""+bad+"\"]\n"))
|
|
if err == nil || !strings.Contains(err.Error(), "lmtp.allow[1]") {
|
|
t.Errorf("%q: want an error naming the entry, got %v", bad, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
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 TestRelayRatePerSecond(t *testing.T) {
|
|
c, err := Load(write(t, "{}\n"))
|
|
if err != nil || float64(c.Relay.RatePerSecond) != 0 {
|
|
t.Fatalf("default is unlimited: %v %v", c.Relay.RatePerSecond, err)
|
|
}
|
|
for y, want := range map[string]float64{"14": 14, "0.5": 0.5, "0": 0, "0.0": 0, "1e2": 100} {
|
|
c, err := Load(write(t, "relay:\n rate_per_second: "+y+"\n"))
|
|
if err != nil || float64(c.Relay.RatePerSecond) != want {
|
|
t.Errorf("rate_per_second %s: got %v, %v; want %v", y, c.Relay.RatePerSecond, err, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestLoadRejectsABadRelayRate(t *testing.T) {
|
|
for _, v := range []string{"-1", "-0.5", ".nan", ".NaN", ".inf", "-.inf", `"nan"`, `"fast"`, "fast", "nan", "[]", "{}"} {
|
|
_, err := Load(write(t, "relay:\n rate_per_second: "+v+"\n"))
|
|
if err == nil || !strings.Contains(err.Error(), "relay.rate_per_second") {
|
|
t.Errorf("rate_per_second %s: want an error naming the key, got %v", 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})
|
|
}
|
|
|
|
func TestBaseURLIsChecked(t *testing.T) {
|
|
for _, ok := range []string{
|
|
"", // one-click unsubscribe is simply off
|
|
"https://lists.example.org",
|
|
"https://lists.example.org/",
|
|
"https://lists.example.org:8443/sub/path",
|
|
"http://localhost:8081",
|
|
"http://127.0.0.1:8081",
|
|
"http://[::1]:8081",
|
|
} {
|
|
if _, err := Load(write(t, "base_url: \""+ok+"\"\n")); err != nil {
|
|
t.Errorf("%q must be accepted: %v", ok, err)
|
|
}
|
|
}
|
|
for _, bad := range []string{
|
|
"http://lists.example.org", // RFC 8058 needs https
|
|
"http://10.0.0.5:8081", // only loopback may use http
|
|
"ftp://lists.example.org", // not http(s) at all
|
|
"lists.example.org", // no scheme
|
|
"//lists.example.org", // no scheme
|
|
"https://", // no host
|
|
"https:///path", // no host
|
|
"https://lists.example.org?x=1", // query
|
|
"https://lists.example.org/#top",
|
|
"https://lists.example.org/#", // an empty fragment is still one
|
|
"https://lists.example.org/?", // an empty query is still one // fragment
|
|
"https://user:pw@lists.example.org", // userinfo
|
|
"https://user@lists.example.org",
|
|
"https://lists.example.org/a b",
|
|
"https://exa mple.org",
|
|
} {
|
|
_, err := Load(write(t, "base_url: \""+bad+"\"\n"))
|
|
if err == nil {
|
|
t.Errorf("%q must be rejected", bad)
|
|
} else if !strings.Contains(err.Error(), "base_url") {
|
|
t.Errorf("%q: the error must name base_url: %v", bad, err)
|
|
}
|
|
}
|
|
}
|