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())) }