Files
2026-11-15 05:47:14 +09:00

649 lines
20 KiB
Go

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()
}