Behind a reverse proxy every visitor shared the proxy's address, so the whole site got 10 signups an hour and one person could block everyone. Over IPv6 each address of a /64 was a fresh key, so the limit did not bind and the map grew by one entry per address. - web.trusted_proxies (addresses or CIDR ranges, default empty) is validated at load and passed to the web handler. X-Forwarded-For is read only when the TCP peer is a trusted proxy; the client is then the right-most entry that is not itself a trusted proxy. An empty or malformed header falls back to the peer. With no trusted proxy the behaviour is unchanged: the header is ignored. - IPv6 clients are keyed by their /64, IPv4 clients by address. - The limiter remembers at most 100000 clients. When full it sweeps expired entries first and otherwise answers 429 to new clients until the oldest window ends, instead of growing.
367 lines
13 KiB
Go
367 lines
13 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)
|
|
}
|
|
}
|
|
}
|
|
|
|
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 := strings.ReplaceAll(string(b), " # trusted_proxies:", " trusted_proxies:")
|
|
if uncommented == string(b) {
|
|
t.Fatal("web.trusted_proxies is not documented")
|
|
}
|
|
c, err := Load(write(t, uncommented))
|
|
if err != nil || len(c.WebTrustedProxies()) == 0 {
|
|
t.Fatalf("documented trusted_proxies: %v %v", c.WebTrustedProxies(), err)
|
|
}
|
|
}
|