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.
255 lines
6.4 KiB
Go
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
|
|
}
|