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) } } } func TestLoadWebTrustedProxies(t *testing.T) { c, err := Load(write(t, "web:\n trusted_proxies: [10.0.0.0/8, 192.168.1.1, \"::1\", \"fd00::/8\"]\n")) if err != nil { t.Fatal(err) } nets := c.WebTrustedProxies() if len(nets) != 4 { t.Fatalf("nets: %v", nets) } for ip, want := range map[string]bool{ "10.9.8.7": true, "192.168.1.1": true, "192.168.1.2": false, "::1": true, "fd00::5": true, "2001:db8::1": false, } { got := false for _, n := range nets { if n.Contains(net.ParseIP(ip)) { got = true } } if got != want { t.Errorf("%s trusted = %v, want %v", ip, got, want) } } for _, empty := range []string{"{}\n", "web:\n trusted_proxies: []\n"} { if c, err := Load(write(t, empty)); err != nil || len(c.WebTrustedProxies()) != 0 { t.Fatalf("%q: no trusted proxy by default: %v %v", empty, c.WebTrustedProxies(), err) } } } func TestLoadRejectsABadTrustedProxy(t *testing.T) { for _, bad := range []string{"not-an-ip", "10.0.0.0/33", "fd00::/129", "10.0.0/8", "", "10.0.0.1/", "proxy.example.org"} { _, err := Load(write(t, "web:\n trusted_proxies: [\"127.0.0.1\", \""+bad+"\"]\n")) if err == nil || !strings.Contains(err.Error(), "web.trusted_proxies[1]") { t.Errorf("%q: want an error naming the entry, got %v", bad, err) } } } func TestExampleConfigLoadsAndDocumentsTheSettings(t *testing.T) { b, err := os.ReadFile("../../parsimony.example.yaml") if err != nil { t.Fatal(err) } if _, err := Load(write(t, string(b))); err != nil { t.Fatal(err) } // Uncommented, the documented lines are valid. uncommented := string(b) for _, line := range []string{" # trusted_proxies:", "# limits:", "# pending_per_hour:"} { if !strings.Contains(uncommented, line) { t.Fatalf("%q is not documented", line) } uncommented = strings.ReplaceAll(uncommented, line, strings.Replace(line, "# ", "", 1)) } c, err := Load(write(t, uncommented)) if err != nil || len(c.WebTrustedProxies()) == 0 || c.Limits.PendingPerHour != 300 { t.Fatalf("documented settings: %v %d %v", c.WebTrustedProxies(), c.Limits.PendingPerHour, err) } } func TestLimitsPendingPerHour(t *testing.T) { c, err := Load(write(t, "{}\n")) if err != nil || c.Limits.PendingPerHour != 300 { t.Fatalf("default: %d %v", c.Limits.PendingPerHour, err) } c, err = Load(write(t, "limits:\n pending_per_hour: 2000\n")) if err != nil || c.Limits.PendingPerHour != 2000 { t.Fatalf("value: %d %v", c.Limits.PendingPerHour, err) } for _, bad := range []string{"0", "-1", "lots", "1.5"} { _, err := Load(write(t, "limits:\n pending_per_hour: "+bad+"\n")) if err == nil || !strings.Contains(err.Error(), "pending_per_hour") { t.Errorf("%s: want an error naming limits.pending_per_hour, got %v", bad, err) } } }