Phase 3: sending domains + per-domain OpenDKIM signing

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>
2026-07-11 22:20:35 +03:00
parent 048be22ded
commit a7a5ad3f91
24 changed files with 1461 additions and 36 deletions
@@ -0,0 +1,138 @@
+package store
+
+import (
+	"database/sql"
+	"errors"
+	"fmt"
+	"time"
+
+	"modernc.org/sqlite"
+	sqlite3 "modernc.org/sqlite/lib"
+)
+
+// ErrDomainExists is returned by AddDomain when the domain is already managed.
+var ErrDomainExists = errors.New("domain already exists")
+
+// ErrDomainNotFound is returned when a domain id/name does not exist.
+var ErrDomainNotFound = errors.New("domain not found")
+
+// Domain is a sending domain managed through the panel (spec 4.1). The DKIM key
+// material itself lives on disk under /data; this row records the selector and
+// metadata. AppCount is populated by the listing queries, not stored.
+type Domain struct {
+	ID           int64
+	Name         string
+	DKIMSelector string
+	CreatedAt    time.Time
+	AppCount     int
+}
+
+// AddDomain inserts a new sending domain. The caller is responsible for having
+// validated name (spec 7.6.2) before it reaches SQL; the query is parameterised
+// regardless. A duplicate name maps to ErrDomainExists.
+func (s *Store) AddDomain(name, selector string) (Domain, error) {
+	now := time.Now().UTC()
+	res, err := s.db.Exec(
+		"INSERT INTO domains (name, dkim_selector, created_at) VALUES (?, ?, ?)",
+		name, selector, now.Format(time.RFC3339),
+	)
+	if err != nil {
+		if isUniqueViolation(err) {
+			return Domain{}, ErrDomainExists
+		}
+		return Domain{}, fmt.Errorf("insert domain: %w", err)
+	}
+	id, err := res.LastInsertId()
+	if err != nil {
+		return Domain{}, fmt.Errorf("domain id: %w", err)
+	}
+	return Domain{ID: id, Name: name, DKIMSelector: selector, CreatedAt: now}, nil
+}
+
+// ListDomains returns every domain with its bound-application count (spec 7.2.2),
+// ordered by name.
+func (s *Store) ListDomains() ([]Domain, error) {
+	rows, err := s.db.Query(`
+		SELECT d.id, d.name, d.dkim_selector, d.created_at,
+		       (SELECT COUNT(*) FROM applications a WHERE a.domain_id = d.id)
+		FROM domains d
+		ORDER BY d.name`)
+	if err != nil {
+		return nil, fmt.Errorf("list domains: %w", err)
+	}
+	defer rows.Close()
+
+	var out []Domain
+	for rows.Next() {
+		d, err := scanDomain(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, d)
+	}
+	return out, rows.Err()
+}
+
+// GetDomain returns a single domain (with its application count) by id, or
+// ErrDomainNotFound.
+func (s *Store) GetDomain(id int64) (Domain, error) {
+	row := s.db.QueryRow(`
+		SELECT d.id, d.name, d.dkim_selector, d.created_at,
+		       (SELECT COUNT(*) FROM applications a WHERE a.domain_id = d.id)
+		FROM domains d
+		WHERE d.id = ?`, id)
+	d, err := scanDomain(row)
+	if errors.Is(err, sql.ErrNoRows) {
+		return Domain{}, ErrDomainNotFound
+	}
+	if err != nil {
+		return Domain{}, err
+	}
+	return d, nil
+}
+
+// DeleteDomain removes a domain. Its applications and their address/binding rows
+// go with it via ON DELETE CASCADE (spec 7.2.4). Returns ErrDomainNotFound if no
+// such row existed.
+func (s *Store) DeleteDomain(id int64) error {
+	res, err := s.db.Exec("DELETE FROM domains WHERE id = ?", id)
+	if err != nil {
+		return fmt.Errorf("delete domain: %w", err)
+	}
+	n, err := res.RowsAffected()
+	if err != nil {
+		return fmt.Errorf("delete domain rows: %w", err)
+	}
+	if n == 0 {
+		return ErrDomainNotFound
+	}
+	return nil
+}
+
+// scanRow is the minimal surface shared by *sql.Row and *sql.Rows.
+type scanRow interface {
+	Scan(dest ...any) error
+}
+
+func scanDomain(r scanRow) (Domain, error) {
+	var (
+		d         Domain
+		createdAt string
+	)
+	if err := r.Scan(&d.ID, &d.Name, &d.DKIMSelector, &createdAt, &d.AppCount); err != nil {
+		return Domain{}, err
+	}
+	d.CreatedAt, _ = time.Parse(time.RFC3339, createdAt)
+	return d, nil
+}
+
+// isUniqueViolation reports whether err is a SQLite UNIQUE/PRIMARY-KEY conflict,
+// so callers can turn a duplicate insert into a friendly domain-level error.
+func isUniqueViolation(err error) bool {
+	var se *sqlite.Error
+	if errors.As(err, &se) {
+		code := se.Code()
+		return code == sqlite3.SQLITE_CONSTRAINT_UNIQUE || code == sqlite3.SQLITE_CONSTRAINT_PRIMARYKEY
+	}
+	return false
+}
@@ -0,0 +1,117 @@
+package store
+
+import (
+	"errors"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func openTestStore(t *testing.T) *Store {
+	t.Helper()
+	st, err := Open(filepath.Join(t.TempDir(), "test.db"))
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	t.Cleanup(func() { st.Close() })
+	return st
+}
+
+func TestAddAndListDomains(t *testing.T) {
+	st := openTestStore(t)
+
+	d, err := st.AddDomain("example.com", "selfpost")
+	if err != nil {
+		t.Fatalf("AddDomain: %v", err)
+	}
+	if d.ID == 0 || d.Name != "example.com" || d.DKIMSelector != "selfpost" {
+		t.Fatalf("unexpected domain: %+v", d)
+	}
+
+	list, err := st.ListDomains()
+	if err != nil {
+		t.Fatalf("ListDomains: %v", err)
+	}
+	if len(list) != 1 || list[0].Name != "example.com" || list[0].AppCount != 0 {
+		t.Fatalf("unexpected list: %+v", list)
+	}
+}
+
+func TestAddDomainDuplicate(t *testing.T) {
+	st := openTestStore(t)
+	if _, err := st.AddDomain("example.com", "selfpost"); err != nil {
+		t.Fatal(err)
+	}
+	_, err := st.AddDomain("example.com", "other")
+	if !errors.Is(err, ErrDomainExists) {
+		t.Fatalf("duplicate AddDomain error = %v, want ErrDomainExists", err)
+	}
+}
+
+func TestGetDomainNotFound(t *testing.T) {
+	st := openTestStore(t)
+	if _, err := st.GetDomain(999); !errors.Is(err, ErrDomainNotFound) {
+		t.Fatalf("GetDomain(missing) = %v, want ErrDomainNotFound", err)
+	}
+}
+
+func TestDeleteDomainCascadesApplications(t *testing.T) {
+	st := openTestStore(t)
+	d, err := st.AddDomain("example.com", "selfpost")
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Insert an application + address directly (the AddApplication API lands in
+	// Phase 4); this verifies the ON DELETE CASCADE wiring now.
+	now := time.Now().UTC().Format(time.RFC3339)
+	res, err := st.db.Exec(
+		"INSERT INTO applications (domain_id, login, address_mode, created_at) VALUES (?, ?, 'wildcard', ?)",
+		d.ID, "app1", now)
+	if err != nil {
+		t.Fatal(err)
+	}
+	appID, _ := res.LastInsertId()
+	if _, err := st.db.Exec(
+		"INSERT INTO application_addresses (application_id, address) VALUES (?, ?)",
+		appID, "noreply@example.com"); err != nil {
+		t.Fatal(err)
+	}
+
+	got, err := st.GetDomain(d.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if got.AppCount != 1 {
+		t.Fatalf("AppCount = %d, want 1", got.AppCount)
+	}
+
+	if err := st.DeleteDomain(d.ID); err != nil {
+		t.Fatalf("DeleteDomain: %v", err)
+	}
+
+	assertCount(t, st, "applications", 0)
+	assertCount(t, st, "application_addresses", 0)
+	if _, err := st.GetDomain(d.ID); !errors.Is(err, ErrDomainNotFound) {
+		t.Errorf("domain still present after delete: %v", err)
+	}
+}
+
+func TestDeleteDomainNotFound(t *testing.T) {
+	st := openTestStore(t)
+	if err := st.DeleteDomain(123); !errors.Is(err, ErrDomainNotFound) {
+		t.Fatalf("DeleteDomain(missing) = %v, want ErrDomainNotFound", err)
+	}
+}
+
+func assertCount(t *testing.T, st *Store, table string, want int) {
+	t.Helper()
+	var n int
+	// table is a trusted literal from the test, not user input.
+	if err := st.db.QueryRow("SELECT COUNT(*) FROM " + table).Scan(&n); err != nil {
+		t.Fatalf("count %s: %v", table, err)
+	}
+	if n != want {
+		t.Errorf("%s count = %d, want %d", table, n, want)
+	}
+}