package store import ( "context" "crypto/ed25519" "crypto/rand" "crypto/sha256" "database/sql" "encoding/base64" "encoding/hex" "errors" "log" "strings" "time" "github.com/google/uuid" ) type FederationInstance struct { ID int64 UUID string CampusUUID string FQDN string Fingerprint string Status string LastSeenAt int64 CreatedAt int64 } type CampusToken struct { ID int64 CampusUUID string Label string Revoked bool CreatedAt int64 LastUsedAt int64 } func (s *Store) ApplyManagedCampusSnapshot( campus Campus, domains []Domain, localInstanceFQDN string, transport string, ) (resultErr error) { defer func() { resultErr = s.sqlError("ApplyManagedCampusSnapshot", resultErr) }() if s.ReadOnly { return ErrReadOnly } if campus.UUID == "" || campus.FQDN == "" { return namespaceValidationError("invalid managed campus snapshot") } ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted}) if err != nil { return err } defer tx.Rollback() if err = s.lockFederationWrite(ctx, tx); err != nil { return err } if _, err := tx.Exec(`UPDATE federation_manifest_state SET applied_at=applied_at WHERE campus_uuid=`+s.sqlParam(1)+``, campus.UUID); err != nil { return err } var pinned int if err := tx.QueryRow(`SELECT COUNT(*) FROM federation_manifest_state WHERE campus_uuid=`+s.sqlParam(1)+``, campus.UUID).Scan(&pinned); err != nil { return err } if pinned != 0 { return namespaceValidationError("unsigned snapshot rejected for a pinned Campus") } if err := s.applyManagedCampusSnapshotTx(tx, campus, domains, localInstanceFQDN, transport); err != nil { return err } return tx.Commit() } // applyManagedCampusSnapshotTx never commits independently: signed manifests, // their checkpoint and the inherited administrator projection share one commit. func (s *Store) applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, localInstanceFQDN, transport string) error { if campus.UUID == "" || campus.FQDN == "" { return namespaceValidationError("invalid managed campus snapshot") } var authority string err := tx.QueryRow(`SELECT authority_mode FROM campuses WHERE uuid=`+s.sqlParam(1)+``, campus.UUID).Scan(&authority) if err != nil && !errors.Is(err, sql.ErrNoRows) { return err } if err == nil && authority != "managed" { return namespaceValidationError("managed Campus snapshot cannot replace a local authority") } seen := make(map[string]bool, len(domains)) for _, domain := range domains { if domain.UUID == "" || domain.CampusUUID != campus.UUID || seen[domain.UUID] { return namespaceValidationError("invalid managed domain snapshot") } seen[domain.UUID] = true var owner string err := tx.QueryRow(`SELECT campus_uuid FROM domains WHERE uuid=`+s.sqlParam(1)+``, domain.UUID).Scan(&owner) if err != nil && !errors.Is(err, sql.ErrNoRows) { return err } if err == nil && owner != campus.UUID { return namespaceValidationError("managed Campus snapshot cannot claim another Campus Domain") } } now := time.Now().Unix() _, err = tx.Exec(` INSERT INTO campuses ( uuid, name, title, default_lang, authority_mode, fqdn, controller_transport, last_contact_at, last_contact_error, enabled, created_at ) VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, 'managed', `+s.sqlParam(5)+`, `+s.sqlParam(6)+`, `+s.sqlParam(7)+`, '', 1, `+s.sqlParam(8)+`) ON CONFLICT(uuid) DO UPDATE SET name = excluded.name, title = excluded.title, default_lang = excluded.default_lang, authority_mode = 'managed', fqdn = excluded.fqdn, controller_transport = excluded.controller_transport, last_contact_at = excluded.last_contact_at, last_contact_error = '', enabled = 1 `, campus.UUID, campus.Name, campus.Title, campus.DefaultLang, campus.FQDN, transport, now, now) if err != nil { return err } if _, err = tx.Exec(` UPDATE domains SET enabled = 0 WHERE campus_uuid = `+s.sqlParam(1)+` `, campus.UUID); err != nil { return err } hasConfigTable := 1 if s.sqlBackend == storeSQLite { if err := tx.QueryRow(` SELECT count(*) FROM sqlite_master WHERE type = 'table' AND name = 'config' `).Scan(&hasConfigTable); err != nil { return err } } for _, domain := range domains { if domain.UUID == "" || domain.CampusUUID != campus.UUID { return namespaceValidationError("invalid managed domain snapshot") } placement := "remote" if normalizeDomainHost(domain.InstanceFQDN) == normalizeDomainHost(localInstanceFQDN) { placement = "local" } _, err = tx.Exec(` INSERT INTO domains ( uuid, name, title, domain, enabled, created_at, campus_uuid, placement, instance_fqdn, instance_fingerprint ) VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, `+s.sqlParam(5)+`, `+s.sqlParam(6)+`, `+s.sqlParam(7)+`, `+s.sqlParam(8)+`, `+s.sqlParam(9)+`, `+s.sqlParam(10)+`) ON CONFLICT(uuid) DO UPDATE SET name = excluded.name, title = excluded.title, domain = excluded.domain, enabled = excluded.enabled, campus_uuid = excluded.campus_uuid, placement = excluded.placement, instance_fqdn = excluded.instance_fqdn, instance_fingerprint = excluded.instance_fingerprint `, domain.UUID, domain.Name, domain.Title, domain.Domain, boolToInt(domain.Enabled), domain.CreatedAt, campus.UUID, placement, domain.InstanceFQDN, domain.InstanceFingerprint) if err != nil { return err } if hasConfigTable != 0 { if _, err = tx.Exec(` INSERT INTO config (domain_uuid, key, value, updated_at) VALUES ( `+s.sqlParam(1)+`, 'locale', CASE WHEN lower(`+s.sqlParam(2)+`) LIKE 'ja%' THEN 'ja' ELSE 'en' END, `+s.sqlParam(3)+` ) ON CONFLICT(domain_uuid, key) DO NOTHING `, domain.UUID, campus.DefaultLang, now); err != nil { return err } } } if err = s.projectCampusAdminMembershipsContext(context.Background(), tx); err != nil { return err } return nil } func boolToInt(value bool) int { if value { return 1 } return 0 } func (s *Store) RecordCampusContact( campusUUID string, contactError string, ) (resultErr error) { defer func() { resultErr = s.sqlError("RecordCampusContact", resultErr) }() if s.ReadOnly { return ErrReadOnly } lastContactAt := time.Now().Unix() if contactError != "" { lastContactAt = 0 } _, err := s.DB.Exec(` UPDATE campuses SET last_contact_at = `+s.sqlParam(1)+`, last_contact_error = `+s.sqlParam(2)+` WHERE uuid = `+s.sqlParam(3)+` AND authority_mode = 'managed' `, lastContactAt, contactError, campusUUID) return err } func (s *Store) deleteManagedCampusTx(ctx context.Context, tx *sql.Tx, id int64) error { var err error var campusUUID string if err := tx.QueryRowContext(ctx, ` SELECT uuid FROM campuses WHERE id = `+s.sqlParam(1)+` AND authority_mode = 'managed' `, id).Scan(&campusUUID); err != nil { return err } configTable := 1 if s.sqlBackend == storeSQLite { if err := tx.QueryRowContext(ctx, ` SELECT count(*) FROM sqlite_master WHERE type = 'table' AND name = 'config' `).Scan(&configTable); err != nil { return err } } if configTable > 0 { if _, err := tx.ExecContext(ctx, ` DELETE FROM config WHERE domain_uuid IN ( SELECT uuid FROM domains WHERE campus_uuid = `+s.sqlParam(1)+` ) `, campusUUID); err != nil { return err } } if _, err := tx.ExecContext(ctx, ` DELETE FROM paths WHERE domain_uuid IN ( SELECT uuid FROM domains WHERE campus_uuid = `+s.sqlParam(1)+` ) `, campusUUID); err != nil { return err } if _, err := tx.ExecContext(ctx, ` DELETE FROM domains WHERE campus_uuid = `+s.sqlParam(1)+` `, campusUUID); err != nil { return err } if err := s.deleteFederationCampusTx(ctx, tx, campusUUID); err != nil { return err } if _, err := tx.ExecContext(ctx, ` DELETE FROM campuses WHERE id = `+s.sqlParam(1)+` `, id); err != nil { return err } if err = s.projectCampusAdminMembershipsContext(ctx, tx); err != nil { return err } return nil } func (s *Store) EnsureFederationSchema() error { if s.sqlBackend == storePostgreSQL { return s.ensurePostgreSQLFederation(context.Background()) } _, err := s.DB.Exec(` CREATE TABLE IF NOT EXISTS campus_tokens ( id INTEGER PRIMARY KEY AUTOINCREMENT, campus_uuid TEXT NOT NULL, token_hash TEXT NOT NULL UNIQUE, label TEXT NOT NULL DEFAULT '', revoked INTEGER NOT NULL DEFAULT 0, created_at INTEGER NOT NULL, last_used_at INTEGER NOT NULL DEFAULT 0 ); CREATE TABLE IF NOT EXISTS federation_instances ( id INTEGER PRIMARY KEY AUTOINCREMENT, uuid TEXT NOT NULL UNIQUE, campus_uuid TEXT NOT NULL, fqdn TEXT NOT NULL, fingerprint TEXT NOT NULL, status TEXT NOT NULL DEFAULT 'pending', last_seen_at INTEGER NOT NULL, created_at INTEGER NOT NULL, UNIQUE(campus_uuid, fqdn, fingerprint) ); CREATE INDEX IF NOT EXISTS idx_federation_instances_campus ON federation_instances(campus_uuid, status, fqdn); CREATE TABLE IF NOT EXISTS federation_instance_capabilities ( instance_uuid TEXT PRIMARY KEY, manifest_version INTEGER NOT NULL ); CREATE TABLE IF NOT EXISTS federation_manifest_versions ( campus_uuid TEXT PRIMARY KEY, revision INTEGER NOT NULL, manifest_hash TEXT NOT NULL, updated_at INTEGER NOT NULL ); CREATE TABLE IF NOT EXISTS federation_manifest_state ( campus_uuid TEXT PRIMARY KEY, controller_public_key TEXT NOT NULL, controller_fingerprint TEXT NOT NULL, applied_revision INTEGER NOT NULL, manifest_json TEXT NOT NULL, applied_at INTEGER NOT NULL ); `) return err } func (s *Store) IssueCampusToken(campusUUID, label string) (_ string, resultErr error) { defer func() { resultErr = s.sqlError("IssueCampusToken", resultErr) }() if s.ReadOnly { return "", ErrReadOnly } raw := make([]byte, 32) if _, err := rand.Read(raw); err != nil { return "", err } token := "pwc_" + base64.RawURLEncoding.EncodeToString(raw) hash := sha256.Sum256([]byte(token)) err := s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error { var mode string if err := tx.QueryRowContext(ctx, `SELECT authority_mode FROM campuses WHERE uuid=`+s.sqlParam(1)+` AND enabled=1`, campusUUID).Scan(&mode); err != nil { return err } if mode != "controller" { return namespaceValidationError("campus is not a controller") } _, err := tx.ExecContext(ctx, ` INSERT INTO campus_tokens ( campus_uuid, token_hash, label, created_at ) VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`) `, campusUUID, hex.EncodeToString(hash[:]), strings.TrimSpace(label), time.Now().Unix()) return err }) if err != nil { return "", err } return token, nil } func (s *Store) ListCampusTokens() (_ []CampusToken, resultErr error) { defer func() { resultErr = s.sqlError("ListCampusTokens", resultErr) }() rows, err := s.DB.Query(` SELECT id, campus_uuid, label, revoked, created_at, last_used_at FROM campus_tokens ORDER BY created_at DESC, id DESC `) if err != nil { return nil, err } defer rows.Close() var out []CampusToken for rows.Next() { var token CampusToken var revoked int if err := rows.Scan( &token.ID, &token.CampusUUID, &token.Label, &revoked, &token.CreatedAt, &token.LastUsedAt, ); err != nil { return nil, err } token.Revoked = revoked != 0 out = append(out, token) } return out, rows.Err() } func (s *Store) RevokeCampusToken(id int64) (resultErr error) { defer func() { resultErr = s.sqlError("RevokeCampusToken", resultErr) }() if s.ReadOnly { return ErrReadOnly } return s.namespaceWrite(context.Background(), func(ctx context.Context, tx *sql.Tx) error { result, err := tx.ExecContext(ctx, `UPDATE campus_tokens SET revoked=1 WHERE id=`+s.sqlParam(1), id) if err != nil { return err } n, err := result.RowsAffected() if err != nil { return err } if n != 1 { return sql.ErrNoRows } return nil }) } func (s *Store) RegisterFederationInstance( token, fqdn, fingerprint, publicKeyRaw, signatureRaw string, capabilities ...FederationCapabilities, ) (_ *Campus, _ *FederationInstance, resultErr error) { defer func() { resultErr = s.sqlError("RegisterFederationInstance", resultErr) }() if s.ReadOnly { return nil, nil, ErrReadOnly } fqdn = normalizeDomainHost(fqdn) fingerprint = strings.ToLower(strings.TrimSpace(fingerprint)) if fqdn == "" || fingerprint == "" { return nil, nil, namespaceValidationError("FQDN and fingerprint are required") } publicKey, err := base64.RawStdEncoding.DecodeString(publicKeyRaw) if err != nil || len(publicKey) != ed25519.PublicKeySize { return nil, nil, namespaceValidationError("invalid instance public key") } publicHash := sha256.Sum256(publicKey) expectedFingerprint := "sha256:" + hex.EncodeToString(publicHash[:]) if fingerprint != expectedFingerprint { return nil, nil, namespaceValidationError("instance fingerprint does not match public key") } version := 1 if len(capabilities) > 1 { return nil, nil, namespaceValidationError("invalid capabilities") } if len(capabilities) == 1 { c := capabilities[0] if c.ManifestVersion != 0 && c.ManifestVersion != 1 && c.ManifestVersion != 2 { return nil, nil, namespaceValidationError("unsupported manifest capability") } if c.ManifestVersion == 2 { proof, e := base64.RawStdEncoding.DecodeString(c.Signature) if e != nil || !ed25519.Verify(publicKey, []byte(FederationCapabilityMessage(fqdn, token)), proof) { return nil, nil, namespaceValidationError("invalid capability signature") } version = 2 } } signature, err := base64.RawStdEncoding.DecodeString(signatureRaw) if err != nil || !ed25519.Verify( ed25519.PublicKey(publicKey), []byte(fqdn+"\n"+strings.TrimSpace(token)), signature, ) { return nil, nil, namespaceValidationError("invalid instance proof-of-possession") } hash := sha256.Sum256([]byte(strings.TrimSpace(token))) tokenHash := hex.EncodeToString(hash[:]) ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted}) if err != nil { return nil, nil, err } defer tx.Rollback() if err = s.lockFederationWrite(ctx, tx); err != nil { return nil, nil, err } var campusUUID string err = tx.QueryRow(` SELECT campus_tokens.campus_uuid FROM campus_tokens JOIN campuses ON campuses.uuid = campus_tokens.campus_uuid AND campuses.authority_mode = 'controller' AND campuses.enabled=1 WHERE campus_tokens.token_hash = `+s.sqlParam(1)+` AND campus_tokens.revoked = 0 `, tokenHash).Scan(&campusUUID) if err != nil { if errors.Is(err, sql.ErrNoRows) { return nil, nil, namespaceValidationError("invalid or revoked campus token") } return nil, nil, err } now := time.Now().Unix() var exactIdentityCount, otherFingerprintCount int if err := tx.QueryRow(` SELECT COALESCE(sum(CASE WHEN fingerprint = `+s.sqlParam(1)+` THEN 1 ELSE 0 END), 0), COALESCE(sum(CASE WHEN fingerprint != `+s.sqlParam(2)+` THEN 1 ELSE 0 END), 0) FROM federation_instances WHERE campus_uuid = `+s.sqlParam(3)+` AND fqdn = `+s.sqlParam(4)+` `, fingerprint, fingerprint, campusUUID, fqdn).Scan( &exactIdentityCount, &otherFingerprintCount, ); err != nil { return nil, nil, err } if exactIdentityCount == 0 && otherFingerprintCount > 0 { log.Printf( "WARNING federation instance fingerprint changed: campus=%s fqdn=%s new_fingerprint=%s", campusUUID, fqdn, fingerprint, ) } if _, err = tx.Exec(` UPDATE campus_tokens SET last_used_at = `+s.sqlParam(1)+` WHERE token_hash = `+s.sqlParam(2)+` `, now, tokenHash); err != nil { return nil, nil, err } if _, err = tx.Exec(` INSERT INTO federation_instances ( uuid, campus_uuid, fqdn, fingerprint, status, last_seen_at, created_at ) VALUES (`+s.sqlParam(1)+`, `+s.sqlParam(2)+`, `+s.sqlParam(3)+`, `+s.sqlParam(4)+`, 'pending', `+s.sqlParam(5)+`, `+s.sqlParam(6)+`) ON CONFLICT(campus_uuid, fqdn, fingerprint) DO UPDATE SET last_seen_at = excluded.last_seen_at `, uuid.NewString(), campusUUID, fqdn, fingerprint, now, now); err != nil { return nil, nil, err } if _, err = tx.Exec(`INSERT INTO federation_instance_capabilities(instance_uuid,manifest_version) SELECT uuid,`+s.sqlParam(1)+` FROM federation_instances WHERE campus_uuid=`+s.sqlParam(2)+` AND fqdn=`+s.sqlParam(3)+` AND fingerprint=`+s.sqlParam(4)+` ON CONFLICT(instance_uuid) DO UPDATE SET manifest_version=excluded.manifest_version`, version, campusUUID, fqdn, fingerprint); err != nil { return nil, nil, err } if err = tx.Commit(); err != nil { return nil, nil, err } campus, err := s.GetCampusByUUID(campusUUID) if err != nil { return nil, nil, err } instance, err := s.GetFederationInstance(campusUUID, fqdn, fingerprint) return campus, instance, err } type FederationCapabilities struct { ManifestVersion int Signature string } func FederationCapabilityMessage(fqdn, token string) string { return normalizeDomainHost(fqdn) + "\n" + strings.TrimSpace(token) + "\nmanifest=2" } func (s *Store) GetFederationInstance( campusUUID, fqdn, fingerprint string, ) (_ *FederationInstance, resultErr error) { defer func() { resultErr = s.sqlError("GetFederationInstance", resultErr) }() row := s.DB.QueryRow(` SELECT id, uuid, campus_uuid, fqdn, fingerprint, status, last_seen_at, created_at FROM federation_instances WHERE campus_uuid = `+s.sqlParam(1)+` AND fqdn = `+s.sqlParam(2)+` AND fingerprint = `+s.sqlParam(3)+` `, campusUUID, fqdn, fingerprint) var instance FederationInstance err := row.Scan( &instance.ID, &instance.UUID, &instance.CampusUUID, &instance.FQDN, &instance.Fingerprint, &instance.Status, &instance.LastSeenAt, &instance.CreatedAt, ) return &instance, err } func (s *Store) ListFederationInstances( campusUUID string, approvedOnly bool, ) (_ []FederationInstance, resultErr error) { defer func() { resultErr = s.sqlError("ListFederationInstances", resultErr) }() query := ` SELECT id, uuid, campus_uuid, fqdn, fingerprint, status, last_seen_at, created_at FROM federation_instances WHERE campus_uuid = ` + s.sqlParam(1) + `` if approvedOnly { query += ` AND status = 'approved'` } query += ` ORDER BY fqdn, created_at` rows, err := s.DB.Query(query, campusUUID) if err != nil { return nil, err } defer rows.Close() var out []FederationInstance for rows.Next() { var instance FederationInstance if err := rows.Scan( &instance.ID, &instance.UUID, &instance.CampusUUID, &instance.FQDN, &instance.Fingerprint, &instance.Status, &instance.LastSeenAt, &instance.CreatedAt, ); err != nil { return nil, err } out = append(out, instance) } return out, rows.Err() } func (s *Store) SetFederationInstanceStatus(id int64, status string) (resultErr error) { defer func() { resultErr = s.sqlError("SetFederationInstanceStatus", resultErr) }() if s.ReadOnly { return ErrReadOnly } if status != "approved" && status != "revoked" { return namespaceValidationError("invalid instance status") } ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second) defer cancel() tx, err := s.DB.BeginTx(ctx, &sql.TxOptions{Isolation: sql.LevelReadCommitted}) if err != nil { return err } defer tx.Rollback() if err = s.lockFederationWrite(ctx, tx); err != nil { return err } result, err := tx.Exec(` UPDATE federation_instances SET status = `+s.sqlParam(1)+` WHERE id = `+s.sqlParam(2)+` `, status, id) if err != nil { return err } affected, err := result.RowsAffected() if err != nil { return err } if affected == 0 { return sql.ErrNoRows } if status == "revoked" { if _, err := tx.Exec(` UPDATE domains SET enabled = 0 WHERE (campus_uuid, instance_fqdn, instance_fingerprint) = ( SELECT campus_uuid, fqdn, fingerprint FROM federation_instances WHERE id = `+s.sqlParam(1)+` ) `, id); err != nil { return err } } return tx.Commit() }