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