simple-nixos-mailserver/mail-server/rspamd.nix

#  nixos-mailserver: a simple mail server
#  Copyright (C) 2016-2018  Robin Raymond
#
#  This program is free software: you can redistribute it and/or modify
#  it under the terms of the GNU General Public License as published by
#  the Free Software Foundation, either version 3 of the License, or
#  (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program. If not, see <http://www.gnu.org/licenses/>

{
  config,
  pkgs,
  lib,
  ...
}:

let
  cfg = config.mailserver;

  postfixCfg = config.services.postfix;
  rspamdCfg = config.services.rspamd;
  rspamdSocket = "rspamd.service";

  rspamdUser = config.services.rspamd.user;
  rspamdGroup = config.services.rspamd.group;

  createDkimKeypair =
    domain:
    let
      privateKey = "${cfg.dkimKeyDirectory}/${domain}.${cfg.dkimSelector}.key";
      publicKey = "${cfg.dkimKeyDirectory}/${domain}.${cfg.dkimSelector}.txt";
    in
    pkgs.writeShellScript "dkim-keygen-${domain}" ''
      if [ ! -f "${privateKey}" ]
      then
        ${lib.getExe' pkgs.rspamd "rspamadm"} dkim_keygen \
          --domain "${domain}" \
          --selector "${cfg.dkimSelector}" \
          --type "${cfg.dkimKeyType}" \
          --bits ${toString cfg.dkimKeyBits} \
          --privkey "${privateKey}" > "${publicKey}"
        chmod 0644 "${publicKey}"
        echo "Generated key for domain ${domain} and selector ${cfg.dkimSelector}"
      fi
    '';

  dkimDomains = lib.unique (cfg.domains ++ (lib.optionals cfg.srs.enable [ cfg.srs.domain ]));
in
{
  config = lib.mkIf cfg.enable {
    environment.systemPackages = lib.mkBefore [
      (pkgs.runCommand "rspamc-wrapped"
        {
          nativeBuildInputs = with pkgs; [ makeWrapper ];
        }
        ''
          makeWrapper ${pkgs.rspamd}/bin/rspamc $out/bin/rspamc \
            --add-flags "-h /run/rspamd/worker-controller.sock"
        ''
      )
    ];

    services.rspamd = {
      enable = true;
      debug = cfg.debug.rspamd;
      locals = {
        "milter_headers.conf" = {
          text = ''
            extended_spam_headers = true;
          '';
        };
        "redis.conf" = {
          text = ''
            servers = "${
              if cfg.redis.port == null then
                cfg.redis.address
              else
                "${cfg.redis.address}:${toString cfg.redis.port}"
            }";
          ''
          + (lib.optionalString (cfg.redis.password != null) ''
            password = "${cfg.redis.password}";
          '');
        };
        "classifier-bayes.conf" = {
          text = ''
            cache {
              backend = "redis";
            }
          '';
        };
        "antivirus.conf" = lib.mkIf cfg.virusScanning {
          text = ''
            clamav {
              action = "reject";
              symbol = "CLAM_VIRUS";
              type = "clamav";
              log_clean = true;
              servers = "/run/clamav/clamd.ctl";
              scan_mime_parts = false; # scan mail as a whole unit, not parts. seems to be needed to work at all
            }
          '';
        };
        "dkim_signing.conf" = {
          text = ''
            enabled = ${lib.boolToString cfg.dkimSigning};
            path = "${cfg.dkimKeyDirectory}/$domain.$selector.key";
            selector = "${cfg.dkimSelector}";
            # Allow for usernames w/o domain part
            allow_username_mismatch = true;
            # Don't normalize DKIM key selection for subdomains
            use_esld = false;
          '';
        };
        "dmarc.conf" = {
          text = ''
            ${lib.optionalString cfg.dmarcReporting.enable ''
              reporting {
                enabled = true;
                email = "noreply-dmarc@${cfg.systemDomain}";
                domain = "${cfg.systemDomain}";
                org_name = "${cfg.systemName}";
                from_name = "${cfg.systemName}";
                msgid_from = "${cfg.systemDomain}";
                ${lib.optionalString (cfg.dmarcReporting.excludeDomains != [ ]) ''
                  exclude_domains = ${builtins.toJSON cfg.dmarcReporting.excludeDomains};
                ''}
              }''}
          '';
        };
      };
      overrides = {
        "options.inc" = {
          text = ''
            local_addrs = [::1/128, 127.0.0.0/8]
          '';
        };
      };

      workers.rspamd_proxy = {
        type = "rspamd_proxy";
        bindSockets = [
          {
            socket = "/run/rspamd/rspamd-milter.sock";
            mode = "0664";
          }
        ];
        count = 1; # Do not spawn too many processes of this type
        extraConfig = ''
          milter = yes; # Enable milter mode
          timeout = 120s; # Needed for Milter usually

          upstream "local" {
            default = yes; # Self-scan upstreams are always default
            self_scan = yes; # Enable self-scan
          }
        '';
      };
      workers.controller = {
        type = "controller";
        count = 1;
        bindSockets = [
          {
            socket = "/run/rspamd/worker-controller.sock";
            mode = "0666";
          }
        ];
        includes = [ ];
        extraConfig = ''
          static_dir = "''${WWWDIR}"; # Serve the web UI static assets
        '';
      };

    };

    services.redis.servers.rspamd.enable = lib.mkDefault cfg.redis.configureLocally;

    systemd.tmpfiles.settings."10-rspamd.conf" = {
      "${cfg.dkimKeyDirectory}" = {
        d = {
          # Create /var/dkim owned by rspamd user/group
          user = rspamdUser;
          group = rspamdGroup;
        };
        Z = {
          # Recursively adjust permissions in /var/dkim
          user = rspamdUser;
          group = rspamdGroup;
        };
      };
    };

    systemd.services.rspamd = {
      requires = [ "redis-rspamd.service" ] ++ (lib.optional cfg.virusScanning "clamav-daemon.service");
      after = [ "redis-rspamd.service" ] ++ (lib.optional cfg.virusScanning "clamav-daemon.service");
      serviceConfig = lib.mkMerge [
        {
          SupplementaryGroups = [ config.services.redis.servers.rspamd.group ];
        }
        (lib.optionalAttrs cfg.dkimSigning {
          ExecStartPre = map createDkimKeypair dkimDomains;
          ReadWritePaths = [ cfg.dkimKeyDirectory ];
        })
      ];
    };

    systemd.services.rspamd-dmarc-reporter = lib.optionalAttrs cfg.dmarcReporting.enable {
      # Explicitly select yesterday's date to work around broken
      # default behaviour when called without a date.
      # https://github.com/rspamd/rspamd/issues/4062
      script = toString [
        (lib.getExe' pkgs.rspamd "rspamadm")
        "dmarc_report"
        "$(date -d 'yesterday' '+%Y%m%d')"
      ];
      serviceConfig = {
        User = "${config.services.rspamd.user}";
        Group = "${config.services.rspamd.group}";

        AmbientCapabilities = [ ];
        CapabilityBoundingSet = "";
        DevicePolicy = "closed";
        IPAddressAllow = "localhost";
        LockPersonality = true;
        NoNewPrivileges = true;
        PrivateDevices = true;
        PrivateMounts = true;
        PrivateTmp = true;
        PrivateUsers = true;
        ProtectClock = true;
        ProtectControlGroups = true;
        ProtectHome = true;
        ProtectHostname = true;
        ProtectKernelLogs = true;
        ProtectKernelModules = true;
        ProtectKernelTunables = true;
        ProtectProc = "invisible";
        ProcSubset = "pid";
        ProtectSystem = "strict";
        RemoveIPC = true;
        RestrictAddressFamilies = [
          "AF_INET"
          "AF_INET6"
          "AF_UNIX"
        ];
        RestrictNamespaces = true;
        RestrictRealtime = true;
        RestrictSUIDSGID = true;
        SupplementaryGroups = lib.optionals cfg.redis.configureLocally [
          config.services.redis.servers.rspamd.group
        ];
        SystemCallArchitectures = "native";
        SystemCallFilter = [
          "@system-service"
          "~@privileged"
        ];
        UMask = "0077";
      };
    };

    systemd.timers.rspamd-dmarc-reporter = lib.optionalAttrs cfg.dmarcReporting.enable {
      description = "Daily delivery of aggregated DMARC reports";
      wantedBy = [
        "timers.target"
      ];
      timerConfig = {
        OnCalendar = "daily";
        Persistent = true;
        RandomizedDelaySec = 86400;
        FixedRandomDelay = true;
      };
    };

    systemd.services.postfix = {
      after = [ rspamdSocket ];
      requires = [ rspamdSocket ];
    };

    users.extraUsers.${postfixCfg.user}.extraGroups = [ rspamdCfg.group ];
  };
}