@le-space/rootfs 0.9.9 → 0.10.0

package/index.d.ts

@@ -166,6 +166,8 @@ interface RootfsExecutionPlan {
     mode: "host" | "docker";
     reason: string;
     referenceRootfsDir: string;
+    /** Run on the host first: files the image needs, built into the reference dir (all a Docker build sees). */
+    assetCommands?: RootfsCommandPlan[];
     prepareCommand?: RootfsCommandPlan;
     runCommand: RootfsCommandPlan;
 }
@@ -176,6 +178,13 @@ interface RootfsExecutionPlanOptions {
     orbitdbRelayMountPath?: string;
     dockerImageTag?: string;
 }
+/**
+ * The orbitdb-relay image carries the attest relay (packages/attest-relay) as
+ * one bundled file, so browsers can reach a confidential guest's RA-TLS port
+ * at wss://<relay host>/attest. Built from this workspace when it is here; an
+ * image built without it has no attest relay (build-rootfs-image.sh says so).
+ */
+declare function profileAssetCommands(contract: RootfsContract, referenceRootfsDir: string): RootfsCommandPlan[];
 declare function createHostRootfsExecutionPlan(plan: RootfsBuildPlan, options?: RootfsExecutionPlanOptions): RootfsExecutionPlan;
 declare function createDockerRootfsExecutionPlan(plan: RootfsBuildPlan, options?: RootfsExecutionPlanOptions): RootfsExecutionPlan;
 declare function selectRootfsExecutionPlan(plan: RootfsBuildPlan, availability: RootfsToolchainAvailability, options?: RootfsExecutionPlanOptions): RootfsExecutionPlan;
@@ -261,4 +270,4 @@ declare function createRootfsScriptCommand(buildPlan: RootfsBuildPlan, reference
 declare function buildRootfs(buildPlan: RootfsBuildPlan, deps: RootfsCommandRunner, availability: RootfsToolchainAvailability, options?: RootfsExecutionPlanOptions): Promise<RootfsExecutionResult>;
 declare function publishRootfs(buildPlan: RootfsBuildPlan, deps: RootfsExecutorDependencies, options?: RootfsPublishOptions): Promise<RootfsPublishExecutionResult>;
 
-export { ITEM_HASH_RE, type RootfsBuildDriver, type RootfsBuildOptions, type RootfsBuildPipeline, type RootfsBuildPlan, type RootfsCommandPlan, type RootfsCommandRunner, type RootfsContract, type RootfsContractManifest, type RootfsContractPort, type RootfsContractRootfs, type RootfsContractServices, type RootfsContractSource, type RootfsContractState, type RootfsExecutedCommand, type RootfsExecutionPlan, type RootfsExecutionPlanOptions, type RootfsExecutionResult, type RootfsExecutorDependencies, type RootfsFileReader, type RootfsFinalizeOptions, type RootfsFinalizeResult, type RootfsIpfsAddEntry, type RootfsManifest, type RootfsManifestOptions, type RootfsManifestOutputPaths, type RootfsManifestState, type RootfsPublicationArtifacts, type RootfsPublicationResult, type RootfsPublishExecutionResult, type RootfsPublishOptions, type RootfsStoreMessageResponse, type RootfsStoreMessageStatus, type RootfsToolchainAvailability, buildRootfs, contractShellEnv, createDockerRootfsBuildPipeline, createDockerRootfsExecutionPlan, createHostRootfsBuildPipeline, createHostRootfsExecutionPlan, createRootfsBuildPipeline, createRootfsBuildPlan, createRootfsManifest, createRootfsPublicationResult, createRootfsScriptCommand, deriveRootfsVersion, extractRootfsCid, extractRootfsSourceSizeBytes, finalizeRootfsBuildPipeline, parseIpfsAddResponse, parseRootfsContract, parseStoreMessageResponse, parseStoreMessageStatus, publicationArtifacts, publishRootfs, readRootfsContractFile, referenceProfileContractPath, referenceProfileRoot, referenceProfileRootfsDir, resolveRootfsManifestOutputPaths, rootfsBuildShellEnv, rootfsSourceSizeBytesFromIpfsAddResponse, selectRootfsExecutionPlan, serializeRootfsManifest, summarizeStoreMessageFailure, validateRootfsContract, validateRootfsManifest };
+export { ITEM_HASH_RE, type RootfsBuildDriver, type RootfsBuildOptions, type RootfsBuildPipeline, type RootfsBuildPlan, type RootfsCommandPlan, type RootfsCommandRunner, type RootfsContract, type RootfsContractManifest, type RootfsContractPort, type RootfsContractRootfs, type RootfsContractServices, type RootfsContractSource, type RootfsContractState, type RootfsExecutedCommand, type RootfsExecutionPlan, type RootfsExecutionPlanOptions, type RootfsExecutionResult, type RootfsExecutorDependencies, type RootfsFileReader, type RootfsFinalizeOptions, type RootfsFinalizeResult, type RootfsIpfsAddEntry, type RootfsManifest, type RootfsManifestOptions, type RootfsManifestOutputPaths, type RootfsManifestState, type RootfsPublicationArtifacts, type RootfsPublicationResult, type RootfsPublishExecutionResult, type RootfsPublishOptions, type RootfsStoreMessageResponse, type RootfsStoreMessageStatus, type RootfsToolchainAvailability, buildRootfs, contractShellEnv, createDockerRootfsBuildPipeline, createDockerRootfsExecutionPlan, createHostRootfsBuildPipeline, createHostRootfsExecutionPlan, createRootfsBuildPipeline, createRootfsBuildPlan, createRootfsManifest, createRootfsPublicationResult, createRootfsScriptCommand, deriveRootfsVersion, extractRootfsCid, extractRootfsSourceSizeBytes, finalizeRootfsBuildPipeline, parseIpfsAddResponse, parseRootfsContract, parseStoreMessageResponse, parseStoreMessageStatus, profileAssetCommands, publicationArtifacts, publishRootfs, readRootfsContractFile, referenceProfileContractPath, referenceProfileRoot, referenceProfileRootfsDir, resolveRootfsManifestOutputPaths, rootfsBuildShellEnv, rootfsSourceSizeBytesFromIpfsAddResponse, selectRootfsExecutionPlan, serializeRootfsManifest, summarizeStoreMessageFailure, validateRootfsContract, validateRootfsManifest };

package/index.js

@@ -385,7 +385,9 @@ function serializeRootfsManifest(manifest) {
 }
 
 // src/execution-plan.ts
+import { existsSync as existsSync2 } from "fs";
 import path2 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
 function ensurePathWithin(parent, child, label) {
   const relative = path2.relative(parent, child);
   if (relative.startsWith("..") || path2.isAbsolute(relative)) {
@@ -411,12 +413,25 @@ function resolveReferenceRootfsDir(contract, override) {
   }
   return referenceProfileRootfsDir(contract.id);
 }
+function profileAssetCommands(contract, referenceRootfsDir) {
+  if (contract.rootfs.profile !== "orbitdb-relay") return [];
+  const bundler = fileURLToPath2(new URL("../../attest-relay/scripts/bundle.mjs", import.meta.url));
+  if (!existsSync2(bundler)) return [];
+  return [
+    {
+      command: process.execPath,
+      args: [bundler, path2.join(referenceRootfsDir, "attest-relay.cjs")],
+      workdir: path2.dirname(bundler)
+    }
+  ];
+}
 function createHostRootfsExecutionPlan(plan, options = {}) {
   const referenceRootfsDir = resolveReferenceRootfsDir(plan.contract, options.referenceRootfsDir);
   return {
     mode: "host",
     reason: "Using host virt-customize/qemu-img toolchain.",
     referenceRootfsDir,
+    assetCommands: profileAssetCommands(plan.contract, referenceRootfsDir),
     runCommand: {
       command: "/bin/bash",
       args: [path2.join(referenceRootfsDir, "build-rootfs-image.sh")],
@@ -462,6 +477,7 @@ function createDockerRootfsExecutionPlan(plan, options = {}) {
     mode: "docker",
     reason: "Using Dockerized Debian/libguestfs builder.",
     referenceRootfsDir,
+    assetCommands: profileAssetCommands(plan.contract, referenceRootfsDir),
     prepareCommand: {
       command: "docker",
       args: [
@@ -662,6 +678,11 @@ function createRootfsScriptCommand(buildPlan, referenceRootfsDir) {
 async function buildRootfs(buildPlan, deps, availability, options = {}) {
   const pipeline = createRootfsBuildPipeline(buildPlan, availability, options);
   const executedCommands = [];
+  for (const asset of pipeline.executionPlan.assetCommands ?? []) {
+    const assetCommand = { command: asset.command, args: asset.args, workdir: asset.workdir, env: asset.env };
+    await deps.run(assetCommand);
+    executedCommands.push(assetCommand);
+  }
   if (pipeline.executionPlan.prepareCommand) {
     const prepareCommand = {
       command: pipeline.executionPlan.prepareCommand.command,
@@ -746,6 +767,7 @@ export {
   parseRootfsContract,
   parseStoreMessageResponse,
   parseStoreMessageStatus,
+  profileAssetCommands,
   publicationArtifacts,
   publishRootfs,
   readRootfsContractFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/rootfs",
-  "version": "0.9.9",
+  "version": "0.10.0",
   "description": "Shared rootfs contract parsing, reference profile assets, and build helpers.",
   "license": "MIT",
   "type": "module",

package/reference/confidential/README.md

@@ -0,0 +1,37 @@
+# Confidential relay rootfs
+
+A confidential (AMD SEV-SNP) instance on Aleph does not boot a rootfs the way a
+normal instance does. Aleph's measured init waits for the owner to attest the
+guest and inject the LUKS passphrase, unlocks the rootfs, **chroots** into it and
+runs its `/sbin/init`. That init is not PID 1, nothing provisions the image from
+outside (no cloud-init), and the encrypted image is uploaded in full.
+
+`make-confidential-rootfs.sh` turns the image a relay profile build makes into
+a plain ext4 that `aleph instance create --confidential --encrypt-rootfs` (or
+`--image`, see below) can boot:
+
+| Change | Why |
+| --- | --- |
+| `/sbin/init` → `confidential-init.sh` | a regular file that stays in the foreground: mounts `/run`, devpts and cgroup2, grows the filesystem (`EXT4_IOC_RESIZE_FS`, since `resize2fs` refuses in the chroot), makes SSH host keys on first boot, then runs `systemctl init` |
+| `systemctl`, `journalctl` → [docker-systemctl-replacement](https://github.com/gdraheim/docker-systemctl-replacement) (pinned, checksummed) behind `confidential-systemctl.py` | starts the enabled units and keeps answering the `systemctl` / `journalctl` calls the profile scripts make, so the profile itself does not change; the wrapper runs `.timer` units (OnBootSec / OnActiveSec, then OnUnitActiveSec, with RandomizedDelaySec), which the replacement does not |
+| cloud-init, networkd, resolved, timesyncd, getty, … off | the measured init already set up network and DNS |
+| `Type=notify` units run as `Type=simple`; the init sets `net.ipv4.ip_unprivileged_port_start=0` | the replacement receives no sd_notify readiness and applies no `AmbientCapabilities`, so Caddy (WSS on 443) would not start (#168) |
+| root's `authorized_keys` from the caller, plus any injected with the passphrase; host keys removed | an encrypted rootfs cannot be provisioned from the INSTANCE message; the widget sends the deployer's key (with its bootstrap token) as the `authorized_keys` secret over the attested channel, and the init adds its key lines before the units start; host keys exist only inside it |
+| no kernel, modules, docs, locales, apt caches | the guest runs the runtime's measured kernel; the image should stay small |
+
+## Image size
+
+`aleph instance create --encrypt-rootfs` uploads through the CCN, which takes at
+most 1 GiB per file. Above ~900 MiB plain, encrypt the image yourself (LUKS2,
+`--cipher aes-xts-plain64`, whole device, ext4 inside: the measured init
+rejects any other cipher), add it through `ipfs.aleph.cloud`, reference it from
+a STORE message and start it with `aleph instance create --confidential --image
+<store hash>`. The **Aleph Confidential Relay Smoke** workflow does both.
+orbitdb-relay is 1.7 GiB plain today; slimming it is #161.
+
+## Known gaps
+
+- Timers are approximated: no OnCalendar, no Persistent catch-up across a
+  reboot (an encrypted instance re-waits for its passphrase after one anyway).
+- `aleph-vm-deploy` takes `confidential: true` with an encrypted rootfs from
+  `.github/actions/aleph-confidential-rootfs`.

package/reference/confidential/confidential-init.sh

@@ -0,0 +1,52 @@
+#!/bin/sh
+# /sbin/init of a confidential (SEV-SNP) relay rootfs.
+#
+# Aleph's measured init unlocks the LUKS rootfs, chroots into it and runs this
+# file. It is not PID 1, so systemd cannot run; docker-systemctl-replacement
+# starts the enabled units instead and keeps answering the `systemctl` and
+# `journalctl` calls the profile scripts make; confidential-systemctl.py
+# (/usr/bin/systemctl) adds the .timer units it does not run.
+# This script must stay in the foreground: when it exits, the VM powers off.
+export PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
+
+mkdir -p /run /dev/pts /sys/fs/cgroup /var/log
+mount -t tmpfs -o mode=755 tmpfs /run
+mkdir -p /run/sshd /run/lock
+mount -t devpts -o gid=5,mode=620,ptmxmode=666 devpts /dev/pts 2>/dev/null
+mountpoint -q /sys/fs/cgroup || mount -t cgroup2 none /sys/fs/cgroup 2>/dev/null
+[ -s /etc/hostname ] && hostname -F /etc/hostname 2>/dev/null
+# Units that bind low ports rely on AmbientCapabilities=CAP_NET_BIND_SERVICE,
+# which the systemctl replacement does not apply (relay-button#168).
+echo 0 > /proc/sys/net/ipv4/ip_unprivileged_port_start 2>/dev/null
+
+# The CRN grows the disk, not the filesystem inside the LUKS volume, and
+# resize2fs refuses in the chroot (it does not see / as mounted), so ask the
+# kernel to grow it online (EXT4_IOC_RESIZE_FS).
+if [ -b /dev/mapper/cryptroot ]; then
+  bs=$(tune2fs -l /dev/mapper/cryptroot 2>/dev/null | sed -n 's/^Block size: *//p')
+  if [ -n "$bs" ]; then
+    blocks=$(( $(blockdev --getsize64 /dev/mapper/cryptroot) / bs ))
+    perl -e 'sysopen(my $f, "/", 0) or die "open: $!"; ioctl($f, 0x40086610, pack("Q", $ARGV[0])) or die "EXT4_IOC_RESIZE_FS: $!\n"' "$blocks" \
+      > /var/log/confidential-resize.log 2>&1
+  fi
+fi
+
+# Host keys are made on the first boot, inside the encrypted disk, so they
+# never exist outside it.
+ls /etc/ssh/ssh_host_*_key >/dev/null 2>&1 || ssh-keygen -A > /dev/null 2>&1
+
+# Keys injected with the passphrase over the attested channel (the widget
+# sends the deployer's key with its bootstrap token there, since nothing reads
+# the INSTANCE message's authorized_keys here). Key lines only, no options.
+if [ -s /tmp/secrets/authorized_keys ]; then
+  mkdir -p -m 700 /root/.ssh
+  touch /root/.ssh/authorized_keys && chmod 600 /root/.ssh/authorized_keys
+  grep -E '^(ssh-(rsa|ed25519)|ecdsa-sha2-nistp(256|384|521)|sk-(ssh-ed25519|ecdsa-sha2-nistp256)@openssh\.com) [A-Za-z0-9+/]+={0,3}( [^[:cntrl:]]*)?$' /tmp/secrets/authorized_keys \
+    | while read -r line; do
+        grep -qxF "$line" /root/.ssh/authorized_keys || printf '%s\n' "$line" >> /root/.ssh/authorized_keys
+      done
+fi
+
+echo "confidential-init: $(uname -r), starting the enabled units" > /dev/console
+/usr/bin/python3 /usr/bin/systemctl __start-enabled-timers
+exec /usr/bin/python3 /usr/lib/confidential/systemctl3.py init

package/reference/confidential/confidential-systemctl.py

@@ -0,0 +1,205 @@
+#!/usr/bin/python3
+"""systemctl for a confidential rootfs: timers here, everything else in
+docker-systemctl-replacement.
+
+docker-systemctl-replacement does not run .timer units ("start not
+implemented for unit type"), but the relay profiles start and enable timers in
+their configure scripts, under `set -e`. This wrapper handles start, restart,
+stop, enable, disable, is-active, is-enabled and status for .timer units: each
+started timer is a small background loop that starts its service after
+OnBootSec / OnActiveSec and then every OnUnitActiveSec, with
+RandomizedDelaySec. All other calls go to the replacement unchanged, except
+that --no-block is honoured: the replacement ignores it and would wait for a
+oneshot unit to finish (the AutoTLS refresh waits for its certificate), so the
+call is run in the background and returns at once, as it does under systemd.
+"""
+
+import os
+import random
+import re
+import signal
+import subprocess
+import sys
+import time
+
+REAL = "/usr/lib/confidential/systemctl3.py"
+UNIT_DIRS = ["/etc/systemd/system", "/run/systemd/system", "/lib/systemd/system", "/usr/lib/systemd/system"]
+WANTS = "/etc/systemd/system/timers.target.wants"
+RUN_DIR = "/run/confidential-timers"
+UNITS = {"us": 1e-6, "ms": 1e-3, "s": 1, "sec": 1, "second": 1, "seconds": 1, "m": 60, "min": 60,
+         "minute": 60, "minutes": 60, "h": 3600, "hr": 3600, "hour": 3600, "hours": 3600,
+         "d": 86400, "day": 86400, "days": 86400, "w": 604800, "week": 604800, "weeks": 604800}
+
+
+def seconds(value):
+    """systemd time span: "2min", "6h", "1h 30min", "90" (seconds)."""
+    value = (value or "").strip()
+    if not value:
+        return None
+    if re.fullmatch(r"\d+(\.\d+)?", value):
+        return float(value)
+    total = 0.0
+    for number, unit in re.findall(r"(\d+(?:\.\d+)?)\s*([a-z]+)", value):
+        total += float(number) * UNITS.get(unit, 0)
+    return total
+
+
+def unit_file(name):
+    for directory in UNIT_DIRS:
+        path = os.path.join(directory, name)
+        if os.path.exists(path):
+            return path
+    return None
+
+
+def timer_settings(name):
+    path = unit_file(name)
+    if not path:
+        return None
+    settings, section = {}, None
+    with open(path) as handle:
+        for line in handle:
+            line = line.strip()
+            if line.startswith("["):
+                section = line.strip("[]")
+            elif section == "Timer" and "=" in line and not line.startswith("#"):
+                key, value = line.split("=", 1)
+                settings[key.strip()] = value.strip()
+    return settings
+
+
+def pid_file(name):
+    return os.path.join(RUN_DIR, name + ".pid")
+
+
+def running_pid(name):
+    try:
+        pid = int(open(pid_file(name)).read())
+        os.kill(pid, 0)
+        return pid
+    except (OSError, ValueError):
+        return None
+
+
+def run_loop(name):
+    """The timer itself; runs detached until stopped."""
+    settings = timer_settings(name) or {}
+    service = settings.get("Unit") or name[: -len(".timer")] + ".service"
+    first = seconds(settings.get("OnActiveSec")) or seconds(settings.get("OnBootSec")) or 0
+    period = seconds(settings.get("OnUnitActiveSec")) or seconds(settings.get("OnUnitInactiveSec"))
+    jitter = seconds(settings.get("RandomizedDelaySec")) or 0
+    time.sleep(first + random.uniform(0, jitter))
+    while True:
+        subprocess.call([sys.executable, REAL, "start", service])
+        if not period:
+            return
+        time.sleep(period + random.uniform(0, jitter))
+
+
+def start(name):
+    if not timer_settings(name):
+        print(f"Unit {name} not found.", file=sys.stderr)
+        return 5
+    if running_pid(name):
+        return 0
+    os.makedirs(RUN_DIR, exist_ok=True)
+    child = subprocess.Popen([sys.executable, os.path.abspath(__file__), "__run-timer", name],
+                             stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                             start_new_session=True)
+    with open(pid_file(name), "w") as handle:
+        handle.write(str(child.pid))
+    return 0
+
+
+def stop(name):
+    pid = running_pid(name)
+    if pid:
+        os.kill(pid, signal.SIGTERM)
+    try:
+        os.remove(pid_file(name))
+    except OSError:
+        pass
+    return 0
+
+
+def enable(name):
+    path = unit_file(name)
+    if not path:
+        return 5
+    os.makedirs(WANTS, exist_ok=True)
+    link = os.path.join(WANTS, name)
+    if not os.path.lexists(link):
+        os.symlink(path, link)
+    return 0
+
+
+def disable(name):
+    link = os.path.join(WANTS, name)
+    if os.path.lexists(link):
+        os.remove(link)
+    return 0
+
+
+def handle_timers(command, names, now):
+    code = 0
+    for name in names:
+        if command == "start":
+            code |= start(name)
+        elif command == "restart":
+            stop(name)
+            code |= start(name)
+        elif command == "stop":
+            code |= stop(name)
+        elif command == "enable":
+            code |= enable(name)
+            if now:
+                code |= start(name)
+        elif command == "disable":
+            code |= disable(name)
+            if now:
+                stop(name)
+        elif command == "is-active":
+            active = running_pid(name) is not None
+            print("active" if active else "inactive")
+            code |= 0 if active else 3
+        elif command == "is-enabled":
+            enabled = os.path.lexists(os.path.join(WANTS, name))
+            print("enabled" if enabled else "disabled")
+            code |= 0 if enabled else 1
+        elif command == "status":
+            pid = running_pid(name)
+            print(f"{name} - {'active (waiting), pid ' + str(pid) if pid else 'inactive (dead)'}")
+            code |= 0 if pid else 3
+    return code
+
+
+def main(argv):
+    if len(argv) >= 2 and argv[0] == "__run-timer":
+        run_loop(argv[1])
+        return 0
+    if len(argv) >= 1 and argv[0] == "__start-enabled-timers":
+        for name in sorted(os.listdir(WANTS)) if os.path.isdir(WANTS) else []:
+            if name.endswith(".timer"):
+                start(name)
+        return 0
+    words = [arg for arg in argv if not arg.startswith("-")]
+    command = words[0] if words else ""
+    timers = [word for word in words[1:] if word.endswith(".timer")]
+    others = [word for word in words[1:] if not word.endswith(".timer")]
+    if "--no-block" in argv:
+        rest = [arg for arg in argv if arg != "--no-block"]
+        subprocess.Popen([sys.executable, os.path.abspath(__file__)] + rest,
+                         stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                         start_new_session=True)
+        return 0
+    if not timers:
+        os.execv(sys.executable, [sys.executable, REAL] + argv)
+    code = handle_timers(command, timers, "--now" in argv)
+    if others:
+        flags = [arg for arg in argv if arg.startswith("-")]
+        code |= subprocess.call([sys.executable, REAL] + flags + [command] + others)
+    return code
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))

package/reference/confidential/make-confidential-rootfs.sh

@@ -0,0 +1,142 @@
+#!/usr/bin/env bash
+# Turn a relay profile image (the qcow2 or raw disk the profile build makes)
+# into a plain ext4 rootfs that `aleph instance create --confidential
+# --encrypt-rootfs` can encrypt and boot on an SEV-SNP node.
+#
+#   make-confidential-rootfs.sh <image> <out.ext4> <authorized_keys>
+#
+# What changes in the image, and why:
+# - /sbin/init becomes confidential-init.sh (a regular file, as the measured
+#   init requires): systemd cannot be PID 1 in the chroot.
+# - /usr/bin/systemctl and /usr/bin/journalctl become docker-systemctl-
+#   replacement, pinned below, behind confidential-systemctl.py, which runs
+#   .timer units; the profile's units and scripts keep working.
+# - cloud-init and the systemd services that manage what the measured init
+#   already did (network, DNS, getty, timesyncd) are no longer started.
+# - Type=notify units run as Type=simple, and the init lets any user bind
+#   ports below 1024 (the replacement has neither sd_notify nor capabilities).
+# - root's authorized_keys come from the caller: nothing provisions an
+#   encrypted rootfs from outside. Host keys are removed and made on first boot.
+# - Kernel, modules, docs and caches go: the guest runs the runtime's measured
+#   kernel, and the encrypted image must stay below the CCN's 1 GiB upload limit.
+#
+# Needs root (qemu-nbd, mount), qemu-utils, rsync, e2fsprogs and curl.
+set -euo pipefail
+
+SYSTEMCTL_REPLACEMENT_COMMIT=8bd65bec50650fcc740e2d55c32162ba7bafdfc8 # v1.7.1097
+SYSTEMCTL3_SHA256=5f5a47f321c7a8881dfd01f774106dc4012d664bee238eada86a7112674fea93
+JOURNALCTL3_SHA256=16a52fe484d7c0fca464c82a56de58980440362942482c0d1fbc424e69f8f833
+MAX_PLAIN_MIB="${MAX_PLAIN_MIB:-900}"
+
+image="${1:?usage: make-confidential-rootfs.sh <image> <out.ext4> <authorized_keys>}"
+out="${2:?missing output path}"
+keys="${3:?missing authorized_keys file}"
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+[ "$(id -u)" = 0 ] || { echo "run as root" >&2; exit 1; }
+[ -s "$keys" ] || { echo "authorized_keys file is empty: $keys" >&2; exit 1; }
+
+work="$(mktemp -d)"
+mnt="$work/mnt"
+root="$work/root"
+nbd=""
+cleanup() {
+  mountpoint -q "$mnt" && umount "$mnt"
+  [ -n "$nbd" ] && qemu-nbd -d "$nbd" >/dev/null 2>&1
+  rm -rf "$work"
+}
+trap cleanup EXIT
+mkdir -p "$mnt" "$root"
+
+# 1. Mount the image's root filesystem (the largest ext4 partition).
+modprobe nbd max_part=16
+nbd=/dev/nbd0
+qemu-nbd -r -c "$nbd" "$image"
+udevadm settle
+part="$(lsblk -lnbo NAME,FSTYPE,SIZE "$nbd" | awk '$2 == "ext4" { print $3, $1 }' | sort -n | tail -1 | cut -d' ' -f2)"
+[ -n "$part" ] || { echo "no ext4 partition in $image" >&2; exit 1; }
+mount -o ro "/dev/$part" "$mnt"
+
+# 2. Copy it, leaving out what a confidential guest never uses.
+rsync -aHAX --numeric-ids \
+  --exclude=/boot/ --exclude=/usr/lib/modules/ --exclude=/lib/modules/ \
+  --exclude=/usr/share/doc/ --exclude=/usr/share/man/ --exclude=/usr/share/info/ \
+  --exclude=/usr/share/locale/ --exclude=/var/cache/apt/ --exclude=/var/lib/apt/lists/ \
+  --exclude=/var/log/ --exclude=/var/lib/cloud/ --exclude=/tmp/ \
+  "$mnt/" "$root/"
+mkdir -p "$root"/{boot,var/log,tmp,var/cache/apt,var/lib/apt/lists}
+chmod 1777 "$root/tmp"
+umount "$mnt"
+
+# 3. The systemd replacement.
+fetch() {
+  curl -fsSL -o "$2" "https://raw.githubusercontent.com/gdraheim/docker-systemctl-replacement/${SYSTEMCTL_REPLACEMENT_COMMIT}/files/docker/$1"
+  echo "$3  $2" | sha256sum -c - >/dev/null
+}
+fetch systemctl3.py "$work/systemctl3.py" "$SYSTEMCTL3_SHA256"
+fetch journalctl3.py "$work/journalctl3.py" "$JOURNALCTL3_SHA256"
+for bin in systemctl journalctl; do
+  for dir in usr/bin bin; do
+    [ -e "$root/$dir/$bin" ] && [ ! -L "$root/$dir/$bin" ] && mv "$root/$dir/$bin" "$root/$dir/$bin.systemd"
+  done
+done
+install -d "$root/usr/lib/confidential"
+install -m 755 "$work/systemctl3.py" "$root/usr/lib/confidential/systemctl3.py"
+# The replacement does not run .timer units; this wrapper does, and passes
+# everything else on.
+install -m 755 "$here/confidential-systemctl.py" "$root/usr/bin/systemctl"
+install -m 755 "$work/journalctl3.py" "$root/usr/bin/journalctl"
+# journalctl3.py calls systemctl3.py from its own directory.
+ln -sf /usr/lib/confidential/systemctl3.py "$root/usr/bin/systemctl3.py"
+[ -x "$root/usr/bin/python3" ] || { echo "the image has no python3, which the systemctl replacement needs" >&2; exit 1; }
+
+# 4. Stop starting what the measured init already did, or what has no place here.
+wants="$root/etc/systemd/system"
+find "$wants" -path '*.wants/*' \( \
+  -name 'cloud-*' -o -name 'systemd-networkd*' -o -name 'systemd-resolved*' \
+  -o -name 'systemd-timesyncd*' -o -name 'networking.service' -o -name 'getty@*' \
+  -o -name 'serial-getty@*' -o -name 'e2scrub*' -o -name 'fstrim*' -o -name 'apt-daily*' \
+  -o -name 'man-db*' -o -name 'unattended-upgrades*' -o -name 'systemd-pstore*' \
+  -o -name 'qemu-guest-agent*' -o -name 'remote-fs.target' \) -delete
+# cloud-init is also pulled in from units under /lib; nothing may start it.
+find "$root/etc/systemd" "$root/lib/systemd/system" "$root/usr/lib/systemd/system" \
+  -name 'cloud-*' \( -type l -o -type f \) -delete 2>/dev/null || true
+rm -f "$root/usr/bin/cloud-init" "$root/usr/bin/cloud-id"
+[ -s "$root/etc/hostname" ] || echo relay > "$root/etc/hostname"
+
+# 4b. Units the replacement cannot run as written (relay-button#168): it does
+# not receive sd_notify readiness, so Type=notify becomes Type=simple (a
+# reverse proxy such as Caddy needs no readiness handshake here); and it does
+# not apply AmbientCapabilities, so low ports are opened to every user by the
+# init (net.ipv4.ip_unprivileged_port_start=0) instead.
+for dir in "$root/etc/systemd/system" "$root/lib/systemd/system" "$root/usr/lib/systemd/system"; do
+  [ -d "$dir" ] || continue
+  # grep exits 1 when a directory has none; under pipefail that would end the script.
+  { grep -rlE '^Type=notify(-reload)?$' "$dir" --include='*.service' 2>/dev/null || true; } | while read -r unit; do
+    sed -i -E 's/^Type=notify(-reload)?$/Type=simple/; /^NotifyAccess=/d' "$unit"
+    echo "Type=notify -> simple: ${unit#$root}"
+  done
+done
+
+# 5. Init, DNS placeholder, SSH.
+rm -f "$root/sbin/init"
+install -m 755 "$here/confidential-init.sh" "$root/sbin/init"
+rm -f "$root/etc/resolv.conf"
+touch "$root/etc/resolv.conf"
+rm -f "$root"/etc/ssh/ssh_host_*
+install -d -m 700 "$root/root/.ssh"
+install -m 600 "$keys" "$root/root/.ssh/authorized_keys"
+ln -sf /lib/systemd/system/ssh.service "$wants/multi-user.target.wants/ssh.service" 2>/dev/null || true
+
+# 6. A tight ext4: the CRN grows the disk, the init grows the filesystem.
+size_mib=$(( $(du -sm "$root" | cut -f1) * 110 / 100 + 64 ))
+echo "rootfs content: $(du -sh "$root" | cut -f1), plain image ${size_mib} MiB"
+[ "$size_mib" -le "$MAX_PLAIN_MIB" ] || {
+  echo "largest directories:" >&2
+  du -xm --max-depth=4 "$root" 2>/dev/null | sort -n | tail -30 | sed "s|$root||" >&2
+  echo "the plain image (${size_mib} MiB) is above ${MAX_PLAIN_MIB} MiB and would exceed the 1 GiB upload limit once encrypted" >&2
+  exit 1
+}
+rm -f "$out"
+truncate -s "${size_mib}M" "$out"
+mkfs.ext4 -q -b 4096 -T default -d "$root" "$out"
+echo "wrote $out"

package/reference/orbitdb-relay/contract.json

@@ -71,6 +71,6 @@
   ],
   "manifest": {
     "copyTarget": "public/rootfs-manifest.json",
-    "notes": "The OrbitDB relay image prebakes Node.js, production dependencies, and Caddy into the qcow2, delays first relay start until Aleph host port mappings are known, exposes a temporary setup endpoint on port 80, and uses Caddy on port 443 to front both HTTPS helper routes and secure libp2p WSS transport for the configured proxy hostname."
+    "notes": "The OrbitDB relay image prebakes Node.js, production dependencies, and Caddy into the qcow2, delays first relay start until Aleph host port mappings are known, exposes a temporary setup endpoint on port 80, and uses Caddy on port 443 to front both HTTPS helper routes and secure libp2p WSS transport for the configured proxy hostname, and serves the attest relay (wss://<proxy hostname>/attest) that browsers use to attest and unlock confidential instances."
   }
 }

package/reference/orbitdb-relay/rootfs/attest-relay.service

@@ -0,0 +1,27 @@
+[Unit]
+Description=Attest relay: WebSocket to an SEV-SNP guest's attestation port, behind Caddy at /attest
+After=network-online.target
+Wants=network-online.target
+
+[Service]
+Type=simple
+# Loopback only: Caddy terminates TLS and proxies wss://<host>/attest here.
+Environment=ATTEST_RELAY_HOST=127.0.0.1
+Environment=ATTEST_RELAY_PORT=8787
+Environment=ATTEST_RELAY_TRUST_PROXY=1
+# Optional overrides (ATTEST_RELAY_ORIGINS, limits) for the operator.
+EnvironmentFile=-/etc/default/attest-relay
+ExecStart=/usr/bin/node /usr/local/lib/attest-relay/attest-relay.cjs
+User=nobody
+Group=nogroup
+NoNewPrivileges=yes
+ProtectSystem=strict
+ProtectHome=yes
+PrivateTmp=yes
+Restart=on-failure
+RestartSec=5
+StandardOutput=journal
+StandardError=journal
+
+[Install]
+WantedBy=multi-user.target

package/reference/orbitdb-relay/rootfs/build-rootfs-image.sh

@@ -228,6 +228,29 @@ case "${ROOTFS_PROFILE}" in
       LICENSE \
       .env.example
 
+    # The attest relay (packages/attest-relay) as one file, so browsers reach
+    # a confidential guest's RA-TLS port through wss://<relay host>/attest.
+    # The rootfs executor bundles it into this directory before the build
+    # (a Docker build sees only this directory); a host build in the
+    # workspace can bundle it here.
+    ATTEST_RELAY_BUNDLE="${ATTEST_RELAY_BUNDLE:-${SCRIPT_DIR}/attest-relay.cjs}"
+    attest_relay_bundler="${SCRIPT_DIR}/../../../../attest-relay/scripts/bundle.mjs"
+    if [ ! -s "${ATTEST_RELAY_BUNDLE}" ] && [ -f "${attest_relay_bundler}" ]; then
+      node "${attest_relay_bundler}" "${ATTEST_RELAY_BUNDLE}" || true
+    fi
+    attest_relay_args=()
+    if [ -s "${ATTEST_RELAY_BUNDLE}" ]; then
+      attest_relay_args=(
+        --mkdir /usr/local/lib/attest-relay
+        --copy-in "${ATTEST_RELAY_BUNDLE}:/usr/local/lib/attest-relay"
+        --copy-in "${SCRIPT_DIR}/attest-relay.service:/etc/systemd/system"
+        --run-command "cd /usr/local/lib/attest-relay && [ -f attest-relay.cjs ] || mv '$(basename "${ATTEST_RELAY_BUNDLE}")' attest-relay.cjs"
+        --run-command "systemctl enable attest-relay.service"
+      )
+    else
+      echo "WARNING: no attest relay bundle at ${ATTEST_RELAY_BUNDLE}; this image will not serve /attest." >&2
+    fi
+
     orbitdb_customize_args=(
       -a "${IMAGE}"
       --mkdir /opt/orbitdb-relay
@@ -262,6 +285,7 @@ case "${ROOTFS_PROFILE}" in
       --run-command "systemctl enable orbitdb-relay-bootstrap.service"
       --run-command "systemctl enable orbitdb-relay-autotls-refresh.timer"
       --run-command "systemctl enable orbitdb-relay.service"
+      "${attest_relay_args[@]}"
       --run-command "rm -f /opt/$(basename "${APP_TAR}")"
     )
 

package/reference/orbitdb-relay/rootfs/orbitdb-relay-configure.sh

@@ -13,6 +13,7 @@ CADDYFILE="${CADDYFILE:-/etc/caddy/Caddyfile}"
 CADDY_UPSTREAM_WSS_PORT="${CADDY_UPSTREAM_WSS_PORT:-9092}"
 CADDY_UPSTREAM_HOST="${CADDY_UPSTREAM_HOST:-127.0.0.1}"
 CADDY_UPSTREAM_METRICS_PORT="${CADDY_UPSTREAM_METRICS_PORT:-9090}"
+CADDY_UPSTREAM_ATTEST_PORT="${CADDY_UPSTREAM_ATTEST_PORT:-8787}"
 # Internal libp2p listen ports. On the Aleph VM, IPv4 is NAT/port-mapped (so it
 # is announced on the externally assigned host ports), but IPv6 is globally
 # routed with NO NAT — the VM is reachable directly on the real listen ports,
@@ -158,6 +159,12 @@ https://${hostname} {
     reverse_proxy 127.0.0.1:${CADDY_UPSTREAM_METRICS_PORT}
   }
 
+  # The attest relay (attest-relay.service): a browser's RA-TLS records to a
+  # confidential guest's attestation port, which it cannot dial itself.
+  handle /attest {
+    reverse_proxy 127.0.0.1:${CADDY_UPSTREAM_ATTEST_PORT}
+  }
+
   reverse_proxy ${CADDY_UPSTREAM_HOST}:${CADDY_UPSTREAM_WSS_PORT}
 }
 EOF