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.
596 lines
16 KiB
Go
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()
|
|
}
|