diff --git a/config/mac-studio-sandbox.json b/config/mac-studio-sandbox.json new file mode 100644 index 0000000000000000000000000000000000000000..2c6f6328055dfcd772d866d91f8360ed92453ddc --- /dev/null +++ b/config/mac-studio-sandbox.json @@ -0,0 +1,4 @@ +{ + "dataset": "globe/clover/mac-studio-sandbox", + "mountPoint": "/srv/mac-studio-vm/sandbox" +} diff --git a/nixos/mac-studio-sandbox.nix b/nixos/mac-studio-sandbox.nix new file mode 100644 index 0000000000000000000000000000000000000000..a19577cfda4c50cf7516a166aa862c289a4c724b --- /dev/null +++ b/nixos/mac-studio-sandbox.nix @@ -0,0 +1,70 @@ +{ config, lib, pkgs, ... }: +let + workspace = builtins.fromJSON (builtins.readFile ../config/mac-studio-sandbox.json); + dataset = workspace.dataset; + mountPoint = workspace.mountPoint; + parent = builtins.dirOf dataset; + checkMount = "${pkgs.runtimeShell} ${../service/samba/check-mount.sh} ${mountPoint} ${dataset}"; +in +{ + systemd.services.mac-studio-sandbox = { + wantedBy = [ "multi-user.target" ]; + after = [ "zfs-mount.service" ]; + before = [ "nfs-mountd.service" "nfs-server.service" ]; + requiredBy = [ "nfs-mountd.service" "nfs-server.service" ]; + path = [ pkgs.zfs pkgs.util-linux pkgs.coreutils pkgs.findutils pkgs.gawk ]; + serviceConfig = { Type = "oneshot"; RemainAfterExit = true; }; + script = '' + test "$(zfs get -H -o value keystatus ${parent})" = available + test "$(zfs get -H -o value encryptionroot ${parent})" = ${parent} + test "$(readlink -m ${mountPoint})" = ${mountPoint} + if mountpoint -q ${mountPoint}; then + ${checkMount} + else + test ! -e ${mountPoint} || { test -d ${mountPoint} && test -z "$(find ${mountPoint} -mindepth 1 -maxdepth 1 -print -quit)"; } + fi + fresh=false + if ! zfs list -H -o name ${dataset} >/dev/null 2>&1; then + mkdir -p ${builtins.dirOf mountPoint} + zfs create -u -o mountpoint=${mountPoint} -o casesensitivity=sensitive \ + -o compression=lz4 -o atime=off -o sync=standard -o acltype=posix -o xattr=sa ${dataset} + fresh=true + fi + test "$(zfs get -H -o value mountpoint ${dataset})" = ${mountPoint} + test "$(zfs get -H -o value encryptionroot ${dataset})" = ${parent} + test "$(zfs get -H -o value casesensitivity ${dataset})" = sensitive + test "$(zfs get -H -o value sync ${dataset})" = standard + test "$(zfs get -H -o value checksum ${dataset})" != off + if test "$(zfs get -H -o value mounted ${dataset})" != yes; then + zfs mount ${dataset} + fi + ${checkMount} + if $fresh; then + chown ${toString config.users.users.clo.uid}:${toString config.users.groups.chloe.gid} ${mountPoint} + chmod 2770 ${mountPoint} + fi + ''; + }; + + services.nfs.server = { + enable = true; + hostName = "10.0.0.1"; + extraNfsdConfig = '' + vers3 = n + udp = n + tcp = y + ''; + exports = '' + ${mountPoint} 10.0.0.222(rw,sync,fsid=0,no_subtree_check,all_squash,anonuid=${toString config.users.users.clo.uid},anongid=${toString config.users.groups.chloe.gid},insecure) + ''; + }; + + systemd.services.nfs-mountd = { + path = [ pkgs.gawk ]; + preStart = lib.mkBefore checkMount; + }; + systemd.services.nfs-server = { + path = [ pkgs.gawk ]; + preStart = lib.mkBefore checkMount; + }; +} diff --git a/nixos/snowglobe.nix b/nixos/snowglobe.nix index c1a50953d2eed09ffc8caf67d8ae75084fa08fa8..8e7a4ab384309981f4450d479d2f33c103de9de4 100644 --- a/nixos/snowglobe.nix +++ b/nixos/snowglobe.nix @@ -15,7 +15,7 @@ let }; in { - imports = [ ./snowglobe-network.nix ]; + imports = [ ./snowglobe-network.nix ./mac-studio-sandbox.nix ]; networking.hostName = "snowglobe"; environment.etc."machine-info".text = '' @@ -29,6 +29,7 @@ in networking.firewall.extraCommands = lib.concatMapStrings ({ address, prefixLength, ... }: '' iptables -A nixos-fw -i enp4s0 -s ${address}/${toString prefixLength} -p tcp --dport 445 -j nixos-fw-accept '') config.networking.interfaces.enp4s0.ipv4.addresses + '' + iptables -A nixos-fw -i enp4s0 -s 10.0.0.222/32 -p tcp --dport 2049 -j nixos-fw-accept ip6tables -A nixos-fw -i enp4s0 -s fe80::/10 -p tcp --dport 445 -j nixos-fw-accept ip6tables -A nixos-fw -i enp4s0 -s fc00::/7 -p tcp --dport 445 -j nixos-fw-accept ''; @@ -81,7 +82,8 @@ in systemd.services.nomad = { requires = [ "zfs-import-${pool}.service" ]; - after = [ "zfs-import-${pool}.service" "zfs-mount.service" ]; + wants = [ "mac-studio-sandbox.service" ]; + after = [ "zfs-import-${pool}.service" "zfs-mount.service" "mac-studio-sandbox.service" ]; preStart = '' test "$(${pkgs.util-linux}/bin/findmnt -n -o SOURCE --mountpoint /srv)" = ${pool} test "$(${pkgs.util-linux}/bin/findmnt -n -o SOURCE --mountpoint /srv/clover)" = ${pool}/clover diff --git a/nixos/tests/mac-studio-sandbox.nix b/nixos/tests/mac-studio-sandbox.nix new file mode 100644 index 0000000000000000000000000000000000000000..78928393aa24fa1656e3cdbf2ef2bb1a0a516ef3 --- /dev/null +++ b/nixos/tests/mac-studio-sandbox.nix @@ -0,0 +1,147 @@ +{ pkgs }: +let + sandbox = builtins.fromJSON (builtins.readFile ../../config/mac-studio-sandbox.json); +in +pkgs.testers.runNixOSTest { + name = "mac-studio-sandbox"; + globalTimeout = 600; + + nodes.server = { + imports = [ ../mac-studio-sandbox.nix ]; + virtualisation = { + memorySize = 3072; + cores = 2; + emptyDiskImages = [ 2048 ]; + }; + networking.hostId = "a1b2c3d4"; + networking.interfaces.eth1.ipv4.addresses = [{ address = "10.0.0.1"; prefixLength = 24; }]; + networking.firewall.allowedTCPPorts = [ 2049 ]; + users.groups.chloe.gid = 3000; + users.users.clo = { isSystemUser = true; uid = 3000; group = "chloe"; }; + boot.supportedFilesystems = [ "zfs" ]; + boot.zfs.forceImportRoot = false; + environment.systemPackages = [ pkgs.python3 pkgs.zfs pkgs.util-linux ]; + systemd.services.sandbox-test-pool = { + before = [ "mac-studio-sandbox.service" ]; + serviceConfig = { Type = "oneshot"; RemainAfterExit = true; }; + script = '' + test "$(${pkgs.util-linux}/bin/blockdev --getsize64 /dev/vdb)" = 2147483648 + umask 077 + head -c 32 /dev/urandom > /run/sandbox-test-key + ${pkgs.zfs}/bin/zpool create -o cachefile=none -O mountpoint=none globe /dev/vdb + ${pkgs.zfs}/bin/zfs create -o encryption=aes-256-gcm -o keyformat=raw \ + -o keylocation=file:///run/sandbox-test-key -o mountpoint=/srv/clover \ + -o casesensitivity=insensitive -o acltype=posixacl globe/clover + ''; + }; + systemd.services.mac-studio-sandbox = { + requires = [ "sandbox-test-pool.service" ]; + after = [ "sandbox-test-pool.service" ]; + }; + }; + + nodes.client = { + virtualisation = { memorySize = 1024; cores = 1; }; + networking.interfaces.eth1.ipv4.addresses = [{ address = "10.0.0.222"; prefixLength = 24; }]; + boot.supportedFilesystems = [ "nfs" ]; + environment.systemPackages = [ pkgs.python3 pkgs.nfs-utils pkgs.util-linux ]; + }; + + testScript = '' + mountpoint = ${builtins.toJSON sandbox.mountPoint} + dataset = ${builtins.toJSON sandbox.dataset} + start_all() + server.wait_for_unit("mac-studio-sandbox.service") + server.wait_for_unit("nfs-server.service") + client.wait_until_succeeds("ip -4 address show dev eth1 | grep -q 10.0.0.222", timeout=20) + + with subtest("fresh encrypted case-sensitive dataset and idempotent setup"): + assert server.succeed(f"zfs get -H -o value encryptionroot {dataset}").strip() == "globe/clover" + assert server.succeed(f"zfs get -H -o value casesensitivity {dataset}").strip() == "sensitive" + assert server.succeed(f"findmnt -n -o SOURCE,FSTYPE --mountpoint {mountpoint}").split() == [dataset, "zfs"] + assert server.succeed(f"stat -c '%u:%g %a' {mountpoint}").strip() == "3000:3000 2770" + server.succeed(f"printf retained > {mountpoint}/retained; systemctl restart mac-studio-sandbox.service") + assert server.succeed(f"cat {mountpoint}/retained") == "retained" + server.wait_for_unit("nfs-server.service") + server.succeed("exportfs -v") + assert "-3" in server.succeed("cat /proc/fs/nfsd/versions").split() + + with subtest("shared guard accepts the dataset bind and rejects a covering wrong mount"): + server.succeed(f"mkdir -p /mnt/guard-bind /mnt/guard-wrong; mount --bind {mountpoint} /mnt/guard-bind") + server.succeed(f"${pkgs.runtimeShell} ${../../service/samba/check-mount.sh} /mnt/guard-bind {dataset} true") + server.succeed("mount -t tmpfs -o size=1m tmpfs /mnt/guard-wrong; mount --bind /mnt/guard-wrong /mnt/guard-bind") + server.fail(f"${pkgs.runtimeShell} ${../../service/samba/check-mount.sh} /mnt/guard-bind {dataset} true") + server.succeed("umount /mnt/guard-bind; umount /mnt/guard-bind; umount /mnt/guard-wrong") + + with subtest("NFS ordinary writes, fsync, rename, execute bits and case distinctions"): + client.succeed("mkdir -p /mnt/sandbox; timeout 30 mount -t nfs -o vers=4,proto=tcp,hard,noatime 10.0.0.1:/ /mnt/sandbox") + client.succeed(r"""python3 - <<'PY' + from pathlib import Path + import os + p = Path('/mnt/sandbox') + with (p / 'pending').open('wb') as f: + f.write(b'synthetic native NFS bytes\n') + f.flush() + os.fsync(f.fileno()) + (p / 'pending').rename(p / 'finished') + assert (p / 'finished').read_bytes() == b'synthetic native NFS bytes\n' + (p / 'A').write_text('uppercase') + (p / 'a').write_text('lowercase') + assert (p / 'A').read_text() == 'uppercase' + assert (p / 'a').read_text() == 'lowercase' + (p / 'run').write_text('#!/bin/sh\nprintf sandbox-exec') + (p / 'run').chmod(0o755) + PY""") + assert client.succeed("/mnt/sandbox/run") == "sandbox-exec" + assert server.succeed(f"stat -c '%u:%g' {mountpoint}/finished").strip() == "3000:3000" + + with subtest("server observes client POSIX lock and release"): + client.succeed(r"""python3 - <<'PY' >/run/sandbox-lock.log 2>&1 & + from pathlib import Path + import fcntl, time + with open('/mnt/sandbox/locked', 'w') as f: + fcntl.lockf(f, fcntl.LOCK_EX) + Path('/run/sandbox-lock-ready').touch() + time.sleep(20) + PY + echo $! > /run/sandbox-lock-pid + """) + client.wait_until_succeeds("test -f /run/sandbox-lock-ready", timeout=15) + server.succeed(f"""python3 - <<'PY' + import fcntl + with open('{mountpoint}/locked', 'r+') as f: + try: + fcntl.lockf(f, fcntl.LOCK_EX | fcntl.LOCK_NB) + except BlockingIOError: + pass + else: + raise AssertionError('NFS client lock was not enforced on server') + PY""") + client.succeed("kill -TERM $(cat /run/sandbox-lock-pid)") + server.wait_until_succeeds(f"python3 -c \"import fcntl; f=open('{mountpoint}/locked','r+'); fcntl.lockf(f,fcntl.LOCK_EX|fcntl.LOCK_NB)\"", timeout=15) + + with subtest("NFS refuses a missing or wrong mounted dataset"): + client.succeed("timeout 30 umount /mnt/sandbox") + server.succeed(f"systemctl stop nfs-server.service nfs-mountd.service; zfs unmount {dataset}") + server.fail("systemctl start nfs-mountd.service") + server.fail("systemctl start nfs-server.service") + server.succeed("systemctl reset-failed nfs-server.service nfs-mountd.service") + server.succeed(f"printf untouched > {mountpoint}/placeholder") + server.fail("systemctl restart mac-studio-sandbox.service") + assert server.succeed(f"cat {mountpoint}/placeholder") == "untouched" + server.succeed(f"rm {mountpoint}/placeholder; systemctl reset-failed mac-studio-sandbox.service") + server.succeed(f"zfs create -o mountpoint={mountpoint} globe/wrong") + server.succeed(f"printf untouched > {mountpoint}/wrong-sentinel") + server.fail("systemctl start nfs-mountd.service") + server.fail("systemctl start nfs-server.service") + server.fail("systemctl restart mac-studio-sandbox.service") + assert server.succeed(f"findmnt -n -o SOURCE --mountpoint {mountpoint}").strip() == "globe/wrong" + assert server.succeed(f"cat {mountpoint}/wrong-sentinel") == "untouched" + server.succeed(f"zfs unmount globe/wrong; zfs set mountpoint=none globe/wrong; zfs mount {dataset}") + server.succeed("systemctl reset-failed; systemctl start mac-studio-sandbox.service nfs-server.service") + client.succeed("timeout 30 mount -t nfs -o vers=4,proto=tcp,hard,noatime 10.0.0.1:/ /mnt/sandbox") + assert client.succeed("cat /mnt/sandbox/finished") == "synthetic native NFS bytes\n" + client.succeed("timeout 30 umount /mnt/sandbox") + server.succeed("systemctl stop nfs-server.service nfs-mountd.service; zpool status -x") + ''; +} diff --git a/service/samba/check-mount.sh b/service/samba/check-mount.sh new file mode 100644 index 0000000000000000000000000000000000000000..aa347733b53c11366a8a3ae36c40b41668588eb1 --- /dev/null +++ b/service/samba/check-mount.sh @@ -0,0 +1,17 @@ +#!/bin/sh +set -eu +exec 3< "$1" +awk -v point="$1" -v dataset="$2" ' + FNR == NR { if ($1 == "mnt_id:") id = $2; next } + $1 == id && $4 == "/" && $5 == point { + for (i = 6; i <= NF; i++) + if ($i == "-" && $(i + 1) == "zfs" && $(i + 2) == dataset) found = 1 + } + END { exit !found } +' /proc/self/fdinfo/3 /proc/self/mountinfo || { + printf 'Refusing to share %s: expected mounted ZFS dataset %s\n' "$1" "$2" >&2 + exit 1 +} +exec 3<&- +shift 2 +exec "$@" diff --git a/service/samba/service.pkl b/service/samba/service.pkl index 4069c53e23d1104122846d69d5ed2f1e136b63fe..c45a364b8e8f3f9e6548b8b8a7856bdf8085357e 100644 --- a/service/samba/service.pkl +++ b/service/samba/service.pkl @@ -1,6 +1,9 @@ amends "../../config/Service.pkl" import "../../config/site.pkl" as site +import "pkl:json" + +local workspace = new json.Parser {}.parse(read("../../config/mac-studio-sandbox.json").text) name = "Samba" @@ -10,6 +13,16 @@ container { hostNetwork = !site.preview cpu = 100 memory = 256 + entrypoint = "/bin/sh" + args { + "/sandbox-check-mount" + "/shares/mac-studio-sandbox" + workspace.dataset + "/container/scripts/entrypoint.sh" + "runsvdir" + "-P" + "/container/config/runit" + } tcp { new { @@ -23,6 +36,8 @@ container { volumes { ["/shares/clover"] { src = site.cloverRoot; readOnly = site.cloverReadOnly } ["/shares/clover/Media"] { src = site.mediaRoot; readOnly = site.mediaReadOnly } + ["/shares/mac-studio-sandbox"] { src = workspace.mountPoint; readOnly = true } + ["/sandbox-check-mount"] { config = "check-mount.sh"; readOnly = true } } env { @@ -48,6 +63,15 @@ container { fruit:veto_appledouble = no kernel oplocks = yes """ + ["SAMBA_VOLUME_CONFIG_mac_studio_sandbox"] = """ + [mac-studio-sandbox] + path = /shares/mac-studio-sandbox + valid users = clo + read only = yes + vfs objects = catia fruit streams_xattr + fruit:veto_appledouble = no + kernel oplocks = yes + """ } }