180 lines
7.6 KiB
Python
180 lines
7.6 KiB
Python
"""
|
|
Tests fuer Phase 14 -- die eigentliche Ursache des "Host-Key konnte nicht
|
|
ermittelt werden -- Ziel nicht erreichbar"-Dauerbrenners.
|
|
|
|
Gemeldet wurde zuletzt:
|
|
|
|
Host-Key konnte nicht ermittelt werden -- Ziel nicht erreichbar:
|
|
get_server_host_key() got an unexpected keyword argument 'connect_timeout'
|
|
|
|
...und zwar in unter einer Sekunde nach dem Klick. Genau das ist der Beweis:
|
|
es wurde nie ein Socket geoeffnet. asyncssh.get_server_host_key() nimmt --
|
|
anders als asyncssh.connect() -- KEIN **kwargs entgegen, 'connect_timeout'
|
|
gehoert nicht zu seinen Parametern. Der Aufruf endete also schon beim
|
|
Argument-Binding in einem TypeError.
|
|
|
|
Warum das dreimal falsch diagnostiziert wurde:
|
|
* Phase 12 fuehrte get_server_host_key(..., connect_timeout=10) ein. Der
|
|
TypeError lief unbehandelt bis FastAPI -> nackter HTTP 500.
|
|
* Der Phase-12-Nachtrag deutete diesen 500er als "except (asyncssh.Error,
|
|
OSError) ist zu eng" und verbreiterte auf except Exception. Damit wurde
|
|
der TypeError zwar gefangen -- aber als HostKeyDiscoveryError, also als
|
|
"Ziel nicht erreichbar" VERKLEIDET. Erst dadurch wurde der Wortlaut
|
|
ueberhaupt sichtbar.
|
|
* Die Tests aus Phase 12 konnten es nicht sehen: ihre asyncssh-Attrappen
|
|
waren als (host, port=22, **kw) definiert und schluckten jedes beliebige
|
|
Argument klaglos.
|
|
|
|
Diese Datei sichert genau diese drei Punkte ab.
|
|
"""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import inspect
|
|
|
|
import asyncssh
|
|
import pytest
|
|
|
|
from app.ssh_proxy import proxy as proxy_module
|
|
from app.ssh_proxy.proxy import (
|
|
HostKeyDiscoveryError,
|
|
_verified_host_key,
|
|
discover_and_store_host_key,
|
|
load_host,
|
|
)
|
|
|
|
try: # je nach sys.path-Modus von pytest
|
|
from tests.test_phase12 import FINGERPRINT, PUBLIC_KEY, FakeConnection, FakeHostKey, _make_db
|
|
except ImportError: # pragma: no cover
|
|
from test_phase12 import FINGERPRINT, PUBLIC_KEY, FakeConnection, FakeHostKey, _make_db
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# Attrappe mit der ECHTEN Signatur von asyncssh 2.18.0. Bewusst kein **kwargs:
|
|
# jedes zusaetzliche Argument aus dem Produktivcode schlaegt hier genauso fehl
|
|
# wie beim echten asyncssh.
|
|
# --------------------------------------------------------------------------
|
|
|
|
def _strict_get_server_host_key(result=None, *, calls=None):
|
|
async def _fake(
|
|
host="", port=(), *, tunnel=(), proxy_command=(), family=(), flags=0,
|
|
local_addr=(), sock=None, client_version=(), kex_algs=(),
|
|
server_host_key_algs=(), config=(), options=None,
|
|
):
|
|
if calls is not None:
|
|
calls.append((host, port))
|
|
if isinstance(result, BaseException):
|
|
raise result
|
|
return result if result is not None else FakeHostKey()
|
|
|
|
return _fake
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# 1) Die Signatur selbst -- der Test, der den Bug im Produktivsystem gefunden
|
|
# haette. Laeuft gegen das TATSAECHLICH installierte asyncssh.
|
|
# --------------------------------------------------------------------------
|
|
|
|
def test_aufruf_passt_zur_echten_signatur_von_get_server_host_key():
|
|
sig = inspect.signature(asyncssh.get_server_host_key)
|
|
# So ruft proxy.py auf -- muss sich binden lassen:
|
|
sig.bind("10.0.0.1", port=22)
|
|
|
|
|
|
def test_connect_timeout_ist_kein_parameter_von_get_server_host_key():
|
|
"""Dokumentiert die Falle: connect_timeout ist bei asyncssh.connect()
|
|
erlaubt (das reicht **kwargs an SSHClientConnectionOptions weiter), bei
|
|
get_server_host_key() aber NICHT -- dessen Parameterliste ist
|
|
abschliessend."""
|
|
sig = inspect.signature(asyncssh.get_server_host_key)
|
|
hat_var_keyword = any(
|
|
p.kind is inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
|
|
)
|
|
if hat_var_keyword:
|
|
pytest.skip("Diese asyncssh-Version nimmt **kwargs entgegen")
|
|
assert "connect_timeout" not in sig.parameters
|
|
with pytest.raises(TypeError):
|
|
sig.bind("10.0.0.1", port=22, connect_timeout=10)
|
|
|
|
|
|
async def test_fetch_server_host_key_uebergibt_nur_host_und_port(monkeypatch):
|
|
calls: list = []
|
|
monkeypatch.setattr(
|
|
asyncssh, "get_server_host_key", _strict_get_server_host_key(calls=calls), raising=False
|
|
)
|
|
key = await proxy_module._fetch_server_host_key("10.0.0.1", 2222)
|
|
assert calls == [("10.0.0.1", 2222)]
|
|
assert key.get_fingerprint("sha256") == FINGERPRINT
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# 2) Beide betroffenen Pfade end-to-end -- mit der strengen Attrappe.
|
|
# Wichtig: _verified_host_key() liegt im REGULAEREN Verbindungspfad
|
|
# (connect_to_host), der connect_timeout-Bug hat also nicht nur den Knopf
|
|
# "Host-Key ermitteln", sondern JEDE SSH-Sitzung lahmgelegt.
|
|
# --------------------------------------------------------------------------
|
|
|
|
async def test_discovery_laeuft_mit_echter_signatur_durch(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(
|
|
asyncssh, "get_server_host_key", _strict_get_server_host_key(), raising=False
|
|
)
|
|
conn = FakeConnection(_make_db(tmp_path, fingerprint=None, host_key=None))
|
|
assert await discover_and_store_host_key(conn, 1, admin_user_id=1) == FINGERPRINT
|
|
|
|
|
|
async def test_pinning_laeuft_mit_echter_signatur_durch(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(
|
|
asyncssh, "get_server_host_key", _strict_get_server_host_key(), raising=False
|
|
)
|
|
conn = FakeConnection(_make_db(tmp_path))
|
|
host = await load_host(conn, 1)
|
|
key = await _verified_host_key(conn, host)
|
|
assert key.get_fingerprint("sha256") == FINGERPRINT
|
|
|
|
|
|
# --------------------------------------------------------------------------
|
|
# 3) Fehlerbehandlung: echte Netzwerkfehler bleiben "Ziel nicht erreichbar",
|
|
# ein Aufruffehler im eigenen Code aber NICHT.
|
|
# --------------------------------------------------------------------------
|
|
|
|
async def test_netzwerkfehler_bleibt_hostkeydiscoveryerror(tmp_path, monkeypatch):
|
|
monkeypatch.setattr(
|
|
asyncssh, "get_server_host_key",
|
|
_strict_get_server_host_key(OSError("Connection refused")), raising=False,
|
|
)
|
|
conn = FakeConnection(_make_db(tmp_path))
|
|
with pytest.raises(HostKeyDiscoveryError) as excinfo:
|
|
await discover_and_store_host_key(conn, 1, admin_user_id=1)
|
|
assert "Connection refused" in excinfo.value.reason
|
|
|
|
|
|
async def test_typeerror_wird_nicht_als_unerreichbar_verkleidet(tmp_path, monkeypatch):
|
|
"""Der Kern der Lehre aus dieser Phase: haette der Catch-all den TypeError
|
|
nicht als HostKeyDiscoveryError ausgegeben, waere die Meldung von Anfang
|
|
an als Programmierfehler erkennbar gewesen."""
|
|
async def _kaputt(*a, **kw):
|
|
raise TypeError("get_server_host_key() got an unexpected keyword argument 'irgendwas'")
|
|
|
|
monkeypatch.setattr(asyncssh, "get_server_host_key", _kaputt, raising=False)
|
|
conn = FakeConnection(_make_db(tmp_path))
|
|
with pytest.raises(TypeError):
|
|
await discover_and_store_host_key(conn, 1, admin_user_id=1)
|
|
host = await load_host(conn, 1)
|
|
with pytest.raises(TypeError):
|
|
await _verified_host_key(conn, host)
|
|
|
|
|
|
async def test_zeitlimit_wird_von_aussen_gesetzt(tmp_path, monkeypatch):
|
|
"""Das Zeitlimit ist nicht ersatzlos entfallen, sondern liegt jetzt in
|
|
asyncio.wait_for() -- unabhaengig davon, wie asyncssh seine Optionen
|
|
benennt."""
|
|
async def _haengt(*a, **kw):
|
|
await asyncio.sleep(5)
|
|
|
|
monkeypatch.setattr(asyncssh, "get_server_host_key", _haengt, raising=False)
|
|
monkeypatch.setattr(proxy_module, "HOST_KEY_CONNECT_TIMEOUT", 0.05)
|
|
conn = FakeConnection(_make_db(tmp_path))
|
|
with pytest.raises(HostKeyDiscoveryError) as excinfo:
|
|
await discover_and_store_host_key(conn, 1, admin_user_id=1)
|
|
assert "Zeitlimit" in excinfo.value.reason
|