maxconn 0.1.0__py3-none-any.whl

maxconn/__init__.py

@@ -0,0 +1,68 @@
+"""maxconn - SSH and Telnet client built from scratch."""
+
+from __future__ import annotations
+
+from maxconn.exceptions import (
+    AuthenticationError,
+    ChannelError,
+    ConnectionTimeoutError,
+    MaxConnError,
+    ProtocolError,
+)
+from maxconn.transport.base import CommandResult, Connection, Transport
+
+__all__ = [
+    "AuthenticationError",
+    "ChannelError",
+    "CommandResult",
+    "Connection",
+    "ConnectionTimeoutError",
+    "MaxConnError",
+    "ProtocolError",
+    "connect",
+]
+
+_DEFAULT_PORTS = {"telnet": 23, "ssh": 22}
+
+
+def connect(
+    host: str,
+    *,
+    protocol: str,
+    username: str,
+    password: str | None = None,
+    pkey: object | None = None,
+    port: int | None = None,
+    timeout: float = 10.0,
+    connect_timeout: float | None = None,
+    auth_timeout: float | None = None,
+    command_timeout: float = 5.0,
+    prompt_timeout: float = 10.0,
+) -> Connection:
+    # Imported per-protocol, not at module load, so using one transport
+    # never pulls in the other's dependencies (see the "import only what
+    # you use" rule in the project brief).
+    transport: Transport
+    if protocol == "telnet":
+        from maxconn.transport.telnet.transport import TelnetTransport
+
+        transport = TelnetTransport()
+    elif protocol == "ssh":
+        from maxconn.transport.ssh.transport import SSHTransport
+
+        transport = SSHTransport()
+    else:
+        raise ValueError(f"Unsupported protocol: {protocol!r}. Supported: 'telnet', 'ssh'")
+
+    resolved_port = port if port is not None else _DEFAULT_PORTS[protocol]
+    resolved_connect_timeout = connect_timeout if connect_timeout is not None else timeout
+    resolved_auth_timeout = auth_timeout if auth_timeout is not None else timeout
+    transport.connect(host, resolved_port, resolved_connect_timeout)
+    transport.authenticate(username, password=password, pkey=pkey, timeout=resolved_auth_timeout)
+    return Connection(
+        transport,
+        host=host,
+        protocol=protocol,
+        command_timeout=command_timeout,
+        prompt_timeout=prompt_timeout,
+    )

maxconn/automation/__init__.py

@@ -0,0 +1,5 @@
+"""Prompt/expect helpers for interactive network CLIs."""
+
+from maxconn.automation.expect import ExpectSession, PromptProfile
+
+__all__ = ["ExpectSession", "PromptProfile"]

maxconn/automation/expect.py

@@ -0,0 +1,84 @@
+"""Small expect-style command runner for prompt-based CLIs."""
+
+from __future__ import annotations
+
+import time
+from enum import Enum
+from typing import Protocol
+
+from maxconn.exceptions import ConnectionTimeoutError
+
+
+class PromptProfile(Enum):
+    GENERIC = ("generic", (">", "#"))
+    CISCO = ("cisco", (">", "#"))
+    HUAWEI = ("huawei", ("<", ">", "]"))
+
+    @property
+    def markers(self) -> tuple[str, ...]:
+        return self.value[1]
+
+
+class ExpectConnection(Protocol):
+    def send(self, data: bytes | str) -> None: ...
+
+    def recv(self, timeout: float | None = None) -> bytes: ...
+
+
+class ExpectSession:
+    def __init__(
+        self,
+        connection: ExpectConnection,
+        *,
+        prompt_markers: tuple[str, ...] | PromptProfile,
+        pagination_markers: tuple[str, ...] = (),
+    ) -> None:
+        self._connection = connection
+        self._prompt_markers = (
+            prompt_markers.markers if isinstance(prompt_markers, PromptProfile) else prompt_markers
+        )
+        self._pagination_markers = pagination_markers
+
+    def run(self, command: str, *, timeout: float = 10.0, strip_echo: bool = False) -> str:
+        self._connection.send(command + "\n")
+        output = self._read_until_prompt(timeout)
+        if strip_echo:
+            output = self._strip_command_echo(output, command)
+        return output
+
+    def _read_until_prompt(self, timeout: float) -> str:
+        deadline = time.monotonic() + timeout
+        buffer = ""
+        while time.monotonic() < deadline:
+            remaining = deadline - time.monotonic()
+            try:
+                chunk = self._connection.recv(timeout=max(remaining, 0.01))
+            except ConnectionTimeoutError as exc:
+                raise ConnectionTimeoutError(
+                    f"Timed out waiting for prompt {self._prompt_markers!r}; got: {buffer!r}"
+                ) from exc
+
+            buffer += chunk.decode(errors="replace")
+            buffer = self._answer_pagination(buffer)
+            if any(marker in buffer for marker in self._prompt_markers):
+                return buffer
+
+        raise ConnectionTimeoutError(
+            f"Timed out waiting for prompt {self._prompt_markers!r}; got: {buffer!r}"
+        )
+
+    def _answer_pagination(self, buffer: str) -> str:
+        for marker in self._pagination_markers:
+            if marker in buffer:
+                self._connection.send(" ")
+                buffer = buffer.replace(marker, "")
+        return buffer
+
+    @staticmethod
+    def _strip_command_echo(output: str, command: str) -> str:
+        normalized_command = command.strip()
+        for separator in ("\r\n", "\n"):
+            prefix = normalized_command + separator
+            if output.startswith(prefix):
+                return output[len(prefix) :]
+        return output

maxconn/exceptions.py

@@ -0,0 +1,18 @@
+class MaxConnError(Exception):
+    """Base exception for all maxconn errors."""
+
+
+class ConnectionTimeoutError(MaxConnError):
+    """Raised when a connection attempt or a read times out."""
+
+
+class AuthenticationError(MaxConnError):
+    """Raised when authentication with the remote host fails."""
+
+
+class ProtocolError(MaxConnError):
+    """Raised when a malformed or unexpected protocol message is received."""
+
+
+class ChannelError(MaxConnError):
+    """Raised when a channel operation fails (SSH channels)."""

maxconn/transport/base.py

@@ -0,0 +1,162 @@
+"""Transport abstraction shared by SSH and Telnet implementations."""
+
+from __future__ import annotations
+
+import logging
+import re
+import time
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+
+from maxconn.automation import ExpectSession, PromptProfile
+from maxconn.exceptions import ConnectionTimeoutError
+
+_AUDIT_LOG = logging.getLogger("maxconn.audit")
+_SECRET_PATTERNS = (
+    re.compile(r"(?i)\b(password|passwd|secret|token|key)\s+\S+"),
+    re.compile(r"(?i)(--password|--passwd|--secret|--token|--key)\s+\S+"),
+)
+
+
+class Transport(ABC):
+    @abstractmethod
+    def connect(self, host: str, port: int, timeout: float) -> None: ...
+
+    @abstractmethod
+    def authenticate(
+        self,
+        username: str,
+        password: str | None = None,
+        pkey: object | None = None,
+        timeout: float | None = None,
+    ) -> None: ...
+    # `pkey`'s concrete type is transport-specific (e.g. SSHTransport
+    # expects a cryptography RSAPrivateKey); transports that don't support
+    # key-based auth raise AuthenticationError when it's passed.
+
+    @abstractmethod
+    def send(self, data: bytes | str) -> None: ...
+
+    @abstractmethod
+    def recv(self, timeout: float | None = None) -> bytes: ...
+
+    @abstractmethod
+    def close(self) -> None: ...
+
+
+def read_until(transport: Transport, markers: tuple[str, ...], timeout: float) -> str:
+    deadline = time.monotonic() + timeout
+    buffer = ""
+    while time.monotonic() < deadline:
+        remaining = deadline - time.monotonic()
+        chunk = transport.recv(timeout=max(remaining, 0.01))
+        buffer += chunk.decode(errors="replace")
+        if any(marker.lower() in buffer.lower() for marker in markers):
+            return buffer
+    raise ConnectionTimeoutError(f"Timed out waiting for markers {markers!r}; got: {buffer!r}")
+
+
+@dataclass(frozen=True)
+class CommandResult:
+    command: str
+    text: str
+    bytes: bytes
+    elapsed: float
+    exit_status: int | None = None
+
+    @property
+    def ok(self) -> bool:
+        return self.exit_status in (None, 0)
+
+
+class Connection:
+    def __init__(
+        self,
+        transport: Transport,
+        *,
+        host: str | None = None,
+        protocol: str | None = None,
+        command_timeout: float = 5.0,
+        prompt_timeout: float = 10.0,
+        prompt_profile: PromptProfile = PromptProfile.GENERIC,
+    ) -> None:
+        self._transport = transport
+        self.host = host
+        self.protocol = protocol
+        self.command_timeout = command_timeout
+        self.prompt_timeout = prompt_timeout
+        self.prompt_profile = prompt_profile
+
+    def send_command(self, command: str, *, read_timeout: float = 5.0) -> str:
+        self._transport.send(command + "\n")
+        deadline = time.monotonic() + read_timeout
+        buffer = ""
+        while time.monotonic() < deadline:
+            remaining = deadline - time.monotonic()
+            try:
+                chunk = self._transport.recv(timeout=max(remaining, 0.01))
+            except ConnectionTimeoutError:
+                break
+            buffer += chunk.decode(errors="replace")
+        return buffer
+
+    def run(
+        self,
+        command: str,
+        *,
+        prompt_markers: tuple[str, ...] | None = None,
+        timeout: float | None = None,
+        strip_echo: bool = True,
+        pagination_markers: tuple[str, ...] = ("--More--",),
+    ) -> CommandResult:
+        start = time.monotonic()
+        resolved_timeout = timeout if timeout is not None else self.command_timeout
+        resolved_markers = prompt_markers if prompt_markers is not None else self.prompt_profile.markers
+        expect = ExpectSession(
+            self,
+            prompt_markers=resolved_markers,
+            pagination_markers=pagination_markers,
+        )
+
+        text = expect.run(command, timeout=resolved_timeout, strip_echo=strip_echo)
+        elapsed = time.monotonic() - start
+        result = CommandResult(
+            command=command,
+            text=text,
+            bytes=text.encode(),
+            elapsed=elapsed,
+        )
+        _AUDIT_LOG.info(
+            "command completed host=%s protocol=%s command=%r elapsed=%.3f ok=%s",
+            self.host,
+            self.protocol,
+            _redact(command),
+            elapsed,
+            result.ok,
+        )
+        return result
+
+    def send(self, data: bytes | str) -> None:
+        self._transport.send(data)
+
+    def recv(self, timeout: float | None = None) -> bytes:
+        return self._transport.recv(timeout=timeout)
+
+    def read_until(self, marker: str, timeout: float = 10.0) -> str:
+        return read_until(self._transport, (marker,), timeout)
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> Connection:
+        return self
+
+    def __exit__(self, exc_type, exc, tb) -> None:
+        self.close()
+
+
+def _redact(value: str) -> str:
+    redacted = value
+    for pattern in _SECRET_PATTERNS:
+        redacted = pattern.sub(lambda match: f"{match.group(1)} <redacted>", redacted)
+    return redacted

maxconn/transport/ssh/auth.py

@@ -0,0 +1,104 @@
+"""SSH user authentication (RFC 4252): the ssh-userauth service request,
+plus the "password" and "publickey" authentication methods."""
+
+from __future__ import annotations
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import padding, rsa
+
+from maxconn.exceptions import AuthenticationError, ProtocolError
+from maxconn.transport.ssh import messages
+from maxconn.transport.ssh.negotiate import EncryptedSession
+from maxconn.transport.ssh.wire import Reader, encode_mpint, encode_string
+
+_MAX_BANNERS = 10
+_PUBKEY_ALGORITHM = "rsa-sha2-256"
+
+
+def build_rsa_public_key_blob(public_key: rsa.RSAPublicKey) -> bytes:
+    numbers = public_key.public_numbers()
+    return encode_string(b"ssh-rsa") + encode_mpint(numbers.e) + encode_mpint(numbers.n)
+
+
+def request_userauth_service(session: EncryptedSession) -> None:
+    request = bytes([messages.SSH_MSG_SERVICE_REQUEST]) + encode_string(b"ssh-userauth")
+    session.send_message(request)
+
+    reader = Reader(session.recv_message())
+    msg_type = reader.read_byte()
+    if msg_type != messages.SSH_MSG_SERVICE_ACCEPT:
+        raise ProtocolError(f"Expected SSH_MSG_SERVICE_ACCEPT ({messages.SSH_MSG_SERVICE_ACCEPT}), got {msg_type}")
+    service_name = reader.read_string()
+    if service_name != b"ssh-userauth":
+        raise ProtocolError(f"Unexpected service accepted: {service_name!r}")
+
+
+def _read_until_auth_result(session: EncryptedSession) -> bytes:
+    """SSH_MSG_USERAUTH_BANNER may arrive before the real result; skip it."""
+    for _ in range(_MAX_BANNERS):
+        payload = session.recv_message()
+        if payload and payload[0] == messages.SSH_MSG_USERAUTH_BANNER:
+            continue
+        return payload
+    raise ProtocolError("Too many SSH_MSG_USERAUTH_BANNER messages without an auth result")
+
+
+def authenticate_password(session: EncryptedSession, username: str, password: str) -> None:
+    request = (
+        bytes([messages.SSH_MSG_USERAUTH_REQUEST])
+        + encode_string(username.encode("utf-8"))
+        + encode_string(b"ssh-connection")
+        + encode_string(b"password")
+        + bytes([0])  # FALSE: this is not a change-password request
+        + encode_string(password.encode("utf-8"))
+    )
+    session.send_message(request)
+
+    payload = _read_until_auth_result(session)
+    reader = Reader(payload)
+    msg_type = reader.read_byte()
+    if msg_type == messages.SSH_MSG_USERAUTH_SUCCESS:
+        return
+    if msg_type == messages.SSH_MSG_USERAUTH_FAILURE:
+        raise AuthenticationError(f"SSH password authentication failed for user {username!r}")
+    raise ProtocolError(f"Unexpected message during password authentication: {msg_type}")
+
+
+def authenticate_publickey(session: EncryptedSession, username: str, private_key: rsa.RSAPrivateKey) -> None:
+    """RFC 4252 §7. Signs directly (no accept-probing round trip) since the
+    servers we target don't require it."""
+    public_key_blob = build_rsa_public_key_blob(private_key.public_key())
+
+    signed_part = (
+        encode_string(session.session_id)
+        + bytes([messages.SSH_MSG_USERAUTH_REQUEST])
+        + encode_string(username.encode("utf-8"))
+        + encode_string(b"ssh-connection")
+        + encode_string(b"publickey")
+        + bytes([1])  # TRUE: a signature is included
+        + encode_string(_PUBKEY_ALGORITHM.encode("ascii"))
+        + encode_string(public_key_blob)
+    )
+    signature = private_key.sign(signed_part, padding.PKCS1v15(), hashes.SHA256())
+    signature_blob = encode_string(_PUBKEY_ALGORITHM.encode("ascii")) + encode_string(signature)
+
+    request = (
+        bytes([messages.SSH_MSG_USERAUTH_REQUEST])
+        + encode_string(username.encode("utf-8"))
+        + encode_string(b"ssh-connection")
+        + encode_string(b"publickey")
+        + bytes([1])
+        + encode_string(_PUBKEY_ALGORITHM.encode("ascii"))
+        + encode_string(public_key_blob)
+        + encode_string(signature_blob)
+    )
+    session.send_message(request)
+
+    payload = _read_until_auth_result(session)
+    reader = Reader(payload)
+    msg_type = reader.read_byte()
+    if msg_type == messages.SSH_MSG_USERAUTH_SUCCESS:
+        return
+    if msg_type == messages.SSH_MSG_USERAUTH_FAILURE:
+        raise AuthenticationError(f"SSH public-key authentication failed for user {username!r}")
+    raise ProtocolError(f"Unexpected message during public-key authentication: {msg_type}")

maxconn/transport/ssh/channel.py

@@ -0,0 +1,131 @@
+"""SSH channel handling: open a session channel and run exec/shell commands
+(RFC 4254 sections 4-6). v0.1 does not track outgoing flow control (channel
+window replenishment for data *we* send) - fine for interactive command/CLI
+use, not for bulk transfers."""
+
+from __future__ import annotations
+
+from maxconn.exceptions import ChannelError
+from maxconn.transport.ssh import messages
+from maxconn.transport.ssh.negotiate import EncryptedSession
+from maxconn.transport.ssh.wire import Reader, encode_string, encode_uint32
+
+INITIAL_WINDOW_SIZE = 2 * 1024 * 1024
+MAX_PACKET_SIZE = 32768
+
+_CONTROL_ONLY_MESSAGES = (
+    messages.SSH_MSG_CHANNEL_WINDOW_ADJUST,
+    messages.SSH_MSG_CHANNEL_SUCCESS,
+    messages.SSH_MSG_CHANNEL_FAILURE,
+    messages.SSH_MSG_CHANNEL_REQUEST,  # e.g. "exit-status" - informational only
+    messages.SSH_MSG_CHANNEL_EOF,
+)
+
+
+class SSHChannel:
+    def __init__(self, session: EncryptedSession, local_id: int, peer_id: int) -> None:
+        self._session = session
+        self.local_id = local_id
+        self.peer_id = peer_id
+        self._closed = False
+
+    def request_exec(self, command: str) -> None:
+        payload = (
+            bytes([messages.SSH_MSG_CHANNEL_REQUEST])
+            + encode_uint32(self.peer_id)
+            + encode_string(b"exec")
+            + bytes([0])  # want_reply = False: caller reads the command output instead
+            + encode_string(command.encode("utf-8"))
+        )
+        self._session.send_message(payload)
+
+    def request_shell(self) -> None:
+        pty_payload = (
+            bytes([messages.SSH_MSG_CHANNEL_REQUEST])
+            + encode_uint32(self.peer_id)
+            + encode_string(b"pty-req")
+            + bytes([0])
+            + encode_string(b"xterm")
+            + encode_uint32(80)
+            + encode_uint32(24)
+            + encode_uint32(640)
+            + encode_uint32(480)
+            + encode_string(b"")
+        )
+        self._session.send_message(pty_payload)
+
+        shell_payload = (
+            bytes([messages.SSH_MSG_CHANNEL_REQUEST])
+            + encode_uint32(self.peer_id)
+            + encode_string(b"shell")
+            + bytes([0])
+        )
+        self._session.send_message(shell_payload)
+
+    def send_data(self, data: bytes) -> None:
+        payload = bytes([messages.SSH_MSG_CHANNEL_DATA]) + encode_uint32(self.peer_id) + encode_string(data)
+        self._session.send_message(payload)
+
+    def recv_data(self) -> bytes:
+        """Read one channel message and return its data payload (empty
+        bytes for control-only messages like a window adjustment)."""
+        while True:
+            payload = self._session.recv_message()
+            reader = Reader(payload)
+            msg_type = reader.read_byte()
+
+            if msg_type == messages.SSH_MSG_CHANNEL_DATA:
+                reader.read_uint32()  # recipient channel (ours; unused)
+                return reader.read_string()
+            if msg_type == messages.SSH_MSG_CHANNEL_EXTENDED_DATA:
+                reader.read_uint32()
+                reader.read_uint32()  # data_type_code (e.g. stderr)
+                return reader.read_string()
+            if msg_type in _CONTROL_ONLY_MESSAGES:
+                continue
+            if msg_type == messages.SSH_MSG_CHANNEL_CLOSE:
+                self._closed = True
+                close_payload = bytes([messages.SSH_MSG_CHANNEL_CLOSE]) + encode_uint32(self.peer_id)
+                self._session.send_message(close_payload)
+                return b""
+
+            raise ChannelError(f"Unexpected message on SSH channel: type {msg_type}")
+
+    @property
+    def closed(self) -> bool:
+        return self._closed
+
+    def close(self) -> None:
+        if not self._closed:
+            self._session.send_message(bytes([messages.SSH_MSG_CHANNEL_CLOSE]) + encode_uint32(self.peer_id))
+            self._closed = True
+
+
+def open_session_channel(session: EncryptedSession, local_id: int = 0) -> SSHChannel:
+    request = (
+        bytes([messages.SSH_MSG_CHANNEL_OPEN])
+        + encode_string(b"session")
+        + encode_uint32(local_id)
+        + encode_uint32(INITIAL_WINDOW_SIZE)
+        + encode_uint32(MAX_PACKET_SIZE)
+    )
+    session.send_message(request)
+
+    payload = session.recv_message()
+    reader = Reader(payload)
+    msg_type = reader.read_byte()
+
+    if msg_type == messages.SSH_MSG_CHANNEL_OPEN_FAILURE:
+        reader.read_uint32()  # recipient channel
+        reason_code = reader.read_uint32()
+        description = reader.read_string().decode(errors="replace")
+        raise ChannelError(f"SSH channel open failed (reason {reason_code}): {description}")
+    if msg_type != messages.SSH_MSG_CHANNEL_OPEN_CONFIRMATION:
+        raise ChannelError(f"Unexpected reply to SSH_MSG_CHANNEL_OPEN: type {msg_type}")
+
+    reader.read_uint32()  # recipient channel (== local_id, echoed back)
+    peer_id = reader.read_uint32()
+    reader.read_uint32()  # peer's initial window size (unused, see module docstring)
+    reader.read_uint32()  # peer's max packet size (unused, same reason)
+
+    return SSHChannel(session, local_id, peer_id)

maxconn/transport/ssh/diffie_hellman.py

@@ -0,0 +1,105 @@
+"""Diffie-Hellman group14-sha256 key exchange (RFC 4253 section 8, group
+from RFC 3526 section 3 - the 2048-bit MODP "group 14")."""
+
+from __future__ import annotations
+
+import hashlib
+import secrets
+import socket
+from dataclasses import dataclass
+
+from maxconn.exceptions import ProtocolError
+from maxconn.transport.ssh import messages
+from maxconn.transport.ssh.packet import decode_binary_packet, encode_binary_packet
+from maxconn.transport.ssh.socket_reader import SocketReader
+from maxconn.transport.ssh.wire import Reader, encode_mpint, encode_string
+
+# RFC 3526 section 3, 2048-bit MODP Group ("group 14").
+_P_HEX = (
+    "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD"
+    "129024E088A67CC74020BBEA63B139B22514A08798E3404"
+    "DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C"
+    "245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406"
+    "B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE"
+    "45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD"
+    "24CF5F83655D23DCA3AD961C62F356208552BB9ED529077"
+    "096966D670C354E4ABC9804F1746C08CA18217C32905E46"
+    "2E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF"
+    "06F4C52C9DE2BCBF6955817183995497CEA956AE515D226"
+    "1898FA051015728E5A8AACAA68FFFFFFFFFFFFFFFF"
+)
+P = int(_P_HEX, 16)
+G = 2
+
+
+@dataclass
+class KexResult:
+    shared_secret: int  # K
+    exchange_hash: bytes  # H
+    host_key_blob: bytes  # K_S, as received from the server
+    signature_blob: bytes  # raw "string" signature blob from KEXDH_REPLY
+
+
+def perform_diffie_hellman(
+    sock: socket.socket,
+    reader: SocketReader,
+    client_version: bytes,
+    server_version: bytes,
+    client_kexinit_payload: bytes,
+    server_kexinit_payload: bytes,
+) -> KexResult:
+    x = secrets.randbelow(P - 3) + 2  # private exponent, 2 <= x <= P-2
+    e = pow(G, x, P)
+
+    packet = encode_binary_packet(bytes([messages.SSH_MSG_KEXDH_INIT]) + encode_mpint(e))
+    sock.sendall(packet)
+
+    reply_payload = decode_binary_packet(reader.read_exact)
+    reply = Reader(reply_payload)
+    msg_type = reply.read_byte()
+    if msg_type != messages.SSH_MSG_KEXDH_REPLY:
+        raise ProtocolError(f"Expected SSH_MSG_KEXDH_REPLY ({messages.SSH_MSG_KEXDH_REPLY}), got {msg_type}")
+
+    host_key_blob = reply.read_string()
+    f = reply.read_mpint()
+    signature_blob = reply.read_string()
+
+    shared_secret = pow(f, x, P)
+    exchange_hash = compute_exchange_hash(
+        client_version=client_version,
+        server_version=server_version,
+        client_kexinit_payload=client_kexinit_payload,
+        server_kexinit_payload=server_kexinit_payload,
+        host_key_blob=host_key_blob,
+        e=e,
+        f=f,
+        shared_secret=shared_secret,
+    )
+    return KexResult(shared_secret, exchange_hash, host_key_blob, signature_blob)
+
+
+def compute_exchange_hash(
+    *,
+    client_version: bytes,
+    server_version: bytes,
+    client_kexinit_payload: bytes,
+    server_kexinit_payload: bytes,
+    host_key_blob: bytes,
+    e: int,
+    f: int,
+    shared_secret: int,
+) -> bytes:
+    """H = SHA256(V_C || V_S || I_C || I_S || K_S || e || f || K), RFC 4253 §8."""
+    hash_input = b"".join(
+        [
+            encode_string(client_version),
+            encode_string(server_version),
+            encode_string(client_kexinit_payload),
+            encode_string(server_kexinit_payload),
+            encode_string(host_key_blob),
+            encode_mpint(e),
+            encode_mpint(f),
+            encode_mpint(shared_secret),
+        ]
+    )
+    return hashlib.sha256(hash_input).digest()