150 lines
5.1 KiB
Go
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)
|
|
}
|
|
})
|
|
}
|
|
}
|