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