gates / gates (push) Successful in 41s
Built, not released; no box has run it. felhom.eu `07-backup-architecture.md` §8.2f.
It does nothing without a hub that knows it: an older hub agrees to no id.
- The record: settings `offsite_ends` {app, removed_at, ends_at}. One writer
(backup.StartOffsiteEnd), called by a removal only with „delete backup data”
and by „Törlés 30 nap múlva” on the restore page. A second press changes
nothing. No record, no deletion. Only on the hub-provisioned tier.
- The date is on the remove dialog before the press; the restore page shows
„Törlésre kijelölve …” with „Mégis megtartom”, and one history line per
carried-out end. An install of the same app deletes the record.
- The weekly window: after the guard has passed the policy's plan under the cap
as before, it adds the snapshots whose app tags are ALL due records, that the
hub agreed to and the box named in the same request; the result names them
apart (removed_for_ended_apps). `_shares`, the box's own stacks and an
installed app are never due.
- The report carries the pending records; the household gets one mail per
press (offsite_end_scheduled), in both languages.
MinAgent unchanged (0.158.1). 143 parity fixtures gained the dialog's one new
script line (patched, not regenerated); one new parity case.
Tests TestD72_*, TestD84_*; 56 mutations seen red
(felhom.eu documentation/audits/build-release-4-2026-11-15/A/redproof-ctrl-*.txt).
Claude-Session: https://claude.ai/code/session_0159rPz1ZhFKsS53msqPYxtS
345 lines
12 KiB
Go
345 lines
12 KiB
Go
package offsiteapply
|
|
|
|
import (
|
|
"context"
|
|
"crypto/ed25519"
|
|
"encoding/json"
|
|
"encoding/pem"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"net/http"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"gitea.dooplex.hu/admin/felhom-controller/internal/backup"
|
|
"golang.org/x/crypto/ssh"
|
|
"golang.org/x/crypto/ssh/knownhosts"
|
|
)
|
|
|
|
// --- func adapters (convenient wiring in main.go) ---
|
|
|
|
type EnablerFunc func(ctx context.Context, host, user string, port int, repoPath, privPEM, knownHosts string, quotaGB int) error
|
|
|
|
func (f EnablerFunc) ConfigureOffbox(ctx context.Context, host, user string, port int, repoPath, privPEM, knownHosts string, quotaGB int) error {
|
|
return f(ctx, host, user, port, repoPath, privPEM, knownHosts, quotaGB)
|
|
}
|
|
|
|
// SettleFunc adapts a plain func to a SettleProvider (thin adapter over the Updater in main.go —
|
|
// the StackDataProvider pattern). It reads the updater's OWN knowledge; the bridge never fetches the
|
|
// floor a second way (no second floor path).
|
|
type SettleFunc func() (version, floor string, updateRunning, floorKnown bool)
|
|
|
|
func (f SettleFunc) SettleState() (string, string, bool, bool) { return f() }
|
|
|
|
// --- HubRegistrar: the box's half of the hub key registrar (decision 69, hub >= v0.127.0) ---
|
|
//
|
|
// The box sends ONLY its public key; the hub writes it into the Storage Box sub-account's
|
|
// authorized_keys pinned to `rclone serve restic --stdio --append-only <repo>`. Until controller
|
|
// v0.289.0 the box fetched the sub-account PASSWORD here (consume-password) — and that password can
|
|
// rewrite authorized_keys, i.e. remove the pin (measured 2026-10-03, R-820). No response this client
|
|
// reads can carry a password; TestHubRegistrar_NeverAsksForAPassword pins the paths it calls.
|
|
type HubRegistrar struct {
|
|
HubURL string
|
|
CustomerID string
|
|
APIKey string
|
|
HC *http.Client
|
|
}
|
|
|
|
func (c HubRegistrar) post(ctx context.Context, path string, body any) ([]byte, error) {
|
|
if c.HubURL == "" || c.CustomerID == "" || c.APIKey == "" {
|
|
return nil, fmt.Errorf("offsite-apply: hub url/customer/apikey not configured")
|
|
}
|
|
hc := c.HC
|
|
if hc == nil {
|
|
hc = &http.Client{Timeout: 3 * time.Minute} // the hub does an SSH round trip to the provider
|
|
}
|
|
var rd io.Reader
|
|
if body != nil {
|
|
b, err := json.Marshal(body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
rd = strings.NewReader(string(b))
|
|
}
|
|
url := strings.TrimRight(c.HubURL, "/") + "/api/v1/offsite/" + path + "/" + c.CustomerID
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, rd)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
req.Header.Set("Authorization", "Bearer "+c.APIKey)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
resp, err := hc.Do(req)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer resp.Body.Close()
|
|
raw, _ := io.ReadAll(io.LimitReader(resp.Body, 1<<16))
|
|
if resp.StatusCode < 200 || resp.StatusCode >= 300 {
|
|
return nil, fmt.Errorf("hub %s: HTTP %d: %s", path, resp.StatusCode, truncate(raw))
|
|
}
|
|
return raw, nil
|
|
}
|
|
|
|
// Register asks the hub to install pub pinned append-only; returns the key's fingerprint as the hub saw it.
|
|
func (c HubRegistrar) Register(ctx context.Context, pub string) (string, error) {
|
|
raw, err := c.post(ctx, "register-key", map[string]string{"public_key": strings.TrimSpace(pub)})
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var r struct {
|
|
Installed bool `json:"installed"`
|
|
Fingerprint string `json:"fingerprint"`
|
|
}
|
|
if err := json.Unmarshal(raw, &r); err != nil || !r.Installed || r.Fingerprint == "" {
|
|
return "", fmt.Errorf("hub register-key: malformed response")
|
|
}
|
|
return r.Fingerprint, nil
|
|
}
|
|
|
|
// Confirm tells the hub the box now uses fp; the hub removes every other key line.
|
|
func (c HubRegistrar) Confirm(ctx context.Context, fp string) error {
|
|
_, err := c.post(ctx, "confirm-key", map[string]string{"fingerprint": fp})
|
|
return err
|
|
}
|
|
|
|
// MoveAside asks the hub to set the repository aside (never deletes) — the box's pinned key cannot.
|
|
func (c HubRegistrar) MoveAside(ctx context.Context) (string, error) {
|
|
raw, err := c.post(ctx, "move-aside", nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var r struct {
|
|
MovedTo string `json:"moved_to"`
|
|
}
|
|
if err := json.Unmarshal(raw, &r); err != nil || r.MovedTo == "" {
|
|
return "", fmt.Errorf("hub move-aside: malformed response")
|
|
}
|
|
return r.MovedTo, nil
|
|
}
|
|
|
|
// --- HubWindowClient: the box's half of the clean-up window (decision 68) ---
|
|
|
|
type HubWindowClient struct{ Registrar HubRegistrar }
|
|
|
|
func (c HubWindowClient) Open(ctx context.Context, countBefore int, ended []backup.OffsiteEndedClaim) (backup.OffsiteWindow, error) {
|
|
// D72/D84: the due end records ride the same request; `ended` is left out when there is none, so the body an
|
|
// older hub sees is the one it always saw.
|
|
req := struct {
|
|
CountBefore int `json:"count_before"`
|
|
Ended []backup.OffsiteEndedClaim `json:"ended,omitempty"`
|
|
}{CountBefore: countBefore, Ended: ended}
|
|
raw, err := c.Registrar.post(ctx, "window-open", req)
|
|
if err != nil {
|
|
return backup.OffsiteWindow{}, err
|
|
}
|
|
var r struct {
|
|
Granted bool `json:"granted"`
|
|
WindowID int64 `json:"window_id"`
|
|
NewestAllowed string `json:"newest_allowed"`
|
|
MaxRemove int `json:"max_remove"`
|
|
Reason string `json:"reason"`
|
|
EndedAllowed []string `json:"ended_allowed"`
|
|
EndedRefused []backup.OffsiteEndedRefusal `json:"ended_refused"`
|
|
}
|
|
if err := json.Unmarshal(raw, &r); err != nil {
|
|
return backup.OffsiteWindow{}, fmt.Errorf("hub window-open: malformed response")
|
|
}
|
|
w := backup.OffsiteWindow{Granted: r.Granted, ID: r.WindowID, MaxRemove: r.MaxRemove, Reason: r.Reason}
|
|
if r.Granted {
|
|
t, perr := time.Parse(time.RFC3339, r.NewestAllowed)
|
|
if perr != nil {
|
|
return backup.OffsiteWindow{}, fmt.Errorf("hub window-open: bad newest_allowed")
|
|
}
|
|
w.NewestAllowed = t
|
|
// Only a GRANTED window carries an agreement.
|
|
w.EndedAllowed, w.EndedRefused = r.EndedAllowed, r.EndedRefused
|
|
}
|
|
return w, nil
|
|
}
|
|
|
|
func (c HubWindowClient) Close(ctx context.Context, res backup.OffsiteWindowResult) error {
|
|
_, err := c.Registrar.post(ctx, "window-close", res)
|
|
return err
|
|
}
|
|
|
|
// --- HubAbandonClient: the box's half of the hub's set-aside deletion (decision 74) ---
|
|
|
|
type HubAbandonClient struct{ Registrar HubRegistrar }
|
|
|
|
func (c HubAbandonClient) Request(ctx context.Context, path string) (time.Time, error) {
|
|
raw, err := c.Registrar.post(ctx, "abandon-request", map[string]string{"path": path})
|
|
if err != nil {
|
|
return time.Time{}, err
|
|
}
|
|
var r struct {
|
|
State string `json:"state"`
|
|
DueAt string `json:"due_at"`
|
|
}
|
|
if err := json.Unmarshal(raw, &r); err != nil || r.State != "pending" {
|
|
return time.Time{}, fmt.Errorf("hub abandon-request: unexpected answer (state %q)", r.State)
|
|
}
|
|
t, err := time.Parse(time.RFC3339, r.DueAt)
|
|
if err != nil {
|
|
return time.Time{}, fmt.Errorf("hub abandon-request: bad due_at")
|
|
}
|
|
return t, nil
|
|
}
|
|
|
|
func (c HubAbandonClient) Status(ctx context.Context) (string, error) {
|
|
raw, err := c.Registrar.post(ctx, "abandon-status", nil)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
var r struct {
|
|
State string `json:"state"`
|
|
}
|
|
if err := json.Unmarshal(raw, &r); err != nil || r.State == "" {
|
|
return "", fmt.Errorf("hub abandon-status: malformed")
|
|
}
|
|
return r.State, nil
|
|
}
|
|
|
|
func (c HubAbandonClient) Cancel(ctx context.Context) error {
|
|
_, err := c.Registrar.post(ctx, "abandon-cancel", nil)
|
|
return err
|
|
}
|
|
|
|
// --- KeyscanScanner: capture the box host key (x/crypto/ssh, no binary) → fingerprint + known_hosts line ---
|
|
|
|
type KeyscanScanner struct {
|
|
Timeout time.Duration
|
|
}
|
|
|
|
var errScanCaptured = errors.New("host key captured")
|
|
|
|
func (s KeyscanScanner) Scan(ctx context.Context, host string, port int) (string, string, error) {
|
|
timeout := s.Timeout
|
|
if timeout == 0 {
|
|
timeout = 10 * time.Second
|
|
}
|
|
var fp, line string
|
|
cfg := &ssh.ClientConfig{
|
|
User: "felhom-keyscan",
|
|
Timeout: timeout,
|
|
HostKeyCallback: func(_ string, _ net.Addr, key ssh.PublicKey) error {
|
|
fp = ssh.FingerprintSHA256(key)
|
|
line = knownhosts.Line([]string{knownhosts.Normalize(net.JoinHostPort(host, strconv.Itoa(port)))}, key)
|
|
return errScanCaptured
|
|
},
|
|
}
|
|
d := net.Dialer{Timeout: timeout}
|
|
conn, err := d.DialContext(ctx, "tcp", net.JoinHostPort(host, strconv.Itoa(port)))
|
|
if err != nil {
|
|
return "", "", fmt.Errorf("dial: %w", err)
|
|
}
|
|
defer conn.Close()
|
|
c, _, _, herr := ssh.NewClientConn(conn, host, cfg)
|
|
if c != nil {
|
|
c.Close()
|
|
}
|
|
if fp != "" && line != "" {
|
|
return fp, line, nil
|
|
}
|
|
return "", "", fmt.Errorf("host-key handshake: %w", herr)
|
|
}
|
|
|
|
// --- ED25519KeyGen: a fresh keypair (OpenSSH private PEM + authorized_keys pub line) ---
|
|
|
|
type ED25519KeyGen struct{}
|
|
|
|
func (ED25519KeyGen) Generate() (string, string, error) {
|
|
pub, priv, err := ed25519.GenerateKey(nil)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
block, err := ssh.MarshalPrivateKey(priv, "felhom-offbox")
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
sshPub, err := ssh.NewPublicKey(pub)
|
|
if err != nil {
|
|
return "", "", err
|
|
}
|
|
privPEM := string(pem.EncodeToMemory(block))
|
|
pubLine := string(ssh.MarshalAuthorizedKey(sshPub)) // includes trailing newline
|
|
return privPEM, pubLine, nil
|
|
}
|
|
|
|
// --- PinnedProber: does this key reach the PINNED append-only server? ---
|
|
//
|
|
// Measured on the provider 2026-10-03 (audits/offsite-lock-build-2026-10-03/partA/A5): `ssh -i <key>
|
|
// host probe` with stdin closed exits 0 and prints rclone's NOTICE when the key is pinned (the forced
|
|
// rclone starts, sees EOF, exits); an UNPINNED key gets the restricted shell → "Command not found",
|
|
// exit 8. A refused key exits 255. So ok = exit 0 AND "rclone" in the output — a POSITIVE observable.
|
|
type PinnedProber struct {
|
|
Timeout time.Duration // 0 → 20 s
|
|
// Run is the exec seam (tests); nil → real ssh.
|
|
Run func(ctx context.Context, args []string) ([]byte, error)
|
|
}
|
|
|
|
func (p PinnedProber) Probe(ctx context.Context, host, user string, port int, knownHosts, privPEM string) bool {
|
|
if strings.TrimSpace(privPEM) == "" {
|
|
return false
|
|
}
|
|
timeout := p.Timeout
|
|
if timeout == 0 {
|
|
timeout = 20 * time.Second
|
|
}
|
|
pctx, cancel := context.WithTimeout(ctx, timeout)
|
|
defer cancel()
|
|
work, err := os.MkdirTemp("", "felhom-keyprobe-")
|
|
if err != nil {
|
|
return false
|
|
}
|
|
defer os.RemoveAll(work)
|
|
khPath, keyPath := filepath.Join(work, "known_hosts"), filepath.Join(work, "id")
|
|
if os.WriteFile(khPath, []byte(knownHosts+"\n"), 0o600) != nil || os.WriteFile(keyPath, []byte(privPEM), 0o600) != nil {
|
|
return false
|
|
}
|
|
args := []string{"-p", strconv.Itoa(port), "-i", keyPath, "-oBatchMode=yes", "-oConnectTimeout=10", "-oIdentitiesOnly=yes",
|
|
"-oStrictHostKeyChecking=yes", "-oUserKnownHostsFile=" + khPath, user + "@" + host, "probe"}
|
|
run := p.Run
|
|
if run == nil {
|
|
run = func(ctx context.Context, args []string) ([]byte, error) {
|
|
cmd := exec.CommandContext(ctx, "ssh", args...)
|
|
cmd.Stdin = strings.NewReader("")
|
|
return cmd.CombinedOutput()
|
|
}
|
|
}
|
|
out, err := run(pctx, args)
|
|
return err == nil && strings.Contains(string(out), "rclone")
|
|
}
|
|
|
|
// PublicKeyOf derives the authorized_keys line of an OpenSSH private key (the migration path: a box
|
|
// whose key predates the pin registers the SAME key, so the hub re-writes it pinned).
|
|
func PublicKeyOf(privPEM string) (string, error) {
|
|
signer, err := ssh.ParsePrivateKey([]byte(privPEM))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return string(ssh.MarshalAuthorizedKey(signer.PublicKey())), nil
|
|
}
|
|
|
|
// FingerprintOf returns the SHA256 fingerprint of an authorized_keys line.
|
|
func FingerprintOf(pub string) (string, error) {
|
|
pk, _, _, _, err := ssh.ParseAuthorizedKey([]byte(pub))
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return ssh.FingerprintSHA256(pk), nil
|
|
}
|
|
|
|
func truncate(b []byte) string {
|
|
s := strings.TrimSpace(string(b))
|
|
if len(s) > 300 {
|
|
return s[:300] + "…"
|
|
}
|
|
return s
|
|
}
|