Files
pages/internal/store/federation_manifest.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
Capture accumulated application, UI, CLI, regression tests and design documentation changes, including task project mapping and default CalDAV list naming.

Keep deployment data, backups, local credentials and build artifacts out of Git. Move the Compose enrollment token to an ignored local environment file.
2026-09-27 14:44:43 +09:00

200 lines
8.2 KiB
Go

package store
import (
"crypto/ed25519"
"crypto/sha256"
"database/sql"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"sort"
"strings"
"time"
)
type CampusManifestPayload struct {
SchemaVersion int `json:"schema_version"`
Revision int64 `json:"revision"`
Campus Campus `json:"campus"`
Domains []Domain `json:"domains"`
DomainEntries map[string]DomainEntrySettings `json:"domain_entries,omitempty"`
}
type SignedCampusManifest struct {
CampusManifestPayload
ControllerPublicKey string `json:"controller_public_key"`
ControllerFingerprint string `json:"controller_fingerprint"`
Signature string `json:"signature"`
}
func (s *Store) federationSigningKey() ed25519.PrivateKey {
seed := s.authKey
if len(seed) != ed25519.SeedSize {
sum := sha256.Sum256(seed)
seed = sum[:]
}
return ed25519.NewKeyFromSeed(seed)
}
func (s *Store) BuildSignedCampusManifest(campus Campus, domains []Domain) (SignedCampusManifest, error) {
if campus.AuthorityMode != "controller" || campus.UUID == "" {
return SignedCampusManifest{}, errors.New("Campus is not a controller")
}
filtered := make([]Domain, 0, len(domains))
seen := make(map[string]bool, len(domains))
for _, domain := range domains {
if domain.CampusUUID == campus.UUID {
if domain.UUID == "" || seen[domain.UUID] {
return SignedCampusManifest{}, errors.New("duplicate or missing Domain identity in Campus manifest")
}
seen[domain.UUID] = true
filtered = append(filtered, domain)
}
}
sort.Slice(filtered, func(i, j int) bool { return filtered[i].UUID < filtered[j].UUID })
entries, err := s.ListDomainEntrySettings()
if err != nil {
return SignedCampusManifest{}, err
}
for id := range entries {
if !seen[id] {
delete(entries, id)
}
}
content, err := json.Marshal(struct {
Campus Campus `json:"campus"`
Domains []Domain `json:"domains"`
Entries map[string]DomainEntrySettings `json:"domain_entries,omitempty"`
}{campus, filtered, entries})
if err != nil {
return SignedCampusManifest{}, err
}
hash := sha256.Sum256(content)
hashText := hex.EncodeToString(hash[:])
var revision int64
// Allocate against the current row inside one write statement. A separate
// SELECT/UPSERT can sign different payloads with the same revision.
err = s.DB.QueryRow(`INSERT INTO federation_manifest_versions(campus_uuid,revision,manifest_hash,updated_at)
VALUES(?,1,?,?) ON CONFLICT(campus_uuid) DO UPDATE SET
revision=CASE WHEN federation_manifest_versions.manifest_hash=excluded.manifest_hash
THEN federation_manifest_versions.revision ELSE federation_manifest_versions.revision+1 END,
manifest_hash=excluded.manifest_hash,
updated_at=CASE WHEN federation_manifest_versions.manifest_hash=excluded.manifest_hash
THEN federation_manifest_versions.updated_at ELSE excluded.updated_at END
WHERE federation_manifest_versions.revision<9223372036854775807 OR federation_manifest_versions.manifest_hash=excluded.manifest_hash
RETURNING revision`, campus.UUID, hashText, time.Now().Unix()).Scan(&revision)
if err != nil {
return SignedCampusManifest{}, err
}
payload := CampusManifestPayload{SchemaVersion: 1, Revision: revision, Campus: campus, Domains: filtered}
if len(entries) > 0 {
payload.SchemaVersion = 2
payload.DomainEntries = entries
}
encoded, err := json.Marshal(payload)
if err != nil {
return SignedCampusManifest{}, err
}
privateKey := s.federationSigningKey()
publicKey := privateKey.Public().(ed25519.PublicKey)
fingerprint := sha256.Sum256(publicKey)
return SignedCampusManifest{
CampusManifestPayload: payload,
ControllerPublicKey: base64.RawStdEncoding.EncodeToString(publicKey),
ControllerFingerprint: "sha256:" + hex.EncodeToString(fingerprint[:]),
Signature: base64.RawStdEncoding.EncodeToString(ed25519.Sign(privateKey, encoded)),
}, nil
}
func verifyCampusManifest(manifest SignedCampusManifest) ([]byte, error) {
if (manifest.SchemaVersion != 1 && manifest.SchemaVersion != 2) || manifest.Revision < 1 || manifest.Campus.UUID == "" || (manifest.SchemaVersion == 1 && len(manifest.DomainEntries) > 0) {
return nil, errors.New("invalid Campus manifest metadata")
}
publicKey, err := base64.RawStdEncoding.DecodeString(manifest.ControllerPublicKey)
if err != nil || len(publicKey) != ed25519.PublicKeySize {
return nil, errors.New("invalid controller public key")
}
fingerprint := sha256.Sum256(publicKey)
if manifest.ControllerFingerprint != "sha256:"+hex.EncodeToString(fingerprint[:]) {
return nil, errors.New("controller fingerprint does not match public key")
}
signature, err := base64.RawStdEncoding.DecodeString(manifest.Signature)
if err != nil {
return nil, errors.New("invalid Campus manifest signature")
}
payload, err := json.Marshal(manifest.CampusManifestPayload)
if err != nil || !ed25519.Verify(ed25519.PublicKey(publicKey), payload, signature) {
return nil, errors.New("Campus manifest signature verification failed")
}
seen := make(map[string]bool, len(manifest.Domains))
for _, domain := range manifest.Domains {
if domain.UUID == "" || seen[domain.UUID] || domain.CampusUUID != manifest.Campus.UUID || strings.ContainsAny(domain.Domain, "/:\\") || strings.ContainsAny(domain.InstanceFQDN, "/:\\") {
return nil, errors.New("Campus manifest contains an invalid Domain hostname")
}
seen[domain.UUID] = true
}
for id, e := range manifest.DomainEntries {
if !seen[id] || !e.valid() {
return nil, errors.New("invalid Domain entry settings")
}
}
return payload, nil
}
func (s *Store) ApplySignedManagedCampusManifest(manifest SignedCampusManifest, expectedCampusUUID, localInstanceFQDN, transport string) error {
payload, err := verifyCampusManifest(manifest)
if err != nil {
return err
}
if expectedCampusUUID != "" && manifest.Campus.UUID != expectedCampusUUID {
return errors.New("Campus controller identity changed")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
// Reserve SQLite's writer before checking the pin/checkpoint, even when the
// Campus has no state yet. Concurrent first pins and duplicate deliveries
// then serialize without a stale read-to-write upgrade or unchecked retry.
if _, err := tx.Exec(`UPDATE federation_manifest_state SET applied_at=applied_at WHERE campus_uuid=?`, manifest.Campus.UUID); err != nil {
return err
}
var pinnedFingerprint, previousPayload string
var appliedRevision int64
err = tx.QueryRow(`SELECT controller_fingerprint,applied_revision,manifest_json FROM federation_manifest_state WHERE campus_uuid=?`, manifest.Campus.UUID).Scan(&pinnedFingerprint, &appliedRevision, &previousPayload)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if err == nil {
if pinnedFingerprint != manifest.ControllerFingerprint {
return errors.New("Campus controller signing identity changed")
}
if manifest.Revision < appliedRevision {
return errors.New("Campus manifest replay rejected")
}
if manifest.Revision == appliedRevision {
if previousPayload == string(payload) {
return nil
}
return errors.New("Campus manifest revision was reused with different content")
}
}
if err := applyManagedCampusSnapshotTx(tx, manifest.Campus, manifest.Domains, localInstanceFQDN, transport); err != nil {
return err
}
for _, d := range manifest.Domains {
if e, ok := manifest.DomainEntries[d.UUID]; ok {
if err := saveDomainEntryTx(tx, d.UUID, e, normalizeDomainHost(d.InstanceFQDN) == normalizeDomainHost(localInstanceFQDN)); err != nil {
return err
}
}
}
_, err = tx.Exec(`INSERT INTO federation_manifest_state(campus_uuid,controller_public_key,controller_fingerprint,applied_revision,manifest_json,applied_at) VALUES(?,?,?,?,?,?) ON CONFLICT(campus_uuid) DO UPDATE SET controller_public_key=excluded.controller_public_key,controller_fingerprint=excluded.controller_fingerprint,applied_revision=excluded.applied_revision,manifest_json=excluded.manifest_json,applied_at=excluded.applied_at`, manifest.Campus.UUID, manifest.ControllerPublicKey, manifest.ControllerFingerprint, manifest.Revision, string(payload), time.Now().Unix())
if err != nil {
return err
}
return tx.Commit()
}