3fe2c0660a
End-to-end direct-ssh-direct: two LibrePortal instances exchange pairing
tokens, each authorizes the other to call a locked-down peer-shell dispatcher
via SSH forced-command, then either side can pull live app data from the
other without needing a shared backup repo.
Push and Connect-via-relay are deferred — push is symmetric to pull (same
forced-command, opposite verb), and the relay variant waits for Connect to
actually exist (config_json + kind enum already future-proofed in Phase 2).
Key generation (peer_key.sh):
One ed25519 keypair per install at ~<manager>/.ssh/libreportal-peer{,.pub}.
Generated lazily on the first peer-related call. Used as our outbound
SSH identity AND as the pubkey other instances authorize.
Forced-command dispatcher (peer_shell.sh):
Standalone script, deployed by peerInstallShell() to
~<manager>/.local/bin/peer-shell. authorized_keys entries look like:
command="~/.local/bin/peer-shell <peer-name>",no-pty,no-port-forwarding,
no-X11-forwarding,no-agent-forwarding,no-user-rc ssh-ed25519 AAAA… peer:<name>
sshd hands us $SSH_ORIGINAL_COMMAND; we parse, whitelist the verb, and
refuse anything else. Verbs:
ping Liveness probe (JSON ok:true).
list-apps JSON {peer, apps:[{slug, size_kb}]}.
stream-app tar of containers_dir/<slug> to stdout (slug strictly
validated — lowercase alnum+dash; rejects path traversal).
Audit log appended to ~/.local/state/libreportal/peer-shell.log. Excluded
from the generated source arrays (would crash any sourcing shell on empty
SSH_ORIGINAL_COMMAND); generate_arrays.sh skip-list extended.
Pairing token (peer_pairing.sh):
Format: lp-peer|v1|<name>|<user>|<host>|<port>|<base64-pubkey>|<fingerprint>
Pipe-delimited because the SHA256 fingerprint and base64 pubkey both
contain ':'. peerPairingParse decodes + re-derives the fingerprint from
the actual key, refusing tokens with mismatched fingerprints (catches
truncation / tampering). peerPairingAccept:
1. Installs peer-shell (peerInstallShell).
2. Appends to authorized_keys with the lockdown options above.
3. Inserts a peers row (kind=direct-ssh-direct, config carries host,
port, user, fingerprint).
Symmetric — user runs accept on BOTH sides with the other's token to
enable bidirectional calls.
Outbound SSH (peer_remote.sh):
peerExec <name> <verb> [args] — looks up the peer's connection config and
ssh's in with the right key, BatchMode + ConnectTimeout + accept-new for
the host key. peerPing wraps it and updates peers.status + last_seen.
Pull-an-app (peer_pull.sh):
peerPullApp <peer> <app> [--no-pre-backup] [--keep-urls]
1. peerPing (refuse if unreachable).
2. migratePreBackupDestination (reuses the Phase 0 safety wrapper —
same restic-tagged pre-migrate snapshot as the backup-channel flow).
3. Stop + wipe destination's app folder.
4. peerExec stream-app | tar -x (pipefail; bails on partial transfers).
5. migrateApplyUrlRewrite + dockerComposeUpdateAndStartApp install
(URL repointing, idempotent install path).
6. dockerComposeUp + post-restore hooks.
Identical Stage-2..6 to migrateApplyApp; only the data source differs
(tar-over-SSH instead of restic-restore).
CLI (cli_peer_commands.sh + header):
libreportal peer token — emit this host's pairing token
libreportal peer pair <token> [name] — accept a token (override name)
libreportal peer apps <peer> — live peer-shell list-apps
libreportal peer pull <peer> <app> [--no-pre-backup] [--keep-urls]
WebUI (/peers):
Header gains 'Show my token' and 'Pair with token' buttons (both open
modals around the matching CLI verbs). Token modal warns the user that
the token is credentials. Pair modal accepts a free-form override name.
Direct-SSH peer cards gain a 'List apps' button that opens an inline
drawer showing the peer's live app inventory (via peer apps) with per-
app 'Pull' buttons. Pull modal has the same two safety toggles as the
Migrate tab (pre-backup ON, URL rewrite ON by default).
Backup-channel manual-add modal kept; direct-SSH must use the token flow.
Smoke-tested:
- All 16 peer-subsystem functions register without crashing the shell.
- peer-shell ping ⇒ {ok:true}; unknown-verb refused; path-traversal slug
refused; valid-slug streams.
- Token emit→parse round-trip preserves every field; garbage rejected
with not-a-token; v99 rejected with unsupported-version.
Signed-off-by: librelad <librelad@digitalangels.vip>
83 lines
2.8 KiB
Bash
83 lines
2.8 KiB
Bash
#!/bin/bash
|
|
|
|
# Receiver-side helpers: invoke peer-shell over SSH and consume its output.
|
|
# These run on the local instance (the one initiating the pull) and connect
|
|
# OUT to a direct-ssh-direct peer using the keypair from peerKeyEnsure.
|
|
|
|
# Inner: SSH options. Strict key check is on; the peer's host key gets
|
|
# learned/stored in ~/.ssh/known_hosts on first connection. Future hardening
|
|
# could bind to the fingerprint we stored at pairing time.
|
|
_peerSshOpts()
|
|
{
|
|
local priv; priv="${HOME}/.ssh/libreportal-peer"
|
|
echo "-i" "$priv" "-o" "BatchMode=yes" "-o" "StrictHostKeyChecking=accept-new" \
|
|
"-o" "PasswordAuthentication=no" "-o" "ConnectTimeout=10"
|
|
}
|
|
|
|
# Read a peer's connection config from its peers row.
|
|
# Echos: "<user>@<host> <port>" or empty on miss.
|
|
_peerSshTarget()
|
|
{
|
|
local peer_name="$1"
|
|
local row; row=$(peerGet "$peer_name")
|
|
[[ -z "$row" || "$row" == "null" ]] && return 1
|
|
local host port user
|
|
host=$(printf '%s' "$row" | grep -o '"host":"[^"]*"' | head -1 | cut -d'"' -f4)
|
|
port=$(printf '%s' "$row" | grep -o '"port":[0-9]*' | head -1 | cut -d':' -f2)
|
|
user=$(printf '%s' "$row" | grep -o '"user":"[^"]*"' | head -1 | cut -d'"' -f4)
|
|
[[ -z "$host" || -z "$user" ]] && return 1
|
|
[[ -z "$port" ]] && port=22
|
|
printf '%s@%s %s\n' "$user" "$host" "$port"
|
|
}
|
|
|
|
# peerExec <peer-name> <verb> [args...]
|
|
# Runs `peer-shell <verb> <args>` on the peer over SSH and prints its output.
|
|
# Returns the SSH exit status.
|
|
peerExec()
|
|
{
|
|
local peer_name="$1"; shift
|
|
local target; target=$(_peerSshTarget "$peer_name") || {
|
|
isError "Peer '$peer_name' has no SSH connection config"
|
|
return 1
|
|
}
|
|
local user_host port
|
|
read -r user_host port <<< "$target"
|
|
|
|
# The remote side has the forced-command in authorized_keys, so what we
|
|
# type after `ssh user@host` is ignored as a command and passed as
|
|
# $SSH_ORIGINAL_COMMAND. Stringify the verb + args.
|
|
local remote_cmd="$*"
|
|
ssh $(_peerSshOpts) -p "$port" "$user_host" "$remote_cmd"
|
|
}
|
|
|
|
# Probe a peer by calling its peer-shell ping verb. Updates the peers row
|
|
# status + last_seen. Echos the new status.
|
|
peerPing()
|
|
{
|
|
local peer_name="$1"
|
|
local out
|
|
out=$(peerExec "$peer_name" ping 2>&1)
|
|
local rc=$?
|
|
local status now
|
|
now=$(date -Iseconds)
|
|
if (( rc == 0 )) && [[ "$out" == *'"ok":true'* ]]; then
|
|
status="ok"
|
|
elif (( rc != 0 )); then
|
|
status="unreachable"
|
|
else
|
|
status="protocol-error"
|
|
fi
|
|
sqlite3 "$(_peerDb)" \
|
|
"UPDATE peers SET status='$(peerSqlEscape "$status")', last_seen='$now' WHERE name='$(peerSqlEscape "$peer_name")';" \
|
|
2>/dev/null
|
|
echo "$status"
|
|
[[ "$status" == "ok" ]]
|
|
}
|
|
|
|
# Fetch the peer's app list. Just relays the JSON peer-shell emits.
|
|
peerListAppsRemote()
|
|
{
|
|
local peer_name="$1"
|
|
peerExec "$peer_name" list-apps
|
|
}
|