Files
pages/cmd/pageswiki/federation_enroll.go
T
Anya Tokugawa c1175d389f Implement Knowledge City platform, organizer and DAV integration
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.
2026-09-27 14:44:43 +09:00

255 lines
6.4 KiB
Go

package main
import (
"bytes"
"crypto/ed25519"
"crypto/rand"
"crypto/sha256"
"encoding/base64"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io"
"net/http"
"os"
"path/filepath"
"strings"
"time"
"pageswiki/internal/store"
)
type externalCampusEnrollment struct {
FQDN string
Token string
HTTP bool
NoDefaultCampus bool
}
type campusEnrollmentSnapshot struct {
Campus store.Campus
Instance store.FederationInstance
Domains []store.Domain
Manifest store.SignedCampusManifest `json:"manifest"`
}
func parseExternalCampusEnrollment(args []string) (*externalCampusEnrollment, error) {
if len(args) == 0 {
return nil, nil
}
noDefaultCampus := false
filtered := make([]string, 0, len(args))
for _, arg := range args {
if arg == "--no-default-campus" {
if noDefaultCampus {
return nil, errors.New("--no-default-campus was specified twice")
}
noDefaultCampus = true
continue
}
filtered = append(filtered, arg)
}
if len(filtered) != 3 ||
(filtered[0] != "--add-external-campus" &&
filtered[0] != "--add-external-campus-http") {
return nil, errors.New(
"usage: pageswiki [--no-default-campus] " +
"[--add-external-campus FQDN TOKEN | " +
"--add-external-campus-http FQDN TOKEN]",
)
}
return &externalCampusEnrollment{
FQDN: strings.TrimSpace(filtered[1]),
Token: strings.TrimSpace(filtered[2]),
HTTP: filtered[0] == "--add-external-campus-http",
NoDefaultCampus: noDefaultCampus,
}, nil
}
func enrollExternalCampus(
dataDir string,
st *store.Store,
enrollment *externalCampusEnrollment,
) error {
if enrollment == nil {
return nil
}
instanceFQDN := strings.TrimSpace(os.Getenv("PAGESWIKI_INSTANCE_FQDN"))
if instanceFQDN == "" {
return errors.New(
"PAGESWIKI_INSTANCE_FQDN is required for external Campus enrollment",
)
}
snapshot, scheme, err := fetchCampusSnapshot(
dataDir,
enrollment,
instanceFQDN,
)
if err != nil {
return err
}
if err := applyEnrollmentSnapshot(st, snapshot, "", instanceFQDN, scheme); err != nil {
return err
}
if err := saveCampusEnrollment(
dataDir,
snapshot.Campus.UUID,
enrollment,
); err != nil {
return err
}
if enrollment.NoDefaultCampus {
_, err = st.RemoveUnusedBootstrapCampus()
}
return err
}
func applyEnrollmentSnapshot(st *store.Store, snapshot *campusEnrollmentSnapshot, expectedCampusUUID, instanceFQDN, scheme string) error {
if snapshot.Manifest.SchemaVersion != 0 {
return st.ApplySignedManagedCampusManifest(snapshot.Manifest, expectedCampusUUID, instanceFQDN, scheme)
}
// Transitional compatibility for pre-manifest controllers. New controllers
// always emit a signed manifest; this branch can be removed after upgrades.
return st.ApplyManagedCampusSnapshot(snapshot.Campus, snapshot.Domains, instanceFQDN, scheme)
}
func fetchCampusSnapshot(
dataDir string,
enrollment *externalCampusEnrollment,
instanceFQDN string,
) (*campusEnrollmentSnapshot, string, error) {
privateKey, fingerprint, err := ensureInstanceIdentity(dataDir)
if err != nil {
return nil, "", err
}
payload, err := json.Marshal(map[string]any{
"manifest_version": 2,
"capability_signature": base64.RawStdEncoding.EncodeToString(ed25519.Sign(privateKey, []byte(store.FederationCapabilityMessage(instanceFQDN, enrollment.Token)))),
"fqdn": instanceFQDN,
"fingerprint": fingerprint,
"public_key": base64.RawStdEncoding.EncodeToString(
privateKey.Public().(ed25519.PublicKey),
),
"signature": base64.RawStdEncoding.EncodeToString(
ed25519.Sign(
privateKey,
[]byte(instanceFQDN+"\n"+enrollment.Token),
),
),
})
if err != nil {
return nil, "", err
}
scheme := "https"
if enrollment.HTTP {
scheme = "http"
}
endpoint := fmt.Sprintf(
"%s://%s/_/api/v1/federation/enroll",
scheme,
enrollment.FQDN,
)
request, err := http.NewRequest(
http.MethodPost,
endpoint,
bytes.NewReader(payload),
)
if err != nil {
return nil, "", err
}
request.Header.Set("Content-Type", "application/json")
request.Header.Set("Authorization", "Bearer "+enrollment.Token)
client := &http.Client{Timeout: 20 * time.Second}
response, err := client.Do(request)
if err != nil {
return nil, "", err
}
defer response.Body.Close()
if response.StatusCode != http.StatusOK {
message, _ := io.ReadAll(io.LimitReader(response.Body, 4<<10))
detail := strings.TrimSpace(string(message))
if detail != "" {
return nil, "", fmt.Errorf(
"Campus controller enrollment failed: %s: %s",
response.Status,
detail,
)
}
return nil, "", fmt.Errorf(
"Campus controller enrollment failed: %s",
response.Status,
)
}
var snapshot campusEnrollmentSnapshot
if err := json.NewDecoder(response.Body).Decode(&snapshot); err != nil {
return nil, "", err
}
return &snapshot, scheme, nil
}
func saveCampusEnrollment(
dataDir string,
campusUUID string,
enrollment *externalCampusEnrollment,
) error {
tokenDir := filepath.Join(dataDir, "federation")
if err := os.MkdirAll(tokenDir, 0700); err != nil {
return err
}
tokenPath := filepath.Join(tokenDir, campusUUID+".token")
if err := os.WriteFile(
tokenPath,
[]byte(enrollment.Token+"\n"),
0600,
); err != nil {
return err
}
if enrollment.NoDefaultCampus {
markerPath := filepath.Join(
tokenDir,
campusUUID+".no-default-campus",
)
if err := os.WriteFile(markerPath, nil, 0600); err != nil {
return err
}
}
scheme := "https"
if enrollment.HTTP {
scheme = "http"
}
endpointPath := filepath.Join(tokenDir, campusUUID+".endpoint")
return os.WriteFile(
endpointPath,
[]byte(scheme+"://"+enrollment.FQDN+"\n"),
0600,
)
}
func ensureInstanceIdentity(
dataDir string,
) (ed25519.PrivateKey, string, error) {
keyPath := filepath.Join(dataDir, "instance-ed25519.key")
privateKey, err := os.ReadFile(keyPath)
if errors.Is(err, os.ErrNotExist) {
_, generated, generateErr := ed25519.GenerateKey(rand.Reader)
if generateErr != nil {
return nil, "", generateErr
}
if writeErr := os.WriteFile(keyPath, generated, 0600); writeErr != nil {
return nil, "", writeErr
}
privateKey = generated
} else if err != nil {
return nil, "", err
}
if len(privateKey) != ed25519.PrivateKeySize {
return nil, "", errors.New("invalid instance Ed25519 private key")
}
publicKey := ed25519.PrivateKey(privateKey).Public().(ed25519.PublicKey)
sum := sha256.Sum256(publicKey)
return ed25519.PrivateKey(privateKey),
"sha256:" + hex.EncodeToString(sum[:]),
nil
}