diff --git a/flake.nix b/flake.nix index 7f5ab5f..a16b549 100644 --- a/flake.nix +++ b/flake.nix @@ -580,6 +580,12 @@ pass-broker-gateway = import ./services/identity/pass-broker-gateway-test.nix { pkgs = nixpkgs.legacyPackages.${system}; }; + + # terra's VPN-confined qBittorrent against a fake Proton peer: + # nix build .#checks.x86_64-linux.qbittorrent-vpn -L + qbittorrent-vpn = import ./services/desktop/qbittorrent-vpn-test.nix { + pkgs = nixpkgs.legacyPackages.${system}; + }; }; # `nix develop` — hot-reload loop for dotfiles/quickshell. diff --git a/hosts/terra/configuration.nix b/hosts/terra/configuration.nix index 0f3c708..8c087fe 100644 --- a/hosts/terra/configuration.nix +++ b/hosts/terra/configuration.nix @@ -10,6 +10,7 @@ ../../profiles/workstation.nix ../../services/desktop/luna-voice.nix ../../services/dev/turtle-beach-re.nix + ../../services/desktop/qbittorrent-vpn.nix inputs.turtle-beach-swarm-re.nixosModules.release inputs.tbctl.nixosModules.tbctl ]; @@ -95,6 +96,16 @@ ''; }; + # Peer values from a Proton WireGuard config generated for a P2P server + # with NAT-PMP on; its PrivateKey is protonvpn_wg_private_key in sops. + homelab.qbittorrentVpn = { + enable = true; + downloadDir = "/mnt/hdd_01/data/Downloads/Torrents"; + privateKeyFile = config.sops.secrets.protonvpn_wg_private_key.path; + peerPublicKey = "nPCWC0rx9ZXEkzh7dxMUTO5/HUqDaLaD827Yp1sJCQU="; + endpoint = "103.69.224.2:51820"; # NL#490 + }; + networking.hostName = "terra"; home-manager.users.darman.homelab.desktop = { diff --git a/hosts/terra/secrets.nix b/hosts/terra/secrets.nix index 5db0652..38abb59 100644 --- a/hosts/terra/secrets.nix +++ b/hosts/terra/secrets.nix @@ -10,6 +10,7 @@ sops.age.sshKeyPaths = [ "/etc/ssh/ssh_host_ed25519_key" ]; sops.secrets.tailscale_authkey = { }; + sops.secrets.protonvpn_wg_private_key = { }; sops.secrets.darman_password.neededForUsers = true; users.users.darman.hashedPasswordFile = config.sops.secrets.darman_password.path; diff --git a/services/desktop/qbittorrent-vpn-test.nix b/services/desktop/qbittorrent-vpn-test.nix new file mode 100644 index 0000000..17ebaae --- /dev/null +++ b/services/desktop/qbittorrent-vpn-test.nix @@ -0,0 +1,199 @@ +# VM test for qbittorrent-vpn.nix. Run: +# nix build .#checks.x86_64-linux.qbittorrent-vpn -L +# +# vpn plays Proton: WireGuard peer at 10.2.0.1 with DNS, a fake NAT-PMP +# gateway and an HTTP echo of the caller's address. client runs the module +# with Qt offscreen. Keys are throwaway, test-only. +{ pkgs }: +let + clientKey = "sD38/QEAIwOEVNFlvNy7k0w/E/PJ9yA6twXF1Ef461Y="; + clientPub = "apnW/TFK+Jx6LDCwSZUgPLYN9+U4b65CHdrGVqfJiEs="; + serverKey = "IHQiVlBcfl2fKus+QiQ5Z6ubIFfg4lb0glszV0vIHnQ="; + serverPub = "4esStqi/GKbgHQpWOwKLLtf3pc/7JvXgeTv+eJ+poE0="; + mappedPort = 41234; + + natpmp = pkgs.writers.writePython3 "fake-natpmp" { } '' + import socket + import struct + s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) + s.bind(("0.0.0.0", 5351)) + while True: + req, addr = s.recvfrom(64) + op = req[1] + if op == 0: + resp = struct.pack("!BBHI4s", 0, 128, 0, 1, + socket.inet_aton("1.2.3.4")) + else: + priv = struct.unpack("!H", req[4:6])[0] + resp = struct.pack("!BBHIHHI", 0, 128 + op, 0, 1, priv, + ${toString mappedPort}, 60) + s.sendto(resp, addr) + ''; + + echo = pkgs.writers.writePython3 "echo-addr" { } '' + from http.server import BaseHTTPRequestHandler, HTTPServer + + + class H(BaseHTTPRequestHandler): + def do_GET(self): + self.send_response(200) + self.end_headers() + self.wfile.write(self.client_address[0].encode()) + + + HTTPServer(("0.0.0.0", 80), H).serve_forever() + ''; +in +pkgs.testers.runNixOSTest { + name = "qbittorrent-vpn"; + + nodes.vpn = { + networking.wireguard.interfaces.wg0 = { + ips = [ "10.2.0.1/24" ]; + listenPort = 51820; + privateKeyFile = "${pkgs.writeText "server.key" serverKey}"; + peers = [{ publicKey = clientPub; allowedIPs = [ "10.2.0.2/32" ]; }]; + }; + networking.firewall.allowedUDPPorts = [ 51820 ]; + networking.firewall.allowedTCPPorts = [ 80 ]; + networking.firewall.trustedInterfaces = [ "wg0" ]; + + services.dnsmasq = { + enable = true; + resolveLocalQueries = false; + settings = { + interface = "wg0"; + bind-dynamic = true; + no-resolv = true; + address = "/tracker.test/10.2.0.1"; + }; + }; + systemd.services.fake-natpmp = { + wantedBy = [ "multi-user.target" ]; + serviceConfig.ExecStart = natpmp; + }; + systemd.services.echo-addr = { + wantedBy = [ "multi-user.target" ]; + serviceConfig.ExecStart = echo; + }; + }; + + nodes.client = { nodes, lib, ... }: { + imports = [ ./qbittorrent-vpn.nix ]; + + users.users.darman = { isNormalUser = true; uid = 1000; }; + environment.systemPackages = [ pkgs.curl pkgs.jq ]; + environment.etc."wg/client.key" = { text = clientKey; mode = "0400"; }; + + homelab.qbittorrentVpn = { + enable = true; + downloadDir = "/mnt/data/Torrents"; + privateKeyFile = "/etc/wg/client.key"; + peerPublicKey = serverPub; + endpoint = "${nodes.vpn.networking.primaryIPAddress}:51820"; + }; + systemd.services.qbittorrent-vpn.environment.QT_QPA_PLATFORM = lib.mkForce "offscreen"; + + # Things the sandbox must hide; the "Wayland socket" is a plain file, only + # its bind is checked. + systemd.tmpfiles.rules = [ + "d /mnt/data 0755 darman users -" + "f /mnt/data/other.txt 0644 darman users - other" + "d /home/darman/.ssh 0700 darman users -" + "f /home/darman/.ssh/id_ed25519 0600 darman users - key" + "d /run/user/1000 0700 darman users -" + "f /run/user/1000/wayland-1 0600 darman users -" + "f /run/user/1000/bus 0600 darman users -" + "f /run/pass-broker.sock 0666 root root -" + "d /run/secrets 0755 root root -" + "f /run/secrets/mine 0400 darman users - secret" + ]; + }; + + testScript = { nodes, ... }: let vpnIP = nodes.vpn.networking.primaryIPAddress; in '' + import json + + start_all() + vpn.wait_for_unit("wireguard-wg0.service") + vpn.wait_for_unit("dnsmasq.service") + vpn.wait_for_unit("fake-natpmp.service") + vpn.wait_for_unit("echo-addr.service") + client.wait_for_unit("multi-user.target") + + def ns(cmd): + return client.succeed(f"ip netns exec proton {cmd}") + + def api(path): + return ns(f"curl -sf http://127.0.0.1:8080/api/v2/{path}") + + with subtest("darman starts it via polkit, launcher queues a magnet"): + client.succeed( + "runuser -u darman -- qbittorrent-vpn " + "'magnet:?xt=urn:btih:0123456789abcdef0123456789abcdef01234567&dn=t'" + ) + client.wait_for_unit("qbittorrent-vpn.service") + client.wait_for_unit("proton-netns.service") + client.wait_until_succeeds("ip netns exec proton curl -sf http://127.0.0.1:8080/api/v2/app/version") + + with subtest("sandbox: own state and downloads only"): + pid = client.succeed("systemctl show -p MainPID --value qbittorrent-vpn").strip() + + def inside(cmd): + return f"nsenter -t {pid} -m -S 1000 -G 100 sh -c '{cmd}'" + + client.succeed(inside("[ -e /run/qbittorrent-vpn/wayland ]")) + client.succeed(inside("touch /mnt/data/Torrents/w /home/darman/.config/qBittorrent/w")) + # InaccessiblePaths leaves a mode-000 node behind, so access, not + # existence, is what's checked. + for hidden in ["/home/darman/.ssh/id_ed25519", "/mnt/data/other.txt", + "/run/user/1000/bus", "/run/pass-broker.sock", "/run/secrets/mine"]: + client.fail(inside(f"cat {hidden}")) + for hidden in ["/home/darman/.ssh", "/run/user/1000", "/run/secrets"]: + client.fail(inside(f"ls {hidden}")) + client.fail(inside("touch /home/darman/x.sh /etc/x")) + client.succeed(f"! tr '\\0' '\\n' < /proc/{pid}/environ | grep -q DBUS_SESSION_BUS_ADDRESS") + + with subtest("magnet is picked up from the watch folder"): + client.wait_until_succeeds( + "ip netns exec proton curl -sf http://127.0.0.1:8080/api/v2/torrents/info" + " | jq -e 'length == 1'" + ) + client.succeed("[ -z \"$(ls -A /home/darman/.local/share/qbittorrent-vpn/watch)\" ]") + + with subtest("NAT-PMP port lands in qBittorrent"): + client.wait_until_succeeds( + "ip netns exec proton curl -sf http://127.0.0.1:8080/api/v2/app/preferences" + " | jq -e '.listen_port == ${toString mappedPort}'" + ) + prefs = json.loads(api("app/preferences")) + assert prefs["current_network_interface"] == "wg-proton", prefs["current_network_interface"] + assert prefs["save_path"].rstrip("/") == "/mnt/data/Torrents", prefs["save_path"] + + with subtest("traffic leaves through the tunnel only"): + assert ns("curl -sf --max-time 5 http://${vpnIP}/") == "10.2.0.2" + # Root namespace still goes direct. + assert client.succeed("curl -sf --max-time 5 http://${vpnIP}/") != "10.2.0.2" + + with subtest("qBittorrent resolves via tunnel DNS, not host nscd"): + pid = client.succeed("systemctl show -p MainPID --value qbittorrent-vpn").strip() + out = client.succeed(f"nsenter -t {pid} -m -n getent hosts tracker.test") + assert out.startswith("10.2.0.1"), out + client.succeed(f"nsenter -t {pid} -m sh -c '! [ -S /run/nscd/socket ]'") + client.fail("getent hosts tracker.test") + + with subtest("tunnel down = no connectivity, no fallback"): + vpn.succeed("ip link set wg0 down") + client.fail("ip netns exec proton curl -sf --max-time 5 http://${vpnIP}/") + vpn.succeed("ip link set wg0 up && ip addr replace 10.2.0.1/24 dev wg0") + client.wait_until_succeeds("ip netns exec proton curl -sf --max-time 5 http://${vpnIP}/") + + with subtest("stopping the GUI tears the namespace down"): + client.succeed("runuser -u darman -- systemctl stop qbittorrent-vpn.service") + client.wait_until_succeeds("! systemctl is-active proton-netns.service") + client.succeed("! systemctl is-active proton-portforward.service") + client.succeed("! [ -e /run/netns/proton ]") + + with subtest("polkit grants only this unit"): + client.fail("runuser -u darman -- systemctl start proton-netns.service") + ''; +} diff --git a/services/desktop/qbittorrent-vpn.nix b/services/desktop/qbittorrent-vpn.nix new file mode 100644 index 0000000..4e5e408 --- /dev/null +++ b/services/desktop/qbittorrent-vpn.nix @@ -0,0 +1,280 @@ +{ config, pkgs, lib, ... }: + +# qBittorrent GUI confined to a ProtonVPN WireGuard network namespace: its +# only route is the tunnel, so a dropped VPN stalls torrents instead of +# leaking them. qbittorrent is deliberately NOT on PATH — an unconfined +# launch would bypass all of this; `qbittorrent-vpn` (and the .desktop +# entry, magnet/.torrent handler) start it as a system unit instead. +let + cfg = config.homelab.qbittorrentVpn; + ns = "proton"; + iface = "wg-proton"; + gateway = "10.2.0.1"; # Proton's in-tunnel DNS + NAT-PMP + webuiPort = 8080; # netns-local only + user = config.users.users.${cfg.user}; + # Outside the netns, so the launcher can hand torrents to a running GUI. + stateDir = "${user.home}/.local/share/qbittorrent-vpn"; + watchDir = "${stateDir}/watch"; + envFile = "${stateDir}/session.env"; + qb = pkgs.qbittorrent; + + launcher = pkgs.writeShellApplication { + name = "qbittorrent-vpn"; + runtimeInputs = [ pkgs.coreutils pkgs.systemd pkgs.gnugrep ]; + text = '' + mkdir -p ${watchDir} + for arg in "$@"; do + case "$arg" in + magnet:*) printf '%s\n' "$arg" > "${watchDir}/$(printf '%s' "$arg" | sha1sum | cut -c1-16).magnet" ;; + file://*) p="''${arg#file://}"; cp -- "$(printf '%b' "''${p//%/\\x}")" ${watchDir}/ ;; + *) cp -- "$arg" ${watchDir}/ ;; + esac + done + # The sandbox binds this one socket by name. + if [ "''${WAYLAND_DISPLAY:-${cfg.waylandDisplay}}" != ${cfg.waylandDisplay} ]; then + echo "qbittorrent-vpn: session is $WAYLAND_DISPLAY, sandbox binds ${cfg.waylandDisplay} (homelab.qbittorrentVpn.waylandDisplay)" >&2 + exit 1 + fi + env | grep -E '^(XDG_CURRENT_DESKTOP|XDG_DATA_DIRS|XCURSOR_[A-Z]+|QT_[A-Z_]+|LANG|LC_[A-Z]+|PATH)=' \ + > ${envFile} || true + exec systemctl start qbittorrent-vpn.service + ''; + }; + + desktopItem = pkgs.makeDesktopItem { + name = "qbittorrent-vpn"; + desktopName = "qBittorrent (ProtonVPN)"; + exec = "qbittorrent-vpn %U"; + icon = "${qb}/share/icons/hicolor/scalable/apps/qbittorrent.svg"; + categories = [ "Network" "FileTransfer" "P2P" ]; + mimeTypes = [ "application/x-bittorrent" "x-scheme-handler/magnet" ]; + }; + + # The only paths qBittorrent can write; the rest of $HOME is invisible. + writable = [ + "${user.home}/.config/qBittorrent" + "${user.home}/.local/share/qBittorrent" + "${user.home}/.cache/qBittorrent" + watchDir + cfg.downloadDir + ]; + # Theme, icons and cursor, read-only; "-" = skip if absent. + themes = map (p: "-${user.home}/${p}") [ + ".config/qt5ct" ".config/qt6ct" ".config/Kvantum" ".config/fontconfig" + ".config/gtk-3.0" ".config/kdeglobals" ".icons" ".local/share/icons" + ".local/share/mime" ".nix-profile" ".local/state/nix/profile" + ]; + + # Unsandboxed, as the user: bind sources must exist before the sandbox is + # built. Also re-applies the settings the confinement relies on, since the + # GUI owns qBittorrent.conf and writes it back on exit. + prepare = pkgs.writeShellScript "qbittorrent-vpn-prepare" '' + set -eu + dir="$HOME/.config/qBittorrent" + mkdir -p ${lib.escapeShellArgs writable} + set_() { ${pkgs.crudini}/bin/crudini --ini-options=nospace --set "$dir/qBittorrent.conf" "$1" "$2" "$3"; } + set_ BitTorrent 'Session\Interface' ${iface} + set_ BitTorrent 'Session\InterfaceName' ${iface} + set_ BitTorrent 'Session\DefaultSavePath' ${cfg.downloadDir} + set_ Network PortForwardingEnabled false + set_ Preferences 'WebUI\Enabled' true + set_ Preferences 'WebUI\Address' 127.0.0.1 + set_ Preferences 'WebUI\Port' ${toString webuiPort} + set_ Preferences 'WebUI\LocalHostAuth' false + # The WebUI refuses to start without credentials; LocalHostAuth=false means + # they're never checked, so a random hash nobody knows the password to. + ${pkgs.crudini}/bin/crudini --get "$dir/qBittorrent.conf" Preferences 'WebUI\Password_PBKDF2' >/dev/null 2>&1 || + set_ Preferences 'WebUI\Password_PBKDF2' \ + "@ByteArray($(head -c16 /dev/urandom | base64 -w0):$(head -c64 /dev/urandom | base64 -w0))" + [ -e "$dir/watched_folders.json" ] || + echo '{"${watchDir}":{"add_torrent_params":{},"recursive":false}}' > "$dir/watched_folders.json" + ''; + + # Proton's documented NAT-PMP loop (60s lease, renewed every 45s); the + # mapped port is pushed into qBittorrent whenever it changes. + portForward = pkgs.writeShellScript "proton-portforward" '' + set -u + api=http://127.0.0.1:${toString webuiPort}/api/v2/app + while :; do + port=$(${pkgs.libnatpmp}/bin/natpmpc -g ${gateway} -a 1 0 udp 60 \ + | ${pkgs.gnused}/bin/sed -n 's/.*Mapped public port \([0-9]*\).*/\1/p') + ${pkgs.libnatpmp}/bin/natpmpc -g ${gateway} -a 1 0 tcp 60 >/dev/null + if [ -n "$port" ]; then + cur=$(${pkgs.curl}/bin/curl -sf $api/preferences | ${pkgs.jq}/bin/jq -r .listen_port) && + [ "$cur" != "$port" ] && + ${pkgs.curl}/bin/curl -sf --data "json={\"listen_port\":$port}" $api/setPreferences && + echo "listen port $cur -> $port" + else + echo "NAT-PMP mapping failed (is this a P2P server?)" >&2 + fi + sleep 45 + done + ''; +in +{ + options.homelab.qbittorrentVpn = { + enable = lib.mkEnableOption "qBittorrent GUI confined to a ProtonVPN netns"; + user = lib.mkOption { type = lib.types.str; default = "darman"; }; + # Fixed at build time: the sandbox binds the Wayland socket by path. + uid = lib.mkOption { type = lib.types.int; default = 1000; }; + waylandDisplay = lib.mkOption { type = lib.types.str; default = "wayland-1"; }; + downloadDir = lib.mkOption { type = lib.types.str; }; + privateKeyFile = lib.mkOption { + type = lib.types.path; + description = "WireGuard PrivateKey from the Proton config."; + }; + address = lib.mkOption { + type = lib.types.str; + default = "10.2.0.2/32"; + description = "IPv4 [Interface] Address. IPv6 is left out: no v6 route, so no v6 leak."; + }; + peerPublicKey = lib.mkOption { type = lib.types.str; }; + endpoint = lib.mkOption { + type = lib.types.str; + description = "[Peer] Endpoint, ip:port — an IP, so no DNS is needed to bring it up."; + }; + }; + + config = lib.mkIf cfg.enable { + environment.systemPackages = [ launcher desktopItem ]; + xdg.mime.defaultApplications = { + "application/x-bittorrent" = "qbittorrent-vpn.desktop"; + "x-scheme-handler/magnet" = "qbittorrent-vpn.desktop"; + }; + + # `ip netns exec` would bind this over /etc/resolv.conf; systemd's + # NetworkNamespacePath does not, so the units below do it themselves. + environment.etc."netns/${ns}/resolv.conf".text = "nameserver ${gateway}\n"; + + # The interface is created in the root namespace and then moved, so its + # UDP socket stays outside (where the internet is) while the interface + # is the netns's only way out. + systemd.services.proton-netns = { + description = "ProtonVPN WireGuard network namespace"; + after = [ "network-online.target" ]; + wants = [ "network-online.target" ]; + path = [ pkgs.iproute2 pkgs.wireguard-tools ]; + unitConfig.StopWhenUnneeded = true; + serviceConfig = { + Type = "oneshot"; + RemainAfterExit = true; + ExecStop = "${pkgs.iproute2}/bin/ip netns del ${ns}"; + }; + script = '' + ip netns del ${ns} 2>/dev/null || true + ip netns add ${ns} + ip -n ${ns} link set lo up + ip link add ${iface} type wireguard + ip link set ${iface} netns ${ns} + ip netns exec ${ns} wg set ${iface} \ + private-key ${cfg.privateKeyFile} \ + peer ${cfg.peerPublicKey} endpoint ${cfg.endpoint} \ + allowed-ips 0.0.0.0/0 persistent-keepalive 25 + ip -n ${ns} addr add ${cfg.address} dev ${iface} + ip -n ${ns} link set ${iface} up + ip -n ${ns} route add default dev ${iface} + ''; + }; + + systemd.services.qbittorrent-vpn-prepare = { + description = "Prepare qBittorrent (ProtonVPN netns) state"; + unitConfig.RequiresMountsFor = [ cfg.downloadDir ]; + serviceConfig = { + Type = "oneshot"; + User = cfg.user; + ExecStart = prepare; + }; + }; + + # Sandboxed so a compromised client (it's internet-facing) gets its own + # state and downloads, not ~/.ssh, the sops age key or the session. + systemd.services.qbittorrent-vpn = { + description = "qBittorrent (ProtonVPN netns)"; + bindsTo = [ "proton-netns.service" ]; + requires = [ "qbittorrent-vpn-prepare.service" ]; + after = [ "proton-netns.service" "qbittorrent-vpn-prepare.service" ]; + wants = [ "proton-portforward.service" ]; + unitConfig.RequiresMountsFor = [ cfg.downloadDir ]; + environment = { + QT_QPA_PLATFORM = "wayland"; + XDG_RUNTIME_DIR = "/run/qbittorrent-vpn"; + WAYLAND_DISPLAY = "/run/qbittorrent-vpn/wayland"; + }; + serviceConfig = { + User = cfg.user; + EnvironmentFile = "-${envFile}"; + ExecStart = "${qb}/bin/qbittorrent --confirm-legal-notice"; + NetworkNamespacePath = "/run/netns/${ns}"; + + RuntimeDirectory = "qbittorrent-vpn"; + RuntimeDirectoryMode = "0700"; + # Hides /home and /run/user; only the paths bound below come back. No + # session bus: through it, systemd --user runs anything unsandboxed. + ProtectHome = "tmpfs"; + TemporaryFileSystem = [ "/mnt:ro" "/media:ro" ]; + BindPaths = writable + ++ [ "-/run/user/${toString cfg.uid}/${cfg.waylandDisplay}:/run/qbittorrent-vpn/wayland" ]; + BindReadOnlyPaths = themes + ++ [ "/etc/netns/${ns}/resolv.conf:/etc/resolv.conf" ]; + InaccessiblePaths = [ + # nscd and resolved answer from the ROOT namespace — reachable through + # their sockets, they would resolve outside the tunnel. + "-/run/nscd" + "-/run/systemd/resolve" + # darman-owned sops secrets, and sockets that act on darman's behalf. + "-/run/secrets" + "-/run/secrets.d" + "-/run/pass-broker.sock" + "-/run/tailscale" + "-/run/ssh-unix-local" + ]; + + ProtectSystem = "strict"; + PrivateTmp = true; + PrivateDevices = true; + PrivatePIDs = true; + ProtectProc = "invisible"; + NoNewPrivileges = true; + CapabilityBoundingSet = ""; + RestrictSUIDSGID = true; + ProtectKernelTunables = true; + ProtectKernelModules = true; + ProtectKernelLogs = true; + ProtectControlGroups = true; + ProtectClock = true; + ProtectHostname = true; + RestrictNamespaces = true; + RestrictRealtime = true; + LockPersonality = true; + SystemCallArchitectures = "native"; + RestrictAddressFamilies = [ "AF_UNIX" "AF_INET" "AF_INET6" "AF_NETLINK" ]; + }; + }; + + systemd.services.proton-portforward = { + description = "ProtonVPN NAT-PMP port forwarding for qBittorrent"; + bindsTo = [ "qbittorrent-vpn.service" ]; + after = [ "qbittorrent-vpn.service" ]; + serviceConfig = { + ExecStart = portForward; + DynamicUser = true; + Restart = "always"; + RestartSec = 10; + NetworkNamespacePath = "/run/netns/${ns}"; + BindReadOnlyPaths = [ "/etc/netns/${ns}/resolv.conf:/etc/resolv.conf" ]; + InaccessiblePaths = [ "-/run/nscd" "-/run/systemd/resolve" ]; + }; + }; + + security.polkit.enable = true; + security.polkit.extraConfig = '' + polkit.addRule(function(action, subject) { + if (action.id == "org.freedesktop.systemd1.manage-units" && + action.lookup("unit") == "qbittorrent-vpn.service" && + ["start", "stop", "restart"].indexOf(action.lookup("verb")) >= 0 && + subject.user == "${cfg.user}") + return polkit.Result.YES; + }); + ''; + }; +}