ccssh 1.0.0__py3-none-any.whl

ccssh/shell.py

@@ -0,0 +1,257 @@
+"""
+ Interactive shell over a ShellSession: an `ssh host` experience.
+
+ Single-reader model: a background pump thread owns transport receives and
+ writes server output to stdout/stderr; the main thread forwards stdin.
+ Terminal is put into raw mode (POSIX) so editors, arrows and Ctrl-C behave;
+ SIGWINCH propagates the new size via window-change. The stdin loop polls
+ with select(2) so a server-side close (e.g. remote bash exiting after
+ Ctrl+D) ends the session promptly instead of hanging on a stdin read.
+"""
+from __future__ import annotations
+
+import os
+import select
+import shutil
+import signal
+import sys
+import threading
+
+from ccssh import channel as CH
+from ccssh import wire as W
+from ccssh.transport import CCSSHError
+
+
+def _termsize() -> tuple[int, int]:
+    s = shutil.get_terminal_size()
+    return max(1, s.columns), max(1, s.lines)
+
+
+def _write_all(fd: int, data: bytes) -> None:
+    """Write the full buffer, retrying partial writes (EAGAIN-safe)."""
+    mv = memoryview(data)
+    while mv:
+        n = os.write(fd, mv)
+        if n <= 0:
+            raise OSError("short write to output")
+        mv = mv[n:]
+
+
+def run_interactive(client, sess=None, *, pty: bool = True, command: str | None = None, stdin_fd: int | None = None) -> int:
+    """
+     Run a shell session interactively. Opens one if not given.
+
+     With command set, runs it on a pty channel instead of a shell
+     (`ssh -t host command`). With pty=False no pty is requested
+     (`ssh -T`). stdin_fd overrides standard input (`ssh -n` passes
+     /dev/null). Returns the remote exit status (0 when none is sent).
+     Restores the terminal on all exits.
+    """
+    own = sess is None
+    if own:
+        cols, rows = _termsize()
+        sess = client.open_shell(cols=cols, rows=rows, pty=pty, command=command)
+    if sess is None:
+        raise CCSSHError("no shell session")
+    t = client._t
+    if t is None:
+        raise CCSSHError("connection closed")
+    done = threading.Event()
+    err: list[BaseException] = []
+    # Through the mux when one is active (forwarding shares the
+    # connection); direct transport reads otherwise (test fakes included).
+    _rx = getattr(client, "_rx", None)
+
+    def _recv_one():
+        if callable(_rx):
+            return _rx(sess.chan)
+        return t.recv_packet()
+    if stdin_fd is None:
+        stdin_fd = sys.stdin.fileno() if hasattr(sys.stdin, "fileno") else -1
+    stdin_no = stdin_fd if stdin_fd >= 0 else 0
+    tty_mode = stdin_fd >= 0 and sys.stdin.isatty()
+    old_attrs = None
+
+    def pump() -> None:
+        try:
+            while not done.is_set():
+                try:
+                    p = _recv_one()
+                except Exception as e:
+                    err.append(e)
+                    done.set()
+                    break
+                if not p:
+                    continue
+                m = p[0]
+                try:
+                    rr = W.Reader(p)
+                    rr.byte()
+                    want = getattr(sess, "chan", sess.srv)
+                    if m == CH.MSG_CHANNEL_DATA:
+                        if rr.u32() != want:
+                            continue
+                        chunk = rr.string()
+                        _write_all(1, chunk)
+                        try:
+                            add = getattr(sess, "add_consumed", None)
+                            if callable(add):
+                                add(len(chunk))
+                            else:
+                                sess.consumed += len(chunk)
+                        except AttributeError:
+                            pass
+                        sess.window_adjust()
+                    elif m == CH.MSG_CHANNEL_EXTENDED_DATA:
+                        if rr.u32() != want:
+                            continue
+                        if rr.u32() != 1:
+                            continue
+                        chunk = rr.string()
+                        _write_all(2, chunk)
+                        # stderr consumes the same server window as stdout:
+                        # without crediting it, >2MB on stderr deadlocks.
+                        try:
+                            add = getattr(sess, "add_consumed", None)
+                            if callable(add):
+                                add(len(chunk))
+                            else:
+                                sess.consumed += len(chunk)
+                        except AttributeError:
+                            pass
+                        sess.window_adjust()
+                    elif m == CH.MSG_WINDOW_ADJUST:
+                        if rr.u32() != want:
+                            continue
+                        sess.credit(rr.u32())
+                    elif m == CH.MSG_CHANNEL_REQUEST:
+                        if rr.u32() != want:
+                            continue
+                        name = rr.string()
+                        if name in (b"exit-status", b"exit-signal"):
+                            rr.bool()
+                            if name == b"exit-status":
+                                try:
+                                    sess.exit_status = rr.u32()
+                                except Exception:
+                                    pass
+                            else:
+                                # A signalled remote process: ssh reports 128
+                                # (unknown layouts can't be parsed for a
+                                # FAILURE reply, so anything else is ignored).
+                                sess.exit_status = 128
+                    elif m == CH.MSG_CHANNEL_EOF:
+                        if rr.u32() != want:
+                            continue
+                        sess.eof_received = True
+                    elif m == CH.MSG_CHANNEL_CLOSE:
+                        if rr.u32() != want:
+                            continue
+                        _peer_closed = getattr(sess, "_peer_closed", None)
+                        if callable(_peer_closed):
+                            try:
+                                _peer_closed()
+                            except Exception:
+                                pass
+                        done.set()
+                        break
+                    elif m == 20:  # no rekey with an open channel (see exec)
+                        err.append(RuntimeError("peer started rekey with an open channel"))
+                        done.set()
+                        break
+                    # IGNORE/DEBUG/GLOBAL_REQUEST never reach here (transport).
+                except Exception as e:
+                    err.append(e)
+                    done.set()
+                    break
+        finally:
+            done.set()
+
+    th = threading.Thread(target=pump, daemon=True)
+    if tty_mode:
+        try:
+            import termios
+            import tty as _tty
+            old_attrs = termios.tcgetattr(stdin_fd)
+            _tty.setraw(stdin_fd)
+        except Exception:
+            old_attrs = None
+            tty_mode = False
+
+    def _on_winch(_signo, _frame) -> None:
+        # No pty was allocated (ssh -T): window-change is meaningless.
+        if getattr(sess, "no_pty", False):
+            return
+        try:
+            cols, rows = _termsize()
+            sess.window_change(cols, rows)
+        except Exception:
+            pass
+
+    old_winch = None
+    _sigwinch = getattr(signal, "SIGWINCH", None)  # None on Windows
+    if tty_mode and _sigwinch is not None:
+        try:
+            old_winch = signal.signal(_sigwinch, _on_winch)
+        except Exception:
+            old_winch = None
+    stdin_open = True
+    try:
+        th.start()
+        while not done.is_set():
+            try:
+                ready, _, _ = select.select([stdin_no], [], [], 0.2)
+            except (OSError, ValueError):
+                ready = [stdin_no] # not selectable: blocking read fallback
+            if done.is_set(): # server closed first (e.g. after Ctrl+D)
+                break
+            if not ready:
+                continue
+            try:
+                chunk = os.read(stdin_no, 4096)
+            except (OSError, ValueError):
+                chunk = b""
+            if not chunk:
+                if stdin_open: # stdin EOF -> half-close, keep reading output
+                    stdin_open = False
+                    sess.send_eof()
+                    # Wait for the server to close (bounded: no infinite hang
+                    # if the shell ignores EOF).
+                    import time as _time
+                    _deadline = _time.monotonic() + 10.0
+                    while not done.is_set() and _time.monotonic() < _deadline:
+                        done.wait(0.05)
+                    if not done.is_set():
+                        try:
+                            sess.close()
+                        except Exception:
+                            pass
+                break
+            try:
+                sess.send(chunk)
+            except Exception as e:
+                err.append(e)
+                break
+        done.wait()
+        th.join(timeout=5)
+    except KeyboardInterrupt:
+        pass
+    finally:
+        done.set()
+        sess.close()
+        if old_winch is not None and _sigwinch is not None:
+            try:
+                signal.signal(_sigwinch, old_winch)
+            except Exception:
+                pass
+        if old_attrs is not None:
+            try:
+                import termios
+                termios.tcsetattr(stdin_fd, termios.TCSADRAIN, old_attrs)
+                sys.stdout.write("\n")
+                sys.stdout.flush()
+            except Exception:
+                pass
+    if err and sess.exit_status is None:
+        raise err[0]
+    return sess.exit_status if sess.exit_status is not None else 0

ccssh/sk.py

@@ -0,0 +1,224 @@
+"""
+ FIDO2 security-key user authentication (sk-ssh-ed25519, sk-ecdsa-sha2-nistp256).
+
+ Formats follow OpenSSH PROTOCOL.u2f exactly (fetched 2026-10-11, v1.26):
+
+  pub blob:  string(alg) + key fields + string(application, usually "ssh:")
+  priv half: string(alg) + key fields + string(application)
+             + byte(flags) + string(key_handle) + string(reserved)
+  preimage:  SHA256(application) + byte(flags) + u32(counter)
+             + ext(empty) + SHA256(message)
+  wire sig:  string(alg) + string(sig) + byte(flags) + u32(counter),
+             where ecdsa sig = mpint(r) + mpint(s) (RFC 5656) and ed25519
+             sig is raw 64 B.
+
+ The touch itself cannot happen in software: signing needs a FIDO2 token.
+ SkKey therefore carries an injectable `signer(application, key_handle,
+ message) -> (sig_raw, flags, counter)`; without one, sign_nested raises
+ a clear error instead of failing obscurely server-side. Parsing,
+ verification and userauth assembly are fully testable without hardware.
+"""
+from __future__ import annotations
+
+import base64
+import hashlib
+import os
+
+from cryptography.hazmat.primitives import hashes
+from cryptography.hazmat.primitives.asymmetric import ec
+from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
+from cryptography.hazmat.primitives.asymmetric.utils import encode_dss_signature
+
+from ccssh import wire as W
+
+ALG_ED = "sk-ssh-ed25519@openssh.com"
+ALG_EC = "sk-ecdsa-sha2-nistp256@openssh.com"
+ALGS = (ALG_ED, ALG_EC)
+DEFAULT_APPLICATION = b"ssh:"
+EC_CURVE_SSH = b"nistp256"
+
+
+def preimage(application: bytes, flags: int, counter: int, message: bytes) -> bytes:
+    """
+     The exact bytes a security key signs (PROTOCOL.u2f, no extensions).
+    """
+    if not 0 <= flags <= 255:
+        raise ValueError("flags must be one byte")
+    if not 0 <= counter < 2**32:
+        raise ValueError("counter must fit uint32")
+    return (hashlib.sha256(application).digest()
+            + bytes([flags])
+            + counter.to_bytes(4, "big")
+            + hashlib.sha256(message).digest())
+
+
+class SkKey:
+    """
+     A security key: public parts + key handle + optional signer callback.
+
+     `signer(application, key_handle, message)` returns (sig_raw, flags,
+     counter); hardware builds the preimage itself. Pass None when no
+     token is attached - signing then raises instead of misbehaving.
+    """
+
+    def __init__(self, alg: str, application: bytes = DEFAULT_APPLICATION, flags: int = 0, key_handle: bytes = b"", pub: bytes = b"", curve: bytes = b"", q: bytes = b"", signer=None):
+        if alg not in ALGS:
+            raise ValueError(f"not a sk key type: {alg!r}")
+        if not 0 <= flags <= 255:
+            raise ValueError("flags must be one byte")
+        self.alg = alg
+        self.application = application
+        self.flags = flags
+        self.key_handle = key_handle
+        self.signer = signer
+        if alg == ALG_ED:
+            if len(pub) != 32:
+                raise ValueError("sk ed25519 pub must be 32 bytes")
+            self.pub = pub
+            self.curve, self.q = b"", b""
+        else:
+            if curve != EC_CURVE_SSH or not q:
+                raise ValueError("sk ecdsa needs nistp256 + point")
+            self.pub, self.curve, self.q = b"", curve, q
+
+    def public_blob(self) -> bytes:
+        if self.alg == ALG_ED:
+            return W.enc_string(self.alg.encode()) + W.enc_string(self.pub) + W.enc_string(self.application)
+        return W.enc_string(self.alg.encode()) + W.enc_string(self.curve) + W.enc_string(self.q) + W.enc_string(self.application)
+
+    def public_line(self, comment: str = "") -> str:
+        # OpenSSH .pub format: "alg base64(full_blob_with_alg) [comment]".
+        inner = self.public_blob()
+        suffix = f" {comment}" if comment else ""
+        return f"{self.alg} {base64.b64encode(inner).decode()}{suffix}"
+
+    def sign_nested(self, message: bytes) -> bytes:
+        """
+         Wire signature buffer: string(alg) + string(sig) + byte(flags) +
+         u32(counter). Verifies its own output against the public key so
+         a broken middleware fails here, not as a server rejection.
+        """
+        if self.signer is None:
+            raise ValueError("no security-key signer configured (FIDO2 touch required)")
+        sig_raw, flags, counter = self.signer(self.application, self.key_handle, message)
+        if self.alg == ALG_ED:
+            if len(sig_raw) != 64:
+                raise ValueError("sk ed25519 signature must be 64 bytes")
+        else:
+            r = W.Reader(sig_raw)
+            r.mpint()
+            r.mpint()
+            if r.rest():
+                raise ValueError("sk ecdsa signature must be mpint(r)+mpint(s)")
+        if not 0 <= flags <= 255 or not 0 <= counter < 2**32:
+            raise ValueError("signer returned bad flags/counter")
+        out = (W.enc_string(self.alg.encode()) + W.enc_string(sig_raw)
+               + bytes([flags]) + counter.to_bytes(4, "big"))
+        if not verify_nested(self.public_blob(), message, out):
+            raise ValueError("signer output does not verify")
+        return out
+
+
+def parse_pub_blob(blob: bytes) -> SkKey:
+    r = W.Reader(blob)
+    alg = r.string().decode()
+    if alg == ALG_ED:
+        pub, app = r.string(), r.string()
+        if r.rest():
+            raise ValueError("trailing bytes in sk pub blob")
+        return SkKey(alg, application=app, pub=pub)
+    if alg == ALG_EC:
+        curve, q, app = r.string(), r.string(), r.string()
+        if r.rest():
+            raise ValueError("trailing bytes in sk pub blob")
+        return SkKey(alg, application=app, curve=curve, q=q)
+    raise ValueError(f"not a sk public key: {alg!r}")
+
+
+def parse_private_blob(blob: bytes, *, strict: bool = True) -> SkKey:
+    """
+     Private half: pub fields + application + flags + key_handle + reserved.
+     Cert-form halves are refused: pass the plain key file with --cert.
+     strict=False tolerates the openssh-key-v1 block padding that follows
+     the half inside key files (used by the file loader only).
+    """
+    r = W.Reader(blob)
+    alg = r.string().decode()
+    if alg in ALGS:
+        pub_part = r.string() if alg == ALG_ED else None
+        if alg == ALG_EC:
+            curve, q = r.string(), r.string()
+        else:
+            curve, q = b"", b""
+        app = r.string()
+        flags = r.byte()
+        handle = r.string()
+        r.string()  # reserved
+        if strict and r.rest():
+            raise ValueError("trailing bytes in sk private half")
+        kw = {"pub": pub_part} if alg == ALG_ED else {"curve": curve, "q": q}
+        return SkKey(alg, application=app, flags=flags, key_handle=handle, **kw)
+    raise ValueError(f"not a sk private key: {alg!r}")
+
+
+def verify_nested(pub_blob: bytes, message: bytes, sig_nested: bytes) -> bool:
+    """
+     Verify an sk wire signature. Returns True/False, never raises.
+    """
+    try:
+        r = W.Reader(sig_nested)
+        sig_alg = r.string().decode()
+        sig_raw = r.string()
+        flags = r.byte()
+        counter = r.u32()
+        if r.rest():
+            return False
+        key = parse_pub_blob(pub_blob)
+        if key.alg != sig_alg:
+            return False
+        pre = preimage(key.application, flags, counter, message)
+        if key.alg == ALG_ED:
+            if len(sig_raw) != 64:
+                return False
+            Ed25519PublicKey.from_public_bytes(key.pub).verify(sig_raw, pre)
+            return True
+        rr = W.Reader(sig_raw)
+        der = encode_dss_signature(rr.mpint(), rr.mpint())
+        if rr.rest():
+            return False
+        ec.EllipticCurvePublicKey.from_encoded_point(
+            ec.SECP256R1(), key.q).verify(der, pre, ec.ECDSA(hashes.SHA256()))
+        return True
+    except Exception:
+        return False
+
+
+def load_openssh_private(path: str, passphrase: bytes | None = None) -> SkKey:
+    """
+     Load an sk openssh-key-v1 file (unencrypted only, like the mldsa
+     loader: encrypted keys raise a clear error).
+    """
+    with open(os.path.expanduser(path), "rb") as f:
+        pem = f.read().decode()
+    b64 = "".join(l for l in pem.splitlines() if l and not l.startswith("-----"))
+    try:
+        raw = base64.b64decode(b64, validate=True)
+    except Exception as e:
+        raise ValueError(f"bad sk key file {path}: {e}") from e
+    if not raw.startswith(b"openssh-key-v1\x00"):
+        raise ValueError("not an openssh-key-v1 file")
+    r = W.Reader(raw[15:])
+    if r.string() != b"none":
+        # Encrypted sk keys are unsupported (passphrase or not): callers
+        # passing one unconditionally get the same clear error.
+        raise ValueError("encrypted sk keys are unsupported: decrypt with ssh-keygen first")
+    r.string()
+    r.string()
+    if r.u32() != 1:
+        raise ValueError("expected exactly 1 key")
+    r.string()  # public blob
+    priv = r.string()
+    pr = W.Reader(priv)
+    if pr.u32() != pr.u32():
+        raise ValueError("checkint mismatch (wrong passphrase?)")
+    return parse_private_blob(priv[pr.tell():], strict=False)