mix
a7a5ad3f91
Add/list/delete of sending domains with per-domain DKIM keys and the OpenDKIM tables that drive signing (spec 6, 7.2.2-4, 7.2.10). internal/domain: - Pure-Go RSA-2048 keygen; PKCS#1 PEM written atomically at 0640; the published DNS TXT record is derived from the key on disk (single source of truth) rather than persisted. No os/exec for key generation. - KeyTable/SigningTable fully regenerated from the registry on every add/delete (idempotent), written atomically; SigningTable via refile: with *@domain, KeyTable with absolute key paths. Table writer refuses any unsafe character as a backstop (spec 7.6.4). - Reload without root: the unprivileged panel signals OpenDKIM through supervisord (`supervisorctl signal USR1 opendkim`, fixed args, no shell, no user input — spec 7.6.3). An existing key is reused, never overwritten, so re-adding a domain keeps its published DNS valid. - Service orchestrates registry -> key -> table rebuild -> reload, with rollback of the row if a downstream step fails; delete cascades apps via the DB FK and removes the key + table entries. Infra: - Shared `selfpost` group bridges panel (writes keys) and opendkim (reads them); /data/opendkim is setgid so panel-created files inherit the group, keys are 0640, RequireSafeKeys is disabled by design. - opendkim.conf moves from verify-only (Mode v) to signing (Mode s). - entrypoint.sh normalises the DKIM tree on every start (ownership, setgid, perms, empty tables before opendkim starts) — self-healing after a restore. - supervisord control socket opened to the `selfpost` group so the panel can request the reload. web/store: - Strict domain-name validation (whitelist [a-z0-9.-], DNS shape, >=2 labels), lower-case normalisation (spec 7.6.2). - Domain queries with application counts; delete relies on ON DELETE CASCADE. Dashboard lists domains + add form; domain page shows the DKIM record; a dedicated confirm page warns about the app cascade before deletion (spec 7.2.4); manual reload button (spec 7.2.12, OpenDKIM side; Postfix reload lands in Phase 5). - Authenticated routes moved to a sub-mux using Go 1.22 method/wildcard patterns. Tests: validateDomain, DKIM keygen/record roundtrip, table rendering + injection-safety, key reuse, store cascade. Verified on the dev server: gofmt/vet/test green, image builds, container e2e (add/delete a domain, DKIM record shown, OpenDKIM reads panel keys and reloads, keys and tables persist across a restart). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
87 lines
2.1 KiB
Go
87 lines
2.1 KiB
Go
package domain
|
|
|
|
import (
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestWriteLoadPrivateKeyRoundtrip(t *testing.T) {
|
|
key, err := generateDKIMKey()
|
|
if err != nil {
|
|
t.Fatalf("generateDKIMKey: %v", err)
|
|
}
|
|
path := filepath.Join(t.TempDir(), "selfpost.private")
|
|
if err := writePrivateKeyPEM(path, key); err != nil {
|
|
t.Fatalf("writePrivateKeyPEM: %v", err)
|
|
}
|
|
|
|
info, err := os.Stat(path)
|
|
if err != nil {
|
|
t.Fatalf("stat: %v", err)
|
|
}
|
|
if perm := info.Mode().Perm(); perm != 0o640 {
|
|
t.Errorf("key perm = %o, want 0640", perm)
|
|
}
|
|
|
|
loaded, err := loadPrivateKeyPEM(path)
|
|
if err != nil {
|
|
t.Fatalf("loadPrivateKeyPEM: %v", err)
|
|
}
|
|
if loaded.N.Cmp(key.N) != 0 || loaded.E != key.E {
|
|
t.Error("loaded key does not match generated key")
|
|
}
|
|
}
|
|
|
|
func TestLoadPrivateKeyRejectsGarbage(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "bad.private")
|
|
if err := os.WriteFile(path, []byte("not a pem"), 0o640); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := loadPrivateKeyPEM(path); err == nil {
|
|
t.Error("expected error for non-PEM key file")
|
|
}
|
|
}
|
|
|
|
func TestDKIMRecord(t *testing.T) {
|
|
key, err := generateDKIMKey()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
rec, err := dkimRecord("selfpost", "example.com", &key.PublicKey)
|
|
if err != nil {
|
|
t.Fatalf("dkimRecord: %v", err)
|
|
}
|
|
if rec.Name != "selfpost._domainkey.example.com" {
|
|
t.Errorf("record name = %q", rec.Name)
|
|
}
|
|
for _, want := range []string{"v=DKIM1", "h=sha256", "k=rsa", "p="} {
|
|
if !strings.Contains(rec.Value, want) {
|
|
t.Errorf("record value %q missing %q", rec.Value, want)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestWriteFileAtomicOverwrite(t *testing.T) {
|
|
path := filepath.Join(t.TempDir(), "f")
|
|
if err := writeFileAtomic(path, []byte("one"), 0o640); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := writeFileAtomic(path, []byte("two"), 0o640); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
got, err := os.ReadFile(path)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if string(got) != "two" {
|
|
t.Errorf("content = %q, want %q", got, "two")
|
|
}
|
|
// No stray temp files left behind in the directory.
|
|
entries, _ := os.ReadDir(filepath.Dir(path))
|
|
if len(entries) != 1 {
|
|
t.Errorf("expected 1 file after atomic writes, found %d", len(entries))
|
|
}
|
|
}
|