selfpost/internal/dmarc/service.go

// Package dmarc receives DMARC aggregate reports: Postfix pipes messages here,
// gzip/XML is parsed, and summaries land in SQLite for the panel.
package dmarc

import (
	"fmt"
	"sort"
	"strings"

	"github.com/mixeme/selfpost/internal/dnscheck"
	"github.com/mixeme/selfpost/internal/postfix"
	"github.com/mixeme/selfpost/internal/store"
)

// Maps is the Postfix manager surface the DMARC service needs.
type Maps interface {
	RebuildDMARCMaps(cfg postfix.DMARCMapsConfig) error
}

// Service coordinates DMARC ingest allow-lists across SQLite and Postfix.
type Service struct {
	store    *store.Store
	maps     Maps
	hostname string
	enabled  bool
}

// NewService builds the DMARC ingest service.
func NewService(st *store.Store, maps Maps, hostname string, enabled bool) *Service {
	return &Service{store: st, maps: maps, hostname: strings.ToLower(strings.TrimSpace(hostname)), enabled: enabled}
}

// Enabled reports whether DMARC ingest is active in this deployment.
func (s *Service) Enabled() bool { return s.enabled }

// Resync rebuilds the Postfix allow-list and transport maps from SQLite.
func (s *Service) Resync() error {
	if !s.enabled {
		return s.maps.RebuildDMARCMaps(postfix.DMARCMapsConfig{})
	}
	addrs, err := s.AllowedRecipients()
	if err != nil {
		return err
	}
	domains := recipientDomains(addrs)
	return s.maps.RebuildDMARCMaps(postfix.DMARCMapsConfig{
		Recipients: addrs,
		Domains:    domains,
	})
}

// AllowedRecipients returns every address Postfix may accept for DMARC ingest.
func (s *Service) AllowedRecipients() ([]string, error) {
	if !s.enabled || s.hostname == "" {
		return nil, nil
	}
	seen := make(map[string]bool)
	var out []string
	add := func(addr string) {
		addr = strings.ToLower(strings.TrimSpace(addr))
		if addr == "" || !IsHostedOnHostname(addr, s.hostname) || seen[addr] {
			return
		}
		seen[addr] = true
		out = append(out, addr)
	}
	// A user's own default that points at this host is accepted even before a
	// domain follows it, so the address can be published first. With no such
	// default anywhere, the instance's generic mailbox stays open — the address
	// the guide tells a fresh install to publish.
	users, err := s.store.ListUsers()
	if err != nil {
		return nil, err
	}
	anyDefault := false
	for _, u := range users {
		if def := u.DMARCDefault(); def.Mode == store.DMARCDefaultAccount || def.Mode == store.DMARCDefaultCustom {
			if addr := def.Resolve(""); addr != "" {
				anyDefault = true
				add(addr)
			}
		}
	}
	if !anyDefault {
		add(DefaultHostedReportAddress(s.hostname))
	}
	domains, err := s.store.ListDomains()
	if err != nil {
		return nil, err
	}
	for _, d := range domains {
		// add keeps only addresses on this host, so a domain reporting elsewhere
		// (or nowhere) opens nothing here.
		rua, err := s.store.DomainDMARCRua(d, HostedReportAddress(s.hostname, d.Name))
		if err != nil {
			return nil, err
		}
		add(rua)
	}
	sort.Strings(out)
	return out, nil
}

func recipientDomains(addrs []string) []string {
	seen := make(map[string]bool)
	var out []string
	for _, addr := range addrs {
		d := dnscheck.EmailDomain(addr)
		if d == "" || seen[d] {
			continue
		}
		seen[d] = true
		out = append(out, d)
	}
	sort.Strings(out)
	return out
}

// HostedSuggestion returns the address the panel should suggest for a domain.
func (s *Service) HostedSuggestion(domain string) string {
	return HostedReportAddress(s.hostname, domain)
}

// DefaultHostedSuggestion is the settings-level hosted address.
func (s *Service) DefaultHostedSuggestion() string {
	return DefaultHostedReportAddress(s.hostname)
}

// ValidateHostedAddress ensures addr is on this hostname before saving.
func (s *Service) ValidateHostedAddress(addr string) error {
	if !IsHostedOnHostname(addr, s.hostname) {
		return fmt.Errorf("hosted report address must be on %s", s.hostname)
	}
	return nil
}