ccssh 1.0.0__tar.gz → 1.0.1__tar.gz

{ccssh-1.0.0/ccssh.egg-info → ccssh-1.0.1}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: ccssh
-Version: 1.0.0
-Summary: From-scratch SSH client in Python (sync + async + CLI), OpenSSH-interop verified
+Version: 1.0.1
+Summary: From-scratch SSH client in Python, OpenSSH-interop verified
 Author: MishaKorzhik_He1Zen
 Author-email: developer.mishakorzhik@gmail.com
 License: MIT
@@ -69,6 +69,10 @@ ccssh -N -L 8080:127.0.0.1:80 he1zen@host           # local forwarding only
 ccssh -L 8080:127.0.0.1:80 he1zen@host              # forward + shell (shared connection)
 ccssh -R 8080:127.0.0.1:80 he1zen@host uptime       # forward + one command
 ccssh -N -R 2022:127.0.0.1:22 he1zen@host           # remote forwarding only
+ccssh -N -D 1080 he1zen@host                        # dynamic forward: SOCKS4/5 proxy on 1080
+ccssh -A he1zen@host                                # forward the local ssh-agent
+ccssh -X he1zen@host xterm                          # forward the local X display (untrusted)
+ccssh -Y he1zen@host xterm                          # ... trusted (like ssh -Y)
 ccssh -J jumpuser@jumphost he1zen@target            # ProxyJump (comma chains ok)
 ccssh -q he1zen@host 'echo quiet'                   # quiet: no info output
 ccssh -n he1zen@host < script.sh                    # stdin from /dev/null
@@ -84,7 +88,10 @@ ccssh -o KexAlgorithms=curve25519-sha256 -o Ciphers=aes256-ctr \
       -o UserKnownHostsFile=~/.ssh/known_hosts he1zen@host
 ccssh -c aes256-ctr -m hmac-sha2-512 he1zen@host    # like ssh -c/-m
 ccssh -o HostKeyAlgorithms=+ssh-dss he1zen@oldbox   # append to the default set
-ccssh -Q cipher                                     # list supported ciphers (mac, kex, key too)
+ccssh -C he1zen@host uptime                         # like ssh -C: zlib@openssh.com
+ccssh -o Compression=yes -o CompressionLevel=9 he1zen@host  # levels 1..9, default 6
+ccssh -Q cipher                                     # list supported ciphers (mac, kex, key, compression too)
+ccssh -Q compression                                # none, zlib@openssh.com (like ssh -Q)
 ```
 
 No password or key given on a terminal? ccssh prompts
@@ -114,6 +121,10 @@ c = CCSSHClient(
     ciphers=["aes256-ctr"],            # any subset of algs.SUPPORTED_CIPHERS
     macs=["hmac-sha2-512"],            # any subset of algs.SUPPORTED_MACS
     hostkeys=["ssh-ed25519"],          # any subset of algs.SUPPORTED_HOSTKEYS
+    compression=True,                  # like ssh -C (zlib@openssh.com); False by default
+    compression_level=6,               # 1..9, like CompressionLevel
+    use_agent=True,                    # publickey via $SSH_AUTH_SOCK (RFC 9987)
+    agent_path=None,                   # ... or an explicit agent socket path
     rekey_bytes=4 * 1024**3,           # auto-rekey after this much traffic
     rekey_interval=3600.0,             # ... or this many seconds
 )
@@ -123,13 +134,24 @@ c.connect("host", port=2222, username="user",
           passphrase="key-passphrase",      # for encrypted keys
           cert_filename="~/.ssh/id_ed25519-cert.pub",
           family=0)                         # 0:any, socket.AF_INET (-4), AF_INET6 (-6)
-print(c.negotiated())  # {"cipher": ..., "mac": ..., "strict": ...}
+print(c.negotiated())  # {"kex": ..., "cipher": ..., "mac": ..., "compression": ..., ...}
 c.close()
 ```
 
-Key auth tries each `-i`/`key_filename` in turn, then falls back to the
-password - like OpenSSH. If the password method fails, the same secret
-is tried via keyboard-interactive (RFC 4256, capped rounds/prompts):
+Compression is 1:1 with OpenSSH: `zlib@openssh.com` (delayed, starts after
+auth) with `-C` / `Compression=yes` / `compression=True`, levels 1..9
+(`CompressionLevel`, default 6), `none` by default with the OpenSSH proposal
+`none,zlib@openssh.com`. Legacy `zlib` (immediate, pre-auth) interoperates
+with old servers when named explicitly (`compression=["zlib", "none"]`) but
+is never offered by default - like every other legacy primitive. Rekey keeps
+compression enabled with fresh dictionaries (RFC 4253).
+
+Key auth tries each `-i`/`key_filename` in turn, then agent keys from
+`$SSH_AUTH_SOCK` (RFC 9987: list + sign, private material never leaves the
+agent; disable with `use_agent=False`, `-o IdentityAgent=path/none` or
+`-o IdentitiesOnly=yes`), then falls back to the password - like OpenSSH.
+If the password method fails, the same secret is tried via
+keyboard-interactive (RFC 4256, capped rounds/prompts):
 servers like serveo.net that only offer `keyboard-interactive` work with
 no extra flags. Certificates pass through opaquely from the
 `ssh-ed25519-cert-v01@openssh.com` file (user certs) and are verified
@@ -267,8 +289,31 @@ tun = jump.open_channel_socket("target", 22)  # direct-tcpip, socket-shaped
 c.connect("target", username="user", password="pw", sock=tun)
 ```
 
-`-L` and `-R` cannot share one connection (one forwarder per
-connection); either one shares it with exec/sftp/shell freely.
+`-L`, `-R` and `-D` cannot share one connection (one port forwarder per
+connection); either one shares it with exec/sftp/shell - and with agent
+(`-A`) and X11 (`-X`/`-Y`) forwarding - freely.
+
+## Dynamic forwarding (`-D`), agent (`-A`) and X11 (`-X`/`-Y`)
+
+```python
+dfwd = c.forward_dynamic(1080)  # SOCKS4/4a/5 proxy on 127.0.0.1:1080
+# point a browser at socks5://127.0.0.1:1080; each CONNECT becomes one
+# direct-tcpip channel through the server (TCP only, like ssh -D)
+dfwd.close()
+
+c.forward_agent()  # ssh -A: relay auth-agent@openssh.com to $SSH_AUTH_SOCK
+print(c.exec_command("ssh-add -l", forward_agent=True)[0])  # remote sees local keys
+# refused auth-agent-req (AllowAgentForwarding no) only warns: the session
+# continues without forwarding, like a refused pty
+
+c.forward_x11()  # ssh -X: relay x11 channels to the local $DISPLAY
+print(c.exec_command("echo $DISPLAY", x11=True)[0])  # server-assigned display
+# x11=True is untrusted (-X), x11_trusted=True is -Y; a refused x11-req or a
+# missing local DISPLAY only warns (fake cookie, per-connection refusal)
+```
+
+`-o ForwardAgent=yes/no`, `-o ForwardX11=yes/no`,
+`-o ForwardX11Trusted=yes/no` mirror the flags.
 
 ## Rekey
 
@@ -287,11 +332,12 @@ closed). Rekey also happens automatically per `rekey_bytes` /
 ```python
 from ccssh import algs
 print(algs.coverage())
-# kex 14/16, ciphers 6/10, MACs 6/16 + certs - all live-verified vs OpenSSH
+# kex 14/16, ciphers 6/10, MACs 6/16, compression 2/2 + certs - all live-verified vs OpenSSH
 print(algs.SUPPORTED_KEX)      # incl. "mlkem768x25519-sha256"
 print(algs.SUPPORTED_CIPHERS)  # aes*-ctr, aes*gcm, chacha20-poly1305
 print(algs.SUPPORTED_MACS)     # hmac-sha2-*, hmac-sha1 (+-etm)
 print(algs.SUPPORTED_HOSTKEYS) # incl. "ssh-mldsa44-ed25519"
+print(algs.SUPPORTED_COMPRESSION)  # none, zlib@openssh.com (like ssh -Q)
 ```
 
 The strict top tier (`algs.MAX_KEX`, `MAX_CIPHERS`, `MAX_MACS`,
@@ -301,10 +347,10 @@ still intersects with the server, so it fails closed when the server
 lacks top-tier algorithms instead of silently downgrading.
 
 Legacy algorithms (`algs.LEGACY_KEX`, `LEGACY_CIPHERS`, `LEGACY_MACS`,
-`LEGACY_HOSTKEYS`: CBC ciphers, 3DES, MD5/SHA1-96/UMAC MACs, group1-sha1,
-gex-sha1, ssh-rsa host keys) are implemented and live-tested but never
-offered by default - name them explicitly to interoperate with old
-servers. The server side needs them enabled too:
+`LEGACY_HOSTKEYS`, `LEGACY_COMPRESSION`: CBC ciphers, 3DES, MD5/SHA1-96/UMAC
+MACs, group1-sha1, gex-sha1, ssh-rsa host keys, plain `zlib`) are implemented
+and live-tested but never offered by default - name them explicitly to
+interoperate with old servers. The server side needs them enabled too:
 
 ```bash
 # sshd_config on the old box
@@ -417,7 +463,7 @@ import asyncio
 from ccssh import AsyncCCSSHClient
 
 async def go():
-    c = AsyncCCSSHClient(host_policy="off") # same knobs as sync (no rekey timers yet)
+    c = AsyncCCSSHClient(host_policy="off") # same knobs as sync (incl. compression/compression_level)
     await c.connect("host", username="u", password="pw", family=0)
     out, err, code = await c.exec_command("echo hi")
     await c.rekey()

{ccssh-1.0.0 → ccssh-1.0.1}/README.md

@@ -28,6 +28,10 @@ ccssh -N -L 8080:127.0.0.1:80 he1zen@host           # local forwarding only
 ccssh -L 8080:127.0.0.1:80 he1zen@host              # forward + shell (shared connection)
 ccssh -R 8080:127.0.0.1:80 he1zen@host uptime       # forward + one command
 ccssh -N -R 2022:127.0.0.1:22 he1zen@host           # remote forwarding only
+ccssh -N -D 1080 he1zen@host                        # dynamic forward: SOCKS4/5 proxy on 1080
+ccssh -A he1zen@host                                # forward the local ssh-agent
+ccssh -X he1zen@host xterm                          # forward the local X display (untrusted)
+ccssh -Y he1zen@host xterm                          # ... trusted (like ssh -Y)
 ccssh -J jumpuser@jumphost he1zen@target            # ProxyJump (comma chains ok)
 ccssh -q he1zen@host 'echo quiet'                   # quiet: no info output
 ccssh -n he1zen@host < script.sh                    # stdin from /dev/null
@@ -43,7 +47,10 @@ ccssh -o KexAlgorithms=curve25519-sha256 -o Ciphers=aes256-ctr \
       -o UserKnownHostsFile=~/.ssh/known_hosts he1zen@host
 ccssh -c aes256-ctr -m hmac-sha2-512 he1zen@host    # like ssh -c/-m
 ccssh -o HostKeyAlgorithms=+ssh-dss he1zen@oldbox   # append to the default set
-ccssh -Q cipher                                     # list supported ciphers (mac, kex, key too)
+ccssh -C he1zen@host uptime                         # like ssh -C: zlib@openssh.com
+ccssh -o Compression=yes -o CompressionLevel=9 he1zen@host  # levels 1..9, default 6
+ccssh -Q cipher                                     # list supported ciphers (mac, kex, key, compression too)
+ccssh -Q compression                                # none, zlib@openssh.com (like ssh -Q)
 ```
 
 No password or key given on a terminal? ccssh prompts
@@ -73,6 +80,10 @@ c = CCSSHClient(
     ciphers=["aes256-ctr"],            # any subset of algs.SUPPORTED_CIPHERS
     macs=["hmac-sha2-512"],            # any subset of algs.SUPPORTED_MACS
     hostkeys=["ssh-ed25519"],          # any subset of algs.SUPPORTED_HOSTKEYS
+    compression=True,                  # like ssh -C (zlib@openssh.com); False by default
+    compression_level=6,               # 1..9, like CompressionLevel
+    use_agent=True,                    # publickey via $SSH_AUTH_SOCK (RFC 9987)
+    agent_path=None,                   # ... or an explicit agent socket path
     rekey_bytes=4 * 1024**3,           # auto-rekey after this much traffic
     rekey_interval=3600.0,             # ... or this many seconds
 )
@@ -82,13 +93,24 @@ c.connect("host", port=2222, username="user",
           passphrase="key-passphrase",      # for encrypted keys
           cert_filename="~/.ssh/id_ed25519-cert.pub",
           family=0)                         # 0:any, socket.AF_INET (-4), AF_INET6 (-6)
-print(c.negotiated())  # {"cipher": ..., "mac": ..., "strict": ...}
+print(c.negotiated())  # {"kex": ..., "cipher": ..., "mac": ..., "compression": ..., ...}
 c.close()
 ```
 
-Key auth tries each `-i`/`key_filename` in turn, then falls back to the
-password - like OpenSSH. If the password method fails, the same secret
-is tried via keyboard-interactive (RFC 4256, capped rounds/prompts):
+Compression is 1:1 with OpenSSH: `zlib@openssh.com` (delayed, starts after
+auth) with `-C` / `Compression=yes` / `compression=True`, levels 1..9
+(`CompressionLevel`, default 6), `none` by default with the OpenSSH proposal
+`none,zlib@openssh.com`. Legacy `zlib` (immediate, pre-auth) interoperates
+with old servers when named explicitly (`compression=["zlib", "none"]`) but
+is never offered by default - like every other legacy primitive. Rekey keeps
+compression enabled with fresh dictionaries (RFC 4253).
+
+Key auth tries each `-i`/`key_filename` in turn, then agent keys from
+`$SSH_AUTH_SOCK` (RFC 9987: list + sign, private material never leaves the
+agent; disable with `use_agent=False`, `-o IdentityAgent=path/none` or
+`-o IdentitiesOnly=yes`), then falls back to the password - like OpenSSH.
+If the password method fails, the same secret is tried via
+keyboard-interactive (RFC 4256, capped rounds/prompts):
 servers like serveo.net that only offer `keyboard-interactive` work with
 no extra flags. Certificates pass through opaquely from the
 `ssh-ed25519-cert-v01@openssh.com` file (user certs) and are verified
@@ -226,8 +248,31 @@ tun = jump.open_channel_socket("target", 22)  # direct-tcpip, socket-shaped
 c.connect("target", username="user", password="pw", sock=tun)
 ```
 
-`-L` and `-R` cannot share one connection (one forwarder per
-connection); either one shares it with exec/sftp/shell freely.
+`-L`, `-R` and `-D` cannot share one connection (one port forwarder per
+connection); either one shares it with exec/sftp/shell - and with agent
+(`-A`) and X11 (`-X`/`-Y`) forwarding - freely.
+
+## Dynamic forwarding (`-D`), agent (`-A`) and X11 (`-X`/`-Y`)
+
+```python
+dfwd = c.forward_dynamic(1080)  # SOCKS4/4a/5 proxy on 127.0.0.1:1080
+# point a browser at socks5://127.0.0.1:1080; each CONNECT becomes one
+# direct-tcpip channel through the server (TCP only, like ssh -D)
+dfwd.close()
+
+c.forward_agent()  # ssh -A: relay auth-agent@openssh.com to $SSH_AUTH_SOCK
+print(c.exec_command("ssh-add -l", forward_agent=True)[0])  # remote sees local keys
+# refused auth-agent-req (AllowAgentForwarding no) only warns: the session
+# continues without forwarding, like a refused pty
+
+c.forward_x11()  # ssh -X: relay x11 channels to the local $DISPLAY
+print(c.exec_command("echo $DISPLAY", x11=True)[0])  # server-assigned display
+# x11=True is untrusted (-X), x11_trusted=True is -Y; a refused x11-req or a
+# missing local DISPLAY only warns (fake cookie, per-connection refusal)
+```
+
+`-o ForwardAgent=yes/no`, `-o ForwardX11=yes/no`,
+`-o ForwardX11Trusted=yes/no` mirror the flags.
 
 ## Rekey
 
@@ -246,11 +291,12 @@ closed). Rekey also happens automatically per `rekey_bytes` /
 ```python
 from ccssh import algs
 print(algs.coverage())
-# kex 14/16, ciphers 6/10, MACs 6/16 + certs - all live-verified vs OpenSSH
+# kex 14/16, ciphers 6/10, MACs 6/16, compression 2/2 + certs - all live-verified vs OpenSSH
 print(algs.SUPPORTED_KEX)      # incl. "mlkem768x25519-sha256"
 print(algs.SUPPORTED_CIPHERS)  # aes*-ctr, aes*gcm, chacha20-poly1305
 print(algs.SUPPORTED_MACS)     # hmac-sha2-*, hmac-sha1 (+-etm)
 print(algs.SUPPORTED_HOSTKEYS) # incl. "ssh-mldsa44-ed25519"
+print(algs.SUPPORTED_COMPRESSION)  # none, zlib@openssh.com (like ssh -Q)
 ```
 
 The strict top tier (`algs.MAX_KEX`, `MAX_CIPHERS`, `MAX_MACS`,
@@ -260,10 +306,10 @@ still intersects with the server, so it fails closed when the server
 lacks top-tier algorithms instead of silently downgrading.
 
 Legacy algorithms (`algs.LEGACY_KEX`, `LEGACY_CIPHERS`, `LEGACY_MACS`,
-`LEGACY_HOSTKEYS`: CBC ciphers, 3DES, MD5/SHA1-96/UMAC MACs, group1-sha1,
-gex-sha1, ssh-rsa host keys) are implemented and live-tested but never
-offered by default - name them explicitly to interoperate with old
-servers. The server side needs them enabled too:
+`LEGACY_HOSTKEYS`, `LEGACY_COMPRESSION`: CBC ciphers, 3DES, MD5/SHA1-96/UMAC
+MACs, group1-sha1, gex-sha1, ssh-rsa host keys, plain `zlib`) are implemented
+and live-tested but never offered by default - name them explicitly to
+interoperate with old servers. The server side needs them enabled too:
 
 ```bash
 # sshd_config on the old box
@@ -376,7 +422,7 @@ import asyncio
 from ccssh import AsyncCCSSHClient
 
 async def go():
-    c = AsyncCCSSHClient(host_policy="off") # same knobs as sync (no rekey timers yet)
+    c = AsyncCCSSHClient(host_policy="off") # same knobs as sync (incl. compression/compression_level)
     await c.connect("host", username="u", password="pw", family=0)
     out, err, code = await c.exec_command("echo hi")
     await c.rekey()

{ccssh-1.0.0 → ccssh-1.0.1}/ccssh/__init__.py

@@ -18,4 +18,4 @@ except ImportError as _e:
     raise
 
 __all__ = ["CCSSHClient", "AsyncCCSSHClient", "AuthError", "HostKeyError", "CCSSHError", "CCSSHTimeoutError", "ShellSession"]
-__version__ = "1.0.0"
+__version__ = "1.0.1"

ccssh-1.0.1/ccssh/agent.py

@@ -0,0 +1,223 @@
+"""
+ SSH agent (RFC 9987 core + OpenSSH PROTOCOL.agent): local key use and
+ agent forwarding (`ssh -A`).
+
+ Two halves:
+
+ * :class:`AgentClient` talks to a local ``ssh-agent`` over its Unix-domain
+   socket (``$SSH_AUTH_SOCK`` by default): list public identities and ask
+   the agent to sign userauth blobs. Private key material never leaves the
+   agent process.
+ * Forwarding: after ``auth-agent-req@openssh.com`` on a session channel,
+   the server opens ``auth-agent@openssh.com`` channels back; each one is
+   relayed byte-for-byte to the local agent socket (see
+   ``ccssh.forward.AgentForwarder``).
+
+ Wire framing on the agent socket is ``uint32 length + payload`` (NOT SSH
+ binary packets). Message numbers (stable since the original ssh.com agent,
+ now RFC 9987):
+
+ * 11 request-identities, 12 identities-answer
+ * 13 sign-request, 14 sign-response
+ * 5 failure, 6 success
+ * sign flags: 2 = RSA-SHA2-256, 4 = RSA-SHA2-512 (0 otherwise)
+"""
+from __future__ import annotations
+
+import os
+import socket
+import struct
+
+from ccssh import wire as W
+
+REQ_IDENTITIES = 11
+IDENTITIES_ANSWER = 12
+SIGN_REQUEST = 13
+SIGN_RESPONSE = 14
+AGENT_FAILURE = 5
+AGENT_SUCCESS = 6
+
+FLAG_RSA_SHA2_256 = 2
+FLAG_RSA_SHA2_512 = 4
+
+MAX_AGENT_MSG = 256 * 1024  # one agent message must never OOM us
+MAX_IDENTITIES = 256  # a rogue agent listing thousands of keys fails closed
+MAX_BLOB = 16384  # same bound as userauth probes (see auth.py)
+
+
+class AgentError(Exception):
+    pass
+
+
+def sign_flags_for_alg(alg: str) -> int:
+    """Agent sign-request flags for a userauth algorithm name."""
+    if alg == "rsa-sha2-256":
+        return FLAG_RSA_SHA2_256
+    if alg == "rsa-sha2-512":
+        return FLAG_RSA_SHA2_512
+    return 0
+
+
+def default_agent_path() -> str | None:
+    """$SSH_AUTH_SOCK when set and non-empty, else None."""
+    p = os.environ.get("SSH_AUTH_SOCK")
+    if p and p.strip():
+        return p
+    return None
+
+
+class AgentClient:
+    """
+     One-shot-per-call client for a local agent socket.
+
+     A fresh Unix connection is opened per call (like OpenSSH's
+     ssh_get_agent_identities: short-lived, no shared state), so concurrent
+     auth attempts never interleave agent framing.
+    """
+
+    def __init__(self, path: str | None = None, *, timeout: float = 10.0):
+        resolved = path if path is not None else default_agent_path()
+        if not resolved:
+            raise AgentError("no agent socket (set SSH_AUTH_SOCK or pass agent_path)")
+        self.path = resolved
+        self.timeout = timeout
+
+    def _transact(self, payload: bytes) -> bytes:
+        if len(payload) > MAX_AGENT_MSG:
+            raise AgentError("agent request too big")
+        try:
+            s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        except OSError as e:
+            raise AgentError(f"cannot create agent socket: {e}") from e
+        try:
+            s.settimeout(self.timeout)
+            try:
+                s.connect(self.path)
+            except OSError as e:
+                raise AgentError(f"cannot connect to agent {self.path}: {e}") from e
+            try:
+                s.sendall(struct.pack(">I", len(payload)) + payload)
+                hdr = _recvn(s, 4)
+                (ln,) = struct.unpack(">I", hdr)
+                if ln == 0 or ln > MAX_AGENT_MSG:
+                    raise AgentError(f"bad agent reply length {ln}")
+                body = _recvn(s, ln)
+            except (OSError, AgentError):
+                raise
+            except Exception as e:
+                raise AgentError(f"agent I/O failed: {e}") from e
+        finally:
+            try:
+                s.close()
+            except Exception:
+                pass
+        if not body:
+            raise AgentError("empty agent reply")
+        return body
+
+    def list_identities(self) -> list[tuple[bytes, str]]:
+        """
+         Returns [(public_blob, comment)]. Fails closed on any malformed
+         data (a hostile $SSH_AUTH_SOCK must never inject keys silently).
+        """
+        body = self._transact(bytes([REQ_IDENTITIES]))
+        r = W.Reader(body)
+        try:
+            m = r.byte()
+        except W.WireError as e:
+            raise AgentError(f"bad agent reply: {e}") from e
+        if m == AGENT_FAILURE:
+            raise AgentError("agent refused identities request")
+        if m != IDENTITIES_ANSWER:
+            raise AgentError(f"agent sent unexpected message {m}")
+        try:
+            n = r.u32()
+        except W.WireError as e:
+            raise AgentError(f"bad agent identities: {e}") from e
+        if n > MAX_IDENTITIES:
+            raise AgentError(f"agent listed too many identities ({n})")
+        out: list[tuple[bytes, str]] = []
+        try:
+            for _ in range(n):
+                blob = r.string()
+                comment = r.string().decode("utf-8", errors="replace")
+                if not blob or len(blob) > MAX_BLOB:
+                    raise AgentError("bad agent key blob length")
+                out.append((blob, comment))
+            r.assert_end()
+        except W.WireError as e:
+            raise AgentError(f"bad agent identities: {e}") from e
+        return out
+
+    def sign(self, key_blob: bytes, data: bytes, flags: int = 0) -> bytes:
+        """
+         Ask the agent to sign ``data`` with the key matching ``key_blob``.
+
+         Returns the nested userauth signature (``string(alg) +
+         string(sig)``), ready for ``auth.enc_pubkey_signed``. Raises
+         AgentError when the agent refuses, the key is unknown, or the
+         reply is malformed.
+        """
+        if not key_blob or len(key_blob) > MAX_BLOB:
+            raise AgentError("bad agent key blob")
+        if len(data) > 65536:
+            raise AgentError("agent sign data too big")
+        req = (bytes([SIGN_REQUEST]) + W.enc_string(key_blob)
+               + W.enc_string(data) + W.enc_u32(flags))
+        body = self._transact(req)
+        r = W.Reader(body)
+        try:
+            m = r.byte()
+        except W.WireError as e:
+            raise AgentError(f"bad agent reply: {e}") from e
+        if m == AGENT_FAILURE:
+            raise AgentError("agent refused to sign (key unknown or locked?)")
+        if m != SIGN_RESPONSE:
+            raise AgentError(f"agent sent unexpected message {m}")
+        try:
+            sig = r.string()
+            r.assert_end()
+        except W.WireError as e:
+            raise AgentError(f"bad agent signature: {e}") from e
+        if not sig:
+            raise AgentError("agent returned empty signature")
+        return sig
+
+
+def _recvn(s: socket.socket, n: int) -> bytes:
+    out = b""
+    while len(out) < n:
+        try:
+            chunk = s.recv(n - len(out))
+        except socket.timeout as e:
+            raise AgentError(f"agent read timeout: {e}") from e
+        if not chunk:
+            raise AgentError("agent closed the connection")
+        out += chunk
+        if len(out) > MAX_AGENT_MSG + 4:
+            raise AgentError("agent reply too big")
+    return out
+
+
+def dec_agent_open(payload: bytes) -> int:
+    """
+     Parse an inbound ``auth-agent@openssh.com`` CHANNEL_OPEN.
+
+     The type carries no extra fields (just sender/window/maxpacket);
+     returns the sender id. Raises AgentError on malformed data.
+    """
+    from ccssh import channel as CH
+    r = W.Reader(payload)
+    try:
+        if r.byte() != CH.MSG_CHANNEL_OPEN:
+            raise AgentError("not a CHANNEL_OPEN")
+        ctype = r.string()
+        if ctype != b"auth-agent@openssh.com":
+            raise AgentError(f"not an agent open (got {ctype!r})")
+        sender = r.u32()
+        r.u32()
+        r.u32()
+        r.assert_end()
+    except W.WireError as e:
+        raise AgentError(f"bad agent open: {e}") from e
+    return sender

{ccssh-1.0.0 → ccssh-1.0.1}/ccssh/algs.py

@@ -1,10 +1,10 @@
 """
  Algorithm registry: what ccssh supports vs OpenSSH (from local `ssh -Q`).
 
-  Honest numbers only: an algorithm counts as supported after loopback AND
-  live-interop tests against a real sshd go green. Weak primitives live in
-  LEGACY (implemented, never offered unless named explicitly).
-  (FIDO2 login additionally needs a
+ Honest numbers only: an algorithm counts as supported after loopback AND
+ live-interop tests against a real sshd go green. Weak primitives live in
+ LEGACY (implemented, never offered unless named explicitly).
+ (FIDO2 login additionally needs a
  hardware token at runtime - see ccssh.sk; all of its software side is
  implemented and tested.)
 """
@@ -81,6 +81,16 @@ OPENSSH_KEYS = [
     "ssh-rsa",
     "ssh-rsa-cert-v01@openssh.com",
 ]
+# Compression methods (RFC 4253 section 6.2 + delayed draft).
+# `ssh -Q compression` on OpenSSH 10.6 reports only these two: plain `zlib`
+# (immediate, post-NEWKEYS) was dropped server-side and lives in LEGACY for
+# old boxes only. Default proposal is "none,zlib@openssh.com" (no compression
+# unless requested, exactly like OpenSSH); -C / Compression=yes swaps it to
+# "zlib@openssh.com,none".
+OPENSSH_COMPRESSION = [
+    "none",
+    "zlib@openssh.com",
+]
 
 """
  Actually implemented and covered by loopback + live tests.
@@ -133,6 +143,18 @@ SUPPORTED_HOSTKEYS = [
 ]
 # Certificate host keys carry full CA verification (see certs.py), not opaque trust.
 
+# Compression: modern OpenSSH offers "none,zlib@openssh.com" by default
+# (disabled) and "zlib@openssh.com,none" with -C/Compression=yes. Plain
+# "zlib" (immediate, pre-auth) is legacy: implemented for old servers,
+# never offered unless named explicitly.
+SUPPORTED_COMPRESSION = [
+    "none",
+    "zlib@openssh.com",
+]
+LEGACY_COMPRESSION = [
+    "zlib",
+]
+
 LEGACY_KEX = [
     "diffie-hellman-group-exchange-sha1",
     "diffie-hellman-group1-sha1"
@@ -281,10 +303,55 @@ def default_kex() -> list[str]:
     return [k for k in SUPPORTED_KEX if "sntrup761" not in k]
 
 
+def default_compression(enabled: bool = False) -> list[str]:
+    """
+     Default compression offer, exactly like OpenSSH (see myproposal.h).
+
+     Disabled (default): ["none", "zlib@openssh.com"] - negotiates to
+     "none" with any modern server (client preference wins). Enabled
+     (-C / Compression=yes): ["zlib@openssh.com", "none"] - negotiates
+     to delayed compression. Plain "zlib" is legacy and never included
+     unless named explicitly (see LEGACY_COMPRESSION).
+    """
+    if enabled:
+        return ["zlib@openssh.com", "none"]
+    return ["none", "zlib@openssh.com"]
+
+
+def normalize_compression(value: bool | str | list[str] | None) -> list[str] | None:
+    """
+     Resolve a compression option to an explicit offer list.
+
+     True -> enabled offer, False -> disabled offer (OpenSSH defaults),
+     None -> pass through (caller falls back), str -> single name or
+     comma list, list -> via normalize_list against the full capability
+     set (SUPPORTED + LEGACY, so "+zlib" works for old servers).
+    """
+    if value is None:
+        return None
+    if isinstance(value, bool):
+        return default_compression(value)
+    if isinstance(value, str):
+        s = value.strip()
+        if not s:
+            raise ValueError("empty compression option")
+        if "," in s:
+            vals = [v.strip() for v in s.split(",")]
+        else:
+            vals = [s]
+        return normalize_list(SUPPORTED_COMPRESSION + LEGACY_COMPRESSION, vals) or []
+    base = SUPPORTED_COMPRESSION + LEGACY_COMPRESSION
+    out = normalize_list(base, list(value))
+    if not out:
+        raise ValueError("compression list is empty")
+    return out
+
+
 def coverage() -> dict[str, str]:
     return {
         "kex": f"{len(SUPPORTED_KEX)}/{len(OPENSSH_KEX)} live (sntrup761 needs liboqs)",
         "cipher": f"{len(SUPPORTED_CIPHERS)}/{len(OPENSSH_CIPHERS)} live",
         "mac": f"{len(SUPPORTED_MACS)}/{len(OPENSSH_MACS)} live (+AEAD implicit)",
         "hostkey": f"{len(SUPPORTED_HOSTKEYS)}/{len(OPENSSH_KEYS)} live (certs with CA verify)",
+        "compression": f"{len(SUPPORTED_COMPRESSION)}/{len(OPENSSH_COMPRESSION)} live (+legacy zlib)",
     }