From 141c5d98e9539ff4de2acee770ff8313343d9775 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 19:58:07 +0100 Subject: [PATCH 1/8] feat(dkimsign): sign messages per From domain with RSA or Ed25519 keys - Add Signer choosing the key by the From address domain: exact match, then parent domains - Sign list headers too, relaxed/relaxed sha256, never a body length limit - Load PKCS#1 and PKCS#8 PEM keys, reject unusable files without echoing key material - Leave messages without a matching key or a usable From untouched --- go.mod | 4 +- go.sum | 5 + internal/dkimsign/dkimsign.go | 166 +++++++++++++++ internal/dkimsign/dkimsign_test.go | 314 +++++++++++++++++++++++++++++ 4 files changed, 488 insertions(+), 1 deletion(-) create mode 100644 internal/dkimsign/dkimsign.go create mode 100644 internal/dkimsign/dkimsign_test.go diff --git a/go.mod b/go.mod index 162f38c..e0831ba 100644 --- a/go.mod +++ b/go.mod @@ -11,13 +11,15 @@ 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 github.com/ncruces/go-strftime v1.1.0 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect + golang.org/x/crypto v0.31.0 // indirect golang.org/x/sys v0.49.0 // indirect - golang.org/x/text v0.14.0 // indirect + golang.org/x/text v0.21.0 // indirect modernc.org/libc v1.80.1 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.12.1 // indirect diff --git a/go.sum b/go.sum index e916675..0706221 100644 --- a/go.sum +++ b/go.sum @@ -2,6 +2,8 @@ github.com/dustin/go-humanize v1.1.0 h1:dbKTrvD0klcbBV/h4AWJdMuZogJACoMlvWIWZ5b2 github.com/dustin/go-humanize v1.1.0/go.mod h1:hc1CvRkJMsgxqjmjMQF3QNRAZBwY8AXBAzKYoSX9sFI= github.com/emersion/go-message v0.18.2 h1:rl55SQdjd9oJcIoQNhubD2Acs1E6IzlZISRTK7x/Lpg= github.com/emersion/go-message v0.18.2/go.mod h1:XpJyL70LwRvq2a8rVbHXikPgKj8+aI0kGdHlg16ibYA= +github.com/emersion/go-msgauth v0.7.0 h1:vj2hMn6KhFtW41kshIBTXvp6KgYSqpA/ZN9Pv4g1INc= +github.com/emersion/go-msgauth v0.7.0/go.mod h1:mmS9I6HkSovrNgq0HNXTeu8l3sRAAuQ9RMvbM4KU7Ck= github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6 h1:oP4q0fw+fOSWn3DfFi4EXdT+B+gTtzx8GC9xsc26Znk= github.com/emersion/go-sasl v0.0.0-20241020182733-b788ff22d5a6/go.mod h1:iL2twTeMvZnrg54ZoPDNfJaJaqy0xIQFuBdrLsmspwQ= github.com/emersion/go-smtp v0.25.1 h1:y6nzefT6PtFeMItFw97GX/ZCkVbh0rqSXG8b3ang8/w= @@ -21,6 +23,8 @@ github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qq github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= +golang.org/x/crypto v0.31.0 h1:ihbySMvVjLAeSH1IbfcRTkD/iNscyz8rGzjF/E5hV6U= +golang.org/x/crypto v0.31.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.42.0 h1:ICeL3t2L30ljSPHHxDnR4fqVcBt/zR2zJAb9juavmQg= @@ -51,6 +55,7 @@ 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/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= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= diff --git a/internal/dkimsign/dkimsign.go b/internal/dkimsign/dkimsign.go new file mode 100644 index 0000000..9bb067f --- /dev/null +++ b/internal/dkimsign/dkimsign.go @@ -0,0 +1,166 @@ +// Package dkimsign signs outgoing messages with DKIM. +// +// The signing domain comes from the address in the message's From header: a key +// for that exact domain, else a key for one of its parent domains (relaxed +// alignment). A message from a domain without a key is left unsigned. +package dkimsign + +import ( + "bytes" + "crypto" + "crypto/ed25519" + "crypto/rsa" + "crypto/x509" + "encoding/pem" + "errors" + "fmt" + "net/mail" + "os" + "regexp" + "strings" + + "github.com/emersion/go-msgauth/dkim" +) + +// headerKeys are the header fields covered by the signature. The list headers +// are included so a recipient can trust the unsubscribe links. Received and +// Return-Path are left out: MTAs add them on the way. +var headerKeys = []string{ + "From", "To", "Cc", "Subject", "Date", "Message-ID", "In-Reply-To", "References", "Reply-To", + "MIME-Version", "Content-Type", "Content-Transfer-Encoding", + "List-Id", "List-Post", "List-Unsubscribe", "List-Unsubscribe-Post", +} + +var selectorRe = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?$`) + +// Key is a signing key for one domain. +type Key struct { + Domain string + Selector string + Signer crypto.Signer // *rsa.PrivateKey or ed25519.PrivateKey +} + +// Signer signs messages with the key that matches their From domain. +type Signer struct { + keys map[string]Key // by lowercase domain +} + +// New builds a Signer. Domains must be unique. +func New(keys []Key) (*Signer, error) { + s := &Signer{keys: map[string]Key{}} + for _, k := range keys { + k.Domain = strings.ToLower(strings.TrimSuffix(strings.TrimSpace(k.Domain), ".")) + switch { + case k.Domain == "": + return nil, errors.New("dkim: a key needs a domain") + case !selectorRe.MatchString(k.Selector): + return nil, fmt.Errorf("dkim: invalid selector %q for %s", k.Selector, k.Domain) + case k.Signer == nil: + return nil, fmt.Errorf("dkim: no private key for %s", k.Domain) + } + switch k.Signer.Public().(type) { + case *rsa.PublicKey, ed25519.PublicKey: + default: + return nil, fmt.Errorf("dkim: unsupported key type for %s", k.Domain) + } + if _, dup := s.keys[k.Domain]; dup { + return nil, fmt.Errorf("dkim: more than one key for %s", k.Domain) + } + s.keys[k.Domain] = k + } + return s, nil +} + +// LoadKey reads a PEM private key file (PKCS#1 or PKCS#8; RSA or Ed25519). +func LoadKey(domain, selector, path string) (Key, error) { + raw, err := os.ReadFile(path) + if err != nil { + return Key{}, err + } + block, _ := pem.Decode(raw) + if block == nil { + return Key{}, fmt.Errorf("%s: not a PEM file", path) + } + var priv crypto.Signer + switch block.Type { + case "RSA PRIVATE KEY": + k, err := x509.ParsePKCS1PrivateKey(block.Bytes) + if err != nil { + return Key{}, fmt.Errorf("%s: invalid RSA private key", path) + } + priv = k + case "PRIVATE KEY": + k, err := x509.ParsePKCS8PrivateKey(block.Bytes) + if err != nil { + return Key{}, fmt.Errorf("%s: invalid PKCS#8 private key", path) + } + switch k := k.(type) { + case *rsa.PrivateKey: + priv = k + case ed25519.PrivateKey: + priv = k + default: + return Key{}, fmt.Errorf("%s: unsupported key type %T (use RSA or Ed25519)", path, k) + } + default: + return Key{}, fmt.Errorf("%s: unsupported PEM type %q", path, block.Type) + } + return Key{Domain: domain, Selector: selector, Signer: priv}, nil +} + +// fromDomain returns the lowercase domain of the first address in From. +func fromDomain(msg []byte) (string, bool) { + m, err := mail.ReadMessage(bytes.NewReader(msg)) + if err != nil { + return "", false + } + addrs, err := m.Header.AddressList("From") + if err != nil || len(addrs) == 0 { + return "", false + } + at := strings.LastIndex(addrs[0].Address, "@") + if at < 0 || at == len(addrs[0].Address)-1 { + return "", false + } + return strings.ToLower(addrs[0].Address[at+1:]), true +} + +func (s *Signer) keyFor(domain string) (Key, bool) { + for { + if k, ok := s.keys[domain]; ok { + return k, true + } + i := strings.Index(domain, ".") + if i < 0 { + return Key{}, false + } + domain = domain[i+1:] + } +} + +// Sign returns msg with a DKIM-Signature header in front. When no key applies +// (or the message has no usable From) it returns msg unchanged and no error. +func (s *Signer) Sign(msg []byte) ([]byte, error) { + domain, ok := fromDomain(msg) + if !ok { + return msg, nil + } + key, ok := s.keyFor(domain) + if !ok { + return msg, nil + } + var out bytes.Buffer + err := dkim.Sign(&out, bytes.NewReader(msg), &dkim.SignOptions{ + Domain: key.Domain, + Selector: key.Selector, + Signer: key.Signer, + Hash: crypto.SHA256, + HeaderCanonicalization: dkim.CanonicalizationRelaxed, + BodyCanonicalization: dkim.CanonicalizationRelaxed, + HeaderKeys: headerKeys, + }) + if err != nil { + return msg, fmt.Errorf("dkim sign for %s: %w", key.Domain, err) + } + return out.Bytes(), nil +} diff --git a/internal/dkimsign/dkimsign_test.go b/internal/dkimsign/dkimsign_test.go new file mode 100644 index 0000000..3d99bbe --- /dev/null +++ b/internal/dkimsign/dkimsign_test.go @@ -0,0 +1,314 @@ +package dkimsign + +import ( + "bytes" + "crypto" + "crypto/ed25519" + "crypto/rand" + "crypto/rsa" + "crypto/x509" + "encoding/base64" + "encoding/pem" + "errors" + "os" + "path/filepath" + "regexp" + "strings" + "sync" + "testing" + + "github.com/emersion/go-msgauth/dkim" +) + +func rsaKey(t *testing.T, bits int) *rsa.PrivateKey { + t.Helper() + k, err := rsa.GenerateKey(rand.Reader, bits) + if err != nil { + t.Fatal(err) + } + return k +} + +// dnsRecord is the TXT record a receiver would find for a key. +func dnsRecord(t *testing.T, pub crypto.PublicKey) string { + t.Helper() + switch k := pub.(type) { + case *rsa.PublicKey: + der, _ := x509.MarshalPKIXPublicKey(k) + return "v=DKIM1; k=rsa; p=" + base64.StdEncoding.EncodeToString(der) + case ed25519.PublicKey: + return "v=DKIM1; k=ed25519; p=" + base64.StdEncoding.EncodeToString(k) + } + t.Fatal("unsupported key") + return "" +} + +// verify checks every DKIM signature of msg against a fake DNS with a single record. +func verify(t *testing.T, msg []byte, selector, domain string, pub crypto.PublicKey) []*dkim.Verification { + t.Helper() + vs, err := dkim.VerifyWithOptions(bytes.NewReader(msg), &dkim.VerifyOptions{ + LookupTXT: func(name string) ([]string, error) { + if name == selector+"._domainkey."+domain { + return []string{dnsRecord(t, pub)}, nil + } + return nil, errors.New("no such record: " + name) + }, + }) + if err != nil { + t.Fatalf("verify: %v", err) + } + return vs +} + +func mustVerify(t *testing.T, msg []byte, selector, domain string, pub crypto.PublicKey) { + t.Helper() + vs := verify(t, msg, selector, domain, pub) + if len(vs) != 1 || vs[0].Err != nil || vs[0].Domain != domain { + t.Fatalf("verification: %+v", vs) + } +} + +func message(from string) []byte { + return []byte("From: " + from + "\r\nTo: dev@lists.example.org\r\nSubject: Hello list\r\nDate: Mon, 01 Jan 2024 10:00:00 +0000\r\n" + + "Message-ID: <1@x>\r\nList-Id: Dev \r\nList-Unsubscribe: \r\n" + + "Content-Type: text/plain; charset=utf-8\r\n\r\nthe body\r\nsecond line\r\n") +} + +func newSigner(t *testing.T, keys ...Key) *Signer { + t.Helper() + s, err := New(keys) + if err != nil { + t.Fatal(err) + } + return s +} + +func TestSignRSAAndVerify(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + in := message("Alice via Dev ") + out, err := s.Sign(in) + if err != nil { + t.Fatal(err) + } + if !bytes.HasPrefix(out, []byte("DKIM-Signature:")) || !bytes.HasSuffix(out, in) { + t.Fatalf("the signature header goes first and the original follows untouched:\n%s", out) + } + mustVerify(t, out, "mail", "lists.example.org", &k.PublicKey) + sig := string(out[:bytes.Index(out, []byte("\r\n\r\n"))]) + for _, want := range []string{"a=rsa-sha256", "c=relaxed/relaxed", "d=lists.example.org", "s=mail"} { + if !strings.Contains(sig, want) { + t.Errorf("signature lacks %q:\n%s", want, sig) + } + } + if strings.Contains(sig, "l=") { + t.Error("a body length limit lets attackers append text: never use l=") + } +} + +func TestSignEd25519AndVerify(t *testing.T) { + pub, priv, _ := ed25519.GenerateKey(rand.Reader) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "ed", Signer: priv}) + out, err := s.Sign(message("dev@lists.example.org")) + if err != nil { + t.Fatal(err) + } + mustVerify(t, out, "ed", "lists.example.org", pub) +} + +func TestSignedHeadersCoverTheListHeaders(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + out, _ := s.Sign(message("dev@lists.example.org")) + sig := strings.ToLower(string(out[:bytes.Index(out, []byte("\r\n\r\n"))])) + for _, h := range []string{"from", "to", "subject", "date", "message-id", "list-id", "list-unsubscribe", "content-type"} { + if !regexpHas(sig, h) { + t.Errorf("%s must be signed: %s", h, sig) + } + } +} + +var hTag = regexp.MustCompile(`(?m)(?:^|[;\s])h=([^;]*)`) + +func regexpHas(sig, header string) bool { + m := hTag.FindStringSubmatch(sig) + if m == nil { + return false + } + for _, h := range strings.Split(strings.Join(strings.Fields(m[1]), ""), ":") { + if h == header { + return true + } + } + return false +} + +func TestTamperingBreaksTheSignature(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + out, _ := s.Sign(message("dev@lists.example.org")) + for name, tampered := range map[string][]byte{ + "body": bytes.Replace(out, []byte("the body"), []byte("the BODY!"), 1), + "subject": bytes.Replace(out, []byte("Subject: Hello list"), []byte("Subject: Hello you"), 1), + "list-unsubscribe": bytes.Replace(out, []byte("List-Unsubscribe: \r\n"), nil, 1), + "appended text": append(append([]byte{}, out...), []byte("extra line\r\n")...), + } { + vs := verify(t, tampered, "mail", "lists.example.org", &k.PublicKey) + if len(vs) != 1 || vs[0].Err == nil { + t.Errorf("%s: a modified message must not verify: %+v", name, vs) + } + } +} + +func TestUnsignedWhenThereIsNoKeyOrNoUsableFrom(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + for name, in := range map[string][]byte{ + "other domain": message("someone@elsewhere.test"), + "no From header": []byte("Subject: x\r\n\r\nbody\r\n"), + "unparsable From": []byte("From: not an address\r\nSubject: x\r\n\r\nbody\r\n"), + "empty message": {}, + "not a message": []byte("garbage"), + } { + out, err := s.Sign(in) + if err != nil || !bytes.Equal(out, in) { + t.Errorf("%s: want the message back untouched, got %q %v", name, out, err) + } + } + // No keys at all. + empty := newSigner(t) + in := message("dev@lists.example.org") + if out, err := empty.Sign(in); err != nil || !bytes.Equal(out, in) { + t.Fatalf("no keys: %v", err) + } +} + +func TestSigningDomainSelection(t *testing.T) { + parent, sub := rsaKey(t, 2048), rsaKey(t, 2048) + s := newSigner(t, + Key{Domain: "example.org", Selector: "p", Signer: parent}, + Key{Domain: "lists.example.org", Selector: "s", Signer: sub}, + ) + // Exact match wins over the parent. + out, _ := s.Sign(message("dev@lists.example.org")) + mustVerify(t, out, "s", "lists.example.org", &sub.PublicKey) + // A subdomain without its own key is signed with the parent (relaxed alignment). + out, _ = s.Sign(message("dev@news.lists.example.org")) + mustVerify(t, out, "s", "lists.example.org", &sub.PublicKey) + out, _ = s.Sign(message("dev@other.example.org")) + mustVerify(t, out, "p", "example.org", &parent.PublicKey) + // A different domain with a similar suffix is not a subdomain. + if out, _ := s.Sign(message("dev@notexample.org")); bytes.HasPrefix(out, []byte("DKIM-Signature")) { + t.Fatal("notexample.org is not a subdomain of example.org") + } +} + +func TestDomainMatchingIgnoresCaseAndDisplayNames(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "Lists.Example.ORG", Selector: "mail", Signer: k}) + out, _ := s.Sign(message(`"someone@elsewhere.test via Dev" `)) + mustVerify(t, out, "mail", "lists.example.org", &k.PublicKey) + // A key domain named only in the display name must not be used. + out, _ = s.Sign(message(`"dev@lists.example.org" `)) + if bytes.HasPrefix(out, []byte("DKIM-Signature")) { + t.Fatal("the domain comes from the address, not the display name") + } +} + +func TestNewRejectsBadKeySets(t *testing.T) { + k := rsaKey(t, 2048) + for name, keys := range map[string][]Key{ + "duplicate domain": {{Domain: "a.org", Selector: "x", Signer: k}, {Domain: "A.org", Selector: "y", Signer: k}}, + "empty domain": {{Domain: "", Selector: "x", Signer: k}}, + "empty selector": {{Domain: "a.org", Selector: "", Signer: k}}, + "no signer": {{Domain: "a.org", Selector: "x"}}, + "selector with a space": {{Domain: "a.org", Selector: "my sel", Signer: k}}, + } { + if _, err := New(keys); err == nil { + t.Errorf("%s: want an error", name) + } + } +} + +func TestSignIsSafeForConcurrentUse(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + var wg sync.WaitGroup + for i := 0; i < 16; i++ { + wg.Add(1) + go func() { + defer wg.Done() + out, err := s.Sign(message("dev@lists.example.org")) + if err != nil || !bytes.HasPrefix(out, []byte("DKIM-Signature")) { + t.Errorf("concurrent sign: %v", err) + } + }() + } + wg.Wait() +} + +func TestBigMessagesAreSigned(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + in := append(message("dev@lists.example.org"), bytes.Repeat([]byte("0123456789abcdef\r\n"), 300_000)...) + out, err := s.Sign(in) + if err != nil { + t.Fatal(err) + } + mustVerify(t, out, "mail", "lists.example.org", &k.PublicKey) +} + +func writePEM(t *testing.T, typ string, der []byte) string { + t.Helper() + path := filepath.Join(t.TempDir(), "key.pem") + if err := os.WriteFile(path, pem.EncodeToMemory(&pem.Block{Type: typ, Bytes: der}), 0o600); err != nil { + t.Fatal(err) + } + return path +} + +func TestLoadKeyFormats(t *testing.T) { + k := rsaKey(t, 2048) + pkcs8, _ := x509.MarshalPKCS8PrivateKey(k) + _, ed, _ := ed25519.GenerateKey(rand.Reader) + edDER, _ := x509.MarshalPKCS8PrivateKey(ed) + for name, path := range map[string]string{ + "rsa pkcs1": writePEM(t, "RSA PRIVATE KEY", x509.MarshalPKCS1PrivateKey(k)), + "rsa pkcs8": writePEM(t, "PRIVATE KEY", pkcs8), + "ed25519 p8": writePEM(t, "PRIVATE KEY", edDER), + } { + key, err := LoadKey("lists.example.org", "mail", path) + if err != nil { + t.Errorf("%s: %v", name, err) + continue + } + s := newSigner(t, key) + out, err := s.Sign(message("dev@lists.example.org")) + if err != nil || !bytes.HasPrefix(out, []byte("DKIM-Signature")) { + t.Errorf("%s: loaded key does not sign: %v", name, err) + } + } +} + +func TestLoadKeyRejectsUnusableFiles(t *testing.T) { + cases := map[string]string{ + "garbage": func() string { + p := filepath.Join(t.TempDir(), "k") + os.WriteFile(p, []byte("not a pem"), 0o600) + return p + }(), + "wrong type": writePEM(t, "CERTIFICATE", []byte("x")), + "truncated der": writePEM(t, "RSA PRIVATE KEY", []byte{1, 2, 3}), + "missing file": "/nonexistent/key.pem", + } + for name, path := range cases { + if _, err := LoadKey("a.org", "mail", path); err == nil { + t.Errorf("%s: want an error", name) + } + } + // The error never contains key material. + _, err := LoadKey("a.org", "mail", writePEM(t, "RSA PRIVATE KEY", []byte{1, 2, 3})) + if err != nil && strings.Contains(err.Error(), "AQID") { + t.Fatal("do not echo key bytes in errors") + } +} From be413a75e07e1d5e1703dedd3b563f612349cfbb Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 19:58:24 +0100 Subject: [PATCH 2/8] feat(config): dkim keys per domain, validated at load --- internal/config/config.go | 33 +++++++++++++++++++++++++++++++++ internal/config/config_test.go | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 66 insertions(+) diff --git a/internal/config/config.go b/internal/config/config.go index 92b60c4..d385904 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -5,6 +5,7 @@ import ( "bytes" "fmt" "os" + "strings" "gopkg.in/yaml.v3" ) @@ -23,12 +24,41 @@ type Config struct { Web struct { Listen string `yaml:"listen"` // public archive and unsubscribe pages; empty disables them } `yaml:"web"` + // DKIM lists the signing keys, one per domain. The private keys stay in files. + DKIM []DKIMKey `yaml:"dkim"` Relay struct { Addr string `yaml:"addr"` // host:port of the outgoing SMTP relay Concurrency int `yaml:"concurrency"` // simultaneous deliveries } `yaml:"relay"` } +// DKIMKey is the signing key of one domain. +type DKIMKey struct { + Domain string `yaml:"domain"` + Selector string `yaml:"selector"` + KeyFile string `yaml:"key_file"` // PEM private key +} + +func (c Config) validate() error { + seen := map[string]bool{} + for i, k := range c.DKIM { + switch { + case strings.TrimSpace(k.Domain) == "": + return fmt.Errorf("dkim[%d]: domain is required", i) + case strings.TrimSpace(k.Selector) == "": + return fmt.Errorf("dkim[%d] (%s): selector is required", i, k.Domain) + case strings.TrimSpace(k.KeyFile) == "": + return fmt.Errorf("dkim[%d] (%s): key_file is required", i, k.Domain) + } + d := strings.ToLower(k.Domain) + if seen[d] { + return fmt.Errorf("dkim[%d]: more than one key for %s", i, k.Domain) + } + seen[d] = true + } + return nil +} + // Load reads path and applies defaults. func Load(path string) (Config, error) { var c Config @@ -49,5 +79,8 @@ func Load(path string) (Config, error) { if err := dec.Decode(&c); err != nil { return c, fmt.Errorf("parse %s: %w", path, err) } + if err := c.validate(); err != nil { + return c, fmt.Errorf("%s: %w", path, err) + } return c, nil } diff --git a/internal/config/config_test.go b/internal/config/config_test.go index df78e2d..46919b6 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -3,6 +3,7 @@ package config import ( "os" "path/filepath" + "strings" "testing" ) @@ -56,3 +57,35 @@ func TestWebCanBeDisabled(t *testing.T) { 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) + } +} From aa55cd3c1784ec43b9aa3b2105c0d4df95733b96 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 19:58:47 +0100 Subject: [PATCH 3/8] feat(queue): optional signing hook applied to the final message --- internal/queue/queue.go | 10 +++++++ internal/queue/queue_test.go | 52 ++++++++++++++++++++++++++++++++++++ 2 files changed, 62 insertions(+) diff --git a/internal/queue/queue.go b/internal/queue/queue.go index acb8ae1..389ac98 100644 --- a/internal/queue/queue.go +++ b/internal/queue/queue.go @@ -52,6 +52,9 @@ type Worker struct { Batch int // deliveries taken per run Timeout time.Duration // per send Interval time.Duration // idle polling, to pick up retries that have become due + // Sign, when set, signs the final message (DKIM). On error the message is sent unsigned: + // not delivering is worse than a missed signature. + Sign func(msg []byte) ([]byte, error) wakeOnce sync.Once wake chan struct{} @@ -165,6 +168,13 @@ func (w *Worker) deliver(ctx context.Context, it store.OutboxItem) Stats { } msg := make([]byte, 0, len(it.Prefix)+len(data)) msg = append(append(msg, it.Prefix...), data...) + if w.Sign != nil { + if signed, err := w.Sign(msg); err != nil { + log.Printf("queue: sign message for %s: %v (sending unsigned)", it.Rcpt, err) + } else { + msg = signed + } + } timeout := w.Timeout if timeout <= 0 { diff --git a/internal/queue/queue_test.go b/internal/queue/queue_test.go index fbddf9b..f96e6f5 100644 --- a/internal/queue/queue_test.go +++ b/internal/queue/queue_test.go @@ -447,3 +447,55 @@ func TestIdleRunPollsForDueRetries(t *testing.T) { e.clk.set(t0.Add(2 * time.Minute)) // the backoff has passed; no Wake needed waitFor(t, "retry by polling", func() bool { return e.snd.count() == 1 }) } + +func TestSignHookSeesTheFinalMessageIncludingThePerRecipientHeaders(t *testing.T) { + e := setup(t) + e.enqueue(t, 1) + var seen []byte + e.w.Sign = func(msg []byte) ([]byte, error) { + seen = append([]byte(nil), msg...) + return append([]byte("X-Signed: yes\r\n"), msg...), nil + } + if st, _ := e.w.RunOnce(context.Background()); st.Sent != 1 { + t.Fatalf("%+v", st) + } + if string(seen) != "X-Rcpt: a\r\nSubject: hi\r\n\r\nbody\r\n" { + t.Fatalf("the signer must see prefix + message, so List-Unsubscribe is covered: %q", seen) + } + if string(e.snd.sent[0].Data) != "X-Signed: yes\r\nX-Rcpt: a\r\nSubject: hi\r\n\r\nbody\r\n" { + t.Fatalf("the relay must get the signed message: %q", e.snd.sent[0].Data) + } +} + +func TestSigningFailureSendsTheMessageUnsigned(t *testing.T) { + e := setup(t) + e.enqueue(t, 1) + e.w.Sign = func(msg []byte) ([]byte, error) { return nil, errors.New("hsm unavailable") } + st, _ := e.w.RunOnce(context.Background()) + if st.Sent != 1 || e.pending(t) != 0 { + t.Fatalf("a signing error must not stop delivery: %+v", st) + } + if string(e.snd.sent[0].Data) != "X-Rcpt: a\r\nSubject: hi\r\n\r\nbody\r\n" { + t.Fatalf("unsigned message expected: %q", e.snd.sent[0].Data) + } +} + +func TestEachAttemptIsSignedAgain(t *testing.T) { + e := setup(t) + e.enqueue(t, 1) + calls := 0 + e.w.Sign = func(msg []byte) ([]byte, error) { calls++; return msg, nil } + failures := int32(1) + e.snd.fn = func(context.Context, string, []string) error { + if atomic.AddInt32(&failures, -1) >= 0 { + return errors.New("down") + } + return nil + } + e.w.RunOnce(context.Background()) + e.clk.set(t0.Add(2 * time.Minute)) + e.w.RunOnce(context.Background()) + if calls != 2 { + t.Fatalf("a retry is signed afresh (new timestamp), signing calls = %d", calls) + } +} From dca9117a2e6e46e13f82d0e497982b55146a32ce Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 19:59:57 +0100 Subject: [PATCH 4/8] 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) + } + } +} From 45303b7143d2a31b11e48d4cf65e688545e4534d Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 20:00:47 +0100 Subject: [PATCH 5/8] feat(dkimsign): key generation, DNS record formatting and parsing helpers --- internal/dkimsign/dkimsign.go | 62 ++++++++++++++++++++ internal/dkimsign/dkimsign_test.go | 90 ++++++++++++++++++++++++++++++ 2 files changed, 152 insertions(+) diff --git a/internal/dkimsign/dkimsign.go b/internal/dkimsign/dkimsign.go index 9bb067f..20fb26c 100644 --- a/internal/dkimsign/dkimsign.go +++ b/internal/dkimsign/dkimsign.go @@ -9,8 +9,10 @@ import ( "bytes" "crypto" "crypto/ed25519" + "crypto/rand" "crypto/rsa" "crypto/x509" + "encoding/base64" "encoding/pem" "errors" "fmt" @@ -164,3 +166,63 @@ func (s *Signer) Sign(msg []byte) ([]byte, error) { } return out.Bytes(), nil } + +// GenerateKeyPEM creates an RSA private key and returns it as PKCS#8 PEM. Use +// 2048 bits: every receiver verifies it and it fits a DNS record. +func GenerateKeyPEM(bits int) ([]byte, error) { + if bits < 1024 { + return nil, fmt.Errorf("RSA keys under 1024 bits are not accepted (use 2048)") + } + k, err := rsa.GenerateKey(rand.Reader, bits) + if err != nil { + return nil, err + } + der, err := x509.MarshalPKCS8PrivateKey(k) + if err != nil { + return nil, err + } + return pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: der}), nil +} + +// Record returns the DKIM DNS TXT value that publishes a public key. +func Record(pub crypto.PublicKey) (string, error) { + switch k := pub.(type) { + case *rsa.PublicKey: + der, err := x509.MarshalPKIXPublicKey(k) + if err != nil { + return "", err + } + return "v=DKIM1; k=rsa; p=" + base64.StdEncoding.EncodeToString(der), nil + case ed25519.PublicKey: + return "v=DKIM1; k=ed25519; p=" + base64.StdEncoding.EncodeToString(k), nil + } + return "", fmt.Errorf("unsupported public key type %T", pub) +} + +// RecordKey extracts the base64 public key (the p= tag, whitespace removed) +// from a DKIM TXT value. +func RecordKey(txt string) (string, bool) { + for _, tag := range strings.Split(txt, ";") { + name, value, ok := strings.Cut(strings.TrimSpace(tag), "=") + if ok && strings.TrimSpace(name) == "p" { + key := strings.Join(strings.Fields(value), "") + return key, key != "" + } + } + return "", false +} + +// SplitTXT cuts a TXT value into the strings of at most 255 bytes that a DNS +// record is made of. +func SplitTXT(value string) []string { + const max = 255 + var parts []string + for len(value) > max { + parts = append(parts, value[:max]) + value = value[max:] + } + if value != "" { + parts = append(parts, value) + } + return parts +} diff --git a/internal/dkimsign/dkimsign_test.go b/internal/dkimsign/dkimsign_test.go index 3d99bbe..c75635a 100644 --- a/internal/dkimsign/dkimsign_test.go +++ b/internal/dkimsign/dkimsign_test.go @@ -312,3 +312,93 @@ func TestLoadKeyRejectsUnusableFiles(t *testing.T) { t.Fatal("do not echo key bytes in errors") } } + +func TestGenerateKeyPEMProducesAUsableKey(t *testing.T) { + pemBytes, err := GenerateKeyPEM(2048) + if err != nil { + t.Fatal(err) + } + if !bytes.HasPrefix(pemBytes, []byte("-----BEGIN PRIVATE KEY-----")) { + t.Fatalf("PKCS#8 expected:\n%s", pemBytes) + } + path := filepath.Join(t.TempDir(), "k.pem") + os.WriteFile(path, pemBytes, 0o600) + key, err := LoadKey("lists.example.org", "mail", path) + if err != nil { + t.Fatal(err) + } + out, err := newSigner(t, key).Sign(message("dev@lists.example.org")) + if err != nil { + t.Fatal(err) + } + rec, err := Record(key.Signer.Public()) + if err != nil { + t.Fatal(err) + } + vs, err := dkim.VerifyWithOptions(bytes.NewReader(out), &dkim.VerifyOptions{ + LookupTXT: func(string) ([]string, error) { return []string{rec}, nil }, + }) + if err != nil || len(vs) != 1 || vs[0].Err != nil { + t.Fatalf("the generated key and its DNS record must work together: %v %+v", err, vs) + } + if _, err := GenerateKeyPEM(512); err == nil { + t.Fatal("keys that are too small must be refused") + } +} + +func TestRecordFormat(t *testing.T) { + k := rsaKey(t, 2048) + rec, err := Record(&k.PublicKey) + if err != nil { + t.Fatal(err) + } + der, _ := x509.MarshalPKIXPublicKey(&k.PublicKey) + if rec != "v=DKIM1; k=rsa; p="+base64.StdEncoding.EncodeToString(der) { + t.Fatalf("rsa record: %s", rec) + } + pub, _, _ := ed25519.GenerateKey(rand.Reader) + rec, _ = Record(pub) + if rec != "v=DKIM1; k=ed25519; p="+base64.StdEncoding.EncodeToString(pub) { + t.Fatalf("ed25519 record: %s", rec) + } + if _, err := Record("not a key"); err == nil { + t.Fatal("unsupported key type") + } +} + +func TestRecordKeyParsing(t *testing.T) { + for in, want := range map[string]string{ + "v=DKIM1; k=rsa; p=AAAA": "AAAA", + "v=DKIM1;k=rsa;p=AA AA": "AAAA", + "v=DKIM1; p=AAAA; t=y": "AAAA", + "p=AAAA": "AAAA", + "v=DKIM1; k=rsa; p=AAAA BBBB\tCCCC": "AAAABBBBCCCC", + } { + if got, ok := RecordKey(in); !ok || got != want { + t.Errorf("RecordKey(%q) = %q %v, want %q", in, got, ok, want) + } + } + for _, in := range []string{"", "v=spf1 -all", "v=DKIM1; k=rsa", "v=DKIM1; p="} { + if _, ok := RecordKey(in); ok { + t.Errorf("RecordKey(%q) must fail", in) + } + } +} + +func TestSplitTXTChunks(t *testing.T) { + for _, n := range []int{0, 1, 254, 255, 256, 400, 510, 511, 1000} { + v := strings.Repeat("a", n) + parts := SplitTXT(v) + if strings.Join(parts, "") != v { + t.Errorf("n=%d: the parts must rebuild the value", n) + } + for _, p := range parts { + if len(p) > 255 { + t.Errorf("n=%d: chunk of %d bytes exceeds the DNS limit", n, len(p)) + } + } + if want := (n + 254) / 255; n > 0 && len(parts) != want { + t.Errorf("n=%d: %d chunks, want %d", n, len(parts), want) + } + } +} From 1e223f1ad189be67165adaf6cd9df0f1f5fde7a7 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 20:01:36 +0100 Subject: [PATCH 6/8] feat(cli): dkim keygen, record and check - Create a signing key (mode 0600, never overwritten without --force) and print the DNS record and the config snippet - Print the record of an existing key, split in DNS-sized strings - Check that DNS publishes the key that matches the private key file - Work offline of the API: no token needed --- internal/cli/cli.go | 9 ++ internal/cli/cli_test.go | 208 +++++++++++++++++++++++++++++++++++++++ internal/cli/dkim.go | 185 ++++++++++++++++++++++++++++++++++ 3 files changed, 402 insertions(+) create mode 100644 internal/cli/dkim.go diff --git a/internal/cli/cli.go b/internal/cli/cli.go index 2dfa020..81e4c80 100644 --- a/internal/cli/cli.go +++ b/internal/cli/cli.go @@ -51,6 +51,14 @@ Administration (talks to the REST API): queue ls outbound queue queue rm discard one queued delivery +DKIM (works offline, needs no token): + dkim keygen [--selector mail] [--out FILE] [--force] + create a signing key and print the DNS record and config + dkim record --key FILE [--selector mail] + print the DNS record of an existing key + dkim check --key FILE [--selector mail] + look the record up in DNS and compare it with the key + Daemon: serve [-config FILE] run the mailing list server @@ -94,6 +102,7 @@ func Run(args []string, io IO, getenv func(string) string) int { "held": {"ls": c.heldLs, "approve": c.heldApprove, "discard": c.heldDiscard}, "archive": {"ls": c.archiveLs, "show": c.archiveShow, "rm": c.archiveRm, "import": c.archiveImport}, "queue": {"ls": c.queueLs, "rm": c.queueRm}, + "dkim": {"keygen": c.dkimKeygen, "record": c.dkimRecord, "check": c.dkimCheck}, } group, ok := commands[rest[0]] if !ok { diff --git a/internal/cli/cli_test.go b/internal/cli/cli_test.go index f64aece..dacaa65 100644 --- a/internal/cli/cli_test.go +++ b/internal/cli/cli_test.go @@ -3,17 +3,25 @@ package cli import ( "bytes" "context" + "crypto/ed25519" + "crypto/rand" + "crypto/x509" "encoding/json" + "encoding/pem" + "errors" "fmt" "io" "net/http" "net/http/httptest" "os" + "path/filepath" + "regexp" "strings" "testing" "time" "codeberg.org/squidd/parsimony/internal/api" + "codeberg.org/squidd/parsimony/internal/dkimsign" "codeberg.org/squidd/parsimony/internal/store" ) @@ -552,3 +560,203 @@ func TestArchiveImportSendsTheFileAsAnMbox(t *testing.T) { t.Fatalf("content type %q, body unchanged: %v", contentType, body == cliMbox) } } + +// --- dkim ---------------------------------------------------------------------- + +// noAuth runs a command that must not need the API token or URL. +func noAuth(t *testing.T, args ...string) (int, string, string) { + t.Helper() + var out, errb bytes.Buffer + code := Run(args, IO{In: strings.NewReader(""), Out: &out, Err: &errb}, func(string) string { return "" }) + return code, out.String(), errb.String() +} + +func TestDKIMKeygen(t *testing.T) { + dir := t.TempDir() + keyFile := filepath.Join(dir, "dkim.pem") + code, out, errs := noAuth(t, "dkim", "keygen", "example.org", "--out", keyFile) + if code != 0 { + t.Fatalf("exit %d: %s", code, errs) + } + info, err := os.Stat(keyFile) + if err != nil || info.Mode().Perm() != 0o600 { + t.Fatalf("the private key must be created with mode 0600: %v %v", err, info) + } + key, err := dkimsign.LoadKey("example.org", "mail", keyFile) + if err != nil { + t.Fatal(err) + } + want, _ := dkimsign.Record(key.Signer.Public()) + for _, s := range []string{ + "mail._domainkey.example.org.", "IN TXT", "Wrote private key to " + keyFile, + "dkim:", "domain: example.org", "selector: mail", "key_file: " + keyFile, want, + "parsimony dkim check example.org", + } { + if !strings.Contains(out, s) { + t.Errorf("output lacks %q:\n%s", s, out) + } + } + // The zone-file form is split in strings of at most 255 bytes. + for _, line := range strings.Split(out, "\n") { + if strings.Contains(line, "IN TXT") { + for _, q := range regexp.MustCompile(`"([^"]*)"`).FindAllStringSubmatch(line, -1) { + if len(q[1]) > 255 { + t.Fatalf("a TXT string of %d bytes exceeds the DNS limit", len(q[1])) + } + } + } + } + if strings.Contains(out, "PRIVATE KEY") { + t.Fatal("never print the private key") + } +} + +func TestDKIMKeygenOptions(t *testing.T) { + dir := t.TempDir() + keyFile := filepath.Join(dir, "k.pem") + code, out, _ := noAuth(t, "dkim", "keygen", "lists.example.org", "--selector", "s2024", "--out", keyFile) + if code != 0 || !strings.Contains(out, "s2024._domainkey.lists.example.org.") || !strings.Contains(out, "selector: s2024") { + t.Fatalf("selector: %d %s", code, out) + } + + first, _ := os.ReadFile(keyFile) + code, _, errs := noAuth(t, "dkim", "keygen", "lists.example.org", "--out", keyFile) + if code != 1 || !strings.Contains(errs, "already exists") { + t.Fatalf("an existing key must not be overwritten: %d %q", code, errs) + } + if again, _ := os.ReadFile(keyFile); !bytes.Equal(first, again) { + t.Fatal("the existing key was modified") + } + if code, _, errs := noAuth(t, "dkim", "keygen", "lists.example.org", "--out", keyFile, "--force"); code != 0 { + t.Fatalf("--force: %d %s", code, errs) + } + if replaced, _ := os.ReadFile(keyFile); bytes.Equal(first, replaced) { + t.Fatal("--force must replace the key") + } + if info, _ := os.Stat(keyFile); info.Mode().Perm() != 0o600 { + t.Fatalf("mode after --force: %v", info.Mode().Perm()) + } +} + +func TestDKIMKeygenDefaultFileName(t *testing.T) { + dir := t.TempDir() + old, _ := os.Getwd() + os.Chdir(dir) + defer os.Chdir(old) + if code, _, errs := noAuth(t, "dkim", "keygen", "example.org"); code != 0 { + t.Fatalf("%d %s", code, errs) + } + if _, err := os.Stat(filepath.Join(dir, "dkim-example.org.pem")); err != nil { + t.Fatalf("default file name: %v", err) + } +} + +func TestDKIMUsageErrors(t *testing.T) { + for name, args := range map[string][]string{ + "no domain": {"dkim", "keygen"}, + "domain with @": {"dkim", "keygen", "a@example.org"}, + "domain with space": {"dkim", "keygen", "my domain.org"}, + "no dot": {"dkim", "keygen", "localhost"}, + "bad selector": {"dkim", "keygen", "example.org", "--selector", "my sel"}, + "bits not a number": {"dkim", "keygen", "example.org", "--bits", "abc"}, + "record no key": {"dkim", "record", "example.org"}, + "check no key": {"dkim", "check", "example.org"}, + "unknown": {"dkim", "frobnicate"}, + } { + if code, _, errs := noAuth(t, args...); code != 2 { + t.Errorf("%s: exit %d, want 2 (%q)", name, code, errs) + } + } + if code, _, errs := noAuth(t, "dkim", "keygen", "example.org", "--bits", "512", "--out", filepath.Join(t.TempDir(), "k")); code != 1 || !strings.Contains(errs, "1024") { + t.Fatalf("a tiny key is refused: %d %q", code, errs) + } +} + +func writeKey(t *testing.T) (string, string) { + t.Helper() + dir := t.TempDir() + keyFile := filepath.Join(dir, "k.pem") + if code, _, errs := noAuth(t, "dkim", "keygen", "example.org", "--out", keyFile); code != 0 { + t.Fatalf("%d %s", code, errs) + } + key, _ := dkimsign.LoadKey("example.org", "mail", keyFile) + rec, _ := dkimsign.Record(key.Signer.Public()) + return keyFile, rec +} + +func TestDKIMRecord(t *testing.T) { + keyFile, rec := writeKey(t) + code, out, errs := noAuth(t, "dkim", "record", "example.org", "--key", keyFile) + if code != 0 || !strings.Contains(out, "mail._domainkey.example.org.") || !strings.Contains(out, rec) { + t.Fatalf("record: %d %q %q", code, out, errs) + } + code, out, _ = noAuth(t, "dkim", "record", "example.org", "--key", keyFile, "--selector", "x1") + if !strings.Contains(out, "x1._domainkey.example.org.") { + t.Fatalf("selector: %q", out) + } + if code, _, errs := noAuth(t, "dkim", "record", "example.org", "--key", "/nonexistent.pem"); code != 1 || errs == "" { + t.Fatalf("missing key: %d %q", code, errs) + } +} + +func withDNS(t *testing.T, records map[string][]string) *[]string { + t.Helper() + var asked []string + old := lookupTXT + lookupTXT = func(name string) ([]string, error) { + asked = append(asked, name) + if r, ok := records[name]; ok { + return r, nil + } + return nil, errors.New("no such host") + } + t.Cleanup(func() { lookupTXT = old }) + return &asked +} + +func TestDKIMCheck(t *testing.T) { + keyFile, rec := writeKey(t) + + asked := withDNS(t, map[string][]string{"mail._domainkey.example.org": {"v=spf1 -all", rec}}) + code, out, errs := noAuth(t, "dkim", "check", "example.org", "--key", keyFile) + if code != 0 || !strings.Contains(out, "OK") || len(*asked) != 1 || (*asked)[0] != "mail._domainkey.example.org" { + t.Fatalf("matching record: %d %q %q asked=%v", code, out, errs, *asked) + } + + withDNS(t, map[string][]string{"mail._domainkey.example.org": {"v=DKIM1; k=rsa; p=AAAAAAAA"}}) + code, _, errs = noAuth(t, "dkim", "check", "example.org", "--key", keyFile) + if code != 1 || !strings.Contains(errs, "different key") { + t.Fatalf("mismatch: %d %q", code, errs) + } + + withDNS(t, map[string][]string{}) + code, _, errs = noAuth(t, "dkim", "check", "example.org", "--key", keyFile) + if code != 1 || !strings.Contains(errs, "no DKIM record") || !strings.Contains(errs, "mail._domainkey.example.org") { + t.Fatalf("missing: %d %q", code, errs) + } + + withDNS(t, map[string][]string{"mail._domainkey.example.org": {"v=spf1 -all"}}) + if code, _, errs = noAuth(t, "dkim", "check", "example.org", "--key", keyFile); code != 1 || !strings.Contains(errs, "no DKIM record") { + t.Fatalf("only unrelated TXT records: %d %q", code, errs) + } + + asked = withDNS(t, map[string][]string{"s9._domainkey.example.org": {rec}}) + if code, _, errs = noAuth(t, "dkim", "check", "example.org", "--key", keyFile, "--selector", "s9"); code != 0 { + t.Fatalf("selector: %d %q asked=%v", code, errs, *asked) + } + if code, _, errs = noAuth(t, "dkim", "check", "example.org", "--key", "/nonexistent.pem"); code != 1 { + t.Fatalf("missing key file: %d %q", code, errs) + } +} + +func TestDKIMCheckEd25519Key(t *testing.T) { + pub, priv, _ := ed25519.GenerateKey(rand.Reader) + der, _ := x509.MarshalPKCS8PrivateKey(priv) + keyFile := filepath.Join(t.TempDir(), "ed.pem") + os.WriteFile(keyFile, pem.EncodeToMemory(&pem.Block{Type: "PRIVATE KEY", Bytes: der}), 0o600) + rec, _ := dkimsign.Record(pub) + withDNS(t, map[string][]string{"mail._domainkey.example.org": {rec}}) + if code, out, errs := noAuth(t, "dkim", "check", "example.org", "--key", keyFile); code != 0 || !strings.Contains(out, "OK") { + t.Fatalf("%d %q %q", code, out, errs) + } +} diff --git a/internal/cli/dkim.go b/internal/cli/dkim.go new file mode 100644 index 0000000..1574cce --- /dev/null +++ b/internal/cli/dkim.go @@ -0,0 +1,185 @@ +package cli + +import ( + "errors" + "fmt" + "net" + "os" + "path/filepath" + "regexp" + "strings" + + "codeberg.org/squidd/parsimony/internal/dkimsign" +) + +// lookupTXT resolves DNS TXT records; tests replace it. +var lookupTXT = net.LookupTXT + +var ( + domainRe = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?(\.[A-Za-z0-9]([A-Za-z0-9-]*[A-Za-z0-9])?)+$`) + selectorRe = regexp.MustCompile(`^[A-Za-z0-9]([A-Za-z0-9._-]*[A-Za-z0-9])?$`) +) + +// dkimTarget parses " --selector S ..." and validates domain and selector. +type dkimTarget struct { + domain, selector string +} + +func (t dkimTarget) recordName() string { return t.selector + "._domainkey." + t.domain } + +// zoneLine is the TXT record as it is written in a DNS zone file. +func (t dkimTarget) zoneLine(value string) string { + quoted := make([]string, 0, 2) + for _, p := range dkimsign.SplitTXT(value) { + quoted = append(quoted, `"`+p+`"`) + } + return fmt.Sprintf("%s. IN TXT %s", t.recordName(), strings.Join(quoted, " ")) +} + +func (c *cmd) dkimKeygen(args []string) int { + fs := newFlagSet("dkim keygen") + selector := fs.String("selector", "mail", "") + out := fs.String("out", "", "") + bits := fs.Int("bits", 2048, "") + force := fs.Bool("force", false, "") + pos, err := parseArgs(fs, args) + if err != nil { + return c.usageError("%v", err) + } + t, code := c.dkimDomain("dkim keygen [--selector S] [--out FILE] [--bits N] [--force]", pos, *selector) + if code != 0 { + return code + } + path := *out + if path == "" { + path = "dkim-" + t.domain + ".pem" + } + if abs, err := filepath.Abs(path); err == nil { + path = abs + } + pemBytes, err := dkimsign.GenerateKeyPEM(*bits) + if err != nil { + return c.fail(err) + } + flags := os.O_WRONLY | os.O_CREATE | os.O_EXCL + if *force { + flags = os.O_WRONLY | os.O_CREATE | os.O_TRUNC + } + f, err := os.OpenFile(path, flags, 0o600) + if errors.Is(err, os.ErrExist) { + return c.fail(fmt.Errorf("%s already exists (use --force to replace it)", path)) + } + if err != nil { + return c.fail(err) + } + if _, err := f.Write(pemBytes); err != nil { + f.Close() + return c.fail(err) + } + if err := f.Close(); err != nil { + return c.fail(err) + } + // An existing file keeps its old mode when truncated: make it private. + if err := os.Chmod(path, 0o600); err != nil { + return c.fail(err) + } + + key, err := dkimsign.LoadKey(t.domain, t.selector, path) + if err != nil { + return c.fail(err) + } + record, err := dkimsign.Record(key.Signer.Public()) + if err != nil { + return c.fail(err) + } + fmt.Fprintf(c.io.Out, "Wrote private key to %s (mode 0600)\n\n", path) + fmt.Fprintf(c.io.Out, "Publish this DNS TXT record:\n\n%s\n\n", t.zoneLine(record)) + fmt.Fprintf(c.io.Out, "Value, for a DNS control panel that wants one string:\n\n%s\n\n", record) + fmt.Fprintf(c.io.Out, "Then add this to the Parsimony config and restart it:\n\ndkim:\n - domain: %s\n selector: %s\n key_file: %s\n\n", t.domain, t.selector, path) + fmt.Fprintf(c.io.Out, "Check the record once it is published:\n\n parsimony dkim check %s --key %s --selector %s\n", t.domain, path, t.selector) + return 0 +} + +// dkimKeyArgs parses " --key FILE [--selector S]" and loads the key. +func (c *cmd) dkimKeyArgs(name string, args []string) (dkimTarget, dkimsign.Key, int) { + fs := newFlagSet(name) + selector := fs.String("selector", "mail", "") + keyFile := fs.String("key", "", "") + pos, err := parseArgs(fs, args) + if err != nil { + return dkimTarget{}, dkimsign.Key{}, c.usageError("%v", err) + } + t, code := c.dkimDomain(name+" --key FILE [--selector S]", pos, *selector) + if code != 0 { + return t, dkimsign.Key{}, code + } + if *keyFile == "" { + return t, dkimsign.Key{}, c.usageError("usage: parsimony %s --key FILE [--selector S]", name) + } + key, err := dkimsign.LoadKey(t.domain, t.selector, *keyFile) + if err != nil { + return t, dkimsign.Key{}, c.fail(err) + } + return t, key, 0 +} + +// dkimDomain validates the positional domain and the selector. +func (c *cmd) dkimDomain(usage string, pos []string, selector string) (dkimTarget, int) { + if len(pos) != 1 { + return dkimTarget{}, c.usageError("usage: parsimony %s", usage) + } + if !domainRe.MatchString(pos[0]) { + return dkimTarget{}, c.usageError("%q is not a valid domain name", pos[0]) + } + if !selectorRe.MatchString(selector) { + return dkimTarget{}, c.usageError("%q is not a valid selector", selector) + } + return dkimTarget{domain: strings.ToLower(pos[0]), selector: selector}, 0 +} + +func (c *cmd) dkimRecord(args []string) int { + t, key, code := c.dkimKeyArgs("dkim record", args) + if code != 0 { + return code + } + record, err := dkimsign.Record(key.Signer.Public()) + if err != nil { + return c.fail(err) + } + fmt.Fprintf(c.io.Out, "%s\n\nValue:\n\n%s\n", t.zoneLine(record), record) + return 0 +} + +func (c *cmd) dkimCheck(args []string) int { + t, key, code := c.dkimKeyArgs("dkim check", args) + if code != 0 { + return code + } + want, err := dkimsign.Record(key.Signer.Public()) + if err != nil { + return c.fail(err) + } + wantKey, _ := dkimsign.RecordKey(want) + + txts, err := lookupTXT(t.recordName()) + found := false + for _, txt := range txts { + got, ok := dkimsign.RecordKey(txt) + if !ok { + continue // not a DKIM record (no p= tag), for instance an SPF record + } + found = true + if got == wantKey { + fmt.Fprintf(c.io.Out, "OK: %s publishes the public key of this private key\n", t.recordName()) + return 0 + } + } + if !found { + reason := "" + if err != nil { + reason = fmt.Sprintf(" (%v)", err) + } + return c.fail(fmt.Errorf("no DKIM record at %s%s; publish the one from `parsimony dkim record`", t.recordName(), reason)) + } + return c.fail(fmt.Errorf("%s publishes a different key than this private key: the record is stale or belongs to another key", t.recordName())) +} From e7cc9cacfb3194e8203f7260f0867afbe34b7ae9 Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 20:02:54 +0100 Subject: [PATCH 7/8] test: close gaps found by mutation checks on DKIM - Cover headers outside the signed list changing in transit, quoted local parts with @, signing errors and lowercase domains - Ignore *.pem so a private key is never committed --- .gitignore | 3 +++ internal/cli/cli_test.go | 16 ++++++++++++ internal/dkimsign/dkimsign_test.go | 40 ++++++++++++++++++++++++++++++ 3 files changed, 59 insertions(+) diff --git a/.gitignore b/.gitignore index 77713c2..835326d 100644 --- a/.gitignore +++ b/.gitignore @@ -4,3 +4,6 @@ parsimony admin/node_modules internal/adminui/dist/* !internal/adminui/dist/.gitkeep + +# Private keys must never be committed +*.pem diff --git a/internal/cli/cli_test.go b/internal/cli/cli_test.go index dacaa65..d6d0c00 100644 --- a/internal/cli/cli_test.go +++ b/internal/cli/cli_test.go @@ -760,3 +760,19 @@ func TestDKIMCheckEd25519Key(t *testing.T) { t.Fatalf("%d %q %q", code, out, errs) } } + +func TestDKIMDomainIsLowercased(t *testing.T) { + keyFile := filepath.Join(t.TempDir(), "k.pem") + code, out, errs := noAuth(t, "dkim", "keygen", "Lists.Example.ORG", "--out", keyFile) + if code != 0 { + t.Fatalf("%d %s", code, errs) + } + if !strings.Contains(out, "mail._domainkey.lists.example.org.") || !strings.Contains(out, "domain: lists.example.org") { + t.Fatalf("DNS names and the config use lowercase:\n%s", out) + } + asked := withDNS(t, map[string][]string{}) + noAuth(t, "dkim", "check", "Lists.Example.ORG", "--key", keyFile) + if len(*asked) != 1 || (*asked)[0] != "mail._domainkey.lists.example.org" { + t.Fatalf("lookup name: %v", *asked) + } +} diff --git a/internal/dkimsign/dkimsign_test.go b/internal/dkimsign/dkimsign_test.go index c75635a..4f7da3c 100644 --- a/internal/dkimsign/dkimsign_test.go +++ b/internal/dkimsign/dkimsign_test.go @@ -10,6 +10,7 @@ import ( "encoding/base64" "encoding/pem" "errors" + "io" "os" "path/filepath" "regexp" @@ -402,3 +403,42 @@ func TestSplitTXTChunks(t *testing.T) { } } } + +func TestHeadersOutsideTheSignedListMayChangeInTransit(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + in := append([]byte("X-Transit: original\r\n"), message("dev@lists.example.org")...) + out, _ := s.Sign(in) + changed := bytes.Replace(out, []byte("X-Transit: original"), []byte("X-Transit: rewritten by a relay"), 1) + mustVerify(t, changed, "mail", "lists.example.org", &k.PublicKey) + withReceived := append([]byte("Received: from relay by mx; Mon, 01 Jan 2024 10:00:01 +0000\r\n"), out...) + mustVerify(t, withReceived, "mail", "lists.example.org", &k.PublicKey) +} + +func TestFromAddressWithAnAtSignInTheLocalPart(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: k}) + out, _ := s.Sign(message(`"odd@name"@lists.example.org`)) + mustVerify(t, out, "mail", "lists.example.org", &k.PublicKey) +} + +// brokenSigner has an RSA public key but cannot sign. +type brokenSigner struct{ pub crypto.PublicKey } + +func (b brokenSigner) Public() crypto.PublicKey { return b.pub } +func (brokenSigner) Sign(io.Reader, []byte, crypto.SignerOpts) ([]byte, error) { + return nil, errors.New("hsm unavailable") +} + +func TestASigningErrorReturnsTheOriginalMessageAndTheError(t *testing.T) { + k := rsaKey(t, 2048) + s := newSigner(t, Key{Domain: "lists.example.org", Selector: "mail", Signer: brokenSigner{pub: &k.PublicKey}}) + in := message("dev@lists.example.org") + out, err := s.Sign(in) + if err == nil || !strings.Contains(err.Error(), "lists.example.org") { + t.Fatalf("the error names the domain: %v", err) + } + if !bytes.Equal(out, in) { + t.Fatal("on error the caller still gets the original message to send unsigned") + } +} From 849a85ec7d40b803934c90c60b380c15ea4c3dfe Mon Sep 17 00:00:00 2001 From: tgiachi Date: Mon, 9 Nov 2026 20:04:32 +0100 Subject: [PATCH 8/8] feat: end-to-end DKIM check through a real Postfix, docs and example config - Check that every message the list delivered through Postfix is signed with the list domain and still verifies, and that edits break it - Run dkim keygen, record and the no-overwrite rule inside the read-only container - Document DKIM, SPF and DMARC in the README and show the dkim block in the example config --- README.md | 34 ++++++++++++++++++ e2e/e2e_test.go | 80 +++++++++++++++++++++++++++++++++++++++++- parsimony.example.yaml | 6 ++++ 3 files changed, 119 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 97ae3e0..6fcd736 100644 --- a/README.md +++ b/README.md @@ -5,6 +5,7 @@ A modern, single-binary mailing list manager: an evolution of Mailman. - Postfix delivers to parsimony over LMTP; parsimony relays through SMTP. - Discussion lists with member-only posting, `List-*` headers, one-click unsubscribe and DMARC-safe `From` rewriting. +- DKIM signing of outgoing mail with one key per list domain, so DMARC holds after the From rewrite. - Durable outbound queue: a post is accepted once it is stored, one delivery per recipient, and a background worker sends it with retries (1m, 5m, 15m, 1h, 3h, then every 6h, for up to 3 days). Relay outages and restarts lose nothing. @@ -89,6 +90,39 @@ of the messages. Messages that cannot be read are listed and counted, and the ex It works whatever the list's archive policy is (the policy only governs live mail). The admin UI has the same import on the Archive tab. Search is accent-insensitive: `caffe` finds "Caffè". +## Outgoing mail: DKIM, SPF and DMARC + +Parsimony rewrites `From` to the list address, so a signature of the original author's domain is of no use and +receivers that enforce DMARC need a signature of the **list domain**. + +``` +parsimony dkim keygen lists.example.org --selector mail --out /etc/parsimony/dkim-lists.pem +``` + +prints the DNS TXT record to publish and the config to add (the private key is written with mode 0600 and the +command never overwrites an existing key without `--force`): + +```yaml +dkim: + - domain: lists.example.org + selector: mail + key_file: /etc/parsimony/dkim-lists.pem +``` + +Once the record is in DNS, `parsimony dkim check lists.example.org --key FILE --selector mail` looks it up and compares it +with the key. Both commands work offline of the API and need no token. + +- A message is signed with the key of the domain in its From address (exact match, else a parent domain), at send time, so + the per-recipient `List-Unsubscribe` headers are covered. Relaxed/relaxed, SHA-256, no body length limit. + Signed: From, To, Cc, Subject, Date, Message-ID, In-Reply-To, References, Reply-To, MIME-Version, Content-Type, + Content-Transfer-Encoding and the `List-*` headers. A relay may add `Received` or rewrite other headers. +- A list on a domain without a key is sent unsigned. A broken key file stops the daemon at startup. If signing fails at + send time the error is logged and the message goes out unsigned: not delivering is worse than a missed signature. +- RSA (2048 bits recommended; PKCS#1 or PKCS#8 PEM) and Ed25519 keys are supported. Some receivers do not verify Ed25519 yet. +- Also publish SPF for the machine that relays your mail (for example `v=spf1 ip4:203.0.113.10 -all` on the list domain) + and a DMARC record (start with `_dmarc.lists.example.org TXT "v=DMARC1; p=none; rua=mailto:postmaster@example.org"`, + then tighten the policy once the reports look clean). + ## Docker The image runs as an unprivileged user (uid 65532) and works with a read-only root filesystem. diff --git a/e2e/e2e_test.go b/e2e/e2e_test.go index 714d7eb..5887029 100644 --- a/e2e/e2e_test.go +++ b/e2e/e2e_test.go @@ -11,7 +11,12 @@ package e2e import ( + "crypto/rand" + "crypto/rsa" + "crypto/x509" + "encoding/base64" "encoding/json" + "encoding/pem" "fmt" "io" "net" @@ -24,6 +29,8 @@ import ( "strings" "testing" "time" + + "github.com/emersion/go-msgauth/dkim" ) const ( @@ -37,6 +44,7 @@ var ( postfixC = "pm-e2e-postfix-" + suffix parsimonyC = "pm-e2e-parsimony-" + suffix smtpAddr string + dkimPub *rsa.PublicKey // the list domain's signing key apiBase string webBase string ) @@ -84,6 +92,16 @@ func TestMain(m *testing.M) { apiBase = fmt.Sprintf("http://127.0.0.1:%d", apiPort) webBase = fmt.Sprintf("http://127.0.0.1:%d", webPort) + // A DKIM key for the list domain, mounted read-only into the container. + key, err := rsa.GenerateKey(rand.Reader, 2048) + if err != nil { + panic(err) + } + dkimPub = &key.PublicKey + keyFile := filepath.Join(os.TempDir(), "pm-e2e-dkim-"+suffix+".pem") + os.WriteFile(keyFile, pem.EncodeToMemory(&pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(key)}), 0o644) + defer os.Remove(keyFile) + cfg := filepath.Join(os.TempDir(), "pm-e2e-"+suffix+".yaml") os.WriteFile(cfg, []byte(fmt.Sprintf(`db: /data/parsimony.db base_url: %s @@ -97,6 +115,10 @@ api: listen: 0.0.0.0:8080 web: listen: 0.0.0.0:8081 +dkim: + - domain: lists.example.test + selector: e2e + key_file: /etc/parsimony/dkim.pem `, webBase)), 0o644) defer os.Remove(cfg) @@ -104,7 +126,7 @@ web: "-p", "127.0.0.1::25", "parsimony-e2e-postfix") mustDocker("run", "-d", "--name", parsimonyC, "--network", network, "--network-alias", "parsimony", "--read-only", "--cap-drop", "ALL", "-e", "PARSIMONY_API_TOKEN="+token, - "-v", cfg+":/etc/parsimony/parsimony.yaml:ro", + "-v", cfg+":/etc/parsimony/parsimony.yaml:ro", "-v", keyFile+":/etc/parsimony/dkim.pem:ro", "-p", fmt.Sprintf("127.0.0.1:%d:8080", apiPort), "-p", fmt.Sprintf("127.0.0.1:%d:8081", webPort), image) smtpAddr = mustDocker("port", postfixC, "25/tcp") smtpAddr = strings.Split(strings.Split(smtpAddr, "\n")[0], " ")[0] // "127.0.0.1:49153" @@ -263,6 +285,24 @@ func waitMail(t *testing.T, user, contains string) string { return found } +// verifyDKIM checks the signatures of a delivered message against the test key. +func verifyDKIM(t *testing.T, raw string) []*dkim.Verification { + t.Helper() + der, _ := x509.MarshalPKIXPublicKey(dkimPub) + vs, err := dkim.VerifyWithOptions(strings.NewReader(raw), &dkim.VerifyOptions{ + LookupTXT: func(name string) ([]string, error) { + if name == "e2e._domainkey."+domain { + return []string{"v=DKIM1; k=rsa; p=" + base64.StdEncoding.EncodeToString(der)}, nil + } + return nil, fmt.Errorf("no record %s", name) + }, + }) + if err != nil { + t.Fatalf("verify: %v", err) + } + return vs +} + func header(msg, name string) string { re := regexp.MustCompile(`(?im)^` + regexp.QuoteMeta(name) + `:[ \t]*(.*(?:\r?\n[ \t]+.*)*)`) if m := re.FindStringSubmatch(msg); m != nil { @@ -608,6 +648,44 @@ func TestWholePath(t *testing.T) { } }) + t.Run("everything the list delivered is DKIM-signed and still verifies after Postfix", func(t *testing.T) { + checked := 0 + for _, user := range []string{"alice", "bob", "carol"} { + for _, m := range mailbox(user) { + vs := verifyDKIM(t, m) + if len(vs) != 1 || vs[0].Err != nil || vs[0].Domain != domain { + t.Fatalf("%s: message %q is not validly signed by %s: %+v", user, header(m, "Subject"), domain, vs) + } + if from := header(m, "From"); !strings.Contains(from, "@"+domain) { + t.Fatalf("a signature for the list domain only makes sense when From is on it: %q", from) + } + checked++ + } + } + if checked < 8 { + t.Fatalf("expected posts, confirmations and approved mail, checked only %d", checked) + } + // A copy changed after delivery must fail verification. + m := mailbox("bob")[0] + tampered := strings.Replace(m, "Subject: ", "Subject: [edited] ", 1) + if vs := verifyDKIM(t, tampered); len(vs) != 1 || vs[0].Err == nil { + t.Fatalf("a modified message must not verify: %+v", vs) + } + }) + + t.Run("dkim keygen works in the read-only container", func(t *testing.T) { + out, err := docker("exec", parsimonyC, "/parsimony", "dkim", "keygen", "keys.example.test", "--out", "/data/e2e-key.pem") + if err != nil || !strings.Contains(out, "mail._domainkey.keys.example.test.") || !strings.Contains(out, "v=DKIM1; k=rsa; p=") { + t.Fatalf("keygen: %v\n%s", err, out) + } + if out, err := docker("exec", parsimonyC, "/parsimony", "dkim", "keygen", "keys.example.test", "--out", "/data/e2e-key.pem"); err == nil || !strings.Contains(out, "already exists") { + t.Fatalf("must not overwrite: %v %s", err, out) + } + if out, err := docker("exec", parsimonyC, "/parsimony", "dkim", "record", "keys.example.test", "--key", "/data/e2e-key.pem"); err != nil || !strings.Contains(out, "v=DKIM1") { + t.Fatalf("record: %v %s", err, out) + } + }) + t.Run("the queue ends empty", func(t *testing.T) { waitQueueEmpty(t) }) diff --git a/parsimony.example.yaml b/parsimony.example.yaml index d5c493b..6cd3494 100644 --- a/parsimony.example.yaml +++ b/parsimony.example.yaml @@ -11,3 +11,9 @@ web: api: listen: 0.0.0.0:8080 # The API token is read from the PARSIMONY_API_TOKEN environment variable. +# Sign outgoing mail with DKIM, one key per domain. The private key stays in a file +# (create it with: parsimony dkim keygen lists.example.org --selector mail). +# dkim: +# - domain: lists.example.org +# selector: mail +# key_file: /etc/parsimony/dkim-lists.pem