Files
pages/internal/store/federation.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

596 lines
16 KiB
Go

package store
import (
"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,
) error {
if campus.UUID == "" || campus.FQDN == "" {
return errors.New("invalid managed campus snapshot")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
if _, err := tx.Exec(`UPDATE federation_manifest_state SET applied_at=applied_at WHERE campus_uuid=?`, campus.UUID); err != nil {
return err
}
var pinned int
if err := tx.QueryRow(`SELECT COUNT(*) FROM federation_manifest_state WHERE campus_uuid=?`, campus.UUID).Scan(&pinned); err != nil {
return err
}
if pinned != 0 {
return errors.New("unsigned snapshot rejected for a pinned Campus")
}
if err := 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 applyManagedCampusSnapshotTx(tx *sql.Tx, campus Campus, domains []Domain, localInstanceFQDN, transport string) error {
if campus.UUID == "" || campus.FQDN == "" {
return errors.New("invalid managed campus snapshot")
}
var authority string
err := tx.QueryRow(`SELECT authority_mode FROM campuses WHERE uuid=?`, campus.UUID).Scan(&authority)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if err == nil && authority != "managed" {
return errors.New("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 errors.New("invalid managed domain snapshot")
}
seen[domain.UUID] = true
var owner string
err := tx.QueryRow(`SELECT campus_uuid FROM domains WHERE uuid=?`, domain.UUID).Scan(&owner)
if err != nil && !errors.Is(err, sql.ErrNoRows) {
return err
}
if err == nil && owner != campus.UUID {
return errors.New("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 (?, ?, ?, ?, 'managed', ?, ?, ?, '', 1, ?)
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 = ?
`, campus.UUID); err != nil {
return err
}
var hasConfigTable int
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 errors.New("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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
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 (
?, 'locale',
CASE
WHEN lower(?) LIKE 'ja%' THEN 'ja'
ELSE 'en'
END,
strftime('%s','now')
)
ON CONFLICT(domain_uuid, key) DO NOTHING
`, domain.UUID, campus.DefaultLang); err != nil {
return err
}
}
}
if err = projectCampusAdminMembershipsTx(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,
) error {
lastContactAt := time.Now().Unix()
if contactError != "" {
lastContactAt = 0
}
_, err := s.DB.Exec(`
UPDATE campuses
SET last_contact_at = ?, last_contact_error = ?
WHERE uuid = ? AND authority_mode = 'managed'
`, lastContactAt, contactError, campusUUID)
return err
}
func (s *Store) deleteManagedCampus(id int64) error {
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
var campusUUID string
if err := tx.QueryRow(`
SELECT uuid FROM campuses
WHERE id = ? AND authority_mode = 'managed'
`, id).Scan(&campusUUID); err != nil {
return err
}
var configTable int
if err := tx.QueryRow(`
SELECT count(*) FROM sqlite_master
WHERE type = 'table' AND name = 'config'
`).Scan(&configTable); err != nil {
return err
}
if configTable > 0 {
if _, err := tx.Exec(`
DELETE FROM config
WHERE domain_uuid IN (
SELECT uuid FROM domains WHERE campus_uuid = ?
)
`, campusUUID); err != nil {
return err
}
}
if _, err := tx.Exec(`
DELETE FROM paths
WHERE domain_uuid IN (
SELECT uuid FROM domains WHERE campus_uuid = ?
)
`, campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM domains WHERE campus_uuid = ?
`, campusUUID); err != nil {
return err
}
if _, err := tx.Exec(`
DELETE FROM campuses WHERE id = ?
`, id); err != nil {
return err
}
if err = projectCampusAdminMembershipsTx(tx); err != nil {
return err
}
return tx.Commit()
}
func (s *Store) EnsureFederationSchema() error {
_, 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, error) {
campus, err := s.GetCampusByUUID(campusUUID)
if err != nil {
return "", err
}
if campus.AuthorityMode != "controller" {
return "", errors.New("campus is not a controller")
}
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.DB.Exec(`
INSERT INTO campus_tokens (
campus_uuid, token_hash, label, created_at
)
VALUES (?, ?, ?, ?)
`, campusUUID, hex.EncodeToString(hash[:]), strings.TrimSpace(label), time.Now().Unix())
if err != nil {
return "", err
}
return token, nil
}
func (s *Store) ListCampusTokens() ([]CampusToken, error) {
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) error {
result, err := s.DB.Exec(`
UPDATE campus_tokens SET revoked = 1 WHERE id = ?
`, id)
if err != nil {
return err
}
affected, err := result.RowsAffected()
if err != nil {
return err
}
if affected == 0 {
return sql.ErrNoRows
}
return nil
}
func (s *Store) RegisterFederationInstance(
token, fqdn, fingerprint, publicKeyRaw, signatureRaw string,
capabilities ...FederationCapabilities,
) (*Campus, *FederationInstance, error) {
fqdn = normalizeDomainHost(fqdn)
fingerprint = strings.ToLower(strings.TrimSpace(fingerprint))
if fqdn == "" || fingerprint == "" {
return nil, nil, errors.New("FQDN and fingerprint are required")
}
publicKey, err := base64.RawStdEncoding.DecodeString(publicKeyRaw)
if err != nil || len(publicKey) != ed25519.PublicKeySize {
return nil, nil, errors.New("invalid instance public key")
}
publicHash := sha256.Sum256(publicKey)
expectedFingerprint := "sha256:" + hex.EncodeToString(publicHash[:])
if fingerprint != expectedFingerprint {
return nil, nil, errors.New("instance fingerprint does not match public key")
}
version := 1
if len(capabilities) > 1 {
return nil, nil, errors.New("invalid capabilities")
}
if len(capabilities) == 1 {
c := capabilities[0]
if c.ManifestVersion != 0 && c.ManifestVersion != 1 && c.ManifestVersion != 2 {
return nil, nil, errors.New("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, errors.New("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, errors.New("invalid instance proof-of-possession")
}
hash := sha256.Sum256([]byte(strings.TrimSpace(token)))
tokenHash := hex.EncodeToString(hash[:])
var campusUUID string
err = s.DB.QueryRow(`
SELECT campus_tokens.campus_uuid
FROM campus_tokens
JOIN campuses
ON campuses.uuid = campus_tokens.campus_uuid
AND campuses.authority_mode = 'controller'
WHERE campus_tokens.token_hash = ?
AND campus_tokens.revoked = 0
`, tokenHash).Scan(&campusUUID)
if err != nil {
if errors.Is(err, sql.ErrNoRows) {
return nil, nil, errors.New("invalid or revoked campus token")
}
return nil, nil, err
}
now := time.Now().Unix()
var exactIdentityCount, otherFingerprintCount int
if err := s.DB.QueryRow(`
SELECT
COALESCE(sum(CASE WHEN fingerprint = ? THEN 1 ELSE 0 END), 0),
COALESCE(sum(CASE WHEN fingerprint != ? THEN 1 ELSE 0 END), 0)
FROM federation_instances
WHERE campus_uuid = ? AND fqdn = ?
`, 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,
)
}
tx, err := s.DB.Begin()
if err != nil {
return nil, nil, err
}
defer tx.Rollback()
if _, err = tx.Exec(`
UPDATE campus_tokens SET last_used_at = ? WHERE token_hash = ?
`, 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 (?, ?, ?, ?, 'pending', ?, ?)
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,? FROM federation_instances WHERE campus_uuid=? AND fqdn=? AND fingerprint=? 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, error) {
row := s.DB.QueryRow(`
SELECT id, uuid, campus_uuid, fqdn, fingerprint, status,
last_seen_at, created_at
FROM federation_instances
WHERE campus_uuid = ? AND fqdn = ? AND fingerprint = ?
`, 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, error) {
query := `
SELECT id, uuid, campus_uuid, fqdn, fingerprint, status,
last_seen_at, created_at
FROM federation_instances
WHERE campus_uuid = ?`
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) error {
if status != "approved" && status != "revoked" {
return errors.New("invalid instance status")
}
tx, err := s.DB.Begin()
if err != nil {
return err
}
defer tx.Rollback()
result, err := tx.Exec(`
UPDATE federation_instances SET status = ? WHERE id = ?
`, 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 = ?
)
`, id); err != nil {
return err
}
}
return tx.Commit()
}