chore(deps): Upgrade filtermail to v0.7.6

## 0.7.6 - 2026-09-11

### Miscellaneous Tasks

- Always use --locked flag in CI

### Performance

- Don't keep multiple copies of the same mail data in memory

## 0.7.5 - 2026-09-10

### Performance

- Pass HttpsClient by reference instead of cloning it
- Remove connection pool

### Refactor

- Do not evaluate smtp_write! argument twice
- Do not clone the Config unnecessarily

Signed-off-by: Jagoda Ślązak <jslazak@jslazak.com>

.github/workflows/ci.yaml

@@ -29,7 +29,7 @@ jobs:
           ref: ${{ github.event.pull_request.head.sha }}
           persist-credentials: false
       - name: download filtermail
-        run: curl -L https://github.com/chatmail/filtermail/releases/download/v0.7.4/filtermail-x86_64 -o /usr/local/bin/filtermail && chmod +x /usr/local/bin/filtermail
+        run: curl -L https://github.com/chatmail/filtermail/releases/download/v0.7.6/filtermail-x86_64 -o /usr/local/bin/filtermail && chmod +x /usr/local/bin/filtermail
       - name: run chatmaild tests 
         working-directory: chatmaild
         run: pipx run tox

.github/workflows/docs-preview.yaml

@@ -13,6 +13,11 @@ jobs:
   scripts:
     name: build 
     runs-on: ubuntu-latest
+    env:
+      # Pin the repository links in the docs to this pull request's head commit
+      # so that linkcheck resolves files which only exist on the branch so far.
+      # see doc/conf.py
+      DOC_GITHUB_REF: ${{ github.event.pull_request.head.sha }}
     environment:
       name: 'staging.chatmail.at/doc/relay/'
       url: https://staging.chatmail.at/doc/relay/${{ steps.prepare.outputs.prid }}

chatmaild/pyproject.toml

@@ -27,9 +27,6 @@ chatmail-quota-expire = "chatmaild.expire:quota_expire_main"
 chatmail-fsreport = "chatmaild.fsreport:main"
 lastlogin = "chatmaild.lastlogin:main"
 
-[project.entry-points.pytest11]
-"chatmaild.testplugin" = "chatmaild.tests.plugin"
-
 [tool.pytest.ini_options]
 addopts = "-v -ra --strict-markers"
 log_format = "%(asctime)s %(levelname)s %(message)s"

chatmaild/src/chatmaild/config.py

@@ -55,6 +55,7 @@ class Config:
         self.postfix_reinject_port_incoming = int(
             params.pop("postfix_reinject_port_incoming", "10026")
         )
+        self.doveauth_http_port = int(params.pop("doveauth_http_port", "10084"))
         self.mtail_address = params.pop("mtail_address", None)
         self.disable_ipv6 = params.pop("disable_ipv6", "false").lower() == "true"
         self.acme_email = params.pop("acme_email", "")

chatmaild/src/chatmaild/defaults/appversions.json

@@ -5,9 +5,9 @@
       "sources": [
         {
           "sourceId": "gplay",
-          "versionInteger": 754,
-          "versionString": "2.57.0",
-          "downloadUrl": "https://github.com/deltachat/deltachat-android/releases/download/v2.57.0/deltachat-gplay-release-2.57.0.apk"
+          "versionInteger": 757,
+          "versionString": "2.59.1",
+          "downloadUrl": "https://github.com/deltachat/deltachat-android/releases/download/v2.59.1/deltachat-gplay-release-2.59.1.apk"
         }
       ]
     }

chatmaild/src/chatmaild/doveauth.py

@@ -1,10 +1,17 @@
-import json
+"""Create chatmail addresses on first login.
+
+Dovecot only asks us about addresses it does not already find in the mailbox:
+the auth.lua we deploy with dovecot (cmdeploy/src/cmdeploy/dovecot/auth.lua.j2)
+verifies existing users itself against a mailbox password file,
+and HTTP-POSTs everything else to the /create endpoint implemented in this module.
+"""
+
 import logging
 import os
 import re
 import sys
-
-import filelock
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
 try:
     import crypt_r
@@ -12,7 +19,6 @@ except ImportError:
     import crypt as crypt_r
 
 from .config import Config, read_config
-from .dictproxy import DictProxy
 from .migrate_db import migrate_from_db_to_maildir
 from .syslimits import has_sufficient_resources
 
@@ -64,109 +70,117 @@ def is_allowed_to_create(config: Config, user, cleartext_password) -> bool:
     return True
 
 
-def split_and_unescape(s):
-    """Split strings using double quote as a separator and backslash as escape character
-    into parts."""
-
-    out = ""
-    i = 0
-    while i < len(s):
-        c = s[i]
-        if c == "\\":
-            # Skip escape character.
-            i += 1
-
-            # This will raise IndexError if there is no character
-            # after escape character. This is expected
-            # as this is an invalid input.
-            out += s[i]
-        elif c == '"':
-            # Separator
-            yield out
-            out = ""
-        else:
-            out += c
-        i += 1
-    yield out
+def verify_password(stored, cleartext_password) -> bool:
+    if stored.startswith("{"):
+        stored = stored.split("}", 1)[1]
+    return crypt_r.crypt(cleartext_password, stored) == stored
 
 
-class AuthDictProxy(DictProxy):
+class DoveAuth:
     def __init__(self, config):
-        super().__init__()
         self.config = config
+        self.creation_lock = threading.Lock()
 
-    def handle_lookup(self, parts):
-        # Dovecot <2.3.17 has only one part,
-        # do not attempt to read any other parts for compatibility.
-        keyname = parts[0]
-
-        namespace, type, args = keyname.split("/", 2)
-        args = list(split_and_unescape(args))
-
+    def create_user(self, addr, cleartext_password) -> bool:
+        """Create the address, or verify the password if it exists already."""
         config = self.config
-        reply_command = "F"
-        res = ""
-        if namespace == "shared":
-            if type == "userdb":
-                user = args[0]
-                if user.endswith(f"@{config.mail_domain}"):
-                    res = self.lookup_userdb(user)
-                if res:
-                    reply_command = "O"
-                else:
-                    reply_command = "N"
-            elif type == "passdb":
-                user = args[1]
-                if user.endswith(f"@{config.mail_domain}"):
-                    res = self.lookup_passdb(user, cleartext_password=args[0])
-                if res:
-                    reply_command = "O"
-                else:
-                    reply_command = "N"
-        json_res = json.dumps(res) if res else ""
-        return f"{reply_command}{json_res}\n"
-
-    def handle_iterate(self, parts):
-        # example: I0\t0\tshared/userdb/
-        if parts[2] == "shared/userdb/":
-            result = "".join(
-                f"Oshared/userdb/{user}\t\n" for user in self.iter_userdb()
-            )
-            return f"{result}\n"
-
-    def iter_userdb(self) -> list:
-        """Get a list of all user addresses."""
-        return [x for x in os.listdir(self.config.mailboxes_dir) if "@" in x]
-
-    def lookup_userdb(self, addr):
-        return self.config.get_user(addr).get_userdb_dict()
-
-    def lookup_passdb(self, addr, cleartext_password):
-        user = self.config.get_user(addr)
-        userdata = user.get_userdb_dict()
-        if userdata:
-            return userdata
-        if not is_allowed_to_create(self.config, addr, cleartext_password):
-            return
-        if not has_sufficient_resources(self.config):
-            return
-
-        lock = filelock.FileLock(str(user.password_path) + ".lock", timeout=5)
-        with lock:
-            userdata = user.get_userdb_dict()
-            if userdata:
-                return userdata
+        if not addr.endswith(f"@{config.mail_domain}"):
+            logging.warning("address not in mail domain: %r", addr)
+            return False
+        try:
+            user = config.get_user(addr)
+        except ValueError:
+            logging.warning("invalid address: %r", addr)
+            return False
+        with self.creation_lock:
+            passhash = user.get_password_hash()
+            if passhash is not None:
+                # a concurrent first login may have just created the address
+                return verify_password(passhash, cleartext_password)
+            if not is_allowed_to_create(config, addr, cleartext_password):
+                return False
+            if not has_sufficient_resources(config):
+                return False
             user.set_password(encrypt_password(cleartext_password))
-            print(f"Created address: {addr}", file=sys.stderr)
-        return user.get_userdb_dict()
+        # mtail counts created_accounts off this exact line
+        print(f"Created address: {addr}", file=sys.stderr)
+        return True
+
+
+class CreateHandler(BaseHTTPRequestHandler):
+    """Answer POST /create requests from dovecot's auth.lua, body `addr\\tpassword`.
+
+    The body must be UTF-8 and only the first tab separates the fields,
+    so a password may itself contain tabs.
+    Any non-UTF8 or \\0 bytes in the body fail the request.
+
+    Addresses are ASCII: dovecot refuses any login name outside its
+    auth_username_chars before auth.lua ever sees it.
+
+    Dovecot hands auth.lua the exact password bytes the client sent;
+    decoding and re-encoding UTF-8 is byte-identical,
+    so dovecot's password_verify later recomputes the same hash crypt() stores here.
+    """
+
+    protocol_version = "HTTP/1.1"  # dovecot's HTTP client reuses connections
+
+    max_body_len = 512  # an address and a password
+
+    def do_POST(self):
+        if self.path != "/create":
+            self.reply(404)
+            return
+        length = self.body_length()
+        if length is None:
+            self.reply(400)
+            return
+        body = self.rfile.read(length)
+        try:
+            addr, _, password = body.decode("utf-8").partition("\t")
+        except UnicodeDecodeError:
+            self.reply(400)
+            return
+        if "\0" in addr or "\0" in password:
+            self.reply(400)
+            return
+        self.reply(200 if self.server.doveauth.create_user(addr, password) else 403)
+
+    def body_length(self):
+        try:
+            length = int(self.headers["Content-Length"])
+        except (TypeError, ValueError):
+            return None
+        return length if 0 <= length <= self.max_body_len else None
+
+    def reply(self, status):
+        self.send_response(status)
+        self.send_header("Content-Length", "0")
+        if status != 200:
+            # Just close on any failure, as body might not be fully read.
+            # It's anyway cheap to re-establish http localhost without TLS.
+            self.send_header("Connection", "close")
+        self.end_headers()
+
+    def log_message(self, format, *args):
+        # the per-request access log would only duplicate our own stderr lines
+        pass
+
+
+class DoveAuthServer(ThreadingHTTPServer):
+    # a burst of first-time logins (e.g. from CI) must not overflow
+    # the accept queue, see https://github.com/chatmail/relay/issues/436
+    request_queue_size = 1000
+
+    def __init__(self, config, port):
+        super().__init__(("127.0.0.1", port), CreateHandler)
+        self.doveauth = DoveAuth(config)
 
 
 def main():
-    socket, cfgpath = sys.argv[1:]
+    (cfgpath,) = sys.argv[1:]
     config = read_config(cfgpath)
 
     migrate_from_db_to_maildir(config)
 
-    dictproxy = AuthDictProxy(config=config)
-
-    dictproxy.serve_forever_from_socket(socket)
+    server = DoveAuthServer(config, config.doveauth_http_port)
+    server.serve_forever()

chatmaild/src/chatmaild/expire.py

@@ -259,7 +259,7 @@ def daily_expire_main(args=None):
     args = parser.parse_args(args)
 
     config = read_config(args.chatmail_ini)
-    now = datetime.utcnow().timestamp()
+    now = time.time()
     if args.days:
         now = now - 86400 * int(args.days)
 

chatmaild/src/chatmaild/fsreport.py

@@ -27,6 +27,7 @@ to also write legacy metrics.py style output (default: /var/www/html/metrics):
 
 import os
 import tempfile
+import time
 from argparse import ArgumentParser
 from datetime import datetime
 
@@ -264,7 +265,7 @@ def main(args=None):
 
     config = read_config(args.chatmail_ini)
 
-    now = datetime.utcnow().timestamp()
+    now = time.time()
     if args.days:
         now = now - 86400 * int(args.days)
 

chatmaild/src/chatmaild/tests/conftest.py

@@ -0,0 +1,3 @@
+"""Opt in to the chatmaild fixtures, which are not registered globally."""
+
+from chatmaild.tests.plugin import *  # noqa: F403

chatmaild/src/chatmaild/tests/plugin.py

@@ -41,22 +41,22 @@ def ipv4_config(make_config):
 
 
 @pytest.fixture
-def maildomain(example_config):
+def example_maildomain(example_config):
     return example_config.mail_domain
 
 
 @pytest.fixture
-def testaddr(maildomain):
-    return f"user.name@{maildomain}"
+def testaddr(example_maildomain):
+    return f"user.name@{example_maildomain}"
 
 
 @pytest.fixture
-def gencreds(maildomain):
+def example_gencreds(example_maildomain):
     count = itertools.count()
     next(count)
 
     def gen(domain=None):
-        domain = domain if domain else maildomain
+        domain = domain if domain else example_maildomain
         while 1:
             num = next(count)
             alphanumeric = "abcdefghijklmnopqrstuvwxyz1234567890"

chatmaild/src/chatmaild/tests/test_config.py

@@ -30,9 +30,9 @@ def test_read_config_ipv4(ipv4_config):
     assert ipv4_config.mail_domain == "[1.3.3.7]"
 
 
-def test_read_config_basic_using_defaults(tmp_path, maildomain):
+def test_read_config_basic_using_defaults(tmp_path, example_maildomain):
     inipath = tmp_path.joinpath("chatmail.ini")
-    inipath.write_text(f"[params]\nmail_domain = {maildomain}")
+    inipath.write_text(f"[params]\nmail_domain = {example_maildomain}")
     example_config = read_config(inipath)
     assert example_config.max_user_send_per_minute == 60
     assert example_config.filtermail_smtp_port_incoming == 10081

chatmaild/src/chatmaild/tests/test_delete_inactive_users.py

@@ -1,6 +1,6 @@
 import time
 
-from chatmaild.doveauth import AuthDictProxy
+from chatmaild.doveauth import DoveAuth
 from chatmaild.expire import daily_expire_main as main_expire
 
 
@@ -18,10 +18,10 @@ def test_login_timestamps(example_config):
 def test_delete_inactive_users(example_config):
     new = time.time()
     old = new - (example_config.delete_inactive_users_after * 86400) - 1
-    dictproxy = AuthDictProxy(example_config)
+    doveauth = DoveAuth(example_config)
 
     def create_user(addr, last_login):
-        dictproxy.lookup_passdb(addr, "q9mr3faue")
+        doveauth.create_user(addr, "q9mr3faue")
         user = example_config.get_user(addr)
         user.maildir.joinpath("cur").mkdir()
         user.maildir.joinpath("cur", "something").mkdir()

chatmaild/src/chatmaild/tests/test_doveauth.py

@@ -1,42 +1,37 @@
-import io
-import json
-import queue
+import http.client
 import threading
-import traceback
+from concurrent.futures import ThreadPoolExecutor
 
 import pytest
 
 import chatmaild.doveauth
 from chatmaild.doveauth import (
-    AuthDictProxy,
+    CreateHandler,
+    DoveAuth,
+    DoveAuthServer,
     is_allowed_to_create,
 )
 from chatmaild.newemail import create_newemail_dict
 
 
 @pytest.fixture
-def dictproxy(example_config):
-    return AuthDictProxy(config=example_config)
+def doveauth(example_config):
+    return DoveAuth(example_config)
 
 
-def test_basic(dictproxy, gencreds):
-    addr, password = gencreds()
-    dictproxy.lookup_passdb(addr, password)
-    data = dictproxy.lookup_userdb(addr)
-    assert data
-    data2 = dictproxy.lookup_passdb(addr, password)
-    assert data == data2
+def stored_hash(config, addr):
+    return config.get_user(addr).get_password_hash()
 
 
-def test_iterate_addresses(dictproxy):
-    addresses = []
+def test_basic(doveauth, example_config, example_gencreds):
+    addr, password = example_gencreds()
+    assert doveauth.create_user(addr, password)
+    passhash = stored_hash(example_config, addr)
+    assert passhash.startswith("{SHA512-CRYPT}")
 
-    for i in range(10):
-        addresses.append(f"asdf1234{i}@chat.example.org")
-        dictproxy.lookup_passdb(addresses[-1], "q9mr3faue")
-
-    res = dictproxy.iter_userdb()
-    assert set(res) == set(addresses)
+    # a second login verifies against the stored hash and rewrites nothing
+    assert doveauth.create_user(addr, password)
+    assert stored_hash(example_config, addr) == passhash
 
 
 def test_invalid_username_length(example_config):
@@ -53,75 +48,32 @@ def test_invalid_username_length(example_config):
     )
 
 
-def test_dont_overwrite_password_on_wrong_login(dictproxy):
-    """Test that logging in with a different password doesn't create a new user"""
-    res = dictproxy.lookup_passdb(
-        "newuser12@chat.example.org", "kajdlkajsldk12l3kj1983"
-    )
-    assert res["password"]
-    res2 = dictproxy.lookup_passdb("newuser12@chat.example.org", "kajdslqwe")
-    # this function always returns a password hash, which is actually compared by dovecot.
-    assert res["password"] == res2["password"]
+def test_dont_overwrite_password_on_wrong_login(doveauth, example_config):
+    addr = "newuser12@chat.example.org"
+    assert doveauth.create_user(addr, "kajdlkajsldk12l3kj1983")
+    passhash = stored_hash(example_config, addr)
+
+    assert not doveauth.create_user(addr, "kajdslqwe")
+    assert stored_hash(example_config, addr) == passhash
+
+    assert doveauth.create_user(addr, "kajdlkajsldk12l3kj1983")
+    assert stored_hash(example_config, addr) == passhash
 
 
-def test_nocreate_file(monkeypatch, tmpdir, dictproxy):
+def test_foreign_domain_is_refused(doveauth):
+    assert not doveauth.create_user("newuser12@evil.example.org", "qlwkejqlwe12")
+
+
+def test_nocreate_file(monkeypatch, tmpdir, doveauth, example_config):
     p = tmpdir.join("nocreate")
     p.write("")
     monkeypatch.setattr(chatmaild.doveauth, "NOCREATE_FILE", str(p))
-    dictproxy.lookup_passdb("newuser12@chat.example.org", "zequ0Aimuchoodaechik")
-    assert not dictproxy.lookup_userdb("newuser12@chat.example.org")
-
-
-def test_handle_dovecot_request(dictproxy):
-    transactions = {}
-    # Test that password can contain ", ', \ and /
-    msg = (
-        'Lshared/passdb/laksjdlaksjdlak\\\\sjdlk\\"12j\\\'3l1/k2j3123"'
-        "some42123@chat.example.org\tsome42123@chat.example.org"
-    )
-    res = dictproxy.handle_dovecot_request(msg, transactions)
-    assert res
-    assert res[0] == "O" and res.endswith("\n")
-    userdata = json.loads(res[1:].strip())
-    assert userdata["home"].endswith("chat.example.org/some42123@chat.example.org")
-    assert userdata["uid"] == userdata["gid"] == "vmail"
-    assert userdata["password"].startswith("{SHA512-CRYPT}")
-
-
-def test_handle_dovecot_protocol_hello_is_skipped(example_config, caplog):
-    dictproxy = AuthDictProxy(config=example_config)
-    rfile = io.BytesIO(b"H3\t2\t0\t\tauth\n")
-    wfile = io.BytesIO()
-    dictproxy.loop_forever(rfile, wfile)
-    assert wfile.getvalue() == b""
-    assert not caplog.messages
-
-
-def test_handle_dovecot_protocol_user_not_exists(example_config):
-    dictproxy = AuthDictProxy(config=example_config)
-    rfile = io.BytesIO(
-        b"H3\t2\t0\t\tauth\nLshared/userdb/foobar@chat.example.org\tfoobar@chat.example.org\n"
-    )
-    wfile = io.BytesIO()
-    dictproxy.loop_forever(rfile, wfile)
-    assert wfile.getvalue() == b"N\n"
-
-
-def test_handle_dovecot_protocol_iterate(gencreds, example_config):
-    dictproxy = AuthDictProxy(config=example_config)
-    dictproxy.lookup_passdb("asdf00000@chat.example.org", "q9mr3faue")
-    dictproxy.lookup_passdb("asdf11111@chat.example.org", "q9mr3faue")
-    rfile = io.BytesIO(b"H3\t2\t0\t\tauth\nI0\t0\tshared/userdb/")
-    wfile = io.BytesIO()
-    dictproxy.loop_forever(rfile, wfile)
-    lines = wfile.getvalue().decode("ascii").split("\n")
-    assert "Oshared/userdb/asdf00000@chat.example.org\t" in lines
-    assert "Oshared/userdb/asdf11111@chat.example.org\t" in lines
-    assert not lines[2]
+    addr = "newuser12@chat.example.org"
+    assert not doveauth.create_user(addr, "zequ0Aimuchoodaechik")
+    assert stored_hash(example_config, addr) is None
 
 
 def test_invalid_localpart_characters(make_config):
-    """Test that is_allowed_to_create rejects localparts with invalid characters."""
     config = make_config("chat.example.org", {"username_min_length": "3"})
     password = "zequ0Aimuchoodaechik"
     domain = config.mail_domain
@@ -141,78 +93,150 @@ def test_invalid_localpart_characters(make_config):
     assert not is_allowed_to_create(config, f"ab@cdef@{domain}", password)
     assert not is_allowed_to_create(config, f"abc/def@{domain}", password)
     assert not is_allowed_to_create(config, f"abc\\def@{domain}", password)
+    assert not is_allowed_to_create(config, f"üser123@{domain}", password)
 
 
-def test_concurrent_creation_same_account(dictproxy):
-    """Test that concurrent creation of the same account doesn't corrupt password."""
+def test_concurrent_creation_same_account(doveauth, example_config, capsys):
     addr = "racetest1@chat.example.org"
     password = "zequ0Aimuchoodaechik"
-    num_threads = 10
-    results = queue.Queue()
 
-    def create():
-        try:
-            res = dictproxy.lookup_passdb(addr, password)
-            results.put(("ok", res))
-        except Exception:
-            results.put(("err", traceback.format_exc()))
-
-    threads = [threading.Thread(target=create, daemon=True) for _ in range(num_threads)]
-    for t in threads:
-        t.start()
-    for t in threads:
-        t.join(timeout=10)
-
-    passwords_seen = set()
-    for _ in range(num_threads):
-        status, res = results.get()
-        if status == "err":
-            pytest.fail(f"concurrent creation failed\n{res}")
-        passwords_seen.add(res["password"])
+    def create(_):
+        ok = doveauth.create_user(addr, password)
+        return ok, stored_hash(example_config, addr)
 
+    with ThreadPoolExecutor(10) as pool:
+        results = list(pool.map(create, range(10)))
+    assert all(ok for ok, _ in results)
     # all threads must see the same password hash
-    assert len(passwords_seen) == 1
-
-
-def test_50_concurrent_lookups_different_accounts(gencreds, dictproxy):
-    num_threads = 50
-    req_per_thread = 5
-    results = queue.Queue()
-
-    def lookup():
-        for i in range(req_per_thread):
-            addr, password = gencreds()
-            try:
-                dictproxy.lookup_passdb(addr, password)
-            except Exception:
-                results.put(traceback.format_exc())
-            else:
-                results.put(None)
-
-    threads = []
-    for i in range(num_threads):
-        thread = threading.Thread(target=lookup, daemon=True)
-        threads.append(thread)
-
-    print(f"created {num_threads} threads, starting them and waiting for results")
-    for thread in threads:
-        thread.start()
-
-    for i in range(num_threads * req_per_thread):
-        res = results.get()
-        if res is not None:
-            pytest.fail(f"concurrent lookup failed\n{res}")
+    assert len({passhash for _, passhash in results}) == 1
+    assert capsys.readouterr().err.count("Created address:") == 1
 
 
 def test_insufficient_resources_block_creation_not_existing_logins(
-    dictproxy, gencreds, monkeypatch
+    doveauth, example_gencreds, monkeypatch
 ):
-    addr, password = gencreds()
-    assert dictproxy.lookup_passdb(addr, password)
+    addr, password = example_gencreds()
+    assert doveauth.create_user(addr, password)
 
     monkeypatch.setattr(
         chatmaild.doveauth, "has_sufficient_resources", lambda config: False
     )
-    newaddr, newpassword = gencreds()
-    assert not dictproxy.lookup_passdb(newaddr, newpassword)
-    assert dictproxy.lookup_passdb(addr, password)
+    newaddr, newpassword = example_gencreds()
+    assert not doveauth.create_user(newaddr, newpassword)
+    assert doveauth.create_user(addr, password)
+
+
+class TestHttpPost:
+    @pytest.fixture
+    def doveauth_server(self, example_config):
+        server = DoveAuthServer(example_config, port=0)
+        threading.Thread(target=server.serve_forever, daemon=True).start()
+        yield f"127.0.0.1:{server.server_address[1]}"
+        server.shutdown()
+        server.server_close()
+
+    @pytest.fixture
+    def post(self, doveauth_server):
+        def post(path, data):
+            conn = http.client.HTTPConnection(doveauth_server, timeout=10)
+            try:
+                return self.post_on(conn, path, data).status
+            finally:
+                conn.close()
+
+        return post
+
+    @pytest.fixture
+    def connection(self, doveauth_server):
+        """One kept-alive connection, which is all dovecot's HTTP client opens."""
+        conn = http.client.HTTPConnection(doveauth_server, timeout=10)
+        yield conn
+        conn.close()
+
+    @staticmethod
+    def post_on(conn, path, data):
+        conn.request("POST", path, body=data)
+        resp = conn.getresponse()
+        resp.read()
+        return resp
+
+    def test_create_and_verify(self, post, example_config, example_gencreds):
+        addr, password = example_gencreds()
+        assert post("/create", f"{addr}\t{password}".encode()) == 200
+        assert stored_hash(example_config, addr).startswith("{SHA512-CRYPT}")
+
+        # second login with the same password verifies, a wrong one is refused
+        assert post("/create", f"{addr}\t{password}".encode()) == 200
+        assert post("/create", f"{addr}\twrong{password}".encode()) == 403
+
+    def test_password_special_chars_survive_transport(self, post, example_gencreds):
+        addr, _ = example_gencreds()
+        password = "laksjdlaksjdlak\\sjdlk\"12j'3l1/k2\tj3123"
+        body = f"{addr}\t{password}".encode()
+        assert post("/create", body) == 200
+        assert post("/create", body) == 200
+        assert post("/create", f"{addr}\totherpassword1".encode()) == 403
+
+    def test_password_must_be_utf8(self, post, example_gencreds):
+        addr, _ = example_gencreds()
+        assert post("/create", f"{addr}\tpässwort12".encode()) == 200
+        assert post("/create", addr.encode() + b"\tp\xe4sswort12") == 400
+
+    def test_nul_is_refused_before_crypt_sees_it(self, post, example_gencreds):
+        addr, _ = example_gencreds()
+        assert post("/create", f"{addr}\tpass\0word12".encode()) == 400
+        assert (
+            post("/create", "us\0er12345@chat.example.org\tlongenough1".encode()) == 400
+        )
+
+    def test_refused_creation(self, post, example_gencreds):
+        addr, _ = example_gencreds()
+        assert post("/create", f"{addr}\tshort".encode()) == 403
+        assert post("/create", b"not-an-address\tlongenoughpassword") == 403
+        body = "bürger123@chat.example.org\tlongenoughpw".encode()
+        assert post("/create", body) == 403
+        assert post("/create", b"") == 403
+
+    def test_body_length_limit(self, post, example_gencreds):
+        addr, _ = example_gencreds()
+        fill = CreateHandler.max_body_len - len(addr) - len("\t")
+        body = f"{addr}\t{'x' * fill}".encode()
+        assert len(body) == CreateHandler.max_body_len
+        assert post("/create", body) == 200
+
+        body = f"{addr}\t{'x' * (fill + 1)}".encode()
+        assert len(body) == CreateHandler.max_body_len + 1
+        assert post("/create", body) == 400
+
+    def test_connection_is_reused_across_200_replies(
+        self, connection, example_gencreds
+    ):
+        addr, password = example_gencreds()
+        body = f"{addr}\t{password}".encode()
+        # create, then verify the same password, on one connection
+        for _ in range(2):
+            resp = self.post_on(connection, "/create", body)
+            assert (resp.status, resp.will_close) == (200, False)
+
+    @pytest.mark.parametrize(
+        "path,data,status",
+        [
+            ("/other", b"not read", 404),
+            ("/create", b"x" * (CreateHandler.max_body_len + 1), 400),
+            ("/create", b"not-an-address\tlongenoughpassword", 403),
+        ],
+    )
+    def test_error_replies_close_the_connection(self, connection, path, data, status):
+        resp = self.post_on(connection, path, data)
+        assert (resp.status, resp.will_close) == (status, True)
+
+    @pytest.mark.parametrize("content_length", [None, "-1", "notanumber", "999999"])
+    def test_bad_content_length(self, connection, content_length):
+        # the fixture timeout turns a server that waits for the body into a failure
+        connection.putrequest("POST", "/create", skip_accept_encoding=True)
+        if content_length is not None:
+            connection.putheader("Content-Length", content_length)
+        connection.endheaders()
+        resp = connection.getresponse()
+        assert resp.status == 400
+        assert resp.will_close

chatmaild/src/chatmaild/tests/test_expire.py

@@ -3,7 +3,6 @@ import os
 import random
 import shutil
 import time
-from datetime import datetime
 from fnmatch import fnmatch
 from pathlib import Path
 
@@ -41,7 +40,7 @@ def fill_mbox(folderdir):
 
 
 def create_new_messages(basedir, relpaths, size=1000, days=0):
-    now = datetime.utcnow().timestamp()
+    now = time.time()
 
     for relpath in relpaths:
         msg_path = Path(basedir).joinpath(relpath)
@@ -112,9 +111,7 @@ def test_mbox_without_password(mbox1, example_config, capsys):
     mbox_rescan = MailboxStat(mbox1.basedir)
     assert mbox_rescan.last_login is None
 
-    exp = Expiry(
-        example_config, dry=False, now=datetime.now().timestamp(), verbose=False
-    )
+    exp = Expiry(example_config, dry=False, now=time.time(), verbose=False)
     exp.process_mailbox_stat(mbox_rescan)
     out, err = capsys.readouterr()
     assert "doesn't have last_login but isn't empty" in err
@@ -152,7 +149,7 @@ def test_report_mdir_filters_by_path(mbox1, example_config):
     """Test that Report with mdir='cur' only counts messages in cur/ subdirectory."""
     from chatmaild.fsreport import Report
 
-    now = datetime.utcnow().timestamp()
+    now = time.time()
 
     # Set password mtime to old enough so min_login_age check passes
     password = Path(mbox1.basedir).joinpath("password")

chatmaild/src/chatmaild/tests/test_lastlogin.py

@@ -1,6 +1,6 @@
 import time
 
-from chatmaild.doveauth import AuthDictProxy
+from chatmaild.doveauth import DoveAuth
 from chatmaild.lastlogin import (
     LastLoginDictProxy,
 )
@@ -9,8 +9,8 @@ from chatmaild.lastlogin import (
 def test_handle_dovecot_request_last_login(testaddr, example_config):
     dictproxy = LastLoginDictProxy(config=example_config)
 
-    authproxy = AuthDictProxy(config=example_config)
-    authproxy.lookup_passdb(testaddr, "1l2k3j1l2k3jl123")
+    doveauth = DoveAuth(example_config)
+    doveauth.create_user(testaddr, "1l2k3j1l2k3jl123")
 
     dictproxy_transactions = {}
 

chatmaild/src/chatmaild/tests/test_migrate_db.py

@@ -63,7 +63,7 @@ def test_migration(tmp_path, example_config, caplog):
         user = example_config.get_user(path.name)
         if last_login:
             assert user.get_last_login_timestamp() == last_login
-        assert password == user.get_userdb_dict()["password"]
+        assert password == user.get_password_hash()
 
     assert not all
     assert not example_config.passdb_path.exists()

chatmaild/src/chatmaild/tests/test_newmail.py

@@ -48,7 +48,7 @@ def test_create_dclogin_url_ipv4(ipv4_config):
     assert addr in url
 
 
-def test_print_new_account(capsys, monkeypatch, maildomain, tmpdir, example_config):
+def test_print_new_account(capsys, monkeypatch, tmpdir, example_config):
     monkeypatch.setattr(chatmaild.newemail, "CONFIG_PATH", str(example_config._inipath))
     print_new_account()
     out, err = capsys.readouterr()

chatmaild/src/chatmaild/tests/test_user.py

@@ -8,28 +8,23 @@ def test_login_timestamp(testaddr, example_config):
     assert user.get_last_login_timestamp() == 86400 * 2
 
 
-def test_get_user_dict_not_set(testaddr, example_config, caplog):
+def test_get_password_hash_not_set(testaddr, example_config, caplog):
     user = example_config.get_user(testaddr)
     assert not caplog.records
-    assert user.get_userdb_dict() == {}
+    assert user.get_password_hash() is None
     assert len(caplog.records) == 0
 
     user.set_password("")
-    assert user.get_userdb_dict() == {}
+    assert user.get_password_hash() is None
     assert len(caplog.records) == 1
 
 
-def test_get_user_dict(make_config, tmp_path):
+def test_get_password_hash(make_config, tmp_path):
     config = make_config("something.testrun.org")
-    addr = "user1@something.org"
-    user = config.get_user(addr)
+    user = config.get_user("user1@something.org")
     enc_password = "l1k2j31lk2j3l1k23j123"
     user.set_password(enc_password)
-    data = user.get_userdb_dict()
-    assert addr in str(data["home"])
-    assert data["uid"] == "vmail"
-    assert data["gid"] == "vmail"
-    assert data["password"] == enc_password
+    assert user.get_password_hash() == enc_password
 
 
 def test_no_mailboxes_dir(testaddr, example_config, tmp_path):

chatmaild/src/chatmaild/user.py

@@ -21,20 +21,17 @@ class User:
     def can_track(self):
         return "@" in self.addr
 
-    def get_userdb_dict(self):
-        """Return a non-empty dovecot 'userdb' style dict
-        if the user has an existing non-empty password"""
+    def get_password_hash(self):
         try:
-            pw = self.password_path.read_text()
+            passhash = self.password_path.read_text()
         except FileNotFoundError:
-            return {}
+            return None
 
-        if not pw:
+        if not passhash:
             logging.error(f"password is empty for: {self.addr}")
-            return {}
+            return None
 
-        home = str(self.maildir)
-        return dict(addr=self.addr, home=home, uid=self.uid, gid=self.gid, password=pw)
+        return passhash
 
     def is_incoming_cleartext_ok(self):
         return not self.enforce_E2EE_path.exists()

cmdeploy/pyproject.toml

@@ -19,6 +19,8 @@ dependencies = [
   "pytest-xdist", 
   "execnet",
   "imap_tools",
+  "jinja2",
+  "lupa",
   "deltachat-rpc-client",
   "deltachat-rpc-server",
 ]
@@ -26,10 +28,6 @@ dependencies = [
 [project.scripts]
 cmdeploy = "cmdeploy.cmdeploy:main"
 
-[project.entry-points.pytest11]
-"chatmaild.testplugin" = "chatmaild.tests.plugin"
-"cmdeploy.testplugin" = "cmdeploy.tests.plugin"
-
 [tool.pytest.ini_options]
 addopts = "-v -ra --strict-markers"
 

cmdeploy/src/cmdeploy/__init__.py

@@ -0,0 +1 @@
+

cmdeploy/src/cmdeploy/acmetool/__init__.py

@@ -4,6 +4,8 @@ from ..basedeploy import Deployer
 
 
 class AcmetoolDeployer(Deployer):
+    bin_path = "/usr/bin/acmetool"
+
     def __init__(self, email, domains):
         self.domains = domains
         self.email = email
@@ -41,8 +43,12 @@ class AcmetoolDeployer(Deployer):
             domains=self.domains,
         )
 
-        self.ensure_systemd_unit("acmetool/acmetool-redirector.service")
-        self.ensure_systemd_unit("acmetool/acmetool-reconcile.service")
+        self.ensure_systemd_unit(
+            "acmetool/acmetool-redirector.service.j2", bin_path=self.bin_path
+        )
+        self.ensure_systemd_unit(
+            "acmetool/acmetool-reconcile.service.j2", bin_path=self.bin_path
+        )
         self.ensure_systemd_unit("acmetool/acmetool-reconcile.timer")
 
     def activate(self):
@@ -52,5 +58,5 @@ class AcmetoolDeployer(Deployer):
 
         server.shell(
             name=f"Reconcile certificates for: {', '.join(self.domains)}",
-            commands=["acmetool --batch --xlog.severity=debug reconcile"],
+            commands=[f"{self.bin_path} --batch --xlog.severity=debug reconcile"],
         )

cmdeploy/src/cmdeploy/acmetool/acmetool-reconcile.service.j2

@@ -4,5 +4,5 @@ After=network.target
 
 [Service]
 Type=oneshot
-ExecStart=/usr/bin/acmetool --batch reconcile
+ExecStart={{ bin_path }} --batch reconcile
 

cmdeploy/src/cmdeploy/acmetool/acmetool-redirector.service.j2

@@ -3,7 +3,7 @@ Description=acmetool HTTP redirector
 
 [Service]
 Type=notify
-ExecStart=/usr/bin/acmetool redirector --service.uid=daemon --bind=127.0.0.1:402
+ExecStart={{ bin_path }} redirector --service.uid=daemon --bind=127.0.0.1:402
 Restart=always
 RestartSec=30
 

cmdeploy/src/cmdeploy/basedeploy.py

@@ -51,7 +51,7 @@ def get_resource(arg, pkg=__package__):
     return importlib.resources.files(pkg).joinpath(arg)
 
 
-def configure_remote_units(deployer, mail_domain, units) -> None:
+def configure_remote_units(deployer, mail_domain, units, **kwargs) -> None:
     remote_base_dir = "/usr/local/lib/chatmaild"
     remote_venv_dir = f"{remote_base_dir}/venv"
     remote_chatmail_inipath = f"{remote_base_dir}/chatmail.ini"
@@ -63,6 +63,7 @@ def configure_remote_units(deployer, mail_domain, units) -> None:
             config_path=remote_chatmail_inipath,
             remote_venv_dir=remote_venv_dir,
             mail_domain=mail_domain,
+            **kwargs,
         )
 
         basename = fn if "." in fn else f"{fn}.service"
@@ -226,7 +227,7 @@ class Deployer:
         res = files.directory(name=name, path=path, present=False, **kwargs)
         return self._update_restart_signals(path, res)
 
-    def download_executable(self, url, dest, sha256sum, extract=None):
+    def download_executable(self, url, dest, sha256sum, extract=None, mode="755"):
         existing = host.get_fact(Sha256File, dest)
         if existing == sha256sum:
             return
@@ -243,7 +244,7 @@ class Deployer:
                 f"({dl_cmd}"
                 f" && echo '{sha256sum}  {tmp}' | sha256sum -c"
                 f" && mv {tmp} {dest})",
-                f"chmod 755 {dest}",
+                f"chmod {mode} {dest}",
             ],
         )
         self.need_restart = True

cmdeploy/src/cmdeploy/deployers.py

@@ -33,6 +33,7 @@ from .filtermail.deployer import FiltermailDeployer
 from .mtail.deployer import MtailDeployer
 from .nginx.deployer import NginxDeployer
 from .opendkim.deployer import OpendkimDeployer
+from .pins import IROH_ARTIFACTS, TURN_ARTIFACTS
 from .postfix.deployer import PostfixDeployer
 from .selfsigned.deployer import SelfSignedTlsDeployer
 from .www import build_webpages, find_merge_conflict, get_paths
@@ -301,55 +302,48 @@ def check_config(config):
 
 
 class TurnDeployer(Deployer):
+    bin_path = "/usr/local/bin/chatmail-turn"
+
     def __init__(self, mail_domain):
         self.mail_domain = mail_domain
         self.units = ["turnserver"]
 
     def install(self):
-        (url, sha256sum) = {
-            "x86_64": (
-                "https://github.com/chatmail/chatmail-turn/releases/download/v0.4/chatmail-turn-x86_64-linux",
-                "1ec1f5c50122165e858a5a91bcba9037a28aa8cb8b64b8db570aa457c6141a8a",
-            ),
-            "aarch64": (
-                "https://github.com/chatmail/chatmail-turn/releases/download/v0.4/chatmail-turn-aarch64-linux",
-                "0fb3e792419494e21ecad536464929dba706bb2c88884ed8f1788141d26fc756",
-            ),
-        }[host.get_fact(facts.server.Arch)]
-        self.download_executable(url, "/usr/local/bin/chatmail-turn", sha256sum)
+        (url, sha256sum) = TURN_ARTIFACTS[host.get_fact(facts.server.Arch)]
+        self.download_executable(url, self.bin_path, sha256sum)
 
     def configure(self):
-        configure_remote_units(self, self.mail_domain, self.units)
+        configure_remote_units(
+            self, self.mail_domain, self.units, bin_path=self.bin_path
+        )
 
     def activate(self):
         activate_remote_units(self, self.units)
 
 
 class IrohDeployer(Deployer):
+    bin_path = "/usr/local/bin/iroh-relay"
+    config_path = "/etc/iroh-relay.toml"
+
     def __init__(self, enable_iroh_relay):
         self.enable_iroh_relay = enable_iroh_relay
 
     def install(self):
-        (url, sha256sum) = {
-            "x86_64": (
-                "https://github.com/n0-computer/iroh/releases/download/v0.35.0/iroh-relay-v0.35.0-x86_64-unknown-linux-musl.tar.gz",
-                "45c81199dbd70f8c4c30fef7f3b9727ca6e3cea8f2831333eeaf8aa71bf0fac1",
-            ),
-            "aarch64": (
-                "https://github.com/n0-computer/iroh/releases/download/v0.35.0/iroh-relay-v0.35.0-aarch64-unknown-linux-musl.tar.gz",
-                "f8ef27631fac213b3ef668d02acd5b3e215292746a3fc71d90c63115446008b1",
-            ),
-        }[host.get_fact(facts.server.Arch)]
+        (url, sha256sum) = IROH_ARTIFACTS[host.get_fact(facts.server.Arch)]
         self.download_executable(
             url,
-            "/usr/local/bin/iroh-relay",
+            self.bin_path,
             sha256sum,
             extract="gunzip | tar -xf - ./iroh-relay -O",
         )
 
     def configure(self):
-        self.ensure_systemd_unit("iroh-relay.service")
-        self.put_file("iroh-relay.toml", "/etc/iroh-relay.toml")
+        self.ensure_systemd_unit(
+            "iroh-relay.service.j2",
+            bin_path=self.bin_path,
+            config_path=self.config_path,
+        )
+        self.put_file("iroh-relay.toml", self.config_path)
 
     def activate(self):
         self.ensure_service(

cmdeploy/src/cmdeploy/dovecot/auth.conf

@@ -1,12 +0,0 @@
-uri = proxy:/run/doveauth/doveauth.socket:auth
-iterate_disable = no
-iterate_prefix = userdb/
-
-default_pass_scheme = plain
-# %E escapes characters " (double quote), ' (single quote) and \ (backslash) with \ (backslash).
-# See <https://doc.dovecot.org/2.3/configuration_manual/config_file/config_variables/#modifiers>
-# for documentation.
-#
-# We escape user-provided input and use double quote as a separator.
-password_key = passdb/%Ew"%Eu
-user_key = userdb/%Eu

cmdeploy/src/cmdeploy/dovecot/auth.lua.j2

@@ -0,0 +1,68 @@
+-- Existing addresses are served from the maildir directly.
+-- Unknown ones are offered to doveauth, which owns the creation policy.
+local mailboxes_dir = "{{ config.mailboxes_dir }}"
+local domain_suffix = "@{{ config.mail_domain }}"
+local create_url = "http://127.0.0.1:{{ config.doveauth_http_port }}/create"
+
+local http_client
+
+local function is_ours(user)
+  return user:sub(-#domain_suffix) == domain_suffix
+     and not user:find("/", 1, true)
+end
+
+local function password_hash(user)
+  local fh = io.open(mailboxes_dir .. "/" .. user .. "/password", "r")
+  if not fh then
+    return nil
+  end
+  local hash, rest = fh:read("l", "a")
+  fh:close()
+  if hash == nil or hash == "" or rest ~= "" then
+    return nil
+  end
+  return hash
+end
+
+local function userdb_fields(user)
+  return {home = mailboxes_dir .. "/" .. user, uid = "vmail", gid = "vmail"}
+end
+
+local function create(user, password)
+  local request = http_client:request({url = create_url, method = "POST"})
+  request:set_payload(user .. "\t" .. password)
+  return request:submit():status()
+end
+
+-- Entry points called by dovecot
+
+function script_init()
+  http_client = dovecot.http.client({request_timeout_msecs = 5000, max_attempts = 1})
+  return 0
+end
+
+function auth_userdb_lookup(req)
+  if not is_ours(req.user) or password_hash(req.user) == nil then
+    return dovecot.auth.USERDB_RESULT_USER_UNKNOWN, {}
+  end
+  return dovecot.auth.USERDB_RESULT_OK, userdb_fields(req.user)
+end
+
+function auth_password_verify(req, password)
+  if not is_ours(req.user) then
+    return dovecot.auth.PASSDB_RESULT_USER_UNKNOWN, {}
+  end
+  local hash = password_hash(req.user)
+  if hash == nil then
+    -- doveauth refuses with 4xx; dovecot reports its own failures as 9000 and up
+    local status = create(req.user, password)
+    if status >= 500 then
+      return dovecot.auth.PASSDB_RESULT_INTERNAL_FAILURE, {}
+    elseif status ~= 200 then
+      return dovecot.auth.PASSDB_RESULT_USER_UNKNOWN, {}
+    end
+  elseif req:password_verify(hash, password) ~= 1 then
+    return dovecot.auth.PASSDB_RESULT_PASSWORD_MISMATCH, {}
+  end
+  return dovecot.auth.PASSDB_RESULT_OK, userdb_fields(req.user)
+end

cmdeploy/src/cmdeploy/dovecot/deployer.py

@@ -14,18 +14,9 @@ from cmdeploy.basedeploy import (
     configure_remote_units,
     is_in_container,
 )
+from cmdeploy.pins import DOVECOT_SHA256, DOVECOT_VERSION
 
-DOVECOT_ARCHIVE_VERSION = "2.3.21+dfsg1-3"
-DOVECOT_PACKAGE_VERSION = f"1:{DOVECOT_ARCHIVE_VERSION}"
-
-DOVECOT_SHA256 = {
-    ("core", "amd64"): "dd060706f52a306fa863d874717210b9fe10536c824afe1790eec247ded5b27d",
-    ("core", "arm64"): "e7548e8a82929722e973629ecc40fcfa886894cef3db88f23535149e7f730dc9",
-    ("imapd", "amd64"): "8d8dc6fc00bbb6cdb25d345844f41ce2f1c53f764b79a838eb2a03103eebfa86",
-    ("imapd", "arm64"): "178fa877ddd5df9930e8308b518f4b07df10e759050725f8217a0c1fb3fd707f",
-    ("lmtpd", "amd64"): "2f69ba5e35363de50962d42cccbfe4ed8495265044e244007d7ccddad77513ab",
-    ("lmtpd", "arm64"): "89f52fb36524f5877a177dff4a713ba771fd3f91f22ed0af7238d495e143b38f",
-}
+DOVECOT_PACKAGE_VERSION = f"1:{DOVECOT_VERSION}"
 
 
 class DovecotDeployer(Deployer):
@@ -40,7 +31,7 @@ class DovecotDeployer(Deployer):
         arch = host.get_fact(Arch)
         with blocked_service_startup():
             debs = []
-            for pkg in ("core", "imapd", "lmtpd"):
+            for pkg in ("core", "imapd", "lmtpd", "auth-lua"):
                 deb, changed = _download_dovecot_package(pkg, arch)
                 self.need_restart |= changed
                 if deb:
@@ -117,7 +108,7 @@ def _download_dovecot_package(package: str, arch: str) -> tuple[str | None, bool
     if DOVECOT_PACKAGE_VERSION in installed_versions:
         return None, False
 
-    url_version = DOVECOT_ARCHIVE_VERSION.replace("+", "%2B")
+    url_version = DOVECOT_VERSION.replace("+", "%2B")
     deb_base = f"{pkg_name}_{url_version}_{arch}.deb"
     primary_url = f"https://download.delta.chat/dovecot/{deb_base}"
     fallback_url = f"https://github.com/chatmail/dovecot/releases/download/upstream%2F{url_version}/{deb_base}"
@@ -143,7 +134,8 @@ def _configure_dovecot(deployer, config: Config, debug: bool = False):
         debug=debug,
         disable_ipv6=config.disable_ipv6,
     )
-    deployer.put_file("dovecot/auth.conf", "/etc/dovecot/auth.conf")
+    deployer.put_template("dovecot/auth.lua.j2", "/etc/dovecot/auth.lua", config=config)
+    deployer.remove_file("/etc/dovecot/auth.conf")
     deployer.put_file(
         "dovecot/push_notification.lua", "/etc/dovecot/push_notification.lua"
     )

cmdeploy/src/cmdeploy/dovecot/dovecot.conf.j2

@@ -61,12 +61,12 @@ imap_capability = +XDELTAPUSH XCHATMAIL
 
 # Authentication for system users.
 passdb {
-  driver = dict
-  args = /etc/dovecot/auth.conf
+  driver = lua
+  args = file=/etc/dovecot/auth.lua blocking=yes
 }
 userdb {
-  driver = dict
-  args = /etc/dovecot/auth.conf
+  driver = lua
+  args = file=/etc/dovecot/auth.lua blocking=yes
 }
 ##
 ## Mailbox locations and namespaces

cmdeploy/src/cmdeploy/filtermail/deployer.py

@@ -3,6 +3,7 @@ import os
 from pyinfra import facts, host
 
 from cmdeploy.basedeploy import Deployer
+from cmdeploy.pins import FILTERMAIL_ARTIFACTS
 
 
 class FiltermailDeployer(Deployer):
@@ -20,11 +21,7 @@ class FiltermailDeployer(Deployer):
             return
 
         arch = host.get_fact(facts.server.Arch)
-        url = f"https://github.com/chatmail/filtermail/releases/download/v0.7.4/filtermail-{arch}"
-        sha256sum = {
-            "x86_64": "484cb8dff083134aefba9fce4a6b7ef4784a0f0e28e5108ecf8bb9e58a44fd2c",
-            "aarch64": "66aa0ca2ca9add7a12d92883d76f8786384092adfde24a3d3a1d0b1f30d23a9e",
-        }[arch]
+        url, sha256sum = FILTERMAIL_ARTIFACTS[arch]
         self.download_executable(url, self.bin_path, sha256sum)
 
     def configure(self):

cmdeploy/src/cmdeploy/iroh-relay.service.j2

@@ -2,7 +2,7 @@
 Description=Iroh relay
 
 [Service]
-ExecStart=/usr/local/bin/iroh-relay --config-path /etc/iroh-relay.toml
+ExecStart={{ bin_path }} --config-path {{ config_path }}
 Restart=on-failure
 RestartSec=5s
 User=iroh

cmdeploy/src/cmdeploy/mtail/deployer.py

@@ -1,10 +1,14 @@
 from pyinfra import facts, host
-from pyinfra.operations import apt
+from pyinfra.operations import apt, server
 
 from cmdeploy.basedeploy import Deployer
+from cmdeploy.pins import FILTERMAIL_ARTIFACTS, MTAIL_ARTIFACTS
 
 
 class MtailDeployer(Deployer):
+    bin_path = "/usr/local/bin/mtail"
+    progs_dir = "/etc/mtail"
+
     def __init__(self, mtail_address):
         self.mtail_address = mtail_address
 
@@ -12,19 +16,10 @@ class MtailDeployer(Deployer):
         # Uninstall mtail package to install a static binary.
         apt.packages(name="Uninstall mtail", packages=["mtail"], present=False)
 
-        (url, sha256sum) = {
-            "x86_64": (
-                "https://github.com/google/mtail/releases/download/v3.0.8/mtail_3.0.8_linux_amd64.tar.gz",
-                "d55cb601049c5e61eabab29998dbbcea95d480e5448544f9470337ba2eea882e",
-            ),
-            "aarch64": (
-                "https://github.com/google/mtail/releases/download/v3.0.8/mtail_3.0.8_linux_arm64.tar.gz",
-                "f748db8ad2a1e0b63684d4c8868cf6a373a20f7e6922e5ece601fff0ee00eb1a",
-            ),
-        }[host.get_fact(facts.server.Arch)]
+        (url, sha256sum) = MTAIL_ARTIFACTS[host.get_fact(facts.server.Arch)]
         self.download_executable(
             url,
-            "/usr/local/bin/mtail",
+            self.bin_path,
             sha256sum,
             extract="gunzip | tar -xf - mtail -O",
         )
@@ -36,8 +31,31 @@ class MtailDeployer(Deployer):
             "mtail/mtail.service.j2",
             address=self.mtail_address or "127.0.0.1",
             port=3903,
+            bin_path=self.bin_path,
+            progs_dir=self.progs_dir,
         )
-        self.put_file("mtail/delivered_mail.mtail", "/etc/mtail/delivered_mail.mtail")
+        if self.mtail_address:
+            self.put_file(
+                "mtail/delivered_mail.mtail", f"{self.progs_dir}/delivered_mail.mtail"
+            )
+            url, sha256sum = FILTERMAIL_ARTIFACTS['mtail']
+            self.download_executable(
+                url,
+                f"{self.progs_dir}/filtermail.mtail",
+                sha256sum,
+                mode="644",
+            )
+            if self.need_restart:
+                # Check if all installed mtail rules compile or fail early
+                # --one_shot to exit, --port 0 to not clash with running mtail.
+                server.shell(
+                    name="Validate mtail programs",
+                    commands=[
+                        f"timeout 30 {self.bin_path} --compile_only --one_shot"
+                        f" --progs {self.progs_dir} --logs /dev/null"
+                        " --address 127.0.0.1 --port 0"
+                    ],
+                )
 
     def activate(self):
         active = bool(self.mtail_address)

cmdeploy/src/cmdeploy/mtail/mtail.service.j2

@@ -5,7 +5,7 @@ Wants=network-online.target
 
 [Service]
 Type=simple
-ExecStart=/bin/sh -c "journalctl -f -o short-iso -n 0 | /usr/local/bin/mtail --address={{ address }} --port={{ port }} --progs /etc/mtail --logtostderr --logs -"
+ExecStart=/bin/sh -c "journalctl -f -o short-iso -n 0 | {{ bin_path }} --address={{ address }} --port={{ port }} --progs {{ progs_dir }} --logtostderr --logs -"
 Restart=on-failure
 RestartSec=2s
 

cmdeploy/src/cmdeploy/pins.py

@@ -0,0 +1,64 @@
+"""Versions, hashes, and download URLs for pre-built artifacts fetched during deploy."""
+
+FILTERMAIL_VERSION = "v0.7.6"
+FILTERMAIL_ARTIFACTS = {
+    "x86_64": (
+        f"https://github.com/chatmail/filtermail/releases/download/{FILTERMAIL_VERSION}/filtermail-x86_64",
+        "bdc33bd649207cfd6e4efcc790a47169cfd94e2e086f7a999257446ff079e629",
+    ),
+    "aarch64": (
+        f"https://github.com/chatmail/filtermail/releases/download/{FILTERMAIL_VERSION}/filtermail-aarch64",
+        "9e68e91fd8ef5261d0804871e4610ec048f8d417261766008c7a2c25afce3d24",
+    ),
+    "mtail": (
+        f"https://raw.githubusercontent.com/chatmail/filtermail/{FILTERMAIL_VERSION}/contrib/filtermail.mtail",
+        "948f688bb89ad47e6eb0fc8fa107e201a689f5adc264ff926be487a2a8562b51",
+    ),
+}
+
+MTAIL_VERSION = "3.4.9"
+MTAIL_ARTIFACTS = {
+    "x86_64": (
+        f"https://github.com/jaqx0r/mtail/releases/download/v{MTAIL_VERSION}/mtail_{MTAIL_VERSION}_linux_amd64.tar.gz",
+        "55f64a87f71955bb871c724b4aadf19fe9d854e6327196919c7fe44943427eab",
+    ),
+    "aarch64": (
+        f"https://github.com/jaqx0r/mtail/releases/download/v{MTAIL_VERSION}/mtail_{MTAIL_VERSION}_linux_arm64.tar.gz",
+        "e0a2b66b372ca257d7daeb7ba10f9233a2192a1f9057618fccc6be5c854a2a3c",
+    ),
+}
+
+DOVECOT_VERSION = "2.3.21+dfsg1-3"
+DOVECOT_SHA256 = {
+    ("core", "amd64"): "dd060706f52a306fa863d874717210b9fe10536c824afe1790eec247ded5b27d",
+    ("core", "arm64"): "e7548e8a82929722e973629ecc40fcfa886894cef3db88f23535149e7f730dc9",
+    ("imapd", "amd64"): "8d8dc6fc00bbb6cdb25d345844f41ce2f1c53f764b79a838eb2a03103eebfa86",
+    ("imapd", "arm64"): "178fa877ddd5df9930e8308b518f4b07df10e759050725f8217a0c1fb3fd707f",
+    ("lmtpd", "amd64"): "2f69ba5e35363de50962d42cccbfe4ed8495265044e244007d7ccddad77513ab",
+    ("lmtpd", "arm64"): "89f52fb36524f5877a177dff4a713ba771fd3f91f22ed0af7238d495e143b38f",
+    ("auth-lua", "amd64"): "d724f37712faba52e177153114af1831e54da555c57c6474c05f96f176176ce4",
+    ("auth-lua", "arm64"): "7272768e20de148c35891d99cd60205acbe7e732b056caf0a83e8194d49136e6",
+}
+TURN_VERSION = "v0.4"
+TURN_ARTIFACTS = {
+    "x86_64": (
+        f"https://github.com/chatmail/chatmail-turn/releases/download/{TURN_VERSION}/chatmail-turn-x86_64-linux",
+        "1ec1f5c50122165e858a5a91bcba9037a28aa8cb8b64b8db570aa457c6141a8a",
+    ),
+    "aarch64": (
+        f"https://github.com/chatmail/chatmail-turn/releases/download/{TURN_VERSION}/chatmail-turn-aarch64-linux",
+        "0fb3e792419494e21ecad536464929dba706bb2c88884ed8f1788141d26fc756",
+    ),
+}
+
+IROH_VERSION = "v0.35.0"
+IROH_ARTIFACTS = {
+    "x86_64": (
+        f"https://github.com/n0-computer/iroh/releases/download/{IROH_VERSION}/iroh-relay-{IROH_VERSION}-x86_64-unknown-linux-musl.tar.gz",
+        "45c81199dbd70f8c4c30fef7f3b9727ca6e3cea8f2831333eeaf8aa71bf0fac1",
+    ),
+    "aarch64": (
+        f"https://github.com/n0-computer/iroh/releases/download/{IROH_VERSION}/iroh-relay-{IROH_VERSION}-aarch64-unknown-linux-musl.tar.gz",
+        "f8ef27631fac213b3ef668d02acd5b3e215292746a3fc71d90c63115446008b1",
+    ),
+}

cmdeploy/src/cmdeploy/service/chatmail-expire.service.f

@@ -5,5 +5,5 @@ After=network.target
 [Service]
 Type=oneshot
 User=vmail
-ExecStart=/usr/local/lib/chatmaild/venv/bin/chatmail-expire /usr/local/lib/chatmaild/chatmail.ini -v --remove
+ExecStart={execpath} {config_path} -v --remove
 

cmdeploy/src/cmdeploy/service/chatmail-fsreport.service.f

@@ -5,5 +5,5 @@ After=network.target
 [Service]
 Type=oneshot
 User=vmail
-ExecStart=/usr/local/lib/chatmaild/venv/bin/chatmail-fsreport /usr/local/lib/chatmaild/chatmail.ini
+ExecStart={execpath} {config_path}
 

cmdeploy/src/cmdeploy/service/doveauth.service.f

@@ -1,12 +1,11 @@
 [Unit]
-Description=Chatmail dict authentication proxy for dovecot
+Description=Chatmail HTTP authentication service for dovecot
 
 [Service]
-ExecStart={execpath} /run/doveauth/doveauth.socket {config_path}
+ExecStart={execpath} {config_path}
 Restart=always
-RestartSec=30
+RestartSec=5
 User=vmail
-RuntimeDirectory=doveauth
 UMask=0077
 
 [Install]

cmdeploy/src/cmdeploy/service/turnserver.service.f

@@ -5,7 +5,7 @@ After=network.target
 [Service]
 Type=simple
 Restart=always
-ExecStart=/usr/local/bin/chatmail-turn --realm {mail_domain} --socket /run/chatmail-turn/turn.socket
+ExecStart={bin_path} --realm {mail_domain} --socket /run/chatmail-turn/turn.socket
 
 # Create /run/chatmail-turn
 RuntimeDirectory=chatmail-turn

cmdeploy/src/cmdeploy/tests/conftest.py

@@ -0,0 +1,27 @@
+"""Run the lua scripts we ship under lupa, which bundles Lua 5.4 like dovecot."""
+
+import pytest
+from chatmaild.tests.plugin import *  # noqa: F403
+from lupa import lua54
+
+from cmdeploy.basedeploy import get_resource
+from cmdeploy.tests.plugin import *  # noqa: F403
+
+
+class Lua:
+    """A Lua runtime to load shipped scripts and mocks into."""
+
+    def __init__(self):
+        self.rt = lua54.LuaRuntime(unpack_returned_tuples=True)
+        self.g = self.rt.globals()
+
+    def load(self, path):
+        self.rt.execute(get_resource(path).read_text())
+
+    def table(self, **kwargs):
+        return self.rt.table(**kwargs)
+
+
+@pytest.fixture
+def lua():
+    return Lua()

cmdeploy/src/cmdeploy/tests/online/test_0_qr.py

@@ -20,17 +20,17 @@ def test_fastcgi_working(maildomain, chatmail_config):
 
 
 @pytest.mark.filterwarnings("ignore::urllib3.exceptions.InsecureRequestWarning")
-def test_newemail_configure(maildomain, rpc, chatmail_config):
+def test_newemail_configure(maildomain, cmrpc, chatmail_config):
     """Test configuring accounts by scanning a QR code works."""
     url = f"DCACCOUNT:https://{maildomain}/new"
     for i in range(3):
-        account_id = rpc.add_account()
+        account_id = cmrpc.add_account()
         if chatmail_config.tls_cert_mode == "self":
             # deltachat core's rustls rejects self-signed HTTPS certs during
             # set_config_from_qr, so fetch credentials via requests instead
             res = requests.post(f"https://{maildomain}/new", verify=False)
             data = res.json()
-            rpc.add_or_update_transport(account_id, {
+            cmrpc.add_or_update_transport(account_id, {
                 "addr": data["email"],
                 "password": data["password"],
                 "imapServer": maildomain,
@@ -38,4 +38,4 @@ def test_newemail_configure(maildomain, rpc, chatmail_config):
                 "certificateChecks": "acceptInvalidCertificates",
             })
         else:
-            rpc.add_transport_from_qr(account_id, url)
+            cmrpc.add_transport_from_qr(account_id, url)

cmdeploy/src/cmdeploy/tests/plugin.py

@@ -18,14 +18,8 @@ def format_mail_domain(raw_domain: str) -> str:
     return raw_domain
 
 
-conftestdir = Path(__file__).parent
-
-
 def pytest_configure(config):
     config._benchresults = {}
-    config.addinivalue_line(
-        "markers", "slow: mark test to require --slow option to run"
-    )
 
 
 def _get_chatmail_config():
@@ -211,7 +205,7 @@ class ImapConn:
         status, res = self.conn.select()
         if int(res[0]) == 0:
             raise ValueError("no messages in imap folder")
-        status, results = self.conn.fetch("1:*", "(RFC822)")
+        status, results = self.conn.fetch("1:*", "(BODY.PEEK[])")
         assert status == "OK"
         return results
 
@@ -377,8 +371,12 @@ class ChatmailACFactory:
 
 
 @pytest.fixture(scope="session")
-def rpc(tmp_path_factory):
-    """Start a deltachat-rpc-server process for the test session."""
+def cmrpc(tmp_path_factory):
+    """Start a deltachat-rpc-server process for the test session.
+
+    Not named "rpc": the deltachat-rpc-client pytest plugin registers a
+    function-scoped fixture under that name and would shadow this one.
+    """
 
     # NB: accounts_dir must NOT already exist as directory --
     # core-rust only creates accounts.toml if the dir doesn't exist yet.
@@ -390,10 +388,10 @@ def rpc(tmp_path_factory):
 
 
 @pytest.fixture
-def cmfactory(rpc, gencreds, maildomain, chatmail_config):
+def cmfactory(cmrpc, gencreds, maildomain, chatmail_config):
     """Return a ChatmailACFactory for creating online Delta Chat accounts."""
     return ChatmailACFactory(
-        rpc=rpc,
+        rpc=cmrpc,
         maildomain=maildomain,
         gencreds=gencreds,
         chatmail_config=chatmail_config,

cmdeploy/src/cmdeploy/tests/pytest.ini

@@ -1,2 +0,0 @@
-[pytest]
-addopts = -vrsx --strict-markers

cmdeploy/src/cmdeploy/tests/test_authlua.py

@@ -0,0 +1,216 @@
+"""Test auth.lua script against mocked dovecot auth API."""
+
+import jinja2
+import pytest
+from chatmaild.doveauth import encrypt_password, verify_password
+
+from cmdeploy.basedeploy import get_resource
+
+USER1 = "user12345@chat.example.org"
+USER2 = "newuser12@chat.example.org"
+OK, UNKNOWN, MISMATCH, INTERNAL = 1, -2, -3, -4
+
+DOVECOT_MOCKS = """
+create_status = 200
+
+dovecot = {
+  auth = {
+    PASSDB_RESULT_OK = OK,
+    PASSDB_RESULT_USER_UNKNOWN = UNKNOWN,
+    PASSDB_RESULT_PASSWORD_MISMATCH = MISMATCH,
+    PASSDB_RESULT_INTERNAL_FAILURE = INTERNAL,
+    USERDB_RESULT_OK = OK,
+    USERDB_RESULT_USER_UNKNOWN = UNKNOWN,
+  },
+  http = {
+    client = function(options)
+      client_options = options
+      return {request = function(_, options)
+        create_request = options
+        return {
+          set_payload = function(_, payload) create_payload = payload end,
+          submit = function()
+            return {status = function() return create_status end}
+          end,
+        }
+      end}
+    end,
+  },
+}
+"""
+
+
+def load_authlua(lua, config):
+    lua.g.OK, lua.g.UNKNOWN = OK, UNKNOWN
+    lua.g.MISMATCH, lua.g.INTERNAL = MISMATCH, INTERNAL
+    lua.rt.execute(DOVECOT_MOCKS)
+    template = jinja2.Template(get_resource("dovecot/auth.lua.j2").read_text())
+    lua.rt.execute(template.render(config=config))
+    assert lua.g.script_init() == 0
+    return lua
+
+
+@pytest.fixture
+def authlua(lua, example_config):
+    return load_authlua(lua, example_config)
+
+
+@pytest.fixture
+def request_for(lua):
+    def request_for(addr):
+        def password_verify(_self, hashed, plain):
+            return 1 if verify_password(hashed, plain) else 0
+
+        return lua.table(user=addr, password_verify=password_verify)
+
+    return request_for
+
+
+@pytest.fixture
+def create_user(example_config):
+    def create_user(addr, password):
+        example_config.get_user(addr).set_password(encrypt_password(password))
+
+    return create_user
+
+
+@pytest.fixture
+def write_password_file(example_config):
+    def write_password_file(addr, content):
+        maildir = example_config.mailboxes_dir / addr
+        maildir.mkdir(parents=True, exist_ok=True)
+        maildir.joinpath("password").write_text(content)
+
+    return write_password_file
+
+
+def test_http_client_uses_dovecot_setting_names(authlua):
+    """dovecot's lua http binding silently ignores keys it does not know."""
+    assert dict(authlua.g.client_options) == {
+        "request_timeout_msecs": 5000,
+        "max_attempts": 1,
+    }
+
+
+def test_existing_address_correct_password(authlua, request_for, create_user):
+    create_user(USER1, "correctgoose")
+    res, fields = authlua.g.auth_password_verify(request_for(USER1), "correctgoose")
+    assert res == OK
+    assert fields["uid"] == fields["gid"] == "vmail"
+    assert fields["home"].endswith(USER1)
+    assert authlua.g.create_payload is None
+
+
+def test_existing_address_wrong_password(authlua, request_for, create_user):
+    create_user(USER1, "correctgoose")
+    res, _ = authlua.g.auth_password_verify(request_for(USER1), "wronghorse")
+    assert res == MISMATCH
+
+
+def test_foreign_domain_is_refused_without_calling_out(
+    authlua, request_for, create_user
+):
+    create_user("user12345@evil.example.org", "correctgoose")
+    request = request_for("user12345@evil.example.org")
+    res, _ = authlua.g.auth_password_verify(request, "correctgoose")
+    assert res == UNKNOWN
+    assert authlua.g.auth_userdb_lookup(request)[0] == UNKNOWN
+    assert authlua.g.create_payload is None
+
+
+def test_name_shorter_than_the_domain_is_refused(authlua, request_for):
+    for name in ("x", "", "chat.example.org"):
+        res, _ = authlua.g.auth_password_verify(request_for(name), "correctgoose")
+        assert res == UNKNOWN
+        assert authlua.g.auth_userdb_lookup(request_for(name))[0] == UNKNOWN
+    assert authlua.g.create_payload is None
+
+
+def test_slash_in_username_is_refused(authlua, request_for):
+    request = request_for("../../etc/shadow@chat.example.org")
+    res, _ = authlua.g.auth_password_verify(request, "somepassword")
+    assert res == UNKNOWN
+    assert authlua.g.auth_userdb_lookup(request)[0] == UNKNOWN
+    assert authlua.g.create_payload is None
+
+
+def test_localpart_policy_is_left_to_doveauth(authlua, request_for):
+    authlua.g.create_status = 403
+    res, _ = authlua.g.auth_password_verify(request_for("@chat.example.org"), "somepw")
+    assert res == UNKNOWN
+    assert authlua.g.create_payload == "@chat.example.org\tsomepw"
+
+
+def test_unknown_address_is_created_via_endpoint(authlua, request_for):
+    res, fields = authlua.g.auth_password_verify(request_for(USER2), "brandnewpass")
+    assert res == OK
+    assert fields["home"].endswith(USER2)
+    assert authlua.g.create_payload == f"{USER2}\tbrandnewpass"
+    assert authlua.g.create_request["url"] == "http://127.0.0.1:10084/create"
+
+
+# doveauth refusing is the user's problem, doveauth failing is ours
+@pytest.mark.parametrize("status", [400, 403, 404])
+def test_creation_refused_by_doveauth_is_user_unknown(authlua, request_for, status):
+    authlua.g.create_status = status
+    res, _ = authlua.g.auth_password_verify(request_for(USER2), "brandnewpass")
+    assert res == UNKNOWN
+
+
+# 9003 is dovecot's own CONNECT_FAILED, what a stopped doveauth actually yields
+@pytest.mark.parametrize("status", [500, 502, 9003, 9005])
+def test_creation_that_doveauth_could_not_answer_is_internal_failure(
+    authlua, request_for, status
+):
+    authlua.g.create_status = status
+    res, _ = authlua.g.auth_password_verify(request_for(USER2), "brandnewpass")
+    assert res == INTERNAL
+
+
+def test_userdb_unknown_before_creation_ok_after(authlua, request_for, create_user):
+    request = request_for(USER1)
+    res, _ = authlua.g.auth_userdb_lookup(request)
+    assert res == UNKNOWN
+    # a userdb lookup must never create anything
+    assert authlua.g.create_payload is None
+
+    create_user(USER1, "correctgoose")
+    res, fields = authlua.g.auth_userdb_lookup(request)
+    assert res == OK
+    assert fields["home"].endswith(USER1)
+    assert fields["uid"] == fields["gid"] == "vmail"
+
+
+def test_empty_password_file_is_unknown(authlua, request_for, write_password_file):
+    write_password_file(USER1, "")
+    assert authlua.g.auth_userdb_lookup(request_for(USER1))[0] == UNKNOWN
+
+    write_password_file(USER1, "\n")
+    assert authlua.g.auth_userdb_lookup(request_for(USER1))[0] == UNKNOWN
+
+
+def test_password_file_format_checks(authlua, request_for, write_password_file):
+    write_password_file(USER1, encrypt_password("correctgoose") + "\n")
+    res, _ = authlua.g.auth_password_verify(request_for(USER1), "correctgoose")
+    assert res == OK
+    assert authlua.g.auth_userdb_lookup(request_for(USER1))[0] == OK
+
+    passhash = encrypt_password("correctgoose")
+    write_password_file(USER1, passhash + "\ntrailing junk")
+    authlua.g.create_status = 403
+    res, _ = authlua.g.auth_password_verify(request_for(USER1), "correctgoose")
+    assert res == UNKNOWN
+    assert authlua.g.auth_userdb_lookup(request_for(USER1))[0] == UNKNOWN
+
+
+def test_ipv4_relay_uses_bracketed_domain(lua, ipv4_config, request_for):
+    # mail_domain is "[1.3.3.7]" here, and is_ours must not read it as a pattern
+    authlua = load_authlua(lua, ipv4_config)
+    addr = f"user12345@{ipv4_config.mail_domain}"
+    ipv4_config.get_user(addr).set_password(encrypt_password("correctgoose"))
+
+    res, fields = authlua.g.auth_password_verify(request_for(addr), "correctgoose")
+    assert res == OK
+    assert fields["home"].endswith(addr)
+    assert authlua.g.auth_userdb_lookup(request_for(addr))[0] == OK
+    assert authlua.g.auth_userdb_lookup(request_for(USER1))[0] == UNKNOWN

cmdeploy/src/cmdeploy/tests/test_dovecot_deployer.py

@@ -111,7 +111,7 @@ def test_download_dovecot_package_uses_archive_version_for_url_and_filename(
 
     deb, changed = dovecot_deployer._download_dovecot_package("core", "amd64")
 
-    archive_version = dovecot_deployer.DOVECOT_ARCHIVE_VERSION.replace("+", "%2B")
+    archive_version = dovecot_deployer.DOVECOT_VERSION.replace("+", "%2B")
     expected_deb = f"/root/dovecot-core_{archive_version}_amd64.deb"
 
     # Verify the returned path uses archive version, not package version (with epoch)
@@ -136,6 +136,7 @@ def test_install_skips_dpkg_path_when_epoch_matched_packages_present(
                     "dovecot-core": [dovecot_deployer.DOVECOT_PACKAGE_VERSION],
                     "dovecot-imapd": [dovecot_deployer.DOVECOT_PACKAGE_VERSION],
                     "dovecot-lmtpd": [dovecot_deployer.DOVECOT_PACKAGE_VERSION],
+                    "dovecot-auth-lua": [dovecot_deployer.DOVECOT_PACKAGE_VERSION],
                 },
             ),
             (dovecot_deployer.Arch, "x86_64"),
@@ -180,9 +181,12 @@ def test_install_unsupported_arch_falls_back_to_apt(
     deployer.install()
 
     actual_pkgs = [c["packages"] for c in apt_calls]
-    assert actual_pkgs == [["dovecot-core"], ["dovecot-imapd"], ["dovecot-lmtpd"]], (
-        f"expected apt install of core/imapd/lmtpd, got {actual_pkgs}"
-    )
+    assert actual_pkgs == [
+        ["dovecot-core"],
+        ["dovecot-imapd"],
+        ["dovecot-lmtpd"],
+        ["dovecot-auth-lua"],
+    ], f"expected apt install of core/imapd/lmtpd/auth-lua, got {actual_pkgs}"
     assert track_shell == [], "should not run dpkg for unsupported arch"
     assert deployer.need_restart is True, (
         "need_restart should be True when apt installed a package"

cmdeploy/src/cmdeploy/tests/test_pushlua.py

@@ -0,0 +1,85 @@
+"""Test the push_notification.lua we ship, against a mocked dovecot mail API."""
+
+import textwrap
+
+import pytest
+
+USER1 = "user12345@chat.example.org"
+USER2 = "user67890@chat.example.org"
+
+DOVECOT_MOCKS = textwrap.dedent("""
+    function make_user(username)
+      local function mailbox(_, name)
+        record("mailbox " .. name)
+        return {
+          sync = function() record("sync") end,
+          metadata_set = function(_, k, v)
+            record("metadata_set " .. k .. "=" .. v)
+          end,
+          free = function() record("free") end,
+        }
+      end
+      return {username = username, mailbox = mailbox}
+    end
+""")
+
+
+@pytest.fixture
+def script(lua):
+    lua.rt.execute(DOVECOT_MOCKS)
+    lua.load("dovecot/push_notification.lua")
+    return lua
+
+
+@pytest.fixture
+def deliver(script):
+    def deliver(recipient, sender):
+        calls = []
+        script.g.record = calls.append
+        user = script.g.make_user(recipient)
+        ctx = script.g.dovecot_lua_notify_begin_txn(user)
+        event = script.table(mailbox="INBOX", from_address=sender)
+        script.g.dovecot_lua_notify_event_message_new(ctx, event)
+        script.g.dovecot_lua_notify_end_txn(ctx, True)
+        return calls
+
+    return deliver
+
+
+def test_entry_points_have_the_names_dovecot_calls(script):
+    assert script.g.dovecot_lua_notify_begin_txn is not None
+    assert script.g.dovecot_lua_notify_event_message_new is not None
+    assert script.g.dovecot_lua_notify_end_txn is not None
+
+
+def test_begin_txn_returns_the_user_as_event_context(script):
+    user = script.g.make_user(USER1)
+    ctx = script.g.dovecot_lua_notify_begin_txn(user)
+    ctx.marker = "seen"
+    assert user.marker == "seen"
+
+
+def test_incoming_message_notifies_metadata_server(deliver):
+    assert deliver(USER1, sender=USER2) == [
+        "mailbox INBOX",
+        "sync",
+        "metadata_set /private/messagenew=",
+        "free",
+    ]
+
+
+def test_own_message_does_not_wake_the_sending_device(deliver):
+    assert deliver(USER1, sender=USER1) == [
+        "mailbox INBOX",
+        "sync",
+        "free",
+    ]
+
+
+def test_message_without_from_address_is_notified(deliver):
+    assert deliver(USER1, sender=None) == [
+        "mailbox INBOX",
+        "sync",
+        "metadata_set /private/messagenew=",
+        "free",
+    ]

doc/source/conf.py

@@ -3,6 +3,8 @@
 # For the full list of built-in configuration values, see the documentation:
 # https://www.sphinx-doc.org/en/master/usage/configuration.html
 
+import os
+
 # -- Project information -----------------------------------------------------
 # https://www.sphinx-doc.org/en/master/usage/configuration.html#project-information
 
@@ -16,18 +18,24 @@ author = 'chatmail collective'
 extensions = [
     #'sphinx.ext.autodoc',
     #'sphinx.ext.viewdoc',
+    'sphinx.ext.extlinks',
     'sphinxcontrib.mermaid',
 ]
 
 templates_path = ['_templates']
 exclude_patterns = []
 
-linkcheck_ignore = [
-    # only resolves once the file is merged to main
-    r"https://github\.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/defaults/appversions\.json",
-]
+# Repository links go through the roles below.
+# CI sets DOC_GITHUB_REF to the head commit of a pull request,
+gh_ref = os.environ.get("DOC_GITHUB_REF", "main")
 
+extlinks = {
+    "repofile": (f"https://github.com/chatmail/relay/blob/{gh_ref}/%s", "%s"),
+    "repodir": (f"https://github.com/chatmail/relay/tree/{gh_ref}/%s", "%s"),
+}
 
+# Warn about repository links spelled out in full instead of using the roles.
+extlinks_detect_hardcoded_links = True
 
 
 # -- Options for HTML output -------------------------------------------------

doc/source/faq.rst

@@ -54,7 +54,7 @@ How can I upgrade my chatmail relay?
 ------------------------------------
 
 To upgrade to the latest ``main`` branch,
-``cd`` into your local checkout of `https://github.com/chatmail/relay/`_
+``cd`` into your local checkout of https://github.com/chatmail/relay/
 and run the following commands:
 
    ::

doc/source/overview.rst

@@ -6,13 +6,13 @@ Technical overview
 Directories of the relay repository
 -----------------------------------
 
-The `chatmail relay repository <https://github.com/chatmail/relay/tree/main/>`_
+The `chatmail relay repository <https://github.com/chatmail/relay>`_
 has four main directories.
 
 ``scripts/``
 ~~~~~~~~~~~~~
 
-`scripts <https://github.com/chatmail/relay/tree/main/scripts>`_
+:repodir:`scripts`
 offers two convenience tools for beginners:
 
 - ``initenv.sh`` installs a local virtualenv Python environment and
@@ -71,7 +71,7 @@ The deployed system components of a chatmail relay are:
 ``chatmaild/``
 ~~~~~~~~~~~~~~
 
-`chatmaild <https://github.com/chatmail/relay/tree/main/chatmaild>`_
+:repodir:`chatmaild`
 is a Python package containing several small services which handle
 authentication, trigger push notifications on new messages, ensure
 that outbound mails are encrypted, delete inactive users, and some
@@ -83,25 +83,25 @@ that integrate with Dovecot and Postfix to achieve instant-onboarding
 and only relaying OpenPGP end-to-end messages encrypted messages. A
 short overview of ``chatmaild`` services:
 
--  `doveauth <https://github.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/doveauth.py>`_
-   implements create-on-login address semantics and is used by Dovecot
-   during IMAP login and by Postfix during SMTP/SUBMISSION login which
-   in turn uses `Dovecot SASL
-   <https://doc.dovecot.org/2.3/configuration_manual/authentication/dict/#complete-example-for-authenticating-via-a-unix-socket>`_
-   to authenticate logins.
+-  :repofile:`doveauth <chatmaild/src/chatmaild/doveauth.py>`
+   implements create-on-login address semantics.
+   Dovecot authenticates IMAP logins, and Postfix SMTP/SUBMISSION logins through `Dovecot SASL
+   <https://doc.dovecot.org/2.3/configuration_manual/authentication/authentication_mechanisms/>`_,
+   from an :repofile:`auth.lua <cmdeploy/src/cmdeploy/dovecot/auth.lua.j2>` script
+   that reads the maildir directly. Only addresses which do not exist yet
+   are passed on to doveauth, which owns the creation policy.
 
--  `chatmail-metadata <https://github.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/metadata.py>`_
-   is contacted by a `Dovecot lua
-   script <https://github.com/chatmail/relay/blob/main/cmdeploy/src/cmdeploy/dovecot/push_notification.lua>`_
-   to store user-specific relay-side config. On new messages, it `passes
-   the user’s push notification
-   token <https://github.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/notifier.py>`_
+-  :repofile:`chatmail-metadata <chatmaild/src/chatmaild/metadata.py>`
+   is contacted by a
+   :repofile:`Dovecot lua script <cmdeploy/src/cmdeploy/dovecot/push_notification.lua>`
+   to store user-specific relay-side config. On new messages, it
+   :repofile:`passes the user’s push notification token <chatmaild/src/chatmaild/notifier.py>`
    to
    `notifications.delta.chat <https://delta.chat/en/help#instant-delivery>`_
    so the push notifications on the user’s phone can be triggered by
    Apple/Google/Huawei.
 
--  `chatmail-expire <https://github.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/expire.py>`_
+-  :repofile:`chatmail-expire <chatmaild/src/chatmaild/expire.py>`
    deletes old messages, large messages, and entire mailboxes
    of users who have not logged in for longer than
    ``delete_inactive_users_after`` days.
@@ -109,15 +109,14 @@ short overview of ``chatmaild`` services:
 -  ``chatmail-quota-expire`` is called by Dovecot's ``quota_warning`` mechanism
    and will automatically remove oldest messages to keep mailboxes well under ``max_mailbox_size``.
 
--  `lastlogin <https://github.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/lastlogin.py>`_
+-  :repofile:`lastlogin <chatmaild/src/chatmaild/lastlogin.py>`
    is contacted by Dovecot when a user logs in and stores the date of
    the login.
 
 ``www/``
 ~~~~~~~~~
 
-`www <https://github.com/chatmail/relay/tree/main/www>`_ contains
-the html, css, and markdown files which make up a chatmail relay’s
+:repodir:`www` contains the html, css, and markdown files which make up a chatmail relay’s
 web page. Edit them before deploying to make your chatmail relay
 stand out.
 
@@ -157,7 +156,7 @@ Chatmail relay dependency diagram
         filtermail-outgoing --- |10025 reinject|postfix;
         filtermail-incoming --- |10026 reinject|postfix;
         postfix --- |milter opendkim.sock|OpenDKIM
-        dovecot --- |doveauth.socket|doveauth;
+        dovecot --- |10084 create|doveauth;
         dovecot --- |message delivery|maildir["maildir
         /home/vmail/.../user"];
         dovecot --- |lastlogin.socket|lastlogin;
@@ -253,7 +252,7 @@ App version information (experimental)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 A chatmail relay ships the
-`appversions.json <https://github.com/chatmail/relay/blob/main/chatmaild/src/chatmaild/defaults/appversions.json>`_
+:repofile:`appversions.json <chatmaild/src/chatmaild/defaults/appversions.json>`
 file of the ``chatmaild`` package
 and serves its content under the IMAP METADATA key
 ``/shared/vendor/deltachat/appversions``.

doc/source/related.rst

@@ -14,10 +14,11 @@ We know of three work-in-progress alternative implementation efforts:
    it to support all of the features and configuration settings required
    to operate as a chatmail relay.
 
--  `Madmail <https://github.com/themadorg/madmail>`_: an
-   experimental fork of `Maddy Mail Server <https://maddy.email/>`_, modified
-   for chatmail deployments.  It provides a single binary solution
-   for running a chatmail relay.
+-  `Madmail <https://github.com/themadorg/madmail>`_: a Rust-based
+   single-binary chatmail relay.  Madmail v2 is a rewrite of an earlier
+   experimental fork of `Maddy Mail Server <https://maddy.email/>`_.
+   It includes SMTP, IMAP, encryption enforcement, and real-time
+   services (TURN/Iroh), and runs on Linux and Windows.
 
 -  `Chatmail Cookbook <https://github.com/feld/chatmail-cookbook>`_:
    A Chef Cookbook implementing a relay server. The project follows the

scripts/initenv.sh

@@ -20,6 +20,10 @@ fi
 
 python3 -m venv --upgrade-deps venv
 
+# an editable install puts src/ on sys.path, so a leftover egg-info there is
+# found as a second distribution and keeps removed entry points registered
+rm -rf chatmaild/src/*.egg-info cmdeploy/src/*.egg-info
+
 venv/bin/pip install -e chatmaild 
 venv/bin/pip install -e cmdeploy
 venv/bin/pip install sphinx sphinxcontrib-mermaid sphinx-autobuild furo  # for building the docs