nixos/modules/services/networking/tailscale.nix

   1 { config, lib, pkgs, ... }:
   2
   3 with lib;
   4
   5 let
   6   cfg = config.services.tailscale;
   7   isNetworkd = config.networking.useNetworkd;
   8 in {
   9   meta.maintainers = with maintainers; [ mbaillie mfrw ];
  10
  11   options.services.tailscale = {
  12     enable = mkEnableOption "Tailscale client daemon";
  13
  14     port = mkOption {
  15       type = types.port;
  16       default = 41641;
  17       description = "The port to listen on for tunnel traffic (0=autoselect).";
  18     };
  19
  20     interfaceName = mkOption {
  21       type = types.str;
  22       default = "tailscale0";
  23       description = ''The interface name for tunnel traffic. Use "userspace-networking" (beta) to not use TUN.'';
  24     };
  25
  26     permitCertUid = mkOption {
  27       type = types.nullOr types.nonEmptyStr;
  28       default = null;
  29       description = "Username or user ID of the user allowed to to fetch Tailscale TLS certificates for the node.";
  30     };
  31
  32     disableTaildrop = mkOption {
  33       default = false;
  34       type = types.bool;
  35       description = "Whether to disable the Taildrop feature for sending files between nodes.";
  36     };
  37
  38     package = lib.mkPackageOption pkgs "tailscale" {};
  39
  40     openFirewall = mkOption {
  41       default = false;
  42       type = types.bool;
  43       description = "Whether to open the firewall for the specified port.";
  44     };
  45
  46     useRoutingFeatures = mkOption {
  47       type = types.enum [ "none" "client" "server" "both" ];
  48       default = "none";
  49       example = "server";
  50       description = ''
  51         Enables settings required for Tailscale's routing features like subnet routers and exit nodes.
  52
  53         To use these these features, you will still need to call `sudo tailscale up` with the relevant flags like `--advertise-exit-node` and `--exit-node`.
  54
  55         When set to `client` or `both`, reverse path filtering will be set to loose instead of strict.
  56         When set to `server` or `both`, IP forwarding will be enabled.
  57       '';
  58     };
  59
  60     authKeyFile = mkOption {
  61       type = types.nullOr types.path;
  62       default = null;
  63       example = "/run/secrets/tailscale_key";
  64       description = ''
  65         A file containing the auth key.
  66         Tailscale will be automatically started if provided.
  67       '';
  68     };
  69
  70     authKeyParameters = mkOption {
  71       type = types.submodule {
  72         options = {
  73           ephemeral = mkOption {
  74             type = types.nullOr types.bool;
  75             default = null;
  76             description = "Whether to register as an ephemeral node.";
  77           };
  78           preauthorized = mkOption {
  79             type = types.nullOr types.bool;
  80             default = null;
  81             description = "Whether to skip manual device approval.";
  82           };
  83           baseURL = mkOption {
  84             type = types.nullOr types.str;
  85             default = null;
  86             description = "Base URL for the Tailscale API.";
  87           };
  88         };
  89       };
  90       default = { };
  91       description = ''
  92         Extra parameters to pass after the auth key.
  93         See https://tailscale.com/kb/1215/oauth-clients#registering-new-nodes-using-oauth-credentials
  94       '';
  95     };
  96
  97     extraUpFlags = mkOption {
  98       description = ''
  99         Extra flags to pass to {command}`tailscale up`. Only applied if `authKeyFile` is specified.";
 100       '';
 101       type = types.listOf types.str;
 102       default = [];
 103       example = ["--ssh"];
 104     };
 105
 106     extraSetFlags = mkOption {
 107       description = "Extra flags to pass to {command}`tailscale set`.";
 108       type = types.listOf types.str;
 109       default = [];
 110       example = ["--advertise-exit-node"];
 111     };
 112
 113     extraDaemonFlags = mkOption {
 114       description = "Extra flags to pass to {command}`tailscaled`.";
 115       type = types.listOf types.str;
 116       default = [];
 117       example = ["--no-logs-no-support"];
 118     };
 119   };
 120
 121   config = mkIf cfg.enable {
 122     environment.systemPackages = [ cfg.package ]; # for the CLI
 123     systemd.packages = [ cfg.package ];
 124     systemd.services.tailscaled = {
 125       after = lib.mkIf (config.networking.networkmanager.enable) [ "NetworkManager-wait-online.service" ];
 126       wantedBy = [ "multi-user.target" ];
 127       path = [
 128         (builtins.dirOf config.security.wrapperDir) # for `su` to use taildrive with correct access rights
 129         pkgs.procps     # for collecting running services (opt-in feature)
 130         pkgs.getent     # for `getent` to look up user shells
 131         pkgs.kmod       # required to pass tailscale's v6nat check
 132       ] ++ lib.optional config.networking.resolvconf.enable config.networking.resolvconf.package;
 133       serviceConfig.Environment = [
 134         "PORT=${toString cfg.port}"
 135         ''"FLAGS=--tun ${lib.escapeShellArg cfg.interfaceName} ${lib.concatStringsSep " " cfg.extraDaemonFlags}"''
 136       ] ++ (lib.optionals (cfg.permitCertUid != null) [
 137         "TS_PERMIT_CERT_UID=${cfg.permitCertUid}"
 138       ]) ++ (lib.optionals (cfg.disableTaildrop) [
 139         "TS_DISABLE_TAILDROP=true"
 140       ]);
 141       # Restart tailscaled with a single `systemctl restart` at the
 142       # end of activation, rather than a `stop` followed by a later
 143       # `start`. Activation over Tailscale can hang for tens of
 144       # seconds in the stop+start setup, if the activation script has
 145       # a significant delay between the stop and start phases
 146       # (e.g. script blocked on another unit with a slow shutdown).
 147       #
 148       # Tailscale is aware of the correctness tradeoff involved, and
 149       # already makes its upstream systemd unit robust against unit
 150       # version mismatches on restart for compatibility with other
 151       # linux distros.
 152       stopIfChanged = false;
 153     };
 154
 155     systemd.services.tailscaled-autoconnect = mkIf (cfg.authKeyFile != null) {
 156       after = ["tailscaled.service"];
 157       wants = ["tailscaled.service"];
 158       wantedBy = [ "multi-user.target" ];
 159       serviceConfig = {
 160         Type = "oneshot";
 161       };
 162       # https://github.com/tailscale/tailscale/blob/v1.72.1/ipn/backend.go#L24-L32
 163       script = let
 164         statusCommand = "${lib.getExe cfg.package} status --json --peers=false | ${lib.getExe pkgs.jq} -r '.BackendState'";
 165         paramToString = v:
 166           if (builtins.isBool v) then (lib.boolToString v)
 167           else (toString v);
 168         params = lib.pipe cfg.authKeyParameters [
 169           (lib.filterAttrs (_: v: v != null))
 170           (lib.mapAttrsToList (k: v: "${k}=${paramToString v}"))
 171           (builtins.concatStringsSep "&")
 172           (params: if params != "" then "?${params}" else "")
 173         ];
 174       in ''
 175         while [[ "$(${statusCommand})" == "NoState" ]]; do
 176           sleep 0.5
 177         done
 178         status=$(${statusCommand})
 179         if [[ "$status" == "NeedsLogin" || "$status" == "NeedsMachineAuth" ]]; then
 180           ${lib.getExe cfg.package} up --auth-key "$(cat ${cfg.authKeyFile})${params}" ${escapeShellArgs cfg.extraUpFlags}
 181         fi
 182       '';
 183     };
 184
 185     systemd.services.tailscaled-set = mkIf (cfg.extraSetFlags != []) {
 186       after = ["tailscaled.service"];
 187       wants = ["tailscaled.service"];
 188       wantedBy = [ "multi-user.target" ];
 189       serviceConfig = {
 190         Type = "oneshot";
 191       };
 192       script = ''
 193         ${lib.getExe cfg.package} set ${escapeShellArgs cfg.extraSetFlags}
 194       '';
 195     };
 196
 197     boot.kernel.sysctl = mkIf (cfg.useRoutingFeatures == "server" || cfg.useRoutingFeatures == "both") {
 198       "net.ipv4.conf.all.forwarding" = mkOverride 97 true;
 199       "net.ipv6.conf.all.forwarding" = mkOverride 97 true;
 200     };
 201
 202     networking.firewall.allowedUDPPorts = mkIf cfg.openFirewall [ cfg.port ];
 203
 204     networking.firewall.checkReversePath = mkIf (cfg.useRoutingFeatures == "client" || cfg.useRoutingFeatures == "both") "loose";
 205
 206     networking.dhcpcd.denyInterfaces = [ cfg.interfaceName ];
 207
 208     systemd.network.networks."50-tailscale" = mkIf isNetworkd {
 209       matchConfig = {
 210         Name = cfg.interfaceName;
 211       };
 212       linkConfig = {
 213         Unmanaged = true;
 214         ActivationPolicy = "manual";
 215       };
 216     };
 217   };
 218 }