93 lines
3.0 KiB
Go
93 lines
3.0 KiB
Go
// Package dkim implements DKIM (RFC 6376) signing for outbound mail using
|
|
// only stdlib crypto — no third-party DKIM library. Verification of inbound
|
|
// DKIM signatures is added in Phase 4's security pipeline.
|
|
package dkim
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"crypto/rsa"
|
|
"crypto/x509"
|
|
"encoding/base64"
|
|
"encoding/pem"
|
|
"fmt"
|
|
)
|
|
|
|
// KeyPair holds a freshly generated DKIM signing key, both as PEM (for
|
|
// encrypted storage) and the DNS TXT record value the operator must publish.
|
|
type KeyPair struct {
|
|
PrivateKeyPEM []byte // PKCS#1 PEM — store encrypted in domains.dkim_private_key_enc
|
|
DNSRecordValue string // paste into: {selector}._domainkey.{domain} TXT record
|
|
}
|
|
|
|
// GenerateKeyPair creates a new RSA-2048 DKIM key pair. RSA-2048 is used
|
|
// (rather than Ed25519) because it has universal support across mail
|
|
// receivers — Ed25519 DKIM (RFC 8463) support is not yet ubiquitous.
|
|
func GenerateKeyPair() (*KeyPair, error) {
|
|
priv, err := rsa.GenerateKey(rand.Reader, 2048)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("generating RSA key: %w", err)
|
|
}
|
|
|
|
privDER := x509.MarshalPKCS1PrivateKey(priv)
|
|
privPEM := pem.EncodeToMemory(&pem.Block{
|
|
Type: "RSA PRIVATE KEY",
|
|
Bytes: privDER,
|
|
})
|
|
|
|
pubDER, err := x509.MarshalPKIXPublicKey(&priv.PublicKey)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("marshaling public key: %w", err)
|
|
}
|
|
pubB64 := base64.StdEncoding.EncodeToString(pubDER)
|
|
|
|
dnsValue := fmt.Sprintf("v=DKIM1; k=rsa; p=%s", pubB64)
|
|
|
|
return &KeyPair{
|
|
PrivateKeyPEM: privPEM,
|
|
DNSRecordValue: dnsValue,
|
|
}, nil
|
|
}
|
|
|
|
// ParsePrivateKey decodes a PEM-encoded RSA private key (as produced by
|
|
// GenerateKeyPair, after decryption from storage).
|
|
func ParsePrivateKey(pemBytes []byte) (*rsa.PrivateKey, error) {
|
|
block, _ := pem.Decode(pemBytes)
|
|
if block == nil {
|
|
return nil, fmt.Errorf("no PEM block found")
|
|
}
|
|
key, err := x509.ParsePKCS1PrivateKey(block.Bytes)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("parsing RSA private key: %w", err)
|
|
}
|
|
return key, nil
|
|
}
|
|
|
|
// ExtractSignatureInfo pulls the signing domain and selector out of a
|
|
// message's DKIM-Signature header, without doing any verification — the
|
|
// caller uses this to know which DNS TXT record to fetch before calling
|
|
// Verify. Returns found=false if no DKIM-Signature header is present.
|
|
func ExtractSignatureInfo(raw []byte) (domain, selector string, found bool) {
|
|
headers, _ := splitMessage(raw)
|
|
headerMap := parseHeaders(headers)
|
|
sigHeader, ok := headerMap["dkim-signature"]
|
|
if !ok {
|
|
return "", "", false
|
|
}
|
|
tags := parseDKIMTags(sigHeader)
|
|
domain = tags["d"]
|
|
selector = tags["s"]
|
|
return domain, selector, domain != "" && selector != ""
|
|
}
|
|
|
|
// ParseDNSPublicKey decodes the "p=" tag value from a DKIM DNS TXT record
|
|
// (as published by GenerateKeyPair's DNSRecordValue, or any RFC 6376
|
|
// compliant record) into the raw public key DER bytes Verify expects.
|
|
func ParseDNSPublicKey(txtRecord string) ([]byte, error) {
|
|
tags := parseDKIMTags(txtRecord)
|
|
pValue, ok := tags["p"]
|
|
if !ok || pValue == "" {
|
|
return nil, fmt.Errorf("no p= tag found in DNS record")
|
|
}
|
|
return base64.StdEncoding.DecodeString(pValue)
|
|
}
|