From 06de153e7d3c6c26cfa3a160cafe6dcdf71b1999 Mon Sep 17 00:00:00 2001 From: patrick Date: Thu, 12 Nov 2026 23:38:07 +0100 Subject: [PATCH] =?UTF-8?q?feat:=20TLS-Optionen=20f=C3=BCr=20lokale=20Zert?= =?UTF-8?q?ifikate=20(Ollama,=20Matrix)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - app/tls.py: gemeinsamer Helfer tls_verify (aus, CA-Datei oder Standard) - Ollama und Matrix bekommen CA-Datei und Schalter "TLS prüfen", UI und Verbindungstests nutzen sie - Checkmk- und Downtime-Client nutzen den Helfer, Verhalten unverändert Co-Authored-By: Claude Sonnet 5.5 --- CLAUDE.md | 8 +++ app/chat/matrix.py | 4 +- app/chat/registry.py | 10 ++-- app/checkmk.py | 9 +-- app/constants.py | 3 + app/downtime/client.py | 8 +-- app/ollama.py | 6 +- app/tls.py | 7 +++ app/web/downtime_section.py | 3 +- app/web/matrix_section.py | 12 +++- app/web/pages.py | 18 +++--- deploy/README.md | 1 + tests/test_tls.py | 32 +++++++++++ tests/test_tls_settings.py | 106 ++++++++++++++++++++++++++++++++++++ 14 files changed, 197 insertions(+), 30 deletions(-) create mode 100644 app/tls.py create mode 100644 tests/test_tls.py create mode 100644 tests/test_tls_settings.py diff --git a/CLAUDE.md b/CLAUDE.md index 85aa7cc..e165792 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -114,6 +114,14 @@ tests/ - CLI `checkbot messages [--grep TEXT] [--backend B] [--errors] [--since 2h|1d] [--limit N]` (`app/cli.py`, `app/outbound/since.py:parse_since`), öffnet die DB wie die anderen CLI-Befehle (kein eigener Read-only-Modus vorhanden). `deploy/checkbot-cli` Usage-Text ergänzt. - Annahmen/Abweichungen: Gekappt wird der nach Datenschutzmodus (voll/kurz) schon zusammengesetzte Text, also genau das, was der Adapter bekommt. Verbindungstests (s.o.) sind bewusst ausgenommen. `OutboundRepository`/CLI öffnen die Datenbank ohne eigenen Read-only-Modus, weil es dafür noch kein Vorbild im Code gibt. +## TLS-Optionen (ungetestet) +- Gemeinsamer Helfer `tls_verify(store, verify_key, ca_key)` in `app/tls.py`: Standard ist Prüfung an; `*.verify_tls` auf aus schaltet sie ganz ab (`verify=False`), sonst gilt die CA-Datei aus `*.ca_file`, falls gesetzt, sonst `True`. Verhalten für Checkmk (`app/checkmk.py`, `app/downtime/client.py`, Checkmk- und Downtime-Section in `app/web/pages.py`/`downtime_section.py`) unverändert, nur über den Helfer statt eigenem Code. +- Neue Settings `ollama.verify_tls` (`app/ollama.py` `from_settings`, Testlauf in `app/web/pages.py`) und `matrix.ca_file`/`matrix.verify_tls` (Adapter-Aufbau in `app/chat/registry.py build_matrix`, Verbindungstest/Testnachricht in `app/web/matrix_section.py`). `MatrixAdapter` nimmt dafür einen `verify`-Parameter (Default `True`) entgegen. +- UI-Felder für Ollama und Matrix wie bei Checkmk: Textfeld für die CA-Datei, Checkbox für die Prüfung, mit Hinweis, dass ein Abschalten nur ins Testnetz gehört und die CA-Datei vorzuziehen ist. +- Telegram bleibt bewusst ohne eigene TLS-Option (öffentliche API bzw. `telegram.api_base` für Eigenbetrieb). +- Audit: Läuft über den vorhandenen generischen Mechanismus in `app/settings.py` (`SettingsStore.set`, Audit-Aktion `setting.set`), da `*.verify_tls` kein Secret-Feld ist, kein eigener Code nötig. Keine Existenzprüfung der CA-Datei beim Speichern. +- Offene Annahmen: Keine Integrationstests gegen eine echte Matrix- oder Ollama-Instanz mit interner CA; nur Helfer-Logik und Durchreichen der Werte (`tests/test_tls.py`, `tests/test_tls_settings.py`) geprüft, nicht gegen echtes TLS-Handshake-Verhalten. + ## Weiterer Weg (entschieden) Reihenfolge: Testbasis, erster Lauf im Test-LXC (`pytest`), Korrekturrunde, Phase 6, Phase 6b, Phase 6c, Phase 8, Abnahme, Parallelbetrieb, Tag `v0.1.0`. Verfeinerungen passieren am Live-System, nicht vorab. - Testbasis: `pytest` manuell im Test-LXC (Dev-venv mit `requirements-dev.txt`), dazu `.gitea/workflows/test.yml` für einen späteren Gitea-Actions-Runner. Logging als Zeilenlog nach journald, Level über `CHECKBOT_LOG_LEVEL` (Default INFO), nie Secrets in Logs (Test für die Adapter). Zeitzone über `CHECKBOT_TZ` im Setup-Skript, Default `Europe/Berlin`. diff --git a/app/chat/matrix.py b/app/chat/matrix.py index 20539fd..b6e9b0b 100644 --- a/app/chat/matrix.py +++ b/app/chat/matrix.py @@ -54,13 +54,13 @@ class MatrixAdapter: def __init__(self, homeserver: str, user_id: str, token: str, default_target: str, timeout: float = DEFAULT_TIMEOUT, transport: httpx.AsyncBaseTransport | None = None, - sleep=asyncio.sleep): + sleep=asyncio.sleep, verify: bool | str = True): self.default_target = default_target self._homeserver = homeserver.rstrip("/") self._user_id = user_id self._token = token self._sleep = sleep - self._client = httpx.AsyncClient(timeout=timeout, transport=transport, + self._client = httpx.AsyncClient(timeout=timeout, transport=transport, verify=verify, headers={"Authorization": f"Bearer {token}"}) def _mask(self, text: str) -> str: diff --git a/app/chat/registry.py b/app/chat/registry.py index a727b59..8d29fbf 100644 --- a/app/chat/registry.py +++ b/app/chat/registry.py @@ -1,8 +1,9 @@ from typing import Callable -from ..constants import (ADAPTER_SETTING_KEYS, DEFAULT_TELEGRAM_API_BASE, FLAG_ON, MATRIX_ENABLED, - MATRIX_HOMESERVER, MATRIX_ROOM_ID, MATRIX_TOKEN, MATRIX_USER_ID, TELEGRAM_API_BASE, - TELEGRAM_CHAT_ID, TELEGRAM_ENABLED, TELEGRAM_TOKEN) +from ..constants import (ADAPTER_SETTING_KEYS, DEFAULT_TELEGRAM_API_BASE, FLAG_ON, MATRIX_CA_FILE, MATRIX_ENABLED, + MATRIX_HOMESERVER, MATRIX_ROOM_ID, MATRIX_TOKEN, MATRIX_USER_ID, MATRIX_VERIFY_TLS, + TELEGRAM_API_BASE, TELEGRAM_CHAT_ID, TELEGRAM_ENABLED, TELEGRAM_TOKEN) +from ..tls import tls_verify from .base import ChatAdapter, Target from .matrix import BACKEND_MATRIX, MatrixAdapter from .outbound import LoggingAdapter, OutboundSink @@ -37,7 +38,8 @@ def build_matrix(store, timeout: float | None = None, sink: OutboundSink | None if not (homeserver and user_id and token and room_id): return None options = {} if timeout is None else {"timeout": timeout} - adapter = MatrixAdapter(homeserver, user_id, token, room_id, **options) + verify = tls_verify(store, MATRIX_VERIFY_TLS, MATRIX_CA_FILE) + adapter = MatrixAdapter(homeserver, user_id, token, room_id, verify=verify, **options) return _wrap(adapter, sink, secrets) diff --git a/app/checkmk.py b/app/checkmk.py index b58b209..b66cb3c 100644 --- a/app/checkmk.py +++ b/app/checkmk.py @@ -4,9 +4,9 @@ from typing import Sequence import httpx -from .constants import (CHECKMK_CA_FILE, CHECKMK_SECRET, CHECKMK_SITE, CHECKMK_URL, - CHECKMK_USER, CHECKMK_VERIFY_TLS, FLAG_OFF, FLAG_ON) +from .constants import CHECKMK_CA_FILE, CHECKMK_SECRET, CHECKMK_SITE, CHECKMK_URL, CHECKMK_USER, CHECKMK_VERIFY_TLS from .models import HOST_SERVICE_NAME +from .tls import tls_verify API_PATH = "/check_mk/api/1.0" SERVICES_PATH = "/domain-types/service/collections/all" @@ -216,10 +216,7 @@ class CheckmkClient: return None url, site = store.get(CHECKMK_URL), store.get(CHECKMK_SITE) user, secret = store.get(CHECKMK_USER), store.get(CHECKMK_SECRET) - if store.get(CHECKMK_VERIFY_TLS, FLAG_ON) == FLAG_OFF: - verify: bool | str = False - else: - verify = store.get(CHECKMK_CA_FILE) or True + verify = tls_verify(store, CHECKMK_VERIFY_TLS, CHECKMK_CA_FILE) return cls(url, site, user, secret, verify=verify) async def _request(self, method: str, path: str, **kwargs) -> dict: diff --git a/app/constants.py b/app/constants.py index 2f06af9..0229108 100644 --- a/app/constants.py +++ b/app/constants.py @@ -9,6 +9,7 @@ OLLAMA_URL = "ollama.url" OLLAMA_TOKEN = "ollama.token" OLLAMA_TIMEOUT = "ollama.timeout" OLLAMA_CA_FILE = "ollama.ca_file" +OLLAMA_VERIFY_TLS = "ollama.verify_tls" OLLAMA_MODEL_ALERT = "ollama.model_alert" OLLAMA_MODEL_AGENT = "ollama.model_agent" @@ -32,6 +33,8 @@ MATRIX_USER_ID = "matrix.user_id" MATRIX_TOKEN = "matrix.token" MATRIX_ROOM_ID = "matrix.room_id" MATRIX_ALLOWLIST = "matrix.allowlist" +MATRIX_CA_FILE = "matrix.ca_file" +MATRIX_VERIFY_TLS = "matrix.verify_tls" TELEGRAM_CONTENT_MODE = "telegram.content_mode" MATRIX_CONTENT_MODE = "matrix.content_mode" diff --git a/app/downtime/client.py b/app/downtime/client.py index 1f55cd8..9930599 100644 --- a/app/downtime/client.py +++ b/app/downtime/client.py @@ -5,7 +5,8 @@ import httpx from ..checkmk import API_PATH, DEFAULT_TIMEOUT, VERSION_PATH from ..chat import mask_secret from ..constants import (CHECKMK_CA_FILE, CHECKMK_DT_SECRET, CHECKMK_DT_USER, CHECKMK_SITE, CHECKMK_URL, - CHECKMK_VERIFY_TLS, FLAG_OFF, FLAG_ON) + CHECKMK_VERIFY_TLS) +from ..tls import tls_verify DOWNTIME_PATH = "/domain-types/downtime/collections/service" TIME_FORMAT = "%Y-%m-%dT%H:%M:%SZ" @@ -38,10 +39,7 @@ class CheckmkDowntimeClient: def from_settings(cls, store) -> "CheckmkDowntimeClient | None": if not is_configured(store): return None - if store.get(CHECKMK_VERIFY_TLS, FLAG_ON) == FLAG_OFF: - verify: bool | str = False - else: - verify = store.get(CHECKMK_CA_FILE) or True + verify = tls_verify(store, CHECKMK_VERIFY_TLS, CHECKMK_CA_FILE) return cls(store.get(CHECKMK_URL), store.get(CHECKMK_SITE), store.get(CHECKMK_DT_USER), store.get(CHECKMK_DT_SECRET), verify=verify) diff --git a/app/ollama.py b/app/ollama.py index 8257f9d..11cda09 100644 --- a/app/ollama.py +++ b/app/ollama.py @@ -2,7 +2,9 @@ import asyncio import httpx -from .constants import DEFAULT_OLLAMA_TIMEOUT, OLLAMA_CA_FILE, OLLAMA_TIMEOUT, OLLAMA_TOKEN, OLLAMA_URL +from .constants import (DEFAULT_OLLAMA_TIMEOUT, OLLAMA_CA_FILE, OLLAMA_TIMEOUT, OLLAMA_TOKEN, OLLAMA_URL, + OLLAMA_VERIFY_TLS) +from .tls import tls_verify VERSION_PATH = "/api/version" TAGS_PATH = "/api/tags" @@ -37,7 +39,7 @@ class OllamaClient: if not url: return None timeout = float(store.get(OLLAMA_TIMEOUT, DEFAULT_OLLAMA_TIMEOUT)) - verify: bool | str = store.get(OLLAMA_CA_FILE) or True + verify = tls_verify(store, OLLAMA_VERIFY_TLS, OLLAMA_CA_FILE) return cls(url, store.get(OLLAMA_TOKEN), timeout=timeout, verify=verify) async def _request(self, method: str, path: str, **kwargs) -> dict: diff --git a/app/tls.py b/app/tls.py new file mode 100644 index 0000000..5cb41e1 --- /dev/null +++ b/app/tls.py @@ -0,0 +1,7 @@ +from .constants import FLAG_OFF, FLAG_ON + + +def tls_verify(store, verify_key: str, ca_key: str) -> bool | str: + if store.get(verify_key, FLAG_ON) == FLAG_OFF: + return False + return store.get(ca_key) or True diff --git a/app/web/downtime_section.py b/app/web/downtime_section.py index 152ca27..ffd3875 100644 --- a/app/web/downtime_section.py +++ b/app/web/downtime_section.py @@ -4,6 +4,7 @@ from ..constants import (CHECKMK_CA_FILE, CHECKMK_DT_ENABLED, CHECKMK_DT_MAX_HOU CHECKMK_DT_USER, CHECKMK_SITE, CHECKMK_URL, CHECKMK_VERIFY_TLS, DEFAULT_DT_MAX_HOURS, DT_MAX_HOURS_CEILING, FLAG_OFF, FLAG_ON) from ..downtime import CheckmkDowntimeClient +from ..tls import tls_verify from .sections import Field, Section SLUG = "checkmk_dt" @@ -34,7 +35,7 @@ async def test_connection(values: dict) -> str: raise ValueError("Checkmk-URL und Site fehlen, bitte zuerst Checkmk einrichten.") if not (values.get(CHECKMK_DT_USER) and values.get(CHECKMK_DT_SECRET)): raise ValueError("Downtime-User oder Secret fehlt.") - verify: bool | str = False if values.get(CHECKMK_VERIFY_TLS) == FLAG_OFF else (values.get(CHECKMK_CA_FILE) or True) + verify = tls_verify(values, CHECKMK_VERIFY_TLS, CHECKMK_CA_FILE) client = CheckmkDowntimeClient(values[CHECKMK_URL], values[CHECKMK_SITE], values[CHECKMK_DT_USER], values[CHECKMK_DT_SECRET], verify=verify) try: diff --git a/app/web/matrix_section.py b/app/web/matrix_section.py index b37ee47..f86aca8 100644 --- a/app/web/matrix_section.py +++ b/app/web/matrix_section.py @@ -5,8 +5,10 @@ from fastapi.responses import JSONResponse from .. import audit from ..chat import MATRIX_ROOM_ID_RE, MATRIX_USER_ID_RE, MatrixAdapter, mask_secret -from ..constants import (FLAG_OFF, FLAG_ON, MATRIX_ALLOWLIST, MATRIX_CONTENT_MODE, MATRIX_ENABLED, - MATRIX_HOMESERVER, MATRIX_ROOM_ID, MATRIX_TOKEN, MATRIX_USER_ID) +from ..constants import (FLAG_OFF, FLAG_ON, MATRIX_ALLOWLIST, MATRIX_CA_FILE, MATRIX_CONTENT_MODE, + MATRIX_ENABLED, MATRIX_HOMESERVER, MATRIX_ROOM_ID, MATRIX_TOKEN, MATRIX_USER_ID, + MATRIX_VERIFY_TLS) +from ..tls import tls_verify from ..users import User from .content_mode import content_mode_field, validate_content_mode from .deps import require_admin @@ -52,8 +54,9 @@ def _adapter(values: dict) -> MatrixAdapter: (MATRIX_TOKEN, "Access-Token")): if not values.get(key): raise ValueError(f"{label} fehlt.") + verify = tls_verify(values, MATRIX_VERIFY_TLS, MATRIX_CA_FILE) return MatrixAdapter(values[MATRIX_HOMESERVER], values[MATRIX_USER_ID], values[MATRIX_TOKEN], - values.get(MATRIX_ROOM_ID, "")) + values.get(MATRIX_ROOM_ID, ""), verify=verify) async def test_connection(values: dict) -> str: @@ -74,6 +77,9 @@ SECTION = Section( Field(MATRIX_TOKEN, "Access-Token des Bot-Users", kind="password", secret=True), Field(MATRIX_ROOM_ID, "Standard-Raum-ID (unverschlüsselt)", placeholder="!abcdef:example.de"), Field(MATRIX_ALLOWLIST, "Erlaubte Matrix-IDs (kommagetrennt)", placeholder="@admin:example.de"), + Field(MATRIX_CA_FILE, "CA-Datei (optional)", placeholder="/etc/ssl/certs/intern-ca.pem"), + Field(MATRIX_VERIFY_TLS, "TLS-Zertifikat prüfen", kind="checkbox", default=FLAG_ON, + hint="Nur im Testnetz abschalten, besser die CA-Datei eintragen."), content_mode_field(MATRIX_CONTENT_MODE, "Mit \"kurz\" enthalten Nachrichten keinen Plugin-Output und keine KI-Texte; " "die KI-Analyse wird dann nicht nachgereicht."), diff --git a/app/web/pages.py b/app/web/pages.py index d167239..dc8e4c9 100644 --- a/app/web/pages.py +++ b/app/web/pages.py @@ -8,11 +8,12 @@ from fastapi.responses import JSONResponse from .. import audit from ..checkmk import CheckmkClient from ..constants import (CHECKMK_CA_FILE, CHECKMK_SECRET, CHECKMK_SITE, CHECKMK_URL, CHECKMK_USER, - CHECKMK_VERIFY_TLS, DEFAULT_OLLAMA_MODEL, DEFAULT_OLLAMA_TIMEOUT, FLAG_OFF, - FLAG_ON, OLLAMA_CA_FILE, OLLAMA_MODEL_AGENT, OLLAMA_MODEL_ALERT, - OLLAMA_TIMEOUT, OLLAMA_TOKEN, OLLAMA_URL) + CHECKMK_VERIFY_TLS, DEFAULT_OLLAMA_MODEL, DEFAULT_OLLAMA_TIMEOUT, FLAG_ON, + OLLAMA_CA_FILE, OLLAMA_MODEL_AGENT, OLLAMA_MODEL_ALERT, + OLLAMA_TIMEOUT, OLLAMA_TOKEN, OLLAMA_URL, OLLAMA_VERIFY_TLS) from ..health import build_checks, run_checks from ..ollama import OllamaClient +from ..tls import tls_verify from ..users import MIN_PASSWORD_LEN, ROLES, User, UserError from . import (alerting_section, downtime_section, matrix_section, retention_section, selftest_section, telegram_section) @@ -58,7 +59,7 @@ def _validate_ollama(values: dict) -> list[str]: async def _test_checkmk(values: dict) -> str: - verify = False if values.get(CHECKMK_VERIFY_TLS) == FLAG_OFF else (values.get(CHECKMK_CA_FILE) or True) + verify = tls_verify(values, CHECKMK_VERIFY_TLS, CHECKMK_CA_FILE) client = CheckmkClient(values[CHECKMK_URL], values[CHECKMK_SITE], values[CHECKMK_USER], values[CHECKMK_SECRET], verify=verify) try: @@ -77,7 +78,7 @@ async def _test_ollama(values: dict) -> str: client = OllamaClient( values[OLLAMA_URL], values.get(OLLAMA_TOKEN) or None, timeout=float(values.get(OLLAMA_TIMEOUT) or DEFAULT_OLLAMA_TIMEOUT), retries=0, - verify=values.get(OLLAMA_CA_FILE) or True, + verify=tls_verify(values, OLLAMA_VERIFY_TLS, OLLAMA_CA_FILE), ) try: version = await client.version() @@ -101,7 +102,8 @@ SECTIONS = { Field(CHECKMK_USER, "Automation-User", required=True), Field(CHECKMK_SECRET, "Automation-Secret", kind="password", required=True, secret=True), Field(CHECKMK_CA_FILE, "CA-Datei (optional)", placeholder="/etc/ssl/certs/intern-ca.pem"), - Field(CHECKMK_VERIFY_TLS, "TLS-Zertifikat prüfen", kind="checkbox"), + Field(CHECKMK_VERIFY_TLS, "TLS-Zertifikat prüfen", kind="checkbox", + hint="Nur im Testnetz abschalten, besser die CA-Datei eintragen."), ), validate=_validate_checkmk, test=_test_checkmk, @@ -113,7 +115,9 @@ SECTIONS = { Field(OLLAMA_URL, "URL", required=True, placeholder="http://office.sysops.de:11434"), Field(OLLAMA_TOKEN, "Bearer-Token (optional)", kind="password", secret=True), Field(OLLAMA_TIMEOUT, "Timeout in Sekunden", default=DEFAULT_OLLAMA_TIMEOUT), - Field(OLLAMA_CA_FILE, "CA-Datei (optional)"), + Field(OLLAMA_CA_FILE, "CA-Datei (optional)", placeholder="/etc/ssl/certs/intern-ca.pem"), + Field(OLLAMA_VERIFY_TLS, "TLS-Zertifikat prüfen", kind="checkbox", + hint="Nur im Testnetz abschalten, besser die CA-Datei eintragen."), Field(OLLAMA_MODEL_ALERT, "Modell für Alarmtexte", required=True, default=DEFAULT_OLLAMA_MODEL), Field(OLLAMA_MODEL_AGENT, "Modell für den Agenten", required=True, default=DEFAULT_OLLAMA_MODEL), ), diff --git a/deploy/README.md b/deploy/README.md index badb11f..6da78d2 100644 --- a/deploy/README.md +++ b/deploy/README.md @@ -16,6 +16,7 @@ Browser --443--> Caddy (TLS, HSTS, /health nur intern) --127.0.0.1:8080--> uvico | `/etc/checkbot` | `checkbot.env`, `master.key`, `session.secret` | Ordner 0750 root:checkbot, `checkbot.env` 0640, Schlüssel 0600 checkbot | | `/var/lib/checkbot` | SQLite-Datenbank | 0750 checkbot | | `/var/backups/checkbot` | tägliche DB-Backups | 0700 checkbot, Dateien 0600 | +| `/etc/checkbot/ca/` | eigene CA-Dateien (Checkmk, Ollama, Matrix, interne CA) | lesbar für den Benutzer checkbot, Pfad in der jeweiligen UI-Section eintragen | | `/etc/caddy/Caddyfile` | aus `Caddyfile.template` gerendert | root | | Datei | Zweck | diff --git a/tests/test_tls.py b/tests/test_tls.py new file mode 100644 index 0000000..7de495c --- /dev/null +++ b/tests/test_tls.py @@ -0,0 +1,32 @@ +from app.constants import FLAG_OFF, FLAG_ON +from app.tls import tls_verify + +VERIFY_KEY = "x.verify_tls" +CA_KEY = "x.ca_file" + + +class FakeStore: + def __init__(self, values: dict): + self._values = values + + def get(self, key, default=None): + return self._values.get(key, default) + + +def test_default_is_true_without_settings(): + assert tls_verify(FakeStore({}), VERIFY_KEY, CA_KEY) is True + + +def test_off_returns_false_even_with_ca_file(): + store = FakeStore({VERIFY_KEY: FLAG_OFF, CA_KEY: "/etc/ssl/ca.pem"}) + assert tls_verify(store, VERIFY_KEY, CA_KEY) is False + + +def test_ca_file_used_when_verify_on(): + store = FakeStore({VERIFY_KEY: FLAG_ON, CA_KEY: "/etc/ssl/ca.pem"}) + assert tls_verify(store, VERIFY_KEY, CA_KEY) == "/etc/ssl/ca.pem" + + +def test_verify_on_without_ca_file_is_true(): + store = FakeStore({VERIFY_KEY: FLAG_ON}) + assert tls_verify(store, VERIFY_KEY, CA_KEY) is True diff --git a/tests/test_tls_settings.py b/tests/test_tls_settings.py new file mode 100644 index 0000000..961e367 --- /dev/null +++ b/tests/test_tls_settings.py @@ -0,0 +1,106 @@ +import os + +import pytest + +from app.chat import registry as chat_registry +from app.constants import (FLAG_OFF, FLAG_ON, MATRIX_CA_FILE, MATRIX_ENABLED, MATRIX_HOMESERVER, MATRIX_ROOM_ID, + MATRIX_TOKEN, MATRIX_USER_ID, MATRIX_VERIFY_TLS, OLLAMA_CA_FILE, OLLAMA_URL, + OLLAMA_VERIFY_TLS) +from app.crypto import SecretBox +from app.db import Database +from app import ollama as ollama_module +from app.settings import SettingsStore + +USER = "tester" + + +@pytest.fixture +def store(): + return SettingsStore(Database(":memory:"), SecretBox(os.urandom(32))) + + +class _Capture: + def __init__(self): + self.kwargs = None + + +def _capturing(monkeypatch, module, name, capture): + original = getattr(module, name) + + def fake(*args, **kwargs): + capture.kwargs = kwargs + return object() + + monkeypatch.setattr(module, name, fake) + return original + + +def _patch_ollama_init(monkeypatch, capture): + def fake_init(self, *args, **kwargs): + capture.kwargs = kwargs + + monkeypatch.setattr(ollama_module.OllamaClient, "__init__", fake_init) + + +def test_ollama_from_settings_defaults_to_verify_true(store, monkeypatch): + store.set(OLLAMA_URL, "https://ollama.example.de", USER) + capture = _Capture() + _patch_ollama_init(monkeypatch, capture) + ollama_module.OllamaClient.from_settings(store) + assert capture.kwargs["verify"] is True + + +def test_ollama_from_settings_uses_ca_file(store, monkeypatch): + store.set(OLLAMA_URL, "https://ollama.example.de", USER) + store.set(OLLAMA_CA_FILE, "/etc/ssl/certs/intern-ca.pem", USER) + capture = _Capture() + _patch_ollama_init(monkeypatch, capture) + ollama_module.OllamaClient.from_settings(store) + assert capture.kwargs["verify"] == "/etc/ssl/certs/intern-ca.pem" + + +def test_ollama_from_settings_verify_off(store, monkeypatch): + store.set(OLLAMA_URL, "https://ollama.example.de", USER) + store.set(OLLAMA_VERIFY_TLS, FLAG_OFF, USER) + store.set(OLLAMA_CA_FILE, "/etc/ssl/certs/intern-ca.pem", USER) + capture = _Capture() + _patch_ollama_init(monkeypatch, capture) + ollama_module.OllamaClient.from_settings(store) + assert capture.kwargs["verify"] is False + + +def _set_matrix_basics(store): + store.set(MATRIX_ENABLED, FLAG_ON, USER) + store.set(MATRIX_HOMESERVER, "https://matrix.example.de", USER) + store.set(MATRIX_USER_ID, "@checkbot:example.de", USER) + store.set(MATRIX_TOKEN, "tok", USER, secret=True) + store.set(MATRIX_ROOM_ID, "!room:example.de", USER) + + +def test_build_matrix_defaults_to_verify_true(store, monkeypatch): + _set_matrix_basics(store) + capture = _Capture() + monkeypatch.setattr(chat_registry, "MatrixAdapter", + lambda *a, **kw: capture.__setattr__("kwargs", kw) or object()) + chat_registry.build_matrix(store) + assert capture.kwargs["verify"] is True + + +def test_build_matrix_verify_off(store, monkeypatch): + _set_matrix_basics(store) + store.set(MATRIX_VERIFY_TLS, FLAG_OFF, USER) + capture = _Capture() + monkeypatch.setattr(chat_registry, "MatrixAdapter", + lambda *a, **kw: capture.__setattr__("kwargs", kw) or object()) + chat_registry.build_matrix(store) + assert capture.kwargs["verify"] is False + + +def test_build_matrix_uses_ca_file(store, monkeypatch): + _set_matrix_basics(store) + store.set(MATRIX_CA_FILE, "/etc/ssl/certs/intern-ca.pem", USER) + capture = _Capture() + monkeypatch.setattr(chat_registry, "MatrixAdapter", + lambda *a, **kw: capture.__setattr__("kwargs", kw) or object()) + chat_registry.build_matrix(store) + assert capture.kwargs["verify"] == "/etc/ssl/certs/intern-ca.pem"