parsimony/internal/config/config_test.go
tgiachi 44b3f9d98a fix(web): key the subscribe limit on the real client
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.
2026-11-10 15:11:26 +01:00

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)
}
}