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 }