From dca9117a2e6e46e13f82d0e497982b55146a32ce Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 19:59:57 +0100 Subject: [PATCH] feat(app): sign outgoing mail with the configured DKIM keys - Load the keys at startup and refuse to start on a broken one - Sign every outgoing message, confirmation mail included, with the key of its From domain - Send unsigned when the domain has no key --- go.mod | 2 +- go.sum | 2 +- internal/app/app.go | 20 +++++++ internal/app/app_test.go | 116 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 138 insertions(+), 2 deletions(-) diff --git a/go.mod b/go.mod index e0831ba..225011b 100644 --- a/go.mod +++ b/go.mod @@ -4,6 +4,7 @@ go 1.27.1 require ( github.com/emersion/go-message v0.18.2 + github.com/emersion/go-msgauth v0.7.0 github.com/emersion/go-smtp v0.25.1 gopkg.in/yaml.v3 v3.0.1 modernc.org/sqlite v1.62.0 @@ -11,7 +12,6 @@ require ( require ( github.com/dustin/go-humanize v1.1.0 // indirect - github.com/emersion/go-msgauth v0.7.0 // indirect github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 // indirect github.com/google/uuid v1.6.0 // indirect github.com/mattn/go-isatty v0.0.24 // indirect diff --git a/go.sum b/go.sum index 0706221..e1e1ac5 100644 --- a/go.sum +++ b/go.sum @@ -53,8 +53,8 @@ golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ= golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= +golang.org/x/text v0.21.0 h1:zyQAAkrwaneQ066sspRyJaG9VNi/YJ1NfzcGB3hZ/qo= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= diff --git a/internal/app/app.go b/internal/app/app.go index cf34233..0b8e26b 100644 --- a/internal/app/app.go +++ b/internal/app/app.go @@ -17,6 +17,7 @@ import ( "codeberg.org/squidd/parsimony/internal/adminui" "codeberg.org/squidd/parsimony/internal/api" "codeberg.org/squidd/parsimony/internal/config" + "codeberg.org/squidd/parsimony/internal/dkimsign" "codeberg.org/squidd/parsimony/internal/ingest" "codeberg.org/squidd/parsimony/internal/outbound" "codeberg.org/squidd/parsimony/internal/queue" @@ -54,6 +55,24 @@ func (r releaser) Release(_ context.Context, id int64) error { return r.rt.Relea // Start opens the database and begins serving. The REST API runs only when // apiToken is not empty. func Start(cfg config.Config, apiToken string) (*App, error) { + // Load the signing keys first: a broken key stops the daemon now, not at the first send. + var sign func([]byte) ([]byte, error) + if len(cfg.DKIM) > 0 { + keys := make([]dkimsign.Key, 0, len(cfg.DKIM)) + for _, k := range cfg.DKIM { + key, err := dkimsign.LoadKey(k.Domain, k.Selector, k.KeyFile) + if err != nil { + return nil, fmt.Errorf("dkim key for %s: %w", k.Domain, err) + } + keys = append(keys, key) + } + signer, err := dkimsign.New(keys) + if err != nil { + return nil, err + } + sign = signer.Sign + } + st, err := store.Open(cfg.DB) if err != nil { return nil, fmt.Errorf("store: %w", err) @@ -67,6 +86,7 @@ func Start(cfg config.Config, apiToken string) (*App, error) { Store: st, Sender: &outbound.SMTPRelay{Addr: cfg.Relay.Addr}, Concurrency: cfg.Relay.Concurrency, + Sign: sign, } rt.OnEnqueue = worker.Wake a.lmtp = ingest.NewServer(rt) diff --git a/internal/app/app_test.go b/internal/app/app_test.go index 3b47ae8..23aae5d 100644 --- a/internal/app/app_test.go +++ b/internal/app/app_test.go @@ -1,15 +1,24 @@ package app import ( + "crypto/rand" + "crypto/rsa" + "crypto/x509" + "encoding/base64" + "encoding/pem" + "errors" "io" "net" "net/http" + "os" + "path/filepath" "strings" "sync" "sync/atomic" "testing" "time" + "github.com/emersion/go-msgauth/dkim" "github.com/emersion/go-smtp" "codeberg.org/squidd/parsimony/internal/config" @@ -521,3 +530,110 @@ func TestCloseInterruptsASlowSendWithoutLosingIt(t *testing.T) { t.Fatalf("the interrupted delivery must stay queued: %+v", st) } } + +// dkimKey writes a fresh RSA key as PKCS#1 PEM and returns the file and the public key. +func dkimKey(t *testing.T) (string, *rsa.PublicKey) { + t.Helper() + k, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + t.Fatal(err) + } + path := filepath.Join(t.TempDir(), "dkim.pem") + if err := os.WriteFile(path, pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}), 0o600); err != nil { + t.Fatal(err) + } + return path, &k.PublicKey +} + +func verifyDKIM(t *testing.T, raw string, selector, domain string, pub *rsa.PublicKey) []*dkim.Verification { + t.Helper() + der, _ := x509.MarshalPKIXPublicKey(pub) + vs, err := dkim.VerifyWithOptions(strings.NewReader(raw), &dkim.VerifyOptions{ + LookupTXT: func(name string) ([]string, error) { + if name == selector+"._domainkey."+domain { + return []string{"v=DKIM1; k=rsa; p=" + base64.StdEncoding.EncodeToString(der)}, nil + } + return nil, errors.New("no record " + name) + }, + }) + if err != nil { + t.Fatalf("verify: %v", err) + } + return vs +} + +func TestOutgoingMailIsSignedWhenAKeyIsConfigured(t *testing.T) { + relayAddr, relay := startSink(t) + keyFile, pub := dkimKey(t) + cfg := testConfig(t, relayAddr) + cfg.DKIM = []config.DKIMKey{{Domain: "example.org", Selector: "mail", KeyFile: keyFile}} + a, err := Start(cfg, "tok") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { a.Close() }) + call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org","title":"Dev"}`, "tok") + call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"alice@example.com"}`, "tok") + + // A post. + msg := "From: Alice \r\nSubject: signed post\r\nMessage-ID: \r\n\r\nbody\r\n" + if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { + t.Fatal(err) + } + // A confirmation mail (system mail) from the same list domain. + if err := lmtpSend(t, a.LMTPAddr, "carol@x.com", "dev+join@example.org", ""); err != nil { + t.Fatal(err) + } + relay.waitCount(t, 2) + signed := 0 + for _, m := range relay.all() { + vs := verifyDKIM(t, m.data, "mail", "example.org", pub) + if len(vs) != 1 || vs[0].Err != nil || vs[0].Domain != "example.org" { + t.Fatalf("every outgoing message is signed with the list domain: %+v\n%.300s", vs, m.data) + } + signed++ + } + if signed != 2 { + t.Fatalf("signed %d", signed) + } +} + +func TestMailIsUnsignedWithoutKeysAndForOtherDomains(t *testing.T) { + relayAddr, relay := startSink(t) + keyFile, _ := dkimKey(t) + cfg := testConfig(t, relayAddr) + cfg.DKIM = []config.DKIMKey{{Domain: "another.test", Selector: "mail", KeyFile: keyFile}} + a, err := Start(cfg, "tok") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { a.Close() }) + call(t, a, "POST", "/api/v1/lists", `{"name":"dev","domain":"example.org"}`, "tok") + call(t, a, "POST", "/api/v1/lists/1/members", `{"address":"alice@example.com"}`, "tok") + msg := "From: Alice \r\nSubject: x\r\nMessage-ID: \r\n\r\nbody\r\n" + if err := lmtpSend(t, a.LMTPAddr, "alice@example.com", "dev@example.org", msg); err != nil { + t.Fatal(err) + } + relay.waitCount(t, 1) + if strings.Contains(relay.all()[0].data, "DKIM-Signature") { + t.Fatal("a list on a domain without a key is sent unsigned") + } +} + +func TestStartFailsOnAnUnusableDKIMKey(t *testing.T) { + relayAddr, _ := startSink(t) + bad := filepath.Join(t.TempDir(), "bad.pem") + os.WriteFile(bad, []byte("not a key"), 0o600) + for name, keyFile := range map[string]string{"missing file": "/nonexistent/dkim.pem", "garbage": bad} { + cfg := testConfig(t, relayAddr) + cfg.DKIM = []config.DKIMKey{{Domain: "example.org", Selector: "mail", KeyFile: keyFile}} + a, err := Start(cfg, "tok") + if err == nil { + a.Close() + t.Fatalf("%s: a broken key must stop the daemon at startup, not later at send time", name) + } + if !strings.Contains(err.Error(), "dkim") || !strings.Contains(err.Error(), "example.org") { + t.Errorf("%s: the error names the key: %v", name, err) + } + } +}