py-web-ssh 0.1.7__tar.gz → 0.1.9__tar.gz

{py_web_ssh-0.1.7 → py_web_ssh-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: py-web-ssh
-Version: 0.1.7
+Version: 0.1.9
 Summary: A Python web SSH client with xterm.js, reconnectable sessions, logs, and file transfer.
 License-Expression: MIT
 License-File: LICENSE
@@ -34,7 +34,7 @@ Description-Content-Type: text/markdown
 - 会话回收：同一个 UUID 如果所有浏览器连接都断开并且 5 分钟内无人重连，服务端会主动断开 SSH 并清理内存缓存。
 - 终端恢复：服务端保存 SSH 输出流，浏览器定期回传 xterm serialize 快照；重连时先恢复快照，再补放快照之后的输出。
 - 日志页面：`/sessions/{uuid}/logs` 展示完整连接、认证、错误和文件传输日志。
-- 文件传输：参考 `simple-ssh-copy` 思路，不使用 SFTP/SCP；每次传输都按连接配置新建独立 SSH 连接，使用远端 `base64` shell 命令上传/下载。上传先写远端临时文件，完成后再 `mv` 到最终路径，并支持进度显示和取消。文件传输连接会校验服务器 host key 必须等于用户在交互终端里确认过的 host key。
+- 文件传输：参考 `simple-ssh-copy` 思路，不使用 SFTP/SCP；每次传输都按连接配置新建独立 SSH 连接，通过短小的远端 shell 命令分块追加 base64 临时文件，再在远端解码到临时数据文件并 `mv` 到最终路径，支持进度显示和取消。文件传输连接会校验服务器 host key 必须等于用户在交互终端里确认过的 host key。
 - 可选 PIN 门禁：服务端传入 `--pin` 后，网页启动时必须先输入正确 PIN；验证成功后浏览器会保存加盐哈希 cookie，后端会保护 HTTP API、日志页面、文件接口和 WebSocket。
 - 启动锁定策略：支持 `--lock-host`、`--lock-username`、`--lock-pwd`、`--lock-private-key`，可从服务端强制绑定目标主机、用户名、密码和服务端侧私钥文件。前端会锁定或隐藏对应控件，后端仍会校验并覆盖敏感字段。
 - 中英双语：默认英文，网页和日志页都支持中英切换；语言选择会长期保存到 `py_web_ssh_lang` cookie。

{py_web_ssh-0.1.7 → py_web_ssh-0.1.9}/README.md

@@ -12,7 +12,7 @@
 - 会话回收：同一个 UUID 如果所有浏览器连接都断开并且 5 分钟内无人重连，服务端会主动断开 SSH 并清理内存缓存。
 - 终端恢复：服务端保存 SSH 输出流，浏览器定期回传 xterm serialize 快照；重连时先恢复快照，再补放快照之后的输出。
 - 日志页面：`/sessions/{uuid}/logs` 展示完整连接、认证、错误和文件传输日志。
-- 文件传输：参考 `simple-ssh-copy` 思路，不使用 SFTP/SCP；每次传输都按连接配置新建独立 SSH 连接，使用远端 `base64` shell 命令上传/下载。上传先写远端临时文件，完成后再 `mv` 到最终路径，并支持进度显示和取消。文件传输连接会校验服务器 host key 必须等于用户在交互终端里确认过的 host key。
+- 文件传输：参考 `simple-ssh-copy` 思路，不使用 SFTP/SCP；每次传输都按连接配置新建独立 SSH 连接，通过短小的远端 shell 命令分块追加 base64 临时文件，再在远端解码到临时数据文件并 `mv` 到最终路径，支持进度显示和取消。文件传输连接会校验服务器 host key 必须等于用户在交互终端里确认过的 host key。
 - 可选 PIN 门禁：服务端传入 `--pin` 后，网页启动时必须先输入正确 PIN；验证成功后浏览器会保存加盐哈希 cookie，后端会保护 HTTP API、日志页面、文件接口和 WebSocket。
 - 启动锁定策略：支持 `--lock-host`、`--lock-username`、`--lock-pwd`、`--lock-private-key`，可从服务端强制绑定目标主机、用户名、密码和服务端侧私钥文件。前端会锁定或隐藏对应控件，后端仍会校验并覆盖敏感字段。
 - 中英双语：默认英文，网页和日志页都支持中英切换；语言选择会长期保存到 `py_web_ssh_lang` cookie。

{py_web_ssh-0.1.7 → py_web_ssh-0.1.9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "py-web-ssh"
-version = "0.1.7"
+version = "0.1.9"
 description = "A Python web SSH client with xterm.js, reconnectable sessions, logs, and file transfer."
 readme = "README.md"
 requires-python = ">=3.10"

{py_web_ssh-0.1.7 → py_web_ssh-0.1.9}/webssh/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.7"
+__version__ = "0.1.9"

{py_web_ssh-0.1.7 → py_web_ssh-0.1.9}/webssh/app.py

@@ -187,7 +187,12 @@ def upload(
 
 @app.post("/api/sessions/{session_id}/files/uploads")
 async def create_upload_task(session_id: str, request: Request) -> JSONResponse:
-    _require_session(session_id)
+    session = _require_session(session_id)
+    if session.confirmed_host_key is None:
+        raise HTTPException(
+            status_code=409,
+            detail="SSH server host key has not been confirmed in the terminal yet.",
+        )
     payload = await request.json()
     remote_path = str(payload.get("remote_path", "")).strip()
     if not remote_path:

py_web_ssh-0.1.9/webssh/files.py

@@ -0,0 +1,311 @@
+from __future__ import annotations
+
+import base64
+import binascii
+import os
+import posixpath
+import shlex
+import threading
+import uuid
+from collections.abc import Callable, Iterator
+from typing import BinaryIO, Protocol
+
+from .models import ConnectRequest
+from .ssh_client import HostKeyInfo, connect_ssh
+
+
+class FileTransferError(RuntimeError):
+    pass
+
+
+class FileTransferCancelled(FileTransferError):
+    pass
+
+
+ProgressCallback = Callable[[int], None]
+UPLOAD_BLOCK_SIZE = 4096
+
+
+class ShellClient(Protocol):
+    def exec_command(self, command: str): ...
+
+
+def upload_file_via_ssh(
+    config: ConnectRequest,
+    source: BinaryIO,
+    remote_path: str,
+    size: int | None,
+    expected_host_key: HostKeyInfo,
+    cancel_event: threading.Event | None = None,
+    progress: ProgressCallback | None = None,
+) -> tuple[str, int]:
+    """Upload using only bounded SSH exec commands and POSIX-ish shell commands.
+
+    This intentionally does not use SFTP or SCP. It follows the simple-ssh-copy
+    style: append base64 fragments with short remote commands, decode into a
+    temporary file, and move that temp file into place after the complete upload
+    succeeds.
+    """
+
+    connected = connect_ssh(
+        config,
+        lambda _level, _message, _details=None: None,
+        expected_host_key=expected_host_key,
+    )
+    client = connected.client
+    remote_dir = posixpath.dirname(remote_path) or "."
+    token = uuid.uuid4().hex
+    base64_temp_path = posixpath.join(remote_dir, f".py-web-ssh-upload-{token}.b64")
+    data_temp_path = posixpath.join(remote_dir, f".py-web-ssh-upload-{token}.tmp")
+    transferred = 0
+    completed = False
+    try:
+        _run_remote_command(client, f"mkdir -p {shlex.quote(remote_dir)}")
+        _run_remote_command(client, f": > {shlex.quote(base64_temp_path)}")
+        transferred = _write_base64_temp_file(
+            client,
+            source,
+            base64_temp_path,
+            cancel_event=cancel_event,
+            progress=progress,
+        )
+
+        if cancel_event and cancel_event.is_set():
+            raise FileTransferCancelled("Upload cancelled by client.")
+
+        _run_remote_command(client, _decode_and_move_command(base64_temp_path, data_temp_path, remote_path))
+        completed = True
+    except FileTransferCancelled:
+        _cleanup_remote_upload(client, base64_temp_path, data_temp_path)
+        _close_transport(client)
+        raise
+    except Exception as exc:
+        _cleanup_remote_upload(client, base64_temp_path, data_temp_path)
+        _close_transport(client)
+        raise FileTransferError(f"SSH shell upload failed: {exc}") from exc
+    finally:
+        if completed:
+            _cleanup_remote_upload(client, base64_temp_path, data_temp_path, raise_on_failure=False)
+        client.close()
+
+    if size is not None and transferred != size:
+        raise FileTransferError(f"Uploaded {transferred} bytes, expected {size} bytes.")
+    return "shell", transferred
+
+
+def download_file_via_ssh(
+    config: ConnectRequest,
+    remote_path: str,
+    expected_host_key: HostKeyInfo,
+) -> tuple[str, Iterator[bytes]]:
+    connected = connect_ssh(
+        config,
+        lambda _level, _message, _details=None: None,
+        expected_host_key=expected_host_key,
+    )
+    client = connected.client
+    command = f"base64 < {shlex.quote(remote_path)}"
+    stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
+    stdin.close()
+
+    def iterator() -> Iterator[bytes]:
+        buffered = b""
+        try:
+            while True:
+                chunk = stdout.channel.recv(64 * 1024)
+                if not chunk:
+                    break
+                buffered += b"".join(chunk.split())
+                keep = len(buffered) % 4
+                ready = buffered[:-keep] if keep else buffered
+                buffered = buffered[-keep:] if keep else b""
+                if ready:
+                    yield base64.b64decode(ready)
+            if buffered:
+                yield base64.b64decode(buffered)
+            exit_code = stdout.channel.recv_exit_status()
+            error_text = stderr.read().decode("utf-8", errors="replace")
+            if exit_code != 0:
+                raise FileTransferError(
+                    f"Remote download command failed with exit code {exit_code}: {error_text}"
+                )
+        except binascii.Error as exc:
+            raise FileTransferError(f"Remote command returned invalid base64: {exc}") from exc
+        finally:
+            stdout.close()
+            stderr.close()
+            client.close()
+
+    return "shell", iterator()
+
+
+def _write_base64_temp_file(
+    client: ShellClient,
+    source: BinaryIO,
+    remote_base64_path: str,
+    cancel_event: threading.Event | None = None,
+    progress: ProgressCallback | None = None,
+    block_size: int = UPLOAD_BLOCK_SIZE,
+) -> int:
+    transferred = 0
+    pending = b""
+
+    while True:
+        if cancel_event and cancel_event.is_set():
+            raise FileTransferCancelled("Upload cancelled by client.")
+        data = source.read(block_size)
+        if not data:
+            break
+
+        data = pending + data
+        encodable_len = len(data) - (len(data) % 3)
+        if encodable_len:
+            raw_chunk = data[:encodable_len]
+            _append_base64_to_remote_file(client, remote_base64_path, base64.b64encode(raw_chunk), block_size)
+            transferred += len(raw_chunk)
+            if progress:
+                progress(transferred)
+        pending = data[encodable_len:]
+
+    if pending:
+        _append_base64_to_remote_file(client, remote_base64_path, base64.b64encode(pending), block_size)
+        transferred += len(pending)
+        if progress:
+            progress(transferred)
+
+    return transferred
+
+
+def _append_base64_to_remote_file(
+    client: ShellClient,
+    remote_base64_path: str,
+    encoded_data: bytes,
+    block_size: int = UPLOAD_BLOCK_SIZE,
+) -> None:
+    quoted_path = shlex.quote(remote_base64_path)
+    command_prefix = "printf %s "
+    command_suffix = f" >> {quoted_path}"
+    max_payload_len = _max_base64_payload_length(command_prefix, command_suffix, block_size)
+    encoded_text = encoded_data.decode("ascii")
+
+    for offset in range(0, len(encoded_text), max_payload_len):
+        payload = encoded_text[offset : offset + max_payload_len]
+        _run_bounded_remote_command(
+            client,
+            f"{command_prefix}{shlex.quote(payload)}{command_suffix}",
+            block_size,
+        )
+
+
+def _max_base64_payload_length(command_prefix: str, command_suffix: str, block_size: int) -> int:
+    overhead = len(command_prefix.encode("utf-8")) + len(command_suffix.encode("utf-8"))
+    available = block_size - overhead
+    if available < 4:
+        raise ValueError("Upload block size is too small for remote command overhead.")
+    return available - (available % 4)
+
+
+def _decode_and_move_command(base64_temp_path: str, data_temp_path: str, remote_path: str) -> str:
+    quoted_base64 = shlex.quote(base64_temp_path)
+    quoted_temp = shlex.quote(data_temp_path)
+    quoted_remote = shlex.quote(remote_path)
+    quoted_error = shlex.quote(f"{data_temp_path}.err")
+    return "\n".join(
+        [
+            "set -e",
+            f"rm -f {quoted_temp} {quoted_error}",
+            f"if command base64 -d < {quoted_base64} > {quoted_temp} 2> {quoted_error}; then",
+            "  :",
+            f"elif command base64 -D < {quoted_base64} > {quoted_temp} 2> {quoted_error}; then",
+            "  :",
+            "else",
+            f"  cat {quoted_error} >&2",
+            "  exit 1",
+            "fi",
+            f"mv -f {quoted_temp} {quoted_remote}",
+            f"rm -f {quoted_base64} {quoted_error}",
+        ]
+    )
+
+
+def _run_bounded_remote_command(client: ShellClient, command: str, block_size: int) -> tuple[bytes, bytes]:
+    command_len = len(command.encode("utf-8"))
+    if command_len > block_size:
+        raise FileTransferError(f"Upload command exceeded block_size={block_size}: {command_len}")
+    return _run_remote_command(client, command)
+
+
+def _run_remote_command(client: ShellClient, command: str) -> tuple[bytes, bytes]:
+    stdin = stdout = stderr = None
+    try:
+        stdin, stdout, stderr = client.exec_command(command)
+        if stdin is not None:
+            stdin.close()
+        output = stdout.read()
+        error = stderr.read()
+        exit_code = stdout.channel.recv_exit_status()
+    except Exception as exc:
+        raise FileTransferError(f"{exc}; command={_short_command(command)}") from exc
+    finally:
+        for stream in (stdin, stdout, stderr):
+            if stream is not None:
+                try:
+                    stream.close()
+                except Exception:
+                    pass
+
+    if exit_code != 0:
+        message = error.decode("utf-8", errors="replace").strip()
+        output_text = output.decode("utf-8", errors="replace").strip()
+        if output_text:
+            message = f"{message}\n{output_text}".strip()
+        raise FileTransferError(
+            message or f"Remote command failed with exit code {exit_code}: {_short_command(command)}"
+        )
+    return output, error
+
+
+def _cleanup_remote_upload(
+    client: ShellClient,
+    base64_temp_path: str,
+    data_temp_path: str,
+    raise_on_failure: bool = False,
+) -> None:
+    command = "rm -f " + " ".join(
+        shlex.quote(path)
+        for path in (
+            base64_temp_path,
+            data_temp_path,
+            f"{data_temp_path}.err",
+        )
+    )
+    try:
+        _run_remote_command(client, command)
+    except Exception:
+        if raise_on_failure:
+            raise
+
+
+def _short_command(command: str, limit: int = 300) -> str:
+    compact = " ".join(command.split())
+    if len(compact) <= limit:
+        return compact
+    return compact[: limit - 3] + "..."
+
+
+def _close_transport(client) -> None:
+    try:
+        transport = client.get_transport()
+        if transport is not None:
+            transport.close()
+    except Exception:
+        pass
+    try:
+        client.close()
+    except Exception:
+        pass
+
+
+def filename_for_download(remote_path: str) -> str:
+    name = posixpath.basename(remote_path.rstrip("/")) or "download.bin"
+    return os.path.basename(name)

{py_web_ssh-0.1.7 → py_web_ssh-0.1.9}/webssh/session.py

@@ -272,6 +272,8 @@ class TerminalSession:
                 self._host_key_lock.wait(timeout=0.2)
         else:
             accepted = False
+            with self._host_key_lock:
+                self._awaiting_host_key_confirmation = False
 
         if accepted:
             self._append_output(b"Y\r\nContinuing SSH authentication...\r\n")

py_web_ssh-0.1.7/webssh/files.py

@@ -1,176 +0,0 @@
-from __future__ import annotations
-
-import base64
-import binascii
-import os
-import posixpath
-import shlex
-import threading
-import uuid
-from collections.abc import Callable, Iterator
-from typing import BinaryIO
-
-from .models import ConnectRequest
-from .ssh_client import HostKeyInfo, connect_ssh
-
-
-class FileTransferError(RuntimeError):
-    pass
-
-
-class FileTransferCancelled(FileTransferError):
-    pass
-
-
-ProgressCallback = Callable[[int], None]
-
-
-def upload_file_via_ssh(
-    config: ConnectRequest,
-    source: BinaryIO,
-    remote_path: str,
-    size: int | None,
-    expected_host_key: HostKeyInfo,
-    cancel_event: threading.Event | None = None,
-    progress: ProgressCallback | None = None,
-) -> tuple[str, int]:
-    """Upload using only an SSH exec channel and POSIX-ish shell commands.
-
-    This intentionally does not use SFTP or SCP. It follows the simple-ssh-copy
-    style: stream base64 into a remote shell, decode into a temporary file, and
-    atomically move the temp file into place after the complete upload succeeds.
-    """
-
-    connected = connect_ssh(
-        config,
-        lambda _level, _message, _details=None: None,
-        expected_host_key=expected_host_key,
-    )
-    client = connected.client
-    remote_dir = posixpath.dirname(remote_path) or "."
-    temp_path = posixpath.join(remote_dir, f".py-web-ssh-upload-{uuid.uuid4().hex}.tmp")
-    command = _upload_command(remote_dir, temp_path, remote_path)
-    stdin = stdout = stderr = None
-    transferred = 0
-    try:
-        stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
-        while True:
-            if cancel_event and cancel_event.is_set():
-                raise FileTransferCancelled("Upload cancelled by client.")
-            chunk = source.read(48 * 1024)
-            if not chunk:
-                break
-            transferred += len(chunk)
-            stdin.write(base64.b64encode(chunk).decode("ascii"))
-            stdin.write("\n")
-            stdin.flush()
-            if progress:
-                progress(transferred)
-
-        if cancel_event and cancel_event.is_set():
-            raise FileTransferCancelled("Upload cancelled by client.")
-
-        stdin.channel.shutdown_write()
-        exit_code = stdout.channel.recv_exit_status()
-        error_text = stderr.read().decode("utf-8", errors="replace")
-    except FileTransferCancelled:
-        _close_transport(client)
-        raise
-    except Exception as exc:
-        _close_transport(client)
-        raise FileTransferError(f"SSH shell upload failed: {exc}") from exc
-    finally:
-        for stream in (stdin, stdout, stderr):
-            if stream is not None:
-                try:
-                    stream.close()
-                except Exception:
-                    pass
-        client.close()
-
-    if exit_code != 0:
-        raise FileTransferError(f"Remote upload command failed with exit code {exit_code}: {error_text}")
-    if size is not None and transferred != size:
-        raise FileTransferError(f"Uploaded {transferred} bytes, expected {size} bytes.")
-    return "shell", transferred
-
-
-def download_file_via_ssh(
-    config: ConnectRequest,
-    remote_path: str,
-    expected_host_key: HostKeyInfo,
-) -> tuple[str, Iterator[bytes]]:
-    connected = connect_ssh(
-        config,
-        lambda _level, _message, _details=None: None,
-        expected_host_key=expected_host_key,
-    )
-    client = connected.client
-    command = f"base64 < {shlex.quote(remote_path)}"
-    stdin, stdout, stderr = client.exec_command(f"sh -c {shlex.quote(command)}")
-    stdin.close()
-
-    def iterator() -> Iterator[bytes]:
-        buffered = b""
-        try:
-            while True:
-                chunk = stdout.channel.recv(64 * 1024)
-                if not chunk:
-                    break
-                buffered += b"".join(chunk.split())
-                keep = len(buffered) % 4
-                ready = buffered[:-keep] if keep else buffered
-                buffered = buffered[-keep:] if keep else b""
-                if ready:
-                    yield base64.b64decode(ready)
-            if buffered:
-                yield base64.b64decode(buffered)
-            exit_code = stdout.channel.recv_exit_status()
-            error_text = stderr.read().decode("utf-8", errors="replace")
-            if exit_code != 0:
-                raise FileTransferError(
-                    f"Remote download command failed with exit code {exit_code}: {error_text}"
-                )
-        except binascii.Error as exc:
-            raise FileTransferError(f"Remote command returned invalid base64: {exc}") from exc
-        finally:
-            stdout.close()
-            stderr.close()
-            client.close()
-
-    return "shell", iterator()
-
-
-def _upload_command(remote_dir: str, temp_path: str, remote_path: str) -> str:
-    quoted_temp = shlex.quote(temp_path)
-    return "\n".join(
-        [
-            "set -e",
-            f"mkdir -p -- {shlex.quote(remote_dir)}",
-            f"tmp={quoted_temp}",
-            "cleanup() { rm -f -- \"$tmp\"; }",
-            "trap cleanup EXIT HUP INT TERM",
-            f"if printf '' | base64 -d >/dev/null 2>&1; then base64 -d > {quoted_temp}; "
-            f"else base64 -D > {quoted_temp}; fi",
-            f"mv -- {quoted_temp} {shlex.quote(remote_path)}",
-            "trap - EXIT",
-        ]
-    )
-
-
-def _close_transport(client) -> None:
-    try:
-        transport = client.get_transport()
-        if transport is not None:
-            transport.close()
-    except Exception:
-        pass
-    try:
-        client.close()
-    except Exception:
-        pass
-
-
-def filename_for_download(remote_path: str) -> str:
-    name = posixpath.basename(remote_path.rstrip("/")) or "download.bin"
-    return os.path.basename(name)