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
This commit is contained in:
parent
fb313736bb
commit
141c5d98e9
4 changed files with 488 additions and 1 deletions
4
go.mod
4
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
|
||||
|
|
|
|||
5
go.sum
5
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=
|
||||
|
|
|
|||
166
internal/dkimsign/dkimsign.go
Normal file
166
internal/dkimsign/dkimsign.go
Normal file
|
|
@ -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
|
||||
}
|
||||
314
internal/dkimsign/dkimsign_test.go
Normal file
314
internal/dkimsign/dkimsign_test.go
Normal file
|
|
@ -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 <dev.lists.example.org>\r\nList-Unsubscribe: <mailto:dev+leave@lists.example.org>\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 <dev@lists.example.org>")
|
||||
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: <mailto:dev+leave@lists.example.org>\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" <DEV@LISTS.example.org>`))
|
||||
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" <x@elsewhere.test>`))
|
||||
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")
|
||||
}
|
||||
}
|
||||
Loading…
Reference in a new issue