Files
pages/internal/store/federation_backend_test.go
T
2026-11-15 05:47:14 +09:00

150 lines
5.1 KiB
Go

package store
import (
"bytes"
"context"
"crypto/ed25519"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"fmt"
"testing"
)
func federationBackend(t *testing.T, b storeSQLBackend) *Store {
t.Helper()
s, _ := accountBackendStore(t, b)
if err := s.EnsureFederationSchema(); err != nil {
t.Fatal(err)
}
if b == storePostgreSQL {
if err := s.ensurePostgreSQLDomainEntry(context.Background()); err != nil {
t.Fatal(err)
}
}
s.authKey = bytes.Repeat([]byte{1}, 32)
return s
}
func TestFederationBackend(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
controller := federationBackend(t, b)
managed := federationBackend(t, b)
campus := Campus{UUID: "signed-campus", Name: "signed-campus", Title: "Campus", DefaultLang: "ja", AuthorityMode: "controller", FQDN: "campus.example.test", Enabled: true}
domains := []Domain{{UUID: "signed-domain", CampusUUID: campus.UUID, Name: "signed-domain", Title: "Domain", Domain: "blog", InstanceFQDN: "node.example.test", Enabled: true}}
manifest, err := controller.BuildSignedCampusManifest(campus, domains)
if err != nil {
t.Fatal(err)
}
apply := func(m SignedCampusManifest) error {
return managed.ApplySignedManagedCampusManifest(m, campus.UUID, "node.example.test", "https")
}
results := make(chan error, 2)
for i := 0; i < 2; i++ {
go func() { results <- apply(manifest) }()
}
for i := 0; i < 2; i++ {
if err := <-results; err != nil {
t.Fatal("duplicate first delivery", err)
}
}
d, err := managed.GetDomainByUUID("signed-domain")
if err != nil || d.Placement != "local" {
t.Fatal(d, err)
}
campus.Title = "Updated"
newer, err := controller.BuildSignedCampusManifest(campus, domains)
if err != nil || newer.Revision <= manifest.Revision {
t.Fatal(newer.Revision, err)
}
if err = apply(newer); err != nil {
t.Fatal(err)
}
if err = apply(manifest); err == nil {
t.Fatal("replay accepted")
}
tampered := newer
tampered.Campus.Title = "tampered"
if err = apply(tampered); err == nil {
t.Fatal("tamper accepted")
}
if err = managed.ApplyManagedCampusSnapshot(campus, domains, "node.example.test", "https"); err == nil {
t.Fatal("unsigned downgrade accepted")
}
// All changes roll back if the durable signed checkpoint cannot be written.
if _, err = managed.DB.Exec(`ALTER TABLE federation_manifest_state RENAME COLUMN controller_public_key TO unavailable_key`); err != nil {
t.Fatal(err)
}
campus.Title = "Must not persist"
next, err := controller.BuildSignedCampusManifest(campus, domains)
if err != nil {
t.Fatal(err)
}
if err = apply(next); err == nil {
t.Fatal("checkpoint failure ignored")
}
actual, err := managed.GetCampusByUUID(campus.UUID)
if err != nil || actual.Title != "Updated" {
t.Fatal("partial snapshot", actual, err)
}
})
}
}
func TestFederationEnrollmentBackend(t *testing.T) {
for _, b := range []storeSQLBackend{storeSQLite, storePostgreSQL} {
t.Run(fmt.Sprint(b), func(t *testing.T) {
s := federationBackend(t, b)
if err := s.CreateCampus("controller-enroll", "Controller", "ja", "controller", "controller.example.test", true); err != nil {
t.Fatal(err)
}
var campus string
if err := s.DB.QueryRow(`SELECT uuid FROM campuses WHERE name='controller-enroll'`).Scan(&campus); err != nil {
t.Fatal(err)
}
token, err := s.IssueCampusToken(campus, "synthetic")
if err != nil {
t.Fatal(err)
}
key := ed25519.NewKeyFromSeed(bytes.Repeat([]byte{2}, 32))
pub := key.Public().(ed25519.PublicKey)
hash := sha256.Sum256(pub)
fp := "sha256:" + hex.EncodeToString(hash[:])
host := "node.example.test"
sig := base64.RawStdEncoding.EncodeToString(ed25519.Sign(key, []byte(host+"\n"+token)))
cap := FederationCapabilities{ManifestVersion: 2, Signature: base64.RawStdEncoding.EncodeToString(ed25519.Sign(key, []byte(FederationCapabilityMessage(host, token))))}
register := func() (*Campus, *FederationInstance, error) {
return s.RegisterFederationInstance(token, host, fp, base64.RawStdEncoding.EncodeToString(pub), sig, cap)
}
_, instance, err := register()
if err != nil || instance.Status != "pending" {
t.Fatal(instance, err)
}
if err = s.SetFederationInstanceStatus(instance.ID, "approved"); err != nil {
t.Fatal(err)
}
if err = s.CreateDomain(campus, "enrolled", "Enrolled", "enrolled", "remote", host, fp, true); err != nil {
t.Fatal(err)
}
var id int64
if err = s.DB.QueryRow(`SELECT id FROM campus_tokens WHERE campus_uuid=`+s.sqlParam(1), campus).Scan(&id); err != nil {
t.Fatal(err)
}
if err = s.RevokeCampusToken(id); err != nil {
t.Fatal(err)
}
if _, _, err = register(); err == nil {
t.Fatal("revoked token accepted")
}
if err = s.SetFederationInstanceStatus(instance.ID, "revoked"); err != nil {
t.Fatal(err)
}
var enabled int
if err = s.DB.QueryRow(`SELECT enabled FROM domains WHERE name='enrolled'`).Scan(&enabled); err != nil || enabled != 0 {
t.Fatal(enabled, err)
}
})
}
}