nixpkgs/nixos/tests/sftpgo.nix

# SFTPGo NixOS test
#
# This NixOS test sets up a basic test scenario for the SFTPGo module
# and covers the following scenarios:
# - uploading a file via sftp
# - downloading the file over sftp
# - assert that the ACLs are respected
# - share a file between alice and bob (using sftp)
# - assert that eve cannot acceess the shared folder between alice and bob.
#
# Additional test coverage for the remaining protocols (i.e. ftp, http and webdav)
# would be a nice to have for the future.
{ pkgs, lib, ...  }:

let
  inherit (import ./ssh-keys.nix pkgs) snakeOilPrivateKey snakeOilPublicKey;

  # Returns an attributeset of users who are not system users.
  normalUsers = config:
    lib.filterAttrs (name: user: user.isNormalUser) config.users.users;

  # Returns true if a user is a member of the given group
  isMemberOf =
    config:
    # str
    groupName:
    # users.users attrset
    user:
      lib.any (x: x == user.name) config.users.groups.${groupName}.members;

  # Generates a valid SFTPGo user configuration for a given user
  # Will be converted to JSON and loaded on application startup.
  generateUserAttrSet =
    config:
    # attrset returned by config.users.users.<username>
    user: {
      # 0: user is disabled, login is not allowed
      # 1: user is enabled
      status = 1;

      username = user.name;
      password = ""; # disables password authentication
      public_keys = user.openssh.authorizedKeys.keys;
      email = "${user.name}@example.com";

      # User home directory on the local filesystem
      home_dir = "${config.services.sftpgo.dataDir}/users/${user.name}";

      # Defines a mapping between virtual SFTPGo paths and filesystem paths outside the user home directory.
      #
      # Supported for local filesystem only. If one or more of the specified folders are not
      # inside the dataprovider they will be automatically created.
      # You have to create the folder on the filesystem yourself
      virtual_folders =
        lib.optional (isMemberOf config sharedFolderName user) {
          name = sharedFolderName;
          mapped_path = "${config.services.sftpgo.dataDir}/${sharedFolderName}";
          virtual_path = "/${sharedFolderName}";
        };

      # Defines the ACL on the virtual filesystem
      permissions =
        lib.recursiveUpdate {
          "/" = [ "list" ];     # read-only top level directory
          "/private" = [ "*" ]; # private subdirectory, not shared with others
        } (lib.optionalAttrs (isMemberOf config "shared" user) {
          "/shared" = [ "*" ];
        });

      filters = {
        allowed_ip = [];
        denied_ip = [];
        web_client = [
          "password-change-disabled"
          "password-reset-disabled"
          "api-key-auth-change-disabled"
        ];
      };

      upload_bandwidth = 0; # unlimited
      download_bandwidth = 0; # unlimited
      expiration_date = 0; # means no expiration
      max_sessions = 0;
      quota_size = 0;
      quota_files = 0;
    };

  # Generates a json file containing a static configuration
  # of users and folders to import to SFTPGo.
  loadDataJson = config: pkgs.writeText "users-and-folders.json" (builtins.toJSON {
    users =
      lib.mapAttrsToList (name: user: generateUserAttrSet config user) (normalUsers config);

    folders = [
      {
        name = sharedFolderName;
        description = "shared folder";

        # 0: local filesystem
        # 1: AWS S3 compatible
        # 2: Google Cloud Storage
        filesystem.provider = 0;

        # Mapped path on the local filesystem
        mapped_path = "${config.services.sftpgo.dataDir}/${sharedFolderName}";

        # All users in the matching group gain access
        users = config.users.groups.${sharedFolderName}.members;
      }
    ];
  });

  # Generated Host Key for connecting to SFTPGo's sftp subsystem.
  snakeOilHostKey = pkgs.writeText "sftpgo_ed25519_host_key" ''
    -----BEGIN OPENSSH PRIVATE KEY-----
    b3BlbnNzaC1rZXktdjEAAAAABG5vbmUAAAAEbm9uZQAAAAAAAAABAAAAMwAAAAtzc2gtZW
    QyNTUxOQAAACBOtQu6U135yxtrvUqPoozUymkjoNNPVK6rqjS936RLtQAAAJAXOMoSFzjK
    EgAAAAtzc2gtZWQyNTUxOQAAACBOtQu6U135yxtrvUqPoozUymkjoNNPVK6rqjS936RLtQ
    AAAEAoRLEV1VD80mg314ObySpfrCcUqtWoOSS3EtMPPhx08U61C7pTXfnLG2u9So+ijNTK
    aSOg009UrquqNL3fpEu1AAAADHNmdHBnb0BuaXhvcwE=
    -----END OPENSSH PRIVATE KEY-----
  '';

  adminUsername = "admin";
  adminPassword = "secretadminpassword";
  aliceUsername = "alice";
  alicePassword = "secretalicepassword";
  bobUsername = "bob";
  bobPassword = "secretbobpassword";
  eveUsername = "eve";
  evePassword = "secretevepassword";
  sharedFolderName = "shared";

  # A file for testing uploading via SFTP
  testFile = pkgs.writeText "test.txt" "hello world";
  sharedFile = pkgs.writeText "shared.txt" "shared content";

  # Define the for exposing SFTP
  sftpPort = 2022;

  # Define the for exposing HTTP
  httpPort = 8080;
in
{
  name = "sftpgo";

  meta.maintainers = with lib.maintainers; [ yayayayaka ];

  nodes = {
    server = { nodes, ... }: {
      networking.firewall.allowedTCPPorts = [ sftpPort httpPort ];

      # nodes.server.configure postgresql database
      services.postgresql = {
        enable = true;
        ensureDatabases = [ "sftpgo" ];
        ensureUsers = [{
          name = "sftpgo";
          ensureDBOwnership = true;
        }];
      };

      services.sftpgo = {
        enable = true;

        loadDataFile = (loadDataJson nodes.server);

        settings = {
          data_provider = {
            driver = "postgresql";
            name = "sftpgo";
            username = "sftpgo";
            host = "/run/postgresql";
            port = 5432;

            # Enables the possibility to create an initial admin user on first startup.
            create_default_admin = true;
          };

          httpd.bindings = [
            {
              address = ""; # listen on all interfaces
              port = httpPort;
              enable_https = false;

              enable_web_client = true;
              enable_web_admin = true;
            }
          ];

          # Enable sftpd
          sftpd = {
            bindings = [{
              address = ""; # listen on all interfaces
              port = sftpPort;
            }];
            host_keys = [ snakeOilHostKey ];
            password_authentication = false;
            keyboard_interactive_authentication = false;
          };
        };
      };

      systemd.services.sftpgo = {
        after = [ "postgresql.service"];
        environment = {
          # Update existing users
          SFTPGO_LOADDATA_MODE = "0";
          SFTPGO_DEFAULT_ADMIN_USERNAME = adminUsername;

          # This will end up in cleartext in the systemd service.
          # Don't use this approach in production!
          SFTPGO_DEFAULT_ADMIN_PASSWORD = adminPassword;
        };
      };

      # Sets up the folder hierarchy on the local filesystem
      systemd.tmpfiles.rules =
        let
          sftpgoUser = nodes.server.services.sftpgo.user;
          sftpgoGroup = nodes.server.services.sftpgo.group;
          statePath = nodes.server.services.sftpgo.dataDir;
        in [
          # Create state directory
          "d ${statePath} 0750 ${sftpgoUser} ${sftpgoGroup} -"
          "d ${statePath}/users 0750 ${sftpgoUser} ${sftpgoGroup} -"

          # Created shared folder directories
          "d ${statePath}/${sharedFolderName} 2770 ${sftpgoUser} ${sharedFolderName}   -"
        ]
        ++ lib.mapAttrsToList (name: user:
          # Create private user directories
          ''
            d ${statePath}/users/${user.name} 0700 ${sftpgoUser} ${sftpgoGroup} -
            d ${statePath}/users/${user.name}/private 0700 ${sftpgoUser} ${sftpgoGroup} -
          ''
        ) (normalUsers nodes.server);

      users.users =
        let
          commonAttrs = {
            isNormalUser = true;
            openssh.authorizedKeys.keys = [ snakeOilPublicKey ];
          };
        in {
          # SFTPGo admin user
          admin = commonAttrs // {
            password = adminPassword;
          };

          # Alice and bob share folders with each other
          alice = commonAttrs // {
            password = alicePassword;
            extraGroups = [ sharedFolderName ];
          };

          bob = commonAttrs // {
            password = bobPassword;
            extraGroups = [ sharedFolderName ];
          };

          # Eve has no shared folders
          eve = commonAttrs // {
            password = evePassword;
          };
        };

      users.groups.${sharedFolderName} = {};

      specialisation = {
        # A specialisation for asserting that SFTPGo can bind to privileged ports.
        privilegedPorts.configuration = { ... }: {
          networking.firewall.allowedTCPPorts = [ 22 80 ];
          services.sftpgo = {
            settings = {
              sftpd.bindings = lib.mkForce [{
                address = "";
                port = 22;
              }];

              httpd.bindings = lib.mkForce [{
                address = "";
                port = 80;
              }];
            };
          };
        };
      };
    };

    client = { nodes, ... }: {
      # Add the SFTPGo host key to the global known_hosts file
      programs.ssh.knownHosts =
        let
          commonAttrs = {
            publicKey = "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIE61C7pTXfnLG2u9So+ijNTKaSOg009UrquqNL3fpEu1";
          };
        in {
          "server" = commonAttrs;
          "[server]:2022" = commonAttrs;
        };
      };
  };

  testScript = { nodes, ... }: let
    # A function to generate test cases for wheter
    # a specified username is expected to access the shared folder.
    accessSharedFoldersSubtest =
      { # The username to run as
        username
        # Whether the tests are expected to succeed or not
      , shouldSucceed ? true
      }: ''
        with subtest("Test whether ${username} can access shared folders"):
            client.${if shouldSucceed then "succeed" else "fail"}("sftp -P ${toString sftpPort} -b ${
              pkgs.writeText "${username}-ls-${sharedFolderName}" ''
                ls ${sharedFolderName}
              ''
            } ${username}@server")
      '';
      statePath = nodes.server.services.sftpgo.dataDir;
  in ''
    start_all()

    client.wait_for_unit("default.target")
    server.wait_for_unit("sftpgo.service")

    with subtest("web client"):
        client.wait_until_succeeds("curl -sSf http://server:${toString httpPort}/web/client/login")

        # Ensure sftpgo found the static folder
        client.wait_until_succeeds("curl -o /dev/null -sSf http://server:${toString httpPort}/static/favicon.ico")

    with subtest("Setup SSH keys"):
        client.succeed("mkdir -m 700 /root/.ssh")
        client.succeed("cat ${snakeOilPrivateKey} > /root/.ssh/id_ecdsa")
        client.succeed("chmod 600 /root/.ssh/id_ecdsa")

    with subtest("Copy a file over sftp"):
        client.wait_until_succeeds("scp -P ${toString sftpPort} ${toString testFile} alice@server:/private/${testFile.name}")
        server.succeed("test -s ${statePath}/users/alice/private/${testFile.name}")

        # The configured ACL should prevent uploading files to the root directory
        client.fail("scp -P ${toString sftpPort} ${toString testFile} alice@server:/")

    with subtest("Attempting an interactive SSH sessions must fail"):
        client.fail("ssh -p ${toString sftpPort} alice@server")

    ${accessSharedFoldersSubtest {
      username = "alice";
      shouldSucceed = true;
    }}

    ${accessSharedFoldersSubtest {
      username = "bob";
      shouldSucceed = true;
    }}

    ${accessSharedFoldersSubtest {
      username = "eve";
      shouldSucceed = false;
    }}

    with subtest("Test sharing files"):
        # Alice uploads a file to shared folder
        client.succeed("scp -P ${toString sftpPort} ${toString sharedFile} alice@server:/${sharedFolderName}/${sharedFile.name}")
        server.succeed("test -s ${statePath}/${sharedFolderName}/${sharedFile.name}")

        # Bob downloads the file from shared folder
        client.succeed("scp -P ${toString sftpPort} bob@server:/shared/${sharedFile.name} ${sharedFile.name}")
        client.succeed("test -s ${sharedFile.name}")

        # Eve should not get the file from shared folder
        client.fail("scp -P ${toString sftpPort} eve@server:/shared/${sharedFile.name}")

    server.succeed("/run/current-system/specialisation/privilegedPorts/bin/switch-to-configuration test")

    client.wait_until_succeeds("sftp -P 22 -b ${pkgs.writeText "get-hello-world.txt" ''
      get /private/${testFile.name}
    ''} alice@server")
  '';
}